Module:Hatnote inline: Difference between revisions
From the Croc Wiki, the Croc encyclopedia
Jump to navigationJump to search
m (SMcCandlish moved page Module:Hatnote-inline to Module:Hatnote inline without leaving a redirect: following move of parent template) |
m (18 revisions imported from wikipedia:Module:Hatnote_inline) |
||
(7 intermediate revisions by 5 users not shown) | |||
Line 2: | Line 2: | ||
-- Module:Hatnote-inline -- |
-- Module:Hatnote-inline -- |
||
-- -- |
-- -- |
||
-- This module produces hatnote-style links and links to related articles, |
-- This module produces hatnote-style links, and links to related articles, -- |
||
-- but inside a <span>, instead of the <div> used by Module:Hatnote. It -- |
-- but inside a <span>, instead of the <div> used by Module:Hatnote. It -- |
||
-- implements the {{hatnote-inline}} meta-template. -- |
-- implements the {{hatnote-inline}} meta-template. -- |
||
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
||
local |
local mHatnote = require('Module:Hatnote') |
||
local mArguments = require('Module:Arguments') |
|||
local checkType = libraryUtil.checkType |
|||
local |
local yesno = require('Module:Yesno') |
||
local yesno -- lazily initialise [[Module:Yesno]] |
|||
local p = {} |
local p = {} |
||
function p.hatnoteInline (frame) |
|||
-------------------------------------------------------------------------------- |
|||
local args = mArguments.getArgs(frame) |
|||
-- Helper functions |
|||
local hatnote = mHatnote.hatnote(frame) |
|||
-------------------------------------------------------------------------------- |
|||
if args.inline == nil or yesno(args.inline, true) then |
|||
local |
local subs = { |
||
['<div'] = '<span', |
|||
-- Fetches the arguments from the parent frame. Whitespace is trimmed and |
|||
['</div>$'] = '</span>' |
|||
-- blanks are removed. |
|||
} |
|||
mArguments = require('Module:Arguments') |
|||
for k, v in pairs(subs) do hatnote = string.gsub(hatnote, k, v, 1) end |
|||
return mArguments.getArgs(frame, {parentOnly = true}) |
|||
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 |
||
return hatnote |
|||
local namespace = link:match('^(.-):') |
|||
if namespace then |
|||
local nsTable = mw.site.namespaces[namespace] |
|||
if nsTable then |
|||
return nsTable.id |
|||
end |
|||
end |
|||
return 0 |
|||
end |
end |
||
p.hatnote = p.hatnoteInline --alias |
|||
function p.formatPages(...) |
|||
-- 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] = 'selfref' |
|||
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 01:26, January 30, 2022
This module is rated as ready for general use. It has reached a mature form and is thought to be relatively bug-free and ready for use wherever appropriate. It is ready to mention on help pages and other Wikipedia resources as an option for new users to learn. To reduce server load and bad output, it should be improved by sandbox testing rather than repeated trial-and-error editing. |
This module produces hatnote-style notes ≠ self-references and notes-to-reader – usually to related articles or a section/anchor at the same page. It does this inside a <span>...</span>
, instead of the <div>...</div>
used by Module:Hatnote. It implements the {{hatnote inline}}
meta-template.
Usage
{{#invoke:Hatnote inline|hatnote|text}}
--------------------------------------------------------------------------------
-- 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, 1) end
end
return hatnote
end
p.hatnote = p.hatnoteInline --alias
return p