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 = {}
--------------------------------------------------------------------------------
-- Argument processing
--------------------------------------------------------------------------------
 
--[[
-- The p table is for functions to be returned from #invoke, and for functions
-- to be used from other Lua modules. The f table is for functions acting as a
-- bridge between #invoke functions and Lua module functions. #invoke functions
-- 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


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
Line 18: Line 36:
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


local function getArgs(frame)
local function formatLink(link, display)
-- Fetches the arguments from the parent frame. Whitespace is trimmed and
-- Makes a wikilink from the given link and display values. Links are
-- blanks are removed.
-- escaped with colons if necessary, and links to sections are detected
mArguments = require('Module:Arguments')
-- and displayed with " § " as a separator rather than the standard
return mArguments.getArgs(frame, {parentOnly = true})
-- MediaWiki "#".
end
 
local function removeInitialColon(s)
-- Removes the initial colon from a string, if present.
return s:match('^:?(.*)')
end


function p.findNamespaceId(link, removeColon)
-- Find whether we need to use the colon trick or not. We need to use the
-- Finds the namespace id (namespace number) of a link or a pagename. This
-- colon trick for categories and files, as otherwise category links
-- function will not work if the link is enclosed in double brackets. Colons
-- categorise the page and file links display the file.
-- are trimmed from the start of the link by default. To skip colon
-- 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
local colon
local nsTable = mw.site.namespaces[namespace]
if namespace and mw.site.namespaces[namespace] then
if nsTable then
-- The start of the link is a valid namespace name; check whether it is
return nsTable.id
-- a category or a file.
local nsid = mw.site.namespaces[namespace].id
if nsid == 6 or nsid == 14 then
colon = ':'
end
end
end
end
return 0
colon = colon or ''
end


function p.formatPages(...)
-- Find the display value.
-- Formats a list of pages using formatLink and returns it as an array. Nil
if not display then
-- values are not allowed.
local page, section = link:match('^(.-)#(.*)$')
local pages = {...}
if page then
local ret = {}
display = page .. ' § ' .. section
for i, page in ipairs(pages) do
end
ret[i] = p._formatLink(page)
end
end
return ret
end


function p.formatPageTables(...)
-- Assemble the link.
-- Takes a list of page/display tables and returns it as a list of
if display then
-- formatted links. Nil values are not allowed.
return string.format('[[%s%s|%s]]', colon, link, display)
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, title)
-- 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')
title = title or 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
else
category = ''
return string.format('[[%s%s]]', colon, link)
end
end
return string.format(
'<strong class="error">Error: %s%s.</strong>%s',
msg,
helpText,
category
)
end
end


function p.disambiguate(page, disambiguator)
local function makeWikitextError(msg)
-- Formats a page title with a disambiguation parenthetical,
-- Formats an error message to be returned to wikitext.
-- i.e. "Example" → "Example (disambiguation)".
return string.format('<strong class="error">Error: %s.</strong>', msg)
checkType('disambiguate', 1, page, 'string')
checkType('disambiguate', 2, disambiguator, 'string', true)
disambiguator = disambiguator or 'disambiguation'
return string.format('%s (%s)', page, disambiguator)
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Format link
-- Hatnote
--
--
-- Makes a wikilink from the given link and display values. Links are escaped
-- Produces standard hatnote text. Implements the {{hatnote}} template.
-- 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)
function p._hatnote(s)
local args = getArgs(frame)
return string.format('<div class="dablink">%s</div>', s)
local link = args[1]
end
local display = args[2]
 
if not link then
function f.hatnote(args)
return p.makeWikitextError(
local s = args[1]
'no link specified',
if not s then
'Template:Format hatnote link#Errors',
return makeWikitextError('no text specified')
args.category
)
end
end
return p._formatLink(link, display)
return p._hatnote(s)
end
end


function p._formatLink(link, display)
p.hatnote = makeInvokeFunction(f.hatnote)
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)
-- Rellink
--
-- Produces a standard link to a related article. Implements the {{rellink}}
-- template.
--------------------------------------------------------------------------------


-- Find whether a faux display value has been added with the {{!}} magic
function p._rellink(s, extraclasses)
-- word.
if extraclasses then
if not display then
extraclasses = ' ' .. extraclasses
local prePipe, postPipe = link:match('^(.-)|(.*)$')
else
link = prePipe or link
extraclasses = ''
display = postPipe
end
end
return string.format('<div class="rellink%s">%s</div>', extraclasses, s)
end


-- Find the display value.
function f.rellink(args)
if not display then
local s = args[1]
local page, section = link:match('^(.-)#(.*)$')
local extraclasses = args.extraclasses
if page then
if not s then
display = page .. ' §&nbsp;' .. section
return makeWikitextError('no text specified')
end
end
end
return p._rellink(s, extraclasses)
end


-- Assemble the link.
p.rellink = makeInvokeFunction(f.rellink)
if display then
return string.format(
'[[:%s|%s]]',
string.gsub(link, '|(.*)$', ''), --display overwrites manual piping
display
)
else
return string.format('[[:%s]]', link)
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Hatnote
-- Details
--
--
-- Produces standard hatnote text. Implements the {{hatnote}} template.
-- 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.hatnote(frame)
function p._details(page, topic)
local args = getArgs(frame)
page = formatLink(page)
local s = args[1]
topic = topic or 'this topic'
local options = {}
local text = string.format('For more details on %s, see %s.', topic, page)
if not s then
local extraclasses = 'boilerplate seealso'
return p.makeWikitextError(
return p._rellink(text, extraclasses)
'no text specified',
'Template:Hatnote#Errors',
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.details(args)
checkType('_hatnote', 1, s, 'string')
local page = args[1]
checkType('_hatnote', 2, options, 'table', true)
local topic = args[2]
options = options or {}
if not page then
local classes = {'hatnote', 'navigation-not-searchable'}
return makeWikitextError('no page specified')
local extraclasses = options.extraclasses
local selfref = options.selfref
if type(extraclasses) == 'string' then
classes[#classes + 1] = extraclasses
end
end
if selfref then
return p._details(page, topic)
classes[#classes + 1] = 'selfref'
end
return string.format(
'<div role="note" class="%s">%s</div>',
table.concat(classes, ' '),
s
)
end
end
p.details = makeInvokeFunction(f.details)


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"