Module:Category handler: Difference between revisions
From All Skies Encyclopaedia
| imported>Mr. Stradivarius  (use live version of Module:Namespace detect) | imported>MusikAnimal  m (1 revision imported) | ||
| (6 intermediate revisions by 4 users not shown) | |||
| Line 1: | Line 1: | ||
| -------------------------------------------------------------------------------- | |||
| -- | --                                                                            -- | ||
| -- | --                              CATEGORY HANDLER                              -- | ||
| -- | --                                                                            -- | ||
| --      This module implements the {{category handler}} template in Lua,  | --      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     -- | |||
| --      automatically for the local wiki. This module requires [[Module:Namespace detect]] and          -- | |||
| --      | --      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 | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| local yesno = require('Module:Yesno') | |||
| --                                          Configuration data                                          -- | |||
| --                      Language-specific parameter names and values can be set here.                   -- | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| -- Lazily load things we don't always need | |||
| local cfg = {} | |||
| local mShared, mappings | |||
| local p = {} | |||
| -- 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 allowed | |||
| cfg.nocat = 'nocat'     | |||
| cfg.categories = 'categories' | |||
| -------------------------------------------------------------------------------- | |||
| -- The parameter name for the legacy "category2" parameter. This skips the blacklist if set to the | |||
| -- Helper functions | |||
| -- 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.category2Negative = '¬' | |||
| local function trimWhitespace(s, removeBlanks) | |||
| -- cfg.subpage is the parameter name to specify how to behave on subpages. cfg.subpageNo is the value to | |||
| 	if type(s) ~= 'string' then | |||
| -- specify to not categorise on subpages; cfg.only is the value to specify to only categorise on subpages. | |||
| 		return s | |||
| cfg.subpage = 'subpage' | |||
| 	end | |||
| cfg.subpageNo = 'no' | |||
| 	s = s:match('^%s*(.-)%s*$') | |||
| cfg.subpageOnly = 'only' | |||
| 	if removeBlanks then | |||
| 		if s ~= '' then | |||
| 			return s | |||
| 		else | |||
| 			return nil | |||
| 		end | |||
| 	else | |||
| 		return s | |||
| 	end | |||
| end | |||
| -------------------------------------------------------------------------------- | |||
| -- The parameter for data to return in all namespaces. | |||
| -- CategoryHandler class | |||
| cfg.all = 'all' | |||
| -------------------------------------------------------------------------------- | |||
| local CategoryHandler = {} | |||
| -- The parameter name for data to return if no data is specified for the namespace that is detected. This | |||
| CategoryHandler.__index = CategoryHandler | |||
| -- must be the same as the cfg.other parameter in [[Module:Namespace detect]]. | |||
| cfg.other = 'other' | |||
| function CategoryHandler.new(data, args) | |||
| -- The parameter name used to specify a page other than the current page; used for testing and | |||
| 	local obj = setmetatable({ _data = data, _args = args }, CategoryHandler) | |||
| -- demonstration. This must be the same as the cfg.page parameter in [[Module:Namespace detect]]. | |||
| cfg.page = 'page' | |||
| 	-- Set the title object | |||
| 	do | |||
| 		local pagename = obj:parameter('demopage') | |||
| 		local success, titleObj | |||
| 		if pagename then | |||
| 			success, titleObj = pcall(mw.title.new, pagename) | |||
| 		end | |||
| 		if success and titleObj then | |||
| 			obj.title = titleObj | |||
| 			if titleObj == mw.title.getCurrentTitle() then | |||
| 				obj._usesCurrentTitle = true | |||
| 			end | |||
| 		else | |||
| 			obj.title = mw.title.getCurrentTitle() | |||
| 			obj._usesCurrentTitle = true | |||
| 		end | |||
| 	end | |||
| 	-- Set suppression parameter values | |||
| -- The categorisation blacklist. Pages that match Lua patterns in this list will not be categorised. | |||
| 	for _, key in ipairs{'nocat', 'categories'} do | |||
| 		local value = obj:parameter(key) | |||
| -- If the namespace name has a space in, it must be written with an underscore, e.g. "Wikipedia_talk". | |||
| 		value = trimWhitespace(value, true) | |||
| -- Other parts of the title can have either underscores or spaces. | |||
| 		obj['_' .. key] = yesno(value) | |||
| cfg.blacklist = { | |||
| 	end | |||
|     '^Main Page$', -- don't categorise the main page. | |||
| 	do | |||
| 		local subpage = obj:parameter('subpage') | |||
|     -- Don't categorise the following pages or their subpages. | |||
| 		local category2 = obj:parameter('category2') | |||
|     '^Wikipedia:Cascade%-protected items$', | |||
| 		if type(subpage) == 'string' then | |||
|     '^Wikipedia:Cascade%-protected items/.*$', | |||
| 			subpage = mw.ustring.lower(subpage) | |||
|     '^User:UBX$', -- The userbox "template" space. | |||
| 		end | |||
|     '^User:UBX/.*$', | |||
| 		if type(category2) == 'string' then | |||
|     '^User_talk:UBX$', | |||
| 			subpage = mw.ustring.lower(category2) | |||
|     '^User_talk:UBX/.*$', | |||
| 		end | |||
| 		obj._subpage = trimWhitespace(subpage, true) | |||
|     -- Don't categorise subpages of these pages, but allow | |||
| 		obj._category2 = trimWhitespace(category2) -- don't remove blank values | |||
|     -- categorisation of the base page. | |||
| 	end | |||
|     '^Wikipedia:Template messages/.+$', | |||
| 	return obj | |||
| end | |||
|     '/[aA]rchive' -- Don't categorise archives. | |||
| } | |||
| function CategoryHandler:parameter(key) | |||
| -- This is a table of namespaces to categorise by default. They should be in the format of parameter | |||
| 	local parameterNames = self._data.parameters[key] | |||
| -- names accepted by [[Module:Namespace detect]]. | |||
| 	local pntype = type(parameterNames) | |||
| cfg.defaultNamespaces = { | |||
| 	if pntype == 'string' or pntype == 'number' then | |||
|     'main', | |||
| 		return self._args[parameterNames] | |||
|     'file', | |||
| 	elseif pntype == 'table' then | |||
|     'help', | |||
| 		for _, name in ipairs(parameterNames) do | |||
|     'category' | |||
| 			local value = self._args[name] | |||
| } | |||
| 			if value ~= nil then | |||
| 				return value | |||
| 			end | |||
| 		end | |||
| 		return nil | |||
| 	else | |||
| 		error(string.format( | |||
| 			'invalid config key "%s"', | |||
| 			tostring(key) | |||
| 		), 2) | |||
| 	end | |||
| end | |||
| function CategoryHandler:isSuppressedByArguments() | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| 	return | |||
| --                                          End configuration data                                      -- | |||
| 		-- See if a category suppression argument has been set. | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| 		self._nocat == true | |||
| 		or self._categories == false | |||
| 		or ( | |||
| 			self._category2 | |||
| 			and self._category2 ~= self._data.category2Yes | |||
| 			and self._category2 ~= self._data.category2Negative | |||
| 		) | |||
| 		-- Check whether we are on a subpage, and see if categories are | |||
| -- Get dependent modules | |||
| 		-- suppressed based on our subpage status. | |||
| local nsDetect = require('Module:Namespace detect') | |||
| 		or self._subpage == self._data.subpageNo and self.title.isSubpage | |||
| local yesno = require('Module:Yesno') | |||
| 		or self._subpage == self._data.subpageOnly and not self.title.isSubpage | |||
| end | |||
| function CategoryHandler:shouldSkipBlacklistCheck() | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| 	-- Check whether the category suppression arguments indicate we | |||
| --                                          Local functions                                             -- | |||
| 	-- should skip the blacklist check. | |||
| --      The following are internal functions, which we do not want to be accessible from other modules. -- | |||
| 	return self._nocat == false | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| 		or self._categories == true | |||
| 		or self._category2 == self._data.category2Yes | |||
| end | |||
| function CategoryHandler:matchesBlacklist() | |||
| -- Find whether we need to return a category or not. | |||
| 	if self._usesCurrentTitle then | |||
| local function needsCategory(pageObject, args) | |||
| 		return self._data.currentTitleMatchesBlacklist | |||
|     -- Don't categorise if the relevant options are set. | |||
| 	else | |||
|     if yesno(args[cfg.nocat]) | |||
| 		mShared = mShared or require('Module:Category handler/shared') | |||
|         or yesno(args[cfg.categories]) == false | |||
| 		return mShared.matchesBlacklist( | |||
|         or ( | |||
| 			self.title.prefixedText, | |||
|             args[cfg.category2]  | |||
| 			mw.loadData('Module:Category handler/blacklist') | |||
|             and args[cfg.category2] ~= cfg.category2Yes  | |||
| 		) | |||
|             and args[cfg.category2] ~= cfg.category2Negative | |||
| 	end | |||
|         ) | |||
|     then | |||
|         return false | |||
|     end | |||
|     -- If there is no pageObject available, then that either means that we are over | |||
|     -- the expensive function limit or that the title specified was invalid. Invalid | |||
|     -- titles will probably only be a problem during testing, so we choose the best | |||
|     -- fallback for being over the expensive function limit. The fallback behaviour | |||
|     -- of the old template was to assume the page was not a subpage, so we will do | |||
|     -- the same here. | |||
|     if args[cfg.subpage] == cfg.subpageNo and pageObject and pageObject.isSubpage then | |||
|         return false | |||
|     end | |||
|     if args[cfg.subpage] == cfg.subpageOnly  | |||
|         and (not pageObject or (pageObject and not pageObject.isSubpage)) | |||
|     then | |||
|         return false | |||
|     end | |||
|     return true | |||
| end | end | ||
| function CategoryHandler:isSuppressed() | |||
| -- Find whether we need to check the blacklist or not. | |||
| 	-- Find if categories are suppressed by either the arguments or by | |||
| local function needsBlacklistCheck(args) | |||
| 	-- matching the blacklist. | |||
|     if yesno(args[cfg.nocat]) == false | |||
| 	return self:isSuppressedByArguments() | |||
|         or yesno(args[cfg.categories]) == true | |||
| 		or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist() | |||
|         or args[cfg.category2] == cfg.category2Yes | |||
|     then | |||
|         return false | |||
|     else | |||
|         return true | |||
|     end | |||
| end | end | ||
| function CategoryHandler:getNamespaceParameters() | |||
| -- Find whether any namespace parameters have been specified. | |||
| 	if self._usesCurrentTitle then | |||
| -- Mappings is the table of parameter mappings taken from | |||
| 		return self._data.currentTitleNamespaceParameters | |||
| -- [[Module:Namespace detect]]. | |||
| 	else | |||
| local function nsParamsExist(mappings, args) | |||
| 		if not mappings then | |||
| 			mShared = mShared or require('Module:Category handler/shared') | |||
|         return true | |||
| 			mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData | |||
|     end | |||
| 		end | |||
|     for ns, params in pairs(mappings) do | |||
| 		return mShared.getNamespaceParameters( | |||
|         for i, param in ipairs(params) do | |||
| 			self.title, | |||
|             if args[param] then | |||
| 			mappings | |||
|                 return true | |||
| 		) | |||
|             end | |||
| 	end | |||
|     end | |||
|     return false | |||
| end | end | ||
| function CategoryHandler:namespaceParametersExist() | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| 	-- Find whether any namespace parameters have been specified. | |||
| --                                          Global functions                                            -- | |||
| 	-- We use the order "all" --> namespace params --> "other" as this is what | |||
| --      The following functions are global, because we want them to be accessible from #invoke and      -- | |||
| 	-- the old template did. | |||
| --      from other Lua modules.                                                                         -- | |||
| 	if self:parameter('all') then | |||
| ---------------------------------------------------------------------------------------------------------- | |||
| 		return true | |||
| 	end | |||
| 	if not mappings then | |||
| 		mShared = mShared or require('Module:Category handler/shared') | |||
| 		mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData | |||
| 	end | |||
| 	for ns, params in pairs(mappings) do | |||
| 		for i, param in ipairs(params) do | |||
| 			if self._args[param] then | |||
| 				return true | |||
| 			end | |||
| 		end | |||
| 	end | |||
| 	if self:parameter('other') then | |||
| 		return true | |||
| 	end | |||
| 	return false | |||
| end | |||
| 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 | |||
| 		-- Namespace parameters exist - advanced usage. | |||
| 		if nsCategory == nil then | |||
| 			nsCategory = self:parameter('other') | |||
| 		end | |||
| 		local ret = {self:parameter('all')} | |||
| 		local numParam = tonumber(nsCategory) | |||
| 		if numParam and numParam >= 1 and math.floor(numParam) == numParam then | |||
| 			-- nsCategory is an integer | |||
| 			ret[#ret + 1] = self._args[numParam] | |||
| 		else | |||
| 			ret[#ret + 1] = nsCategory | |||
| 		end | |||
| 		if #ret < 1 then | |||
| 			return nil | |||
| 		else | |||
| 			return table.concat(ret) | |||
| 		end | |||
| 	elseif self._data.defaultNamespaces[self.title.namespace] then | |||
| 		-- Namespace parameters don't exist, simple usage. | |||
| 		return self._args[1] | |||
| 	end | |||
| 	return nil | |||
| end | |||
| -------------------------------------------------------------------------------- | |||
| -- Exports | |||
| -------------------------------------------------------------------------------- | |||
| local p = {} | local p = {} | ||
| function p._exportClasses() | |||
| -- Find if a string matches the blacklist. Returns the match if one is found, or nil otherwise. | |||
| 	-- Used for testing purposes. | |||
| -- Input should be a page title with a namespace prefix, e.g. "Wikipedia talk:Articles for deletion". | |||
| 	return { | |||
| function p.matchesBlacklist(page) | |||
| 		CategoryHandler = CategoryHandler | |||
|     if type(page) ~= 'string' then return end | |||
| 	} | |||
|     for i, pattern in ipairs(cfg.blacklist) do | |||
|         local match = mw.ustring.match(page, pattern) | |||
|         if match then | |||
|             return match | |||
|         end | |||
|     end | |||
| end | end | ||
| function p._main(args, data) | |||
| -- The main structure of the module. Checks whether we need to categorise, | |||
| 	data = data or mw.loadData('Module:Category handler/data') | |||
| -- and then passes the relevant arguments to [[Module:Namespace detect]]. | |||
| 	local handler = CategoryHandler.new(data, args) | |||
| function p._main(args) | |||
| 	if handler:isSuppressed() then | |||
|     -- Get the page object and argument mappings from | |||
| 		return nil | |||
|     -- [[Module:Namespace detect]], to save us from having to rewrite the | |||
| 	end | |||
|     -- code. | |||
| 	return handler:getCategories() | |||
|     local pageObject = nsDetect.getPageObject(args[cfg.page]) | |||
|     local mappings = nsDetect.getParamMappings() | |||
|     if not needsCategory(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.defaultNamespaces) do | |||
|                 ndargs[ndarg] = args[1] | |||
|             end | |||
|             ndargs.page = args.page | |||
|             ndargs.demospace = args.demospace | |||
|             local ndresult = nsDetect._main(ndargs) | |||
|             if ndresult then | |||
|                 ret = ret .. ndresult | |||
|             end | |||
|         else | |||
|             -- Namespace parameters exist; advanced usage. | |||
|             -- If the all parameter is specified, return it. | |||
|             local all = args.all | |||
|             if type(all) == 'string' then | |||
|                 ret = ret .. all | |||
|             end | |||
|             -- Get the arguments to pass to [[Module: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._main(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 integers | |||
|                 -- 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 type(data) == 'string' then | |||
|                     ret = ret .. data | |||
|                 end | |||
|             end | |||
|         end | |||
|     end | |||
|     return ret | |||
| end | end | ||
| function p.main(frame) | function p.main(frame, data) | ||
| 	data = data or mw.loadData('Module:Category handler/data') | |||
|     -- If called via #invoke, use the args passed into the invoking | |||
| 	local args = require('Module:Arguments').getArgs(frame, { | |||
|     -- template, or the args passed to #invoke if any exist. Otherwise | |||
| 		wrappers = data.wrappers, | |||
|     -- assume args are being passed directly in. | |||
| 		valueFunc = function (k, v) | |||
|     local origArgs | |||
| 			v = trimWhitespace(v) | |||
|     if frame == mw.getCurrentFrame() then | |||
| 			if type(k) == 'number' then | |||
|         origArgs = frame:getParent().args | |||
| 				if v ~= '' then | |||
|         for k, v in pairs(frame.args) do | |||
| 					return v | |||
|             origArgs = frame.args | |||
| 				else | |||
|             break | |||
| 					return nil | |||
|         end | |||
| 				end | |||
|     else | |||
| 			else | |||
|         origArgs = frame | |||
| 				return v | |||
|     end | |||
| 			end | |||
| 		end | |||
|     -- Trim whitespace and remove blank arguments for the following args: | |||
| 	}) | |||
|     -- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page". | |||
| 	return p._main(args, data) | |||
|     for k, v in pairs(origArgs) do | |||
|         if type(v) == 'string' then | |||
|             v = mw.text.trim(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] = v | |||
|             end | |||
|         else | |||
|             args[k] = 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) | |||
| end | end | ||
Latest revision as of 06:12, 1 April 2020
Documentation for this module may be created at Module:Category handler/doc
--------------------------------------------------------------------------------
--                                                                            --
--                              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
local yesno = require('Module:Yesno')
-- Lazily load things we don't always need
local mShared, mappings
local p = {}
--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------
local function trimWhitespace(s, removeBlanks)
	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
	end
end
--------------------------------------------------------------------------------
-- CategoryHandler class
--------------------------------------------------------------------------------
local CategoryHandler = {}
CategoryHandler.__index = CategoryHandler
function CategoryHandler.new(data, args)
	local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
	
	-- Set the title object
	do
		local pagename = obj:parameter('demopage')
		local success, titleObj
		if pagename then
			success, titleObj = pcall(mw.title.new, pagename)
		end
		if success and titleObj then
			obj.title = titleObj
			if titleObj == mw.title.getCurrentTitle() then
				obj._usesCurrentTitle = true
			end
		else
			obj.title = mw.title.getCurrentTitle()
			obj._usesCurrentTitle = true
		end
	end
	-- Set suppression parameter values
	for _, key in ipairs{'nocat', 'categories'} do
		local value = obj:parameter(key)
		value = trimWhitespace(value, true)
		obj['_' .. key] = yesno(value)
	end
	do
		local subpage = obj:parameter('subpage')
		local category2 = obj:parameter('category2')
		if type(subpage) == 'string' then
			subpage = mw.ustring.lower(subpage)
		end
		if type(category2) == 'string' then
			subpage = mw.ustring.lower(category2)
		end
		obj._subpage = trimWhitespace(subpage, true)
		obj._category2 = trimWhitespace(category2) -- don't remove blank values
	end
	return obj
end
function CategoryHandler:parameter(key)
	local parameterNames = self._data.parameters[key]
	local pntype = type(parameterNames)
	if pntype == 'string' or pntype == 'number' then
		return self._args[parameterNames]
	elseif pntype == 'table' then
		for _, name in ipairs(parameterNames) do
			local value = self._args[name]
			if value ~= nil then
				return value
			end
		end
		return nil
	else
		error(string.format(
			'invalid config key "%s"',
			tostring(key)
		), 2)
	end
end
function CategoryHandler:isSuppressedByArguments()
	return
		-- See if a category suppression argument has been set.
		self._nocat == true
		or self._categories == false
		or (
			self._category2
			and self._category2 ~= self._data.category2Yes
			and self._category2 ~= self._data.category2Negative
		)
		-- Check whether we are on a subpage, and see if categories are
		-- 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.isSubpage
end
function CategoryHandler:shouldSkipBlacklistCheck()
	-- Check whether the category suppression arguments indicate we
	-- should skip the blacklist check.
	return self._nocat == false
		or self._categories == true
		or self._category2 == self._data.category2Yes
end
function CategoryHandler:matchesBlacklist()
	if self._usesCurrentTitle then
		return self._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 categories are suppressed by either the arguments or by
	-- matching the blacklist.
	return self:isSuppressedByArguments()
		or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end
function CategoryHandler:getNamespaceParameters()
	if self._usesCurrentTitle then
		return self._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 mShared.getNamespaceParameters(
			self.title,
			mappings
		)
	end
end
function CategoryHandler: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.
	if self:parameter('all') then
		return true
	end
	if not mappings then
		mShared = mShared or require('Module:Category handler/shared')
		mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
	end
	for ns, params in pairs(mappings) do
		for i, param in ipairs(params) do
			if self._args[param] then
				return true
			end
		end
	end
	if self:parameter('other') then
		return true
	end
	return false
end
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
		-- Namespace parameters exist - advanced usage.
		if nsCategory == nil then
			nsCategory = self:parameter('other')
		end
		local ret = {self:parameter('all')}
		local numParam = tonumber(nsCategory)
		if numParam and numParam >= 1 and math.floor(numParam) == numParam then
			-- nsCategory is an integer
			ret[#ret + 1] = self._args[numParam]
		else
			ret[#ret + 1] = nsCategory
		end
		if #ret < 1 then
			return nil
		else
			return table.concat(ret)
		end
	elseif self._data.defaultNamespaces[self.title.namespace] then
		-- Namespace parameters don't exist, simple usage.
		return self._args[1]
	end
	return nil
end
--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------
local p = {}
function p._exportClasses()
	-- Used for testing purposes.
	return {
		CategoryHandler = CategoryHandler
	}
end
function p._main(args, data)
	data = data or mw.loadData('Module:Category handler/data')
	local handler = CategoryHandler.new(data, args)
	if handler:isSuppressed() then
		return nil
	end
	return handler:getCategories()
end
function p.main(frame, data)
	data = data or mw.loadData('Module:Category handler/data')
	local args = require('Module:Arguments').getArgs(frame, {
		wrappers = data.wrappers,
		valueFunc = function (k, v)
			v = trimWhitespace(v)
			if type(k) == 'number' then
				if v ~= '' then
					return v
				else
					return nil
				end
			else
				return v
			end
		end
	})
	return p._main(args, data)
end
return p







