TEPwiki

Module:Documentation: Difference between revisions

Module Discussion

Module:Documentation (view source)

Revision as of 17:30, 11 January 2024

18,668 bytes added ,  5 months ago
m
1 revision imported from wikipedia:Module:Documentation
(use the cfg key only with formatMessage in order to generate more descriptive error messages)
m (1 revision imported from wikipedia:Module:Documentation)
 
(146 intermediate revisions by 27 users not shown)
Line 3:
-- Get required modules.
local getArgs = require('Module:Arguments').getArgs
local htmlBuilder = require('Module:HtmlBuilder')
local messageBox = require('Module:Message box')
local libraryUtil = require('libraryUtil')
 
-- Get the config table.
Line 11 ⟶ 8:
 
local p = {}
 
-- Constants.
local currentTitle = mw.title.getCurrentTitle()
local subjectSpace = mw.site.namespaces[currentTitle.namespace].subject.id -- The number of the current subject namespace.
 
-- Often-used functions.
local gsubugsub = mw.ustring.gsub
local checkTypeformat = libraryUtilmw.checkTypeustring.format
 
----------------------------------------------------------------------------
-- Helper functions
--
-- These are defined as local functions, but are made available in the p
-- table for testing purposes.
----------------------------------------------------------------------------
 
local function formatMessagemessage(cfgKey, valArray, expectType)
--[[
-- FormatsGets 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
-- Values from valArray can be specified in the message by using $1 for [1], $2 for [2], etc.
-- of the type expectType. The default type for expectType is 'string'.
-- For example, if the message cfg.fooMessage had the value 'Foo $2 bar $1.',
-- If the table valArray is present, strings such as $1, $2 etc. in the
-- formatMessage('fooMessage', {'baz', 'qux'}) would return "Foo qux bar baz."
-- message are substituted with values from the table keys [1], [2] etc.
-- For example, if the message "foo-message" had the value 'Foo $2 bar $1.',
-- message('foo-message', {'baz', 'qux'}) would return "Foo qux bar baz."
--]]
local msg = cfg[cfgKey]
checkType('formatMessage', 1, cfgKey, 'string')
expectType = expectType or 'string'
checkType('formatMessage', 2, valArray, 'table')
if type(msg) ~= expectType then
local msg = cfg[cfgKey] or error('formatMessage: no message found for cfg key "' .. cfgKey .. '"', 2)
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('formatMessagemessage: no value found for key $' .. match .. ' in message cfg.' .. cfgKey, 24)
end
 
