IMNI WIKI

Module:Pagetype: Difference between revisions

Module Discussion

Module:Pagetype (view source)

Revision as of 19:09, 9 June 2024

356 bytes added ,  10 months ago
m
1 revision imported
(username removed)
m (1 revision imported)
m (1 revision imported)
 
(One intermediate revision by one other user not shown)
Line 6: Line 6:
--                                                                            --
--                                                                            --
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Load config.
-- Load config.
local cfg = mw.loadData('Module:Pagetype/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 p = {}
local p = {}
Line 31: Line 29:


-- Get argument keys for a title's namespace
-- Get argument keys for a title's namespace
local function getNamespaceArgKeys(title, cfg)
local function getNamespaceArgKeys(title)
local nsInfo = mw.site.namespaces[title.namespace]
local nsInfo = mw.site.namespaces[title.namespace]
local customAliases = cfg.customNamespaceAliases[title.namespace] or {}
local customAliases = cfg.customNamespaceAliases[title.namespace] or {}
Line 47: Line 45:


-- Get the argument for a title's namespace, if it was specified in the args table.
-- Get the argument for a title's namespace, if it was specified in the args table.
local function getNamespaceArg(title, args, cfg)
local function getNamespaceArg(title, args)
if title.isTalkPage then
if title.isTalkPage then
return lookUpNamespaceArg(args, cfg.talk)
return lookUpNamespaceArg(args, cfg.talk)
end
end
for _, key in ipairs(getNamespaceArgKeys(title, cfg)) do
for _, key in ipairs(getNamespaceArgKeys(title)) do
local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))
local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))
if arg ~= nil then
if arg ~= nil then
Line 61: Line 59:


-- Look up a page type specific to the title's namespace
-- Look up a page type specific to the title's namespace
local function getExplicitPageType(title, cfg)
local function getExplicitPageType(title)
if title.isTalkPage then
if title.isTalkPage then
return cfg.talkDefault
return cfg.talkDefault
Line 70: Line 68:


-- Get a default page type that is not specific to the title's namespace
-- Get a default page type that is not specific to the title's namespace
local function getDefaultPageType(args, cfg)
local function getDefaultPageType(args)
local other = lookUpNamespaceArg(args, cfg.other)
local other = lookUpNamespaceArg(args, cfg.other)
if type(other) == 'string' then
if type(other) == 'string' then
Line 102: Line 100:
end
end


local function pluralize(pageType, cfg)
local function pluralize(pageType)
if cfg.irregularPlurals[pageType] then
if cfg.irregularPlurals[pageType] then
return cfg.irregularPlurals[pageType]
return cfg.irregularPlurals[pageType]
Line 110: Line 108:
end
end


local function parseContent(title, args, list, parameter, default, articleOnly)
local function parseContent(title, args, optionsList)
if articleOnly and title.namespace~=0 -- only detect in mainspace
if title.namespace==828 and title.subpageText~='doc' -- don't detect modules
or title.namespace==828 and title.subpageText~='doc' -- don't detect modules
or not title.exists -- can't check unless page exists
or not title.exists -- can't check unless page exists
then
then
return nil
return nil
end
end
local templates = mw.loadData('Module:Pagetype/' .. list)
local content = title:getContent()
local content = title:getContent()
if content == nil then
if content == nil then
return nil
return nil
end
end
content = require('Module:Wikitext Parsing').PrepareText(content) -- disregard templates which do not have any affect  
local templates -- lazily evaluated
local templateNames = {}
for _, options in next, optionsList do
local templateFound = false
local list, parameter, default, articleOnly = unpack(options, 1, 4)
for template in string.gmatch(content, "{{%s*([^|}]-)%s*[|}]") do
if not articleOnly or title.namespace==0 then -- only check for templates if we should...
if templates[capitalize(template)] then
local out = lookUpNamespaceArg(args, parameter)
templateFound = true
if type(out) == "string" or (out ~= false and default) then -- ...and if we actually have anything to say about them
break
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
local out = lookUpNamespaceArg(args, parameter)
if not templateFound then
return nil
elseif type(out)=='string' then
return out
else
return default
end
end
end
end


-- Gets the pagetype from a class specified from the first positional parameter.
-- Find pages which do not exist
local function getPageTypeFromClass(args, class, key, aliasTable, default)
local function nonExistent(title, args)
local arg = lookUpNamespaceArg(args, key)
local arg = lookUpNamespaceArg(args, cfg.ne)
if arg == false then
if arg == false then
-- Don't check for this class if it is specifically disallowed.
return nil
return nil
end
end
if aliasTable[class] then
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
if type(arg) == 'string' then
return arg
return arg
else
else
return default
return cfg.naDefault
end
end
end
end
return nil
end
end


