Modul: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 [[Modul:Pagetype/config]].       --
--                                                                            --
--------------------------------------------------------------------------------
-- Load config.
localcfg=mw.loadData('Modul:Pagetype/config')
-- Load required modules.
localyesno=require('Modul: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('Modul: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('Modul: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},
{'disambiguation',cfg.dab,cfg.dabDefault,true},
})
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('Modul:Arguments').getArgs(frame)
returnp._main(args)
end
returnp