Editing Module:Hatnote

Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. Read the Privacy Policy to learn what information we collect about you and how we use it.

If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.

Latest revision Your text
Line 3: Line 3:
--                                                                            --
--                                                                            --
-- This module produces hatnote links and links to related articles. It      --
-- This module produces hatnote links and links to related articles. It      --
-- implements the {{hatnote}} and {{format link}} meta-templates and includes --
-- implements the {{rellink}} and {{hatnote}} meta-templates, and a few of    --
-- helper functions for other Lua hatnote modules.                           --
-- the more popular templates they depend on, including {{main}},            --
-- {{see also}}, {{further}} and {{details}}.                                 --
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


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


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Helper functions
-- Argument processing
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


local function getArgs(frame)
--[[
-- Fetches the arguments from the parent frame. Whitespace is trimmed and
-- The p table is for functions to be returned from #invoke, and for functions
-- blanks are removed.
-- to be used from other Lua modules. The f table is for functions acting as a
mArguments = require('Module:Arguments')
-- bridge between #invoke functions and Lua module functions. #invoke functions
return mArguments.getArgs(frame, {parentOnly = true})
-- are connected to f table functions through the makeInvokeFunction function.
-- Functions for use from other Lua modules have names beginning with an
-- underscore.
--]]
local p, f = {}, {}
 
local function makeInvokeFunction(func)
return function(frame)
local args = mArguments.getArgs(frame, {parentOnly = true})
return func(args)
end
end
end


local function removeInitialColon(s)
--------------------------------------------------------------------------------
-- Removes the initial colon from a string, if present.
-- Helper functions
return s:match('^:?(.*)')
--------------------------------------------------------------------------------
end


function p.findNamespaceId(link, removeColon)
local function findNamespaceId(link)
-- Finds the namespace id (namespace number) of a link or a pagename. This
-- 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
-- function will not work if the link is enclosed in double brackets or if
-- are trimmed from the start of the link by default. To skip colon
-- the link has been escaped with the colon trick.
-- trimming, set the removeColon parameter to false.
checkType('findNamespaceId', 1, link, 'string')
checkType('findNamespaceId', 2, removeColon, 'boolean', true)
if removeColon ~= false then
link = removeInitialColon(link)
end
local namespace = link:match('^(.-):')
local namespace = link:match('^(.-):')
if namespace then
if namespace then
Line 50: Line 50:
end
end


function p.formatPages(...)
local function formatLink(link, display)
-- 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 "#".
 
-- 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.
link = link:match('^:?(.*)') -- Remove initial colon if specified.
local namespace = findNamespaceId(link)
local colon
if namespace == 6 or namespace == 14 then
colon = ':'
else
colon = ''
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
 
local function formatPages(...)
-- Formats a list of pages using formatLink and returns it as an array. Nil
-- Formats a list of pages using formatLink and returns it as an array. Nil
-- values are not allowed.
-- values are not allowed.
Line 56: Line 90:
local ret = {}
local ret = {}
for i, page in ipairs(pages) do
for i, page in ipairs(pages) do
ret[i] = p._formatLink(page)
ret[i] = formatLink(page)
end
end
return ret
return ret
end
end


function p.formatPageTables(...)
local function formatPageTables(pages)
-- Takes a list of page/display tables and returns it as a list of
-- Takes a list of page/display tables and returns it as a list of
-- formatted links. Nil values are not allowed.
-- formatted links. Nil values are not allowed.
local pages = {...}
local links = {}
local links = {}
for i, t in ipairs(pages) do
for i, t in ipairs(pages) do
checkType('formatPageTables', i, t, 'table')
local link = t[1]
local link = t[1]
local display = t[2]
local display = t[2]
links[i] = p._formatLink(link, display)
links[i] = formatLink(link, display)
end
end
return links
return links
end
end


function p.makeWikitextError(msg, helpLink, addTrackingCategory, title)
local function makeWikitextError(msg)
-- Formats an error message to be returned to wikitext. If
-- Formats an error message to be returned to wikitext.
-- addTrackingCategory is not false after being returned from
return string.format('<strong class="error">Error: %s.</strong>', msg)
-- [[Module:Yesno]], and if we are not on a talk page, a tracking category
end
-- is added.
 
checkType('makeWikitextError', 1, msg, 'string')
--------------------------------------------------------------------------------
checkType('makeWikitextError', 2, helpLink, 'string', true)
-- Hatnote
yesno = require('Module:Yesno')
--
title = title or mw.title.getCurrentTitle()
-- Produces standard hatnote text. Implements the {{hatnote}} template.
-- Make the help link text.
--------------------------------------------------------------------------------
local helpText
 
