Changes

------------------------------------------------------------------------------------------------------------ ---- CATEGORY HANDLER ---- ---- This module implements the {{category handler}} template in Lua, ---- with a few improvements: all namespaces and all namespace aliases ---- namespaces and all namespace aliases are supported, and namespace names are detected automatically for ---- automatically for the local wiki. This module requires [[Module:Namespace detect]] and ---- and [[Module:Yesno]] to be available on the local wiki. It can be configured for different wikis ---- configured for different wikis by altering the values in the "cfg" table. ---- ------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------ Configuration data ---- Language-specific parameter names and values can be set here. ------------------------------------------------------------------------------------------------------------ local cfg = {} -- The following config values set the names of parameters that suppress categorisation. They are used-- with Module:Yesno, and work as follows:---- cfg.nocat:-- Result of yesno(args[cfg.nocat]) Effect-- true Categorisation is suppressed-- false Categorisation is allowed, and the blacklist check is skipped-- nil Categorisation is allowed---- cfg.categories:-- Result of yesno(args[cfg.categories]) Effect-- true Categorisation is allowed, and the blacklist check is skipped-- false Categorisation is suppressed-- nil Categorisation is allowedcfg.nocat = 'nocat' cfg.categories = 'categories' -- The parameter name for the legacy "category2" parameter. This skips the blacklist if set to the-- cfg.category2Yes value, and suppresses categorisation if present but equal to anything other than-- cfg.category2Yes or cfg.category2Negative.cfg.category2 = 'category2'cfg.category2Yes = 'yes' -- cfg.subpage is the parameter name to specify how to behave on subpages. cfg.subpageNo is the value to-- specify to not categorise on subpages; cfg.only is the value to specify to only categorise on subpages.cfg.subpage = 'subpage'cfg.subpageNo = 'no'cfg.subpageOnly = 'only' -- The parameter for data to return in all namespaces.cfg.all = 'all' -- The parameter name for data to return if no data is specified for the namespace that is detected. This-- must be the same as the cfg.other parameter in [[Module:Namespace detect]].cfg.other = 'other' -- The parameter name used to specify a page other than the current page; used for testing and-- demonstration. This must be the same as the cfg.page parameter in [[Module:Namespace detectCategory handler/config]].cfg.page = 'page' -- The categorisation blacklist. Pages that match Lua patterns in this list will not be categorised.-- (However, see the explanation of cfg.nocat, cfg.categories and cfg.category2 for some exceptions.)-- If the namespace name has a space in, it must pages can be written with an underscore, e.g. "Wikipedia_talk".-- Other parts of the title can have either underscores or spaces.cfg.blacklist = { '^Main Page$', blacklisted -- don't categorise the main page. -- Don't categorise the following pages or their subpages. '^Wikipedia:Cascade%-protected items$', '^Wikipedia:Cascade%-protected items/.*$', '^User:UBX$', -- The userbox "template" space. '^User:UBX/.*$', '^User_talk:UBX$', '^User_talk:UBX/.*$', -- Don't categorise subpages of these pages, but allow -- from categorisation of the base page. '^Wikipedia:Template messages/.+$', '/[aA]rchive' -- Don't categorise archives.} -- This is a table of namespaces to categorise by default. They should be in the format of parameter-- names accepted by using [[Module:Namespace detectCategory handler/blacklist]].cfg.defaultNamespaces = { 'main', 'file', 'help', 'category'} -------------------------------------------------------------------------------------------------------- ---- End configuration data ------------------------------------------------------------------------------------------------------------ -- Get dependent Load required moduleslocal nsDetect = require('Module:Namespace detect')

