Module:Namespace detect: Difference between revisions

From Sarkarverse
Jump to navigation Jump to search
(Reimport and edit replacing Wikipedia and wp with SV)
m (1 revision)
 
(12 intermediate revisions by the same user not shown)
Line 1: Line 1:
----------------------------------------------------------------------
--[[
--                                                                 --
--------------------------------------------------------------------------------
--                       NAMESPACE DETECT                         --
--                                                                           --
--                                                                 --
--                           NAMESPACE DETECT                               --
--     This module implements the {{namespace detect}} template    --
--                                                                           --
--     in Lua, with a few improvements: all namespaces and all     --
-- This module implements the {{namespace detect}} template in Lua, with a   --
--      namespace aliases are supported, and namespace names are    --
-- few improvements: all namespaces and all namespace aliases are supported, --
--     detected automatically for the local wiki. Function names  --
-- and namespace names are detected automatically for the local wiki. The    --
--     can be configured for different wikis by altering the      --
-- module can also use the corresponding subject namespace value if it is    --
--     values in the "cfg" table.                                  --
-- used on a talk page. Parameter names can be configured for different wikis --
--                                                                 --
-- by altering the values in the "cfg" table in                              --
----------------------------------------------------------------------
-- Module:Namespace detect/config.                                            --
--                                                                           --
----------------------------------------------------------------------
--------------------------------------------------------------------------------
--                      Configuration data                          --
--]]
--     Language-specific parameter names can be set here.          --
 
----------------------------------------------------------------------
local data = mw.loadData('Module:Namespace detect/data')
local argKeys = data.argKeys
local cfg = {}
local cfg = data.cfg
local mappings = data.mappings
-- The name for the parameter to display content for the main namespace:
 
cfg.main = 'main'
local yesno = require('Module:Yesno')
local mArguments -- Lazily initialise Module:Arguments
-- The name for the parameter to display content in talk namespaces:
local mTableTools -- Lazily initilalise Module:TableTools
cfg.talk = 'talk'
local ustringLower = mw.ustring.lower
 
-- The name for the parameter to display content for "other" namespaces
-- (namespaces for which parameters have not been specified, or for when
-- cfg.demospace is set to cfg.other):
cfg.other = 'other'
-- The name for the parameter to set a demonstration namespace:
cfg.demospace = 'demospace'
-- The name for the parameter to set a specific page to compare:
cfg.page = 'page'
-- The header for the namespace column in the wikitable containing the
-- list of possible subject-space parameters.
cfg.wikitableNamespaceHeader = 'Namespace'
-- The header for the wikitable containing the list of possible
-- subject-space parameters.
cfg.wikitableAliasesHeader = 'Aliases'
----------------------------------------------------------------------
--                    End configuration data                      --
----------------------------------------------------------------------
----------------------------------------------------------------------
--                        Global functions                          --
--      The following functions are global, because we want them    --
--      to be accessible from other Lua modules called using        --
--      require().                                                 --
----------------------------------------------------------------------
-- Declare the table of functions to return.
local p = {}
local p = {}
 
-- Get the page object. This will return the page object for the page
local function fetchValue(t1, t2)
-- specified, or nil if there are errors in the title or if the
-- Fetches a value from the table t1 for the first key in array t2 where
-- expensive function count has been exceeded.
-- a non-nil value of t1 exists.
function p.getPageObject( page )
for i, key in ipairs(t2) do
    -- Get the title object for args.page if it is specified. Otherwise
local value = t1[key]
    -- get the title object for the current page.
if value ~= nil then
    if page then
return value
        -- Get the page object, passing the function through pcall
end
        -- in case we are over the expensive function count limit.
end
        local noError, pageObject = pcall(mw.title.new, page)
return nil
        if not noError then
            return nil
        else
            return pageObject
        end
    else
        return mw.title.getCurrentTitle()
    end   
end
end
 
--[[ Returns a table of how parameter names map to namespace names.
local function equalsArrayValue(t, value)
The keys are the actual namespace names, in lower case, and the  
-- Returns true if value equals a value in the array t. Otherwise
values are the possible parameter names for that namespace, also
-- returns false.
in lower case. The table entries are structured like this:
for i, arrayValue in ipairs(t) do
    [''] = {
if value == arrayValue then
        {'main'},
return true
    },
end
    ['SV'] = {
end
        {'SV', 'project' }
return false
    }
end
]]
 
function p.getPageObject(page)
-- Get the page object, passing the function through pcall in case of
-- errors, e.g. being over the expensive function count limit.
if page then
local success, pageObject = pcall(mw.title.new, page)
if success then
return pageObject
else
return nil
end
else
return mw.title.getCurrentTitle()
end
end
 
