Jump to content

Module:Pagetype: Difference between revisions

Permanently protected module
From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
add caps parameter per talk request
Use Module:Disambiguation to detect disambiguation pages, and remove dependency on Module:Namespace detect. At the moment, this is using the config sandbox, but I will switch to the updated config shortly.
Line 11: Line 11:


-- Load config.
-- Load config.
local cfg = mw.loadData('Module:Pagetype/config')
local cfg = mw.loadData('Module:Pagetype/config/sandbox')


-- Load required modules.
-- Load required modules.
local getArgs = require('Module:Arguments').getArgs
local getArgs = require('Module:Arguments').getArgs
local yesno = require('Module:Yesno')
local yesno = require('Module:Yesno')
local nsDetectModule = require('Module:Namespace detect')
local mDisambiguation = require('Module:Disambiguation')
local nsDetect = nsDetectModule._main
local getParamMappings = nsDetectModule.getParamMappings
local getPageObject = nsDetectModule.getPageObject


local p = {}
local p = {}


-- Look up a namespace argument in the args table.
local function shallowCopy(t)
local function lookUpNamespaceArg(args, key)
-- Makes a shallow copy of a table.
local ret = {}
local arg = args[key]
-- Convert "yes", "1" etc. to true, "no", "0" etc. to false, and leave
for k, v in pairs(t) do
-- other values the same.
ret[k] = v
return yesno(arg, arg)
end

-- Append multiple values to an array
local function appendMultiple(target, source)
for _, value in ipairs(source) do
table.insert(target, value)
end
end
return ret
end
end


-- Get argument keys for a title's namespace
local function checkPagetypeInput(namespace, val)
local function getNamespaceArgKeys(title, cfg)
-- Checks to see whether we need the default value for the given namespace,
local nsInfo = mw.site.namespaces[title.namespace]
-- and if so gets it from the pagetypes table.
local customAliases = cfg.customNamespaceAliases[title.namespace] or {}
-- The yesno function returns true/false for "yes", "no", etc., and returns
local keys = {}
-- val for other input.
if nsInfo.name ~= '' then
local ret = yesno(val, val)
table.insert(keys, nsInfo.name)
if ret and type(ret) ~= 'string' then
end
ret = cfg.pagetypes[namespace]
if nsInfo.canonicalName ~= nsInfo.name and nsInfo.canonicalName ~= '' then
table.insert(keys, nsInfo.canonicalName)
end
end
appendMultiple(keys, nsInfo.aliases)
return ret
appendMultiple(keys, customAliases)
return keys
end
end


-- Get the argument for a title's namespace, if it was specified in the args
local function getPagetypeFromClass(class, param, aliasTable, default)
-- table.
-- Gets the pagetype from a class specified from the first positional
local function getNamespaceArg(title, args, cfg)
-- parameter.
if title.isTalkPage then
param = yesno(param, param)
return lookUpNamespaceArg(args, cfg.talk)
if param ~= false then -- No check if specifically disallowed.
end
for _, alias in ipairs(aliasTable) do
for _, key in ipairs(getNamespaceArgKeys(title, cfg)) do
if class == alias then
local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))
if type(param) == 'string' then
if arg ~= nil then
return param
else
return arg
return default
end
end
end
end
end
end
return nil
end
end


-- Look up a page type specific to the title's namespace
local function getNsDetectValue(args)
local function getExplicitPageType(title, cfg)
-- Builds the arguments to pass to [[Module:Namespace detect]] and returns
if title.isTalkPage then
-- the result.
return cfg.talkDefault
else
return cfg.pagetypes[title.namespace]
end
end


-- Get the default values.
-- Get a default page type that is not specific to the title's namespace
local function getDefaultPageType(args, cfg)
local ndArgs = {}
local defaultns = args[cfg.defaultns]
local other = lookUpNamespaceArg(args, cfg.other)
if defaultns == cfg.defaultnsAll then
if type(other) == 'string' then
return other
ndArgs = shallowCopy(cfg.pagetypes)
else
else
return cfg.otherDefault
local defaultnsArray
if defaultns == cfg.defaultnsExtended then
defaultnsArray = cfg.extendedNamespaces
elseif defaultns == cfg.defaultnsNone then
defaultnsArray = {}
else
defaultnsArray = cfg.defaultNamespaces
end
for _, namespace in ipairs(defaultnsArray) do
ndArgs[namespace] = cfg.pagetypes[namespace]
end
end
end
end


