Mô đun:Pagetype

----------------------------------------------------------------------------------                                                                            ----                                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').getArgslocal yesno = require('Module:Yesno')local nsDetectModule = require('Module:Namespace detect')local nsDetect = nsDetectModule._mainlocal getParamMappings = nsDetectModule.getParamMappingslocal getPageObject = nsDetectModule.getPageObjectlocal 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 retendlocal 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 retendlocal 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	endendlocal 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 = shallowCopy(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		-- 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 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)endlocal 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)		and args[cfg.defaultns] ~= cfg.defaultnsAll	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	endendfunction p._main(args)	local redirect = detectRedirects(args)	if redirect then		return redirect	else		return getNsDetectValue(args)	endendfunction p.main(frame)	local args = getArgs(frame)	return p._main(args)endreturn p