if helpLink then
function p._hatnote(s)
helpText = ' ([[' .. helpLink .. '|help]])'
return string.format('<div class="dablink">%s</div>', s)
end
 
function f.hatnote(args)
local s = args[1]
if not s then
return makeWikitextError('no text specified')
end
return p._hatnote(s)
end
 
p.hatnote = makeInvokeFunction(f.hatnote)
 
--------------------------------------------------------------------------------
-- Rellink
--
-- Produces a standard link to a related article. Implements the {{rellink}}
-- template.
--------------------------------------------------------------------------------
 
function p._rellink(s, extraclasses)
if extraclasses then
extraclasses = ' ' .. extraclasses
else
else
helpText = ''
extraclasses = ''
end
end
-- Make the category text.
return string.format('<div class="rellink%s">%s</div>', extraclasses, s)
local category
end
if not title.isTalkPage and yesno(addTrackingCategory) ~= false then
 
category = 'Hatnote templates with errors'
function f.rellink(args)
category = string.format(
local s = args[1]
'[[%s:%s]]',
local extraclasses = args.extraclasses
mw.site.namespaces[14].name,
if not s then
category
return makeWikitextError('no text specified')
)
else
category = ''
end
end
return string.format(
return p._rellink(s, extraclasses)
'<strong class="error">Error: %s%s.</strong>%s',
end
msg,
 
helpText,
p.rellink = makeInvokeFunction(f.rellink)
category
 
)
--------------------------------------------------------------------------------
-- Details
--
-- Produces a "For more details on this topic" link. the first parameter is the
-- page linked to, and if the second parameter is present it is used instead
-- of the "this topic" text.
--------------------------------------------------------------------------------
 
function p._details(page, topic)
page = formatLink(page)
topic = topic or 'this topic'
local text = string.format('For more details on %s, see %s.', topic, page)
local extraclasses = 'boilerplate seealso'
return p._rellink(text, extraclasses)
end
end


function p.disambiguate(page, disambiguator)
function f.details(args)
-- Formats a page title with a disambiguation parenthetical,
local page = args[1]
-- i.e. "Example" → "Example (disambiguation)".
local topic = args[2]
checkType('disambiguate', 1, page, 'string')
if not page then
checkType('disambiguate', 2, disambiguator, 'string', true)
return makeWikitextError('no page specified')
disambiguator = disambiguator or 'disambiguation'
end
return string.format('%s (%s)', page, disambiguator)
return p._details(page, topic)
end
end
p.details = makeInvokeFunction(f.details)


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Format link
-- Further
--
--
-- Makes a wikilink from the given link and display values. Links are escaped
-- Produces a "Further information: a, b and c" link. It accepts an unlimited
-- with colons if necessary, and links to sections are detected and displayed
-- number of positional parameters, each of which is a page name.
-- with " § " as a separator rather than the standard MediaWiki "#". Used in
-- the {{format hatnote link}} template.
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


function p.formatLink(frame)
function p._further(...)
local args = getArgs(frame)
local links = formatPages(...)
local link = args[1]
local text = 'Further information: ' .. mw.text.listToText(links)
local display = args[2]
return p._rellink(text)
if not link then
end
return p.makeWikitextError(
 
'no link specified',
function f.further(args)
'Template:Format hatnote link#Errors',
local pages = mTableTools.compressSparseArray(args)
args.category
if #pages < 1 then
)
return makeWikiTextError('no pages specified')
end
end
return p._formatLink(link, display)
return p._further(unpack(pages))
end
end


function p._formatLink(link, display)
p.further = makeInvokeFunction(f.further)
checkType('_formatLink', 1, link, 'string')
checkType('_formatLink', 2, display, 'string', true)


-- Remove the initial colon for links where it was specified manually.
--------------------------------------------------------------------------------
link = removeInitialColon(link)
-- Main
--
-- Produces a link to a main article or articles. If used in category or
-- category talk space, produces "The main article for this category is xxx".
-- Otherwise, produces "Main article: xxx". Accepts an unlimited number of
-- page/display tables. Non-table inputs will result in an error. The first
-- value in the table should be the page name. Omitting this will result in an
-- error, except in the case of the first table, which uses the page name as a
-- fallaback. The second value in the table is an optional display value for
-- the link. If the first page name is not in mainspace, the output uses "page"
-- instead of "article". If more than one page is specified, the function uses
-- plural forms.
--------------------------------------------------------------------------------