-- Provided for backward compatibility with other modules
function p.getParamMappings()
function p.getParamMappings()
    local mappings = {}
return mappings
    mappings[mw.ustring.lower( mw.site.namespaces[0].name )] = { cfg.main }
    mappings[cfg.talk] = { cfg.talk }
    for nsid, ns in pairs( mw.site.subjectNamespaces ) do
        if nsid ~= 0 then -- Exclude main namespace.
            local nsname = mw.ustring.lower( ns.name )
            local canonicalName = mw.ustring.lower( ns.canonicalName )
            mappings[nsname] = { nsname }
            if canonicalName ~= nsname then
                table.insert( mappings[nsname], canonicalName )
            end
            for _, alias in ipairs( ns.aliases ) do
                table.insert( mappings[nsname], mw.ustring.lower( alias ) )
            end
        end
    end
    return mappings
end
end
 
--[[ Create a wikitable of all subject namespace parameters, for documentation
local function getNamespace(args)
  purposes. Talk is excluded, as it should usually be treated separately in
-- This function gets the namespace name from the page object.
  the documentation.
local page = fetchValue(args, argKeys.demopage)
]]
if page == '' then
function p.table()
page = nil
    -- Get the parameter mappings.
end
    local mappings = p.getParamMappings()
local demospace = fetchValue(args, argKeys.demospace)
if demospace == '' then
    -- Start the wikitable.
demospace = nil
    local ret = '{| class="wikitable"'
end
        .. '\n|-'
local subjectns = fetchValue(args, argKeys.subjectns)
        .. '\n! ' .. cfg.wikitableNamespaceHeader
local ret
        .. '\n! ' .. cfg.wikitableAliasesHeader
if demospace then
-- Handle "demospace = main" properly.
    -- Generate the row for the main namespace, as we want this
if equalsArrayValue(argKeys.main, ustringLower(demospace)) then
    -- to be first in the list.
ret = mw.site.namespaces[0].name
    ret = ret .. '\n|-'
else
        .. '\n| <code>' .. cfg.main .. '</code>'
ret = demospace
        .. '\n|'
end
else
    -- Enclose all parameter names in <code> tags.
local pageObject = p.getPageObject(page)
    for ns, params in pairs( mappings ) do
if pageObject then
        if ns ~= mw.site.namespaces[0].name then
if pageObject.isTalkPage then
            for i, param in ipairs( params ) do
-- Get the subject namespace if the option is set,
                mappings[ns][i] = '<code>' .. param .. '</code>'
-- otherwise use "talk".
            end
if yesno(subjectns) then
        end
ret = mw.site.namespaces[pageObject.namespace].subject.name
    end
else
ret = 'talk'
    -- Generate the other wikitable rows.
end
    for ns, params in pairs( mappings ) do
else
        if ns ~= mw.site.namespaces[0].name then -- Ignore the main namespace.
ret = pageObject.nsText
            ret = ret .. '\n|-'
end
                .. '\n| ' .. params[1]
else
                .. '\n| ' .. table.concat( params, ', ', 2 )
return nil -- return nil if the page object doesn't exist.
        end
end
    end
end
ret = ret:gsub('_', ' ')
    -- End the wikitable.
return ustringLower(ret)
    ret = ret .. '\n|-'
        .. '\n|}'
    return ret
end
end
 
----------------------------------------------------------------------
function p._main(args)
--                        Local functions                          --
-- Check the parameters stored in the mappings table for any matches.
--      The following are internal functions, which we do not want  --
local namespace = getNamespace(args) or 'other' -- "other" avoids nil table keys
--      to be accessible from other modules.                       --
local params = mappings[namespace] or {}
----------------------------------------------------------------------
local ret = fetchValue(args, params)
--[[
-- Gets the namespace name to compare to the arguments. The returned value
-- If there were no matches, return parameters for other namespaces.
-- is lower-case.
-- This happens if there was no text specified for the namespace that
local function getNamespace( page, demospace )
-- was detected or if the demospace parameter is not a valid
    local ret
-- namespace. Note that the parameter for the detected namespace must be
    if demospace then
-- completely absent for this to happen, not merely blank.
        -- Handle "demospace = main" properly.
--]]
        if mw.ustring.lower( demospace ) == cfg.main then
if ret == nil then
            ret = mw.site.namespaces[0].name
ret = fetchValue(args, argKeys.other)
        else
end
            ret = demospace
return ret
        end
    else
        local pageObject = p.getPageObject( page )
        if pageObject then
            if pageObject.isTalkPage then
                -- {{namespace detect}} uses the same value for all talk
                -- namespaces, so that's what the module should do too.
                ret = cfg.talk
            else
                ret = pageObject.nsText
            end
        else
            return nil -- return nil if the page object doesn't exist.
        end
    end
    return mw.ustring.lower(ret)
