en>Mr. Stradivarius |
en>MZMcBride |
Line 1: |
Line 1: |
| -- This module implements {{documentation}}.
| | <div class="messagebox" id="template_doc_page_viewed_directly" style="text-align: center"> |
| | | This is the [[Wikipedia:Template documentation|documentation]] page {{{1|for [[{{NAMESPACE}}:{{BASEPAGENAME}}]].}}} <div style="font-size: 90%">When it is viewed directly, links using [[Help:Variable|variables]] may appear broken; do not replace these with [[hard coding|hardcoded]] page names or URLs.</div> |
| -- Get required modules.
| | </div><includeonly>{{#if: {{{inhib|{{{inhibit|}}}}}} |<!-- skip -->|[[Category:Template documentation|{{PAGENAME}}]]}}</includeonly><noinclude> |
| local getArgs = require('Module:Arguments').getArgs
| | {{pp-semi-protected|small=yes}} |
| local htmlBuilder = require('Module:HtmlBuilder')
| | {{template doc}} |
| local messageBox = require('Module:Message box')
| | <!-- Add categories and interwikis to the /doc subpage, not here! --> |
| | | </noinclude> |
| -- Get the config table.
| |
| local cfg = mw.loadData('Module:Documentation/config')
| |
| | |
| local p = {}
| |
| | |
| -- Often-used functions.
| |
| local gsub = mw.ustring.gsub
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Helper functions
| |
| --
| |
| -- These are defined as local functions, but are made available in the p
| |
| -- table for testing purposes.
| |
| ----------------------------------------------------------------------------
| |
| | |
| local function message(cfgKey, expectType, valArray)
| |
| --[[
| |
| -- 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
| |
| -- of the type expectType.
| |
| -- 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.
| |
| -- For example, if the message cfg.fooMessage had the value 'Foo $2 bar $1.',
| |
| -- message('fooMessage', 'string', {'baz', 'qux'}) would return "Foo qux bar baz."
| |
| --]]
| |
| local msg = cfg[cfgKey]
| |
| if expectType and type(msg) ~= expectType then
| |
| error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2)
| |
| end
| |
| if not valArray then
| |
| return msg
| |
| end
| |
| | |
| local function getMessageVal(match)
| |
| match = tonumber(match)
| |
| return valArray[match] or error('message: no value found for key $' .. match .. ' in message cfg.' .. cfgKey, 4)
| |
| end
| |
| | |
| local ret = gsub(msg, '$([1-9][0-9]*)', getMessageVal)
| |
| return ret
| |
| end
| |
| | |
| p.message = message
| |
| | |
| local function makeWikilink(page, display)
| |
| if display then
| |
| return mw.ustring.format('[[%s|%s]]', page, display)
| |
| else
| |
| return mw.ustring.format('[[%s]]', page)
| |
| end
| |
| end
| |
| | |
| p.makeWikilink = makeWikilink
| |
| | |
| local function makeCategoryLink(cat, sort)
| |
| local catns = mw.site.namespaces[14].name
| |
| return makeWikilink(catns .. ':' .. cat, sort)
| |
| end
| |
| | |
| p.makeCategoryLink = makeCategoryLink
| |
| | |
| local function makeUrlLink(url, display)
| |
| return mw.ustring.format('[%s %s]', url, display)
| |
| end
| |
| | |
| p.makeUrlLink = makeUrlLink
| |
| | |
| local function makeToolbar(...)
| |
| local ret = {}
| |
| local lim = select('#', ...)
| |
| if lim < 1 then
| |
| return nil
| |
| end
| |
| for i = 1, lim do
| |
| ret[#ret + 1] = select(i, ...)
| |
| end
| |
| return '<small style="font-style: normal;">(' .. table.concat(ret, ' | ') .. ')</small>'
| |
| end
| |
| | |
| 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
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Argument processing
| |
| ----------------------------------------------------------------------------
| |
| | |
| local function makeInvokeFunc(funcName)
| |
| return function (frame)
| |
| local headingArg = message('headingArg', 'string')
| |
| local args = getArgs(frame, {
| |
| valueFunc = function (key, value)
| |
| if type(value) == 'string' then
| |
| value = value:match('^%s*(.-)%s*$') -- Remove whitespace.
| |
| if key == headingArg or value ~= '' then
| |
| return value
| |
| else
| |
| return nil
| |
| end
| |
| else
| |
| return value
| |
| end
| |
| end
| |
| })
| |
| return p[funcName](args)
| |
| end
| |
| end
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Main function
| |
| ----------------------------------------------------------------------------
| |
| | |
| p.main = makeInvokeFunc('_main')
| |
| | |
| function p._main(args)
| |
| local env = p.getEnvironment(args)
| |
| local root = htmlBuilder.create()
| |
| 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)
| |
| end
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Environment settings
| |
| ----------------------------------------------------------------------------
| |
| | |
| function p.getEnvironment(args)
| |
| -- Returns a table with information about the environment, including the title to use, the subject namespace, etc.
| |
| -- 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:
| |
| -- 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.docspace - the name of the namespace the title puts its documentation in.
| |
| -- env.templatePage - the name of the template page with no namespace or interwiki prefixes.
| |
| local env, envFuncs = {}, {}
| |
| | |
| -- 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, {
| |
| __index = function (t, key)
| |
| local envFunc = envFuncs[key]
| |
| if envFunc then
| |
| local val = envFunc()
| |
| env[key] = val
| |
| return val
| |
| else
| |
| return nil
| |
| end
| |
| end
| |
| })
| |
| | |
| -- Get the title.
| |
| function envFuncs.title()
| |
| local title
| |
| local titleArg = args[message('titleArg', 'string')]
| |
| if titleArg then
| |
| title = mw.title.new(titleArg)
| |
| if not title then
| |
| error(message('titleArgError', 'string', {titleArg}))
| |
| end
| |
| else
| |
| title = mw.title.getCurrentTitle()
| |
| end
| |
| return title
| |
| end
| |
| | |
| -- 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
| |
| 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 subpage = title.subpageText
| |
| if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
| |
| return title.baseText
| |
| else
| |
| return title.text
| |
| end
| |
| end
| |
| | |
| function envFuncs.docTitle()
| |
| local title = env.title
| |
| local docname = args[1] -- Other docname, if fed.
| |
| local docspace = env.docspace
| |
| local templatePage = env.templatePage
| |
| 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
| |
| return mw.title.new(docpage)
| |
| end
| |
| | |
| function env:grab(key)
| |
| local success, val = pcall(function() return self[key] end)
| |
| return success, val
| |
| 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
| |
| 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.
| |
| return nil
| |
| 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)
| |
| if level ~= '' then
| |
| return level
| |
| else
| |
| return nil -- The parser function returns the blank string if there is no match.
| |
| end
| |
| end
| |
| local prefixedTitle = title.prefixedText
| |
| if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then
| |
| -- 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
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Start box
| |
| ----------------------------------------------------------------------------
| |
| | |
| p.startBox = makeInvokeFunc('_startBox')
| |
| | |
| function p._startBox(args, env)
| |
| -- Generate [view][edit][history][purge] or [create] links.
| |
| local links
| |
| local content = args[message('contentArg', 'string')]
| |
| if not content then
| |
| -- No need to include the links if the documentation is on the template page itself.
| |
| local linksData = p.makeStartBoxLinksData(args, env)
| |
| links = p.renderStartBoxLinks(linksData)
| |
| end
| |
| -- Generate the start box html.
| |
| local data = p.makeStartBoxData(args, env, links)
| |
| if type(data) == 'table' then
| |
| return p.renderStartBox(data)
| |
| elseif type(data) == 'string' then
| |
| -- data is an error message.
| |
| return data
| |
| else
| |
| -- User specified no heading.
| |
| return nil
| |
| end
| |
| end
| |
| | |
| 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)
| |
| end
| |
| local docTitleSuccess, docTitle = env:grab('docTitle')
| |
| if docTitleSuccess then
| |
| data.docTitle = docTitle
| |
| else
| |
| return err(docTitle)
| |
| end
| |
| -- View, display, edit, and purge links if /doc exists.
| |
| data.viewLinkDisplay = message('viewLinkDisplay', 'string')
| |
| data.editLinkDisplay = message('editLinkDisplay', 'string')
| |
| data.historyLinkDisplay = message('historyLinkDisplay', 'string')
| |
| data.purgeLinkDisplay = message('purgeLinkDisplay', 'string')
| |
| -- Create link if /doc doesn't exist.
| |
| local preload = args[message('preloadArg', 'string')]
| |
| if not preload then
| |
| if env.subjectSpace == 6 then -- File namespace
| |
| preload = message('fileDocpagePreload', 'string')
| |
| else
| |
| preload = message('docpagePreload', 'string')
| |
| end
| |
| end
| |
| data.preload = preload
| |
| data.createLinkDisplay = message('createLinkDisplay', 'string')
| |
| return data
| |
| end
| |
| | |
| function p.renderStartBoxLinks(data)
| |
| -- Render the [view][edit][history][purge] or [create] links.
| |
| local ret
| |
| local docTitle = data.docTitle
| |
| local title = data.title
| |
| if docTitle.exists then
| |
| local viewLink = makeWikilink(docTitle.prefixedText, data.viewLinkDisplay)
| |
| local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay)
| |
| local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay)
| |
| local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
| |
| ret = '[%s] [%s] [%s] [%s]'
| |
| ret = ret:gsub('%[', '[') -- Replace square brackets with HTML entities.
| |
| ret = ret:gsub('%]', ']')
| |
| ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink)
| |
| else
| |
| ret = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)
| |
| end
| |
| end
| |
| | |
| function p.makeStartBoxData(args, env, links)
| |
| local subjectSpace = env.subjectSpace
| |
| local data = {}
| |
|
| |
| -- Heading
| |
| local heading = args[message('headingArg', 'string')] -- Blank values are not removed.
| |
| if heading == '' then
| |
| -- Don't display the start box if the heading arg is defined but blank.
| |
| return nil
| |
| end
| |
| if heading then
| |
| data.heading = heading
| |
| elseif subjectSpace == 10 then -- Template namespace
| |
| data.heading = message('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string')
| |
| elseif subjectSpace == 828 then -- Module namespace
| |
| data.heading = message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string')
| |
| elseif subjectSpace == 6 then -- File namespace
| |
| data.heading = message('fileNamespaceHeading', 'string')
| |
| else
| |
| data.heading = message('otherNamespacesHeading', 'string')
| |
| end
| |
|
| |
| -- Heading CSS
| |
| local headingStyle = args[message('headingStyleArg', 'string')]
| |
| if headingStyle then
| |
| data.headingStyleText = headingStyle
| |
| elseif subjectSpace == 10 then
| |
| -- We are in the template or template talk namespaces.
| |
| data.headingFontWeight = 'bold'
| |
| data.headingFontSize = '125%'
| |
| else
| |
| data.headingFontSize = '150%'
| |
| end
| |
|
| |
| -- [view][edit][history][purge] or [create] links.
| |
| if links then
| |
| data.linksClass = message('startBoxLinkclasses', 'string')
| |
| data.linksId = message('startBoxLinkId', 'string')
| |
| data.links = links
| |
| end
| |
|
| |
| return data
| |
| end
| |
| | |
| function p.renderStartBox(data)
| |
| -- Renders the start box html.
| |
| local sbox = htmlBuilder.create('div')
| |
| 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)
| |
| local links = data.links
| |
| if links then
| |
| sbox.tag('span')
| |
| .addClass(data.linksClass)
| |
| .attr('id', data.linksId)
| |
| .wikitext(links)
| |
| end
| |
| return tostring(sbox)
| |
| end
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Documentation content
| |
| ----------------------------------------------------------------------------
| |
| | |
| p.content = makeInvokeFunc('_content')
| |
| | |
| 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
| |
| -- The line breaks below are necessary so that "=== Headings ===" at the start and end
| |
| -- of docs are interpreted correctly.
| |
| return '\n' .. (content or '') .. '\n'
| |
| end
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- End box
| |
| ----------------------------------------------------------------------------
| |
| | |
| p.endBox = makeInvokeFunc('_endBox')
| |
| | |
| function p._endBox(args, env)
| |
| local title = env.title
| |
| local subjectSpace = env.subjectSpace
| |
| | |
| -- 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
| |
| 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
| |
| end
| |
| | |
| -- 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 = ''
| |
| if linkBox then
| |
| -- Use custom link box content if it is defined.
| |
| text = text .. linkBox
| |
| else
| |
| if docExist then
| |
| -- /doc exists; link to it.
| |
| 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 />'
| |
| 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 />'
| |
| 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
| |
| fmargs.text = text
| |
| | |
| -- Return the fmbox output.
| |
| return messageBox.main('fmbox', fmargs)
| |
| end
| |
| | |
| ----------------------------------------------------------------------------
| |
| -- Tracking categories
| |
| ----------------------------------------------------------------------------
| |
| | |
| function p.addTrackingCategories(env)
| |
| -- Check if {{documentation}} is transcluded on a /doc or /testcases page.
| |
| local title = env.title
| |
| local ret = ''
| |
| local subpage = title.subpageText
| |
| if message('displayStrangeUsageCategory', 'boolean') and (subpage == message('docSubpage', 'string') or subpage == message('testcasesSubpage', 'string')) then
| |
| local sort = (title.namespace == 0 and message('strangeUsageCategoryMainspaceSort', 'string') or '') .. title.prefixedText -- Sort on namespace.
| |
| ret = ret .. makeCategoryLink(message('strangeUsageCategory', 'string'), sort)
| |
| end
| |
| return ret
| |
| end
| |
| | |
| return p
| |