-- Find whether a faux display value has been added with the {{!}} magic
function p._main(...)
-- word.
-- Get the list of pages. If no first page was specified we use the current
if not display then
-- page name.
local prePipe, postPipe = link:match('^(.-)|(.*)$')
local pages = {...}
link = prePipe or link
local currentTitle = mw.title.getCurrentTitle()
display = postPipe
local firstPageTable = pages[1]
local firstPage
if firstPageTable then
firstPage = firstPageTable[1]
else
firstPage = currentTitle.text
firstPageTable = {firstPage}
pages[1] = firstPageTable
end
end


-- Find the display value.
-- Find the pagetype.
if not display then
local firstPageNs = findNamespaceId(firstPage)
local page, section = link:match('^(.-)#(.*)$')
local pagetype = firstPageNs == 0 and 'article' or 'page'
if page then
 
display = page .. ' §&nbsp;' .. section
-- Make the formatted link text
local links = formatPageTables(pages)
links = mw.text.listToText(links)
 
-- Build the text.
local isPlural = #pages > 1
local currentNs = currentTitle.namespace
local isCategoryNamespace = currentNs - currentNs % 2 == 14
local stringToFormat
if isCategoryNamespace then
if isPlural then
stringToFormat = 'The main %ss for this'
.. ' [[Wikipedia:Categorization|category]] are %s'
else
stringToFormat = 'The main %s for this'
.. ' [[Wikipedia:Categorization|category]] is %s'
end
else
if isPlural then
stringToFormat = 'Main %ss: %s'
else
stringToFormat = 'Main %s: %s'
end
end
end
end
local text = string.format(stringToFormat, pagetype, links)
-- Pass the text to p._rellink.
local extraclasses = 'relarticle mainarticle'
return p._rellink(text, extraclasses)
end


-- Assemble the link.
function f.main(args)
if display then
local pages = {}
return string.format(
for k, v in pairs(args) do
'[[:%s|%s]]',
if type(k) == 'number' then
string.gsub(link, '|(.*)$', ''), --display overwrites manual piping
local display = args['l' .. tostring(k)]
display
local page = {v, display}
)
pages[k] = page
else
end
return string.format('[[:%s]]', link)
end
end
pages = mTableTools.compressSparseArray(pages)
return p._main(unpack(pages))
end
end
p.main = makeInvokeFunction(f.main)


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Hatnote
-- See also
--
--
-- Produces standard hatnote text. Implements the {{hatnote}} template.
-- Produces a "See also: a, b and c" link. The first parameter is an optional
-- alternative for the "See also" text. The following parameters are an
-- unlimited number of page/display tables. The first entry in the table is the
-- page name, and the second entry in the table is the display text.
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


function p.hatnote(frame)
function p._seealso(altphrase, ...)
local args = getArgs(frame)
altphrase = altphrase or 'See also'
local s = args[1]
local pages = {...}
local options = {}
local links = formatPageTables(pages)
if not s then
links = mw.text.listToText(links)
return p.makeWikitextError(
local text = altphrase .. ': ' .. links
'no text specified',
local extraclasses = 'boilerplate seealso'
'Template:Hatnote#Errors',
return p._rellink(text, extraclasses)
args.category
)
end
options.extraclasses = args.extraclasses
options.selfref = args.selfref
return p._hatnote(s, options)
end
end


function p._hatnote(s, options)
function f.seealso(args)
checkType('_hatnote', 1, s, 'string')
local pages = {}
checkType('_hatnote', 2, options, 'table', true)
for k, v in pairs(args) do
options = options or {}
if type(k) == 'number' then
local classes = {'hatnote', 'navigation-not-searchable'}
local numstring = tostring(k)
local extraclasses = options.extraclasses
local display = args['label ' .. numstring]
local selfref = options.selfref
or args['l' .. numstring]
if type(extraclasses) == 'string' then
local page = {v, display}
classes[#classes + 1] = extraclasses
pages[k] = page
end
end
end
if selfref then
pages = mTableTools.compressSparseArray(pages)
classes[#classes + 1] = 'selfref'
if not pages[1] then
return makeWikitextError(
'[[Template:See also|'
.. 'Template must be given at least one article name]]'
)
end
end
return string.format(
local altphrase = args.altphrase
'<div role="note" class="%s">%s</div>',
return p._seealso(altphrase, unpack(pages))
table.concat(classes, ' '),
s
)
end
end
p.seealso = makeInvokeFunction(f.seealso)


return p
return p
Please note that all contributions to Nonbinary Wiki are considered to be released under the Creative Commons Attribution-ShareAlike (see Nonbinary Wiki:Copyrights for details). If you do not want your writing to be edited mercilessly and redistributed at will, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource. Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)

Template used on this page:

Retrieved from "https://nonbinary.wiki/wiki/Module:Hatnote"