end
end
 
-- Compare the namespace found with the parameters that have been
function p.main(frame)
-- specified, and return content of the appropriate parameter.
mArguments = require('Module:Arguments')
local function compare( args )
local args = mArguments.getArgs(frame, {removeBlanks = false})
    -- Get the namespace to compare the parameters to, and the parameter
local ret = p._main(args)
    -- mapping table.
return ret or ''
    local namespace = getNamespace( args[cfg.page], args[cfg.demospace] )
    local mappings = p.getParamMappings()
    -- Check for any matches in the namespace arguments. The order we check
    -- them doesn't matter, as there can only be one match.
    for ns, params in pairs( mappings ) do
        if ns == namespace then
            -- Check all aliases for matches. The default local namespace is
            -- checked first, as {{namespace detect}} checked these before
            -- alias names.
            for _, param in ipairs( params ) do
                if args[param] then
                    return args[param]
                end
            end
        end
    end
    -- If there were no matches, return parameters for other namespaces.
    -- This happens if there was no text specified for the namespace that
    -- was detected or if the demospace parameter is not a valid namespace.
    -- Note that the parameter for the detected namespace must be completely
    -- absent for this to happen, not merely blank.
    if args[cfg.other] then
        return args[cfg.other]
    end
end
end
 
----------------------------------------------------------------------
function p.table(frame)
--                             Main function                        --
--[[
--     This is the function that will be most used. It processes  --
-- Create a wikitable of all subject namespace parameters, for
--     the arguments and calls the compare() function. It is       --
-- documentation purposes. The talk parameter is optional, in case it
--      global, but is put down here as it depends on the other    --
-- needs to be excluded in the documentation.
--     local in order for it to work.                             --
--]]
----------------------------------------------------------------------
-- Load modules and initialise variables.
function p.main(frame)
mTableTools = require('Module:TableTools')
    -- If called via #invoke, use the args passed into the invoking
local namespaces = mw.site.namespaces
    -- template, or the args passed to #invoke if any exist. Otherwise
local cfg = data.cfg
    -- assume args are being passed directly in.
local useTalk = type(frame) == 'table'
    local origArgs
and type(frame.args) == 'table'
    if frame == mw.getCurrentFrame() then
and yesno(frame.args.talk) -- Whether to use the talk parameter.
        origArgs = frame:getParent().args
        for k, v in pairs( frame.args ) do
-- Get the header names.
            origArgs = frame.args
local function checkValue(value, default)
            break
if type(value) == 'string' then
        end
return value
    else
else
        origArgs = frame
return default
    end
end
end
    -- Trim whitespace and remove blank arguments for demospace and
local nsHeader = checkValue(cfg.wikitableNamespaceHeader, 'Namespace')
    -- page parameters.
local aliasesHeader = checkValue(cfg.wikitableAliasesHeader, 'Aliases')
    local args = {}
 
    for k, v in pairs(origArgs) do
-- Put the namespaces in order.
        v = mw.text.trim(v) -- Trim whitespace.
local mappingsOrdered = {}
        if k == cfg.demospace or k == cfg.page then
for nsname, params in pairs(mappings) do
            if v ~= '' then
if useTalk or nsname ~= 'talk' then
                args[k] = v
local nsid = namespaces[nsname].id
            end
-- Add 1, as the array must start with 1; nsid 0 would be lost otherwise.
        else
nsid = nsid + 1
            args[k] = v
mappingsOrdered[nsid] = params
        end
end
    end
end
mappingsOrdered = mTableTools.compressSparseArray(mappingsOrdered)
    return compare(args)
 
-- Build the table.
local ret = '{| class="wikitable"'
.. '\n|-'
.. '\n! ' .. nsHeader
.. '\n! ' .. aliasesHeader
for i, params in ipairs(mappingsOrdered) do
for j, param in ipairs(params) do
if j == 1 then
ret = ret .. '\n|-'
.. '\n| <code>' .. param .. '</code>'
.. '\n| '
elseif j == 2 then
ret = ret .. '<code>' .. param .. '</code>'
else
ret = ret .. ', <code>' .. param .. '</code>'
end
end
end
ret = ret .. '\n|-'
.. '\n|}'
return ret
end
end
 
return p
return p

Latest revision as of 14:35, 7 April 2014

--[[

-- -- -- NAMESPACE DETECT -- -- -- -- This module implements the 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. The -- -- module can also use the corresponding subject namespace value if it is -- -- used on a talk page. Parameter names can be configured for different wikis -- -- by altering the values in the "cfg" table in -- -- Module:Namespace detect/config. -- -- --

--]]

