Module:Pagetype: Difference between revisions

Permanently protected module
From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
add a defaultns parameter to allow different sets of default namespaces
add detection of non-existent pages, some code simplication
(13 intermediate revisions by 5 users not shown)
Line 1: Line 1:
----------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- --
-- --
-- This meta-module which automatically detects namespaces, and allows --
-- PAGETYPE --
-- for a great deal of customisation. It can easily be ported to other --
-- --
-- This is a meta-module intended to replace {{pagetype}} and similar templates. It --
-- wikis by changing the values in the [[Module:Pagetype/config]]. --
-- 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 configuration --
-- table.
-- Load config.
local cfg = mw.loadData('Module:Pagetype/config')
-- --
----------------------------------------------------------------------------------------------------


-- Load required modules.
local cfg = {}
local yesno = require('Module:Yesno')
local p = {}


-- Look up a namespace argument in the args table.
----------------------------------------------------------------------------------------------------
local function lookUpNamespaceArg(args, key)
-- Configuration data --
local arg = args[key]
-- This module can be localised for other wikis by using the configuration parameters below. --
-- 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
-- This table holds the values to use for "main=true", "user=true", etc. Keys to this table should
local function appendMultiple(target, source)
-- be namespace parameters that can be used with [[Module:Namespace detect]].
for _, value in ipairs(source) do
cfg.pagetypes = {
table.insert(target, value)
['main'] = 'article',
end
['user'] = 'user page',
end
['project'] = 'project page',
['wikipedia'] = 'project page',
['wp'] = 'project page',
['file'] = 'file',
['image'] = 'file',
['mediawiki'] = 'interface page',
['template'] = 'template',
['help'] = 'help page',
['category'] = 'category',
['portal'] = 'portal',
['book'] = 'book',
['education program'] = 'education program page',
['timedtext'] = 'Timed Text page',
['module'] = 'module',
['talk'] = 'talk page',
['special'] = 'special page',
['media'] = 'file'
}


-- Get argument keys for a title's namespace
-- This table holds the names of the namespaces to be looked up from cfg.pagetypes by default.
local function getNamespaceArgKeys(title)
cfg.defaultNamespaces = {'main', 'file', 'template', 'category', 'module', 'book'}
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.
-- This table holds the names of the namespaces to be looked up from cry.pagetypes if cfg.defaultnsExtended is set.
local function getNamespaceArg(title, args)
cfg.extendedNamespaces = {'main', 'user', 'project', 'file', 'mediawiki', 'template', 'category', 'help', 'portal', 'module', 'book'}
if title.isTalkPage then
return lookUpNamespaceArg(args, cfg.talk)
end
for _, key in ipairs(getNamespaceArgKeys(title)) 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
-- The parameter name to set which default namespace values to be looked up from cfg.pagetypes.
local function getExplicitPageType(title)
cfg.defaultns = 'defaultns'
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
-- The value of cfg.defaultns to set all namespaces, including talk.
local function getDefaultPageType(args)
cfg.defaultnsAll = 'all'
local other = lookUpNamespaceArg(args, cfg.other)
if type(other) == 'string' then
return other
else
return cfg.otherDefault
end
end


local function detectRedirects(title, args)
-- The value of cfg.defaultns to set the namespaces listed in cfg.extendedNamespaces
local redirect = lookUpNamespaceArg(args, cfg.redirect)
cfg.defaultnsExtended = 'extended'
if redirect == false then
-- Don't detect redirects if they have been specifically disallowed.
return nil
end


-- Allow custom values for redirects.
-- The value of cfg.defaultns to set no default namespaces.
if not title.isRedirect then
cfg.defaultnsNone = 'none'
return nil
elseif type(redirect) == 'string' then
return redirect
else
return cfg.redirectDefault
end
end


local function capitalize(pageType)
-- The parameter name to use for disambiguation pages page.
local first = mw.ustring.sub(pageType, 1, 1)
cfg.dab = 'dab'
local rest = mw.ustring.sub(pageType, 2)
return mw.ustring.upper(first) .. rest
end


local function pluralize(pageType)
-- This table holds the different possible aliases for disambiguation-class pages. These should be lower-case.
if cfg.irregularPlurals[pageType] then
cfg.dabAliases = {'disambiguation', 'disambig', 'disamb', 'dab'}
return cfg.irregularPlurals[pageType]

else
-- The default value for disambiguation pages.
return pageType .. cfg.plural -- often 's'
cfg.dabDefault = 'page'

-- The parameter name to use for N/A-class page.
cfg.na = 'na'

