Module:Documentation: Difference between revisions

Jump to navigation Jump to search
(rename formatMessage --> message, as it is no longer just doing formatting; tweak the function's comment as well)
(start conversion to a p.getEnv function rather than using globals; I've only got as far as the start box, so the module currently won't run)
Line 10: Line 10:


local p = {}
local p = {}
-- Constants.
local currentTitle = mw.title.getCurrentTitle()
local subjectSpace = mw.site.namespaces[currentTitle.namespace].subject.id -- The number of the current subject namespace.


-- Often-used functions.
-- Often-used functions.
Line 104: Line 100:


----------------------------------------------------------------------------
----------------------------------------------------------------------------
-- Main functions
-- Main function
----------------------------------------------------------------------------
----------------------------------------------------------------------------


Line 110: Line 106:


function p._main(args)
function p._main(args)
-- Get environment data, using pcall in case we get any errors.
local success, env = pcall(p.getEnv, args)
if not success then
return string.format('<strong class="error">[[Module:Documentation]] error: %s</strong>', env) -- If there's an error, env is the error message.
end
-- Build the documentation.
local root = htmlBuilder.create()
local root = htmlBuilder.create()
root
root
.wikitext(p.protectionTemplate())
.wikitext(p.protectionTemplate(env))
.wikitext(p.sandboxNotice(args))
.wikitext(p.sandboxNotice(args, env))
-- This div tag is from {{documentation/start box}}, but moving it here
-- This div tag is from {{documentation/start box}}, but moving it here
-- so that we don't have to worry about unclosed tags.
-- so that we don't have to worry about unclosed tags.
Line 120: Line 122:
.addClass(message('mainDivClasses', 'string'))
.addClass(message('mainDivClasses', 'string'))
.newline()
.newline()
.wikitext(p._startBox(args))
.wikitext(p._startBox(args, env))
.wikitext(p._content(args))
.wikitext(p._content(args, env))
.tag('div')
.tag('div')
.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
Line 127: Line 129:
.done()
.done()
.done()
.done()
.wikitext(p._endBox(args))
.wikitext(p._endBox(args, env))
.newline()
.newline()
.wikitext(p.addTrackingCategories())
.wikitext(p.addTrackingCategories(env))
return tostring(root)
return tostring(root)
end
end


function p.sandboxNotice(args)
----------------------------------------------------------------------------
-- Environment settings
----------------------------------------------------------------------------
 
function p.getEnv(args)
-- Returns a table with information about the environment, including the title to use, the subject namespace, etc.
-- This is called from p._main using pcall in case we get any errors from exceeding the expensive function count
-- limit, or other perils unknown.
--
-- Data includes:
-- env.title - the title object of the page we are making documentation for (usually the current title)
-- env.subjectSpace - the number of the title's subject namespace.
-- env.docspace - the name of the namespace the title puts its documentation in.
-- env.templatePage - the name of the template page with no namespace or interwiki prefixes.
local env = {}
 
-- Get the title.
local title
local titleArg = args[message('titleArg', 'string')]
if titleArg then
title = mw.title.new(titleArg)
if not title then
error(message('titleArgError', 'string', {titleArg}))
end
else
title = mw.title.getCurrentTitle()
end
env.title = title
 
-- Get the subject namespace number.
local subjectSpace = mw.site.namespaces[title.namespace].subject.id
env.subjectSpace = subjectSpace
-- Get the name of the documentation namespace.
local docspace
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.
docspace = mw.site.namespaces[subjectSpace].talk.name
else
docspace = title.subjectNsText
end
env.docspace = docspace
-- Get the template page with no namespace or interwiki prefixes.
local templatePage
local subpage = title.subpageText
if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
templatePage = title.baseText
else
templatePage = title.text
end
env.templatePage = templatePage
 
return env
end
 
----------------------------------------------------------------------------
-- Auxiliary templates
----------------------------------------------------------------------------
 
function p.sandboxNotice(args, env)
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string')
local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string')
if not (sandboxNoticeTemplate and currentTitle.subpageText == message('sandboxSubpage', 'string')) then
if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then
return nil
return nil
end
end
Line 148: Line 211:
end
end


function p.protectionTemplate()
function p.protectionTemplate(env)
local title = env.title
local protectionTemplate = message('protectionTemplate', 'string')
local protectionTemplate = message('protectionTemplate', 'string')
if not (protectionTemplate and currentTitle.namespace == 10) then
if not (protectionTemplate and title.namespace == 10) then
-- Don't display the protection template if we are not in the template namespace.
-- Don't display the protection template if we are not in the template namespace.
return nil
return nil
end
end
local frame = mw.getCurrentFrame()
local frame = mw.getCurrentFrame()
local function getProtectionLevel(protectionType)
local function getProtectionLevel(protectionType, page)
-- Gets the protection level for the current page.
-- Gets the protection level for page, or for the current page if page is not specified.
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType)
local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType, page)
if level ~= '' then
if level ~= '' then
return level
return level
Line 164: Line 228:
end
end
end
end
if getProtectionLevel('move') == 'sysop' or getProtectionLevel('edit') then
local prefixedTitle = title.prefixedText
if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then
-- The page is full-move protected, or full, template, or semi-protected.
-- The page is full-move protected, or full, template, or semi-protected.
return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')}
return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')}
Line 170: Line 235:
return nil
return nil
end
end
----------------------------------------------------------------------------
-- Start box
----------------------------------------------------------------------------