local function detectRedirects(title, args)
--[[
local redirect = lookUpNamespaceArg(args, cfg.redirect)
-- Add custom values passed in from the arguments. These overwrite the
if redirect == false then
-- defaults. The possible argument names are fetched from
-- Don't detect redirects if they have been specifically disallowed.
-- Module:Namespace detect automatically in case new namespaces are
return nil
-- added. Although we accept namespace aliases as parameters, we only pass
-- the local namespace name as a parameter to Module:Namespace detect.
-- This means that the "image" parameter can overwrite defaults for the
-- File: namespace, which wouldn't work if we passed the parameters through
-- separately.
--]]
local mappings = getParamMappings()
for ns, paramAliases in pairs(mappings) do
-- Copy the aliases table, as # doesn't work with tables returned from
-- mw.loadData.
paramAliases = shallowCopy(paramAliases)
local paramName = paramAliases[1]
-- Iterate backwards along the array so that any values for the local
-- namespace names overwrite those for namespace aliases.
for i = #paramAliases, 1, -1 do
local paramAlias = paramAliases[i]
local ndArg = checkPagetypeInput(paramAlias, args[paramAlias])
if ndArg == false then
-- If any arguments are false, convert them to nil to protect
-- against breakage by future changes to
-- [[Module:Namespace detect]].
ndArgs[paramName] = nil
elseif ndArg then
ndArgs[paramName] = ndArg
end
end
end
end

-- Check for disambiguation-class and N/A-class pages in mainspace.
-- Allow custom values for redirects.
if ndArgs.main then
if not title.isRedirect then
local class = args[1]
return nil
if type(class) == 'string' then
elseif type(redirect) == 'string' then
-- Put in lower case so e.g. "Dab" and "dab" will both match.
return redirect
class = mw.ustring.lower(class)
else
end
return cfg.redirectDefault
local dab = getPagetypeFromClass(
end
class,
end
args[cfg.dab],

cfg.dabAliases,
local function detectDisambiguationPages(title, args, cfg)
cfg.dabDefault
if title.namespace ~= 0 then
)
-- Only detect disambiguation pages in mainspace
if dab then
return nil
ndArgs.main = dab
end

local dab = lookUpNamespaceArg(args, cfg.dab)
if dab == false then
-- Don't detect disambiguation pages if explicitly disallowed
return nil
end

if not mDisambiguation.isDisambiguation(title:getContent()) then
return nil
elseif type(dab) == 'string' then
return dab
else
return cfg.dabDefault
end
end

-- Gets the pagetype from a class specified from the first positional
-- parameter.
local function getPageTypeFromClass(args, class, key, aliasTable, default)
local arg = lookUpNamespaceArg(args, key)
if arg == false then
-- Don't check for this class if it is specifically disallowed.
return nil
end
if aliasTable[class] then
if type(arg) == 'string' then
return arg
else
else
return default
local na = getPagetypeFromClass(
class,
args[cfg.na],
cfg.naAliases,
cfg.naDefault
)
if na then
ndArgs.main = na
end
end
end
end
end
return nil
-- If there is no talk value specified, use the corresponding subject
end
-- namespace for talk pages.

if not ndArgs.talk then
-- Get page types for mainspaces pages with an explicit class specified
ndArgs.subjectns = true
local function getMainNamespaceClassPageType(title, args, cfg)
if title.namespace ~= 0 then
return nil
end
end
local class = args[1]
-- Add the fallback value. This can also be customised, but it cannot be
if type(class) == 'string' then
-- disabled.
-- Put in lower case so e.g. "na" and "NA" will both match.
local other = args[cfg.other]
class = mw.ustring.lower(class)
-- We will ignore true/false/nil results from yesno here, but using it
end
-- anyway for consistency.
return getPageTypeFromClass(
other = yesno(other, other)
args,
if type(other) == 'string' then
class,
ndArgs.other = other
cfg.na,
cfg.naAliases,
cfg.naDefault
)
end

