|
--------------------------------------------------------------------------------
-- This module provides easy processing of arguments passed to Scribunto from
-- Module:Hatnote --
-- #invoke. It is intended for use by other Lua modules, and should not be
-- --
-- called from #invoke directly.
-- This module produces hatnote links and links to related articles. It --
-- implements the {{hatnote}} and {{format link}} meta-templates and includes --
-- helper functions for other Lua hatnote modules. --
--------------------------------------------------------------------------------
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local mArguments -- lazily initialise [[Module:Arguments]]
local yesno -- lazily initialise [[Module:Yesno]]
local argumentsp = {}
--------------------------------------------------------------------------------
-- Generate four different tidyVal functions, so that we don't have to check the
-- Helper functions
-- options every time we call it.
--------------------------------------------------------------------------------
local function tidyValDefaultgetArgs(key, valframe)
-- Fetches the arguments from the parent frame. Whitespace is trimmed and
if type(val) == 'string' then
-- blanks are removed.
val = val:match('^%s*(.-)%s*$')
mArguments = require('Module:Arguments')
if val == '' then
return mArguments.getArgs(frame, {parentOnly = true})
return nil
else
return val
end
else
return val
end
end
local function tidyValTrimOnlyremoveInitialColon(key, vals)
-- Removes the initial colon from a string, if present.
if type(val) == 'string' then
return vals:match('^%s*:?(.-*)%s*$')
else
return val
end
end
local function tidyValRemoveBlanksOnlyp.findNamespaceId(keylink, valremoveColon)
-- Finds the namespace id (namespace number) of a link or a pagename. This
if type(val) == 'string' then
-- function will not work if the link is enclosed in double brackets. Colons
if val:find('%S') then
-- are trimmed from the start of the link by default. To skip colon
return val
-- trimming, set the removeColon parameter to true.
else
checkType('findNamespaceId', 1, link, 'string')
return nil
checkType('findNamespaceId', 2, removeColon, 'boolean', true)
if removeColon ~= false then
link = removeInitialColon(link)
end
local namespace = link:match('^(.-):')
if namespace then
local nsTable = mw.site.namespaces[namespace]
if nsTable then
return nsTable.id
end
else
return val
end
return 0
end
local function tidyValNoChangep.formatPages(key, val...)
-- Formats a list of pages using formatLink and returns it as an array. Nil
return val
-- values are not allowed.
local pages = {...}
local ret = {}
for i, page in ipairs(pages) do
ret[i] = p._formatLink(page)
end
return ret
end
local function matchesTitlep.formatPageTables(given, title...)
-- Takes a list of page/display tables and returns it as a list of
local tp = type( given )
-- formatted links. Nil values are not allowed.
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
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)
local translate_mt = { __index = function(t, k) return k end }
-- Formats an error message to be returned to wikitext. If
-- addTrackingCategory is not false after being returned from
function arguments.getArgs(frame, options)
-- [[Module:Yesno]], and if we are not on a talk page, a tracking category
checkType('getArgs', 1, frame, 'table', true)
-- is added.
checkType('getArgs', 2, options, 'table', true)
checkType('makeWikitextError', 1, msg, 'string')
frame = frame or {}
checkType('makeWikitextError', 2, helpLink, 'string', true)
options = options or {}
yesno = require('Module:Yesno')
local title = mw.title.getCurrentTitle()
--[[
-- SetMake upthe argumenthelp translationlink text.
local helpText
--]]
if helpLink then
options.translate = options.translate or {}
helpText = ' ([[' .. helpLink .. '|help]])'
if getmetatable(options.translate) == nil then
else
setmetatable(options.translate, translate_mt)
helpText = ''
end
-- Make the category text.
if options.backtranslate == nil then
local category
options.backtranslate = {}
if not title.isTalkPage and yesno(addTrackingCategory) ~= false then
for k,v in pairs(options.translate) do
category = 'Hatnote templates with errors'
options.backtranslate[v] = k
category = string.format(
end
'[[%s:%s]]',
end
mw.site.namespaces[14].name,
if options.backtranslate and getmetatable(options.backtranslate) == nil then
category
setmetatable(options.backtranslate, {
)
__index = function(t, k)
else
if options.translate[k] ~= k then
category = ''
return nil
else
return k
end
end
})
end
return string.format(
'<strong class="error">Error: %s%s.</strong>%s',
msg,
helpText,
category
)
end
--------------------------------------------------------------------------------
--[[
-- Format link
-- Get the argument tables. If we were passed a valid frame object, get the
--
-- frame arguments (fargs) and the parent frame arguments (pargs), depending
-- Makes a wikilink from the given link and display values. Links are escaped
-- on the options set and on the parent frame's availability. If we weren't
-- with colons if necessary, and links to sections are detected and displayed
-- passed a valid frame object, we are being called from another Lua module
-- with " § " as a separator rather than the standard MediaWiki "#". Used in
-- or from the debug console, so assume that we were passed a table of args
-- the {{format hatnote link}} template.
-- directly, and assign it to a new variable (luaArgs).
--------------------------------------------------------------------------------
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- The wrappers option makes Module:Arguments look up arguments in
-- either the frame argument table or the parent argument table, but
-- not both. This means that users can use either the #invoke syntax
-- or a wrapper template without the loss of performance associated
-- with looking arguments up in both the frame and the parent frame.
-- Module:Arguments will look up arguments in the parent frame
-- if it finds the parent frame's title in options.wrapper;
-- otherwise it will look up arguments in the frame object passed
-- to getArgs.
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end
function p.formatLink(frame)
-- We test for false specifically here so that nil (the default) acts like true.
local args = getArgs(frame)
if found or options.frameOnly == false then
pargs local link = parent.args[1]
local display = args[2]
end
if not found or options.parentOnly == falselink then
return p.makeWikitextError(
fargs = frame.args
'no link specified',
end
'Template:Format hatnote link#Errors',
end
args.category
else
)
-- options.wrapper isn't set, so check the other options.
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end
return p._formatLink(link, display)
end
function p._formatLink(link, display)
-- Set the order of precedence of the argument tables. If the variables are
-- nil,Find nothingwhether willwe be addedneed to use the table,colon whichtrick isor hownot. weWe avoidneed clashesto use the
-- colon trick for categories and files, as otherwise category links
-- between the frame/parent args and the Lua args.
-- categorise the page and file links display the file.
local argTables = {fargs}
checkType('_formatLink', 1, link, 'string')
argTables[#argTables + 1] = pargs
checkType('_formatLink', 2, display, 'string', true)
argTables[#argTables + 1] = luaArgs
link = removeInitialColon(link)
local namespace = p.findNamespaceId(link, false)
--[[
local colon
-- Generate the tidyVal function. If it has been specified by the user, we
if namespace == 6 or namespace == 14 then
-- use that; if not, we choose one of four functions depending on the
colon = ':'
-- options chosen. This is so that we don't have to call the options table
-- every time the function is called.
--]]
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(
"bad value assigned to option 'valueFunc'"
.. '(function expected, got '
.. type(tidyVal)
.. ')',
2
)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
colon = ''
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end
-- Find whether a faux display value has been added with the {{!}} magic
--[[
-- word.
-- Set up the args, metaArgs and nilArgs tables. args will be the one
if not display then
-- accessed from functions, and metaArgs will hold the actual arguments. Nil
local prePipe, postPipe = link:match('^(.-)|(.*)$')
-- arguments are memoized in nilArgs, and the metatable connects all of them
link = prePipe or link
-- together.
display = postPipe
--]]
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)
local function mergeArgs(tables)
--[[
-- Accepts multiple tables as input and merges their keys and values
-- into one table. If a value is already present it is not overwritten;
-- tables listed earlier have precedence. We are also memoizing nil
-- values, which can be overwritten if they are 's' (soft).
--]]
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end
-- Find the display value.
--[[
if not display then
-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
local page, section = link:match('^(.-)#(.*)$')
-- and are only fetched from the argument tables once. Fetching arguments
if page then
-- from the argument tables is the most resource-intensive step in this
display = page .. ' § ' .. section
-- module, so we try and avoid it where possible. For this reason, nil
-- arguments are also memoized, in the nilArgs table. Also, we keep a record
-- in the metatable of when pairs and ipairs have been called, so we do not
-- run pairs and ipairs on the argument tables more than once. We also do
-- not run ipairs on fargs and pargs if pairs has already been run, as all
-- the arguments will already have been copied over.
--]]
metatable.__index = function (t, key)
--[[
-- Fetches an argument when the args table is indexed. First we check
-- to see if the value is memoized, and if not we try and fetch it from
-- the argument tables. When we check memoization, we need to check
-- metaArgs before nilArgs, as both can be non-nil at the same time.
-- If the argument is not present in metaArgs, we also check whether
-- pairs has been run yet. If pairs has already been run, we return nil.
-- This is because all the arguments will have already been copied into
-- metaArgs by the mergeArgs function, meaning that any other arguments
-- must be nil.
--]]
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end
-- Assemble the link.
metatable.__newindex = function (t, key, val)
if display then
-- This function is called when a module tries to add a new value to the
return string.format('[[%s%s|%s]]', colon, link, display)
-- args table, or tries to change an existing value.
else
if type(key) == 'string' then
return string.format('[[%s%s]]', colon, link)
key = options.translate[key]
end
if options.readOnly then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; the table is read-only',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; overwriting existing arguments is not permitted',
2
)
elseif val == nil then
--[[
-- If the argument is to be overwritten with nil, we need to erase
-- the value in metaArgs, so that __index, __pairs and __ipairs do
-- not use a previous existing value, if present; and we also need
-- to memoize the nil in nilArgs, so that the value isn't looked
-- up in the argument tables if it is accessed again.
--]]
metaArgs[key] = nil
nilArgs[key] = 'h'
else
metaArgs[key] = val
end
end
end
--------------------------------------------------------------------------------
local function translatenext(invariant)
-- Hatnote
local k, v = next(invariant.t, invariant.k)
--
invariant.k = k
-- Produces standard hatnote text. Implements the {{hatnote}} template.
if k == nil then
--------------------------------------------------------------------------------
return nil
elseif type(k) ~= 'string' or not options.backtranslate then
return k, v
else
local backtranslate = options.backtranslate[k]
if backtranslate == nil then
-- Skip this one. This is a tail call, so this won't cause stack overflow
return translatenext(invariant)
else
return backtranslate, v
end
end
end
metatable.__pairs = function p.hatnote(frame)
local args = getArgs(frame)
-- Called when pairs is run on the args table.
local s = args[1]
if not metatable.donePairs then
local options = {}
mergeArgs(argTables)
if not s then
metatable.donePairs = true
return p.makeWikitextError(
end
'no text specified',
return translatenext, { t = metaArgs }
'Template:Hatnote#Errors',
args.category
)
end
options.extraclasses = args.extraclasses
options.selfref = args.selfref
return p._hatnote(s, options)
end
local function inextp._hatnote(ts, ioptions)
checkType('_hatnote', 1, s, 'string')
-- This uses our __index metamethod
checkType('_hatnote', 2, options, 'table', true)
local v = t[i + 1]
local classes = {'hatnote'}
if v ~= nil then
local extraclasses = options.extraclasses
return i + 1, v
local selfref = options.selfref
end
if type(extraclasses) == 'string' then
classes[#classes + 1] = extraclasses
end
if selfref then
classes[#classes + 1] = 'selfref'
metatable.__ipairs = function (t)
-- Called when ipairs is run on the args table.
return inext, t, 0
end
return string.format(
'<div class="%s">%s</div>',
return args
table.concat(classes, ' '),
s
)
end
return argumentsp
| 