Module:Documentation: Difference between revisions

Jump to navigation Jump to search
← Older edit
m>Mr. Stradivarius
create new function to separate html rendering in the start box
MeowyCats2 (talk | contribs)
Bureaucrats, Interface administrators, Stewards, Administrators
38 edits
m 224 revisions imported
 
(187 intermediate revisions by 68 users not shown)
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 12: Line 10:


-- Often-used functions.
-- Often-used functions.
local gsub = mw.ustring.gsub
local ugsub = mw.ustring.gsub


----------------------------------------------------------------------------
----------------------------------------------------------------------------
Line 21: Line 19:
----------------------------------------------------------------------------
----------------------------------------------------------------------------


local function message(cfgKey, expectType, valArray)
local function message(cfgKey, valArray, expectType)
--[[
--[[
-- Gets a message from the cfg table and formats it if appropriate.
-- Gets a message from the cfg table and formats it if appropriate.
-- The function raises an error if the value from the cfg table is not
-- The function raises an error if the value from the cfg table is not
-- of the type expectType.
-- of the type expectType. The default type for expectType is 'string'.
-- 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 cfg.fooMessage had the value 'Foo $2 bar $1.',
-- For example, if the message "foo-message" had the value 'Foo $2 bar $1.',
-- message('fooMessage', 'string', {'baz', 'qux'}) would return "Foo qux bar baz."
-- message('foo-message', {'baz', 'qux'}) would return "Foo qux bar baz."
--]]
--]]
local msg = cfg[cfgKey]
local msg = cfg[cfgKey]
if expectType and type(msg) ~= expectType then
expectType = expectType or 'string'
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 44: Line 43:
end
end


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


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


p.makeToolbar = makeToolbar
p.makeToolbar = makeToolbar
local function err(msg)
return string.format(
'<strong class="error">[[Module:Documentation]] error: %s</strong>%s',
msg,
makeCategoryLink('Documentation template invocations with errors')
)
end
p.err = err


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


----------------------------------------------------------------------------
----------------------------------------------------------------------------
-- Main function
-- Entry points
----------------------------------------------------------------------------
----------------------------------------------------------------------------
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)
--[[
-- This function defines logic flow for the module.
-- @args - table of arguments passed by the user
--]]
local env = p.getEnvironment(args)
local env = p.getEnvironment(args)
local root = htmlBuilder.create()
local root = mw.html.create()
root
root
.wikitext(p.protectionTemplate(env))
:tag('div')
.wikitext(p.sandboxNotice(args, env))
-- 'documentation-container'
-- This div tag is from {{documentation/start box}}, but moving it here
:addClass(message('container'))
-- so that we don't have to worry about unclosed tags.
:attr('role', 'complementary')
.tag('div')
:attr('aria-labelledby', args.heading ~= '' and 'documentation-heading' or nil)
.attr('id', message('mainDivId', 'string'))
:attr('aria-label', args.heading == '' and 'Documentation' or nil)
.addClass(message('mainDivClasses', 'string'))
:newline()
.newline()
:tag('div')
.wikitext(p._startBox(args, env))
-- 'documentation'
.wikitext(p._content(args, env))
:addClass(message('main-div-classes'))
.tag('div')
:newline()
.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
:wikitext(p._startBox(args, env))
.newline()
:wikitext(p._content(args, env))
.done()
:tag('div')
.done()
-- 'documentation-clear'
.wikitext(p._endBox(args, env))
:addClass(message('clear'))
.newline()
:done()
.wikitext(p.addTrackingCategories(env))
:newline()
return tostring(root)
: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
end


Line 158: Line 166:


function p.getEnvironment(args)
function p.getEnvironment(args)
-- Returns a table with information about the environment, including the title to use, the subject namespace, etc.
--[[
-- This is called from p._main using pcall in case we get any errors from exceeding the expensive function count
-- Returns a table with information about the environment, including title
-- limit, or other perils unknown.
-- 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:
-- 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 name of the namespace the title puts its documentation in.
-- env.docSpace - the number of the namespace the title puts its documentation in.
-- env.templatePage - the name of the template page with no namespace or interwiki prefixes.
-- 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 = {}, {}
local env, envFuncs = {}, {}


-- Set up the metatable. If a nil value is called, we call that function in the envFuncs table and memoize it
-- Set up the metatable. If triggered we call the corresponding function in the envFuncs table. The value
-- in the env table so we don't have to call any of the functions more than once.
-- 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, {
setmetatable(env, {
__index = function (t, key)
__index = function (t, key)
local envFunc = envFuncs[key]
local envFunc = envFuncs[key]
if envFunc then
if envFunc then
local val = envFunc()
local success, val = pcall(envFunc)
env[key] = val
if success then
return val
env[key] = val -- Memoise the value.
else
return val
return nil
end
end
end
return nil
end
end
})
})


-- Get the title.
function envFuncs.title()
function envFuncs.title()
-- The title object for the current page, or a test page passed with args.page.
local title
local title
local titleArg = args[message('titleArg', 'string')]
local titleArg = args.page
if titleArg then
if titleArg then
title = mw.title.new(titleArg)
title = mw.title.new(titleArg)
if not title then
error(message('titleArgError', 'string', {titleArg}))
end
else
else
title = mw.title.getCurrentTitle()
title = mw.title.getCurrentTitle()
Line 199: Line 219:
end
end


-- Get the subject namespace number.
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.subjectSpace()
function envFuncs.subjectSpace()
-- The subject namespace number.
return mw.site.namespaces[env.title.namespace].subject.id
return mw.site.namespaces[env.title.namespace].subject.id
end
end
 
-- Get the name of the documentation namespace.
function envFuncs.docSpace()
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
local subjectSpace = env.subjectSpace
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
-- Pages in the Article, File, MediaWiki or Category namespaces must have their
return subjectSpace + 1
-- /doc, /sandbox and /testcases pages in talk space.
return mw.site.namespaces[subjectSpace].talk.name
else
else
return env.title.subjectNsText
return subjectSpace
end
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
end
-- Get the template page with no namespace or interwiki prefixes.
function envFuncs.compareUrl()
function envFuncs.templatePage()
-- Diff link between the sandbox and the main template using [[Special:ComparePages]].
local title = env.title
local templateTitle = env.templateTitle
local subpage = title.subpageText
local sandboxTitle = env.sandboxTitle
if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
if templateTitle.exists and sandboxTitle.exists then
return title.baseText
local compareUrl = mw.uri.fullUrl(
'Special:ComparePages',
{ page1 = templateTitle.prefixedText, page2 = sandboxTitle.prefixedText}
)
return tostring(compareUrl)
else
else
return title.text
return nil
end
end
end
end
 
function env:grab(key)
local success, val = pcall(function() return self[key] end)
return success, val
end


return env
return env
Line 236: Line 319:


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


function p.sandboxNotice(args, env)
p.startBox = makeInvokeFunc('_startBox')
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string')
 
if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then
function p._startBox(args, env)
--[[
-- 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.protectionTemplate(env)
function p.makeStartBoxLinksData(args, 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 protectionTemplate = message('protectionTemplate', 'string')
local docTitle = env.docTitle
if not (protectionTemplate and title.namespace == 10) then
if not title or not docTitle then
-- Don't display the protection template if we are not in the template namespace.
return nil
return nil
end
end
local frame = mw.getCurrentFrame()
if docTitle.isRedirect then
local function getProtectionLevel(protectionType, page)
docTitle = docTitle.redirectTarget
-- Gets the protection level for page, or for the current page if page is not specified.
end
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType, page)
 
if level ~= '' then
local data = {}
return level
data.title = title
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
return nil -- The parser function returns the blank string if there is no match.
preload = message('docpage-preload')
end
end
end
end
local prefixedTitle = title.prefixedText
data.preload = preload
if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then
data.createLinkDisplay = message('create-link-display')
-- The page is full-move protected, or full, template, or semi-protected.
return data
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
--]]
local function escapeBrackets(s)
-- Escapes square brackets with HTML entities.
s = s:gsub('%[', '&#91;') -- Replace square brackets with HTML entities.
s = s:gsub('%]', '&#93;')
return s
end


p.startBox = makeInvokeFunc('_startBox')
local ret
local docTitle = data.docTitle
local title = data.title
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
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
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)
ret = '[%s] [%s]'
ret = escapeBrackets(ret)
ret = mw.ustring.format(ret, createLink, purgeLink)
end
return ret
end


