Changes
update to use Module:Yesno and to allow it to play nicely with other Lua modules
------------------------------------------------------------------------------------------------------------ ---- CATEGORY HANDLER ---- ---- This module implements the {{category handler}} template ---- in Lua, with a few improvements: all namespaces and all ---- namespaces and all namespace aliases are supported, and namespace names are detected ---- detected automatically for the local wiki. This module requires [[Module:Namespace detect]] and ---- requires [[Module:Namespace detectYesno]] to be available on ---- the local wiki. It can be configured for different wikis ---- by altering the values in the "cfg" table. ---- ------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------ Configuration data ---- Language-specific parameter names and values can be set here. ---- here. --------------------------------------------------------------------------------------------------------
local cfg = {}
-- cfg.nocat is The following config values set the parameter name to names of parameters that suppress categorisation.They are used-- with Module:Yesno, and work as follows:---- cfg.nocatTrue nocat:-- Result of yesno(args[cfg.nocat]) Effect-- true Categorisation is the value to suppress categorisationsuppressed-- false Categorisation is allowed, and the blacklist check is skipped-- nil Categorisation is allowed---- cfg.nocatFalse categories:-- Result of yesno(args[cfg.categories]) Effect-- true Categorisation is the value to both categorise allowed, and to skip theblacklist check is skipped-- blacklist check.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 -- cfg.category2Yes value, and-- suppresses categorisation if present but equal to anything otherthan-- than cfg.category2Yes or cfg.category2Negative.
cfg.category2 = 'category2'
cfg.category2Yes = 'yes'
cfg.category2Negative = '¬Ê'
-- 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.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 detect]].
cfg.page = 'page'
-- The categorisation blacklist. Pages that match Lua patterns in this-- list will not be categorised unless any of the following options are.-- set: "(However, see the explanation of cfg.nocat=false", "cfg.categories=yes", or "and cfg.category2=yes"for some exceptions. )-- If the namespace name has a space in, it must be written with an-- underscore, e.g. "Wikipedia_talk". -- Other parts of the title can have-- either underscores or spaces.
cfg.blacklist = {
'^Main Page$', -- don't categorise the main page.
}
-- This is a table of namespaces to categorise by default. They-- should be in the format of parameter -- names accepted by-- [[Module:Namespace detect]].
cfg.defaultNamespaces = {
'main',
}
------------------------------------------------------------------------------------------------------------ End configuration data ------------------------------------------------------------------------------------------------------------
-- Get [[Module:Namespace detect]] and declare the table of functions-- that we will return.dependent moduleslocal NamespaceDetect nsDetect = require('Module:Namespace detect')local p yesno = {}require('Module:Yesno')
------------------------------------------------------------------------------------------------------------ Local functions ---- The following are internal functions, which we do not want ---- to be accessible from other modules. ------------------------------------------------------------------------------------------------------------
-- Find whether we need to return a category or not.
local function needsCategory( pageObject, args )
-- Don't categorise if the relevant options are set.
if yesno(args[cfg.nocat] == cfg.nocatTrue) or yesno(args[cfg.categories] ) == cfg.categoriesNofalse or ( args[cfg.category2]
and args[cfg.category2] ~= cfg.category2Yes
and args[cfg.category2] ~= cfg.category2Negative ) then
return false
end
end
if args[cfg.subpage] == cfg.subpageOnly
and (not pageObject or (pageObject and not pageObject.isSubpage) ) then
return false
end
-- Find whether we need to check the blacklist or not.
local function needsBlacklistCheck( args ) if yesno(args[cfg.nocat] ) == cfg.nocatFalsefalse or yesno(args[cfg.categories] ) == cfg.categoriesYestrue or args[cfg.category2] == cfg.category2Yes then
return false
else
return true
end
end
-- Mappings is the table of parameter mappings taken from
-- [[Module:Namespace detect]].
local function nsParamsExist( mappings, args )
if args[cfg.all] or args[cfg.other] then
return true
end
for ns, params in pairs( mappings ) do for i, param in ipairs( params ) do
if args[param] then
return true
end
return false
end
----------------------------------------------------------------------------------------------------------
-- Global functions --
-- The following functions are global, because we want them to be accessible from #invoke and --
-- from other Lua modules. --
----------------------------------------------------------------------------------------------------------
local p = {}
-- 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(page)
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
-- The main structure of the module. Checks whether we need to categorise,
-- and then passes the relevant arguments to [[Module:Namespace detect]].
-- Get the page object and argument mappings from
-- [[Module:Namespace detect]], to save us from having to rewrite the
-- code.
local pageObject = NamespaceDetectnsDetect.getPageObject( args[cfg.page] ) local mappings = NamespaceDetectnsDetect.getParamMappings()
local ret = '' -- The string to return.
-- Check blacklist if necessary.
if not needsBlacklistCheck( args ) or not findBlacklistMatchp.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
local ndresult = NamespaceDetectnsDetect.main( ndargs )
if ndresult then
ret = ret .. ndresult
-- 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
local data = NamespaceDetectnsDetect.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
and args[datanum] then
ret = ret .. args[ datanum ]
end
else
end
-- If called via #invoke, use the args passed into the invoking
-- template, or the args passed to #invoke if any exist. Otherwise
if frame == mw.getCurrentFrame() then
origArgs = frame:getParent().args
for k, v in pairs( frame.args ) do
origArgs = frame.args
break
-- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page".
local args = {}
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
-- 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 if local argVal = args[v] if type(argVal) == 'string' then args[v] = mw.ustring.lower( args[v] argVal)
end
end
return p._main( args )
end
return p