Module:Documentation/sandbox

This is the module sandbox page for Module:Documentation (diff).

Module documentation

This module is rated as ready for general use. It has reached a mature form and is thought to be bug-free and ready for use wherever appropriate. It is ready to mention on help pages and other resources as an option for new users to learn. To reduce server load and bad output, it should be improved by sandbox testing rather than repeated trial-and-error editing.

Lua logo Uses Lua:

CSS This module uses TemplateStyles:

Module:Documentation/styles.css (sandbox)

TNT This module uses Module:TNT for localisation:

I18n/Documentation.tab

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

Normal usage

[edit ]

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

[edit ]

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

localdocumentation=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

[edit ]

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.

To display Module documentation on the Module's page itself, you should create MediaWiki:Scribunto-doc-page-show accordingly. (See also Extension:Scribunto/Lua reference manual#Module documentation)

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 above documentation is transcluded from Module:Documentation/doc. (edit | history)
Editors can experiment in this module’s sandbox (edit | diff) and testcases (create) pages.
Please add categories to the /doc subpage. Subpages of this module.

 --[[
  Add your experimental module code here.
 --]]
 -- 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/sandbox')
 locali18n=mw.loadData('Module:Documentation/i18n/sandbox')
 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.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
 ----------------------------------------------------------------------------

 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.prefixedText}
 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

Retrieved from "https://www.mediawiki.org/w/index.php?title=Module:Documentation/sandbox&oldid=4731979"