Editing Module:Documentation
Jump to navigation
Jump to search
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: | ||
-- Get required modules. | -- Get required modules. | ||
local getArgs = require('Module:Arguments').getArgs | local getArgs = require('Module:Arguments').getArgs | ||
local htmlBuilder = require('Module:HtmlBuilder') | |||
local messageBox = require('Module:Message box') | |||
-- Get the config table. | -- Get the config table. | ||
Line 10: | Line 12: | ||
-- Often-used functions. | -- Often-used functions. | ||
local | local gsub = mw.ustring.gsub | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
-- Helper functions | -- Helper functions | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
local function message(cfgKey, valArray | local function message(cfgKey, expectType, valArray) | ||
--[[ | --[[ | ||
-- Gets a message from the cfg table and formats it if appropriate. | -- Gets a message from the cfg table and formats it if appropriate. | ||
-- The function raises an error if the value from the cfg table is not | -- The function raises an error if the value from the cfg table is not | ||
-- of the type expectType | -- of the type expectType. | ||
-- If the table valArray is present, strings such as $1, $2 etc. in the | -- If the table valArray is present, strings such as $1, $2 etc. in the | ||
-- message are substituted with values from the table keys [1], [2] etc. | -- message are substituted with values from the table keys [1], [2] etc. | ||
-- For example, if the message | -- For example, if the message cfg.fooMessage had the value 'Foo $2 bar $1.', | ||
-- message(' | -- message('fooMessage', 'string', {'baz', 'qux'}) would return "Foo qux bar baz." | ||
--]] | --]] | ||
local msg = cfg[cfgKey] | local msg = cfg[cfgKey] | ||
expectType | if expectType and type(msg) ~= expectType then | ||
error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2) | error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2) | ||
end | end | ||
Line 43: | Line 41: | ||
end | end | ||
local ret = gsub(msg, '$([1-9][0-9]*)', getMessageVal) | |||
return ret | |||
end | end | ||
p.message = message | p.message = message -- Make this function available for testing. | ||
local function makeWikilink(page, display) | local function makeWikilink(page, display) | ||
Line 55: | Line 54: | ||
end | end | ||
end | end | ||
local function makeCategoryLink(cat, sort) | local function makeCategoryLink(cat, sort) | ||
local catns = mw.site.namespaces[14].name | local catns = mw.site.namespaces[14].name | ||
return makeWikilink(catns .. ' | return makeWikilink(catns .. '/' .. cat, sort) | ||
end | end | ||
local function makeUrlLink(url, display) | local function makeUrlLink(url, display) | ||
return mw.ustring.format('[%s %s]', url, display) | return mw.ustring.format('[%s %s]', url, display) | ||
end | end | ||
local function makeToolbar(...) | local function makeToolbar(...) | ||
Line 80: | Line 73: | ||
ret[#ret + 1] = select(i, ...) | ret[#ret + 1] = select(i, ...) | ||
end | end | ||
return '<small style="font-style: normal;">(' .. table.concat(ret, ' | ') .. ')</small>' | |||
return '< | |||
end | end | ||
p.makeToolbar = makeToolbar | p.makeToolbar = makeToolbar -- Make this function available for testing. | ||
local function err(msg) | |||
return string.format( | |||
'<strong class="error">[[Module:Documentation]] error: %s</strong>%s', | |||
msg, | |||
makeCategoryLink('Documentation template invocations with errors') | |||
) | |||
end | |||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
Line 93: | Line 92: | ||
local function makeInvokeFunc(funcName) | local function makeInvokeFunc(funcName) | ||
return function (frame) | return function (frame) | ||
local headingArg = message('headingArg', 'string') | |||
local args = getArgs(frame, { | local args = getArgs(frame, { | ||
valueFunc = function (key, value) | valueFunc = function (key, value) | ||
if type(value) == 'string' then | if type(value) == 'string' then | ||
value = value:match('^%s*(.-)%s*$') -- Remove whitespace. | value = value:match('^%s*(.-)%s*$') -- Remove whitespace. | ||
if key == | if key == headingArg or value ~= '' then | ||
return value | return value | ||
else | else | ||
Line 112: | Line 112: | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
-- | -- Main function | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
p.main = makeInvokeFunc('_main') | p.main = makeInvokeFunc('_main') | ||
function p._main(args) | function p._main(args) | ||
local env = p.getEnvironment(args) | local env = p.getEnvironment(args) | ||
local root = | local root = htmlBuilder.create() | ||
root | root | ||
.wikitext(p.protectionTemplate(env)) | |||
.wikitext(p.sandboxNotice(args, env)) | |||
-- This div tag is from {{documentation/start box}}, but moving it here | |||
-- so that we don't have to worry about unclosed tags. | |||
.tag('div') | |||
.attr('id', message('mainDivId', 'string')) | |||
.addClass(message('mainDivClasses', 'string')) | |||
.newline() | |||
.wikitext(p._startBox(args, env)) | |||
.wikitext(p._content(args, env)) | |||
.tag('div') | |||
.css('clear', 'both') -- So right or left floating items don't stick out of the doc box. | |||
.newline() | |||
.done() | |||
.done() | |||
.wikitext(p._endBox(args, env)) | |||
.newline() | |||
.wikitext(p.addTrackingCategories(env)) | |||
return tostring(root) | |||
return | |||
end | end | ||
Line 166: | Line 147: | ||
function p.getEnvironment(args) | function p.getEnvironment(args) | ||
-- Returns a table with information about the environment, including the title to use, the subject namespace, etc. | |||
-- Returns a table with information about the environment, including | -- This is called from p._main using pcall in case we get any errors from exceeding the expensive function count | ||
-- limit, or other perils unknown. | |||
-- | |||
-- | |||
-- | -- | ||
-- Data includes: | -- Data includes: | ||
-- env.title - the title object of the page we are making documentation for (usually the current title) | |||
-- env.subjectSpace - the number of the title's subject namespace. | -- env.subjectSpace - the number of the title's subject namespace. | ||
-- env. | -- env.docspace - the name of the namespace the title puts its documentation in. | ||
-- env. | -- env.templatePage - the name of the template page with no namespace or interwiki prefixes. | ||
local env, envFuncs = {}, {} | local env, envFuncs = {}, {} | ||
-- Set up the metatable. If | -- Set up the metatable. If a nil value is called, we call that function in the envFuncs table and memoize it | ||
-- | -- in the env table so we don't have to call any of the functions more than once. | ||
setmetatable(env, { | setmetatable(env, { | ||
__index = function (t, key) | __index = function (t, key) | ||
local envFunc = envFuncs[key] | local envFunc = envFuncs[key] | ||
if envFunc then | if envFunc then | ||
local | local val = envFunc() | ||
env[key] = val | |||
return val | |||
else | |||
return nil | |||
end | end | ||
end | end | ||
}) | }) | ||
-- Get the title. | |||
function envFuncs.title() | function envFuncs.title() | ||
local title | local title | ||
local titleArg = args | local titleArg = args[message('titleArg', 'string')] | ||
if titleArg then | if titleArg then | ||
title = mw.title.new(titleArg) | title = mw.title.new(titleArg) | ||
if not title then | |||
error(message('titleArgError', 'string', {titleArg})) | |||
end | |||
else | else | ||
title = mw.title.getCurrentTitle() | title = mw.title.getCurrentTitle() | ||
Line 219: | Line 188: | ||
end | end | ||
-- Get the subject namespace number. | |||
function envFuncs.subjectSpace() | function envFuncs.subjectSpace() | ||
return mw.site.namespaces[env.title.namespace].subject.id | return mw.site.namespaces[env.title.namespace].subject.id | ||
end | end | ||
-- Get the name of the documentation namespace. | |||
function envFuncs.docspace() | |||
local subjectSpace = env.subjectSpace | local subjectSpace = env.subjectSpace | ||
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then | if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then | ||
return subjectSpace | -- Pages in the Article, File, MediaWiki or Category namespaces must have their | ||
-- /doc, /sandbox and /testcases pages in talk space. | |||
return mw.site.namespaces[subjectSpace].talk.name | |||
else | else | ||
return | return env.title.subjectNsText | ||
end | end | ||
end | end | ||
function envFuncs. | -- Get the template page with no namespace or interwiki prefixes. | ||
function envFuncs.templatePage() | |||
local | local title = env.title | ||
local | local subpage = title.subpageText | ||
if | if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then | ||
return title.baseText | |||
return | |||
else | else | ||
return | return title.text | ||
end | end | ||
end | end | ||
function env:grab(key) | |||
local success, val = pcall(function() return self[key] end) | |||
return success, val | |||
end | |||
return env | return env | ||
Line 319: | Line 225: | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
-- | -- Auxiliary templates | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
function p.sandboxNotice(args, env) | |||
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string') | |||
function p. | if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then | ||
if not | |||
return nil | return nil | ||
end | end | ||
local frame = mw.getCurrentFrame() | |||
local notice = htmlBuilder.create() | |||
notice | |||
.tag('div') | |||
.css('clear', 'both') | |||
.done() | |||
.wikitext(frame:expandTemplate{title = sandboxNoticeTemplate, args = {[message('sandboxNoticeLivepageParam')] = args[message('livepageArg', 'string')]}}) | |||
return tostring(notice) | |||
end | end | ||
function p. | function p.protectionTemplate(env) | ||
local title = env.title | local title = env.title | ||
local | local protectionTemplate = message('protectionTemplate', 'string') | ||
if not title | if not (protectionTemplate and title.namespace == 10) then | ||
-- Don't display the protection template if we are not in the template namespace. | |||
return nil | return nil | ||
end | end | ||
local frame = mw.getCurrentFrame() | |||
local function getProtectionLevel(protectionType, page) | |||
-- Gets the protection level for page, or for the current page if page is not specified. | |||
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType, page) | |||
local | if level ~= '' then | ||
return level | |||
if | |||
else | else | ||
return nil -- The parser function returns the blank string if there is no match. | |||
end | end | ||
end | end | ||
local prefixedTitle = title.prefixedText | |||
if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then | |||
return | -- The page is full-move protected, or full, template, or semi-protected. | ||
return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')} | |||
end | |||
return nil | |||
end | end | ||
---------------------------------------------------------------------------- | |||
-- Start box | |||
---------------------------------------------------------------------------- | |||
-- | p.startBox = makeInvokeFunc('_startBox') | ||
local | function p._startBox(args, env) | ||
local title = env.title | |||
-- Arg processing from {{documentation}}. | |||
local preload = args[message('preloadArg', 'string')] -- Allow custom preloads. | |||
local heading = args[message('headingArg', 'string')] -- Blank values are not removed. | |||
local headingStyle = args[message('headingStyleArg', 'string')] | |||
local content = args[message('contentArg', 'string')] | |||
local docspace = env.docspace | |||
local docname = args[1] -- Other docname, if fed. | |||
local templatePage = env.templatePage | |||
-- Arg processing from {{documentation/start box2}}. | |||
local docpage | |||
local | if docname then | ||
docpage = docname | |||
if | |||
else | else | ||
local | local namespace = docspace or title.nsText | ||
local pagename = templatePage or title.text | |||
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string') | |||
end | end | ||
local docTitle = mw.title.new(docpage) | |||
local docExist = docTitle.exists | |||
-- Output from {{documentation/start box}}. | |||
-- First, check the heading parameter. | |||
-- | |||
if heading == '' then | if heading == '' then | ||
-- | -- Heading is defined but blank, so do nothing. | ||
return nil | return nil | ||
end | |||
-- Build the start box div. | |||
local sbox = htmlBuilder.create('div') | |||
sbox | |||
.css('padding-bottom', '3px') | |||
.css('border-bottom', '1px solid #aaa') | |||
.css('margin-bottom', '1ex') | |||
.newline() | |||
-- Make the heading. | |||
local hspan = sbox.tag('span') | |||
if headingStyle then | |||
hspan.cssText(headingStyle) | |||
elseif subjectSpace == 10 then | |||
-- We are in the template or template talk namespaces. | |||
hspan | |||
.css('font-weight', 'bold') | |||
.css('fond-size', '125%') | |||
else | |||
hspan.css('font-size', '150%') | |||
end | end | ||
if heading then | if heading then | ||
data.heading | -- "heading" has data. | ||
hspan.wikitext(heading) | |||
elseif subjectSpace == 10 then -- Template namespace | elseif subjectSpace == 10 then -- Template namespace | ||
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string')) | |||
elseif subjectSpace == 828 then -- Module namespace | elseif subjectSpace == 828 then -- Module namespace | ||
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string')) | |||
elseif subjectSpace == 6 then -- File namespace | elseif subjectSpace == 6 then -- File namespace | ||
hspan.wikitext(message('fileNamespaceHeading', 'string')) | |||
else | else | ||
hspan.wikitext(message('otherNamespacesHeading', 'string')) | |||
end | end | ||
-- | -- Add the [view][edit][history][purge] or [create] links. | ||
-- Check for the content parameter first, as we don't need the links if the documentation | |||
if | -- content is being entered directly onto the template page. | ||
if not content then | |||
local lspan = sbox.tag('span') -- lspan is short for "link span". | |||
lspan | |||
.addClass(message('startBoxLinkclasses', 'string')) | |||
.attr('id', message('startBoxLinkId', 'string')) | |||
if docExist then | |||
local viewLink = makeWikilink(docpage, message('viewLinkDisplay', 'string')) | |||
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string')) | |||
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string')) | |||
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, message('purgeLinkDisplay', 'string')) | |||
local text = '[%s] [%s] [%s] [%s]' | |||
text = text:gsub('%[', '[') -- Replace square brackets with HTML entities. | |||
text = text:gsub('%]', ']') | |||
lspan.wikitext(mw.ustring.format(text, viewLink, editLink, historyLink, purgeLink)) | |||
else | |||
if not preload then | |||
if subjectSpace == 6 then -- File namespace | |||
preload = message('fileDocpagePreload', 'string') | |||
else | |||
preload = message('docpagePreload', 'string') | |||
end | |||
end | |||
lspan.wikitext(makeUrlLink(docTitle:fullUrl{action = 'edit', preload = preload}, message('createLinkDisplay', 'string'))) | |||
end | |||
end | end | ||
return tostring(sbox) | return tostring(sbox) | ||
end | end | ||
Line 524: | Line 378: | ||
function p._content(args, env) | function p._content(args, env) | ||
local content = args[message('contentArg', 'string')] | |||
if not content then | |||
local docpage = args[1] | |||
if docpage and mw.title.new(docpage).exists then | |||
local frame = mw.getCurrentFrame() | |||
content = frame:preprocess('{{ ' .. docpage .. ' }}') | |||
else | |||
docpage = env.docspace .. ':' .. env.templatePage .. '/' .. message('docSubpage', 'string') | |||
if mw.title.new(docpage).exists then | |||
local frame = mw.getCurrentFrame() | |||
content = frame:preprocess('{{ ' .. docpage .. ' }}') | |||
end | |||
end | |||
end | end | ||
-- The line breaks below are necessary so that "=== Headings ===" at the start and end | -- The line breaks below are necessary so that "=== Headings ===" at the start and end | ||
-- of docs are interpreted correctly. | -- of docs are interpreted correctly. | ||
return '\n' .. (content or '') .. '\n' | return '\n' .. (content or '') .. '\n' | ||
end | end | ||
Line 561: | Line 404: | ||
function p._endBox(args, env) | function p._endBox(args, env) | ||
local title = env.title | |||
local subjectSpace = env.subjectSpace | local subjectSpace = env.subjectSpace | ||
local | |||
if | -- Argument processing in {{documentation}}. | ||
local content = args[message('contentArg', 'string')] | |||
local linkBox = args[message('linkBoxArg', 'string')] -- So "link box=off" works. | |||
local docspace = env.docspace | |||
local docname = args[1] -- Other docname, if fed. | |||
local templatePage = env.templatePage | |||
-- Argument processing in {{documentation/end box2}}. | |||
local docpageRoot = (docspace or title.nsText) .. ':' .. (templatePage or title.text) | |||
local docpage | |||
if docname then | |||
docpage = docname | |||
else | |||
docpage = docpageRoot .. '/' .. message('docSubpage', 'string') | |||
end | end | ||
local docTitle = mw.title.new(docpage) | |||
-- | local docExist = docTitle.exists | ||
local docnameFed = args[1] and true | |||
local sandbox = docpageRoot .. '/' .. message('sandboxSubpage', 'string') | |||
local testcases = docpageRoot .. '/' .. message('testcasesSubpage', 'string') | |||
templatePage = title.nsText .. ':' .. templatePage | |||
-- Output from {{documentation/end box}} | |||
-- First, check whether we should output the end box at all. Add the end box by default if the documentation | |||
-- exists or if we are in the user, module or template namespaces. | |||
if linkBox == message('linkBoxOff', 'string') or not (docExist or subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10) then | |||
return nil | return nil | ||
end | end | ||
-- Assemble the | -- Assemble the arguments for {{fmbox}}. | ||
local fmargs = {} | |||
fmargs[message('fmboxIdParam', 'string')] = message('fmboxId', 'string') -- Sets fmargs.id = 'documentation-meta-data' | |||
fmargs[message('fmboxImageParam', 'string')] = message('fmboxImageNone', 'string') -- Sets fmargs.image = 'none' | |||
fmargs[message('fmboxStyleParam', 'string')] = message('fmboxStyle', 'string') -- Sets fmargs.style = 'background-color: #ecfcf4' | |||
fmargs[message('fmboxTextstyleParam', 'string')] = message('fmboxTextstyle', 'string') -- Sets fmargs.textstyle = 'font-style: italic;' | |||
-- Assemble the fmbox text field. | |||
local text = '' | local text = '' | ||
if linkBox then | if linkBox then | ||
-- Use custom link box content if it is defined. | |||
text = text .. linkBox | text = text .. linkBox | ||
else | else | ||
text = text .. ( | if docExist then | ||
if subjectSpace == 2 or subjectSpace == | -- /doc exists; link to it. | ||
-- We are in the user, template | local docLink = makeWikilink(docpage) | ||
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string')) | |||
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string')) | |||
text = text .. message('transcludedFromBlurb', 'string', {docLink}) .. ' ' .. makeToolbar(editLink, historyLink) .. '<br />' | |||
if not | elseif subjectSpace == 828 then | ||
-- " | -- /doc does not exist; ask to create it. | ||
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = message('modulePreload', 'string')}, message('createLinkDisplay', 'string')) | |||
-- | text = text .. message('createModuleDocBlurb', 'string', {createLink}) .. '<br />' | ||
text = text .. ( | end | ||
-- Add links to /sandbox and /testcases when appropriate. | |||
if subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10 then | |||
-- We are in the user, module or template namespaces. | |||
local sandboxLinks, testcasesLinks | |||
local pagePossessive = subjectSpace == 828 and message('modulePossessive', 'string') or message('templatePossessive', 'string') | |||
local sandboxTitle = mw.title.new(sandbox) | |||
if sandboxTitle.exists then | |||
local sandboxLink = makeWikilink(sandbox, message('sandboxLinkDisplay', 'string')) | |||
local sandboxEditLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit'}, message('sandboxEditLinkDisplay', 'string')) | |||
local compareLink = makeUrlLink(mw.title.new('Special:ComparePages'):fullUrl{page1 = templatePage, page2 = sandbox}, message('compareLinkDisplay', 'string')) | |||
sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink) | |||
else | |||
local sandboxPreload = subjectSpace == 828 and message('moduleSandboxPreload', 'string') or message('templateSandboxPreload', 'string') | |||
local sandboxCreateLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}, message('sandboxCreateLinkDisplay', 'string')) | |||
local mirrorSummary = message('mirrorEditSummary', 'string', {makeWikilink(templatePage)}) | |||
local mirrorLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = templatePage, summary = mirrorSummary}, message('mirrorLinkDisplay', 'string')) | |||
sandboxLinks = message('sandboxLinkDisplay', 'string') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink) | |||
end | |||
local testcaseTitle = mw.title.new(testcases) | |||
if testcaseTitle.exists then | |||
local testcasesLink = makeWikilink(testcases, message('testcasesLinkDisplay', 'string')) | |||
local testcasesEditLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit'}, message('testcasesEditLinkDisplay', 'string')) | |||
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink) | |||
else | |||
local testcasesPreload = subjectSpace == 828 and message('moduleTestcasesPreload', 'string') or message('templateTestcasesPreload', 'string') | |||
local testcasesCreateLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit', preload = testcasesPreload}, message('testcasesCreateLinkDisplay', 'string')) | |||
testcasesLinks = message('testcasesLinkDisplay', 'string') .. ' ' .. makeToolbar(testcasesCreateLink) | |||
end | |||
text = text .. message('experimentBlurb', 'string', {pagePossessive, sandboxLinks, testcasesLinks}) .. '<br />' | |||
-- Show the categories text, but not if "content" fed or "docname fed" since then it is unclear where to add the categories. | |||
if not content and not docnameFed then | |||
local docPathLink = makeWikilink(docpage, message('docLinkDisplay', 'string')) | |||
text = text .. message('addCategoriesBlurb', 'string', {docPathLink}) | |||
end | |||
-- Show the "subpages" link. | |||
if subjectSpace ~= 6 then -- Don't show the link in file space. | |||
local pagetype | |||
if subjectSpace == 10 then | |||
pagetype = message('templatePagetype', 'string') | |||
elseif subjectSpace == 828 then | |||
pagetype = message('modulePagetype', 'string') | |||
else | |||
pagetype = message('defaultPagetype', 'string') | |||
end | |||
text = text .. ' ' .. makeWikilink('Special:PrefixIndex/' .. templatePage .. '/', message('subpagesLinkDisplay', 'string', {pagetype})) | |||
end | |||
-- Show the "print" link if it exists. | |||
local printPage = templatePage .. '/' .. message('printSubpage', 'string') | |||
local printTitle = mw.title.new(printPage) | |||
if printTitle.exists then | |||
local printLink = makeWikilink(printPage, message('printLinkDisplay', 'string')) | |||
text = text .. '<br />' .. message('printBlurb', 'string', {printLink}) | |||
.. (message('displayPrintCategory', 'boolean') and makeCategoryLink(message('printCategory', 'string')) or '') | |||
end | end | ||
end | end | ||
end | end | ||
fmargs.text = text | |||
-- Return the fmbox output. | |||
return messageBox.main('fmbox', fmargs) | |||
-- | |||
return | |||
end | end | ||
Line 832: | Line 528: | ||
function p.addTrackingCategories(env) | function p.addTrackingCategories(env) | ||
-- Check if {{documentation}} is transcluded on a /doc or /testcases page. | -- Check if {{documentation}} is transcluded on a /doc or /testcases page. | ||
local title = env.title | local title = env.title | ||
local | local ret = '' | ||
local subpage = title.subpageText | local subpage = title.subpageText | ||
if message('displayStrangeUsageCategory', 'boolean') and (subpage == message('docSubpage', 'string') or subpage == message('testcasesSubpage', 'string')) then | |||
if message(' | local sort = (title.namespace == 0 and message('strangeUsageCategoryMainspaceSort', 'string') or '') .. title.prefixedText -- Sort on namespace. | ||
ret = ret .. makeCategoryLink(message('strangeUsageCategory', 'string'), sort) | |||
) | |||
ret = ret .. makeCategoryLink(message(' | |||
end | end | ||
return ret | return ret |