Module:Pagetype - Revision history

Buburka Rinderbuy: 1 revision imported

2024-03-27T07:20:34Z

1 revision imported

← Older revision

Revision as of 03:20, 27 March 2024

Template:Track listing>MSGJ: performance improvements and bug fix by User:Aidan9382

2024-03-22T19:27:12Z

performance improvements and bug fix by User:Aidan9382

← Older revision		Revision as of 15:27, 22 March 2024
Line 110:		Line 110:
	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
Line 225:		Line 237:
	return (		return (
	detectRedirects(title, args, cfg)		detectRedirects(title, args, cfg)
	or parseContent(title, args, 'softredirect', cfg.softRedirect, cfg.softRedirectDefault)		or parseContent(title, args, {
	~~or parseContent(title, args,~~ 'setindex', cfg.sia, cfg.siaDefault, true)		{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},
	~~or parseContent(title, args,~~ 'disambiguation', cfg.dab, cfg.dabDefault, true)		{'setindex', cfg.sia, cfg.siaDefault, true},
			{'disambiguation', cfg.dab, cfg.dabDefault, true},
			})
	or getMainNamespaceClassPageType(title, args, cfg)		or getMainNamespaceClassPageType(title, args, cfg)
	or getNamespaceArgPageType(title, args, cfg)		or getNamespaceArgPageType(title, args, cfg)

Buburka Rinderbuy: 1 revision imported

2024-02-10T14:55:44Z

1 revision imported

← Older revision

Revision as of 10:55, 10 February 2024

Template:Tooltip>Plastikspork: Add exist check per discussion

2024-02-03T14:03:49Z

Add exist check per discussion

← Older revision		Revision as of 10:03, 3 February 2024
Line 1:		Line 1:
	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
	-- --		-- --
	~~-- PAGETYPE --~~		-- This meta-module which automatically detects namespaces, and allows --
	~~-- --~~		-- for a great deal of customisation. It can easily be ported to other --
	-- 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]]. --		-- wikis by changing the values in the [[Module:Pagetype/config]]. --
	-- --		-- --
Line 16:		Line 13:
	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 p = {}		local p = {}

Line 51:		Line 46:
	end		end

	-- Get the argument for a title's namespace, if it was specified in the args		-- Get the argument for a title's namespace, if it was specified in the args table.
	-- table.
	local function getNamespaceArg(title, args, cfg)		local function getNamespaceArg(title, args, cfg)
	if title.isTalkPage then		if title.isTalkPage then
Line 102:		Line 96:
	end		end

	local function ~~detectDisambiguationPages~~(title, args, ~~cfg~~)		local function capitalize(pageType)
	if title.namespace ~= 0 ~~then~~		local first = mw.ustring.sub(pageType, 1, 1)
	-- ~~Only~~ detect ~~disambiguation pages in mainspace~~		local rest = mw.ustring.sub(pageType, 2)
			return mw.ustring.upper(first) .. rest
			end

			local function pluralize(pageType, cfg)
			if cfg.irregularPlurals[pageType] then
			return cfg.irregularPlurals[pageType]
			else
			return pageType .. cfg.plural -- often 's'
			end
			end

			local function parseContent(title, args, list, parameter, default, articleOnly)
			if articleOnly and title.namespace~=0 -- only detect in mainspace
			or title.namespace==828 and title.subpageText~='doc' -- don't detect modules
			or not title.exists -- can't check unless page exists
			then
	return nil		return nil
	end		end
			local templates = mw.loadData('Module:Pagetype/' .. list)
	local ~~dab~~ = ~~lookUpNamespaceArg~~(~~args, cfg.dab~~)		local content = title:getContent()
	if ~~dab~~ == ~~false~~ then		if content == nil then
	~~-- Don't detect disambiguation pages if explicitly disallowed~~
	return nil		return nil
	end		end
			content = require('Module:Wikitext Parsing').PrepareText(content) -- disregard templates which do not have any affect
	~~if not mDisambiguation~~.~~isDisambiguation~~(~~title:getContent~~()) then		local templateNames = {}
			local templateFound = false
			for template in string.gmatch(content, "{{%s([^\|}]-)%s[\|}]") do
			if templates[capitalize(template)] then
			templateFound = true
			break
			end
			end
			local out = lookUpNamespaceArg(args, parameter)
			if not templateFound then
	return nil		return nil
	elseif type(~~dab~~) == 'string' then		elseif type(out)=='string' then
	return ~~dab~~		return out
	else		else
	return ~~cfg.dabDefault~~		return default
	end		end
	end		end

	-- Gets the pagetype from a class specified from the first positional		-- Gets the pagetype from a class specified from the first positional parameter.
	-- parameter.
	local function getPageTypeFromClass(args, class, key, aliasTable, default)		local function getPageTypeFromClass(args, class, key, aliasTable, default)
	local arg = lookUpNamespaceArg(args, key)		local arg = lookUpNamespaceArg(args, key)