localreturn ret = gsubugsub(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(...)
Line 70 ⟶ 81:
ret[#ret + 1] = select(i, ...)
end
-- 'documentation-toolbar'
return '<small style="font-style: normal;">(' .. table.concat(ret, ' &#124; ') .. ')</small>'
return format(
'<span class="%s">(%s)</span>',
message('toolbar-class'),
table.concat(ret, ' &#124; ')
)
end
 
p.makeToolbar = makeToolbar
 
----------------------------------------------------------------------------
Line 79 ⟶ 97:
local function makeInvokeFunc(funcName)
return function (frame)
local headingArg = cfg.headingArg
local args = getArgs(frame, {
valueFunc = function (key, value)
if type(value) == 'string' then
value = value:match('^%s*(.-)%s*$') -- Remove whitespace.
if key == headingArg'heading' or value ~= '' then
return value
else
Line 99 ⟶ 116:
 
----------------------------------------------------------------------------
-- MainEntry functionspoints
----------------------------------------------------------------------------
 
function p.nonexistent(frame)
if mw.title.getCurrentTitle().subpageText == 'testcases' then
return frame:expandTemplate{title = 'module test cases notice'}
else
return p.main(frame)
end
end
 
p.main = makeInvokeFunc('_main')
 
function p._main(args)
--[[
local root = htmlBuilder.create()
-- This function defines logic flow for the module.
-- @args - table of arguments passed by the user
--]]
local env = p.getEnvironment(args)
local root = mw.html.create()
root
.:wikitext(p.protectionTemplate_getModuleWikitext(args, env))
.:wikitext(p.sandboxNoticeprotectionTemplate(argsenv))
:wikitext(p.sandboxNotice(args, env))
-- This div tag is from {{documentation/start box}}, but moving it here
:tag('div')
-- so that we don't have to worry about unclosed tags.
-- 'documentation-container'
.tag('div')
:addClass(message('container'))
.attr('id', cfg.mainDivId)
:attr('role', 'complementary')
.addClass(cfg.mainDivClasses)
:attr('aria-labelledby', args.heading ~= '' and 'documentation-heading' or nil)
.wikitext(p._startBox(args))
:attr('aria-label', args.heading == '' and 'Documentation' or nil)
.wikitext(p._content(args))
.tag:newline('div')
:tag('div')
.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
-- 'documentation'
.done()
:addClass(message('main-div-classes'))
.done()
:newline()
.wikitext(p._endBox(args))
. :wikitext(p.addTrackingCategories_startBox(args, env))
:wikitext(p._content(args, env))
return tostring(root)
:tag('div')
-- 'documentation-clear'
:addClass(message('clear'))
:done()
:newline()
:done()
:wikitext(p._endBox(args, env))
:done()
:wikitext(p.addTrackingCategories(env))
-- 'Module:Documentation/styles.css'
return mw.getCurrentFrame():extensionTag (
'templatestyles', '', {src=cfg['templatestyles']
}) .. tostring(root)
end
 
----------------------------------------------------------------------------
function p.sandboxNotice(args)
-- Environment settings
local sandboxNoticeTemplate = cfg.sandboxNoticeTemplate
----------------------------------------------------------------------------
if not (sandboxNoticeTemplate and currentTitle.subpageText == cfg.sandboxSubpage) then
 
return nil
function p.getEnvironment(args)
--[[
-- Returns a table with information about the environment, including title
-- objects and other namespace- or path-related data.
-- @args - table of arguments passed by the user
--
-- Title objects include:
-- env.title - the page we are making documentation for (usually the current title)
-- env.templateTitle - the template (or module, file, etc.)
-- env.docTitle - the /doc subpage.
-- env.sandboxTitle - the /sandbox subpage.
-- env.testcasesTitle - the /testcases subpage.
--
-- Data includes:
-- env.protectionLevels - the protection levels table of the title object.
-- env.subjectSpace - the number of the title's subject namespace.
-- env.docSpace - the number of the namespace the title puts its documentation in.
-- env.docpageBase - the text of the base page of the /doc, /sandbox and /testcases pages, with namespace.
-- env.compareUrl - URL of the Special:ComparePages page comparing the sandbox with the template.
--
-- All table lookups are passed through pcall so that errors are caught. If an error occurs, the value
-- returned will be nil.
--]]
local env, envFuncs = {}, {}
 
-- Set up the metatable. If triggered we call the corresponding function in the envFuncs table. The value
-- returned by that function is memoized in the env table so that we don't call any of the functions
-- more than once. (Nils won't be memoized.)
setmetatable(env, {
__index = function (t, key)
local envFunc = envFuncs[key]
if envFunc then
local success, val = pcall(envFunc)
if success then
env[key] = val -- Memoise the value.
return val
end
end
return nil
end
})
 
function envFuncs.title()
-- The title object for the current page, or a test page passed with args.page.
local title
local titleArg = args.page
if titleArg then
title = mw.title.new(titleArg)
else
title = mw.title.getCurrentTitle()
end
return title
end
 
function envFuncs.templateTitle()
--[[
-- The template (or module, etc.) title object.
-- Messages:
-- 'sandbox-subpage' --> 'sandbox'
-- 'testcases-subpage' --> 'testcases'
--]]
local subjectSpace = env.subjectSpace
local title = env.title
local subpage = title.subpageText
if subpage == message('sandbox-subpage') or subpage == message('testcases-subpage') then
return mw.title.makeTitle(subjectSpace, title.baseText)
else
return mw.title.makeTitle(subjectSpace, title.text)
end
end
 
function envFuncs.docTitle()
--[[
-- Title object of the /doc subpage.
-- Messages:
-- 'doc-subpage' --> 'doc'
--]]
local title = env.title
local docname = args[1] -- User-specified doc page.
local docpage
if docname then
docpage = docname
else
docpage = env.docpageBase .. '/' .. message('doc-subpage')
end
return mw.title.new(docpage)
end
function envFuncs.sandboxTitle()
--[[
-- Title object for the /sandbox subpage.
-- Messages:
-- 'sandbox-subpage' --> 'sandbox'
--]]
return mw.title.new(env.docpageBase .. '/' .. message('sandbox-subpage'))
end
function envFuncs.testcasesTitle()
--[[
-- Title object for the /testcases subpage.
-- Messages:
-- 'testcases-subpage' --> 'testcases'
--]]
return mw.title.new(env.docpageBase .. '/' .. message('testcases-subpage'))
end
 
function envFuncs.protectionLevels()
-- The protection levels table of the title object.
return env.title.protectionLevels
end
 
function envFuncs.subjectSpace()
-- The subject namespace number.
return mw.site.namespaces[env.title.namespace].subject.id
end
 
function envFuncs.docSpace()
-- The documentation namespace number. For most namespaces this is the
-- same as the subject namespace. However, pages in the Article, File,
-- MediaWiki or Category namespaces must have their /doc, /sandbox and
-- /testcases pages in talk space.
local subjectSpace = env.subjectSpace
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
return subjectSpace + 1
else
return subjectSpace
end
end
 
function envFuncs.docpageBase()
-- The base page of the /doc, /sandbox, and /testcases subpages.
-- For some namespaces this is the talk page, rather than the template page.
local templateTitle = env.templateTitle
local docSpace = env.docSpace
local docSpaceText = mw.site.namespaces[docSpace].name
-- Assemble the link. docSpace is never the main namespace, so we can hardcode the colon.
return docSpaceText .. ':' .. templateTitle.text
end
function envFuncs.compareUrl()
-- Diff link between the sandbox and the main template using [[Special:ComparePages]].
local templateTitle = env.templateTitle
local sandboxTitle = env.sandboxTitle
if templateTitle.exists and sandboxTitle.exists then
local compareUrl = mw.uri.canonicalUrl(
'Special:ComparePages',
{ page1 = templateTitle.prefixedText, page2 = sandboxTitle.prefixedText}
)
return tostring(compareUrl)
else
return nil
end
end
 
return env
end
 
----------------------------------------------------------------------------
-- Auxiliary templates
----------------------------------------------------------------------------
 
p.getModuleWikitext = makeInvokeFunc('_getModuleWikitext')
 
function p._getModuleWikitext(args, env)
local currentTitle = mw.title.getCurrentTitle()
if currentTitle.contentModel ~= 'Scribunto' then return end
pcall(require, currentTitle.prefixedText) -- if it fails, we don't care
local moduleWikitext = package.loaded["Module:Module wikitext"]
if moduleWikitext then
return moduleWikitext.main()
end
local frame = mw.getCurrentFrame()
local notice = htmlBuilder.create()
notice
.tag('div')
.css('clear', 'both')
.done()
.wikitext(frame:expandTemplate{title = sandboxNoticeTemplate, args = {[cfg.sandboxNoticeLivepageParam] = args[cfg.livepageArg]}})
return tostring(notice)
end
 
function p.protectionTemplatesandboxNotice(args, env)
--[=[
local protectionTemplate = cfg.protectionTemplate
-- Generates a sandbox notice for display above sandbox pages.
if not (protectionTemplate and currentTitle.namespace == 10) then
-- @args - a table of arguments passed by the user
-- Don't display the protection template if we are not in the template namespace.
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
--
-- Messages:
-- 'sandbox-notice-image' --> '[[File:Sandbox.svg|50px|alt=|link=]]'
-- 'sandbox-notice-blurb' --> 'This is the $1 for $2.'
-- 'sandbox-notice-diff-blurb' --> 'This is the $1 for $2 ($3).'
-- 'sandbox-notice-pagetype-template' --> '[[Wikipedia:Template test cases|template sandbox]] page'
-- 'sandbox-notice-pagetype-module' --> '[[Wikipedia:Template test cases|module sandbox]] page'
-- 'sandbox-notice-pagetype-other' --> 'sandbox page'
-- 'sandbox-notice-compare-link-display' --> 'diff'
-- 'sandbox-notice-testcases-blurb' --> 'See also the companion subpage for $1.'
-- 'sandbox-notice-testcases-link-display' --> 'test cases'
-- 'sandbox-category' --> 'Template sandboxes'
-- 'module-sandbox-category' --> 'Module sandboxes'
-- 'other-sandbox-category' --> 'Sandboxes outside of template or module namespace'
--]=]
local title = env.title
local sandboxTitle = env.sandboxTitle
local templateTitle = env.templateTitle
local subjectSpace = env.subjectSpace
if not (subjectSpace and title and sandboxTitle and templateTitle
and mw.title.equals(title, sandboxTitle)) then
return nil
end
-- Build the table of arguments to pass to {{ombox}}. We need just two fields, "image" and "text".
local frame = mw.getCurrentFrame()
local omargs = {}
local function getProtectionLevel(protectionType)
omargs.image = message('sandbox-notice-image')
-- Gets the protection level for the current page.
-- Get the text. We start with the opening blurb, which is something like
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType)
-- "This is the template sandbox for [[Template:Foo]] (diff)."
if level ~= '' then
local text = ''
return level
local pagetype, sandboxCat
if subjectSpace == 10 then
pagetype = message('sandbox-notice-pagetype-template')
sandboxCat = message('sandbox-category')
elseif subjectSpace == 828 then
pagetype = message('sandbox-notice-pagetype-module')
sandboxCat = message('module-sandbox-category')
else
pagetype = message('sandbox-notice-pagetype-other')
sandboxCat = message('other-sandbox-category')
end
local templateLink = makeWikilink(templateTitle.prefixedText)
local compareUrl = env.compareUrl
if compareUrl then
local compareDisplay = message('sandbox-notice-compare-link-display')
local compareLink = makeUrlLink(compareUrl, compareDisplay)
text = text .. message('sandbox-notice-diff-blurb', {pagetype, templateLink, compareLink})
else
text = text .. message('sandbox-notice-blurb', {pagetype, templateLink})
end
-- Get the test cases page blurb if the page exists. This is something like
-- "See also the companion subpage for [[Template:Foo/testcases|test cases]]."
local testcasesTitle = env.testcasesTitle
if testcasesTitle and testcasesTitle.exists then
if testcasesTitle.contentModel == "Scribunto" then
local testcasesLinkDisplay = message('sandbox-notice-testcases-link-display')
local testcasesRunLinkDisplay = message('sandbox-notice-testcases-run-link-display')
local testcasesLink = makeWikilink(testcasesTitle.prefixedText, testcasesLinkDisplay)
local testcasesRunLink = makeWikilink(testcasesTitle.talkPageTitle.prefixedText, testcasesRunLinkDisplay)
text = text .. '<br />' .. message('sandbox-notice-testcases-run-blurb', {testcasesLink, testcasesRunLink})
else
local testcasesLinkDisplay = message('sandbox-notice-testcases-link-display')
return nil -- The parser function returns the blank string if there is no match.
local testcasesLink = makeWikilink(testcasesTitle.prefixedText, testcasesLinkDisplay)
text = text .. '<br />' .. message('sandbox-notice-testcases-blurb', {testcasesLink})
end
end
if getProtectionLevel('move') == 'sysop' or getProtectionLevel('edit') then
-- Add the sandbox to the sandbox category.
-- The page is full-move protected, or full, template, or semi-protected.
omargs.text = text .. makeCategoryLink(sandboxCat)
return frame:expandTemplate{title = protectionTemplate, args = cfg.protectionTemplateArgs}
 
-- 'documentation-clear'
return '<div class="' .. message('clear') .. '"></div>'
.. require('Module:Message box').main('ombox', omargs)
end
 
function p.protectionTemplate(env)
-- Generates the padlock icon in the top right.
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- Messages:
-- 'protection-template' --> 'pp-template'
-- 'protection-template-args' --> {docusage = 'yes'}
local protectionLevels = env.protectionLevels
if not protectionLevels then
return nil
end
local editProt = protectionLevels.edit and protectionLevels.edit[1]
local moveProt = protectionLevels.move and protectionLevels.move[1]
if editProt then
-- The page is edit-protected.
return require('Module:Protection banner')._main{
message('protection-reason-edit'), small = true
}
elseif moveProt and moveProt ~= 'autoconfirmed' then
-- The page is move-protected but not edit-protected. Exclude move
-- protection with the level "autoconfirmed", as this is equivalent to
-- no move protection at all.
return require('Module:Protection banner')._main{
action = 'move', small = true
}
else
return nil
end
return nil
end
 
----------------------------------------------------------------------------
-- Start box
----------------------------------------------------------------------------
 
p.startBox = makeInvokeFunc('_startBox')
 
function p._startBox(args, env)
--[[
-- Arg processing from {{documentation}}.
-- This function generates the start box.
local preload = args[cfg.preloadArg] -- Allow custom preloads.
-- @args - a table of arguments passed by the user
local heading = args[cfg.headingArg] -- Blank values are not removed.
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
local headingStyle = args[cfg.headingStyleArg]
--
local content = args[cfg.contentArg]
-- The actual work is done by p.makeStartBoxLinksData and p.renderStartBoxLinks which make
local docspace = p.docspace()
-- the [view] [edit] [history] [purge] links, and by p.makeStartBoxData and p.renderStartBox
local docname = args[1] -- Other docname, if fed.
-- which generate the box HTML.
local templatePage = p.templatePage()
--]]
 
env = env or p.getEnvironment(args)
-- Arg processing from {{documentation/start box2}}.
local docpagelinks
local content = args.content
if docname then
if not content or args[1] then
docpage = docname
-- No need to include the links if the documentation is on the template page itself.
local linksData = p.makeStartBoxLinksData(args, env)
if linksData then
links = p.renderStartBoxLinks(linksData)
end
end
-- Generate the start box html.
local data = p.makeStartBoxData(args, env, links)
if data then
return p.renderStartBox(data)
else
-- User specified no heading.
local namespace = docspace or currentTitle.nsText
return nil
local pagename = templatePage or currentTitle.text
docpage = namespace .. ':' .. pagename .. '/' .. cfg.docSubpage
end
end
local docTitle = mw.title.new(docpage)
local docExist = docTitle.exists
-- Output from {{documentation/start box}}.
 
function p.makeStartBoxLinksData(args, env)
-- First, check the heading parameter.
--[[
if heading == '' then
-- Does initial processing of data to make the [view] [edit] [history] [purge] links.
-- Heading is defined but blank, so do nothing.
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
--
-- Messages:
-- 'view-link-display' --> 'view'
-- 'edit-link-display' --> 'edit'
-- 'history-link-display' --> 'history'
-- 'purge-link-display' --> 'purge'
-- 'module-preload' --> 'Template:Documentation/preload-module-doc'
-- 'docpage-preload' --> 'Template:Documentation/preload'
-- 'create-link-display' --> 'create'
--]]
local subjectSpace = env.subjectSpace
local title = env.title
local docTitle = env.docTitle
if not title or not docTitle then
return nil
end
if docTitle.isRedirect then
docTitle = docTitle.redirectTarget
end
 
-- BuildCreate thelink startif box/doc divdoesn't exist.
local sboxpreload = htmlBuilderargs.create('div')preload
if not preload then
sbox
if subjectSpace == 828 then -- Module namespace
.css('padding-bottom', '3px')
preload = message('module-preload')
.css('border-bottom', '1px solid #aaa')
else
.css('margin-bottom', '1ex')
preload = message('docpage-preload')
end
end
return {
title = title,
docTitle = docTitle,
-- View, display, edit, and purge links if /doc exists.
viewLinkDisplay = message('view-link-display'),
editLinkDisplay = message('edit-link-display'),
historyLinkDisplay = message('history-link-display'),
purgeLinkDisplay = message('purge-link-display'),
preload = preload,
createLinkDisplay = message('create-link-display')
}
end
 
function p.renderStartBoxLinks(data)
-- Make the heading.
--[[
local hspan = sbox.tag('span')
-- Generates the [view][edit][history][purge] or [create][purge] links from the data table.
if headingStyle then
-- @data - a table of data generated by p.makeStartBoxLinksData
hspan.cssText(headingStyle)
--]]
elseif subjectSpace == 10 then
local docTitle = data.docTitle
-- We are in the template or template talk namespaces.
-- yes, we do intend to purge the template page on which the documentation appears
hspan
local purgeLink = makeWikilink("Special:Purge/" .. data.title.prefixedText, data.purgeLinkDisplay)
.css('font-weight', 'bold')
.css('fond-size', '125%')
if docTitle.exists then
local viewLink = makeWikilink(docTitle.prefixedText, data.viewLinkDisplay)
local editLink = makeWikilink("Special:EditPage/" .. docTitle.prefixedText, data.editLinkDisplay)
local historyLink = makeWikilink("Special:PageHistory/" .. docTitle.prefixedText, data.historyLinkDisplay)
return "&#91;" .. viewLink .. "&#93; &#91;" .. editLink .. "&#93; &#91;" .. historyLink .. "&#93; &#91;" .. purgeLink .. "&#93;"
else
local createLink = makeUrlLink(docTitle:canonicalUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)
hspan.css('font-size', '150%')
return "&#91;" .. createLink .. "&#93; &#91;" .. purgeLink .. "&#93;"
end
return ret
end
 
function p.makeStartBoxData(args, env, links)
--[=[
-- Does initial processing of data to pass to the start-box render function, p.renderStartBox.
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- @links - a string containing the [view][edit][history][purge] links - could be nil if there's an error.
--
-- Messages:
-- 'documentation-icon-wikitext' --> '[[File:Test Template Info-Icon - Version (2).svg|50px|link=|alt=]]'
-- 'template-namespace-heading' --> 'Template documentation'
-- 'module-namespace-heading' --> 'Module documentation'
-- 'file-namespace-heading' --> 'Summary'
-- 'other-namespaces-heading' --> 'Documentation'
-- 'testcases-create-link-display' --> 'create'
--]=]
local subjectSpace = env.subjectSpace
if not subjectSpace then
-- Default to an "other namespaces" namespace, so that we get at least some output
-- if an error occurs.
subjectSpace = 2
end
local data = {}
-- Heading
local heading = args.heading -- 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" has= data.heading
hspan.wikitext(heading)
elseif subjectSpace == 10 then -- Template namespace
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('template-namespace-heading')
hspan.wikitext(cfg.documentationIconWikitext .. ' ' .. cfg.templateNamespaceHeading)
elseif subjectSpace == 828 then -- Module namespace
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('module-namespace-heading')
hspan.wikitext(cfg.documentationIconWikitext .. ' ' .. cfg.moduleNamespaceHeading)
elseif subjectSpace == 6 then -- File namespace
data.heading = message('file-namespace-heading')
hspan.wikitext(cfg.fileNamespaceHeading)
else
data.heading = message('other-namespaces-heading')
hspan.wikitext(cfg.otherNamespaceHeading)
end
 
-- Heading CSS
-- Add the [view][edit][history][purge] or [create] links.
local headingStyle = args['heading-style']
-- Check for the content parameter first, as we don't need the links if the documentation
if headingStyle then
-- content is being entered directly onto the template page.
data.headingStyleText = headingStyle
if not content then
else
local lspan = sbox.tag('span') -- lspan is short for "link span".
-- 'documentation-heading'
lspan
data.headingClass = message('main-div-heading-class')
.addClass(cfg.startBoxLinkclasses)
.attr('id', cfg.startBoxLinkId)
if docExist then
local viewLink = makeWikilink(docpage, cfg.viewLinkDisplay)
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, cfg.editLinkDisplay)
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, cfg.historyLinkDisplay)
local purgeLink = makeUrlLink(currentTitle:fullUrl{action = 'purge'}, cfg.purgeLinkDisplay)
local text = '[%s] [%s] [%s] [%s]'
text = text:gsub('%[', '&#91;') -- Replace square brackets with HTML entities.
text = text:gsub('%]', '&#93;')
lspan.wikitext(mw.ustring.format(text, viewLink, editLink, historyLink, purgeLink))
else
if not preload then
if subjectSpace == 6 then -- File namespace
preload = cfg.fileDocpagePreload
else
preload = cfg.docpagePreload
end
end
lspan.wikitext(makeUrlLink(docTitle:fullUrl{action = 'edit', preload = preload}, cfg.createLinkDisplay))
end
end
-- Data for the [view][edit][history][purge] or [create] links.
if links then
-- 'mw-editsection-like plainlinks'
data.linksClass = message('start-box-link-classes')
data.links = links
end
return data
end
 
function p.renderStartBox(data)
-- Renders the start box html.
-- @data - a table of data generated by p.makeStartBoxData.
local sbox = mw.html.create('div')
sbox
-- 'documentation-startbox'
:addClass(message('start-box-class'))
:newline()
:tag('span')
:addClass(data.headingClass)
:attr('id', 'documentation-heading')
:cssText(data.headingStyleText)
: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)
-- Displays the documentation contents
local content = args[cfg.contentArg]
-- @args - a table of arguments passed by the user
if not content then
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
local docpage = args[1]
env = env or p.getEnvironment(args)
if docpage and mw.title.new(docpage).exists then
local framedocTitle = mwenv.getCurrentFrame()docTitle
local content = args.content
content = frame:preprocess('{{ ' .. docpage .. ' }}')
if not content and docTitle and docTitle.exists then
else
content = args._content or mw.getCurrentFrame():expandTemplate{title = docTitle.prefixedText}
docpage = p.docspace() .. ':' .. p.templatePage() .. '/' .. cfg.docSubpage
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
Line 281 ⟶ 663:
end
 
p.endBoxcontentTitle = makeInvokeFunc('_endBox_contentTitle')
 
function p._endBox(args)
-- Argument processing in {{documentation}}.
local content = args[cfg.contentArg]
local linkBox = args[cfg.linkBoxArg] -- So "link box=off" works.
local docspace = p.docspace()
local docname = args[1] -- Other docname, if fed.
local templatePage = p.templatePage()
 
function p._contentTitle(args, env)
-- Argument processing in {{documentation/end box2}}.
env = env or p.getEnvironment(args)
local docpageRoot = (docspace or currentTitle.nsText) .. ':' .. (templatePage or currentTitle.text)
local docpagedocTitle = env.docTitle
if not args.content and docTitle and docTitle.exists then
if docname then
return docTitle.prefixedText
docpage = docname
else
return ''
docpage = docpageRoot .. '/' .. cfg.docSubpage
end
end
local docTitle = mw.title.new(docpage)
 
local docExist = docTitle.exists
----------------------------------------------------------------------------
local docnameFed = args[1] and true
-- End box
local sandbox = docpageRoot .. '/' .. cfg.sandboxSubpage
----------------------------------------------------------------------------
local testcases = docpageRoot .. '/' .. cfg.testcasesSubpage
 
templatePage = currentTitle.nsText .. ':' .. templatePage
p.endBox = makeInvokeFunc('_endBox')
 
function p._endBox(args, env)
-- Output from {{documentation/end box}}
--[=[
-- This function generates the end box (also known as the link box).
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
--
--]=]
-- Get environment data.
-- First, check whether we should output the end box at all. Add the end box by default if the documentation
env = env or p.getEnvironment(args)
-- exists or if we are in the user, module or template namespaces.
local subjectSpace = env.subjectSpace
if linkBox == cfg.linkBoxOff or not (docExist or subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10) then
local docTitle = env.docTitle
if not subjectSpace or not docTitle then
return nil
end
-- 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.
local linkBox = args['link box']
if linkBox == 'off'
or not (
docTitle.exists
or subjectSpace == 2
or subjectSpace == 828
or subjectSpace == 10
)
then
return nil
end
 
-- Assemble the argumentslink for {{fmbox}}box.
local fmargs = {}
fmargs[cfg.fmboxIdParam] = cfg.fmboxId -- Sets fmargs.id = 'documentation-meta-data'
fmargs[cfg.fmboxImageParam] = cfg.fmboxImageNone -- Sets fmargs.image = 'none'
fmargs[cfg.fmboxStyleParam] = cfg.fmboxStyle -- Sets fmargs.style = 'background-color: #ecfcf4'
fmargs[cfg.fmboxTextstyleParam] = cfg.fmboxTextstyle -- 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
text = text .. (p.makeDocPageBlurb(args, env) or '') -- "This documentation is transcluded from [[Foo]]."
if docExist then
if subjectSpace == 2 or subjectSpace == 10 or subjectSpace == 828 then
-- /doc exists; link to it.
-- We are in the user, template or module namespaces.
local docLink = makeWikilink(docpage)
-- Add sandbox and testcases links.
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, cfg.editLinkDisplay)
-- "Editors can experiment in this template's sandbox and testcases pages."
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, cfg.historyLinkDisplay)
text = text .. formatMessage('transcludedFromBlurb'p.makeExperimentBlurb(args, {docLink}env) ..or ' ' .. makeToolbar(editLink, historyLink) .. '<br />'
if not args.content and not args[1] then
elseif subjectSpace == 828 then
-- /doc"Please doesadd notcategories exist;to askthe to create/doc itsubpage."
-- Don't show this message with inline docs or with an explicitly specified doc page,
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = cfg.modulePreload}, cfg.createLinkDisplay)
-- as then it is unclear where to add the categories.
text = text .. formatMessage('createModuleDocBlurb', {createLink}) .. '<br />'
text = text .. (p.makeCategoriesBlurb(args, env) or '')
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 cfg.modulePossessive or cfg.templatePossessive
local sandboxTitle = mw.title.new(sandbox)
if sandboxTitle.exists then
local sandboxLink = makeWikilink(sandbox, cfg.sandboxLinkDisplay)
local sandboxEditLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit'}, cfg.sandboxEditLinkDisplay)
local compareLink = makeUrlLink(mw.title.new('Special:ComparePages'):fullUrl{page1 = templatePage, page2 = sandbox}, cfg.compareLinkDisplay)
sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
else
local sandboxPreload = subjectSpace == 828 and cfg.moduleSandboxPreload or cfg.templateSandboxPreload
local sandboxCreateLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}, cfg.sandboxCreateLinkDisplay)
local mirrorSummary = formatMessage('mirrorEditSummary', {makeWikilink(templatePage)})
local mirrorLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = templatePage, summary = mirrorSummary}, cfg.mirrorLinkDisplay)
sandboxLinks = cfg.sandboxLinkDisplay .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
end
local testcaseTitle = mw.title.new(testcases)
if testcaseTitle.exists then
local testcasesLink = makeWikilink(testcases, cfg.testcasesLinkDisplay)
local testcasesEditLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit'}, cfg.testcasesEditLinkDisplay)
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
else
local testcasesPreload = subjectSpace == 828 and cfg.moduleTestcasesPreload or cfg.templateTestcasesPreload
local testcasesCreateLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit', preload = testcasesPreload}, cfg.testcasesCreateLinkDisplay)
testcasesLinks = cfg.testcasesLinkDisplay .. ' ' .. makeToolbar(testcasesCreateLink)
end
text = text .. formatMessage('experimentBlurb', {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, cfg.docLinkDisplay)
text = text .. formatMessage('addCategoriesBlurb', {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 = cfg.templatePagetype
elseif subjectSpace == 828 then
pagetype = cfg.modulePagetype
else
pagetype = cfg.defaultPagetype
end
text = text .. ' ' .. makeWikilink('Special:PrefixIndex/' .. templatePage .. '/', formatMessage('subpagesLinkDisplay', {pagetype}))
end
-- Show the "print" link if it exists.
local printPage = templatePage .. '/' .. cfg.printSubpage
local printTitle = mw.title.new(printPage)
if printTitle.exists then
local printLink = makeWikilink(printPage, cfg.printLinkDisplay)
text = text .. '<br />' .. formatMessage('printBlurb', {printLink})
.. (cfg.displayPrintCategory and makeCategoryLink(cfg.printCategory) or '')
end
text = text .. ' ' .. (p.makeSubpagesBlurb(args, env) or '') --"Subpages of this template"
end
end
fmargs.text = text
local box = mw.html.create('div')
-- 'documentation-metadata'
box:attr('role', 'note')
:addClass(message('end-box-class'))
-- 'plainlinks'
:addClass(message('end-box-plainlinks'))
:wikitext(text)
:done()
 
return '\n' .. tostring(box)
-- Return the fmbox output.
return messageBox.main('fmbox', fmargs)
end
 
function p.addTrackingCategoriesmakeDocPageBlurb(args, env)
--[=[
-- Check if {{documentation}} is transcluded on a /doc or /testcases page.
-- Makes the blurb "This documentation is transcluded from [[Template:Foo]] (edit, history)".
local ret = ''
-- @args - a table of arguments passed by the user
local subpage = currentTitle.subpageText
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
if cfg.displayStrangeUsageCategory and (subpage == cfg.docSubpage or subpage == cfg.testcasesSubpage) then
--
local sort = (currentTitle.namespace == 0 and cfg.strangeUsageCategoryMainspaceSort or '') .. currentTitle.prefixedText -- Sort on namespace.
-- Messages:
ret = ret .. makeCategoryLink(cfg.strangeUsageCategory, sort)
-- 'edit-link-display' --> 'edit'
-- 'history-link-display' --> 'history'
-- 'transcluded-from-blurb' -->
-- 'The above [[Wikipedia:Template documentation|documentation]]
-- is [[Help:Transclusion|transcluded]] from $1.'
-- 'module-preload' --> 'Template:Documentation/preload-module-doc'
-- 'create-link-display' --> 'create'
-- 'create-module-doc-blurb' -->
-- 'You might want to $1 a documentation page for this [[Wikipedia:Lua|Scribunto module]].'
--]=]
local docTitle = env.docTitle
if not docTitle then
return nil
end
if docTitle.exists then
-- /doc exists; link to it.
local docLink = makeWikilink(docTitle.prefixedText)
local editDisplay = message('edit-link-display')
local editLink = makeWikilink("Special:EditPage/" .. docTitle.prefixedText, editDisplay)
local historyDisplay = message('history-link-display')
local historyLink = makeWikilink("Special:PageHistory/" .. docTitle.prefixedText, historyDisplay)
return message('transcluded-from-blurb', {docLink})
.. ' '
.. makeToolbar(editLink, historyLink)
.. '<br />'
elseif env.subjectSpace == 828 then
-- /doc does not exist; ask to create it.
local createUrl = docTitle:canonicalUrl{action = 'edit', preload = message('module-preload')}
local createDisplay = message('create-link-display')
local createLink = makeUrlLink(createUrl, createDisplay)
return message('create-module-doc-blurb', {createLink})
.. '<br />'
end
return ret
end
 
function p.docspacemakeExperimentBlurb(args, env)
--[[
-- Determines the namespace of the documentation.
-- Renders the text "Editors can experiment in this template's sandbox (edit | diff) and testcases (edit) pages."
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
-- @args - a table of arguments passed by the user
-- Pages in the Article, File, MediaWiki or Category namespaces must have their
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- /doc, /sandbox and /testcases pages in talk space.
--
return mw.site.namespaces[subjectSpace].talk.name
-- Messages:
-- 'sandbox-link-display' --> 'sandbox'
-- 'sandbox-edit-link-display' --> 'edit'
-- 'compare-link-display' --> 'diff'
-- 'module-sandbox-preload' --> 'Template:Documentation/preload-module-sandbox'
-- 'template-sandbox-preload' --> 'Template:Documentation/preload-sandbox'
-- 'sandbox-create-link-display' --> 'create'
-- 'mirror-edit-summary' --> 'Create sandbox version of $1'
-- 'mirror-link-display' --> 'mirror'
-- 'mirror-link-preload' --> 'Template:Documentation/mirror'
-- 'sandbox-link-display' --> 'sandbox'
-- 'testcases-link-display' --> 'testcases'
-- 'testcases-edit-link-display'--> 'edit'
-- 'template-sandbox-preload' --> 'Template:Documentation/preload-sandbox'
-- 'testcases-create-link-display' --> 'create'
-- 'testcases-link-display' --> 'testcases'
-- 'testcases-edit-link-display' --> 'edit'
-- 'module-testcases-preload' --> 'Template:Documentation/preload-module-testcases'
-- 'template-testcases-preload' --> 'Template:Documentation/preload-testcases'
-- 'experiment-blurb-module' --> 'Editors can experiment in this module's $1 and $2 pages.'
-- 'experiment-blurb-template' --> 'Editors can experiment in this template's $1 and $2 pages.'
--]]
local subjectSpace = env.subjectSpace
local templateTitle = env.templateTitle
local sandboxTitle = env.sandboxTitle
local testcasesTitle = env.testcasesTitle
local templatePage = templateTitle.prefixedText
if not subjectSpace or not templateTitle or not sandboxTitle or not testcasesTitle then
return nil
end
-- Make links.
local sandboxLinks, testcasesLinks
if sandboxTitle.exists then
local sandboxPage = sandboxTitle.prefixedText
local sandboxDisplay = message('sandbox-link-display')
local sandboxLink = makeWikilink(sandboxPage, sandboxDisplay)
local sandboxEditDisplay = message('sandbox-edit-link-display')
local sandboxEditLink = makeWikilink("Special:EditPage/" .. sandboxPage, sandboxEditDisplay)
local compareUrl = env.compareUrl
local compareLink
if compareUrl then
local compareDisplay = message('compare-link-display')
compareLink = makeUrlLink(compareUrl, compareDisplay)
end
sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
else
local sandboxPreload
if subjectSpace == 828 then
sandboxPreload = message('module-sandbox-preload')
else
sandboxPreload = message('template-sandbox-preload')
end
local sandboxCreateUrl = sandboxTitle:canonicalUrl{action = 'edit', preload = sandboxPreload}
local sandboxCreateDisplay = message('sandbox-create-link-display')
local sandboxCreateLink = makeUrlLink(sandboxCreateUrl, sandboxCreateDisplay)
local mirrorSummary = message('mirror-edit-summary', {makeWikilink(templatePage)})
local mirrorPreload = message('mirror-link-preload')
local mirrorUrl = sandboxTitle:canonicalUrl{action = 'edit', preload = mirrorPreload, summary = mirrorSummary}
if subjectSpace == 828 then
mirrorUrl = sandboxTitle:canonicalUrl{action = 'edit', preload = templateTitle.prefixedText, summary = mirrorSummary}
end
local mirrorDisplay = message('mirror-link-display')
local mirrorLink = makeUrlLink(mirrorUrl, mirrorDisplay)
sandboxLinks = message('sandbox-link-display') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
end
if testcasesTitle.exists then
local testcasesPage = testcasesTitle.prefixedText
local testcasesDisplay = message('testcases-link-display')
local testcasesLink = makeWikilink(testcasesPage, testcasesDisplay)
local testcasesEditUrl = testcasesTitle:canonicalUrl{action = 'edit'}
local testcasesEditDisplay = message('testcases-edit-link-display')
local testcasesEditLink = makeWikilink("Special:EditPage/" .. testcasesPage, testcasesEditDisplay)
-- for Modules, add testcases run link if exists
if testcasesTitle.contentModel == "Scribunto" and testcasesTitle.talkPageTitle and testcasesTitle.talkPageTitle.exists then
local testcasesRunLinkDisplay = message('testcases-run-link-display')
local testcasesRunLink = makeWikilink(testcasesTitle.talkPageTitle.prefixedText, testcasesRunLinkDisplay)
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink, testcasesRunLink)
else
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
end
else
local testcasesPreload
if subjectSpace == 828 then
testcasesPreload = message('module-testcases-preload')
else
testcasesPreload = message('template-testcases-preload')
end
local testcasesCreateUrl = testcasesTitle:canonicalUrl{action = 'edit', preload = testcasesPreload}
local testcasesCreateDisplay = message('testcases-create-link-display')
local testcasesCreateLink = makeUrlLink(testcasesCreateUrl, testcasesCreateDisplay)
testcasesLinks = message('testcases-link-display') .. ' ' .. makeToolbar(testcasesCreateLink)
end
local messageName
if subjectSpace == 828 then
messageName = 'experiment-blurb-module'
else
messageName = 'experiment-blurb-template'
return currentTitle.subjectNsText
end
return message(messageName, {sandboxLinks, testcasesLinks})
end
 
function p.templatePagemakeCategoriesBlurb(args, env)
--[[
-- Determines the template page. No namespace or interwiki prefixes are included.
-- Generates the text "Please add categories to the /doc subpage."
local subpage = currentTitle.subpageText
-- @args - a table of arguments passed by the user
if subpage == cfg.sandboxSubpage or subpage == cfg.testcasesSubpage then
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
return currentTitle.baseText
-- Messages:
-- 'doc-link-display' --> '/doc'
-- 'add-categories-blurb' --> 'Please add categories to the $1 subpage.'
--]]
local docTitle = env.docTitle
if not docTitle then
return nil
end
local docPathLink = makeWikilink(docTitle.prefixedText, message('doc-link-display'))
return message('add-categories-blurb', {docPathLink})
end
 
function p.makeSubpagesBlurb(args, env)
--[[
-- Generates the "Subpages of this template" link.
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- Messages:
-- 'template-pagetype' --> 'template'
-- 'module-pagetype' --> 'module'
-- 'default-pagetype' --> 'page'
-- 'subpages-link-display' --> 'Subpages of this $1'
--]]
local subjectSpace = env.subjectSpace
local templateTitle = env.templateTitle
if not subjectSpace or not templateTitle then
return nil
end
local pagetype
if subjectSpace == 10 then
pagetype = message('template-pagetype')
elseif subjectSpace == 828 then
pagetype = message('module-pagetype')
else
pagetype = message('default-pagetype')
return currentTitle.text
end
local subpagesLink = makeWikilink(
'Special:PrefixIndex/' .. templateTitle.prefixedText .. '/',
message('subpages-link-display', {pagetype})
)
return message('subpages-blurb', {subpagesLink})
end
 
----------------------------------------------------------------------------
-- Tracking categories
----------------------------------------------------------------------------
 
function p.addTrackingCategories(env)
--[[
-- Check if {{documentation}} is transcluded on a /doc or /testcases page.
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- Messages:
-- 'display-strange-usage-category' --> true
-- 'doc-subpage' --> 'doc'
-- 'testcases-subpage' --> 'testcases'
-- 'strange-usage-category' --> 'Wikipedia pages with strange ((documentation)) usage'
--
-- /testcases pages in the module namespace are not categorised, as they may have
-- {{documentation}} transcluded automatically.
--]]
local title = env.title
local subjectSpace = env.subjectSpace
if not title or not subjectSpace then
return nil
end
local subpage = title.subpageText
if message('display-strange-usage-category', nil, 'boolean')
and (
subpage == message('doc-subpage')
or subjectSpace ~= 828 and subpage == message('testcases-subpage')
)
then
return makeCategoryLink(message('strange-usage-category'))
end
return ''
end
 
Retrieved from "https://tep.wiki/wiki/Special:MobileDiff/7418...74454"