Module:Pagetype: Difference between revisions

Revision as of 19:27, 22 March 2024

Latest revision as of 17:35, 21 May 2024

(3 intermediate revisions by the same user not shown)

Line 6:

-- --

--------------------------------------------------------------------------------

-- Load config.

local cfg = mw.loadData('Module:Pagetype/config')

-- Load required modules.

local getArgs = require('Module:Arguments').getArgs

local yesno = require('Module:Yesno')

local p = {}

Line 31 ⟶ 29:

-- Get argument keys for a title's namespace

local function getNamespaceArgKeys(title, cfg)

local nsInfo = mw.site.namespaces[title.namespace]

local customAliases = cfg.customNamespaceAliases[title.namespace] or {}

Line 47 ⟶ 45:

-- Get the argument for a title's namespace, if it was specified in the args table.

local function getNamespaceArg(title, args, cfg)

if title.isTalkPage then

return lookUpNamespaceArg(args, cfg.talk)

end

for _, key in ipairs(getNamespaceArgKeys(title, cfg)) do

local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))

if arg ~= nil then

Line 61 ⟶ 59:

-- Look up a page type specific to the title's namespace

local function getExplicitPageType(title, cfg)

if title.isTalkPage then

return cfg.talkDefault

Line 70 ⟶ 68:

-- Get a default page type that is not specific to the title's namespace

local function getDefaultPageType(args, cfg)

local other = lookUpNamespaceArg(args, cfg.other)

if type(other) == 'string' then

Line 102 ⟶ 100:

end

local function pluralize(pageType, cfg)

if cfg.irregularPlurals[pageType] then

return cfg.irregularPlurals[pageType]

Line 153 ⟶ 151:

end

-- Find pages which do not exist

-- Gets the pagetype from a class specified from the first positional parameter.

local function getPageTypeFromClassnonExistent(argstitle, class, key, aliasTable, defaultargs)

local arg = lookUpNamespaceArg(args, keycfg.ne)

if arg == false then

-- Don't check for this class if it is specifically disallowed.

return nil

end

local exists = false

if aliasTable[class] then

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 defaultcfg.naDefault

end

end

return nil

end

-- Get page types for mainspaces pages with an explicit class specified

local function getMainNamespaceClassPageType(title, args, cfg)

if title.namespace ~= 0 then

return nil

end

local class = args[1]

if type(class) == 'string' then -- Put in lower case so e.g. "na" and "NA" will both match

-- 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)

return getPageTypeFromClass(

if arg == false then -- don't check for this class if it is specifically disallowed

args,

return nil

class,

end

cfg.na,

if cfg.naAliases,[class] then

if type(arg) == 'string' then

cfg.naDefault

return arg

)

else

return cfg.naDefault

end

else

return nil

end

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

Line 207 ⟶ 213:

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.

local function isInDefaultActiveNamespace(title, args,= cfg)false

local defaultNamespacesKey = args[cfg.defaultns]

if defaultNamespacesKey == cfg.defaultnsAll then

isInDefaultActiveNamespace = true

return true

end

local defaultNamespaces

if defaultNamespacesKey == cfg.defaultnsExtended then

defaultNamespaces = cfg.extendedNamespaces

elseif defaultNamespacesKey == cfg.defaultnsNone then

defaultNamespaces = {}

else

defaultNamespaceslocal = cfg.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 defaultNamespaces[title.namespace] or false

return getExplicitPageType(title)

end

-- 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

return getDefaultPageType(args, cfg)

end

end

local function getPageTypep._main(title, args, cfg)

return (

detectRedirects(title, args, cfg)

or parseContent(title, args, {

{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},

{'setindex', cfg.sia, cfg.siaDefault, true},

{'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

if args.page then

title = mw.title.new(args.page)

if not title then

return nil

end

else

title = mw.title.getCurrentTitle()

end

if title and not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll then

title = title.subjectPageTitle

if shouldUseSubjectTitle(args, cfg) then

return title.subjectPageTitle

else

return title

end

local pageType = detectRedirects(title, args)

end

or nonExistent(title, args)

or parseContent(title, args, {

function p._main(args)

{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},

local title = getTitle(args, cfg)

{'setindex', cfg.sia, cfg.siaDefault, true},

local pageType = getPageType(title, args, cfg)

{'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, cfg)

end

if yesno(args.caps, false) then

Line 284 ⟶ 270:

function p.main(frame)

local args = require('Module:Arguments').getArgs(frame)

return p._main(args)

end