Line 178:		Line 195:
	end		end

	-- Whether the title is in the set of default active namespaces which are		-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
	-- looked up in cfg.pagetypes.
	local function isInDefaultActiveNamespace(title, args, cfg)		local function isInDefaultActiveNamespace(title, args, cfg)
	local defaultNamespacesKey = args[cfg.defaultns]		local defaultNamespacesKey = args[cfg.defaultns]
Line 209:		Line 225:
	return (		return (
	detectRedirects(title, args, cfg)		detectRedirects(title, args, cfg)
	or ~~detectDisambiguationPages~~(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 getMainNamespaceClassPageType(title, args, cfg)
	or getNamespaceArgPageType(title, args, cfg)		or getNamespaceArgPageType(title, args, cfg)
Line 237:		Line 255:
	return title		return title
	end		end
	~~end~~

	~~local function pluralize(pageType, cfg)~~
	~~if cfg.irregularPlurals[pageType] then~~
	~~return cfg.irregularPlurals[pageType]~~
	~~else~~
	~~return pageType .. cfg.plural -- often 's'~~
	~~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		end

Buburka Rinderbuy: 1 revision imported

2024-01-29T09:25:55Z

1 revision imported

← Older revision

Revision as of 05:25, 29 January 2024

Module:Pagetype>Mr. Stradivarius: switch back to using Module:Pagetype/config, as it has now been updated

2023-08-28T13:37:34Z

switch back to using Module:Pagetype/config, as it has now been updated

New page

--------------------------------------------------------------------------------
-- --
-- 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 mDisambiguation = require('Module:Disambiguation')

local p = {}

-- Look up a namespace argument in the args table.
local function lookUpNamespaceArg(args, key)
local arg = args[key]
-- Convert "yes", "1" etc. to true, "no", "0" etc. to false, and leave
-- other values the same.
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

-- 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 {}
local keys = {}
if nsInfo.name ~= '' then
table.insert(keys, nsInfo.name)
end
if nsInfo.canonicalName ~= nsInfo.name and nsInfo.canonicalName ~= '' then
table.insert(keys, nsInfo.canonicalName)
end
appendMultiple(keys, nsInfo.aliases)
appendMultiple(keys, customAliases)
return keys
end

-- 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
return arg
end
end
return nil
end

-- Look up a page type specific to the title's namespace
local function getExplicitPageType(title, cfg)
if title.isTalkPage then
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
local function getDefaultPageType(args, cfg)
local other = lookUpNamespaceArg(args, cfg.other)
if type(other) == 'string' then
return other
else
return cfg.otherDefault
end
end

local function detectRedirects(title, args)
local redirect = lookUpNamespaceArg(args, cfg.redirect)
if redirect == false then
-- Don't detect redirects if they have been specifically disallowed.
return nil
end

-- Allow custom values for redirects.
if not title.isRedirect then
return nil
elseif type(redirect) == 'string' then
return redirect
else
return cfg.redirectDefault
end
end

local function detectDisambiguationPages(title, args, cfg)
if title.namespace ~= 0 then
-- Only detect disambiguation pages in mainspace
return nil
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
return default
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.
class = mw.ustring.lower(class)
end
return getPageTypeFromClass(
args,
class,
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
return nil
end
end

-- 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 defaultNamespacesKey = args[cfg.defaultns]
if defaultNamespacesKey == cfg.defaultnsAll then
return true
end

local defaultNamespaces
if defaultNamespacesKey == cfg.defaultnsExtended then
defaultNamespaces = cfg.extendedNamespaces
elseif defaultNamespacesKey == cfg.defaultnsNone then
defaultNamespaces = {}
else
defaultNamespaces = cfg.defaultNamespaces
end
return defaultNamespaces[title.namespace] or false
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 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
else
title = mw.title.getCurrentTitle()
end

if shouldUseSubjectTitle(args, cfg) then
return title.subjectPageTitle
else
return title
end
end

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

function p.main(frame)
local args = getArgs(frame)
return p._main(args)
end

return p