p.startBox = makeInvokeFunc('_startBox')
p.startBox = makeInvokeFunc('_startBox')


function p._startBox(args)
function p._startBox(args, env)
-- Arg processing from {{documentation}}.
-- Arg processing from {{documentation}}.
local preload = args[message('preloadArg', 'string')] -- Allow custom preloads.
local preload = args[message('preloadArg', 'string')] -- Allow custom preloads.
Line 179: Line 248:
local headingStyle = args[message('headingStyleArg', 'string')]
local headingStyle = args[message('headingStyleArg', 'string')]
local content = args[message('contentArg', 'string')]
local content = args[message('contentArg', 'string')]
local docspace = p.docspace()
local docspace = env.docspace
local docname = args[1] -- Other docname, if fed.
local docname = args[1] -- Other docname, if fed.
local templatePage = p.templatePage()
local templatePage = env.templatePage


-- Arg processing from {{documentation/start box2}}.
-- Arg processing from {{documentation/start box2}}.
Line 267: Line 336:
return tostring(sbox)
return tostring(sbox)
end
end
----------------------------------------------------------------------------
-- Documentation content
----------------------------------------------------------------------------


p.content = makeInvokeFunc('_content')
p.content = makeInvokeFunc('_content')
Line 289: Line 362:
return '\n' .. (content or '') .. '\n'  
return '\n' .. (content or '') .. '\n'  
end
end
----------------------------------------------------------------------------
-- End box
----------------------------------------------------------------------------


p.endBox = makeInvokeFunc('_endBox')
p.endBox = makeInvokeFunc('_endBox')
Line 408: Line 485:
return messageBox.main('fmbox', fmargs)
return messageBox.main('fmbox', fmargs)
end
end
----------------------------------------------------------------------------
-- Tracking categories
----------------------------------------------------------------------------


function p.addTrackingCategories()
function p.addTrackingCategories()
Line 418: Line 499:
end
end
return ret
return ret
end
function p.docspace()
-- Determines the namespace of the documentation.
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 currentTitle.subjectNsText
end
end
function p.templatePage()
-- Determines the template page. No namespace or interwiki prefixes are included.
local subpage = currentTitle.subpageText
if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
return currentTitle.baseText
else
return currentTitle.text
end
end
end


return p
return p

Revision as of 06:53, 3 January 2014

Documentation for this module may be created at Module:Documentation/doc 

-- This module implements {{documentation}}.

-- Get required modules.
local getArgs = require('Module:Arguments').getArgs
local htmlBuilder = require('Module:HtmlBuilder')
local messageBox = require('Module:Message box')

-- Get the config table.
local cfg = mw.loadData('Module:Documentation/config')

local p = {}

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

----------------------------------------------------------------------------
-- Helper functions
----------------------------------------------------------------------------