-- This table holds the different possible aliases for N/A-class pages. These should be lower-case.
cfg.naAliases = {'na', 'n/a'}

-- The default value for N/A-class pages.
cfg.naDefault = 'page'

-- The parameter name to use for redirects.
cfg.redirect = 'redirect'

-- The default value to use for redirects.
cfg.redirectDefault = 'redirect'

-- The parameter name for undefined namespaces.
cfg.other = 'other'

-- The value used if the module detects an undefined namespace.
cfg.otherDefault = 'page'

----------------------------------------------------------------------------------------------------
-- End configuration data --
----------------------------------------------------------------------------------------------------

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

local p = {}

local function checkPagetypeInput(namespace, val)
-- Checks to see whether we need the default value for the given namespace, and if so gets it from the pagetypes table.
local ret = yesno(val, val) -- Returns true/false for "yes", "no", etc., and returns val for other input.
if ret and type(ret) ~= 'string' then
ret = cfg.pagetypes[namespace]
end
end
return ret
end
end


local function getPagetypeFromClass(class, param, aliasTable, default)
local function parseContent(title, args, optionsList)
if title.namespace==828 and title.subpageText~='doc' -- don't detect modules
-- Gets the pagetype from a class specified from the first positional parameter.
or not title.exists -- can't check unless page exists
param = yesno(param, param)
then
if param ~= false then -- Check for classes unless they are specifically disallowed.
return nil
for _, alias in ipairs(aliasTable) do
end
if class == alias then
local content = title:getContent()
if type(param) == 'string' then
if content == nil then
return param
return nil
else
end
return default
local templates -- lazily evaluated
for _, options in next, optionsList do
local list, parameter, default, articleOnly = unpack(options, 1, 4)
if not articleOnly or title.namespace==0 then -- only check for templates if we should...
local out = lookUpNamespaceArg(args, parameter)
if type(out) == "string" or (out ~= false and default) then -- ...and if we actually have anything to say about them
if not templates then
templates = {} -- do our delayed evaluation now that we are required to
content = require('Module:Wikitext Parsing').PrepareText(content) -- disregard templates which do not have any affect
for template in string.gmatch(content, "{{%s*([^|}]-)%s*[|}]") do
templates[#templates+1] = capitalize(template)
end
end
local wantedTemplates = mw.loadData('Module:Pagetype/' .. list)
local templateFound = false
for _, template in next, templates do
if wantedTemplates[template] then
templateFound = true
break
end
end
if templateFound then
if type(out)=='string' then
return out
elseif out ~= false and default then
return default
end
end
end
end
end
Line 127: Line 151:
end
end


-- Find pages which do not exist
local function getNsDetectValue(args)
local function nonExistent(title, args)
-- Builds the arguments to pass to [[Module:Namespace detect]] and returns the result.
local arg = lookUpNamespaceArg(args, cfg.ne)
-- First, get the default values.
if arg == false then
local ndArgs = {}
return nil
local defaultns = args[cfg.defaultns]
end
if defaultns == cfg.defaultnsAll then
if not title.exists then -- not an article if it does not exist
ndArgs = cfg.pagetypes
if type(arg) == 'string' then
else
return arg
local defaultnsArray
if defaultns == cfg.defaultnsExtended then
defaultnsArray = cfg.extendedNamespaces
elseif defaultns == cfg.defaultnsNone then
defaultnsArray = {}
else
else
return cfg.naDefault
defaultnsArray = cfg.defaultNamespaces
end
for _, namespace in ipairs(defaultnsArray) do
ndArgs[namespace] = cfg.pagetypes[namespace]
end
end
end
end
end
-- Add custom values passed in from the arguments. These overwrite the defaults.

-- The possible argument names are fetched from [[Module:Namespace detect]] automatically in case new namespaces are added.
-- Get page types for mainspaces pages with an explicit class specified
-- Although we accept namespace aliases as parameters, we only pass the local namespace name as a parameter to [[Module:Namespace detect]].
local function getMainNamespaceClassPageType(title, args)
-- 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()
local class = args[1]
if type(class) == 'string' then -- Put in lower case so e.g. "na" and "NA" will both match
for ns, paramAliases in pairs(mappings) do
class = mw.ustring.lower(class)
local paramName = paramAliases[1]
for i = #paramAliases, 1, -1 do -- Iterate backwards along the array so that any values for the local namespace names overwrite those for namespace aliases.
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
local arg = lookUpNamespaceArg(args, cfg.na)
-- Check for disambiguation-class and N/A-class pages in mainspace.
if arg == false then -- don't check for this class if it is specifically disallowed
if ndArgs.main then
return nil
local class = args[1]
end
if type(class) == 'string' then
if cfg.naAliases[class] then
-- Put in lower case so e.g. "Dab" and "dab" will both match.
if type(arg) == 'string' then
class = mw.ustring.lower(class)
return arg
end
local dab = getPagetypeFromClass(class, args[cfg.dab], cfg.dabAliases, cfg.dabDefault)
if dab then
ndArgs.main = dab
else
else
return cfg.naDefault
local na = getPagetypeFromClass(class, args[cfg.na], cfg.naAliases, cfg.naDefault)
if na then
ndArgs.main = na
end
end
end
end
-- If there is no talk value specified, use the corresponding subject namespace for talk pages.
if not ndArgs.talk then
ndArgs.subjectns = true
end
-- Add the fallback value. This can also be customised, but it cannot be disabled.
local other = args[cfg.other]
other = yesno(other, other) -- We will ignore true/false/nil results from yesno here, but using it anyway for consistency.
if type(other) == 'string' then
ndArgs.other = other
else
else
return nil
ndArgs.other = cfg.otherDefault
end
end
-- Allow custom page values.
ndArgs.page = args.page
return nsDetect(ndArgs)
end
end


-- Get page type specified by an explicit namespace argument.
local function detectRedirects(args)
local function getNamespaceArgPageType(title, args)
local redirect = args[cfg.redirect]
local namespaceArg = getNamespaceArg(title, args)
redirect = yesno(redirect, redirect) -- Returns true/false for "yes", "no", etc., and returns redirect for other input.
if namespaceArg == true then
if redirect == false then return end -- Detect redirects unless they have been explicitly disallowed with "redirect=no" or similar.
-- Namespace has been explicitly enabled, so return the default for
local pageObject = getPageObject(args.page)
-- this namespace
-- If we are using subject namespaces elsewhere, do so here as well.
return getExplicitPageType(title)
if pageObject and not yesno(args.talk, true) then
elseif namespaceArg == false then
pageObject = getPageObject(pageObject.subjectNsText .. ':' .. pageObject.text)
-- Namespace has been explicitly disabled
return getDefaultPageType(args)
elseif namespaceArg then
-- This namespaces uses custom text
return namespaceArg
else
return nil
end
end
end
-- Allow custom values for redirects.

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)
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
local isInDefaultActiveNamespace = false
local defaultNamespacesKey = args[cfg.defaultns]
if defaultNamespacesKey == cfg.defaultnsAll then
isInDefaultActiveNamespace = true
else
local defaultNamespaces
if defaultNamespacesKey == cfg.defaultnsExtended then
defaultNamespaces = cfg.extendedNamespaces
elseif defaultNamespacesKey == cfg.defaultnsNone then
defaultNamespaces = {}
else
else
defaultNamespaces = cfg.defaultNamespaces
return cfg.redirectDefault
end
end
isInDefaultActiveNamespace = defaultNamespaces[title.namespace]
end
if isInDefaultActiveNamespace then
return getExplicitPageType(title)
else
return getDefaultPageType(args)
end
end
end
end