-- Lazily load things we don't always needlocal mShared, mappings local p = {} ---------------------------------------------------------------------------------- Helper functions---------------------------------------------------------------------------- Local functions ---- The following are internal functions local function trimWhitespace(s, which we do not want to be accessible from other modulesremoveBlanks) if type(s) ~= 'string' then return s end s = s:match('^%s*(. -)%s*$') if removeBlanks then if s ~= '' then return s else return nil end else return s endend ----------------------------------------------------------------------------------CategoryHandler class-------------------------------------------------------------------------------- local CategoryHandler = {}CategoryHandler.__index = CategoryHandler -- Find whether we need to return a category or notfunction CategoryHandler.new(data, args) local function needsCategoryobj = setmetatable(pageObject{ _data = data, _args = args}, CategoryHandler) -- DonSet the title object do local pagename = obj:parameter('t categorise demopage') local success, titleObj if pagename then success, titleObj = pcall(mw.title.new, pagename) end if the relevant options are setsuccess and titleObj then obj.title = titleObj if yesnotitleObj == mw.title.getCurrentTitle() then obj._usesCurrentTitle = true end else obj.title = mw.title.getCurrentTitle(args[cfg) obj._usesCurrentTitle = true end end  -- Set suppression parameter values for _, key in ipairs{'nocat]', 'categories'} do local value = obj:parameter(key) or yesno value = trimWhitespace(argsvalue, true) obj[cfg'_' ..categorieskey]= yesno(value) end do local subpage =obj:parameter('subpage') local category2 = falseobj:parameter('category2') or if type(subpage) == 'string' then args[cfg subpage = mw.ustring.lower(subpage) end if type(category2] ) == 'string' then and args[cfg subpage = mw.ustring.lower(category2] ~) end obj._subpage = cfgtrimWhitespace(subpage, true) obj.category2Yes _category2 = trimWhitespace(category2) -- don't remove blank values end return objend function CategoryHandler:parameter(key) and args local parameterNames = self._data.parameters[cfgkey] local pntype = type(parameterNames) if pntype == 'string' or pntype == 'number' then return self.category2_args[parameterNames] ~ elseif pntype == cfg.category2Negative'table' then for _, name in ipairs(parameterNames)do local value = self._args[name] if value ~= nil then return falsevalue end end -- If there is no pageObject available return nil else error(string.format( 'invalid config key "%s"', tostring(key) ), then that either means that we are over2) endend function CategoryHandler:isSuppressedByArguments() return -- the expensive function limit See if a category suppression argument has been set. self._nocat == true or self._categories == false or that the title specified was invalid( self._category2 and self._category2 ~= self._data.category2Yes and self._category2 ~= self._data. Invalidcategory2Negative ) -- titles will probably only be Check whether we are on a problem during testingsubpage, so we choose the bestand see if categories are -- fallback for being over the expensive suppressed based on our subpage status. or self._subpage == self._data.subpageNo and self.title.isSubpage or self._subpage == self._data.subpageOnly and not self.title.isSubpageend function limit. The fallback behaviourCategoryHandler:shouldSkipBlacklistCheck() -- of Check whether the old template was to assume the page was not a subpage, so category suppression arguments indicate we will do -- should skip the same hereblacklist check. return self._nocat == false or self._categories == true if args[cfg or self.subpage] _category2 == cfgself.subpageNo and pageObject and pageObject_data.category2Yesend function CategoryHandler:matchesBlacklist() if self.isSubpage _usesCurrentTitle then return falseself._data.currentTitleMatchesBlacklist else mShared = mShared or require('Module:Category handler/shared') return mShared.matchesBlacklist( self.title.prefixedText, mw.loadData('Module:Category handler/blacklist') ) end end function CategoryHandler:isSuppressed() -- Find if args[cfgcategories are suppressed by either the arguments or by -- matching the blacklist.subpage] == cfg.subpageOnly and return self:isSuppressedByArguments() or not pageObject or self:shouldSkipBlacklistCheck(pageObject ) and not pageObject.isSubpageself:matchesBlacklist()end function CategoryHandler:getNamespaceParameters() if self._usesCurrentTitle then return falseself._data.currentTitleNamespaceParameters else if not mappings then mShared = mShared or require('Module:Category handler/shared') mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData end return truemShared.getNamespaceParameters( self.title, mappings ) end

function CategoryHandler:namespaceParametersExist() -- Find whether we need to check any namespace parameters have been specified. -- We use the order "all" --> namespace params --> "other" as this is what -- the blacklist or notold template did.local function needsBlacklistCheck if self:parameter(args'all')then return true end if yesnonot mappings then mShared = mShared or require('Module:Category handler/shared') mappings = mShared.getParamMappings(args[cfgtrue) -- gets mappings with mw.nocat]loadData end for ns, params in pairs(mappings) == falsedo or yesno for i, param in ipairs(args[cfg.categories]params) == truedo or args if self._args[cfg.category2param] == cfg.category2Yes then return falsetrue end end end else if self:parameter('other') then return true end return false

