Module:Documentation

    From Nonbinary Wiki
    Revision as of 02:04, 15 January 2014 by m>Mr. Stradivarius (finish splitting the _startBox function into smaller functions)

    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
    --
    -- These are defined as local functions, but are made available in the p
    -- table for testing purposes.
    ----------------------------------------------------------------------------
    
    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
    
    p.message = message
    
    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
    
    p.makeWikilink = makeWikilink
    
    local function makeCategoryLink(cat, sort)
    	local catns = mw.site.namespaces[14].name
    	return makeWikilink(catns .. ':' .. cat, sort)
    end
    
    p.makeCategoryLink = makeCategoryLink
    
    local function makeUrlLink(url, display)
    	return mw.ustring.format('[%s %s]', url, display)
    end
    
    p.makeUrlLink = makeUrlLink
    
    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	
    
    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
    
    ----------------------------------------------------------------------------
    -- 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)
    	local env = p.getEnvironment(args)
    	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.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
    	-- 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, envFuncs = {}, {}
    
    	-- Set up the metatable. If a nil value is called, we call that function in the envFuncs table and memoize it
    	-- in the env table so we don't have to call any of the functions more than once.
    	setmetatable(env, {
    		__index = function (t, key)
    			local envFunc = envFuncs[key]
    			if envFunc then
    				local val = envFunc()
    				env[key] = val
    				return val
    			else
    				return nil
    			end
    		end
    	})	
    
    	-- Get the title.
    	function envFuncs.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
    		return title
    	end
    
    	-- Get the subject namespace number.
    	function envFuncs.subjectSpace()
    		return mw.site.namespaces[env.title.namespace].subject.id
    	end
    	
    	-- Get the name of the documentation namespace.
    	function envFuncs.docspace()
    		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 subpage = title.subpageText
    		if subpage == message('sandboxSubpage', 'string') or subpage == message('testcasesSubpage', 'string') then
    			return title.baseText
    		else
    			return title.text
    		end
    	end
    
    	function envFuncs.docTitle()
    		local title = env.title
    		local docname = args[1] -- Other docname, if fed.
    		local docspace = env.docspace
    		local templatePage = env.templatePage
    		local docpage
    		if docname then
    			docpage = docname
    		else
    			local namespace = docspace or title.nsText
    			local pagename = templatePage or title.text
    			docpage = namespace .. ':' .. pagename .. '/' .. message('docSubpage', 'string')
    		end
    		return mw.title.new(docpage)
    	end
    
    	function env:grab(key)
    		local success, val = pcall(function() return self[key] end)
    		return success, val
    	end
    
    	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)
    	-- Generate [view][edit][history][purge] or [create] links.
    	local links
    	local content = args[message('contentArg', 'string')]
    	if not content then
    		-- No need to include the links if the documentation is on the template page itself.
    		local linksData = p.makeStartBoxLinksData(args, env)
    		links = p.renderStartBoxLinks(linksData)
    	end
    	-- Generate the start box html.
    	local data = p.makeStartBoxData(args, env, links)
    	if type(data) == 'table' then
    		return p.renderStartBox(data)
    	elseif type(data) == 'string' then
    		-- data is an error message.
    		return data
    	else
    		-- User specified no heading.
    		return nil
    	end
    end
    
    function p.makeStartBoxLinksData(args, env)
    	local data = {}
    	-- Get title objects.
    	local titleSuccess, title = env:grab('title')
    	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.
    	data.viewLinkDisplay = message('viewLinkDisplay', 'string')
    	data.editLinkDisplay = message('editLinkDisplay', 'string')
    	data.historyLinkDisplay = message('historyLinkDisplay', 'string')
    	data.purgeLinkDisplay = message('purgeLinkDisplay', 'string')
    	-- Create link if /doc doesn't exist.
    	local preload = args[message('preloadArg', 'string')]
    	if not preload then
    		if env.subjectSpace == 6 then -- File namespace
    			preload = message('fileDocpagePreload', 'string')
    		else
    			preload = message('docpagePreload', 'string')
    		end
    	end
    	data.preload = preload
    	data.createLinkDisplay = message('createLinkDisplay', 'string')
    	return data
    end
    
    function p.renderStartBoxLinks(data)
    	-- Render the [view][edit][history][purge] or [create] links.
    	local ret
    	local docTitle = data.docTitle
    	local title = data.title
    	if docTitle.exists then
    		local viewLink = makeWikilink(docpage, data.viewLinkDisplay)
    		local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay)
    		local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay)
    		local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
    		ret = '[%s] [%s] [%s] [%s]'
    		ret = ret:gsub('%[', '&#91;') -- Replace square brackets with HTML entities.
    		ret = ret:gsub('%]', '&#93;')
    		ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink)
    	else
    		ret = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)
    	end
    end
    
    function p.makeStartBoxData(args, env, links)
    	local subjectSpace = env.subjectSpace
    	local data = {}
    	
    	-- Heading
    	local heading = args[message('headingArg', 'string')] -- 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('documentationIconWikitext', 'string') .. ' ' .. message('templateNamespaceHeading', 'string')
    	elseif subjectSpace == 828 then -- Module namespace
    		data.heading = message('documentationIconWikitext', 'string') .. ' ' .. message('moduleNamespaceHeading', 'string')
    	elseif subjectSpace == 6 then -- File namespace
    		data.heading = message('fileNamespaceHeading', 'string')
    	else
    		data.heading = message('otherNamespacesHeading', 'string')
    	end
    	
    	-- Heading CSS
    	local headingStyle = args[message('headingStyleArg', 'string')]
    	if headingStyle then
    		data.headingStyleText = headingStyle
    	elseif subjectSpace == 10 then
    		-- We are in the template or template talk namespaces.
    		data.headingFontWeight = 'bold'
    		data.headingFontSize = '125%'
    	else
    		data.headingFontSize = '150%'
    	end
    	
    	-- [view][edit][history][purge] or [create] links.
    	if links then
    		data.linksClass = message('startBoxLinkclasses', 'string')
    		data.linksId = message('startBoxLinkId', 'string')
    		data.links = links
    	end
    	
    	return data
    end
    
    function p.renderStartBox(data)
    	-- Renders the start box html.
    	local sbox = htmlBuilder.create('div')
    	sbox
    		.css('padding-bottom', '3px')
    		.css('border-bottom', '1px solid #aaa')
    		.css('margin-bottom', '1ex')
    		.newline()
    		.tag('span')
    			.cssText(data.headingStyleText)
    			.css('font-weight', data.headingFontWeight)
    			.css('font-size', data.headingFontSize)
    			.wikitext(data.heading)
    	local links = data.links
    	if links then
    		sbox.tag('span')
    			.addClass(data.linksClass)
    			.attr('id', data.linksId)
    			.wikitext(links)
    	end
    	return tostring(sbox)
    end
    
    ----------------------------------------------------------------------------
    -- Documentation content
    ----------------------------------------------------------------------------
    
    p.content = makeInvokeFunc('_content')
    
    function p._content(args, env)
    	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 = env.docspace .. ':' .. env.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, env)
    	local title = env.title
    	local subjectSpace = env.subjectSpace
    
    	-- Argument processing in {{documentation}}.
    	local content = args[message('contentArg', 'string')]
    	local linkBox = args[message('linkBoxArg', 'string')] -- So "link box=off" works.
    	local docspace = env.docspace
    	local docname = args[1] -- Other docname, if fed.
    	local templatePage = env.templatePage
    
    	-- Argument processing in {{documentation/end box2}}.
    	local docpageRoot = (docspace or title.nsText) .. ':' .. (templatePage or title.text)
    	local docpage
    	if docname then
    		docpage = docname
    	else
    		docpage = docpageRoot .. '/' .. message('docSubpage', 'string')
    	end
    	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 = title.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(env)
    	-- Check if {{documentation}} is transcluded on a /doc or /testcases page.
    	local title = env.title
    	local ret = ''
    	local subpage = title.subpageText
    	if message('displayStrangeUsageCategory', 'boolean') and (subpage == message('docSubpage', 'string') or subpage == message('testcasesSubpage', 'string')) then
    		local sort = (title.namespace == 0 and message('strangeUsageCategoryMainspaceSort', 'string') or '') .. title.prefixedText -- Sort on namespace.
    		ret = ret .. makeCategoryLink(message('strangeUsageCategory', 'string'), sort)
    	end
    	return ret
    end
    
    return p