Difference between revisions of "Module:Pagetype/sandbox"
Jump to navigation
Jump to search
blackwiki>Mr. Stradivarius (try loading config with mw.loadData) |
blackwiki>Mr. Stradivarius (beautification fixes) |
||
| 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. | -- Load config. | ||
| Line 24: | Line 24: | ||
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 33: | Line 36: | ||
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 49: | Line 53: | ||
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] | ||
| Line 68: | Line 74: | ||
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] | + | 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 93: | Line 110: | ||
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 103: | Line 130: | ||
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 122: | Line 153: | ||
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 and not yesno(args.talk, true) then | ||
| − | pageObject = getPageObject(pageObject.subjectNsText .. ':' .. pageObject.text) | + | pageObject = getPageObject( |
| + | pageObject.subjectNsText .. ':' .. pageObject.text | ||
| + | ) | ||
end | end | ||
-- Allow custom values for redirects. | -- Allow custom values for redirects. | ||
Revision as of 04:31, 4 April 2014
Documentation for this module may be created at Module:Pagetype/sandbox/doc
--------------------------------------------------------------------------------
-- --
-- PAGETYPE --
-- --
-- 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 = {}
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.
-- 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
ret = cfg.pagetypes[namespace]
end
return ret
end
local function getPagetypeFromClass(class, param, aliasTable, default)
-- Gets the pagetype from a class specified from the first positional
-- parameter.
param = yesno(param, param)
if param ~= false then -- No check if specifically disallowed.
for _, alias in ipairs(aliasTable) do
if class == alias then
if type(param) == 'string' then
return param
else
return default
end
end
end
end
end
local function getNsDetectValue(args)
-- Builds the arguments to pass to [[Module:Namespace detect]] and returns
-- the result.
-- Get the default values.
local ndArgs = {}
local defaultns = args[cfg.defaultns]
if defaultns == cfg.defaultnsAll then
ndArgs = cfg.pagetypes
else
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
--[[
-- Add custom values passed in from the arguments. These overwrite the
-- 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()
for ns, paramAliases in pairs(mappings) do
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
-- Check for disambiguation-class and N/A-class pages in mainspace.
if ndArgs.main then
local class = args[1]
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
local na = getPagetypeFromClass(
class,
args[cfg.na],
cfg.naAliases,
cfg.naDefault
)
if na then
ndArgs.main = na
end
end
end
-- If there is no talk value specified, use the corresponding subject
-- namespace for talk pages.
if not ndArgs.talk then
ndArgs.subjectns = true
end
-- Add the fallback value. This can also be customised, but it cannot be
-- disabled.
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
ndArgs.other = other
else
ndArgs.other = cfg.otherDefault
end
-- Allow custom page values.
ndArgs.page = args.page
return nsDetect(ndArgs)
end
local function detectRedirects(args)
local redirect = args[cfg.redirect]
-- The yesno function returns true/false for "yes", "no", etc., and returns
-- 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)
-- 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
-- Allow custom values for redirects.
if pageObject and pageObject.isRedirect then
if type(redirect) == 'string' then
return redirect
else
return cfg.redirectDefault
end
end
end
function p._main(args)
local redirect = detectRedirects(args)
if redirect then
return redirect
else
return getNsDetectValue(args)
end
end
function p.main(frame)
local args = getArgs(frame)
return p._main(args)
end
return p