local function message(cfgKey, expectType, valArray)
	--[[
	-- Gets a message from the cfg table and formats it if appropriate.
	-- The function raises an error if the value from the cfg table is not
	-- of the type expectType.
	-- If the table valArray is present, strings such as $1, $2 etc. in the
	-- message are substituted with values from the table keys [1], [2] etc.
	-- For example, if the message cfg.fooMessage had the value 'Foo $2 bar $1.',
	-- message('fooMessage', 'string', {'baz', 'qux'}) would return "Foo qux bar baz."
	--]]
	local msg = cfg[cfgKey]
	if expectType and type(msg) ~= expectType then
		error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2)
	end
	if not valArray then
		return msg
	end

	local function getMessageVal(match)
		match = tonumber(match)
		return valArray[match] or error('message: no value found for key $' .. match .. ' in message cfg.' .. cfgKey, 4)
	end

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

local function makeWikilink(page, display)
	if display then
		return mw.ustring.format('[[%s|%s]]', page, display)
	else
		return mw.ustring.format('[[%s]]', page)
	end
end

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

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

local function makeToolbar(...)
	local ret = {}
	local lim = select('#', ...)
	if lim < 1 then
		return nil
	end
	for i = 1, lim do
		ret[#ret + 1] = select(i, ...)
	end
	return '<small style="font-style: normal;">(' .. table.concat(ret, ' &#124; ') .. ')</small>'
end	

----------------------------------------------------------------------------
-- Argument processing
----------------------------------------------------------------------------

local function makeInvokeFunc(funcName)
	return function (frame)
		local headingArg = message('headingArg', 'string')
		local args = getArgs(frame, {
			valueFunc = function (key, value)
				if type(value) == 'string' then
					value = value:match('^%s*(.-)%s*$') -- Remove whitespace.
					if key == headingArg or value ~= '' then
						return value
					else
						return nil
					end
				else
					return value
				end
			end
		})
		return p[funcName](args)
	end
end

----------------------------------------------------------------------------
-- Main function
----------------------------------------------------------------------------

p.main = makeInvokeFunc('_main')

function p._main(args)
	-- Get environment data, using pcall in case we get any errors.
	local success, env = pcall(p.getEnv, args)
	if not success then
		return string.format('<strong class="error">[[Module:Documentation]] error: %s</strong>', env) -- If there's an error, env is the error message.
	end
	-- Build the documentation.
	local root = htmlBuilder.create()
	root
		.wikitext(p.protectionTemplate(env))
		.wikitext(p.sandboxNotice(args, env))
		 -- This div tag is from {{documentation/start box}}, but moving it here
		 -- so that we don't have to worry about unclosed tags.
		.tag('div')
			.attr('id', message('mainDivId', 'string'))
			.addClass(message('mainDivClasses', 'string'))
			.newline()
			.wikitext(p._startBox(args, env))
			.wikitext(p._content(args, env))
			.tag('div')
				.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
				.newline()
				.done()
			.done()
		.wikitext(p._endBox(args, env))
		.newline()
		.wikitext(p.addTrackingCategories(env))
	return tostring(root)
end

----------------------------------------------------------------------------
-- Environment settings
----------------------------------------------------------------------------

function p.getEnv(args)
	-- Returns a table with information about the environment, including the title to use, the subject namespace, etc.
	-- This is called from p._main using pcall in case we get any errors from exceeding the expensive function count
	-- limit, or other perils unknown.
	--
	-- Data includes:
	-- env.title - the title object of the page we are making documentation for (usually the current title)
	-- env.subjectSpace - the number of the title's subject namespace.
	-- env.docspace - the name of the namespace the title puts its documentation in.
	-- env.templatePage - the name of the template page with no namespace or interwiki prefixes.
	local env = {}

	-- Get the title.
	local title
	local titleArg = args[message('titleArg', 'string')]
	if titleArg then
		title = mw.title.new(titleArg)
		if not title then
			error(message('titleArgError', 'string', {titleArg}))
		end
	else
		title = mw.title.getCurrentTitle()
	end
	env.title = title

	-- Get the subject namespace number.
	local subjectSpace = mw.site.namespaces[title.namespace].subject.id
	env.subjectSpace = subjectSpace
	
	-- Get the name of the documentation namespace.
	local docspace
	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.
		docspace = mw.site.namespaces[subjectSpace].talk.name 
	else
		docspace = title.subjectNsText
	end
	env.docspace = docspace
	
	-- Get the template page with no namespace or interwiki prefixes.
	local templatePage
	local subpage = title.subpageText
	if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
		templatePage = title.baseText
	else
		templatePage = title.text
	end
	env.templatePage = templatePage

	return env
end	

----------------------------------------------------------------------------
-- Auxiliary templates
----------------------------------------------------------------------------

function p.sandboxNotice(args, env)
	local sandboxNoticeTemplate = message('sandboxNoticeTemplate', 'string')
	if not (sandboxNoticeTemplate and env.title.subpageText == message('sandboxSubpage', 'string')) then
		return nil
	end
	local frame = mw.getCurrentFrame()
	local notice = htmlBuilder.create()
	notice
		.tag('div')
			.css('clear', 'both')
			.done()
		.wikitext(frame:expandTemplate{title = sandboxNoticeTemplate, args = {[message('sandboxNoticeLivepageParam')] = args[message('livepageArg', 'string')]}})
	return tostring(notice)
end

function p.protectionTemplate(env)
	local title = env.title
	local protectionTemplate = message('protectionTemplate', 'string')
	if not (protectionTemplate and title.namespace == 10) then
		-- Don't display the protection template if we are not in the template namespace.
		return nil
	end
	local frame = mw.getCurrentFrame()
	local function getProtectionLevel(protectionType, page)
		-- Gets the protection level for page, or for the current page if page is not specified.
		local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType, page)
		if level ~= '' then
			return level
		else
			return nil -- The parser function returns the blank string if there is no match.
		end
	end
	local prefixedTitle = title.prefixedText
	if getProtectionLevel('move', prefixedTitle) == 'sysop' or getProtectionLevel('edit', prefixedTitle) then
		-- The page is full-move protected, or full, template, or semi-protected.
		return frame:expandTemplate{title = protectionTemplate, args = message('protectionTemplateArgs', 'table')}
	end
	return nil