local data = mw.loadData('Module:Namespace detect/data') local argKeys = data.argKeys local cfg = data.cfg local mappings = data.mappings

local yesno = require('Module:Yesno') local mArguments -- Lazily initialise Module:Arguments local mTableTools -- Lazily initilalise Module:TableTools local ustringLower = mw.ustring.lower

local p = {}

local function fetchValue(t1, t2) -- Fetches a value from the table t1 for the first key in array t2 where -- a non-nil value of t1 exists. for i, key in ipairs(t2) do local value = t1[key] if value ~= nil then return value end end return nil end

local function equalsArrayValue(t, value) -- Returns true if value equals a value in the array t. Otherwise -- returns false. for i, arrayValue in ipairs(t) do if value == arrayValue then return true end end return false end

function p.getPageObject(page) -- Get the page object, passing the function through pcall in case of -- errors, e.g. being over the expensive function count limit. if page then local success, pageObject = pcall(mw.title.new, page) if success then return pageObject else return nil end else return mw.title.getCurrentTitle() end end

-- Provided for backward compatibility with other modules function p.getParamMappings() return mappings end

local function getNamespace(args) -- This function gets the namespace name from the page object. local page = fetchValue(args, argKeys.demopage) if page == then page = nil end local demospace = fetchValue(args, argKeys.demospace) if demospace == then demospace = nil end local subjectns = fetchValue(args, argKeys.subjectns) local ret if demospace then -- Handle "demospace = main" properly. if equalsArrayValue(argKeys.main, ustringLower(demospace)) then ret = mw.site.namespaces[0].name else ret = demospace end else local pageObject = p.getPageObject(page) if pageObject then if pageObject.isTalkPage then -- Get the subject namespace if the option is set, -- otherwise use "talk". if yesno(subjectns) then ret = mw.site.namespaces[pageObject.namespace].subject.name else ret = 'talk' end else ret = pageObject.nsText end else return nil -- return nil if the page object doesn't exist. end end ret = ret:gsub('_', ' ') return ustringLower(ret) end

function p._main(args) -- Check the parameters stored in the mappings table for any matches. local namespace = getNamespace(args) or 'other' -- "other" avoids nil table keys local params = mappings[namespace] or {} local ret = fetchValue(args, params) --[[ -- If there were no matches, return parameters for other namespaces. -- This happens if there was no text specified for the namespace that -- was detected or if the demospace parameter is not a valid -- namespace. Note that the parameter for the detected namespace must be -- completely absent for this to happen, not merely blank. --]] if ret == nil then ret = fetchValue(args, argKeys.other) end return ret end

function p.main(frame) mArguments = require('Module:Arguments') local args = mArguments.getArgs(frame, {removeBlanks = false}) local ret = p._main(args) return ret or end

function p.table(frame) --[[ -- Create a wikitable of all subject namespace parameters, for -- documentation purposes. The talk parameter is optional, in case it -- needs to be excluded in the documentation. --]]

-- Load modules and initialise variables. mTableTools = require('Module:TableTools') local namespaces = mw.site.namespaces local cfg = data.cfg local useTalk = type(frame) == 'table' and type(frame.args) == 'table' and yesno(frame.args.talk) -- Whether to use the talk parameter.

-- Get the header names. local function checkValue(value, default) if type(value) == 'string' then return value else return default end end local nsHeader = checkValue(cfg.wikitableNamespaceHeader, 'Namespace') local aliasesHeader = checkValue(cfg.wikitableAliasesHeader, 'Aliases')

-- Put the namespaces in order. local mappingsOrdered = {} for nsname, params in pairs(mappings) do if useTalk or nsname ~= 'talk' then local nsid = namespaces[nsname].id -- Add 1, as the array must start with 1; nsid 0 would be lost otherwise. nsid = nsid + 1 mappingsOrdered[nsid] = params end end mappingsOrdered = mTableTools.compressSparseArray(mappingsOrdered)

-- Build the table. local ret = '{| class="wikitable"' .. '\n|-' .. '\n! ' .. nsHeader .. '\n! ' .. aliasesHeader for i, params in ipairs(mappingsOrdered) do for j, param in ipairs(params) do if j == 1 then ret = ret .. '\n|-' .. '\n| ' .. param .. '' .. '\n| ' elseif j == 2 then ret = ret .. '' .. param .. '' else ret = ret .. ', ' .. param .. '' end end end ret = ret .. '\n|-' .. '\n|}' return ret end

return p

Retrieved from "https://sarkarverse.org/index.php?title=Module:Namespace_detect&oldid=22065"