Module:Category handler

 --------------------------------------------------------------------------------
 -- --
 -- CATEGORY HANDLER --
 -- --
 -- This module implements the {{category handler}} 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. This module requires [[Module:Namespace detect]] --
 -- and [[Module:Yesno]] to be available on the local wiki. It can be --
 -- configured for different wikis by altering the values in --
 -- [[Module:Category handler/config]], and pages can be blacklisted --
 -- from categorisation by using [[Module:Category handler/blacklist]]. --
 -- --
 --------------------------------------------------------------------------------

 -- Load required modules
 localyesno=require('Module:Yesno')

 -- Lazily load things we don't always need
 localmShared,mappings

 localp={}

 --------------------------------------------------------------------------------
 -- Helper functions
 --------------------------------------------------------------------------------

 localfunctiontrimWhitespace(s,removeBlanks)
 iftype(s)~='string'then
 returns
 end
 s=s:match('^%s*(.-)%s*$')
 ifremoveBlanksthen
 ifs~=''then
 returns
 else
 returnnil
 end
 else
 returns
 end
 end

 --------------------------------------------------------------------------------
 -- CategoryHandler class
 --------------------------------------------------------------------------------

 localCategoryHandler={}
 CategoryHandler.__index=CategoryHandler

 functionCategoryHandler.new(data,args)
 localobj=setmetatable({_data=data,_args=args},CategoryHandler)

 -- Set the title object
 do
 localpagename=obj:parameter('demopage')
 localsuccess,titleObj
 ifpagenamethen
 success,titleObj=pcall(mw.title.new,pagename)
 end
 ifsuccessandtitleObjthen
 obj.title=titleObj
 iftitleObj==mw.title.getCurrentTitle()then
 obj._usesCurrentTitle=true
 end
 else
 obj.title=mw.title.getCurrentTitle()
 obj._usesCurrentTitle=true
 end
 end

 -- Set suppression parameter values
 for_,keyinipairs{'nocat','categories'}do
 localvalue=obj:parameter(key)
 value=trimWhitespace(value,true)
 obj['_'..key]=yesno(value)
 end
 do
 localsubpage=obj:parameter('subpage')
 localcategory2=obj:parameter('category2')
 iftype(subpage)=='string'then
 subpage=mw.ustring.lower(subpage)
 end
 iftype(category2)=='string'then
 subpage=mw.ustring.lower(category2)
 end
 obj._subpage=trimWhitespace(subpage,true)
 obj._category2=trimWhitespace(category2)-- don't remove blank values
 end
 returnobj
 end

 functionCategoryHandler:parameter(key)
 localparameterNames=self._data.parameters[key]
 localpntype=type(parameterNames)
 ifpntype=='string'orpntype=='number'then
 returnself._args[parameterNames]
 elseifpntype=='table'then
 for_,nameinipairs(parameterNames)do
 localvalue=self._args[name]
 ifvalue~=nilthen
 returnvalue
 end
 end
 returnnil
 else
 error(string.format(
 'invalid config key "%s"',
 tostring(key)
 ),2)
 end
 end

 functionCategoryHandler:isSuppressedByArguments()
 return
 -- See if a category suppression argument has been set.
 self._nocat==true
 orself._categories==false
 or(
 self._category2
 andself._category2~=self._data.category2Yes
 andself._category2~=self._data.category2Negative
 )

 -- Check whether we are on a subpage, and see if categories are
 -- suppressed based on our subpage status.
 orself._subpage==self._data.subpageNoandself.title.isSubpage
 orself._subpage==self._data.subpageOnlyandnotself.title.isSubpage
 end

 functionCategoryHandler:shouldSkipBlacklistCheck()
 -- Check whether the category suppression arguments indicate we
 -- should skip the blacklist check.
 returnself._nocat==false
 orself._categories==true
 orself._category2==self._data.category2Yes
 end

 functionCategoryHandler:matchesBlacklist()
 ifself._usesCurrentTitlethen
 returnself._data.currentTitleMatchesBlacklist
 else
 mShared=mSharedorrequire('Module:Category handler/shared')
 returnmShared.matchesBlacklist(
 self.title.prefixedText,
 mw.loadData('Module:Category handler/blacklist')
 )
 end
 end

 functionCategoryHandler:isSuppressed()
 -- Find if categories are suppressed by either the arguments or by
 -- matching the blacklist.
 returnself:isSuppressedByArguments()
 ornotself:shouldSkipBlacklistCheck()andself:matchesBlacklist()
 end

 functionCategoryHandler:getNamespaceParameters()
 ifself._usesCurrentTitlethen
 returnself._data.currentTitleNamespaceParameters
 else
 ifnotmappingsthen
 mShared=mSharedorrequire('Module:Category handler/shared')
 mappings=mShared.getParamMappings(true)-- gets mappings with mw.loadData
 end
 returnmShared.getNamespaceParameters(
 self.title,
 mappings
 )
 end
 end

 functionCategoryHandler:namespaceParametersExist()
 -- Find whether any namespace parameters have been specified.
 -- We use the order "all" --> namespace params --> "other" as this is what
 -- the old template did.
 ifself:parameter('all')then
 returntrue
 end
 ifnotmappingsthen
 mShared=mSharedorrequire('Module:Category handler/shared')
 mappings=mShared.getParamMappings(true)-- gets mappings with mw.loadData
 end
 forns,paramsinpairs(mappings)do
 fori,paraminipairs(params)do
 ifself._args[param]then
 returntrue
 end
 end
 end
 ifself:parameter('other')then
 returntrue
 end
 returnfalse
 end

 functionCategoryHandler:getCategories()
 localparams=self:getNamespaceParameters()
 localnsCategory
 fori,paraminipairs(params)do
 localvalue=self._args[param]
 ifvalue~=nilthen
 nsCategory=value
 break
 end
 end
 ifnsCategory~=nilorself:namespaceParametersExist()then
 -- Namespace parameters exist - advanced usage.
 ifnsCategory==nilthen
 nsCategory=self:parameter('other')
 end
 localret={self:parameter('all')}
 localnumParam=tonumber(nsCategory)
 ifnumParamandnumParam>=1andmath.floor(numParam)==numParamthen
 -- nsCategory is an integer
 ret[#ret+1]=self._args[numParam]
 else
 ret[#ret+1]=nsCategory
 end
 if#ret<1then
 returnnil
 else
 returntable.concat(ret)
 end
 elseifself._data.defaultNamespaces[self.title.namespace]then
 -- Namespace parameters don't exist, simple usage.
 returnself._args[1]
 end
 returnnil
 end

 --------------------------------------------------------------------------------
 -- Exports
 --------------------------------------------------------------------------------

 localp={}

 functionp._exportClasses()
 -- Used for testing purposes.
 return{
 CategoryHandler=CategoryHandler
 }
 end

 functionp._main(args,data)
 data=dataormw.loadData('Module:Category handler/data')
 localhandler=CategoryHandler.new(data,args)
 ifhandler:isSuppressed()then
 returnnil
 end
 returnhandler:getCategories()
 end

 functionp.main(frame,data)
 data=dataormw.loadData('Module:Category handler/data')
 localargs=require('Module:Arguments').getArgs(frame,{
 wrappers=data.wrappers,
 valueFunc=function(k,v)
 v=trimWhitespace(v)
 iftype(k)=='number'then
 ifv~=''then
 returnv
 else
 returnnil
 end
 else
 returnv
 end
 end
 })
 returnp._main(args,data)
 end

 returnp