Module:Hatnote inline: Difference between revisions

    From Nonbinary Wiki
    m>SMcCandlish
    (CSS class update (the selfref one is actually selfreference, and it should also use noprint))
    m (14 revisions imported from templatewiki:Module:Hatnote_inline)
     
    (2 intermediate revisions by 2 users not shown)
    Line 7: Line 7:
    --------------------------------------------------------------------------------
    --------------------------------------------------------------------------------


    local libraryUtil = require('libraryUtil')
    local mHatnote = require('Module:Hatnote')
    local checkType = libraryUtil.checkType
    local mArguments = require('Module:Arguments')
    local mArguments -- lazily initialise [[Module:Arguments]]
    local yesno = require('Module:Yesno')
    local yesno -- lazily initialise [[Module:Yesno]]
     
    local p = {}
    local p = {}


    --------------------------------------------------------------------------------
    function p.hatnoteInline (frame)
    -- Helper functions
    local args = mArguments.getArgs(frame)
    --------------------------------------------------------------------------------
    local hatnote = mHatnote.hatnote(frame)
     
    if args.inline == nil or yesno(args.inline, true) then
    local function getArgs(frame)
    local subs = {
    -- Fetches the arguments from the parent frame. Whitespace is trimmed and
    ['^<div'] = '<span',
    -- blanks are removed.
    ['</div>$'] = '</span>'
    mArguments = require('Module:Arguments')
    }
    return mArguments.getArgs(frame, {parentOnly = true})
    for k, v in pairs(subs) do hatnote = string.gsub(hatnote, k, v) end
    end
     
    local function removeInitialColon(s)
    -- Removes the initial colon from a string, if present.
    return s:match('^:?(.*)')
    end
     
    function p.findNamespaceId(link, removeColon)
    -- Finds the namespace id (namespace number) of a link or a pagename. This
    -- function will not work if the link is enclosed in double brackets. Colons
    -- are trimmed from the start of the link by default. To skip colon
    -- trimming, set the removeColon parameter to true.
    checkType('findNamespaceId', 1, link, 'string')
    checkType('findNamespaceId', 2, removeColon, 'boolean', true)
    if removeColon ~= false then
    link = removeInitialColon(link)
    end
    end
    local namespace = link:match('^(.-):')
    return hatnote
    if namespace then
    local nsTable = mw.site.namespaces[namespace]
    if nsTable then
    return nsTable.id
    end
    end
    return 0
    end
    end


    function p.formatPages(...)
    p.hatnote = p.hatnoteInline --alias
    -- Formats a list of pages using formatLink and returns it as an array. Nil
    -- values are not allowed.
    local pages = {...}
    local ret = {}
    for i, page in ipairs(pages) do
    ret[i] = p._formatLink(page)
    end
    return ret
    end
     
    function p.formatPageTables(...)
    -- Takes a list of page/display tables and returns it as a list of
    -- formatted links. Nil values are not allowed.
    local pages = {...}
    local links = {}
    for i, t in ipairs(pages) do
    checkType('formatPageTables', i, t, 'table')
    local link = t[1]
    local display = t[2]
    links[i] = p._formatLink(link, display)
    end
    return links
    end
     
    function p.makeWikitextError(msg, helpLink, addTrackingCategory)
    -- Formats an error message to be returned to wikitext. If
    -- addTrackingCategory is not false after being returned from
    -- [[Module:Yesno]], and if we are not on a talk page, a tracking category
    -- is added.
    checkType('makeWikitextError', 1, msg, 'string')
    checkType('makeWikitextError', 2, helpLink, 'string', true)
    yesno = require('Module:Yesno')
    local title = mw.title.getCurrentTitle()
    -- Make the help link text.
    local helpText
    if helpLink then
    helpText = ' ([[' .. helpLink .. '|help]])'
    else
    helpText = ''
    end
    -- Make the category text.
    local category
    if not title.isTalkPage and yesno(addTrackingCategory) ~= false then
    category = 'Hatnote templates with errors'
    category = string.format(
    '[[%s:%s]]',
    mw.site.namespaces[14].name,
    category
    )
    else
    category = ''
    end
    return string.format(
    '<strong class="error">Error: %s%s.</strong>%s',
    msg,
    helpText,
    category
    )
    end
     
    --------------------------------------------------------------------------------
    -- Format link
    --
    -- Makes a wikilink from the given link and display values. Links are escaped
    -- with colons if necessary, and links to sections are detected and displayed
    -- with " § " as a separator rather than the standard MediaWiki "#". Used in
    -- the {{format hatnote link}} template.
    --------------------------------------------------------------------------------
     
    function p.formatLink(frame)
    local args = getArgs(frame)
    local link = args[1]
    local display = args[2]
    if not link then
    return p.makeWikitextError(
    'no link specified',
    'Template:Format hatnote link#Errors',
    args.category
    )
    end
    return p._formatLink(link, display)
    end
     
    function p._formatLink(link, display)
    -- Find whether we need to use the colon trick or not. We need to use the
    -- colon trick for categories and files, as otherwise category links
    -- categorise the page and file links display the file.
    checkType('_formatLink', 1, link, 'string')
    checkType('_formatLink', 2, display, 'string', true)
    link = removeInitialColon(link)
    local namespace = p.findNamespaceId(link, false)
    local colon
    if namespace == 6 or namespace == 14 then
    colon = ':'
    else
    colon = ''
    end
     
    -- Find whether a faux display value has been added with the {{!}} magic
    -- word.
    if not display then
    local prePipe, postPipe = link:match('^(.-)|(.*)$')
    link = prePipe or link
    display = postPipe
    end
     
    -- Find the display value.
    if not display then
    local page, section = link:match('^(.-)#(.*)$')
    if page then
    display = page .. ' § ' .. section
    end
    end
     
    -- Assemble the link.
    if display then
    return string.format('[[%s%s|%s]]', colon, link, display)
    else
    return string.format('[[%s%s]]', colon, link)
    end
    end
     
    --------------------------------------------------------------------------------
    -- Hatnote
    --
    -- Produces standard hatnote text. Implements the {{hatnote}} template.
    --------------------------------------------------------------------------------
     
    function p.hatnote(frame)
    local args = getArgs(frame)
    local s = args[1]
    local options = {}
    if not s then
    return p.makeWikitextError(
    'no text specified',
    'Template:Hatnote#Errors',
    args.category
    )
    end
    options.extraclasses = args.extraclasses
    options.selfref = args.selfref
    options.inline = args.inline
    return p._hatnote(s, options)
    end
     
    function p._hatnote(s, options)
    checkType('_hatnote', 1, s, 'string')
    checkType('_hatnote', 2, options, 'table', true)
    local classes = {'hatnote'}
    local extraclasses = options.extraclasses
    local selfref = options.selfref
    if type(extraclasses) == 'string' then
    classes[#classes + 1] = extraclasses
    end
    if selfref then
    classes[#classes + 1] = 'selfreference noprint'
    end
    local tag = options.inline and 'span' or 'div'
    return string.format(
    '<%s class="%s">%s</%s>',
    tag,
    table.concat(classes, ' '),
    s,
    tag
    )
    end


    return p
    return p

    Latest revision as of 09:59, 16 November 2019

    Documentation for this module may be created at Module:Hatnote inline/doc 

    --------------------------------------------------------------------------------
--                              Module:Hatnote-inline                         --
--                                                                            --
-- This module produces hatnote-style links and links to related articles,    --
-- but inside a <span>, instead of the <div> used by Module:Hatnote.  It      --
-- implements the {{hatnote-inline}} meta-template.                           --
--------------------------------------------------------------------------------

local mHatnote = require('Module:Hatnote')
local mArguments = require('Module:Arguments')
local yesno = require('Module:Yesno')
local p = {}

function p.hatnoteInline (frame)
	local args = mArguments.getArgs(frame)
	local hatnote = mHatnote.hatnote(frame)
	if args.inline == nil or yesno(args.inline, true) then
		local subs = {
			['^<div'] = '<span',
			['</div>$'] = '</span>'
		}
		for k, v in pairs(subs) do hatnote = string.gsub(hatnote, k, v) end
	end
	return hatnote
end

p.hatnote = p.hatnoteInline --alias

return p
    Retrieved from "https://nonbinary.wiki/index.php?title=Module:Hatnote_inline&oldid=20299"