function p._startBox(args, env)
function p.makeStartBoxData(args, env, links)
local title = env.title
--[=[
-- 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
local subjectSpace = env.subjectSpace
 
if not subjectSpace then
-- Arg processing from {{documentation}}.
-- Default to an "other namespaces" namespace, so that we get at least some output
local preload = args[message('preloadArg', 'string')] -- Allow custom preloads.
-- if an error occurs.
local heading = args[message('headingArg', 'string')] -- Blank values are not removed.
subjectSpace = 2
local headingStyle = args[message('headingStyleArg', 'string')]
local content = args[message('contentArg', 'string')]
local docspace = env.docspace
local docname = args[1] -- Other docname, if fed.
local templatePage = env.templatePage
 
-- Arg processing from {{documentation/start box2}}.
local docpage
if docname then
docpage = docname
else
local namespace = docspace or title.nsText
local pagename = templatePage or title.text
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string')
end
end
local docTitle = mw.title.new(docpage)
local data = {}
local docExist = docTitle.exists
-- Output from {{documentation/start box}}.
-- Heading
 
local heading = args.heading -- Blank values are not removed.
-- First, check the heading parameter.
if heading == '' then
if heading == '' then
-- Heading is defined but blank, so do nothing.
-- Don't display the start box if the heading arg is defined but blank.
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('font-size', '125%')
else
hspan.css('font-size', '150%')
end
end
if heading then
if heading then
-- "heading" has data.
data.heading = heading
hspan.wikitext(heading)
elseif subjectSpace == 10 then -- Template namespace
elseif subjectSpace == 10 then -- Template namespace
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string'))
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('template-namespace-heading')
elseif subjectSpace == 828 then -- Module namespace
elseif subjectSpace == 828 then -- Module namespace
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string'))
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('module-namespace-heading')
elseif subjectSpace == 6 then -- File namespace
elseif subjectSpace == 6 then -- File namespace
hspan.wikitext(message('fileNamespaceHeading', 'string'))
data.heading = message('file-namespace-heading')
else
else
hspan.wikitext(message('otherNamespacesHeading', 'string'))
data.heading = message('other-namespaces-heading')
end
end
 
-- Add the [view][edit][history][purge] or [create] links.
-- Heading CSS
-- Check for the content parameter first, as we don't need the links if the documentation
local headingStyle = args['heading-style']
-- content is being entered directly onto the template page.
if headingStyle then
if not content then
data.headingStyleText = headingStyle
local lspan = sbox.tag('span') -- lspan is short for "link span".
else
lspan
-- 'documentation-heading'
.addClass(message('startBoxLinkclasses', 'string'))
data.headingClass = message('main-div-heading-class')
.attr('id', message('startBoxLinkId', 'string'))
end
if docExist then
local viewLink = makeWikilink(docpage, message('viewLinkDisplay', 'string'))
-- Data for the [view][edit][history][purge] or [create] links.
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string'))
if links then
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string'))
-- 'mw-editsection-like plainlinks'
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, message('purgeLinkDisplay', 'string'))
data.linksClass = message('start-box-link-classes')
local text = '[%s] [%s] [%s] [%s]'
data.links = links
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 tostring(sbox)
return data
end
end


function p.renderStartBox(data)
function p.renderStartBox(data)
-- Renders the start box html.
-- Renders the start box html.
local sbox = htmlBuilder.create('div')
-- @data - a table of data generated by p.makeStartBoxData.
local sbox = mw.html.create('div')
sbox
sbox
.css('padding-bottom', '3px')
-- 'documentation-startbox'
.css('border-bottom', '1px solid #aaa')
:addClass(message('start-box-class'))
.css('margin-bottom', '1ex')
:newline()
.newline()
:tag('span')
.tag('span')
:addClass(data.headingClass)
.cssText(data.headingStyleText)
:attr('id', 'documentation-heading')
.css('font-weight', data.headingFontWeight)
:cssText(data.headingStyleText)
.css('font-size', data.headingFontSize)
:wikitext(data.heading)
.wikitext(data.heading)
local links = data.links
if data.showLinks then
if links then
sbox.tag('span')
sbox:tag('span')
.addClass(data.linksClass)
:addClass(data.linksClass)
.attr('id', data.linksId)
:attr('id', data.linksId)
.wikitext(data.links)
:wikitext(links)
end
end
return tostring(sbox)
return tostring(sbox)
Line 412: Line 524:


function p._content(args, env)
function p._content(args, env)
local content = args[message('contentArg', 'string')]
-- Displays the documentation contents
if not content then
-- @args - a table of arguments passed by the user
local docpage = args[1]
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
if docpage and mw.title.new(docpage).exists then
env = env or p.getEnvironment(args)
local frame = mw.getCurrentFrame()
local docTitle = env.docTitle
content = frame:preprocess('{{ ' .. docpage .. ' }}')
local content = args.content
else
if not content and docTitle and docTitle.exists then
docpage = env.docspace .. ':' .. env.templatePage .. '/' .. message('docSubpage', 'string')
content = args._content or mw.getCurrentFrame():expandTemplate{title = docTitle.prefixedText}
if mw.title.new(docpage).exists then
end
local frame = mw.getCurrentFrame()
if mw.site.siteName == "Miraheze Developers Wiki" and args.noexportinstructions ~= "yes" then
content = frame:preprocess('{{ ' .. docpage .. ' }}')
local export = mw.getCurrentFrame():expandTemplate{title="How to export"}
end
content = export .. "<br/>" .. (content or '')
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 438: Line 561:


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
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


-- Argument processing in {{documentation}}.
-- Assemble the link box.
local content = args[message('contentArg', 'string')]
local text = ''
local linkBox = args[message('linkBoxArg', 'string')] -- So "link box=off" works.
if linkBox then
local docspace = env.docspace
text = text .. linkBox
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
else
docpage = docpageRoot .. '/' .. message('docSubpage', 'string')
text = text .. (p.makeDocPageBlurb(args, env) or '') -- "This documentation is transcluded from [[Foo]]."
if subjectSpace == 2 or subjectSpace == 10 or subjectSpace == 828 then
-- We are in the user, template or module namespaces.
-- Add sandbox and testcases links.
-- "Editors can experiment in this template's sandbox and testcases pages."
text = text .. (p.makeExperimentBlurb(args, env) or '') .. '<br />'
if not args.content and not args[1] then
-- "Please add categories to the /doc subpage."
-- Don't show this message with inline docs or with an explicitly specified doc page,
-- as then it is unclear where to add the categories.
text = text .. (p.makeCategoriesBlurb(args, env) or '')
end
text = text .. ' ' .. (p.makeSubpagesBlurb(args, env) or '') --"Subpages of this template"
end
end
end
local docTitle = mw.title.new(docpage)
local docExist = docTitle.exists
local box = mw.html.create('div')
local docnameFed = args[1] and true
-- 'documentation-metadata'
local sandbox = docpageRoot .. '/' .. message('sandboxSubpage', 'string')
box:attr('role', 'note')
local testcases = docpageRoot .. '/' .. message('testcasesSubpage', 'string')
:addClass(message('end-box-class'))
templatePage = title.nsText .. ':' .. templatePage
-- 'plainlinks'
:addClass(message('end-box-plainlinks'))
:wikitext(text)
:done()
 
return '\n' .. tostring(box)
end


-- Output from {{documentation/end box}}
function p.makeDocPageBlurb(args, env)
--[=[
-- First, check whether we should output the end box at all. Add the end box by default if the documentation
-- Makes the blurb "This documentation is transcluded from [[Template:Foo]] (edit, history)".
-- exists or if we are in the user, module or template namespaces.
-- @args - a table of arguments passed by the user
if linkBox == message('linkBoxOff', 'string') or not (docExist or subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10) then
-- @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
return nil
end
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


-- Assemble the arguments for {{fmbox}}.
function p.makeExperimentBlurb(args, env)
local fmargs = {}
--[[
fmargs[message('fmboxIdParam', 'string')] = message('fmboxId', 'string') -- Sets fmargs.id = 'documentation-meta-data'
-- Renders the text "Editors can experiment in this template's sandbox (edit | diff) and testcases (edit) pages."
fmargs[message('fmboxImageParam', 'string')] = message('fmboxImageNone', 'string') -- Sets fmargs.image = 'none'
-- @args - a table of arguments passed by the user
fmargs[message('fmboxStyleParam', 'string')] = message('fmboxStyle', 'string') -- Sets fmargs.style = 'background-color: #ecfcf4'
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
fmargs[message('fmboxTextstyleParam', 'string')] = message('fmboxTextstyle', 'string') -- Sets fmargs.textstyle = 'font-style: italic;'
--
 
-- Messages:
-- Assemble the fmbox text field.
-- 'sandbox-link-display' --> 'sandbox'
local text = ''
-- 'sandbox-edit-link-display' --> 'edit'
if linkBox then
-- 'compare-link-display' --> 'diff'
-- Use custom link box content if it is defined.
-- 'module-sandbox-preload' --> 'Template:Documentation/preload-module-sandbox'
text = text .. linkBox
-- '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
else
if docExist then
local sandboxPreload
-- /doc exists; link to it.
if subjectSpace == 828 then
local docLink = makeWikilink(docpage)
sandboxPreload = message('module-sandbox-preload')
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string'))
else
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string'))
sandboxPreload = message('template-sandbox-preload')
text = text .. message('transcludedFromBlurb', 'string', {docLink}) .. ' ' .. makeToolbar(editLink, historyLink) .. '<br />'
elseif subjectSpace == 828 then
-- /doc does not exist; ask to create it.
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = message('modulePreload', 'string')}, message('createLinkDisplay', 'string'))
text = text .. message('createModuleDocBlurb', 'string', {createLink}) .. '<br />'
end
end
-- Add links to /sandbox and /testcases when appropriate.
local sandboxCreateUrl = sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}
if subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10 then
local sandboxCreateDisplay = message('sandbox-create-link-display')
-- We are in the user, module or template namespaces.
local sandboxCreateLink = makeUrlLink(sandboxCreateUrl, sandboxCreateDisplay)
local sandboxLinks, testcasesLinks
local mirrorSummary = message('mirror-edit-summary', {makeWikilink(templatePage)})
local pagePossessive = subjectSpace == 828 and message('modulePossessive', 'string') or message('templatePossessive', 'string')
local mirrorPreload = message('mirror-link-preload')
local sandboxTitle = mw.title.new(sandbox)
local mirrorUrl = sandboxTitle:fullUrl{action = 'edit', preload = mirrorPreload, summary = mirrorSummary}
if sandboxTitle.exists then
if subjectSpace == 828 then
local sandboxLink = makeWikilink(sandbox, message('sandboxLinkDisplay', 'string'))
mirrorUrl = sandboxTitle:fullUrl{action = 'edit', preload = templateTitle.prefixedText, summary = mirrorSummary}
local sandboxEditLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit'}, message('sandboxEditLinkDisplay', 'string'))
end
local compareLink = makeUrlLink(mw.title.new('Special:ComparePages'):fullUrl{page1 = templatePage, page2 = sandbox}, message('compareLinkDisplay', 'string'))
local mirrorDisplay = message('mirror-link-display')
sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
local mirrorLink = makeUrlLink(mirrorUrl, mirrorDisplay)
else
sandboxLinks = message('sandbox-link-display') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
local sandboxPreload = subjectSpace == 828 and message('moduleSandboxPreload', 'string') or message('templateSandboxPreload', 'string')
end
local sandboxCreateLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}, message('sandboxCreateLinkDisplay', 'string'))
if testcasesTitle.exists then
local mirrorSummary = message('mirrorEditSummary', 'string', {makeWikilink(templatePage)})
local testcasesPage = testcasesTitle.prefixedText
local mirrorLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = templatePage, summary = mirrorSummary}, message('mirrorLinkDisplay', 'string'))
local testcasesDisplay = message('testcases-link-display')
sandboxLinks = message('sandboxLinkDisplay', 'string') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
local testcasesLink = makeWikilink(testcasesPage, testcasesDisplay)
end
local testcasesEditUrl = testcasesTitle:fullUrl{action = 'edit'}
local testcaseTitle = mw.title.new(testcases)
local testcasesEditDisplay = message('testcases-edit-link-display')
if testcaseTitle.exists then
local testcasesEditLink = makeUrlLink(testcasesEditUrl, testcasesEditDisplay)
local testcasesLink = makeWikilink(testcases, message('testcasesLinkDisplay', 'string'))
-- for Modules, add testcases run link if exists
local testcasesEditLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit'}, message('testcasesEditLinkDisplay', 'string'))
if testcasesTitle.contentModel == "Scribunto" and testcasesTitle.talkPageTitle and testcasesTitle.talkPageTitle.exists then
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
local testcasesRunLinkDisplay = message('testcases-run-link-display')
else
local testcasesRunLink = makeWikilink(testcasesTitle.talkPageTitle.prefixedText, testcasesRunLinkDisplay)
local testcasesPreload = subjectSpace == 828 and message('moduleTestcasesPreload', 'string') or message('templateTestcasesPreload', 'string')
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink, testcasesRunLink)
local testcasesCreateLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit', preload = testcasesPreload}, message('testcasesCreateLinkDisplay', 'string'))
else
testcasesLinks = message('testcasesLinkDisplay', 'string') .. ' ' .. makeToolbar(testcasesCreateLink)
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
end
end
text = text .. message('experimentBlurb', 'string', {pagePossessive, sandboxLinks, testcasesLinks}) .. '<br />'
else
-- Show the categories text, but not if "content" fed or "docname fed" since then it is unclear where to add the categories.
local testcasesPreload
if not content and not docnameFed then
if subjectSpace == 828 then
local docPathLink = makeWikilink(docpage, message('docLinkDisplay', 'string'))
testcasesPreload = message('module-testcases-preload')
text = text .. message('addCategoriesBlurb', 'string', {docPathLink})
else
end
testcasesPreload = message('template-testcases-preload')
-- Show the "subpages" link.
if subjectSpace ~= 6 then -- Don't show the link in file space.
local pagetype
if subjectSpace == 10 then
pagetype = message('templatePagetype', 'string')
elseif subjectSpace == 828 then
pagetype = message('modulePagetype', 'string')
else
pagetype = message('defaultPagetype', 'string')
end
text = text .. ' ' .. makeWikilink('Special:PrefixIndex/' .. templatePage .. '/', message('subpagesLinkDisplay', 'string', {pagetype}))
end
-- Show the "print" link if it exists.
local printPage = templatePage .. '/' .. message('printSubpage', 'string')
local printTitle = mw.title.new(printPage)
if printTitle.exists then
local printLink = makeWikilink(printPage, message('printLinkDisplay', 'string'))
text = text .. '<br />' .. message('printBlurb', 'string', {printLink})
.. (message('displayPrintCategory', 'boolean') and makeCategoryLink(message('printCategory', 'string')) or '')
end
end
end
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
end
fmargs.text = text
local messageName
if subjectSpace == 828 then
messageName = 'experiment-blurb-module'
else
messageName = 'experiment-blurb-template'
end
return message(messageName, {sandboxLinks, testcasesLinks})
end


-- Return the fmbox output.
function p.makeCategoriesBlurb(args, env)
return messageBox.main('fmbox', fmargs)
--[[
-- 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 562: Line 832:


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
if not title or not subjectSpace then
return nil
end
local subpage = title.subpageText
local ret = ''
local ret = ''
local subpage = title.subpageText
if message('display-strange-usage-category', nil, 'boolean')
if message('displayStrangeUsageCategory', 'boolean') and (subpage == message('docSubpage', 'string') or subpage == message('testcasesSubpage', 'string')) then
and (
local sort = (title.namespace == 0 and message('strangeUsageCategoryMainspaceSort', 'string') or '') .. title.prefixedText -- Sort on namespace.
subpage == message('doc-subpage')
ret = ret .. makeCategoryLink(message('strangeUsageCategory', 'string'), sort)
or subjectSpace ~= 828 and subpage == message('testcases-subpage')
)
then
ret = ret .. makeCategoryLink(message('strange-usage-category'))
end
end
return ret
return ret
Retrieved from "https://meta.skywiki.org/wiki/Module:Documentation"