-- Get page type specified by an explicit namespace argument.
local function getNamespaceArgPageType(title, args, cfg)
local namespaceArg = getNamespaceArg(title, args, cfg)
if namespaceArg == true then
-- Namespace has been explicitly enabled, so return the default for
-- this namespace
return getExplicitPageType(title, cfg)
elseif namespaceArg == false then
-- Namespace has been explicitly disabled
return getDefaultPageType(args, cfg)
elseif namespaceArg then
-- This namespaces uses custom text
return namespaceArg
else
else
return nil
ndArgs.other = cfg.otherDefault
end
end
-- Allow custom page values.
ndArgs.page = args.page
return nsDetect(ndArgs)
end
end


-- Whether the title is in the set of default active namespaces which are
local function detectRedirects(args)
-- looked up in cfg.pagetypes.
local redirect = args[cfg.redirect]
local function isInDefaultActiveNamespace(title, args, cfg)
-- The yesno function returns true/false for "yes", "no", etc., and returns
local defaultNamespacesKey = args[cfg.defaultns]
-- redirect for other input.
if defaultNamespacesKey == cfg.defaultnsAll then
redirect = yesno(redirect, redirect)
return true
if redirect == false then
-- Detect redirects unless they have been explicitly disallowed with
-- "redirect=no" or similar.
return
end
end

local pageObject = getPageObject(args.page)
local defaultNamespaces
-- If we are using subject namespaces elsewhere, do so here as well.
if defaultNamespacesKey == cfg.defaultnsExtended then
if pageObject
defaultNamespaces = cfg.extendedNamespaces
and not yesno(args.talk, true)
elseif defaultNamespacesKey == cfg.defaultnsNone then
and args[cfg.defaultns] ~= cfg.defaultnsAll
defaultNamespaces = {}
then
else
pageObject = getPageObject(
defaultNamespaces = cfg.defaultNamespaces
pageObject.subjectNsText .. ':' .. pageObject.text
)
end
end
return defaultNamespaces[title.namespace] or false
-- Allow custom values for redirects.
end
if pageObject and pageObject.isRedirect then

if type(redirect) == 'string' then
-- Get page type not specified or detected by other means
return redirect
local function getOtherPageType(title, args, cfg)
else
if isInDefaultActiveNamespace(title, args, cfg) then
return cfg.redirectDefault
return getExplicitPageType(title, cfg)
else
return getDefaultPageType(args, cfg)
end
end

local function getPageType(title, args, cfg)
return (
detectRedirects(title, args, cfg)
or detectDisambiguationPages(title, args, cfg)
or getMainNamespaceClassPageType(title, args, cfg)
or getNamespaceArgPageType(title, args, cfg)
or getOtherPageType(title, args, cfg)
)
end

local function shouldUseSubjectTitle(args, cfg)
return not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll
end

-- Get the Scribunto title object to fetch the page type of
local function getTitle(args, cfg)
local title
if args.page then
title = mw.title.new(args.page)
if not title then
return nil
end
end
else
title = mw.title.getCurrentTitle()
end

if shouldUseSubjectTitle(args, cfg) then
return title.subjectPageTitle
else
return title
end
end
end
end


function p._main(args)
local function pluralize(pageType, cfg)
if cfg.irregularPlurals[pageType] then
local redirect = detectRedirects(args)
return cfg.irregularPlurals[pageType]
local pagetype = ""
if redirect then
pagetype = redirect
else
else
return pageType .. cfg.plural -- often 's'
pagetype = getNsDetectValue(args)
end
end
end

local function capitalize(pageType)
local first = mw.ustring.sub(pageType, 1, 1)
local rest = mw.ustring.sub(pageType, 2)
return mw.ustring.upper(first) .. rest
end

