Editing Module:Documentation

Jump to navigation Jump to search
Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

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 ugsub = mw.ustring.gsub
local gsub = mw.ustring.gsub


----------------------------------------------------------------------------
----------------------------------------------------------------------------
-- Helper functions
-- Helper functions
--
-- These are defined as local functions, but are made available in the p
-- table for testing purposes.
----------------------------------------------------------------------------
----------------------------------------------------------------------------


local function message(cfgKey, valArray, expectType)
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. The default type for expectType is 'string'.
-- 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 "foo-message" had the value 'Foo $2 bar $1.',
-- For example, if the message cfg.fooMessage had the value 'Foo $2 bar $1.',
-- message('foo-message', {'baz', 'qux'}) would return "Foo qux bar baz."
-- message('fooMessage', 'string', {'baz', 'qux'}) would return "Foo qux bar baz."
--]]
--]]
local msg = cfg[cfgKey]
local msg = cfg[cfgKey]
expectType = expectType or 'string'
if expectType and type(msg) ~= expectType then
if type(msg) ~= expectType then
error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2)
error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2)
end
end
Line 43: Line 41:
end
end


return ugsub(msg, '$([1-9][0-9]*)', getMessageVal)
local ret = gsub(msg, '$([1-9][0-9]*)', getMessageVal)
return ret
end
end
p.message = message


local function makeWikilink(page, display)
local function makeWikilink(page, display)
Line 55: Line 52:
end
end
end
end
p.makeWikilink = makeWikilink


local function makeCategoryLink(cat, sort)
local function makeCategoryLink(cat, sort)
local catns = mw.site.namespaces[14].name
local catns = mw.site.namespaces[14].name
return makeWikilink(catns .. ':' .. cat, sort)
return makeWikilink(catns .. '/' .. cat, sort)
end
end
p.makeCategoryLink = makeCategoryLink


local function makeUrlLink(url, display)
local function makeUrlLink(url, display)
return mw.ustring.format('[%s %s]', url, display)
return mw.ustring.format('[%s %s]', url, display)
end
end
p.makeUrlLink = makeUrlLink


