Editing Module:Category handler

From MINR.ORG WIKI

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 save 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   --
−
--      with a few improvements: all namespaces and all namespace aliases     --
+
--      in Lua, with a few improvements: all namespaces and all    --
−
--      are supported, and namespace names are detected automatically for    --
+
--      namespace aliases are supported, and namespace names are   --
−
--      the local wiki. This module requires [[Module:Namespace detect]]     --
+
--      detected automatically for the local wiki. This module      --
−
--      and [[Module:Yesno]] to be available on the local wiki. It can be     --
+
--      requires [[Module:Namespace detect]] to be available on     --
−
--      configured for different wikis by altering the values in             --
+
--      the local wiki. It can be configured for different wikis    --
−
--      [[Module:Category handler/config]], and pages can be blacklisted      --
+
--      by altering the values in the "cfg" table.                 --
−
--      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 = {}
+
-- cfg.nocat is the parameter name to suppress categorisation.
 +
-- cfg.nocatTrue is the value to suppress categorisation, and
 +
-- cfg.nocatFalse is the value to both categorise and to skip the
 +
-- blacklist check.
 +
cfg.nocat = 'nocat'   
 +
cfg.nocatTrue = 'true'
 +
cfg.nocatFalse = 'false'
 +
 
 +
-- The parameter name for the legacy "categories" parameter. This
 +
-- skips the blacklist if set to the cfg.category2Yes value, and
 +
-- suppresses categorisation if set to the cfg.categoriesNo value.
 +
cfg.categories = 'categories'
 +
cfg.categoriesYes = 'yes'
 +
cfg.categoriesNo = 'no'
  
−
--------------------------------------------------------------------------------
+
-- The parameter name for the legacy "category2" parameter. This
−
-- Helper functions
+
-- 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.category2Negative = '¬'
  
−
local function trimWhitespace(s, removeBlanks)
+
-- cfg.subpage is the parameter name to specify how to behave on
−
if type(s) ~= 'string' then
+
-- subpages. cfg.subpageNo is the value to specify to not
−
return s
+
-- categorise on subpages; cfg.only is the value to specify to only
−
end
+
-- categorise on subpages.
−
s = s:match('^%s*(.-)%s*$')
+
cfg.subpage = 'subpage'
−
if removeBlanks then
+
cfg.subpageNo = 'no'
−
if s ~= '' then
+
cfg.subpageOnly = 'only'
−
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
−
CategoryHandler.__index = CategoryHandler
+
-- the namespace that is detected. This 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
−
local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
+
-- page; used for testing and demonstration. This must be the same
−
+
-- as the cfg.page parameter in [[Module:Namespace detect]].
−
-- Set the title object
+
cfg.page = 'page'
−
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
−
for _, key in ipairs{'nocat', 'categories'} do
+
-- list will not be categorised unless any of the following options are
−
local value = obj:parameter(key)
+
-- set: "nocat=false", "categories=yes", or "category2=yes".
−
value = trimWhitespace(value, true)
+
-- If the namespace name has a space in, it must be written with an
−
obj['_' .. key] = yesno(value)
+
-- underscore, e.g. "Wikipedia_talk". Other parts of the title can have
−
end
+
-- either underscores or spaces.
−
do
+
cfg.blacklist = {
−
local subpage = obj:parameter('subpage')
+
    '^Main Page$', -- don't categorise the main page.
−
local category2 = obj:parameter('category2')
+
   
−
if type(subpage) == 'string' then
+
    -- Don't categorise the following pages or their subpages.
−
subpage = mw.ustring.lower(subpage)
+
    '^Wikipedia:Cascade%-protected items$',
−
end
+
    '^Wikipedia:Cascade%-protected items/.*$',
−
if type(category2) == 'string' then
+
    '^User:UBX$', -- The userbox "template" space.
−
subpage = mw.ustring.lower(category2)
+
    '^User:UBX/.*$',
−
end
+
    '^User_talk:UBX$',
−
obj._subpage = trimWhitespace(subpage, true)
+
    '^User_talk:UBX/.*$',
−
obj._category2 = trimWhitespace(category2) -- don't remove blank values
+
   
−
end
+
    -- Don't categorise subpages of these pages, but allow
−
return obj
+
    -- categorisation of the base page.
−
end
+
    '^Wikipedia:Template messages/.*$',
 +
   
 +
    '/[aA]rchive' -- Don't categorise archives.
 +
}
  