function p._main(args)
local title = getTitle(args, cfg)
local pageType = getPageType(title, args, cfg)
if yesno(args.plural, false) then
if yesno(args.plural, false) then
pageType = pluralize(pageType, cfg)
if cfg.irregularPlurals[pagetype] then
pagetype = cfg.irregularPlurals[pagetype]
else
pagetype = pagetype .. cfg.plural -- often 's'
end
end
end
if yesno(args.caps, false) then
if yesno(args.caps, false) then
pageType = capitalize(pageType)
pagetype = mw.ustring.upper(mw.ustring.sub(pagetype, 1, 1)) ..
mw.ustring.sub(pagetype, 2)
end
end
return pagetype
return pageType
end
end


Revision as of 13:35, 28 August 2023

--------------------------------------------------------------------------------
--                                                                            --
--                                PAGETYPE                                    --
--                                                                            --
--      This is a meta-module intended to replace {{pagetype}} and similar    --
--      templates. It automatically detects namespaces, and allows for a      --
--      great deal of customisation. It can easily be ported to other         --
--      wikis by changing the values in the [[Module:Pagetype/config]].       --
--                                                                            --
--------------------------------------------------------------------------------

-- Load config.
local cfg = mw.loadData('Module:Pagetype/config/sandbox')

-- Load required modules.
local getArgs = require('Module:Arguments').getArgs
local yesno = require('Module:Yesno')
local mDisambiguation = require('Module:Disambiguation')

local p = {}

-- Look up a namespace argument in the args table.
local function lookUpNamespaceArg(args, key)
	local arg = args[key]
	-- Convert "yes", "1" etc. to true, "no", "0" etc. to false, and leave
	-- other values the same.
	return yesno(arg, arg)
end

-- Append multiple values to an array
local function appendMultiple(target, source)
	for _, value in ipairs(source) do
		table.insert(target, value)
	end
end

-- Get argument keys for a title's namespace
local function getNamespaceArgKeys(title, cfg)
	local nsInfo = mw.site.namespaces[title.namespace]
	local customAliases = cfg.customNamespaceAliases[title.namespace] or {}
	local keys = {}
	if nsInfo.name ~= '' then
		table.insert(keys, nsInfo.name)
	end
	if nsInfo.canonicalName ~= nsInfo.name and nsInfo.canonicalName ~= '' then
		table.insert(keys, nsInfo.canonicalName)
	end
	appendMultiple(keys, nsInfo.aliases)
	appendMultiple(keys, customAliases)
	return keys
end

-- Get the argument for a title's namespace, if it was specified in the args
-- table.
local function getNamespaceArg(title, args, cfg)
	if title.isTalkPage then
		return lookUpNamespaceArg(args, cfg.talk)
	end
	for _, key in ipairs(getNamespaceArgKeys(title, cfg)) do
		local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))
		if arg ~= nil then
			return arg
		end
	end
	return nil
end

-- Look up a page type specific to the title's namespace
local function getExplicitPageType(title, cfg)
	if title.isTalkPage then
		return cfg.talkDefault
	else
		return cfg.pagetypes[title.namespace]
	end
end

-- Get a default page type that is not specific to the title's namespace
local function getDefaultPageType(args, cfg)
	local other = lookUpNamespaceArg(args, cfg.other)
	if type(other) == 'string' then
		return other
	else
		return cfg.otherDefault
	end
end

local function detectRedirects(title, args)
	local redirect = lookUpNamespaceArg(args, cfg.redirect)
	if redirect == false then
		-- Don't detect redirects if they have been specifically disallowed.
		return nil
	end

	-- Allow custom values for redirects.
	if not title.isRedirect then
		return nil
	elseif type(redirect) == 'string' then
		return redirect
	else
		return cfg.redirectDefault
	end
end

local function detectDisambiguationPages(title, args, cfg)
	if title.namespace ~= 0 then
		-- Only detect disambiguation pages in mainspace
		return nil
	end

	local dab = lookUpNamespaceArg(args, cfg.dab)
	if dab == false then
		-- Don't detect disambiguation pages if explicitly disallowed
		return nil
	end

	if not mDisambiguation.isDisambiguation(title:getContent()) then
		return nil
	elseif type(dab) == 'string' then
		return dab
	else
		return cfg.dabDefault
	end
end