-- Get page types for mainspaces pages with an explicit class specified
-- Get page types for mainspaces pages with an explicit class specified
local function getMainNamespaceClassPageType(title, args, cfg)
local function getMainNamespaceClassPageType(title, args)
if title.namespace ~= 0 then
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)
if arg == false then -- don't check for this class if it is specifically disallowed
return nil
return nil
end
end
local class = args[1]
if cfg.naAliases[class] then
if type(class) == 'string' then
if type(arg) == 'string' then
-- Put in lower case so e.g. "na" and "NA" will both match.
return arg
class = mw.ustring.lower(class)
else
return cfg.naDefault
end
else
return nil
end
end
return getPageTypeFromClass(
args,
class,
cfg.na,
cfg.naAliases,
cfg.naDefault
)
end
end


-- Get page type specified by an explicit namespace argument.
-- Get page type specified by an explicit namespace argument.
local function getNamespaceArgPageType(title, args, cfg)
local function getNamespaceArgPageType(title, args)
local namespaceArg = getNamespaceArg(title, args, cfg)
local namespaceArg = getNamespaceArg(title, args)
if namespaceArg == true then
if namespaceArg == true then
-- Namespace has been explicitly enabled, so return the default for
-- Namespace has been explicitly enabled, so return the default for
-- this namespace
-- this namespace
return getExplicitPageType(title, cfg)
return getExplicitPageType(title)
elseif namespaceArg == false then
elseif namespaceArg == false then
-- Namespace has been explicitly disabled
-- Namespace has been explicitly disabled
return getDefaultPageType(args, cfg)
return getDefaultPageType(args)
elseif namespaceArg then
elseif namespaceArg then
-- This namespaces uses custom text
-- This namespaces uses custom text
Line 195: Line 213:
end
end


-- Get page type not specified or detected by other means
local function getOtherPageType(title, args)
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
local function isInDefaultActiveNamespace(title, args, cfg)
local isInDefaultActiveNamespace = false
local defaultNamespacesKey = args[cfg.defaultns]
local defaultNamespacesKey = args[cfg.defaultns]
if defaultNamespacesKey == cfg.defaultnsAll then
if defaultNamespacesKey == cfg.defaultnsAll then
return true
isInDefaultActiveNamespace = true
end
 
local defaultNamespaces
if defaultNamespacesKey == cfg.defaultnsExtended then
defaultNamespaces = cfg.extendedNamespaces
elseif defaultNamespacesKey == cfg.defaultnsNone then
defaultNamespaces = {}
else
else
defaultNamespaces = cfg.defaultNamespaces
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
end
return defaultNamespaces[title.namespace] or false
if isInDefaultActiveNamespace then
end
return getExplicitPageType(title)
 
-- Get page type not specified or detected by other means
local function getOtherPageType(title, args, cfg)
if isInDefaultActiveNamespace(title, args, cfg) then
return getExplicitPageType(title, cfg)
else
else
return getDefaultPageType(args, cfg)
return getDefaultPageType(args)
end
end
end
end


local function getPageType(title, args, cfg)
function p._main(args)
return (
detectRedirects(title, args, cfg)
or parseContent(title, args, 'softredirect', cfg.softRedirect, cfg.softRedirectDefault)
or parseContent(title, args, 'setindex', cfg.sia, cfg.siaDefault, true)
or parseContent(title, args, 'disambiguation', cfg.dab, cfg.dabDefault, true)
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
local title
if args.page then
if args.page then
title = mw.title.new(args.page)
title = mw.title.new(args.page)
if not title then
return nil
end
else
else
title = mw.title.getCurrentTitle()
title = mw.title.getCurrentTitle()
end
end
 
if title and not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll then
if shouldUseSubjectTitle(args, cfg) then
title = title.subjectPageTitle
return title.subjectPageTitle
else
return title
end
end
end
local pageType = detectRedirects(title, args)
 
or nonExistent(title, args)
function p._main(args)
or parseContent(title, args, {
local title = getTitle(args, cfg)
{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},
local pageType = getPageType(title, args, cfg)
{'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
if yesno(args.plural, false) then
pageType = pluralize(pageType, cfg)
pageType = pluralize(pageType)
end
end
if yesno(args.caps, false) then
if yesno(args.caps, false) then
Line 270: Line 270:


function p.main(frame)
function p.main(frame)
local args = getArgs(frame)
local args = require('Module:Arguments').getArgs(frame)
return p._main(args)
return p._main(args)
end
end


return p
return p
Retrieved from "https://wiki.innocentmichael.org/Special:MobileDiff/124...1489"