Module:Namespace detect: Difference between revisions

From CasperTech Wiki
Jump to navigation Jump to search
m (1 revision)
 
m (1 revision imported)
 
(One intermediate revision by one other 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.                                           --
--                                                                           --
--------------------------------------------------------------------------------
--]]


----------------------------------------------------------------------
local data = mw.loadData('Module:Namespace detect/data')
--                      Configuration data                         --
local argKeys = data.argKeys
--      Language-specific parameter names can be set here.         --
local cfg = data.cfg
----------------------------------------------------------------------
local mappings = data.mappings


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


-- The name for the parameter to display content for the main namespace:
local p = {}
cfg.main = 'main'


-- The name for the parameter to display content in talk namespaces:
local function fetchValue(t1, t2)
cfg.talk = 'talk'
-- 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


-- The name for the parameter to display content for "other" namespaces
local function equalsArrayValue(t, value)
-- (namespaces for which parameters have not been specified, or for when
-- Returns true if value equals a value in the array t. Otherwise
-- cfg.demospace is set to cfg.other):
-- returns false.
cfg.other = 'other'
for i, arrayValue in ipairs(t) do
 
if value == arrayValue then
-- The name for the parameter to set a demonstration namespace:
return true
cfg.demospace = 'demospace'
end
 
end
-- The name for the parameter to set a specific page to compare:
return false
cfg.page = 'page'
end
 
-- 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                      --
----------------------------------------------------------------------
 
-- Specify variables available to the whole module
local p = {}
local args = {}


-- Get the page object. This will return the page object for the page
function p.getPageObject(page)
-- specified, or nil if there are errors in the title or if the
-- Get the page object, passing the function through pcall in case of
-- expensive function count has been exceeded.
-- errors, e.g. being over the expensive function count limit.
local function getPageObject()
if page then
    -- Get the title object for args.page if it is specified. Otherwise
local success, pageObject = pcall(mw.title.new, page)
    -- get the title object for the current page.
if success then
    if args[cfg.page] then
return pageObject
        -- Get the page object, passing the function through pcall  
else
        -- in case we are over the expensive function count limit.
return nil
        local noError, pageObject = pcall(mw.title.new, args[cfg.page])
end
        if not noError then
else
            return nil
return mw.title.getCurrentTitle()
        else
end
            return pageObject
        end
    else
        return mw.title.getCurrentTitle()
    end  
end
end


-- Detects the namespace for a page object.
-- Provided for backward compatibility with other modules
local function detectNamespace(pageObject)
function p.getParamMappings()
    if pageObject.isTalkPage then
return mappings
        -- Returns the value of cfg.talk or the local "Talk" namespace name.
        return cfg.talk or mw.site.namespaces[1].name
    else
        return pageObject.nsText
    end
end
end


-- Gets the namespace name to compare to the arguments. The returned value
local function getNamespace(args)
-- is lower-case.
-- This function gets the namespace name from the page object.
local function getNamespace()
local page = fetchValue(args, argKeys.demopage)
    local ret
if page == '' then
    if args[cfg.demospace] then
page = nil
        -- Handle "demospace = main" properly.
end
        if mw.ustring.lower( args[cfg.demospace] ) == cfg.main then
local demospace = fetchValue(args, argKeys.demospace)
            ret = mw.site.namespaces[0].name
if demospace == '' then
        else
demospace = nil
            ret = args[cfg.demospace]
end
        end
local subjectns = fetchValue(args, argKeys.subjectns)
    else
local ret
        local pageObject = getPageObject()
if demospace then
        if pageObject then
-- Handle "demospace = main" properly.
            ret = detectNamespace( getPageObject() )
if equalsArrayValue(argKeys.main, ustringLower(demospace)) then
        else
ret = mw.site.namespaces[0].name
            return nil -- return nil if the page object doesn't exist.
else
        end
ret = demospace
    end
end
    return mw.ustring.lower(ret)
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
end


-- Compare the namespace found with the parameters that have been
function p._main(args)
-- specified, and return content of the appropriate parameter.
-- Check the parameters stored in the mappings table for any matches.
local function compare()
local namespace = getNamespace(args) or 'other' -- "other" avoids nil table keys
    local namespace = getNamespace()
local params = mappings[namespace] or {}
   
local ret = fetchValue(args, params)
    -- First, compare mainspace parameters.
--[[
    if namespace == mw.site.namespaces[0].name and args[cfg.main] then
-- If there were no matches, return parameters for other namespaces.
        return args[cfg.main]
-- This happens if there was no text specified for the namespace that
    end
-- was detected or if the demospace parameter is not a valid
   
-- namespace. Note that the parameter for the detected namespace must be
    -- Next, compare parameters for non-main namespaces.
-- completely absent for this to happen, not merely blank.
    for nsid, ns in pairs( mw.site.namespaces ) do
--]]
        local nsname = mw.ustring.lower( ns.name )