−
function CategoryHandler:parameter(key)
+
-- This is a table of namespaces to categorise by default. They
−
local parameterNames = self._data.parameters[key]
+
-- should be in the format of parameter names accepted by
−
local pntype = type(parameterNames)
+
-- [[Module:Namespace detect]].
−
if pntype == 'string' or pntype == 'number' then
+
cfg.defaultNamespaces = {
−
return self._args[parameterNames]
+
    'main',
−
elseif pntype == 'table' then
+
    'file',
−
for _, name in ipairs(parameterNames) do
+
    'help',
−
local value = self._args[name]
+
    'category'
−
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 [[Module:Namespace detect]] and declare the table of functions
−
-- suppressed based on our subpage status.
+
-- that we will return.
−
or self._subpage == self._data.subpageNo and self.title.isSubpage
+
local NamespaceDetect = require('Module:Namespace detect')
−
or self._subpage == self._data.subpageOnly and not self.title.isSubpage
+
local p = {}
−
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  --
−
return self._nocat == false
+
--     to be accessible from other modules.                       --
−
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 args[cfg.nocat] == cfg.nocatTrue
−
mShared = mShared or require('Module:Category handler/shared')
+
        or args[cfg.categories] == cfg.categoriesNo
−
return mShared.matchesBlacklist(
+
        or ( args[cfg.category2]
−
self.title.prefixedText,
+
            and args[cfg.category2] ~= cfg.category2Yes
−
mw.loadData('Module:Category handler/blacklist')
+
            and args[cfg.category2] ~= cfg.category2Negative )
−
)
+
        then
−
end
+
        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 args[cfg.nocat] == cfg.nocatFalse
−
return self:isSuppressedByArguments()
+
        or args[cfg.categories] == cfg.categoriesYes
−
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()
+
-- Searches the blacklist to find a match with the page object. The
−
if self._usesCurrentTitle then
+
-- string searched is the namespace plus the title, including subpages.
−
return self._data.currentTitleNamespaceParameters
+
-- Returns true if there is a match, otherwise returns false.
−
else
+
local function findBlacklistMatch( pageObject )
−
if not mappings then
+
    if not pageObject then return end
−
mShared = mShared or require('Module:Category handler/shared')
+
   
−
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
+
    -- Get the title to check.
−
end
+
    local title = pageObject.nsText -- Get the namespace.
−
return mShared.getNamespaceParameters(
+
    -- Append a colon if the namespace isn't the blank string.
−
self.title,
+
    if #title > 0 then
−
mappings
+
        title = title .. ':' .. pageObject.text
−
)
+
    else
−
end
+
        title = pageObject.text
 +
    end
 +
   
 +
    -- Check the blacklist.
 +
    for i, pattern in ipairs( cfg.blacklist ) do
 +
        if mw.ustring.match( title, pattern ) then
 +
            return true
 +
        end
 +
    end
 +
    return false
 
end
 
end
  
−
function CategoryHandler:namespaceParametersExist()
+
-- Find whether any namespace parameters have been specified.
−
-- Find whether any namespace parameters have been specified.
+
-- Mappings is the table of parameter mappings taken from
−
-- We use the order "all" --> namespace params --> "other" as this is what
+
-- [[Module:Namespace detect]].
−
-- the old template did.
+
local function nsParamsExist( mappings, args )
−
if self:parameter('all') then
+
    if args[cfg.all] or args[cfg.other] then
−
return true
+
        return true
−
end
+
    end
−
if not mappings then
+
    for ns, params in pairs( mappings ) do
−
mShared = mShared or require('Module:Category handler/shared')
+
        for i, param in ipairs( params ) do
−
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
+
            if args[param] then
−
end
+
                return true
−
for ns, params in pairs(mappings) do
+
            end
−
for i, param in ipairs(params) do
+
        end
−
if self._args[param] then
+
    end
−
return true
+
    return false
−
end
 
−
end
 
−
end
 
−
if self:parameter('other') then
 
−
return true
 
−
end
 
−
return false
 
 
end
 
end
  
−
function CategoryHandler:getCategories()
+
-- The main structure of the module. Checks whether we need to categorise,
−
local params = self:getNamespaceParameters()
+
-- and then passes the relevant arguments to [[Module:Namespace detect]].
−
local nsCategory
+
local function _main( args )
−
for i, param in ipairs(params) do
+
    -- Get the page object and argument mappings from
−
local value = self._args[param]
+
    -- [[Module:Namespace detect]], to save us from having to rewrite the
−
if value ~= nil then
+
    -- code.
−
nsCategory = value
+
    local pageObject = NamespaceDetect.getPageObject( args[cfg.page] )
−
break
+
    local mappings = NamespaceDetect.getParamMappings()
−
end
+
   
−
end
+
    -- Check if we need a category or not, and return nothing if not.
−
if nsCategory ~= nil or self:namespaceParametersExist() then
+
    if not needsCategory( pageObject, args ) then return end
−
-- Namespace parameters exist - advanced usage.
+
   
−
if nsCategory == nil then
+
    local ret = '' -- The string to return.
−
nsCategory = self:parameter('other')
+
    -- Check blacklist if necessary.
−
end
+
    if not needsBlacklistCheck( args )
−
local ret = {self:parameter('all')}
+
        or not findBlacklistMatch( pageObject ) then
−
local numParam = tonumber(nsCategory)
+
       
−
if numParam and numParam >= 1 and math.floor(numParam) == numParam then
+
        if not nsParamsExist( mappings, args ) then
−
-- nsCategory is an integer
+
            -- No namespace parameters exist; basic usage. Pass args[1] to
−
ret[#ret + 1] = self._args[numParam]
+
            -- [[Module:Namespace detect]] using the default namespace
−
else
+
            -- parameters, and return the result.
−
ret[#ret + 1] = nsCategory
+
            local ndargs = {}
−
end
+
            for _, ndarg in ipairs( cfg.defaultNamespaces ) do
−
if #ret < 1 then
+
                ndargs[ndarg] = args[1]
−
return nil
+
            end
−
else
+
            ndargs.page = args.page
−
return table.concat(ret)
+
            local ndresult = NamespaceDetect.main( ndargs )
−
end
+
            if ndresult then
−
elseif self._data.defaultNamespaces[self.title.namespace] then
+
                ret = ret .. ndresult
−
-- Namespace parameters don't exist, simple usage.
+
            end
−
return self._args[1]
+
        else
−
end
+
            -- Namespace parameters exist; advanced usage.
−
return nil
+
            -- If the all parameter is specified, return it.
 +
            if args.all then
 +
                ret = ret .. args.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
 +
            if args.other then
 +
                ndargs.other = args.other
 +
            end
 +
            if args.page then
 +
                ndargs.page = args.page
 +
            end
 +
           
 +
            local data = NamespaceDetect.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
 +
                -- "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
  
−
--------------------------------------------------------------------------------
+
----------------------------------------------------------------------
−
-- Exports
+
--                       Global functions                          --
−
--------------------------------------------------------------------------------
+
--     The following functions are global, because we want them    --
−
 
+
--     to be accessible from #invoke and from other Lua modules.  --
−
local p = {}
+
--     At the moment only the main function is here. It processes  --
−
 
+
--     the arguments and passes them to the _main function.        --
−
function p._exportClasses()
+
----------------------------------------------------------------------
−
-- Used for testing purposes.
 
−
return {
 
−
CategoryHandler = CategoryHandler
 
−
}
 
−
end
 
  
−
function p._main(args, 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 handler = CategoryHandler.new(data, args)
+
    -- template, or the args passed to #invoke if any exist. Otherwise
−
if handler:isSuppressed() then
+
    -- assume args are being passed directly in.
−
return nil
+
    local origArgs
−
end
+
    if frame == mw.getCurrentFrame() then
−
return handler:getCategories()
+
        origArgs = frame:getParent().args
−
end
+
        for k, v in pairs( frame.args ) do
 +
            origArgs = frame.args
 +
            break
 +
        end
 +
    else
 +
        origArgs = frame
 +
    end
  
−
function p.main(frame, data)
+
    -- Trim whitespace and remove blank arguments for the following args:
−
data = data or mw.loadData('Module:Category handler/data')
+
    -- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page".
−
local args = require('Module:Arguments').getArgs(frame, {
+
    local args = {}
−
wrappers = data.wrappers,
+
    for k, v in pairs( origArgs ) do
−
valueFunc = function (k, v)
+
        v = mw.text.trim(v) -- Trim whitespace.
−
v = trimWhitespace(v)
+
        if type(k) == 'number'
−
if type(k) == 'number' then
+
            or k == cfg.nocat
−
if v ~= '' then
+
            or k == cfg.categories
−
return v
+
            or k == cfg.subpage
−
else
+
            or k == cfg.page then
−
return nil
+
            if v ~= '' then
−
end
+
                args[k] = v
−
else
+
            end
−
return v
+
        else
−
end
+
            args[k] = v
−
end
+
        end
−
})
+
    end
−
return p._main(args, data)
+
   
 +
    -- 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
 +
        if args[v] then
 +
            args[v] = mw.ustring.lower( args[v] )
 +
        end
 +
    end
 +
   
 +
    return _main( args )
 
end
 
end
  
 
return p
 
return p

Please note that all contributions to MINR.ORG WIKI 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 MINR.ORG WIKI:Copyrights for details). Do not submit copyrighted work without permission!

Cancel Editing help (opens in new window)
Retrieved from "https://wiki.minr.org/Module:Category_handler"