Wikipedia

Module:Pagetype: Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
use a configuration table for easy porting to other wikis
m fix for files and interface messages which do exist but are not stored locally
 
(29 intermediate revisions by 6 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 --
-- --
-- Thiswikis isby achanging meta-modulethe intendedvalues toin replacethe {{pagetype}} and similar templates[[Module:Pagetype/config]]. 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 configuration --
-- Load tableconfig.
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]
-- Language-specific parameter names can be set here. --
-- 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',
['file'] = '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
 
-- The value used ifGet the moduleargument matchesfor a title's namespace, thatif hasit not beenwas specified in the args table.
local function getNamespaceArg(title, args)
cfg.fallback = 'page'
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)
-- End configuration data --
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
-- Load required modules.
local function getDefaultPageType(args)
local yesno = require('Module:Yesno')
local other = lookUpNamespaceArg(args, cfg.other)
local nsDetectModule = require('Module:Namespace detect')
if type(other) == 'string' then
local nsDetect = nsDetectModule._main
return other
local getPageObject = nsDetectModule.getPageObject
else
return cfg.otherDefault
end
end
 
local function detectRedirects(title, args)
-- Move some of the cfg tables to local variables.
local pagetypesredirect = lookUpNamespaceArg(args, cfg.pagetypesredirect)
if redirect == false then
local defaultNamespaces = cfg.defaultNamespaces
-- Don't detect redirects if they have been specifically disallowed.
return nil
end
 
-- Allow custom values for redirects.
local p = {}
if not title.isRedirect then
return nil
elseif type(redirect) == 'string' then
return redirect
else
return cfg.redirectDefault
end
end
 
local function getNamespacePagetypecapitalize(namespace, vpageType)
local first = mw.ustring.sub(pageType, 1, 1)
local ret = yesno(v, v) -- Returns true/false for "yes", "no", etc., and returns v for other input.
local rest = mw.ustring.sub(pageType, 2)
if ret and type(ret) ~= 'string' then
return mw.ustring.upper(first) .. rest
ret = pagetypes[namespace]
end
 
local function pluralize(pageType)
if cfg.irregularPlurals[pageType] then
return cfg.irregularPlurals[pageType]
else
return pageType .. cfg.plural -- often 's'
end
return ret
end
 
local function getNsDetectValueparseContent(title, args, optionsList)
if title.namespace==828 and title.subpageText~='doc' -- don't detect modules
local ndArgs = {}
or not title.exists -- can't check unless page exists
-- Get the default values.
then
for _, namespace in ipairs(defaultNamespaces) do
return nil
ndArgs[namespace] = pagetypes[namespace]
end
local content = title:getContent()
-- Add custom values passed in from the arguments. These overwrite the defaults.
if content == nil then
for namespace in pairs(pagetypes) do
return nil
local ndArg = getNamespacePagetype(namespace, args[namespace])
end
if ndArg == false then
local templates -- lazily evaluated
-- If any arguments are false, convert them to nil to protect against breakage by future changes
for _, options in next, optionsList do
-- to [[Module:Namespace detect]].
local list, parameter, default, articleOnly = unpack(options, 1, 4)
ndArgs[namespace] = nil
if not articleOnly or title.namespace==0 then -- only check for templates if we should...
elseif ndArg then
local out = lookUpNamespaceArg(args, parameter)
ndArgs[namespace] = ndArg
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
-- If there is no talk value specified, use the corresponding subject namespace for talk pages.
 
if not ndArgs.talk then
-- Find pages which do not exist
ndArgs.subjectns = true
local function nonExistent(title, args)
local arg = lookUpNamespaceArg(args, cfg.ne)
if arg == false then
return nil
end
local exists = false
if title.exists then -- not an article if it does not exist
exists = true
elseif title.namespace==8 and mw.message.new(title.text):exists() then
exists = true
elseif title.namespace==6 and title.fileExists then
exists = true
end
if not exists then
if type(arg) == 'string' then
return arg
else
return cfg.naDefault
end
end
-- Add the fallback value.
ndArgs.other = cfg.fallback
-- Allow custom page values.
ndArgs.page = args.page
return nsDetect(ndArgs)
end
 
-- Get page types for mainspaces pages with an explicit class specified
local function detectRedirects(args)
local function getMainNamespaceClassPageType(title, args)
local redirect = args.redirect
local class = args[1]
redirect = yesno(redirect, redirect) -- Returns true/false for "yes", "no", etc., and returns redirect for other input.
if type(class) == 'string' then -- Put in lower case so e.g. "na" and "NA" will both match
if redirect == false then return end
class = mw.ustring.lower(class)
local pageObject = getPageObject(args.page)
-- If we are using subject namespaces elsewhere, do so here as well.
if pageObject and not yesno(args.talk, true) then
pageObject = getPageObject(pageObject.subjectNsText .. ':' .. pageObject.text)
end
local arg = lookUpNamespaceArg(args, cfg.na)
-- Allow custom values for redirects.
if arg == false then -- don't check for this class if it is specifically disallowed
if pageObject and pageObject.isRedirect then
return nil
if type(redirect) == 'string' then
end
return redirect
if cfg.naAliases[class] then
if type(arg) == 'string' then
return arg
else
return 'redirect'cfg.naDefault
end
else
return nil
end
end
 
-- Get page type specified by an explicit namespace argument.
function p._main(args)
local redirectfunction = detectRedirectsgetNamespaceArgPageType(title, args)
local namespaceArg = getNamespaceArg(title, args)
if redirect then
if namespaceArg == true then
return redirect
-- 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 getNsDetectValue(args)nil
end
end
 
 
function p.main(frame)
-- Get page type not specified or detected by other means
-- If called via #invoke, use the args passed into the invoking template, or the args passed to #invoke if any exist.
local function getOtherPageType(title, args)
-- Otherwise assume args are being passed directly in from the debug console or from another Lua module.
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
local origArgs
local isInDefaultActiveNamespace = false
if frame == mw.getCurrentFrame() then
local defaultNamespacesKey = args[cfg.defaultns]
origArgs = frame:getParent().args
if defaultNamespacesKey == cfg.defaultnsAll then
for k, v in pairs(frame.args) do
isInDefaultActiveNamespace = true
origArgs = frame.args
else
break
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)
origArgs = frame
end
end
-- Trim whitespace and remove blank arguments.
 
local args = {}
function p._main(args)
for k, v in pairs(origArgs) do
local title
if type(v) == 'string' then
if args.page then
v = mw.text.trim(v)
title = mw.title.new(args.page)
end
else
if v ~= '' then
title = mw.title.getCurrentTitle()
args[k] = v
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
 
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"