IxWiki

Module:Pagetype: Difference between revisions

Module Discussion

Module:Pagetype (view source)

Revision as of 09:37, 28 August 2023

760 bytes added ,  28 August 2023
switch back to using Module:Pagetype/config, as it has now been updated
m (1 revision imported)
>Mr. Stradivarius
(switch back to using Module:Pagetype/config, as it has now been updated)
 
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 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 = {}


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


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


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


local function getNsDetectValue(args)
local function detectDisambiguationPages(title, args, cfg)
-- Builds the arguments to pass to [[Module:Namespace detect]] and returns
if title.namespace ~= 0 then
-- the result.
-- 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


-- Get the default values.
if not mDisambiguation.isDisambiguation(title:getContent()) then
local ndArgs = {}
return nil
local defaultns = args[cfg.defaultns]
elseif type(dab) == 'string' then
if defaultns == cfg.defaultnsAll then
return dab
ndArgs = shallowCopy(cfg.pagetypes)
else
else
local defaultnsArray
return cfg.dabDefault
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


--[[
-- Gets the pagetype from a class specified from the first positional
-- Add custom values passed in from the arguments. These overwrite the
-- parameter.
-- defaults. The possible argument names are fetched from
local function getPageTypeFromClass(args, class, key, aliasTable, default)
-- Module:Namespace detect automatically in case new namespaces are
local arg = lookUpNamespaceArg(args, key)
-- added. Although we accept namespace aliases as parameters, we only pass
if arg == false then
-- the local namespace name as a parameter to Module:Namespace detect.
-- Don't check for this class if it is specifically disallowed.
-- This means that the "image" parameter can overwrite defaults for the
return nil
-- 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.
if aliasTable[class] then
if ndArgs.main then
if type(arg) == 'string' then
local class = args[1]
return arg
if type(class) == 'string' then
-- Put in lower case so e.g. "Dab" and "dab" will both match.
class = mw.ustring.lower(class)
end
local dab = getPagetypeFromClass(
class,
args[cfg.dab],
cfg.dabAliases,
cfg.dabDefault
)
if dab then
ndArgs.main = dab
else
else
local na = getPagetypeFromClass(
return default
class,
args[cfg.na],
cfg.naAliases,
cfg.naDefault
)
if na then
ndArgs.main = na
end
end
end
end
end
-- If there is no talk value specified, use the corresponding subject
return nil
-- namespace for talk pages.
end
if not ndArgs.talk then
 
ndArgs.subjectns = true
-- 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
end
-- Add the fallback value. This can also be customised, but it cannot be
local class = args[1]
-- disabled.
if type(class) == 'string' then
local other = args[cfg.other]
-- Put in lower case so e.g. "na" and "NA" will both match.
-- We will ignore true/false/nil results from yesno here, but using it
class = mw.ustring.lower(class)
-- anyway for consistency.
end
other = yesno(other, other)
return getPageTypeFromClass(
if type(other) == 'string' then
args,
ndArgs.other = other
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
else
ndArgs.other = cfg.otherDefault
return nil
end
end
-- Allow custom page values.
ndArgs.page = args.page
return nsDetect(ndArgs)
end
end


local function detectRedirects(args)
-- Whether the title is in the set of default active namespaces which are
local redirect = args[cfg.redirect]
-- looked up in cfg.pagetypes.
-- The yesno function returns true/false for "yes", "no", etc., and returns
local function isInDefaultActiveNamespace(title, args, cfg)
-- redirect for other input.
local defaultNamespacesKey = args[cfg.defaultns]
redirect = yesno(redirect, redirect)
if defaultNamespacesKey == cfg.defaultnsAll then
if redirect == false then
return true
-- Detect redirects unless they have been explicitly disallowed with
end
-- "redirect=no" or similar.
 
return
local defaultNamespaces
if defaultNamespacesKey == cfg.defaultnsExtended then
defaultNamespaces = cfg.extendedNamespaces
elseif defaultNamespacesKey == cfg.defaultnsNone then
defaultNamespaces = {}
else
defaultNamespaces = cfg.defaultNamespaces
end
end
local pageObject = getPageObject(args.page)
return defaultNamespaces[title.namespace] or false
-- If we are using subject namespaces elsewhere, do so here as well.
end
if pageObject
 
and not yesno(args.talk, true)
-- Get page type not specified or detected by other means
and args[cfg.defaultns] ~= cfg.defaultnsAll
local function getOtherPageType(title, args, cfg)
then
if isInDefaultActiveNamespace(title, args, cfg) then
pageObject = getPageObject(
return getExplicitPageType(title, cfg)
pageObject.subjectNsText .. ':' .. pageObject.text
else
)
return getDefaultPageType(args, cfg)
end
end
-- Allow custom values for redirects.
end
if pageObject and pageObject.isRedirect then
 
if type(redirect) == 'string' then
local function getPageType(title, args, cfg)
return redirect
return (
else
detectRedirects(title, args, cfg)
return cfg.redirectDefault
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)
local redirect = detectRedirects(args)
if cfg.irregularPlurals[pageType] then
local pagetype = ""
return cfg.irregularPlurals[pageType]
if redirect then
pagetype = redirect
else
else
pagetype = getNsDetectValue(args)
return pageType .. cfg.plural -- often 's'
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
if cfg.irregularPlurals[pagetype] then
pageType = pluralize(pageType, cfg)
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 = mw.ustring.upper(mw.ustring.sub(pagetype, 1, 1)) ..
pageType = capitalize(pageType)
mw.ustring.sub(pagetype, 2)
end
end
return pagetype
return pageType
end
end


Anonymous user
Retrieved from "https://ixwiki.com/wiki/Special:MobileDiff/66949"