Module:Documentation

 -- This module implements {{documentation}}.

 -- Get required modules.
 localgetArgs=require('Module:Arguments').getArgs
 localmessageBox=require('Module:Message box')

 -- Get the config table.
 localcfg=mw.loadData('Module:Documentation/config')
 locali18n=mw.loadData('Module:Documentation/i18n')
 localp={}

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

 ----------------------------------------------------------------------------
 -- Helper functions
 --
 -- These are defined as local functions, but are made available in the p
 -- table for testing purposes.
 ----------------------------------------------------------------------------

 localfunctionmessage(cfgKey,valArray,expectType)
 --[[
 	-- 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. The default type for expectType is 'string'.
 	-- 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 "foo-message" had the value 'Foo 2ドル bar 1ドル.',
 	-- message('foo-message', {'baz', 'qux'}) would return "Foo qux bar baz."
 	--]]
 localmsg=cfg[cfgKey]
 expectType=expectTypeor'string'
 iftype(msg)~=expectTypethen
 error(require('Module:TNT').format('I18n/Documentation','cfg-error-msg-type',cfgKey,expectType,type(msg)),2)
 end
 ifnotvalArraythen
 returnmsg
 end

 localfunctiongetMessageVal(match)
 match=tonumber(match)
 returnvalArray[match]orerror(require('Module:TNT').format('I18n/Documentation','cfg-error-msg-empty','$'..match,cfgKey),4)
 end

 localret=ugsub(msg,'$([1-9][0-9]*)',getMessageVal)
 returnret
 end

 p.message=message

 localfunctionmakeWikilink(page,display)
 ifdisplaythen
 returnmw.ustring.format('[[%s|%s]]',page,display)
 else
 returnmw.ustring.format('[[%s]]',page)
 end
 end

 p.makeWikilink=makeWikilink

 localfunctionmakeCategoryLink(cat,sort)
 localcatns=mw.site.namespaces[14].name
 returnmakeWikilink(catns..':'..cat,sort)
 end

 p.makeCategoryLink=makeCategoryLink

 localfunctionmakeUrlLink(url,display)
 returnmw.ustring.format('[%s %s]',url,display)
 end

 p.makeUrlLink=makeUrlLink

 localfunctionmakeToolbar(...)
 localret={}
 locallim=select('#',...)
 iflim<1then
 returnnil
 end
 fori=1,limdo
 ret[#ret+1]=select(i,...)
 end
 return'<small style="font-style: normal;">('..table.concat(ret,' &#124; ')..')</small>'
 end

 p.makeToolbar=makeToolbar

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

 localfunctionmakeInvokeFunc(funcName)
 returnfunction(frame)
 localargs=getArgs(frame,{
 valueFunc=function(key,value)
 iftype(value)=='string'then
 value=value:match('^%s*(.-)%s*$')-- Remove whitespace.
 ifkey=='heading'orvalue~=''then
 returnvalue
 else
 returnnil
 end
 else
 returnvalue
 end
 end
 })
 returnp[funcName](args)
 end
 end

 ----------------------------------------------------------------------------
 -- Load TemplateStyles
 ----------------------------------------------------------------------------

 p.main=function(frame)
 localparent=frame.getParent(frame)
 localoutput=p._main(parent.args)
 returnframe:extensionTag{name='templatestyles',args={src=message('templatestyles-scr')}}..output
 end

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

 functionp._main(args)
 --[[
 	-- This function defines logic flow for the module.
 	-- @args - table of arguments passed by the user
 	-- 
 	-- Messages:
 	-- 'main-div-id' --> 'template-documentation'
 	-- 'main-div-classes' --> 'template-documentation iezoomfix'
 	--]]
 localenv=p.getEnvironment(args)
 localroot=mw.html.create()
 root
 :wikitext(p._getModuleWikitext(args,env))
 :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('main-div-id'))
 :addClass(message('main-div-class'))
 :wikitext(p._startBox(args,env))
 :wikitext(p._content(args,env))
 :done()
 :wikitext(p._endBox(args,env))
 :wikitext(p.addTrackingCategories(env))
 returntostring(root)
 end

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

 functionp.getEnvironment(args)
 --[[
 	-- Returns a table with information about the environment, including title 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.
 	-- env.printTitle - the print version of the template, located at the /Print subpage.
 	--
 	-- Data includes:
 	-- env.protectionLevels - the protection levels table of the title object.
 	-- env.subjectSpace - the number of the title's subject namespace.
 	-- env.docSpace - the number of the namespace the title puts its documentation in.
 	-- 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.
 	--]]

 localenv,envFuncs={},{}

 -- Set up the metatable. If triggered we call the corresponding function in the envFuncs table. The value
 -- 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,{
 __index=function(t,key)
 localenvFunc=envFuncs[key]
 ifenvFuncthen
 localsuccess,val=pcall(envFunc)
 ifsuccessthen
 env[key]=val-- Memoise the value.
 returnval
 end
 end
 returnnil
 end
 })

 functionenvFuncs.title()
 -- The title object for the current page, or a test page passed with args.page.
 localtitle
 localtitleArg=args.page
 iftitleArgthen
 title=mw.title.new(titleArg)
 else
 title=mw.title.getCurrentTitle()
 end
 returntitle
 end

 functionenvFuncs.templateTitle()
 --[[
 		-- The template (or module, etc.) title object.
 		-- Messages:
 		-- 'sandbox-subpage' --> 'sandbox'
 		-- 'testcases-subpage' --> 'testcases'
 		--]]
 localsubjectSpace=env.subjectSpace
 localtitle=env.title
 localsubpage=title.subpageText
 ifsubpage==message('sandbox-subpage')orsubpage==message('testcases-subpage')then
 returnmw.title.makeTitle(subjectSpace,title.baseText)
 else
 returnmw.title.makeTitle(subjectSpace,title.text)
 end
 end

 functionenvFuncs.docTitle()
 --[[
 		-- Title object of the /doc subpage.
 		-- Messages:
 		-- 'doc-subpage' --> 'doc'
 		--]]
 localtitle=env.title
 localdocname=args[1]-- User-specified doc page.
 localdocpage
 ifdocnamethen
 docpage=docname
 else
 docpage=env.docpageBase..'/'..message('doc-subpage')
 end
 returnmw.title.new(docpage)
 end

 functionenvFuncs.sandboxTitle()
 --[[
 		-- Title object for the /sandbox subpage.
 		-- Messages:
 		-- 'sandbox-subpage' --> 'sandbox'
 		--]]
 returnmw.title.new(env.docpageBase..'/'..message('sandbox-subpage'))
 end

 functionenvFuncs.testcasesTitle()
 --[[
 		-- Title object for the /testcases subpage.
 		-- Messages:
 		-- 'testcases-subpage' --> 'testcases'
 		--]]
 returnmw.title.new(env.docpageBase..'/'..message('testcases-subpage'))
 end

 functionenvFuncs.printTitle()
 --[[
 		-- Title object for the /Print subpage.
 		-- Messages:
 		-- 'print-subpage' --> 'Print'
 		--]]
 returnenv.templateTitle:subPageTitle(message('print-subpage'))
 end

 functionenvFuncs.protectionLevels()
 -- The protection levels table of the title object.
 returnenv.title.protectionLevels
 end

 functionenvFuncs.subjectSpace()
 -- The subject namespace number.
 returnmw.site.namespaces[env.title.namespace].subject.id
 end

 functionenvFuncs.docSpace()
 -- The documentation namespace number. For most namespaces this is the same as the
 -- subject namespace. However, pages in the Article, File, MediaWiki or Category
 -- namespaces must have their /doc, /sandbox and /testcases pages in talk space.
 localsubjectSpace=env.subjectSpace
 ifsubjectSpace==0orsubjectSpace==6orsubjectSpace==8orsubjectSpace==14then
 returnsubjectSpace+1
 else
 returnsubjectSpace
 end
 end

 functionenvFuncs.docpageBase()
 -- The base page of the /doc, /sandbox, and /testcases subpages.
 -- For some namespaces this is the talk page, rather than the template page.
 localtemplateTitle=env.templateTitle
 localdocSpace=env.docSpace
 localdocSpaceText=mw.site.namespaces[docSpace].name
 -- Assemble the link. docSpace is never the main namespace, so we can hardcode the colon.
 returndocSpaceText..':'..templateTitle.text
 end

 functionenvFuncs.compareUrl()
 -- Diff link between the sandbox and the main template using [[Special:ComparePages]].
 localtemplateTitle=env.templateTitle
 localsandboxTitle=env.sandboxTitle
 iftemplateTitle.existsandsandboxTitle.existsthen
 localcompareUrl=mw.uri.fullUrl(
 'Special:ComparePages',
 {page1=templateTitle.prefixedText,page2=sandboxTitle.prefixedText}
 )
 returntostring(compareUrl)
 else
 returnnil
 end
 end

 returnenv
 end

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

 p.getModuleWikitext=makeInvokeFunc('_getModuleWikitext')

 functionp._getModuleWikitext(args,env)
 localcurrentTitle=mw.title.getCurrentTitle()
 ifcurrentTitle.contentModel~='Scribunto'thenreturnend
 pcall(require,currentTitle.prefixedText)-- if it fails, we don't care
 localmoduleWikitext=package.loaded["Module:Module wikitext"]
 ifmoduleWikitextthen
 returnmoduleWikitext.main()
 end
 end

 functionp.sandboxNotice(args,env)
 --[=[
 	-- Generates a sandbox notice for display above sandbox pages.
 	-- @args - a table of arguments passed by the user
 	-- @env - environment table containing title objects, etc., generated with p.getEnvironment
 	-- 
 	-- Messages:
 	-- 'sandbox-notice-image' --> '[[Image:Sandbox.svg|50px|alt=|link=]]'
 	-- 'sandbox-notice-blurb' --> 'This is the 1ドル for 2ドル.'
 	-- 'sandbox-notice-diff-blurb' --> 'This is the 1ドル for 2ドル (3ドル).'
 	-- 'sandbox-notice-pagetype-template' --> '[[w:Wikipedia:Template test cases|template sandbox]] page'
 	-- 'sandbox-notice-pagetype-module' --> '[[w:Wikipedia:Template test cases|module sandbox]] page'
 	-- 'sandbox-notice-pagetype-other' --> 'sandbox page'
 	-- 'sandbox-notice-compare-link-display' --> 'diff'
 	-- 'sandbox-notice-testcases-blurb' --> 'See also the companion subpage for 1ドル.'
 	-- 'sandbox-notice-testcases-link-display' --> 'test cases'
 	-- 'sandbox-category' --> 'Template sandboxes'
 	--]=]
 localtitle=env.title
 localsandboxTitle=env.sandboxTitle
 localtemplateTitle=env.templateTitle
 localsubjectSpace=env.subjectSpace
 ifnot(subjectSpaceandtitleandsandboxTitleandtemplateTitleandmw.title.equals(title,sandboxTitle))then
 returnnil
 end
 -- Build the table of arguments to pass to {{ombox}}. We need just two fields, "image" and "text".
 localomargs={}
 omargs.image=message('sandbox-notice-image')
 -- Get the text. We start with the opening blurb, which is something like
 -- "This is the template sandbox for [[Template:Foo]] (diff)."
 localtext=''
 localframe=mw.getCurrentFrame()
 localisPreviewing=frame:preprocess('{{REVISIONID}}')==''-- True if the page is being previewed.
 localpagetype
 ifsubjectSpace==10then
 pagetype=message('sandbox-notice-pagetype-template')
 elseifsubjectSpace==828then
 pagetype=message('sandbox-notice-pagetype-module')
 else
 pagetype=message('sandbox-notice-pagetype-other')
 end
 localtemplateLink=makeWikilink(templateTitle.prefixedText)
 localcompareUrl=env.compareUrl
 ifisPreviewingornotcompareUrlthen
 text=text..message('sandbox-notice-blurb',{pagetype,templateLink})
 else
 localcompareDisplay=message('sandbox-notice-compare-link-display')
 localcompareLink=makeUrlLink(compareUrl,compareDisplay)
 text=text..message('sandbox-notice-diff-blurb',{pagetype,templateLink,compareLink})
 end
 -- Get the test cases page blurb if the page exists. This is something like
 -- "See also the companion subpage for [[Template:Foo/testcases|test cases]]."
 localtestcasesTitle=env.testcasesTitle
 iftestcasesTitleandtestcasesTitle.existsthen
 iftestcasesTitle.contentModel=="Scribunto"then
 localtestcasesLinkDisplay=message('sandbox-notice-testcases-link-display')
 localtestcasesRunLinkDisplay=message('sandbox-notice-testcases-run-link-display')
 localtestcasesLink=makeWikilink(testcasesTitle.prefixedText,testcasesLinkDisplay)
 localtestcasesRunLink=makeWikilink(testcasesTitle.talkPageTitle.prefixedText,testcasesRunLinkDisplay)
 text=text..'<br />'..message('sandbox-notice-testcases-run-blurb',{testcasesLink,testcasesRunLink})
 else
 localtestcasesLinkDisplay=message('sandbox-notice-testcases-link-display')
 localtestcasesLink=makeWikilink(testcasesTitle.prefixedText,testcasesLinkDisplay)
 text=text..'<br />'..message('sandbox-notice-testcases-blurb',{testcasesLink})
 end
 end
 -- Add the sandbox to the sandbox category.
 text=text..makeCategoryLink(message('sandbox-category'))
 omargs.text=text
 omargs.class=message('sandbox-class')
 localret='<div style="clear: both;"></div>'
 ret=ret..messageBox.main('ombox',omargs)
 returnret
 end

 functionp.protectionTemplate(env)
 -- Generates the padlock icon in the top right.
 -- @env - environment table containing title objects, etc., generated with p.getEnvironment
 -- Messages:
 -- 'protection-template' --> 'pp-template'
 -- 'protection-template-args' --> {docusage = 'yes'}
 localtitle=env.title
 localprotectionLevels
 localprotectionTemplate=message('protection-template')
 localnamespace=title.namespace
 ifnot(protectionTemplateand(namespace==10ornamespace==828))then
 -- Don't display the protection template if we are not in the template or module namespaces.
 returnnil
 end
 protectionLevels=env.protectionLevels
 ifnotprotectionLevelsthen
 returnnil
 end
 localeditLevels=protectionLevels.edit
 localmoveLevels=protectionLevels.move
 ifmoveLevelsandmoveLevels[1]=='sysop'oreditLevelsandeditLevels[1]then
 -- The page is full-move protected, or full, template, or semi-protected.
 localframe=mw.getCurrentFrame()
 returnframe:expandTemplate{title=protectionTemplate,args=message('protection-template-args',nil,'table')}
 else
 returnnil
 end
 end

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

 p.startBox=makeInvokeFunc('_startBox')

 functionp._startBox(args,env)
 --[[
 	-- This function generates the start box.
 	-- @args - a table of arguments passed by the user
 	-- @env - environment table containing title objects, etc., generated with p.getEnvironment
 	-- 
 	-- The actual work is done by p.makeStartBoxLinksData and p.renderStartBoxLinks which make
 	-- the [view] [edit] [history] [purge] links, and by p.makeStartBoxData and p.renderStartBox
 	-- which generate the box HTML.
 	--]]
 env=envorp.getEnvironment(args)
 locallinks
 localcontent=args.content
 ifnotcontentthen
 -- No need to include the links if the documentation is on the template page itself.
 locallinksData=p.makeStartBoxLinksData(args,env)
 iflinksDatathen
 links=p.renderStartBoxLinks(linksData)
 end
 end
 -- Generate the start box html.
 localdata=p.makeStartBoxData(args,env,links)
 ifdatathen
 returnp.renderStartBox(data)
 else
 -- User specified no heading.
 returnnil
 end
 end

 functionp.makeStartBoxLinksData(args,env)
 --[[
 	-- Does initial processing of data to make the [view] [edit] [history] [purge] links.
 	-- @args - a table of arguments passed by the user
 	-- @env - environment table containing title objects, etc., generated with p.getEnvironment
 	-- 
 	-- Messages:
 	-- 'view-link-display' --> 'view'
 	-- 'edit-link-display' --> 'edit'
 	-- 'history-link-display' --> 'history'
 	-- 'purge-link-display' --> 'purge'
 	-- 'file-docpage-preload' --> 'Template:Documentation/preload-filespace'
 	-- 'module-preload' --> 'Template:Documentation/preload-module-doc'
 	-- 'docpage-preload' --> 'Template:Documentation/preload'
 	-- 'create-link-display' --> 'create'
 	--]]
 localsubjectSpace=env.subjectSpace
 localtitle=env.title
 localdocTitle=env.docTitle
 ifnottitleornotdocTitlethen
 returnnil
 end
 ifdocTitle.isRedirectthen
 docTitle=docTitle.redirectTarget
 end

 localdata={}
 data.title=title
 data.docTitle=docTitle
 -- View, display, edit, and purge links if /doc exists.
 data.viewLinkDisplay=i18n['view-link-display']
 data.editLinkDisplay=i18n['edit-link-display']
 data.historyLinkDisplay=i18n['history-link-display']
 data.purgeLinkDisplay=i18n['purge-link-display']
 -- Create link if /doc doesn't exist.
 localpreload=args.preload
 ifnotpreloadthen
 ifsubjectSpace==6then-- File namespace
 preload=message('file-docpage-preload')
 elseifsubjectSpace==828then-- Module namespace
 preload=message('module-preload')
 else
 preload=message('docpage-preload')
 end
 end
 data.preload=preload
 data.createLinkDisplay=i18n['create-link-display']
 returndata
 end

 functionp.renderStartBoxLinks(data)
 --[[
 	-- Generates the [view][edit][history][purge] or [create] links from the data table.
 	-- @data - a table of data generated by p.makeStartBoxLinksData
 	--]]

 localfunctionescapeBrackets(s)
 -- Escapes square brackets with HTML entities.
 s=s:gsub('%[','&#91;')-- Replace square brackets with HTML entities.
 s=s:gsub('%]','&#93;')
 returns
 end

 localret
 localdocTitle=data.docTitle
 localtitle=data.title
 ifdocTitle.existsthen
 localviewLink=makeWikilink(docTitle.prefixedText,data.viewLinkDisplay)
 localeditLink=makeUrlLink(docTitle:fullUrl{action='edit'},data.editLinkDisplay)
 localhistoryLink=makeUrlLink(docTitle:fullUrl{action='history'},data.historyLinkDisplay)
 localpurgeLink=makeUrlLink(title:fullUrl{action='purge'},data.purgeLinkDisplay)
 ret='[%s] [%s] [%s] [%s]'
 ret=escapeBrackets(ret)
 ret=mw.ustring.format(ret,viewLink,editLink,historyLink,purgeLink)
 else
 localcreateLink=makeUrlLink(docTitle:fullUrl{action='edit',preload=data.preload},data.createLinkDisplay)
 ret='[%s]'
 ret=escapeBrackets(ret)
 ret=mw.ustring.format(ret,createLink)
 end
 returnret
 end

 functionp.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=Documentation icon]]'
 	-- 'template-namespace-heading' --> 'Template documentation'
 	-- 'module-namespace-heading' --> 'Module documentation'
 	-- 'file-namespace-heading' --> 'Summary'
 	-- 'other-namespaces-heading' --> 'Documentation'
 	-- 'start-box-linkclasses' --> 'mw-editsection-like plainlinks'
 	-- 'start-box-link-id' --> 'doc_editlinks'
 	-- 'testcases-create-link-display' --> 'create'
 	--]=]
 localsubjectSpace=env.subjectSpace
 ifnotsubjectSpacethen
 -- Default to an "other namespaces" namespace, so that we get at least some output
 -- if an error occurs.
 subjectSpace=2
 end
 localdata={}

 -- Heading
 localheading=args.heading-- Blank values are not removed.
 ifheading==''then
 -- Don't display the start box if the heading arg is defined but blank.
 returnnil
 end
 ifheadingthen
 data.heading=heading
 elseifsubjectSpace==10then-- Template namespace
 data.heading=i18n['template-namespace-heading']
 elseifsubjectSpace==828then-- Module namespace
 data.heading=i18n['module-namespace-heading']
 elseifsubjectSpace==6then-- File namespace
 data.heading=i18n['file-namespace-heading']
 else
 data.heading=i18n['other-namespaces-heading']
 end

 -- Data for the [view][edit][history][purge] or [create] links.
 iflinksthen
 data.linksClass=message('start-box-linkclasses')
 data.linksId=message('start-box-link-id')
 data.links=links
 end

 returndata
 end

 functionp.renderStartBox(data)
 -- Renders the start box html.
 -- @data - a table of data generated by p.makeStartBoxData.
 localsbox=mw.html.create('div')
 sbox
 :addClass(message('header-div-class'))
 :tag('div')
 :addClass(message('heading-div-class'))
 :wikitext(data.heading)
 locallinks=data.links
 iflinksthen
 sbox
 :tag('div')
 :addClass(data.linksClass)
 :attr('id',data.linksId)
 :wikitext(links)
 end
 returntostring(sbox)
 end

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

 p.content=makeInvokeFunc('_content')

 functionp._content(args,env)
 -- Displays the documentation contents
 -- @args - a table of arguments passed by the user
 -- @env - environment table containing title objects, etc., generated with p.getEnvironment
 env=envorp.getEnvironment(args)
 localdocTitle=env.docTitle
 localcontent=args.content
 ifnotcontentanddocTitleanddocTitle.existsthen
 content=args._contentormw.getCurrentFrame():expandTemplate{title=docTitle}
 end
 -- The line breaks below are necessary so that "=== Headings ===" at the start and end
 -- of docs are interpreted correctly.
 localcbox=mw.html.create('div')
 cbox
 :addClass(message('content-div-class'))
 :wikitext('\n'..(contentor'')..'\n')
 returntostring(cbox)
 end

 p.contentTitle=makeInvokeFunc('_contentTitle')

 functionp._contentTitle(args,env)
 env=envorp.getEnvironment(args)
 localdocTitle=env.docTitle
 ifnotargs.contentanddocTitleanddocTitle.existsthen
 returndocTitle.prefixedText
 else
 return''
 end
 end

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

 p.endBox=makeInvokeFunc('_endBox')

 functionp._endBox(args,env)
 --[=[
 	-- 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=envorp.getEnvironment(args)
 localsubjectSpace=env.subjectSpace
 localdocTitle=env.docTitle
 ifnotsubjectSpaceornotdocTitlethen
 returnnil
 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.
 locallinkBox=args['link box']
 iflinkBox=='off'
 ornot(
 docTitle.exists
 orsubjectSpace==2
 orsubjectSpace==828
 orsubjectSpace==10
 )
 then
 returnnil
 end

 -- Assemble the footer text field.
 localtext=''
 iflinkBoxthen
 text=text..linkBox
 else
 text=text..(p.makeDocPageBlurb(args,env)or'')-- "This documentation is transcluded from [[Foo]]." 
 ifsubjectSpace==2orsubjectSpace==10orsubjectSpace==828then
 -- 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'')
 text=text..'<br />'
 ifnotargs.contentandnotargs[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"
 localprintBlurb=p.makePrintBlurb(args,env)-- Two-line blurb about print versions of templates.
 ifprintBlurbthen
 text=text..'<br />'..printBlurb
 end
 end
 end

 localebox=mw.html.create('div')
 ebox
 :addClass(message('footer-div-class'))
 :wikitext(text)
 returntostring(ebox)
 end

 functionp.makeDocPageBlurb(args,env)
 --[=[
 	-- Makes the blurb "This documentation is transcluded from [[Template:Foo]] (edit, history)".
 	-- @args - a table of arguments passed by the user
 	-- @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 [[w:Wikipedia:Template documentation|documentation]] 
 	-- is [[w:Wikipedia: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 [[w:Wikipedia:Lua|Scribunto module]].'
 	--]=]
 localdocTitle=env.docTitle
 ifnotdocTitleorargs.contentthen
 returnnil
 end
 localret
 ifdocTitle.existsthen
 -- /doc exists; link to it.
 localdocLink=makeWikilink(docTitle.prefixedText)
 localeditUrl=docTitle:fullUrl{action='edit'}
 localeditDisplay=i18n['edit-link-display']
 localeditLink=makeUrlLink(editUrl,editDisplay)
 localhistoryUrl=docTitle:fullUrl{action='history'}
 localhistoryDisplay=i18n['history-link-display']
 localhistoryLink=makeUrlLink(historyUrl,historyDisplay)
 ret=message('transcluded-from-blurb',{docLink})
 ..' '
 ..makeToolbar(editLink,historyLink)
 ..'<br />'
 elseifenv.subjectSpace==828then
 -- /doc does not exist; ask to create it.
 localcreateUrl=docTitle:fullUrl{action='edit',preload=message('module-preload')}
 localcreateDisplay=i18n['create-link-display']
 localcreateLink=makeUrlLink(createUrl,createDisplay)
 ret=message('create-module-doc-blurb',{createLink})
 ..'<br />'
 end
 returnret
 end

 functionp.makeExperimentBlurb(args,env)
 --[[
 	-- Renders the text "Editors can experiment in this template's sandbox (edit | diff) and testcases (edit) pages."
 	-- @args - a table of arguments passed by the user
 	-- @env - environment table containing title objects, etc., generated with p.getEnvironment
 	-- 
 	-- Messages:
 	-- 'sandbox-link-display' --> 'sandbox'
 	-- 'sandbox-edit-link-display' --> 'edit'
 	-- 'compare-link-display' --> 'diff'
 	-- 'module-sandbox-preload' --> 'Template:Documentation/preload-module-sandbox'
 	-- '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.'
 	--]]
 localsubjectSpace=env.subjectSpace
 localtemplateTitle=env.templateTitle
 localsandboxTitle=env.sandboxTitle
 localtestcasesTitle=env.testcasesTitle
 localtemplatePage=templateTitle.prefixedText
 ifnotsubjectSpaceornottemplateTitleornotsandboxTitleornottestcasesTitlethen
 returnnil
 end
 -- Make links.
 localsandboxLinks,testcasesLinks
 ifsandboxTitle.existsthen
 localsandboxPage=sandboxTitle.prefixedText
 localsandboxDisplay=message('sandbox-link-display')
 localsandboxLink=makeWikilink(sandboxPage,sandboxDisplay)
 localsandboxEditUrl=sandboxTitle:fullUrl{action='edit'}
 localsandboxEditDisplay=message('sandbox-edit-link-display')
 localsandboxEditLink=makeUrlLink(sandboxEditUrl,sandboxEditDisplay)
 localcompareUrl=env.compareUrl
 localcompareLink
 ifcompareUrlthen
 localcompareDisplay=message('compare-link-display')
 compareLink=makeUrlLink(compareUrl,compareDisplay)
 end
 sandboxLinks=sandboxLink..' '..makeToolbar(sandboxEditLink,compareLink)
 else
 localsandboxPreload
 ifsubjectSpace==828then
 sandboxPreload=message('module-sandbox-preload')
 else
 sandboxPreload=message('template-sandbox-preload')
 end
 localsandboxCreateUrl=sandboxTitle:fullUrl{action='edit',preload=sandboxPreload}
 localsandboxCreateDisplay=message('sandbox-create-link-display')
 localsandboxCreateLink=makeUrlLink(sandboxCreateUrl,sandboxCreateDisplay)
 localmirrorSummary=message('mirror-edit-summary',{makeWikilink(templatePage)})
 localmirrorPreload=message('mirror-link-preload')
 localmirrorUrl=sandboxTitle:fullUrl{action='edit',preload=mirrorPreload,summary=mirrorSummary}
 localmirrorDisplay=message('mirror-link-display')
 localmirrorLink=makeUrlLink(mirrorUrl,mirrorDisplay)
 sandboxLinks=message('sandbox-link-display')..' '..makeToolbar(sandboxCreateLink,mirrorLink)
 end
 iftestcasesTitle.existsthen
 localtestcasesPage=testcasesTitle.prefixedText
 localtestcasesDisplay=message('testcases-link-display')
 localtestcasesLink=makeWikilink(testcasesPage,testcasesDisplay)
 localtestcasesEditUrl=testcasesTitle:fullUrl{action='edit'}
 localtestcasesEditDisplay=message('testcases-edit-link-display')
 localtestcasesEditLink=makeUrlLink(testcasesEditUrl,testcasesEditDisplay)
 testcasesLinks=testcasesLink..' '..makeToolbar(testcasesEditLink)
 else
 localtestcasesPreload
 ifsubjectSpace==828then
 testcasesPreload=message('module-testcases-preload')
 else
 testcasesPreload=message('template-testcases-preload')
 end
 localtestcasesCreateUrl=testcasesTitle:fullUrl{action='edit',preload=testcasesPreload}
 localtestcasesCreateDisplay=message('testcases-create-link-display')
 localtestcasesCreateLink=makeUrlLink(testcasesCreateUrl,testcasesCreateDisplay)
 testcasesLinks=message('testcases-link-display')..' '..makeToolbar(testcasesCreateLink)
 end
 localmessageName
 ifsubjectSpace==828then
 messageName='experiment-blurb-module'
 else
 messageName='experiment-blurb-template'
 end
 returnmessage(messageName,{sandboxLinks,testcasesLinks})
 end

 functionp.makeCategoriesBlurb(args,env)
 --[[
 	-- 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.'
 	--]]
 localdocTitle=env.docTitle
 ifnotdocTitlethen
 returnnil
 end
 localdocPathLink=makeWikilink(docTitle.prefixedText,message('doc-link-display'))
 returnmessage('add-categories-blurb',{docPathLink})
 end

 functionp.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ドル'
 	--]]
 localsubjectSpace=env.subjectSpace
 localtemplateTitle=env.templateTitle
 ifnotsubjectSpaceornottemplateTitlethen
 returnnil
 end
 localpagetype
 ifsubjectSpace==10then
 pagetype=message('template-pagetype')
 elseifsubjectSpace==828then
 pagetype=message('module-pagetype')
 else
 pagetype=message('default-pagetype')
 end
 localsubpagesLink=makeWikilink(
 'Special:PrefixIndex/'..templateTitle.prefixedText..'/',
 message('subpages-link-display',{pagetype})
 )
 returnmessage('subpages-blurb',{subpagesLink})
 end

 functionp.makePrintBlurb(args,env)
 --[=[
 	-- Generates the blurb displayed when there is a print version of the template available.
 	-- @args - a table of arguments passed by the user
 	-- @env - environment table containing title objects, etc., generated with p.getEnvironment
 	--
 	-- Messages:
 	-- 'print-link-display' --> '/Print'
 	-- 'print-blurb' --> 'A [[Help:Books/for experts#Improving the book layout|print version]]'
 	--		.. ' of this template exists at 1ドル.'
 	--		.. ' If you make a change to this template, please update the print version as well.'
 	-- 'display-print-category' --> true
 	-- 'print-category' --> 'Templates with print versions'
 	--]=]
 localprintTitle=env.printTitle
 ifnotprintTitlethen
 returnnil
 end
 localret
 ifprintTitle.existsthen
 localprintLink=makeWikilink(printTitle.prefixedText,message('print-link-display'))
 ret=message('print-blurb',{printLink})
 localdisplayPrintCategory=message('display-print-category',nil,'boolean')
 ifdisplayPrintCategorythen
 ret=ret..makeCategoryLink(message('print-category'))
 end
 end
 returnret
 end

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

 functionp.addTrackingCategories(env)
 --[[
 	-- 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.
 	--]]
 localtitle=env.title
 localsubjectSpace=env.subjectSpace
 ifnottitleornotsubjectSpacethen
 returnnil
 end
 localsubpage=title.subpageText
 localret=''
 ifmessage('display-strange-usage-category',nil,'boolean')
 and(
 subpage==message('doc-subpage')
 orsubjectSpace~=828andsubpage==message('testcases-subpage')
 )
 then
 ret=ret..makeCategoryLink(message('strange-usage-category'))
 end
 returnret
 end

 returnp