function CategoryHandler:getCategories() local params = self:getNamespaceParameters() local nsCategory for i, param in ipairs(params) do local value = self._args[param] if value ~= nil then nsCategory = value break end end if nsCategory ~= nil or self:namespaceParametersExist() then -- Find whether any namespace Namespace parameters have been specifiedexist - advanced usage.-- Mappings is the table of if nsCategory == nil then nsCategory = self:parameter mappings taken from('other') end-- [[Module local ret = {self:Namespace detect]].parameter('all')} local function nsParamsExistnumParam = tonumber(mappings, argsnsCategory) if argsnumParam and numParam >= 1 and math.floor(numParam) == numParam then -- nsCategory is an integer ret[cfg#ret + 1] = self.all_args[numParam] or args else ret[cfg.other#ret + 1] = nsCategory end if #ret < 1 then return truenil end else for ns, params in pairs return table.concat(mappingsret) do for i, param in ipairs(params) do end if args elseif self._data.defaultNamespaces[paramself.title.namespace] then -- Namespace parameters don't exist, simple usage. return true end endself._args[1] end return falsenil

------------------------------------------------------------------------------------------------------------ Global functions ---- The following functions are global, because we want them to be accessible from #invoke and ---- from other Lua modules. --Exports----------------------------------------------------------------------------------------------------------

-- Find if a string matches the blacklist. Returns the match if one is found, or nil otherwise.-- Input should be a page title with a namespace prefix, e.g. "Wikipedia talk:Articles for deletion".function p.matchesBlacklist_exportClasses(page) if type(page) ~= 'string' then return end -- Used for i, pattern in ipairs(cfg.blacklist) do local match = mw.ustringtesting purposes.match(page, pattern) if match then return match{ end CategoryHandler = CategoryHandler end }

-- The main structure of the module. Checks whether we need to categorise,-- and then passes the relevant arguments to [[Module:Namespace detect]].function p._main(args) -- Get the page object and argument mappings from -- [[Module:Namespace detect]], to save us from having to rewrite the -- code. local pageObject = nsDetect.getPageObject(args[cfg.page]data) local mappings data = nsDetectdata or mw.getParamMappings() if not needsCategoryloadData(pageObject, args) then return end local ret = '' -- Check blacklist if necessary. if not needsBlacklistCheck(args) or not p.matchesBlacklist(pageObject.prefixedText) then if not nsParamsExist(mappings, args) then -- No namespace parameters exist; basic usage. Pass args[1] to -- [[Module:Namespace detect]] using the default namespace -- parameters, and return the result. local ndargs = {} for _, ndarg in ipairs(cfg.defaultNamespacesCategory handler/data') do ndargs[ndarg] = args[1] end ndargs.page = args.page ndargs.demospace = args.demospace local ndresult handler = nsDetectCategoryHandler._mainnew(ndargs) if ndresult then ret = ret .. ndresult end else -- Namespace parameters exist; advanced usage. -- If the all parameter is specifieddata, return it. local all = args.all) if type(all) == 'string' then ret = ret .. all end -- Get the arguments to pass to [[Modulehandler:Namespace detect]]. local ndargs = {} for ns, params in pairs(mappings) do for _, param in ipairs(params) do ndargs[param] = args[param] or args[cfg.other] or nil end end ndargs.other = args.other ndargs.page = args.page ndargs.demospace = args.demospace local data = nsDetect._mainisSuppressed(ndargs) -- Work out what to return based on the result of the namespace detect call. local datanum = tonumber(data) if type(datanum) == 'number' then -- "data" is a number, so return that positional parameter. -- Remove non-positive integer values, as only positive integersnil -- from 1-10 were used with the old template. if datanum > 0 and math.floor(datanum) == datanum then local dataArg = args[datanum] if type(dataArg) == 'string' then ret = ret .. dataArg end end else -- "data" is not a number, so return it as it is. if typehandler:getCategories(data) == 'string' then ret = ret .. data end end end end return ret

function p.main(frame, data) -- If called via #invoke, use the args passed into the invoking -- template, data = data or the args passed to #invoke if any exist. Otherwise -- assume args are being passed directly in. local origArgs if frame == mw.getCurrentFrameloadData('Module:Category handler/data') then origArgs local args = framerequire('Module:getParent(Arguments').args for k, v in pairsgetArgs(frame.args) do origArgs = frame.args break end else, { origArgs wrappers = frame end -- Trim whitespace and remove blank arguments for the following args: -- 1, 2, 3 etcdata.wrappers, "nocat", "categories", "subpage", and "page". local args valueFunc = {} for function (k, v in pairs(origArgs) do if type(v) == 'string' then v = mw.text.trimtrimWhitespace(v) -- Trim whitespace. end if type(k) == 'number' or k == cfg.nocat or k == cfg.categories or k == cfg.subpage or k == cfg.page then if v ~= '' then args[k] = return v else return nil end else args[k] = return v end end -- Lower-case "nocat", "categories", "category2", and "subpage". These -- parameters are put in lower case whenever they appear in the old -- template, so we can just do it once here and save ourselves some work. local lowercase = {cfg.nocat, cfg.categories, cfg.category2, cfg.subpage } for _, v in ipairs(lowercase) do local argVal = args[v] if type(argVal) == 'string' then args[v] = mw.ustring.lower(argVal) end end return p._main(args, data)