function p._main(args)
function p._main(args)
local title
local redirect = detectRedirects(args)
if redirect then
if args.page then
title = mw.title.new(args.page)
return redirect
else
else
title = mw.title.getCurrentTitle()
return getNsDetectValue(args)
end
end
if title and not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll then
title = title.subjectPageTitle
end
local pageType = detectRedirects(title, args)
or nonExistent(title, args)
or parseContent(title, args, {
{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},
{'setindex', cfg.sia, cfg.siaDefault, true},
{'disambiguation', cfg.dab, cfg.dabDefault, true},
{'rfd', cfg.rfd, cfg.rfdDefault},
})
or (title.namespace == 0 and getMainNamespaceClassPageType(title, args))
or getNamespaceArgPageType(title, args)
or getOtherPageType(title, args)
if yesno(args.plural, false) then
pageType = pluralize(pageType)
end
if yesno(args.caps, false) then
pageType = capitalize(pageType)
end
return pageType
end
end


function p.main(frame)
function p.main(frame)
local args = require('Module:Arguments').getArgs(frame)
-- If called via #invoke, use the args passed into the invoking template, or the args passed to #invoke if any exist.
-- Otherwise assume args are being passed directly in from the debug console or from another Lua module.
local origArgs
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.
local args = {}
for k, v in pairs(origArgs) do
if type(v) == 'string' then
v = mw.text.trim(v)
end
if v ~= '' then
args[k] = v
end
end
return p._main(args)
return p._main(args)
end
end

