Module:Namespace detect

 --[[
 --------------------------------------------------------------------------------
 -- --
 -- NAMESPACE DETECT --
 -- --
 -- This module implements the {{namespace detect}} template in Lua, with a --
 -- few improvements: all namespaces and all namespace aliases are supported, --
 -- and namespace names are detected automatically for the local wiki. The --
 -- module can also use the corresponding subject namespace value if it is --
 -- used on a talk page. Parameter names can be configured for different wikis --
 -- by altering the values in the "cfg" table in --
 -- Module:Namespace detect/config. --
 -- --
 --------------------------------------------------------------------------------
 --]]

 localdata=mw.loadData('Module:Namespace detect/data')
 localargKeys=data.argKeys
 localcfg=data.cfg
 localmappings=data.mappings

 localyesno=require('Module:Yesno')
 localmArguments-- Lazily initialise Module:Arguments
 localmTableTools-- Lazily initilalise Module:TableTools
 localustringLower=mw.ustring.lower

 localp={}

 localfunctionfetchValue(t1,t2)
 -- Fetches a value from the table t1 for the first key in array t2 where
 -- a non-nil value of t1 exists.
 fori,keyinipairs(t2)do
 localvalue=t1[key]
 ifvalue~=nilthen
 returnvalue
 end
 end
 returnnil
 end

 localfunctionequalsArrayValue(t,value)
 -- Returns true if value equals a value in the array t. Otherwise
 -- returns false.
 fori,arrayValueinipairs(t)do
 ifvalue==arrayValuethen
 returntrue
 end
 end
 returnfalse
 end

 functionp.getPageObject(page)
 -- Get the page object, passing the function through pcall in case of
 -- errors, e.g. being over the expensive function count limit.
 ifpagethen
 localsuccess,pageObject=pcall(mw.title.new,page)
 ifsuccessthen
 returnpageObject
 else
 returnnil
 end
 else
 returnmw.title.getCurrentTitle()
 end
 end

 -- Provided for backward compatibility with other modules
 functionp.getParamMappings()
 returnmappings
 end

 localfunctiongetNamespace(args)
 -- This function gets the namespace name from the page object.
 localpage=fetchValue(args,argKeys.demopage)
 ifpage==''then
 page=nil
 end
 localdemospace=fetchValue(args,argKeys.demospace)
 ifdemospace==''then
 demospace=nil
 end
 localsubjectns=fetchValue(args,argKeys.subjectns)
 localret
 ifdemospacethen
 -- Handle "demospace = main" properly.
 ifequalsArrayValue(argKeys.main,ustringLower(demospace))then
 ret=mw.site.namespaces[0].name
 else
 ret=demospace
 end
 else
 localpageObject=p.getPageObject(page)
 ifpageObjectthen
 ifpageObject.isTalkPagethen
 -- Get the subject namespace if the option is set,
 -- otherwise use "talk".
 ifyesno(subjectns)then
 ret=mw.site.namespaces[pageObject.namespace].subject.name
 else
 ret='talk'
 end
 else
 ret=pageObject.nsText
 end
 else
 returnnil-- return nil if the page object doesn't exist.
 end
 end
 ret=ret:gsub('_',' ')
 returnustringLower(ret)
 end

 functionp._main(args)
 -- Check the parameters stored in the mappings table for any matches.
 localnamespace=getNamespace(args)or'other'-- "other" avoids nil table keys
 localparams=mappings[namespace]or{}
 localret=fetchValue(args,params)
 --[[
 	-- If there were no matches, return parameters for other namespaces.
 	-- This happens if there was no text specified for the namespace that
 	-- was detected or if the demospace parameter is not a valid
 	-- namespace. Note that the parameter for the detected namespace must be
 	-- completely absent for this to happen, not merely blank.
 	--]]
 ifret==nilthen
 ret=fetchValue(args,argKeys.other)
 end
 returnret
 end

 functionp.main(frame)
 mArguments=require('Module:Arguments')
 localargs=mArguments.getArgs(frame,{removeBlanks=false})
 localret=p._main(args)
 returnretor''
 end

 functionp.table(frame)
 --[[
 	-- Create a wikitable of all subject namespace parameters, for
 	-- documentation purposes. The talk parameter is optional, in case it
 	-- needs to be excluded in the documentation.
 	--]]

 -- Load modules and initialise variables.
 mTableTools=require('Module:TableTools')
 localnamespaces=mw.site.namespaces
 localcfg=data.cfg
 localuseTalk=type(frame)=='table'
 andtype(frame.args)=='table'
 andyesno(frame.args.talk)-- Whether to use the talk parameter.

 -- Get the header names.
 localfunctioncheckValue(value,default)
 iftype(value)=='string'then
 returnvalue
 else
 returndefault
 end
 end
 localnsHeader=checkValue(cfg.wikitableNamespaceHeader,'Namespace')
 localaliasesHeader=checkValue(cfg.wikitableAliasesHeader,'Aliases')

 -- Put the namespaces in order.
 localmappingsOrdered={}
 fornsname,paramsinpairs(mappings)do
 ifuseTalkornsname~='talk'then
 localnsid=namespaces[nsname].id
 -- Add 1, as the array must start with 1; nsid 0 would be lost otherwise.
 nsid=nsid+1
 mappingsOrdered[nsid]=params
 end
 end
 mappingsOrdered=mTableTools.compressSparseArray(mappingsOrdered)

 -- Build the table.
 localret='{| class="wikitable"'
 ..'\n|-'
 ..'\n! '..nsHeader
 ..'\n! '..aliasesHeader
 fori,paramsinipairs(mappingsOrdered)do
 forj,paraminipairs(params)do
 ifj==1then
 ret=ret..'\n|-'
 ..'\n| <code>'..param..'</code>'
 ..'\n| '
 elseifj==2then
 ret=ret..'<code>'..param..'</code>'
 else
 ret=ret..', <code>'..param..'</code>'
 end
 end
 end
 ret=ret..'\n|-'
 ..'\n|}'
 returnret
 end

 returnp