Editing Module:Category handler

From Guild of Archivists
Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.

Latest revision Your text
Line 1: Line 1:
--------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
--                                                                           --
--                                                                                                     --
--                             CATEGORY HANDLER                             --
--                                         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   --
--      with a few improvements: all namespaces and all namespace aliases    --
--      namespaces and all namespace aliases are supported, and namespace names are detected           --
--      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]]     --
--      [[Module:Yesno]] to be available on the local wiki. It can be configured for different wikis    --
--      and [[Module:Yesno]] to be available on the local wiki. It can be     --
--      by altering the values in the "cfg" table.                                                      --
--      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
-- (However, see the explanation of cfg.nocat, cfg.categories and cfg.category2 for some exceptions.)
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()
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()
-- Find whether we need to return a category or not.
if self._usesCurrentTitle then
local function needsCategory(pageObject, args)
return self._data.currentTitleNamespaceParameters
    -- Don't categorise if the relevant options are set.
else
    if yesno(args[cfg.nocat])
if not mappings then
        or yesno(args[cfg.categories]) == false
mShared = mShared or require('Module:Category handler/shared')
        or (
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
            args[cfg.category2]
end
            and args[cfg.category2] ~= cfg.category2Yes
return mShared.getNamespaceParameters(
            and args[cfg.category2] ~= cfg.category2Negative
self.title,
        )
mappings
    then
)
        return false
end
    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:namespaceParametersExist()
-- Find whether we need to check the blacklist or not.
-- Find whether any namespace parameters have been specified.
local function needsBlacklistCheck(args)
-- We use the order "all" --> namespace params --> "other" as this is what
    if yesno(args[cfg.nocat]) == false
-- the old template did.
        or yesno(args[cfg.categories]) == true
if self:parameter('all') then
        or args[cfg.category2] == cfg.category2Yes
return true
    then
end
        return false
if not mappings then
    else
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
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
end


function CategoryHandler:getCategories()
-- Find whether any namespace parameters have been specified.
local params = self:getNamespaceParameters()
-- Mappings is the table of parameter mappings taken from
local nsCategory
-- [[Module:Namespace detect]].
for i, param in ipairs(params) do
local function nsParamsExist(mappings, args)
local value = self._args[param]
    if args[cfg.all] or args[cfg.other] then
if value ~= nil then
        return true
nsCategory = value
    end
break
    for ns, params in pairs(mappings) do
end
        for i, param in ipairs(params) do
end
            if args[param] then
if nsCategory ~= nil or self:namespaceParametersExist() then
                return true
-- Namespace parameters exist - advanced usage.
            end
if nsCategory == nil then
        end
nsCategory = self:parameter('other')
    end
end
    return false
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
end


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


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, data)
function p.main(frame)
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)
    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
            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


return p
return p
Please note that all contributions to Guild of Archivists may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see GoArch:Copyrights for details). Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)

Template used on this page:

Retrieved from "https://archive.guildofarchivists.org/wiki/Module:Category_handler"