Module:Documentation

This module displays a green box containing documentation for templates, Lua modules, or other pages. The {{documentation}} template invokes it.

Normal usage

For most uses, you should use the {{documentation}} template; please see that template's page for its usage instructions and parameters.

Use in other modules

To use this module from another Lua module, first load it with require:

local documentation = require('Module:Documentation').main

Then you can simply call it using a table of arguments.

documentation{content = 'Some documentation', ['link box'] = 'My custom link box'}

Please refer to the template documentation for usage instructions and a list of parameters.

Porting to other wikis

The module has a configuration file at Module:Documentation/config which is intended to allow easy translation and porting to other wikis. Please see the code comments in the config page for instructions. If you have any questions, or you need a feature which is not currently implemented, please leave a message at Template talk:Documentation to get the attention of a developer.

The messages that need to be customized to display a documentation template/module at the top of module pages are MediaWiki:Scribunto-doc-page-show and MediaWiki:Scribunto-doc-page-does-not-exist.

---

-- This module implements {{documentation}}.

----------------------------------------------------------------------------
-- Configuration
----------------------------------------------------------------------------

-- Here you can set the values of the parameters and messages used in this module, so that it
-- can be easily ported to other wikis.

local cfg = {}

-- Argument names
-- The following are all names of arguments that affect the behaviour of {{documentation}}.
-- The comments next to the configuration values are the effects that the argument has
-- on the module. (Not the effects of the argument names themselves.)

cfg.livepageArg = 'livepage' -- Name of the live template; used in {{template sandbox notice}}.
cfg.headingArg = 'heading' -- Custom heading used in the start box.
cfg.preloadArg = 'preload' -- Custom preload page for creating documentation.
cfg.headingStyleArg = 'heading-style' -- Custom CSS style for the start box heading.
cfg.contentArg = 'content' -- Passes documentation content directly from the {{documentation}} invocation.
cfg.linkBoxArg = 'link box' -- Specifies a custom link box (end box) or prevents it from being generated.

-- Software settings
-- The following are software settings that may change from wiki to wiki. For example, the classes
-- defined in commons.css or the names of templates.

cfg.mainDivId = 'template-documentation' -- The "id" attribute of the main HTML "div" tag.
cfg.mainDivClasses = 'template-documentation iezoomfix' -- The CSS classes added to the main HTML "div" tag.
cfg.sandboxSubpage = 'sandbox' -- The name of the template subpage typically used for sandboxes.
cfg.sandboxNoticeTemplate = 'template sandbox notice' -- The name of the template to display at the top of sandbox pages.
cfg.sandboxNoticeLivepageParam = 1 -- The parameter of the sandbox notice template to send the cfg.livepageArg to.

-- Display settings
-- The following settings configure the values displayed by the module.

cfg.sandboxLinkDisplay = 'sandbox'

----------------------------------------------------------------------------
-- End configuration
----------------------------------------------------------------------------

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

local p = {}

-- Constants.
local currentTitle = mw.title.getCurrentTitle()
local subjectSpace = mw.site.namespaces[currentTitle.namespace].subject.id

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

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

----------------------------------------------------------------------------
-- Main functions
----------------------------------------------------------------------------

p.main = makeInvokeFunc('_main')

function p._main(args)
	local root = htmlBuilder.create()
	root
		.wikitext(p.protectionTemplate())
		.wikitext(p.sandboxNotice(args))
		 -- 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', cfg.mainDivId)
			.addClass(cfg.mainDivClasses)
			.wikitext(p._startBox(args))
			.wikitext(p._content(args))
			.tag('div')
				.css('clear', 'both') -- So right or left floating items don't stick out of the doc box.
				.done()
			.done()
		.wikitext(p._endBox(args))
		.wikitext(p.addTrackingCategories())
	return tostring(root)
end

function p.sandboxNotice(args)
	local sandboxNoticeTemplate = cfg.sandboxNoticeTemplate
	if not (sandboxNoticeTemplate and currentTitle.subpageText == cfg.sandboxSubpage) 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 = {[cfg.sandboxNoticeLivepageParam] = args[cfg.livepageArg]}})
	return tostring(notice)
end

function p.protectionTemplate()
	if currentTitle.namespace == 10 then -- We are in the template namespace.
		local frame = mw.getCurrentFrame()

		local function getProtectionLevel(protectionType)
			-- Gets the protection level for the current page.
			local level = frame:callParserFunction('PROTECTIONLEVEL', protectionType)
			if level ~= '' then
				return level
			else
				return nil -- The parser function returns the blank string if there is no match.
			end
		end

		if getProtectionLevel('move') == 'sysop' or getProtectionLevel('edit') then
			-- The page is full-move protected, or full, template, or semi-protected.
			return frame:expandTemplate{title = 'pp-template', args = {docusage = 'yes'}}
		end
	end
	return nil
end

p.startBox = makeInvokeFunc('_startBox')