-- Gets the pagetype from a class specified from the first positional
-- parameter.
local function getPageTypeFromClass(args, class, key, aliasTable, default)
	local arg = lookUpNamespaceArg(args, key)
	if arg == false then
		-- Don't check for this class if it is specifically disallowed.
		return nil
	end
	if aliasTable[class] then
		if type(arg) == 'string' then
			return arg
		else
			return default
		end
	end
	return nil
end

-- Get page types for mainspaces pages with an explicit class specified
local function getMainNamespaceClassPageType(title, args, cfg)
	if title.namespace ~= 0 then
		return nil
	end
	local class = args[1]
	if type(class) == 'string' then
		-- Put in lower case so e.g. "na" and "NA" will both match.
		class = mw.ustring.lower(class)
	end
	return getPageTypeFromClass(
		args,
		class,
		cfg.na,
		cfg.naAliases,
		cfg.naDefault
	)
end

-- Get page type specified by an explicit namespace argument.
local function getNamespaceArgPageType(title, args, cfg)
	local namespaceArg = getNamespaceArg(title, args, cfg)
	if namespaceArg == true then
		-- Namespace has been explicitly enabled, so return the default for
		-- this namespace
		return getExplicitPageType(title, cfg)
	elseif namespaceArg == false then
		-- Namespace has been explicitly disabled
		return getDefaultPageType(args, cfg)
	elseif namespaceArg then
		-- This namespaces uses custom text
		return namespaceArg
	else
		return nil
	end
end

-- Whether the title is in the set of default active namespaces which are
-- looked up in cfg.pagetypes.
local function isInDefaultActiveNamespace(title, args, cfg)
	local defaultNamespacesKey = args[cfg.defaultns]
	if defaultNamespacesKey == cfg.defaultnsAll then
		return true
	end

	local defaultNamespaces
	if defaultNamespacesKey == cfg.defaultnsExtended then
		defaultNamespaces = cfg.extendedNamespaces
	elseif defaultNamespacesKey == cfg.defaultnsNone then
		defaultNamespaces = {}
	else
		defaultNamespaces = cfg.defaultNamespaces
	end
	return defaultNamespaces[title.namespace] or false
end

-- Get page type not specified or detected by other means
local function getOtherPageType(title, args, cfg)
	if isInDefaultActiveNamespace(title, args, cfg) then
		return getExplicitPageType(title, cfg)
	else
		return getDefaultPageType(args, cfg)
	end
end

local function getPageType(title, args, cfg)
	return (
		detectRedirects(title, args, cfg)
		or detectDisambiguationPages(title, args, cfg)
		or getMainNamespaceClassPageType(title, args, cfg)
		or getNamespaceArgPageType(title, args, cfg)
		or getOtherPageType(title, args, cfg)
	)
end

local function shouldUseSubjectTitle(args, cfg)
	return not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll
end

-- Get the Scribunto title object to fetch the page type of
local function getTitle(args, cfg)
	local title
	if args.page then
		title = mw.title.new(args.page)
		if not title then
			return nil
		end
	else
		title = mw.title.getCurrentTitle()
	end

	if shouldUseSubjectTitle(args, cfg) then
		return title.subjectPageTitle
	else
		return title
	end
end

local function pluralize(pageType, cfg)
	if cfg.irregularPlurals[pageType] then
		return cfg.irregularPlurals[pageType]
	else
		return pageType .. cfg.plural -- often 's'
	end
end

local function capitalize(pageType)
	local first = mw.ustring.sub(pageType, 1, 1)
	local rest = mw.ustring.sub(pageType, 2)
	return mw.ustring.upper(first) .. rest
end

function p._main(args)
	local title = getTitle(args, cfg)
	local pageType = getPageType(title, args, cfg)
	if yesno(args.plural, false) then
		pageType = pluralize(pageType, cfg)
	end
	if yesno(args.caps, false) then
		pageType = capitalize(pageType)
	end
	return pageType
end

function p.main(frame)
	local args = getArgs(frame)
	return p._main(args)
end

return p
Retrieved from "https://en.wikipedia.org/w/index.php?title=Module:Pagetype&oldid=1172658813"