end

----------------------------------------------------------------------------
-- Start box
----------------------------------------------------------------------------

p.startBox = makeInvokeFunc('_startBox')

function p._startBox(args, env)
	-- Arg processing from {{documentation}}.
	local preload = args[message('preloadArg', 'string')] -- Allow custom preloads.
	local heading = args[message('headingArg', 'string')] -- Blank values are not removed.
	local headingStyle = args[message('headingStyleArg', 'string')]
	local content = args[message('contentArg', 'string')]
	local docspace = env.docspace
	local docname = args[1] -- Other docname, if fed.
	local templatePage = env.templatePage

	-- Arg processing from {{documentation/start box2}}.
	local docpage
	if docname then
		docpage = docname
	else
		local namespace = docspace or currentTitle.nsText
		local pagename = templatePage or currentTitle.text
		docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string')
	end
	local docTitle = mw.title.new(docpage)
	local docExist = docTitle.exists
	
	-- Output from {{documentation/start box}}.

	-- First, check the heading parameter.
	if heading == '' then
		-- Heading is defined but blank, so do nothing.
		return nil
	end

	-- Build the start box div.
	local sbox = htmlBuilder.create('div')
	sbox
		.css('padding-bottom', '3px')
		.css('border-bottom', '1px solid #aaa')
		.css('margin-bottom', '1ex')
		.newline()

	-- Make the heading.
	local hspan = sbox.tag('span')
	if headingStyle then
		hspan.cssText(headingStyle)
	elseif subjectSpace == 10 then
		-- We are in the template or template talk namespaces.
		hspan
			.css('font-weight', 'bold')
			.css('fond-size', '125%')
	else
		hspan.css('font-size', '150%')
	end
	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

	-- 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(currentTitle: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

----------------------------------------------------------------------------
-- Documentation content
----------------------------------------------------------------------------

p.content = makeInvokeFunc('_content')

function p._content(args)
	local content = args[message('contentArg', 'string')]
	if not content then
		local docpage = args[1]
		if docpage and mw.title.new(docpage).exists then
			local frame = mw.getCurrentFrame()
			content = frame:preprocess('{{ ' .. docpage .. ' }}')
		else
			docpage = p.docspace() .. ':' .. p.templatePage() .. '/' .. message('docSubpage', 'string')
			if mw.title.new(docpage).exists then
				local frame = mw.getCurrentFrame()
				content = frame:preprocess('{{ ' .. docpage .. ' }}')
			end
		end
	end
	-- The line breaks below are necessary so that "=== Headings ===" at the start and end
	-- of docs are interpreted correctly.
	return '\n' .. (content or '') .. '\n' 
end

----------------------------------------------------------------------------
-- End box
----------------------------------------------------------------------------

p.endBox = makeInvokeFunc('_endBox')

function p._endBox(args)
	-- Argument processing in {{documentation}}.
	local content = args[message('contentArg', 'string')]
	local linkBox = args[message('linkBoxArg', 'string')] -- So "link box=off" works.
	local docspace = p.docspace()
	local docname = args[1] -- Other docname, if fed.
	local templatePage = p.templatePage()

	-- Argument processing in {{documentation/end box2}}.
	local docpageRoot = (docspace or currentTitle.nsText) .. ':' .. (templatePage or currentTitle.text)
	local docpage
	if docname then
		docpage = docname
	else
		docpage = docpageRoot .. '/' .. message('docSubpage', 'string')
	end
	local docTitle = mw.title.new(docpage)
	local docExist = docTitle.exists
	local docnameFed = args[1] and true
	local sandbox = docpageRoot .. '/' .. message('sandboxSubpage', 'string')
	local testcases = docpageRoot .. '/' .. message('testcasesSubpage', 'string')
	templatePage = currentTitle.nsText .. ':' .. templatePage

	-- Output from {{documentation/end box}}
	
	-- First, check whether we should output the end box at all. Add the end box by default if the documentation
	-- exists or if we are in the user, module or template namespaces.
	if linkBox == message('linkBoxOff', 'string') or not (docExist or subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10) then
		return nil
	end

	-- Assemble the arguments for {{fmbox}}.
	local fmargs = {}
	fmargs[message('fmboxIdParam', 'string')] = message('fmboxId', 'string') -- Sets fmargs.id = 'documentation-meta-data'
	fmargs[message('fmboxImageParam', 'string')] = message('fmboxImageNone', 'string') -- Sets fmargs.image = 'none'
	fmargs[message('fmboxStyleParam', 'string')] = message('fmboxStyle', 'string') -- Sets fmargs.style = 'background-color: #ecfcf4'
	fmargs[message('fmboxTextstyleParam', 'string')] = message('fmboxTextstyle', 'string') -- Sets fmargs.textstyle = 'font-style: italic;'

	-- Assemble the fmbox text field.
	local text = ''
	if linkBox then
		-- Use custom link box content if it is defined.
		text = text .. linkBox
	else
		if docExist then
			-- /doc exists; link to it.
			local docLink = makeWikilink(docpage)
			local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, message('editLinkDisplay', 'string'))
			local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, message('historyLinkDisplay', 'string'))
			text = text .. message('transcludedFromBlurb', 'string', {docLink}) .. ' ' .. makeToolbar(editLink, historyLink) .. '<br />'
		elseif subjectSpace == 828 then
			-- /doc does not exist; ask to create it.
			local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = message('modulePreload', 'string')}, message('createLinkDisplay', 'string'))
			text = text .. message('createModuleDocBlurb', 'string', {createLink}) .. '<br />'
		end
		-- Add links to /sandbox and /testcases when appropriate.
		if subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10 then
			-- We are in the user, module or template namespaces. 
			local sandboxLinks, testcasesLinks
			local pagePossessive = subjectSpace == 828 and message('modulePossessive', 'string') or message('templatePossessive', 'string')
			local sandboxTitle = mw.title.new(sandbox)
			if sandboxTitle.exists then
				local sandboxLink = makeWikilink(sandbox, message('sandboxLinkDisplay', 'string'))
				local sandboxEditLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit'}, message('sandboxEditLinkDisplay', 'string'))
				local compareLink = makeUrlLink(mw.title.new('Special:ComparePages'):fullUrl{page1 = templatePage, page2 = sandbox}, message('compareLinkDisplay', 'string'))
				sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
			else
				local sandboxPreload = subjectSpace == 828 and message('moduleSandboxPreload', 'string') or message('templateSandboxPreload', 'string')
				local sandboxCreateLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}, message('sandboxCreateLinkDisplay', 'string'))
				local mirrorSummary = message('mirrorEditSummary', 'string', {makeWikilink(templatePage)})
				local mirrorLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = templatePage, summary = mirrorSummary}, message('mirrorLinkDisplay', 'string'))
				sandboxLinks = message('sandboxLinkDisplay', 'string') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
			end
			local testcaseTitle = mw.title.new(testcases)
			if testcaseTitle.exists then
				local testcasesLink = makeWikilink(testcases, message('testcasesLinkDisplay', 'string'))
				local testcasesEditLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit'}, message('testcasesEditLinkDisplay', 'string'))
				testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
			else
				local testcasesPreload = subjectSpace == 828 and message('moduleTestcasesPreload', 'string') or message('templateTestcasesPreload', 'string')
				local testcasesCreateLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit', preload = testcasesPreload}, message('testcasesCreateLinkDisplay', 'string'))
				testcasesLinks = message('testcasesLinkDisplay', 'string') .. ' ' .. makeToolbar(testcasesCreateLink)
			end
			text = text .. message('experimentBlurb', 'string', {pagePossessive, sandboxLinks, testcasesLinks}) .. '<br />'
			-- Show the categories text, but not if "content" fed or "docname fed" since then it is unclear where to add the categories.
			if not content and not docnameFed then
				local docPathLink = makeWikilink(docpage, message('docLinkDisplay', 'string'))
				text = text .. message('addCategoriesBlurb', 'string', {docPathLink})
			end
			-- Show the "subpages" link.
			if subjectSpace ~= 6 then -- Don't show the link in file space.
				local pagetype
				if subjectSpace == 10 then
					pagetype = message('templatePagetype', 'string')
				elseif subjectSpace == 828 then
					pagetype = message('modulePagetype', 'string')
				else
					pagetype = message('defaultPagetype', 'string')
				end
				text = text .. ' ' .. makeWikilink('Special:PrefixIndex/' .. templatePage .. '/', message('subpagesLinkDisplay', 'string', {pagetype}))
			end
			-- Show the "print" link if it exists.
			local printPage = templatePage .. '/' .. message('printSubpage', 'string')
			local printTitle = mw.title.new(printPage)
			if printTitle.exists then
				local printLink = makeWikilink(printPage, message('printLinkDisplay', 'string'))
				text = text .. '<br />' .. message('printBlurb', 'string', {printLink})
					.. (message('displayPrintCategory', 'boolean') and makeCategoryLink(message('printCategory', 'string')) or '')
			end
		end
	end
	fmargs.text = text

	-- Return the fmbox output.
	return messageBox.main('fmbox', fmargs)
end

----------------------------------------------------------------------------
-- Tracking categories
----------------------------------------------------------------------------

function p.addTrackingCategories()
	-- Check if {{documentation}} is transcluded on a /doc or /testcases page.
	local ret = ''
	local subpage = currentTitle.subpageText
	if message('displayStrangeUsageCategory', 'boolean') and (subpage == message('docSubpage', 'string') or subpage == message('testcasesSubpage', 'string')) then
		local sort = (currentTitle.namespace == 0 and message('strangeUsageCategoryMainspaceSort', 'string') or '') .. currentTitle.prefixedText -- Sort on namespace.
		ret = ret .. makeCategoryLink(message('strangeUsageCategory', 'string'), sort)
	end
	return ret
end

return p
Retrieved from "https://www.wikidoc.org/index.php?title=Module:Documentation&oldid=1290794"