local function makeToolbar(...)
local function makeToolbar(...)
Line 80: Line 71:
ret[#ret + 1] = select(i, ...)
ret[#ret + 1] = select(i, ...)
end
end
-- 'documentation-toolbar'
return '<small style="font-style: normal;">(' .. table.concat(ret, ' &#124; ') .. ')</small>'
return '<span class="' .. message('toolbar-class') .. '">('
.. table.concat(ret, ' &#124; ') .. ')</span>'
end
end
p.makeToolbar = makeToolbar


----------------------------------------------------------------------------
----------------------------------------------------------------------------
Line 93: Line 80:
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 == 'heading' or value ~= '' then
if key == headingArg or value ~= '' then
return value
return value
else
else
Line 112: Line 100:


----------------------------------------------------------------------------
----------------------------------------------------------------------------
-- Entry points
-- Main function
----------------------------------------------------------------------------
----------------------------------------------------------------------------
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')
p.main = makeInvokeFunc('_main')


function p._main(args)
function p._main(args)
--[[
-- Get environment data, using pcall in case we get any errors.
-- This function defines logic flow for the module.
local success, env = pcall(p.getEnv, args)
-- @args - table of arguments passed by the user
if not success then
--]]
return string.format('<strong class="error">[[Module:Documentation]] error: %s</strong>', env) -- If there's an error, env is the error message.
local env = p.getEnvironment(args)
end
local root = mw.html.create()
-- Build the documentation.
local root = htmlBuilder.create()
root
root
:tag('div')
.wikitext(p.protectionTemplate(env))
-- 'documentation-container'
.wikitext(p.sandboxNotice(args, env))
:addClass(message('container'))
-- This div tag is from {{documentation/start box}}, but moving it here
:attr('role', 'complementary')
-- so that we don't have to worry about unclosed tags.
:attr('aria-labelledby', args.heading ~= '' and 'documentation-heading' or nil)
.tag('div')
:attr('aria-label', args.heading == '' and 'Documentation' or nil)
.attr('id', message('mainDivId', 'string'))
:newline()
.addClass(message('mainDivClasses', 'string'))
:tag('div')
.newline()
-- 'documentation'
.wikitext(p._startBox(args, env))
:addClass(message('main-div-classes'))
.wikitext(p._content(args, env))
:newline()
.tag('div')
:wikitext(p._startBox(args, env))
.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
:wikitext(p._content(args, env))
.newline()
:tag('div')
.done()
-- 'documentation-clear'
.done()
:addClass(message('clear'))
.wikitext(p._endBox(args, env))
:done()
.newline()
:newline()
.wikitext(p.addTrackingCategories(env))
:done()
return tostring(root)
: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
end


Line 165: Line 139:
----------------------------------------------------------------------------
----------------------------------------------------------------------------


function p.getEnvironment(args)
function p.getEnv(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 title
-- This is called from p._main using pcall in case we get any errors from exceeding the expensive function count
-- objects and other namespace- or path-related data.
-- limit, or other perils unknown.
-- @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:
-- 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.docSpace - the number of the namespace the title puts its documentation in.
-- env.docspace - the name 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.templatePage - the name of the template page with no namespace or interwiki prefixes.
-- env.compareUrl - URL of the Special:ComparePages page comparing the sandbox with the template.
local env = {}
--
-- 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
-- Get the title.
-- returned by that function is memoized in the env table so that we don't call any of the functions
local title
-- more than once. (Nils won't be memoized.)
local titleArg = args[message('titleArg', 'string')]
setmetatable(env, {
if titleArg then
__index = function (t, key)
title = mw.title.new(titleArg)
local envFunc = envFuncs[key]
if not title then
if envFunc then
error(message('titleArgError', 'string', {titleArg}))
local success, val = pcall(envFunc)
if success then
env[key] = val -- Memoise the value.
return val
end
end
return nil
end
end
})
else
 
title = mw.title.getCurrentTitle()
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
end
env.title = title


function envFuncs.templateTitle()
-- Get the subject namespace number.
--[[
local subjectSpace = mw.site.namespaces[title.namespace].subject.id
-- The template (or module, etc.) title object.
env.subjectSpace = subjectSpace
-- 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()
-- Get the name of the documentation namespace.
--[[
local docspace
-- Title object for the /sandbox subpage.
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
-- Messages:
-- Pages in the Article, File, MediaWiki or Category namespaces must have their
-- 'sandbox-subpage' --> 'sandbox'
-- /doc, /sandbox and /testcases pages in talk space.
--]]
docspace = mw.site.namespaces[subjectSpace].talk.name
return mw.title.new(env.docpageBase .. '/' .. message('sandbox-subpage'))
else
docspace = title.subjectNsText
end
end
env.docspace = docspace
function envFuncs.testcasesTitle()
-- Get the template page with no namespace or interwiki prefixes.
--[[
local templatePage
-- Title object for the /testcases subpage.
local subpage = title.subpageText
-- Messages:
if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
-- 'testcases-subpage' --> 'testcases'
templatePage = title.baseText
--]]
else
return mw.title.new(env.docpageBase .. '/' .. message('testcases-subpage'))
templatePage = title.text
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
end
 
env.templatePage = templatePage
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.fullUrl(
'Special:ComparePages',
{ page1 = templateTitle.prefixedText, page2 = sandboxTitle.prefixedText}
)
return tostring(compareUrl)
else
return nil
end
end


return env
return env
Line 319: Line 193:


----------------------------------------------------------------------------
----------------------------------------------------------------------------
-- Start box
-- Auxiliary templates
----------------------------------------------------------------------------
----------------------------------------------------------------------------


p.startBox = makeInvokeFunc('_startBox')
function p.sandboxNotice(args, env)
 
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string')
function p._startBox(args, env)
if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then
--[[
-- This function generates the start box.
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
--
-- The actual work is done by p.makeStartBoxLinksData and p.renderStartBoxLinks which make
-- the [view] [edit] [history] [purge] links, and by p.makeStartBoxData and p.renderStartBox
-- which generate the box HTML.
--]]
env = env or p.getEnvironment(args)
local links
local content = args.content
if not content or args[1] then
-- 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.
return nil
return nil
end
end
local frame = mw.getCurrentFrame()
local notice = htmlBuilder.create()
notice
.tag('div')
.css('clear', 'both')
.done()
.wikitext(frame:expandTemplate{title = sandboxNoticeTemplate, args = {[message('sandboxNoticeLivepageParam')] = args[message('livepageArg', 'string')]}})
return tostring(notice)
end
end


function p.makeStartBoxLinksData(args, env)
function p.protectionTemplate(env)
--[[
-- Does initial processing of data to make the [view] [edit] [history] [purge] links.
-- @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 title = env.title
local docTitle = env.docTitle
local protectionTemplate = message('protectionTemplate', 'string')
if not title or not docTitle then
if not (protectionTemplate and title.namespace == 10) then
-- Don't display the protection template if we are not in the template namespace.
return nil
return nil
end
end
if docTitle.isRedirect then
local frame = mw.getCurrentFrame()
docTitle = docTitle.redirectTarget
local function getProtectionLevel(protectionType, page)
end
-- Gets the protection level for page, or for the current page if page is not specified.
 
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType, page)
local data = {}
if level ~= '' then
data.title = title
return level
data.docTitle = docTitle
-- View, display, edit, and purge links if /doc exists.
data.viewLinkDisplay = message('view-link-display')
data.editLinkDisplay = message('edit-link-display')
data.historyLinkDisplay = message('history-link-display')
data.purgeLinkDisplay = message('purge-link-display')
-- Create link if /doc doesn't exist.
local preload = args.preload
if not preload then
if subjectSpace == 828 then -- Module namespace
preload = message('module-preload')
else
else
preload = message('docpage-preload')
return nil -- The parser function returns the blank string if there is no match.
end
end
end
end
data.preload = preload
local prefixedTitle = title.prefixedText
data.createLinkDisplay = message('create-link-display')
if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then
return data
-- The page is full-move protected, or full, template, or semi-protected.
return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')}
end
return nil
end
end


function p.renderStartBoxLinks(data)
----------------------------------------------------------------------------
--[[
-- Start box
-- Generates the [view][edit][history][purge] or [create][purge] links from the data table.
----------------------------------------------------------------------------
-- @data - a table of data generated by p.makeStartBoxLinksData
 
--]]
p.startBox = makeInvokeFunc('_startBox')
 
local function escapeBrackets(s)
function p._startBox(args, env)
-- Escapes square brackets with HTML entities.
local title = env.title
s = s:gsub('%[', '&#91;') -- Replace square brackets with HTML entities.
 
s = s:gsub('%]', '&#93;')
-- Arg processing from {{documentation}}.
return s
local preload = args[message('preloadArg', 'string')] -- Allow custom preloads.
end
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 ret
-- Arg processing from {{documentation/start box2}}.
local docTitle = data.docTitle
local docpage
local title = data.title
if docname then
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
docpage = docname
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)
ret = '[%s] [%s] [%s] [%s]'
ret = escapeBrackets(ret)
ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink)
else
else
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)
local namespace = docspace or title.nsText
ret = '[%s] [%s]'
local pagename = templatePage or title.text
ret = escapeBrackets(ret)
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string')
ret = mw.ustring.format(ret, createLink, purgeLink)
end
end
return ret
local docTitle = mw.title.new(docpage)
end
local docExist = docTitle.exists
-- Output from {{documentation/start box}}.


function p.makeStartBoxData(args, env, links)
-- First, check the heading parameter.
--[=[
-- 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
if heading == '' then
-- Don't display the start box if the heading arg is defined but blank.
-- Heading is defined but blank, so do nothing.
return nil
return nil
end
-- Build the start box div.
local sbox = htmlBuilder.create('div')
sbox
.css('padding-bottom', '3px')
.css('border-bottom', '1px solid #aaa')
.css('margin-bottom', '1ex')
.newline()
-- Make the heading.
local hspan = sbox.tag('span')
if headingStyle then
hspan.cssText(headingStyle)
elseif subjectSpace == 10 then
-- We are in the template or template talk namespaces.
hspan
.css('font-weight', 'bold')
.css('fond-size', '125%')
else
hspan.css('font-size', '150%')
end
end
if heading then
if heading then
data.heading = heading
-- "heading" has data.
hspan.wikitext(heading)
elseif subjectSpace == 10 then -- Template namespace
elseif subjectSpace == 10 then -- Template namespace
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('template-namespace-heading')
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string'))
elseif subjectSpace == 828 then -- Module namespace
elseif subjectSpace == 828 then -- Module namespace
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('module-namespace-heading')
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string'))
elseif subjectSpace == 6 then -- File namespace
elseif subjectSpace == 6 then -- File namespace
data.heading = message('file-namespace-heading')
hspan.wikitext(message('fileNamespaceHeading', 'string'))
else
else
data.heading = message('other-namespaces-heading')
hspan.wikitext(message('otherNamespacesHeading', 'string'))
end
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(message('startBoxLinkclasses', 'string'))
end
.attr('id', message('startBoxLinkId', 'string'))
if docExist then
-- Data for the [view][edit][history][purge] or [create] links.
local viewLink = makeWikilink(docpage, message('viewLinkDisplay', 'string'))
if links then
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string'))
-- 'mw-editsection-like plainlinks'
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string'))
data.linksClass = message('start-box-link-classes')
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, message('purgeLinkDisplay', 'string'))
data.links = links
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 = 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 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)
return tostring(sbox)
end
end
Line 524: Line 346:


function p._content(args, env)
function p._content(args, env)
-- Displays the documentation contents
local content = args[message('contentArg', 'string')]
-- @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 docTitle = env.docTitle
local frame = mw.getCurrentFrame()
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 = env.docspace .. ':' .. env.templatePage .. '/' .. message('docSubpage', 'string')
end
if mw.title.new(docpage).exists then
if mw.site.siteName == "Miraheze Developers Wiki" and args.noexportinstructions ~= "yes" then
local frame = mw.getCurrentFrame()
local export = mw.getCurrentFrame():expandTemplate{title="How to export"}
content = frame:preprocess('{{ ' .. docpage .. ' }}')
content = export .. "<br/>" .. (content or '')
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
p.contentTitle = makeInvokeFunc('_contentTitle')
function p._contentTitle(args, env)
env = env or p.getEnvironment(args)
local docTitle = env.docTitle
if not args.content and docTitle and docTitle.exists then
return docTitle.prefixedText
else
return ''
end
end
end


Line 561: Line 372:


function p._endBox(args, env)
function p._endBox(args, env)
--[=[
local title = env.title
-- 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.
env = env or p.getEnvironment(args)
local subjectSpace = env.subjectSpace
local subjectSpace = env.subjectSpace
local docTitle = env.docTitle
 
if not subjectSpace or not docTitle then
-- Argument processing in {{documentation}}.
return nil
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)
-- Check whether we should output the end box at all. Add the end
local docExist = docTitle.exists
-- box by default if the documentation exists or if we are in the
local docnameFed = args[1] and true
-- user, module or template namespaces.
local sandbox = docpageRoot .. '/' .. message('sandboxSubpage', 'string')
local linkBox = args['link box']
local testcases = docpageRoot .. '/' .. message('testcasesSubpage', 'string')
if linkBox == 'off'
templatePage = title.nsText .. ':' .. templatePage
or not (
 
docTitle.exists
-- Output from {{documentation/end box}}
or subjectSpace == 2
or subjectSpace == 828
-- First, check whether we should output the end box at all. Add the end box by default if the documentation
or subjectSpace == 10
-- 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
then
return nil
return nil
end
end


-- Assemble the link box.
-- 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 .. (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'}, message('editLinkDisplay', 'string'))
-- "Editors can experiment in this template's sandbox and testcases pages."
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string'))
text = text .. (p.makeExperimentBlurb(args, env) or '') .. '<br />'
text = text .. message('transcludedFromBlurb', 'string', {docLink}) .. ' ' .. makeToolbar(editLink, historyLink) .. '<br />'
if not args.content and not args[1] then
elseif subjectSpace == 828 then
-- "Please add categories to the /doc subpage."
-- /doc does not exist; ask to create it.
-- Don't show this message with inline docs or with an explicitly specified doc page,
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = message('modulePreload', 'string')}, message('createLinkDisplay', 'string'))
-- as then it is unclear where to add the categories.
text = text .. message('createModuleDocBlurb', 'string', {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 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
text = text .. ' ' .. (p.makeSubpagesBlurb(args, env) or '') --"Subpages of this template"
end
end
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.
end
return messageBox.main('fmbox', fmargs)
 
function p.makeDocPageBlurb(args, env)
--[=[
-- Makes the blurb "This documentation is transcluded from [[Template:Foo]] (edit, history)".
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
--
-- Messages:
-- '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
local ret
if docTitle.exists then
-- /doc exists; link to it.
local docLink = makeWikilink(docTitle.prefixedText)
local editUrl = docTitle:fullUrl{action = 'edit'}
local editDisplay = message('edit-link-display')
local editLink = makeUrlLink(editUrl, editDisplay)
local historyUrl = docTitle:fullUrl{action = 'history'}
local historyDisplay = message('history-link-display')
local historyLink = makeUrlLink(historyUrl, historyDisplay)
ret = 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:fullUrl{action = 'edit', preload = message('module-preload')}
local createDisplay = message('create-link-display')
local createLink = makeUrlLink(createUrl, createDisplay)
ret = message('create-module-doc-blurb', {createLink})
.. '<br />'
end
return ret
end
 
function p.makeExperimentBlurb(args, env)
--[[
-- Renders the text "Editors can experiment in this template's sandbox (edit | diff) and testcases (edit) pages."
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
--
-- 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 sandboxEditUrl = sandboxTitle:fullUrl{action = 'edit'}
local sandboxEditDisplay = message('sandbox-edit-link-display')
local sandboxEditLink = makeUrlLink(sandboxEditUrl, 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:fullUrl{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:fullUrl{action = 'edit', preload = mirrorPreload, summary = mirrorSummary}
if subjectSpace == 828 then
mirrorUrl = sandboxTitle:fullUrl{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:fullUrl{action = 'edit'}
local testcasesEditDisplay = message('testcases-edit-link-display')
local testcasesEditLink = makeUrlLink(testcasesEditUrl, 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:fullUrl{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'
end
return message(messageName, {sandboxLinks, testcasesLinks})
end
 
function p.makeCategoriesBlurb(args, env)
--[[
-- Generates the text "Please add categories to the /doc subpage."
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- 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')
end
local subpagesLink = makeWikilink(
'Special:PrefixIndex/' .. templateTitle.prefixedText .. '/',
message('subpages-link-display', {pagetype})
)
return message('subpages-blurb', {subpagesLink})
end
end


Line 832: Line 496:


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.
-- @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 title = env.title
local subjectSpace = env.subjectSpace
local ret = ''
if not title or not subjectSpace then
return nil
end
local subpage = title.subpageText
local subpage = title.subpageText
local ret = ''
if message('displayStrangeUsageCategory', 'boolean') and (subpage == message('docSubpage', 'string') or subpage == message('testcasesSubpage', 'string')) then
if message('display-strange-usage-category', nil, 'boolean')
local sort = (title.namespace == 0 and message('strangeUsageCategoryMainspaceSort', 'string') or '') .. title.prefixedText -- Sort on namespace.
and (
ret = ret .. makeCategoryLink(message('strangeUsageCategory', 'string'), sort)
subpage == message('doc-subpage')
or subjectSpace ~= 828 and subpage == message('testcases-subpage')
)
then
ret = ret .. makeCategoryLink(message('strange-usage-category'))
end
end
return ret
return ret
Please note that all contributions to Meta Wiki may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see Meta Wiki:Copyrights for details). Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)
Retrieved from "https://meta.skywiki.org/wiki/Module:Documentation"