Module:Pagetype: Difference between revisions
Jump to navigation
Jump to search
m (1 revision) |
m (1 revision) |
||
(3 intermediate revisions by the same user not shown) | |||
Line 1: | Line 1: | ||
-------------------------------------------------------------------------------- | |||
-- | -- -- | ||
-- | -- PAGETYPE -- | ||
-- | -- -- | ||
-- This is a meta-module intended to replace {{pagetype}} and similar | -- This is a meta-module intended to replace {{pagetype}} and similar -- | ||
-- automatically detects namespaces, and allows for a | -- templates. It automatically detects namespaces, and allows for a -- | ||
-- It can easily be ported to other wikis by changing the values in the | -- 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. | -- Load required modules. | ||
local getArgs = require('Module:Arguments').getArgs | |||
local yesno = require('Module:Yesno') | local yesno = require('Module:Yesno') | ||
local nsDetectModule = require('Module:Namespace detect') | local nsDetectModule = require('Module:Namespace detect') | ||
Line 101: | Line 22: | ||
local p = {} | local p = {} | ||
local function shallowCopy(t) | |||
-- Makes a shallow copy of a table. | |||
local ret = {} | |||
for k, v in pairs(t) do | |||
ret[k] = v | |||
end | |||
return ret | |||
end | |||
local function checkPagetypeInput(namespace, val) | local function checkPagetypeInput(namespace, val) | ||
-- Checks to see whether we need the default value for the given namespace, and if so gets it from the pagetypes table. | -- Checks to see whether we need the default value for the given namespace, | ||
-- and if so gets it from the pagetypes table. | |||
-- The yesno function returns true/false for "yes", "no", etc., and returns | |||
-- val for other input. | |||
local ret = yesno(val, val) | |||
if ret and type(ret) ~= 'string' then | if ret and type(ret) ~= 'string' then | ||
ret = cfg.pagetypes[namespace] | ret = cfg.pagetypes[namespace] | ||
Line 112: | Line 45: | ||
local function getPagetypeFromClass(class, param, aliasTable, default) | local function getPagetypeFromClass(class, param, aliasTable, default) | ||
-- Gets the pagetype from a class specified from the first positional parameter. | -- Gets the pagetype from a class specified from the first positional | ||
-- parameter. | |||
param = yesno(param, param) | param = yesno(param, param) | ||
if param ~= false then -- | if param ~= false then -- No check if specifically disallowed. | ||
for _, alias in ipairs(aliasTable) do | for _, alias in ipairs(aliasTable) do | ||
if class == alias then | if class == alias then | ||
Line 128: | Line 62: | ||
local function getNsDetectValue(args) | local function getNsDetectValue(args) | ||
-- Builds the arguments to pass to [[Module:Namespace detect]] and returns the result. | -- Builds the arguments to pass to [[Module:Namespace detect]] and returns | ||
-- | -- the result. | ||
-- Get the default values. | |||
local ndArgs = {} | local ndArgs = {} | ||
local defaultns = args[cfg.defaultns] | local defaultns = args[cfg.defaultns] | ||
if defaultns == cfg.defaultnsAll then | if defaultns == cfg.defaultnsAll then | ||
ndArgs = cfg.pagetypes | ndArgs = shallowCopy(cfg.pagetypes) | ||
else | else | ||
local defaultnsArray | local defaultnsArray | ||
Line 147: | Line 83: | ||
end | end | ||
end | end | ||
-- Add custom values passed in from the arguments. These overwrite the | |||
-- The possible argument names are fetched from | --[[ | ||
-- Although we accept namespace aliases as parameters, we only pass the local namespace name as a parameter to | -- Add custom values passed in from the arguments. These overwrite the | ||
-- This means that the "image" parameter can overwrite defaults for the File: namespace, which wouldn't work if we passed the parameters through separately. | -- defaults. The possible argument names are fetched from | ||
-- Module:Namespace detect automatically in case new namespaces are | |||
-- 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() | local mappings = getParamMappings() | ||
for ns, paramAliases in pairs(mappings) do | for ns, paramAliases in pairs(mappings) do | ||
local paramName = paramAliases[1] | -- 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 paramAlias = paramAliases[i] | ||
local ndArg = checkPagetypeInput(paramAlias, args[paramAlias]) | local ndArg = checkPagetypeInput(paramAlias, args[paramAlias]) | ||
if ndArg == false then | if ndArg == false then | ||
-- If any arguments are false, convert them to nil to protect against breakage by future changes to [[Module:Namespace detect]]. | -- If any arguments are false, convert them to nil to protect | ||
-- against breakage by future changes to | |||
-- [[Module:Namespace detect]]. | |||
ndArgs[paramName] = nil | ndArgs[paramName] = nil | ||
elseif ndArg then | elseif ndArg then | ||
Line 172: | Line 122: | ||
class = mw.ustring.lower(class) | class = mw.ustring.lower(class) | ||
end | end | ||
local dab = getPagetypeFromClass(class, args[cfg.dab], cfg.dabAliases, cfg.dabDefault) | local dab = getPagetypeFromClass( | ||
class, | |||
args[cfg.dab], | |||
cfg.dabAliases, | |||
cfg.dabDefault | |||
) | |||
if dab then | if dab then | ||
ndArgs.main = dab | ndArgs.main = dab | ||
else | else | ||
local na = getPagetypeFromClass(class, args[cfg.na], cfg.naAliases, cfg.naDefault) | local na = getPagetypeFromClass( | ||
class, | |||
args[cfg.na], | |||
cfg.naAliases, | |||
cfg.naDefault | |||
) | |||
if na then | if na then | ||
ndArgs.main = na | ndArgs.main = na | ||
Line 182: | Line 142: | ||
end | end | ||
end | end | ||
-- If there is no talk value specified, use the corresponding subject namespace for talk pages. | -- If there is no talk value specified, use the corresponding subject | ||
-- namespace for talk pages. | |||
if not ndArgs.talk then | if not ndArgs.talk then | ||
ndArgs.subjectns = true | ndArgs.subjectns = true | ||
end | end | ||
-- Add the fallback value. This can also be customised, but it cannot be disabled. | -- Add the fallback value. This can also be customised, but it cannot be | ||
-- disabled. | |||
local other = args[cfg.other] | local other = args[cfg.other] | ||
-- We will ignore true/false/nil results from yesno here, but using it | |||
-- anyway for consistency. | |||
other = yesno(other, other) | |||
if type(other) == 'string' then | if type(other) == 'string' then | ||
ndArgs.other = other | ndArgs.other = other | ||
Line 201: | Line 165: | ||
local function detectRedirects(args) | local function detectRedirects(args) | ||
local redirect = args[cfg.redirect] | local redirect = args[cfg.redirect] | ||
-- The yesno function returns true/false for "yes", "no", etc., and returns | |||
if redirect == false then | -- redirect for other input. | ||
redirect = yesno(redirect, redirect) | |||
if redirect == false then | |||
-- Detect redirects unless they have been explicitly disallowed with | |||
-- "redirect=no" or similar. | |||
return | |||
end | |||
local pageObject = getPageObject(args.page) | local pageObject = getPageObject(args.page) | ||
-- If we are using subject namespaces elsewhere, do so here as well. | -- If we are using subject namespaces elsewhere, do so here as well. | ||
if pageObject and not yesno(args.talk, true) then | if pageObject | ||
pageObject = getPageObject(pageObject.subjectNsText .. ':' .. pageObject.text) | and not yesno(args.talk, true) | ||
and args[cfg.defaultns] ~= cfg.defaultnsAll | |||
then | |||
pageObject = getPageObject( | |||
pageObject.subjectNsText .. ':' .. pageObject.text | |||
) | |||
end | end | ||
-- Allow custom values for redirects. | -- Allow custom values for redirects. | ||
Line 228: | Line 203: | ||
function p.main(frame) | function p.main(frame) | ||
local args = getArgs(frame) | |||
return p._main(args) | return p._main(args) | ||
end | end | ||
return p | return p |