function p._startBox(args)
	-- Arg processing from {{documentation}}.
	local preload = args[cfg.preloadArg] -- Allow custom preloads.
	local heading = args[cfg.headingArg] -- Blank values are not removed.
	local headingStyle = args[cfg.headingStyleArg]
	local content = args[cfg.contentArg]
	local docspace = p.docspace()
	local docname = args[1] -- Other docname, if fed.
	local templatePage = p.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 .. '/doc'
	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')

	-- 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('[[File:Template-info.png|50px|link=|alt=Documentation icon]] Template documentation')
	elseif subjectSpace == 828 then -- Module namespace
		hspan.wikitext('[[File:Template-info.png|50px|link=|alt=Documentation icon]] Module documentation')
	elseif subjectSpace == 6 then -- File namespace
		hspan.wikitext('Summary')
	else
		hspan.wikitext('Documentation')
	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('mw-editsection plainlinks')
			.attr('id', 'doc_editlinks')
		if docExist then
			local viewLink = makeWikilink(docpage, 'view')
			local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, 'edit')
			local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, 'history')
			local purgeLink = makeUrlLink(docTitle:fullUrl{action = 'purge'}, 'purge')
			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 = 'Template:Documentation/preload-filespace'
				else
					preload = 'Template:Documentation/preload'
				end
			end
			lspan.wikitext(makeUrlLink(docTitle:fullUrl{action = 'edit', preload = preload}, 'create'))
		end
	end

	return tostring(sbox)
end

p.content = makeInvokeFunc('_content')

function p._content(args)
	local content = args[cfg.contentArg]
	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() .. '/doc'
			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

p.endBox = makeInvokeFunc('_endBox')

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

	-- 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 .. '/doc'
	end
	local docTitle = mw.title.new(docpage)
	local docExist = docTitle.exists
	local docnameFed = args[1] and true
	local sandbox = docpageRoot .. '/' .. cfg.sandboxSubpage
	local testcases = docpageRoot .. '/testcases'
	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 == 'off' or not (docExist or subjectSpace == 2 or subjectSpace == 828 or subjectSpace == 10) then
		return nil
	end

	-- Assemble the arguments for {{fmbox}}.
	local fmargs = {}
	fmargs.id = 'documentation-meta-data'
	fmargs.image = 'none'
	fmargs.style = 'background-color: #ecfcf4'
	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'}, 'edit')
			local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, 'history')
			text = text .. 'The above [[Wikipedia:Template documentation|documentation]] is [[Wikipedia:Transclusion|transcluded]] from '
				.. 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 = 'Template:Documentation/preload-module-doc'}, 'create')
			text = text .. 'You might want to ' .. createLink .. ' a documentation page for this [[Wikipedia:Lua|Scribunto module]].<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 pagePossessive = subjectSpace == 828 and "module's" or "template's"
			text = text .. 'Editors can experiment in this ' .. pagePossessive .. ' '
			local sandboxTitle = mw.title.new(sandbox)
			if sandboxTitle.exists then
				local sandboxLink = makeWikilink(sandbox, cfg.sandboxLinkDisplay)
				local sandboxEditLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit'}, 'edit')
				local compareLink = makeUrlLink(mw.title.new('Special:ComparePages'):fullUrl{page1 = templatePage, page2 = sandbox}, 'diff')
				text = text .. sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
			else
				local sandboxPreload = 'Template:Documentation/preload-' .. (subjectSpace == 828 and 'module-' or '') .. 'sandbox'
				local sandboxCreateLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}, 'create')
				local mirrorSummary = 'Create sandbox version of ' .. makeWikilink(templatePage)
				local mirrorLink = makeUrlLink(sandboxTitle:fullUrl{action = 'edit', preload = templatePage, summary = mirrorSummary}, 'mirror')
				text = text .. cfg.sandboxLinkDisplay .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
			end
			text = text .. ' and '
			local testcaseTitle = mw.title.new(testcases)
			if testcaseTitle.exists then
				local testcasesLink = makeWikilink(testcases, 'testcases')
				local testcasesEditLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit'}, 'edit')
				text = text .. testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
			else
				local testcasesPreload = 'Template:Documentation/preload-' .. (subjectSpace == 828 and 'module-' or '') .. 'testcases'
				local testcasesCreateLink = makeUrlLink(testcaseTitle:fullUrl{action = 'edit', preload = testcasesPreload}, 'create')
				text = text .. 'testcases ' .. makeToolbar(testcasesCreateLink)
			end
			text = text .. ' pages. <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
				text = text .. 'Please add categories to the ' .. makeWikilink(docpage, '/doc') .. ' subpage.'
			end
			-- Show the "subpages" link.
			if subjectSpace ~= 6 then -- Don't show the link in file space.
				local pagetype
				if subjectSpace == 10 then
					pagetype = 'template'
				elseif subjectSpace == 828 then
					pagetype = 'module'
				else
					pagetype = 'page'
				end
				text = text .. ' ' .. makeWikilink('Special:PrefixIndex/' .. templatePage .. '/', 'Subpages of this ' .. pagetype)
			end
			-- Show the "print" link if it exists.
			local printPage = templatePage .. '/Print'
			local printTitle = mw.title.new(printPage)
			if printTitle.exists then
				text = text .. '<br />A [[Help:Books/for experts#Improving the book layout|print version]] of this template exists at '
					.. makeWikilink(printPage, '/Print') .. '. If you make a change to this template, please update the print version as well.'
					.. '[[Category:Templates with print versions]]'
			end
		end
	end
	fmargs.text = text

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

function p.addTrackingCategories()
	-- Check if {{documentation}} is transcluded on a /doc or /testcases page.
	local ret = ''
	local subpage = currentTitle.subpageText
	if subpage == 'doc' or subpage == 'testcases' then
		local sort = (currentTitle.namespace == 0 and 'Main:' or '') .. currentTitle.prefixedText -- Sort on namespace.
		ret = ret .. makeWikilink('Category:Wikipedia pages with strange ((documentation)) usage', sort)
	end
	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 == cfg.sandboxSubpage or subpage == 'testcases' then
		return currentTitle.baseText
	else
		return currentTitle.text
	end
end

return p