Revision as of 12:25, 16 May 2024

--------------------------------------------------------------------------------
--                                                                            --
--      This meta-module which 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')

-- Load required modules.
local yesno = require('Module:Yesno')
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)
	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)
	if title.isTalkPage then
		return lookUpNamespaceArg(args, cfg.talk)
	end
	for _, key in ipairs(getNamespaceArgKeys(title)) 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)
	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)
	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 capitalize(pageType)
	local first = mw.ustring.sub(pageType, 1, 1)
	local rest = mw.ustring.sub(pageType, 2)
	return mw.ustring.upper(first) .. rest
end

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

local function parseContent(title, args, optionsList)
	if title.namespace==828 and title.subpageText~='doc' -- don't detect modules
		or not title.exists -- can't check unless page exists
	then
		return nil
	end
	local content = title:getContent()
	if content == nil then
		return nil
	end
	local templates -- lazily evaluated
	for _, options in next, optionsList do
		local list, parameter, default, articleOnly = unpack(options, 1, 4)
		if not articleOnly or title.namespace==0 then -- only check for templates if we should...
			local out = lookUpNamespaceArg(args, parameter)
			if type(out) == "string" or (out ~= false and default) then -- ...and if we actually have anything to say about them
				if not templates then
					templates = {} -- do our delayed evaluation now that we are required to
					content = require('Module:Wikitext Parsing').PrepareText(content) -- disregard templates which do not have any affect
					for template in string.gmatch(content, "{{%s*([^|}]-)%s*[|}]") do
						templates[#templates+1] = capitalize(template)
					end
				end
				local wantedTemplates = mw.loadData('Module:Pagetype/' .. list)
				local templateFound = false
				for _, template in next, templates do
					if wantedTemplates[template] then
						templateFound = true
						break
					end
				end
				if templateFound then
					if type(out)=='string' then
						return out
					elseif out ~= false and default then
						return default
					end
				end
			end
		end
	end
end

-- Find pages which do not exist
local function nonExistent(title, args)
	local arg = lookUpNamespaceArg(args, cfg.ne)
	if arg == false then
		return nil
	end
	if not title.exists then -- not an article if it does not exist
		if type(arg) == 'string' then
			return arg
		else
			return cfg.naDefault
		end
	end
end

-- Get page types for mainspaces pages with an explicit class specified
local function getMainNamespaceClassPageType(title, args)
	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
	local arg = lookUpNamespaceArg(args, cfg.na)
	if arg == false then -- don't check for this class if it is specifically disallowed
		return nil
	end
	if cfg.naAliases[class] then
		if type(arg) == 'string' then
			return arg
		else
			return cfg.naDefault
		end
	else
		return nil
	end
end

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


-- Get page type not specified or detected by other means
local function getOtherPageType(title, args)
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
	local isInDefaultActiveNamespace = false
	local defaultNamespacesKey = args[cfg.defaultns]
	if defaultNamespacesKey == cfg.defaultnsAll then
		isInDefaultActiveNamespace = true
	else
		local defaultNamespaces
		if defaultNamespacesKey == cfg.defaultnsExtended then
			defaultNamespaces = cfg.extendedNamespaces
		elseif defaultNamespacesKey == cfg.defaultnsNone then
			defaultNamespaces = {}
		else
			defaultNamespaces = cfg.defaultNamespaces
		end
		isInDefaultActiveNamespace = defaultNamespaces[title.namespace]
	end
	if isInDefaultActiveNamespace then
		return getExplicitPageType(title)
	else
		return getDefaultPageType(args)
	end
end

function p._main(args)
	local title
	if args.page then
		title = mw.title.new(args.page)
	else
		title = mw.title.getCurrentTitle()
	end
	if title and not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll then
		title = title.subjectPageTitle
	end
	local pageType = detectRedirects(title, args)
		or nonExistent(title, args)
		or parseContent(title, args, {
			{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},
			{'setindex', cfg.sia, cfg.siaDefault, true},
			{'disambiguation', cfg.dab, cfg.dabDefault, true},
			{'rfd', cfg.rfd, cfg.rfdDefault},
		})
		or (title.namespace == 0 and getMainNamespaceClassPageType(title, args))
		or getNamespaceArgPageType(title, args)
		or getOtherPageType(title, args)
	if yesno(args.plural, false) then
		pageType = pluralize(pageType)
	end
	if yesno(args.caps, false) then
		pageType = capitalize(pageType)
	end
	return pageType
end

function p.main(frame)
	local args = require('Module:Arguments').getArgs(frame)
	return p._main(args)
end

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