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 | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
Line 19: | Line 21: | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
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 44: | ||
end | end | ||
local ret = gsub(msg, '$([1-9][0-9]*)', getMessageVal) | |||
return ret | |||
end | end | ||
Line 80: | Line 82: | ||
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 | ||
local function err(msg) | |||
return string.format( | |||
'<strong class="error">[[Module:Documentation]] error: %s</strong>%s', | |||
msg, | |||
makeCategoryLink('Documentation template invocations with errors') | |||
) | |||
end | |||
p.err = err | |||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
Line 93: | Line 103: | ||
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 123: | ||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
-- | -- 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 158: | ||
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 199: | ||
end | end | ||
function envFuncs. | -- Get the subject namespace number. | ||
function envFuncs.subjectSpace() | |||
return mw.site.namespaces[env.title.namespace].subject.id | |||
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 | |||
-- 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 | |||
return env.title.subjectNsText | |||
end | |||
end | |||
-- Get the template page with no namespace or interwiki prefixes. | |||
function envFuncs.templatePage() | |||
local title = env.title | local title = env.title | ||
local subpage = title.subpageText | local subpage = title.subpageText | ||
if subpage == message(' | if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then | ||
return | return title.baseText | ||
else | else | ||
return | return title.text | ||
end | end | ||
end | end | ||
function envFuncs.docTitle() | function envFuncs.docTitle() | ||
local title = env.title | local title = env.title | ||
local docname = args[1] -- | local docname = args[1] -- Other docname, if fed. | ||
local docspace = env.docspace | |||
local templatePage = env.templatePage | |||
local docpage | local docpage | ||
if docname then | if docname then | ||
docpage = docname | docpage = docname | ||
else | else | ||
docpage = | local namespace = docspace or title.nsText | ||
local pagename = templatePage or title.text | |||
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string') | |||
end | end | ||
return mw.title.new(docpage) | return mw.title.new(docpage) | ||
end | end | ||
function | function env:grab(key) | ||
local success, val = pcall(function() return self[key] end) | |||
return success, val | |||
return | |||
end | end | ||
return env | |||
end | |||
---------------------------------------------------------------------------- | |||
-- Auxiliary templates | |||
---------------------------------------------------------------------------- | |||
function p.sandboxNotice(args, env) | |||
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string') | |||
if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then | |||
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 | |||
function p.protectionTemplate(env) | |||
local title = env.title | |||
-- | local protectionTemplate = message('protectionTemplate', 'string') | ||
if not (protectionTemplate and title.namespace == 10) then | |||
-- | -- Don't display the protection template if we are not in the template namespace. | ||
local | return nil | ||
if | end | ||
return | 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) | |||
if level ~= '' then | |||
return level | |||
else | else | ||
return | 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 | |||
-- The | -- The page is full-move protected, or full, template, or semi-protected. | ||
return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')} | |||
end | end | ||
return nil | |||
end | |||
end | |||
---------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ||
Line 325: | Line 302: | ||
function p._startBox(args, env) | function p._startBox(args, env) | ||
-- | local title = env.title | ||
-- | local subjectSpace = env.subjectSpace | ||
-- | |||
-- | -- 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 | |||
local | |||
if | -- Arg processing from {{documentation/start box2}}. | ||
-- | local docpage | ||
if docname then | |||
docpage = docname | |||
else | |||
local namespace = docspace or title.nsText | |||
local pagename = templatePage or title.text | |||
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string') | |||
end | |||
local docTitle = mw.title.new(docpage) | |||
local docExist = docTitle.exists | |||
-- Output from {{documentation/start box}}. | |||
-- First, check the heading parameter. | |||
if heading == '' then | |||
-- Heading is defined but blank, so do nothing. | |||
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('font-size', '125%') | |||
else | |||
hspan.css('font-size', '150%') | |||
end | end | ||
-- | if heading then | ||
-- "heading" has data. | |||
hspan.wikitext(heading) | |||
elseif subjectSpace == 10 then -- Template namespace | |||
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string')) | |||
elseif subjectSpace == 828 then -- Module namespace | |||
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string')) | |||
elseif subjectSpace == 6 then -- File namespace | |||
hspan.wikitext(message('fileNamespaceHeading', 'string')) | |||
else | else | ||
-- | hspan.wikitext(message('otherNamespacesHeading', 'string')) | ||
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 | |||
-- 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) | |||
end | end | ||
function p.makeStartBoxLinksData(args, env) | function p.makeStartBoxLinksData(args, env) | ||
local data = {} | |||
-- Get title objects. | |||
-- | local titleSuccess, title = env:grab('title') | ||
if titleSuccess then | |||
data.title = title | |||
else | |||
return err(title) | |||
return | |||
end | end | ||
if | local docTitleSuccess, docTitle = env:grab('docTitle') | ||
docTitle = docTitle | if docTitleSuccess then | ||
data.docTitle = docTitle | |||
else | |||
return err(docTitle) | |||
end | end | ||
-- View, display, edit, and purge links if /doc exists. | -- View, display, edit, and purge links if /doc exists. | ||
data.viewLinkDisplay = message(' | data.viewLinkDisplay = message('viewLinkDisplay', 'string') | ||
data.editLinkDisplay = message(' | data.editLinkDisplay = message('editLinkDisplay', 'string') | ||
data.historyLinkDisplay = message(' | data.historyLinkDisplay = message('historyLinkDisplay', 'string') | ||
data.purgeLinkDisplay = message(' | data.purgeLinkDisplay = message('purgeLinkDisplay', 'string') | ||
-- Create link if /doc doesn't exist. | -- Create link if /doc doesn't exist. | ||
local preload = args | local preload = args[message('preloadArg', 'string')] | ||
if not preload then | if not preload then | ||
if subjectSpace == | if env.subjectSpace == 6 then -- File namespace | ||
preload = message(' | preload = message('fileDocpagePreload', 'string') | ||
else | else | ||
preload = message(' | preload = message('docpagePreload', 'string') | ||
end | end | ||
end | end | ||
data.preload = preload | data.preload = preload | ||
data.createLinkDisplay = message(' | data.createLinkDisplay = message('createLinkDisplay', 'string') | ||
return data | return data | ||
end | end | ||
function p.renderStartBoxLinks(data) | function p.renderStartBoxLinks(data) | ||
-- | -- Render the [view][edit][history][purge] or [create] links. | ||
local ret | local ret | ||
local docTitle = data.docTitle | local docTitle = data.docTitle | ||
local title = data.title | local title = data.title | ||
if docTitle.exists then | if docTitle.exists then | ||
local viewLink = makeWikilink( | local viewLink = makeWikilink(docpage, data.viewLinkDisplay) | ||
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay) | local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay) | ||
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay) | local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay) | ||
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay) | |||
ret = '[%s] [%s] [%s] [%s]' | ret = '[%s] [%s] [%s] [%s]' | ||
ret = | ret = ret:gsub('%[', '[') -- Replace square brackets with HTML entities. | ||
ret = ret:gsub('%]', ']') | |||
ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink) | ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink) | ||
else | else | ||
lspan.wikitext(makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)) | |||
end | end | ||
end | end | ||
function p.renderStartBox(data) | function p.renderStartBox(data) | ||
-- Renders the start box html. | -- Renders the start box html. | ||
local sbox = htmlBuilder.create('div') | |||
local sbox = | |||
sbox | sbox | ||
-- ' | .css('padding-bottom', '3px') | ||
.css('border-bottom', '1px solid #aaa') | |||
.css('margin-bottom', '1ex') | |||
.newline() | |||
.tag('span') | |||
.cssText(data.headingStyleText) | |||
.css('font-weight', data.headingFontWeight) | |||
.css('font-size', data.headingFontSize) | |||
.wikitext(data.heading) | |||
if data.showLinks then | |||
sbox | sbox.tag('span') | ||
.addClass(data.linksClass) | |||
.attr('id', data.linksId) | |||
.wikitext(data.links) | |||
end | end | ||
return tostring(sbox) | return tostring(sbox) | ||
Line 524: | Line 481: | ||
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 507: | ||
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) | |||
-- | |||
end | end | ||
Line 832: | Line 631: | ||
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 |