Wikipedia

Module:Pagetype: Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
m Changed protection level for "Module:Pagetype": Nearly 8 million transclusions, only template used in WPBannerMeta not to be fully protected ([Edit=Require administrator access] (indefinite) [Move=Require administrator access] (indefinite))
m fix for files and interface messages which do exist but are not stored locally
 
(10 intermediate revisions by 4 users not shown)
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 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 nsDetectModule = require('Module:Namespace detect')
local nsDetect = nsDetectModule._main
local getParamMappings = nsDetectModule.getParamMappings
local getPageObject = nsDetectModule.getPageObject
 
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 retarg = {}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
return ret
end
 
-- Get argument keys for a title's namespace
local function checkPagetypeInput(namespace, val)
local function getNamespaceArgKeys(title)
-- 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
ret = cfg.pagetypes[namespace]
end
if nsInfo.canonicalName ~= nsInfo.name and nsInfo.canonicalName ~= '' then
return ret
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 getPagetypeFromClass(class, param, aliasTable, default)
local function getNamespaceArg(title, args)
-- Gets the pagetype from a class specified from the first positional
if title.isTalkPage then
-- parameter.
return lookUpNamespaceArg(args, cfg.talk)
param = yesno(param, param)
end
if param ~= false then -- No check if specifically disallowed.
for _, aliaskey in ipairs(aliasTablegetNamespaceArgKeys(title)) do
local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))
if class == alias then
if type(param)arg =~= 'string'nil then
return paramarg
else
return default
end
end
end
end
return nil
end
 
-- Look up a page type specific to the title's namespace
local function getNsDetectValue(args)
local function getExplicitPageType(title)
-- 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 thea default values.page type that is not specific to the title's namespace
local function getDefaultPageType(args)
local ndArgs = {}
local defaultnsother = lookUpNamespaceArg(args[, cfg.defaultns]other)
if defaultnstype(other) == cfg.defaultnsAll'string' then
return other
ndArgs = shallowCopy(cfg.pagetypes)
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
 
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
end
-- the local namespace name as a parameter to Module:Namespace detect.
 
-- This means that the "image" parameter can overwrite defaults for the
-- Allow custom values for redirects.
-- File: namespace, which wouldn't work if we passed the parameters through
if not title.isRedirect then
-- separately.
return nil
--]]
elseif type(redirect) == 'string' then
local mappings = getParamMappings()
return redirect
for ns, paramAliases in pairs(mappings) do
else
-- Copy the aliases table, as # doesn't work with tables returned from
return cfg.redirectDefault
-- mw.loadData.
end
paramAliases = shallowCopy(paramAliases)
end
local paramName = paramAliases[1]
 
-- Iterate backwards along the array so that any values for the local
local function capitalize(pageType)
-- namespace names overwrite those for namespace aliases.
for local ifirst = #paramAliasesmw.ustring.sub(pageType, 1, -1 do)
local rest = mw.ustring.sub(pageType, 2)
local paramAlias = paramAliases[i]
return mw.ustring.upper(first) .. rest
local ndArg = checkPagetypeInput(paramAlias, args[paramAlias])
end
if ndArg == false then
 
-- If any arguments are false, convert them to nil to protect
local function pluralize(pageType)
-- against breakage by future changes to
if cfg.irregularPlurals[pageType] then
-- [[Module:Namespace detect]].
return cfg.irregularPlurals[pageType]
ndArgs[paramName] = nil
else
elseif ndArg then
return pageType .. cfg.plural -- often 's'
ndArgs[paramName] = ndArg
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
-- Check for disambiguation-class and N/A-class pages in mainspace.
 
if ndArgs.main then
-- Find pages which do not exist
local class = args[1]
local function nonExistent(title, args)
if type(class) == 'string' then
local arg = lookUpNamespaceArg(args, cfg.ne)
-- Put in lower case so e.g. "Dab" and "dab" will both match.
if arg == false then
class = mw.ustring.lower(class)
return nil
end
end
local dab = getPagetypeFromClass(
local exists = false
class,
if title.exists then -- not an article if it does not exist
args[cfg.dab],
exists = true
cfg.dabAliases,
elseif title.namespace==8 and mw.message.new(title.text):exists() then
cfg.dabDefault
exists = true
)
elseif title.namespace==6 and title.fileExists then
if dab then
ndArgs.mainexists = dabtrue
end
if not exists then
if type(arg) == 'string' then
return arg
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.
-- Get page types for mainspaces pages with an explicit class specified
if not ndArgs.talk then
local function getMainNamespaceClassPageType(title, args)
ndArgs.subjectns = true
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)
-- Add the fallback value. This can also be customised, but it cannot be
if arg == false then -- don't check for this class if it is specifically disallowed
-- disabled.
return nil
local other = args[cfg.other]
end
-- We will ignore true/false/nil results from yesno here, but using it
if cfg.naAliases[class] then
-- anyway for consistency.
if type(arg) == 'string' then
other = yesno(other, other)
return arg
if type(other) == 'string' then
else
ndArgs.other = other
return cfg.naDefault
end
else
return nil
ndArgs.other = cfg.otherDefault
end
-- Allow custom page values.
ndArgs.page = args.page
return nsDetect(ndArgs)
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)
-- The yesno function returns true/false for "yes", "no", etc., and returns
if namespaceArg == true then
-- redirect for other input.
-- Namespace has been explicitly enabled, so return the default for
redirect = yesno(redirect, redirect)
-- this namespace
if redirect == false then
return getExplicitPageType(title)
-- Detect redirects unless they have been explicitly disallowed with
elseif namespaceArg == false then
-- "redirect=no" or similar.
-- Namespace has been explicitly disabled
return
return getDefaultPageType(args)
elseif namespaceArg then
-- This namespaces uses custom text
return namespaceArg
else
return nil
end
end
local pageObject = getPageObject(args.page)
 
-- If we are using subject namespaces elsewhere, do so here as well.
 
if pageObject
-- Get page type not specified or detected by other means
and not yesno(args.talk, true)
local function getOtherPageType(title, args)
and args[cfg.defaultns] ~= cfg.defaultnsAll
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
then
local isInDefaultActiveNamespace = false
pageObject = getPageObject(
local defaultNamespacesKey = args[cfg.defaultns]
pageObject.subjectNsText .. ':' .. pageObject.text
if defaultNamespacesKey == cfg.defaultnsAll then
)
isInDefaultActiveNamespace = true
end
else
-- Allow custom values for redirects.
local defaultNamespaces
if pageObject and pageObject.isRedirect then
if type(redirect)defaultNamespacesKey == 'string'cfg.defaultnsExtended then
defaultNamespaces = cfg.extendedNamespaces
return redirect
elseif defaultNamespacesKey == cfg.defaultnsNone then
defaultNamespaces = {}
else
defaultNamespaces = cfg.defaultNamespaces
return cfg.redirectDefault
end
isInDefaultActiveNamespace = defaultNamespaces[title.namespace]
end
if isInDefaultActiveNamespace then
return getExplicitPageType(title)
else
return getDefaultPageType(args)
end
end
 
function p._main(args)
local title
local redirect = detectRedirects(args)
if redirectargs.page then
title = mw.title.new(args.page)
return redirect
else
title = mw.title.getCurrentTitle()
return getNsDetectValue(args)
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
Retrieved from "https://en.wikipedia.org/wiki/Module:Pagetype"