Module:Pagetype

 --------------------------------------------------------------------------------
 -- --
 -- This meta-module which automatically detects namespaces, and allows --
 -- for a great deal of customisation. It can easily be ported to other --
 -- wikis by changing the values in the [[Module:Pagetype/config]]. --
 -- --
 --------------------------------------------------------------------------------
 -- Load config.
 localcfg=mw.loadData('Module:Pagetype/config')

 -- Load required modules.
 localyesno=require('Module:Yesno')
 localp={}

 -- Look up a namespace argument in the args table.
 localfunctionlookUpNamespaceArg(args,key)
 localarg=args[key]
 -- Convert "yes", "1" etc. to true, "no", "0" etc. to false, and leave
 -- other values the same.
 returnyesno(arg,arg)
 end

 -- Append multiple values to an array
 localfunctionappendMultiple(target,source)
 for_,valueinipairs(source)do
 table.insert(target,value)
 end
 end

 -- Get argument keys for a title's namespace
 localfunctiongetNamespaceArgKeys(title)
 localnsInfo=mw.site.namespaces[title.namespace]
 localcustomAliases=cfg.customNamespaceAliases[title.namespace]or{}
 localkeys={}
 ifnsInfo.name~=''then
 table.insert(keys,nsInfo.name)
 end
 ifnsInfo.canonicalName~=nsInfo.nameandnsInfo.canonicalName~=''then
 table.insert(keys,nsInfo.canonicalName)
 end
 appendMultiple(keys,nsInfo.aliases)
 appendMultiple(keys,customAliases)
 returnkeys
 end

 -- Get the argument for a title's namespace, if it was specified in the args table.
 localfunctiongetNamespaceArg(title,args)
 iftitle.isTalkPagethen
 returnlookUpNamespaceArg(args,cfg.talk)
 end
 for_,keyinipairs(getNamespaceArgKeys(title))do
 localarg=lookUpNamespaceArg(args,mw.ustring.lower(key))
 ifarg~=nilthen
 returnarg
 end
 end
 returnnil
 end

 -- Look up a page type specific to the title's namespace
 localfunctiongetExplicitPageType(title)
 iftitle.isTalkPagethen
 returncfg.talkDefault
 else
 returncfg.pagetypes[title.namespace]
 end
 end

 -- Get a default page type that is not specific to the title's namespace
 localfunctiongetDefaultPageType(args)
 localother=lookUpNamespaceArg(args,cfg.other)
 iftype(other)=='string'then
 returnother
 else
 returncfg.otherDefault
 end
 end

 localfunctiondetectRedirects(title,args)
 localredirect=lookUpNamespaceArg(args,cfg.redirect)
 ifredirect==falsethen
 -- Don't detect redirects if they have been specifically disallowed.
 returnnil
 end

 -- Allow custom values for redirects.
 ifnottitle.isRedirectthen
 returnnil
 elseiftype(redirect)=='string'then
 returnredirect
 else
 returncfg.redirectDefault
 end
 end

 localfunctioncapitalize(pageType)
 localfirst=mw.ustring.sub(pageType,1,1)
 localrest=mw.ustring.sub(pageType,2)
 returnmw.ustring.upper(first)..rest
 end

 localfunctionpluralize(pageType)
 ifcfg.irregularPlurals[pageType]then
 returncfg.irregularPlurals[pageType]
 else
 returnpageType..cfg.plural-- often 's'
 end
 end

 localfunctionparseContent(title,args,optionsList)
 iftitle.namespace==828andtitle.subpageText~='doc'-- don't detect modules
 ornottitle.exists-- can't check unless page exists
 then
 returnnil
 end
 localcontent=title:getContent()
 ifcontent==nilthen
 returnnil
 end
 localtemplates-- lazily evaluated
 for_,optionsinnext,optionsListdo
 locallist,parameter,default,articleOnly=unpack(options,1,4)
 ifnotarticleOnlyortitle.namespace==0then-- only check for templates if we should...
 localout=lookUpNamespaceArg(args,parameter)
 iftype(out)=="string"or(out~=falseanddefault)then-- ...and if we actually have anything to say about them
 ifnottemplatesthen
 templates={}-- do our delayed evaluation now that we are required to
 content=require('Module:Wikitext Parsing').PrepareText(content)-- disregard templates which do not have any affect
 fortemplateinstring.gmatch(content,"{{%s*([^|}]-)%s*[|}]")do
 templates[#templates+1]=capitalize(template)
 end
 end
 localwantedTemplates=mw.loadData('Module:Pagetype/'..list)
 localtemplateFound=false
 for_,templateinnext,templatesdo
 ifwantedTemplates[template]then
 templateFound=true
 break
 end
 end
 iftemplateFoundthen
 iftype(out)=='string'then
 returnout
 elseifout~=falseanddefaultthen
 returndefault
 end
 end
 end
 end
 end
 end

 -- Find pages which do not exist
 localfunctionnonExistent(title,args)
 localarg=lookUpNamespaceArg(args,cfg.ne)
 ifarg==falsethen
 returnnil
 end
 localexists=false
 iftitle.existsthen-- not an article if it does not exist
 exists=true
 elseiftitle.namespace==8andmw.message.new(title.text):exists()then
 exists=true
 elseiftitle.namespace==6andtitle.fileExiststhen
 exists=true
 end
 ifnotexiststhen
 iftype(arg)=='string'then
 returnarg
 else
 returncfg.naDefault
 end
 end
 end

 -- Get page types for mainspaces pages with an explicit class specified
 localfunctiongetMainNamespaceClassPageType(title,args)
 localclass=args[1]
 iftype(class)=='string'then-- Put in lower case so e.g. "na" and "NA" will both match
 class=mw.ustring.lower(class)
 end
 localarg=lookUpNamespaceArg(args,cfg.na)
 ifarg==falsethen-- don't check for this class if it is specifically disallowed
 returnnil
 end
 ifcfg.naAliases[class]then
 iftype(arg)=='string'then
 returnarg
 else
 returncfg.naDefault
 end
 else
 returnnil
 end
 end

 -- Get page type specified by an explicit namespace argument.
 localfunctiongetNamespaceArgPageType(title,args)
 localnamespaceArg=getNamespaceArg(title,args)
 ifnamespaceArg==truethen
 -- Namespace has been explicitly enabled, so return the default for
 -- this namespace
 returngetExplicitPageType(title)
 elseifnamespaceArg==falsethen
 -- Namespace has been explicitly disabled
 returngetDefaultPageType(args)
 elseifnamespaceArgthen
 -- This namespaces uses custom text
 returnnamespaceArg
 else
 returnnil
 end
 end


 -- Get page type not specified or detected by other means
 localfunctiongetOtherPageType(title,args)
 -- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
 localisInDefaultActiveNamespace=false
 localdefaultNamespacesKey=args[cfg.defaultns]
 ifdefaultNamespacesKey==cfg.defaultnsAllthen
 isInDefaultActiveNamespace=true
 else
 localdefaultNamespaces
 ifdefaultNamespacesKey==cfg.defaultnsExtendedthen
 defaultNamespaces=cfg.extendedNamespaces
 elseifdefaultNamespacesKey==cfg.defaultnsNonethen
 defaultNamespaces={}
 else
 defaultNamespaces=cfg.defaultNamespaces
 end
 isInDefaultActiveNamespace=defaultNamespaces[title.namespace]
 end
 ifisInDefaultActiveNamespacethen
 returngetExplicitPageType(title)
 else
 returngetDefaultPageType(args)
 end
 end

 functionp._main(args)
 localtitle
 ifargs.pagethen
 title=mw.title.new(args.page)
 else
 title=mw.title.getCurrentTitle()
 end
 iftitleandnotyesno(args.talk,true)andargs[cfg.defaultns]~=cfg.defaultnsAllthen
 title=title.subjectPageTitle
 end
 localpageType=detectRedirects(title,args)
 ornonExistent(title,args)
 orparseContent(title,args,{
 {'softredirect',cfg.softRedirect,cfg.softRedirectDefault},
 {'setindex',cfg.sia,cfg.siaDefault,true},
 {'disambiguation',cfg.dab,cfg.dabDefault,true},
 {'rfd',cfg.rfd,cfg.rfdDefault},
 })
 or(title.namespace==0andgetMainNamespaceClassPageType(title,args))
 orgetNamespaceArgPageType(title,args)
 orgetOtherPageType(title,args)
 ifyesno(args.plural,false)then
 pageType=pluralize(pageType)
 end
 ifyesno(args.caps,false)then
 pageType=capitalize(pageType)
 end
 returnpageType
 end

 functionp.main(frame)
 localargs=require('Module:Arguments').getArgs(frame)
 returnp._main(args)
 end

 returnp