Module:Pagetype: Difference between revisions
From The Lands Of Liberos Project
Content added Content deleted
m (1 revision imported) |
m (1 revision imported) |
||
(One intermediate revision by one other user not shown) | |||
Line 16: | Line 16: | ||
local getArgs = require('Module:Arguments').getArgs |
local getArgs = require('Module:Arguments').getArgs |
||
local yesno = require('Module:Yesno') |
local yesno = require('Module:Yesno') |
||
local |
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 |
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 |
|||
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 a default page type that is not specific to the title's namespace |
|||
local function getDefaultPageType(args, cfg) |
|||
local ndArgs = {} |
|||
local |
local other = lookUpNamespaceArg(args, cfg.other) |
||
if |
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 |
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 |
return pageType |
||
end |
end |
||
Latest revision as of 08:59, 1 December 2023
Documentation for this module may be created at Module:Pagetype/doc
--------------------------------------------------------------------------------
-- --
-- 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')
-- 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