Module:Documentation: Difference between revisions

Jump to navigation Jump to search
← Older edit
m>Mr. Stradivarius
add functions for rendering start box links and for making the start box link data
MeowyCats2 (talk | contribs)
Bureaucrats, Interface administrators, Stewards, Administrators
38 edits
m 224 revisions imported
 
(186 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()
function envFuncs.subjectSpace()
--[[
return mw.site.namespaces[env.title.namespace].subject.id
-- The template (or module, etc.) title object.
end
-- Messages:
-- 'sandbox-subpage' --> 'sandbox'
-- Get the name of the documentation namespace.
-- 'testcases-subpage' --> 'testcases'
function envFuncs.docspace()
--]]
local subjectSpace = env.subjectSpace
local subjectSpace = env.subjectSpace
if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
-- Pages in the Article, File, MediaWiki or Category namespaces must have their
-- /doc, /sandbox and /testcases pages in talk space.
return mw.site.namespaces[subjectSpace].talk.name
else
return env.title.subjectNsText
end
end
-- Get the template page with no namespace or interwiki prefixes.
function envFuncs.templatePage()
local title = env.title
local title = env.title
local subpage = title.subpageText
local subpage = title.subpageText
if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
if subpage == message('sandbox-subpage') or subpage == message('testcases-subpage') then
return title.baseText
return mw.title.makeTitle(subjectSpace, title.baseText)
else
else
return title.text
return mw.title.makeTitle(subjectSpace, title.text)
end
end
end
end


function envFuncs.docTitle()
function envFuncs.docTitle()
--[[
-- Title object of the /doc subpage.
-- Messages:
-- 'doc-subpage' --> 'doc'
--]]
local title = env.title
local title = env.title
local docname = args[1] -- Other docname, if fed.
local docname = args[1] -- User-specified doc page.
local docspace = env.docspace
local templatePage = env.templatePage
local docpage
local docpage
if docname then
if docname then
docpage = docname
docpage = docname
else
else
local namespace = docspace or title.nsText
docpage = env.docpageBase .. '/' .. message('doc-subpage')
local pagename = templatePage or title.text
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string')
end
end
return mw.title.new(docpage)
return mw.title.new(docpage)
end
end
 
function env:grab(key)
function envFuncs.sandboxTitle()
local success, val = pcall(function() return self[key] end)
--[[
return success, val
-- 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
end


return env
end


----------------------------------------------------------------------------
function envFuncs.subjectSpace()
-- Auxiliary templates
-- The subject namespace number.
----------------------------------------------------------------------------
return mw.site.namespaces[env.title.namespace].subject.id
end


function p.sandboxNotice(args, env)
function envFuncs.docSpace()
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string')
-- The documentation namespace number. For most namespaces this is the
if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then
-- same as the subject namespace. However, pages in the Article, File,
return nil
-- 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
local frame = mw.getCurrentFrame()
local notice = htmlBuilder.create()
notice
.tag('div')
.css('clear', 'both')
.done()
.wikitext(frame:expandTemplate{title = sandboxNoticeTemplate, args = {[message('sandboxNoticeLivepageParam')] = args[message('livepageArg', 'string')]}})
return tostring(notice)
end


function p.protectionTemplate(env)
function envFuncs.docpageBase()
local title = env.title
-- The base page of the /doc, /sandbox, and /testcases subpages.
local protectionTemplate = message('protectionTemplate', 'string')
-- For some namespaces this is the talk page, rather than the template page.
if not (protectionTemplate and title.namespace == 10) then
local templateTitle = env.templateTitle
-- Don't display the protection template if we are not in the template namespace.
local docSpace = env.docSpace
return nil
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
local frame = mw.getCurrentFrame()
local function getProtectionLevel(protectionType, page)
function envFuncs.compareUrl()
-- Gets the protection level for page, or for the current page if page is not specified.
-- Diff link between the sandbox and the main template using [[Special:ComparePages]].
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType, page)
local templateTitle = env.templateTitle
if level ~= '' then
local sandboxTitle = env.sandboxTitle
return level
if templateTitle.exists and sandboxTitle.exists then
local compareUrl = mw.uri.fullUrl(
'Special:ComparePages',
{ page1 = templateTitle.prefixedText, page2 = sandboxTitle.prefixedText}
)
return tostring(compareUrl)
else
else
return nil -- The parser function returns the blank string if there is no match.
return nil
end
end
end
end
local prefixedTitle = title.prefixedText
 
if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then
return env
-- The page is full-move protected, or full, template, or semi-protected.
end
return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')}
end
return nil
end


----------------------------------------------------------------------------
----------------------------------------------------------------------------
Line 302: Line 325:


function p._startBox(args, env)
function p._startBox(args, env)
local title = env.title
--[[
local subjectSpace = env.subjectSpace
-- This function generates the start box.
 
-- @args - a table of arguments passed by the user
-- Arg processing from {{documentation}}.
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
local preload = args[message('preloadArg', 'string')] -- Allow custom preloads.
--
local heading = args[message('headingArg', 'string')] -- Blank values are not removed.
-- The actual work is done by p.makeStartBoxLinksData and p.renderStartBoxLinks which make
local headingStyle = args[message('headingStyleArg', 'string')]
-- the [view] [edit] [history] [purge] links, and by p.makeStartBoxData and p.renderStartBox
local content = args[message('contentArg', 'string')]
-- which generate the box HTML.
local docspace = env.docspace
--]]
local docname = args[1] -- Other docname, if fed.
env = env or p.getEnvironment(args)
local templatePage = env.templatePage
local links
 
local content = args.content
-- Arg processing from {{documentation/start box2}}.
if not content or args[1] then
local docpage
-- No need to include the links if the documentation is on the template page itself.
if docname then
local linksData = p.makeStartBoxLinksData(args, env)
docpage = docname
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
else
local namespace = docspace or title.nsText
-- User specified no heading.
local pagename = templatePage or title.text
return nil
docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string')
end
end
local docTitle = mw.title.new(docpage)
end
local docExist = docTitle.exists
-- Output from {{documentation/start box}}.


-- First, check the heading parameter.
function p.makeStartBoxLinksData(args, env)
if heading == '' then
--[[
-- Heading is defined but blank, so do nothing.
-- 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 docTitle = env.docTitle
if not title or not docTitle then
return nil
return nil
end
end
 
if docTitle.isRedirect then  
-- Build the start box div.
docTitle = docTitle.redirectTarget
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
if heading then
-- "heading" has data.
hspan.wikitext(heading)
elseif subjectSpace == 10 then -- Template namespace
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string'))
elseif subjectSpace == 828 then -- Module namespace
hspan.wikitext(message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string'))
elseif subjectSpace == 6 then -- File namespace
hspan.wikitext(message('fileNamespaceHeading', 'string'))
else
hspan.wikitext(message('otherNamespacesHeading', 'string'))
end
end


-- Add the [view][edit][history][purge] or [create] links.
-- Check for the content parameter first, as we don't need the links if the documentation
-- content is being entered directly onto the template page.
if not content then
local lspan = sbox.tag('span') -- lspan is short for "link span".
lspan
.addClass(message('startBoxLinkclasses', 'string'))
.attr('id', message('startBoxLinkId', 'string'))
if docExist then
local viewLink = makeWikilink(docpage, message('viewLinkDisplay', 'string'))
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string'))
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string'))
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, message('purgeLinkDisplay', 'string'))
local text = '[%s] [%s] [%s] [%s]'
text = text:gsub('%[', '&#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
return tostring(sbox)
end
function p.makeStartBoxLinksData(args, env)
local data = {}
local data = {}
-- Get title objects.
data.title = title
local titleSuccess, title = env:grab('title')
data.docTitle = docTitle
if titleSuccess then
data.title = title
else
return err(title)
end
local docTitleSuccess, docTitle = env:grab('docTitle')
if docTitleSuccess then
data.docTitle = docTitle
else
return err(docTitle)
end
-- View, display, edit, and purge links if /doc exists.
-- View, display, edit, and purge links if /doc exists.
data.viewLinkDisplay = message('viewLinkDisplay', 'string')
data.viewLinkDisplay = message('view-link-display')
data.editLinkDisplay = message('editLinkDisplay', 'string')
data.editLinkDisplay = message('edit-link-display')
data.historyLinkDisplay = message('historyLinkDisplay', 'string')
data.historyLinkDisplay = message('history-link-display')
data.purgeLinkDisplay = message('purgeLinkDisplay', 'string')
data.purgeLinkDisplay = message('purge-link-display')
-- Create link if /doc doesn't exist.
-- Create link if /doc doesn't exist.
local preload = args[message('preloadArg', 'string')]
local preload = args.preload
if not preload then
if not preload then
if env.subjectSpace == 6 then -- File namespace
if subjectSpace == 828 then -- Module namespace
preload = message('fileDocpagePreload', 'string')
preload = message('module-preload')
else
else
preload = message('docpagePreload', 'string')
preload = message('docpage-preload')
end
end
end
end
data.preload = preload
data.preload = preload
data.createLinkDisplay = message('createLinkDisplay', 'string')
data.createLinkDisplay = message('create-link-display')
return data
return data
end
end


function p.renderStartBoxLinks(data)
function p.renderStartBoxLinks(data)
-- Render the [view][edit][history][purge] or [create] links.
--[[
-- 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
 
local ret
local ret
local docTitle = data.docTitle
local docTitle = data.docTitle
local title = data.title
local title = data.title
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
if docTitle.exists then
if docTitle.exists then
local viewLink = makeWikilink(docpage, data.viewLinkDisplay)
local viewLink = makeWikilink(docTitle.prefixedText, data.viewLinkDisplay)
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay)
local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay)
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay)
local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay)
local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
ret = '[%s] [%s] [%s] [%s]'
ret = '[%s] [%s] [%s] [%s]'
ret = ret:gsub('%[', '&#91;') -- Replace square brackets with HTML entities.
ret = escapeBrackets(ret)
ret = ret:gsub('%]', '&#93;')
ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink)
ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink)
else
else
lspan.wikitext(makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay))
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
end
return ret
end
function p.makeStartBoxData(args, env, links)
--[=[
-- Does initial processing of data to pass to the start-box render function, p.renderStartBox.
-- @args - a table of arguments passed by the user
-- @env - environment table containing title objects, etc., generated with p.getEnvironment
-- @links - a string containing the [view][edit][history][purge] links - could be nil if there's an error.
--
-- Messages:
-- 'documentation-icon-wikitext' --> '[[File:Test Template Info-Icon - Version (2).svg|50px|link=|alt=]]'
-- 'template-namespace-heading' --> 'Template documentation'
-- 'module-namespace-heading' --> 'Module documentation'
-- 'file-namespace-heading' --> 'Summary'
-- 'other-namespaces-heading' --> 'Documentation'
-- 'testcases-create-link-display' --> 'create'
--]=]
local subjectSpace = env.subjectSpace
if not subjectSpace then
-- Default to an "other namespaces" namespace, so that we get at least some output
-- if an error occurs.
subjectSpace = 2
end
local data = {}
-- Heading
local heading = args.heading -- Blank values are not removed.
if heading == '' then
-- Don't display the start box if the heading arg is defined but blank.
return nil
end
if heading then
data.heading = heading
elseif subjectSpace == 10 then -- Template namespace
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('template-namespace-heading')
elseif subjectSpace == 828 then -- Module namespace
data.heading = message('documentation-icon-wikitext') .. ' ' .. message('module-namespace-heading')
elseif subjectSpace == 6 then -- File namespace
data.heading = message('file-namespace-heading')
else
data.heading = message('other-namespaces-heading')
end
-- Heading CSS
local headingStyle = args['heading-style']
if headingStyle then
data.headingStyleText = headingStyle
else
-- 'documentation-heading'
data.headingClass = message('main-div-heading-class')
end
-- Data for the [view][edit][history][purge] or [create] links.
if links then
-- 'mw-editsection-like plainlinks'
data.linksClass = message('start-box-link-classes')
data.links = links
end
return data
end
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 481: 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 507: 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 />'
end
elseif subjectSpace == 828 then
local sandboxCreateUrl = sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}
-- /doc does not exist; ask to create it.
local sandboxCreateDisplay = message('sandbox-create-link-display')
local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = message('modulePreload', 'string')}, message('createLinkDisplay', 'string'))
local sandboxCreateLink = makeUrlLink(sandboxCreateUrl, sandboxCreateDisplay)
text = text .. message('createModuleDocBlurb', 'string', {createLink}) .. '<br />'
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
end
-- Add links to /sandbox and /testcases when appropriate.
else
if subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10 then
local testcasesPreload
-- We are in the user, module or template namespaces.
if subjectSpace == 828 then
local sandboxLinks, testcasesLinks
testcasesPreload = message('module-testcases-preload')
local pagePossessive = subjectSpace == 828 and message('modulePossessive', 'string') or message('templatePossessive', 'string')
else
local sandboxTitle = mw.title.new(sandbox)
testcasesPreload = message('template-testcases-preload')
if sandboxTitle.exists then
local sandboxLink = makeWikilink(sandbox, message('sandboxLinkDisplay', 'string'))
local sandboxEditLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit'}, message('sandboxEditLinkDisplay', 'string'))
local compareLink = makeUrlLink(mw.title.new('Special:ComparePages'):fullUrl{page1 = templatePage, page2 = sandbox}, message('compareLinkDisplay', 'string'))
sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
else
local sandboxPreload = subjectSpace == 828 and message('moduleSandboxPreload', 'string') or message('templateSandboxPreload', 'string')
local sandboxCreateLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}, message('sandboxCreateLinkDisplay', 'string'))
local mirrorSummary = message('mirrorEditSummary', 'string', {makeWikilink(templatePage)})
local mirrorLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = templatePage, summary = mirrorSummary}, message('mirrorLinkDisplay', 'string'))
sandboxLinks = message('sandboxLinkDisplay', 'string') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
end
local testcaseTitle = mw.title.new(testcases)
if testcaseTitle.exists then
local testcasesLink = makeWikilink(testcases, message('testcasesLinkDisplay', 'string'))
local testcasesEditLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit'}, message('testcasesEditLinkDisplay', 'string'))
testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
else
local testcasesPreload = subjectSpace == 828 and message('moduleTestcasesPreload', 'string') or message('templateTestcasesPreload', 'string')
local testcasesCreateLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit', preload = testcasesPreload}, message('testcasesCreateLinkDisplay', 'string'))
testcasesLinks = message('testcasesLinkDisplay', 'string') .. ' ' .. makeToolbar(testcasesCreateLink)
end
text = text .. message('experimentBlurb', 'string', {pagePossessive, sandboxLinks, testcasesLinks}) .. '<br />'
-- Show the categories text, but not if "content" fed or "docname fed" since then it is unclear where to add the categories.
if not content and not docnameFed then
local docPathLink = makeWikilink(docpage, message('docLinkDisplay', 'string'))
text = text .. message('addCategoriesBlurb', 'string', {docPathLink})
end
-- Show the "subpages" link.
if subjectSpace ~= 6 then -- Don't show the link in file space.
local pagetype
if subjectSpace == 10 then
pagetype = message('templatePagetype', 'string')
elseif subjectSpace == 828 then
pagetype = message('modulePagetype', 'string')
else
pagetype = message('defaultPagetype', 'string')
end
text = text .. ' ' .. makeWikilink('Special:PrefixIndex/' .. templatePage .. '/', message('subpagesLinkDisplay', 'string', {pagetype}))
end
-- Show the "print" link if it exists.
local printPage = templatePage .. '/' .. message('printSubpage', 'string')
local printTitle = mw.title.new(printPage)
if printTitle.exists then
local printLink = makeWikilink(printPage, message('printLinkDisplay', 'string'))
text = text .. '<br />' .. message('printBlurb', 'string', {printLink})
.. (message('displayPrintCategory', 'boolean') and makeCategoryLink(message('printCategory', 'string')) or '')
end
end
end
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 631: 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"