Modul:Pagetype: Perbedaan antara revisi

Loncat ke navigasi Loncat ke pencarian

Modul:Pagetype (sunting)

Revisi per 22 September 2023 18.59

1.129 bita dihapus ,  1 tahun yang lalu
←Membuat halaman berisi '-------------------------------------------------------------------------------- -- -- -- PAGETYPE -- -- -- -- This is a meta-module intended to replace {{pagetype}} and similar -- -- templates. It automatically detects namespaces, and al...'
dw>Mr. Stradivarius
(switch back to using Module:Pagetype/config, as it has now been updated)
 
(←Membuat halaman berisi '-------------------------------------------------------------------------------- -- -- -- PAGETYPE -- -- -- -- This is a meta-module intended to replace {{pagetype}} and similar -- -- templates. It automatically detects namespaces, and al...')
Baris 16: Baris 16:
local getArgs = require('Module:Arguments').getArgs
local getArgs = require('Module:Arguments').getArgs
local yesno = require('Module:Yesno')
local yesno = require('Module:Yesno')
local mDisambiguation = require('Module:Disambiguation')
local nsDetectModule = require('Module:Namespace detect')
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 arg = args[key]
local ret = {}
-- 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
ret = cfg.pagetypes[namespace]
end
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
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
else
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
-- Get the default values.
local function getDefaultPageType(args, cfg)
local ndArgs = {}
local other = lookUpNamespaceArg(args, cfg.other)
local defaultns = args[cfg.defaultns]
if type(other) == 'string' then
if defaultns == cfg.defaultnsAll 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


local function pluralize(pageType, cfg)
function p._main(args)
if cfg.irregularPlurals[pageType] then
local redirect = detectRedirects(args)
return cfg.irregularPlurals[pageType]
if redirect then
return redirect
else
else
return pageType .. cfg.plural -- often 's'
return getNsDetectValue(args)
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
end
return pageType
end
end


Diperoleh dari "https://wiki.javasatu.com/wiki/Istimewa:MobileDiff/2275"

Menu navigasi