if ret == nil then
        local canonicalName = mw.ustring.lower( ns.canonicalName )
ret = fetchValue(args, argKeys.other)
        -- Check the namespace, and ignore main namespace values.
end
        if nsid ~= 0 and nsname == namespace then
return ret
            -- Check local namespace name.
            if args[nsname] then
                return args[nsname]
            -- Check canonical namespace name.
            elseif args[canonicalName] then
                return args[canonicalName]
            else
                -- Check alias names.
                for _, alias in ipairs( ns.aliases ) do
                    local aliasArg = args[ mw.ustring.lower( alias ) ]
                    if aliasArg then
                        return aliasArg
                    end
                end
            end
        end
    end
   
    -- Finally, 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


-- Process the arguments.
function p.main(frame)
function p.main(frame)
    -- If called via #invoke, use the args passed into the invoking
mArguments = require('Module:Arguments')
    -- template, or the args passed to #invoke if any exist. Otherwise
local args = mArguments.getArgs(frame, {removeBlanks = false})
    -- assume args are being passed directly in.
local ret = p._main(args)
    local origArgs
return ret or ''
    if frame == mw.getCurrentFrame() then
        origArgs = frame:getParent().args
        for k, v in pairs( frame.args ) do
            origArgs = frame.args
            break
        end
    else
        origArgs = frame
    end
   
    -- Trim whitespace and remove blank arguments for demospace and
    -- page parameters.
    for k, v in pairs(origArgs) do
        v = mw.text.trim(v) -- Trim whitespace.
        if k == cfg.demospace or k == cfg.page then
            if v ~= '' then
                args[k] = v
            end
        else
            args[k] = v
        end
    end
   
    return compare()
end
end


-- Create a wikitable of all possible namespace parameters.
function p.table(frame)
function p.table()
--[[
    -- Start the wikitable.
-- Create a wikitable of all subject namespace parameters, for
    local ret = '{| class="wikitable"'
-- documentation purposes. The talk parameter is optional, in case it
        .. '\n|-'
-- needs to be excluded in the documentation.
        .. '\n! ' .. cfg.wikitableNamespaceHeader
--]]
        .. '\n! ' .. cfg.wikitableAliasesHeader
   
-- Load modules and initialise variables.
    -- Generate the row for the main namespace.
mTableTools = require('Module:TableTools')
    ret = ret .. '\n|-'
local namespaces = mw.site.namespaces
        .. '\n| ' .. cfg.main
local cfg = data.cfg
        .. '\n|'
local useTalk = type(frame) == 'table'  
   
and type(frame.args) == 'table'  
    -- Generate the other wikitable rows.
and yesno(frame.args.talk) -- Whether to use the talk parameter.
    for nsid, ns in pairs( mw.site.subjectNamespaces ) do
        if nsid ~= 0 then -- Ignore the main namespace, as it is set in cfg.
-- Get the header names.
            local name = '<code>' .. mw.ustring.lower( ns.name ) .. '</code>'
local function checkValue(value, default)
            local aliases = {}
if type(value) == 'string' then
            if ns.canonicalName ~= ns.name then
return value
                table.insert( aliases, '<code>' .. mw.ustring.lower( ns.canonicalName ) .. '</code>' )
else
            end
return default
            for _, v in ipairs( ns.aliases ) do
end
                table.insert( aliases, '<code>' .. mw.ustring.lower(v) .. '</code>' )
end
            end
local nsHeader = checkValue(cfg.wikitableNamespaceHeader, 'Namespace')
            ret = ret .. '\n|-'
local aliasesHeader = checkValue(cfg.wikitableAliasesHeader, 'Aliases')
                .. '\n| ' .. name
 
                .. '\n| ' .. table.concat( aliases, ', ' )
-- Put the namespaces in order.
        end
local mappingsOrdered = {}
    end
for nsname, params in pairs(mappings) do
   
if useTalk or nsname ~= 'talk' then
    -- End the wikitable.
local nsid = namespaces[nsname].id
    ret = ret .. '\n|-'
-- Add 1, as the array must start with 1; nsid 0 would be lost otherwise.
        .. '\n|}'
nsid = nsid + 1
   
mappingsOrdered[nsid] = params
    return ret
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| <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 20:08, 9 December 2018

Documentation for this module may be created at Module:Namespace detect/doc

--[[
--------------------------------------------------------------------------------
--                                                                            --
--                            NAMESPACE DETECT                                --
--                                                                            --
-- This module implements the {{namespace detect}} 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| <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

return p