Difference between revisions of "Module:Category handler/sandbox"

From blackwiki
Jump to navigation Jump to search
blackwiki>Mr. Stradivarius
(deal with nocat/blacklist logic at the same time, use "titleObj" rather than "pageObj", and cache things with mw.loadData where we can)
m (35 revisions imported)
 
(32 intermediate revisions by 3 users not shown)
Line 14: Line 14:
 
--------------------------------------------------------------------------------
 
--------------------------------------------------------------------------------
  
local data = mw.loadData('Module:Category handler/data')
+
-- Load required modules
 +
local yesno = require('Module:Yesno')
  
-- Get dependent modules
+
-- Lazily load things we don't always need
local mNamespaceDetect = require('Module:Namespace detect')
+
local mShared, mappings
local yesno = require('Module:Yesno')
 
  
 
local p = {}
 
local p = {}
  
local function needsCategory(titleObj, args)
+
--------------------------------------------------------------------------------
-- This function finds whether we need to return a category or not.
+
-- Helper functions
 +
--------------------------------------------------------------------------------
 +
 
 +
local function trimWhitespace(s, removeBlanks)
 +
if type(s) ~= 'string' then
 +
return s
 +
end
 +
s = s:match('^%s*(.-)%s*$')
 +
if removeBlanks then
 +
if s ~= '' then
 +
return s
 +
else
 +
return nil
 +
end
 +
else
 +
return s
 +
end
 +
end
 +
 
 +
--------------------------------------------------------------------------------
 +
-- CategoryHandler class
 +
--------------------------------------------------------------------------------
 +
 
 +
local CategoryHandler = {}
 +
CategoryHandler.__index = CategoryHandler
 +
 
 +
function CategoryHandler.new(data, args)
 +
local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
 
 
-- Don't categorise if the relevant options are set.
+
-- Set the title object
if yesno(args[data.nocat])
+
do
or yesno(args[data.categories]) == false
+
local pagename = obj:parameter('demopage')
 +
local success, titleObj
 +
if pagename then
 +
success, titleObj = pcall(mw.title.new, pagename)
 +
end
 +
if success and titleObj then
 +
obj.title = titleObj
 +
if titleObj == mw.title.getCurrentTitle() then
 +
obj._usesCurrentTitle = true
 +
end
 +
else
 +
obj.title = mw.title.getCurrentTitle()
 +
obj._usesCurrentTitle = true
 +
end
 +
end
 +
 
 +
-- Set suppression parameter values
 +
for _, key in ipairs{'nocat', 'categories'} do
 +
local value = obj:parameter(key)
 +
value = trimWhitespace(value, true)
 +
obj['_' .. key] = yesno(value)
 +
end
 +
do
 +
local subpage = obj:parameter('subpage')
 +
local category2 = obj:parameter('category2')
 +
if type(subpage) == 'string' then
 +
subpage = mw.ustring.lower(subpage)
 +
end
 +
if type(category2) == 'string' then
 +
subpage = mw.ustring.lower(category2)
 +
end
 +
obj._subpage = trimWhitespace(subpage, true)
 +
obj._category2 = trimWhitespace(category2) -- don't remove blank values
 +
end
 +
return obj
 +
end
 +
 
 +
function CategoryHandler:parameter(key)
 +
local parameterNames = self._data.parameters[key]
 +
local pntype = type(parameterNames)
 +
if pntype == 'string' or pntype == 'number' then
 +
return self._args[parameterNames]
 +
elseif pntype == 'table' then
 +
for _, name in ipairs(parameterNames) do
 +
local value = self._args[name]
 +
if value ~= nil then
 +
return value
 +
end
 +
end
 +
return nil
 +
else
 +
error(string.format(
 +
'invalid config key "%s"',
 +
tostring(key)
 +
), 2)
 +
end
 +
end
 +
 
 +
function CategoryHandler:isSuppressedByArguments()
 +
return
 +
-- See if a category suppression argument has been set.
 +
self._nocat == true
 +
or self._categories == false
 
or (
 
or (
args[data.category2]
+
self._category2
and args[data.category2] ~= data.category2Yes  
+
and self._category2 ~= self._data.category2Yes
and args[data.category2] ~= data.category2Negative
+
and self._category2 ~= self._data.category2Negative
 +
)
 +
 
 +
-- Check whether we are on a subpage, and see if categories are
 +
-- suppressed based on our subpage status.
 +
or self._subpage == self._data.subpageNo and self.title.isSubpage
 +
or self._subpage == self._data.subpageOnly and not self.title.isSubpage
 +
end
 +
 
 +
function CategoryHandler:shouldSkipBlacklistCheck()
 +
-- Check whether the category suppression arguments indicate we
 +
-- should skip the blacklist check.
 +
return self._nocat == false
 +
or self._categories == true
 +
or self._category2 == self._data.category2Yes
 +
end
 +
 
 +
function CategoryHandler:matchesBlacklist()
 +
if self._usesCurrentTitle then
 +
return self._data.currentTitleMatchesBlacklist
 +
else
 +
mShared = mShared or require('Module:Category handler/shared')
 +
return mShared.matchesBlacklist(
 +
self.title.prefixedText,
 +
mw.loadData('Module:Category handler/blacklist')
 
)
 
)
then
 
return false
 
 
end
 
end
 +
end
  
-- If there is no titleObj available, then that either means that we are over
+
function CategoryHandler:isSuppressed()
-- the expensive function limit or that the title specified was invalid. Invalid
+
-- Find if categories are suppressed by either the arguments or by
-- titles will probably only be a problem during testing, so we choose the best
+
-- matching the blacklist.
-- fallback for being over the expensive function limit. The fallback behaviour
+
return self:isSuppressedByArguments()
-- of the old template was to assume the page was not a subpage, so we will do
+
or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
-- the same here.
 
if args[data.subpage] == data.subpageNo and titleObj and titleObj.isSubpage then
 
return false
 
end
 
if args[data.subpage] == data.subpageOnly
 
and (not titleObj or (titleObj and not titleObj.isSubpage))
 
then
 
return false
 
end
 
return true
 
 
end
 
end
  
-- Find whether we need to check the blacklist or not.
+
function CategoryHandler:getNamespaceParameters()
local function needsBlacklistCheck(args)
+
if self._usesCurrentTitle then
if yesno(args[data.nocat]) == false
+
return self._data.currentTitleNamespaceParameters
or yesno(args[data.categories]) == true
 
or args[data.category2] == data.category2Yes
 
then
 
return false
 
 
else
 
else
return true
+
if not mappings then
 +
mShared = mShared or require('Module:Category handler/shared')
 +
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
 +
end
 +
return mShared.getNamespaceParameters(
 +
self.title,
 +
mappings
 +
)
 
end
 
end
 
end
 
end
  
-- Find whether any namespace parameters have been specified.
+
function CategoryHandler:namespaceParametersExist()
-- Mappings is the table of parameter mappings taken from
+
-- Find whether any namespace parameters have been specified.
-- [[Module:Namespace detect]].
+
-- We use the order "all" --> namespace params --> "other" as this is what
local function nsParamsExist(mappings, args)
+
-- the old template did.
if args[data.all] or args[data.other] then
+
if self:parameter('all') then
 
return true
 
return true
 +
end
 +
if not mappings then
 +
mShared = mShared or require('Module:Category handler/shared')
 +
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
 
end
 
end
 
for ns, params in pairs(mappings) do
 
for ns, params in pairs(mappings) do
 
for i, param in ipairs(params) do
 
for i, param in ipairs(params) do
if args[param] then
+
if self._args[param] then
 
return true
 
return true
 
end
 
end
 
end
 
end
 +
end
 +
if self:parameter('other') then
 +
return true
 
end
 
end
 
return false
 
return false
 
end
 
end
  
function p.matchesBlacklist(page, blacklist)
+
function CategoryHandler:getCategories()
-- Wrapper function to maintain backwards compatibility. This is not always
+
local params = self:getNamespaceParameters()
-- needed, so the /shared module is only loaded when required.
+
local nsCategory
return require('Module:Category handler/shared').matchesBlacklist
+
for i, param in ipairs(params) do
end
+
local value = self._args[param]
 
+
if value ~= nil then
-- The main structure of the module. Checks whether we need to categorise,
+
nsCategory = value
-- and then passes the relevant arguments to [[Module:Namespace detect]].
+
break
function p._main(args)
+
end
-- Get the page object and argument mappings from
 
-- [[Module:Namespace detect]], to save us from having to rewrite the
 
-- code.
 
local titleObj = mNamespaceDetect.getPageObject(args[data.demopage])
 
local mappings = mNamespaceDetect.getParamMappings()
 
 
if not needsCategory(titleObj, args)
 
or (needsBlacklistCheck(args) and (
 
args[data.demopage] and p.matchesBlacklist(
 
titleObj.prefixedText,
 
mw.loadData('Module:Category handler/blacklist')
 
)
 
or data.currentTitleMatchesBlacklist
 
))
 
then
 
return nil
 
 
end
 
end
+
if nsCategory ~= nil or self:namespaceParametersExist() then
local ret = {}
+
-- Namespace parameters exist - advanced usage.
if not nsParamsExist(mappings, args) then
+
if nsCategory == nil then
-- No namespace parameters exist; basic usage. Pass args[1] to
+
nsCategory = self:parameter('other')
-- [[Module:Namespace detect]] using the default namespace
 
-- parameters, and return the result.
 
local ndargs = {}
 
for _, ndarg in ipairs(data.defaultNamespaces) do
 
ndargs[ndarg] = args[1]
 
 
end
 
end
ndargs.page = args.page
+
local ret = {self:parameter('all')}
ndargs.demospace = args.demospace
+
local numParam = tonumber(nsCategory)
local ndresult = mNamespaceDetect._main(ndargs)
+
if numParam and numParam >= 1 and math.floor(numParam) == numParam then
if ndresult then
+
-- nsCategory is an integer
ret[#ret + 1] = ndresult
+
ret[#ret + 1] = self._args[numParam]
end
+
else
else
+
ret[#ret + 1] = nsCategory
-- Namespace parameters exist; advanced usage.
 
-- If the all parameter is specified, return it.
 
local all = args.all
 
if type(all) == 'string' then
 
ret[#ret + 1] = all
 
 
end
 
end
+
if #ret < 1 then
-- Get the arguments to pass to [[Module:Namespace detect]].
+
return nil
local ndargs = {}
 
for ns, params in pairs(mappings) do
 
for _, param in ipairs(params) do
 
ndargs[param] = args[param] or args[data.other] or nil
 
end
 
end
 
ndargs.other = args.other
 
ndargs.page = args.page
 
ndargs.demospace = args.demospace
 
 
local data = mNamespaceDetect._main(ndargs)
 
 
-- Work out what to return based on the result of the namespace detect call.
 
local datanum = tonumber(data)
 
if type(datanum) == 'number' then
 
-- "data" is a number, so return that positional parameter.
 
-- Remove non-positive integer values, as only positive integers
 
-- from 1-10 were used with the old template.
 
if datanum > 0 and math.floor(datanum) == datanum then
 
local dataArg = args[datanum]
 
if type(dataArg) == 'string' then
 
ret = ret .. dataArg
 
end
 
end
 
 
else
 
else
-- "data" is not a number, so return it as it is.
+
return table.concat(ret)
if type(data) == 'string' then
 
ret[#ret + 1] = data
 
end
 
 
end
 
end
 +
elseif self._data.defaultNamespaces[self.title.namespace] then
 +
-- Namespace parameters don't exist, simple usage.
 +
return self._args[1]
 
end
 
end
return table.concat(ret)
+
return nil
 +
end
 +
 
 +
--------------------------------------------------------------------------------
 +
-- Exports
 +
--------------------------------------------------------------------------------
 +
 
 +
local p = {}
 +
 
 +
function p._exportClasses()
 +
-- Used for testing purposes.
 +
return {
 +
CategoryHandler = CategoryHandler
 +
}
 
end
 
end
  
function p.main(frame)
+
function p._main(args, data)
-- If called via #invoke, use the args passed into the invoking
+
data = data or mw.loadData('Module:Category handler/data')
-- template, or the args passed to #invoke if any exist. Otherwise
+
local handler = CategoryHandler.new(data, args)
-- assume args are being passed directly in.
+
if handler:isSuppressed() then
local origArgs
+
return nil
if frame == mw.getCurrentFrame() then
 
origArgs = frame:getParent().args
 
for k, v in pairs(frame.args) do
 
origArgs = frame.args
 
break
 
end
 
else
 
origArgs = frame
 
 
end
 
end
 +
return handler:getCategories()
 +
end
  
-- Trim whitespace and remove blank arguments for the following args:
+
function p.main(frame, data)
-- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page".
+
data = data or mw.loadData('Module:Category handler/data')
local args = {}
+
local args = require('Module:Arguments').getArgs(frame, {
for k, v in pairs(origArgs) do
+
wrappers = data.wrappers,
if type(v) == 'string' then
+
valueFunc = function (k, v)
v = mw.text.trim(v) -- Trim whitespace.
+
v = trimWhitespace(v)
end
+
if type(k) == 'number' then
if type(k) == 'number'
+
if v ~= '' then
or k == data.nocat
+
return v
or k == data.categories
+
else
or k == data.subpage
+
return nil
or k == data.page
+
end
then
+
else
if v ~= '' then
+
return v
args[k] = v
 
 
end
 
end
else
 
args[k] = v
 
 
end
 
end
end
+
})
+
return p._main(args, data)
-- Lower-case "nocat", "categories", "category2", and "subpage". These
 
-- parameters are put in lower case whenever they appear in the old
 
-- template, so we can just do it once here and save ourselves some work.
 
local lowercase = {data.nocat, data.categories, data.category2, data.subpage}
 
for _, v in ipairs(lowercase) do
 
local argVal = args[v]
 
if type(argVal) == 'string' then
 
args[v] = mw.ustring.lower(argVal)
 
end
 
end
 
 
return p._main(args)
 
 
end
 
end
  
 
return p
 
return p

Latest revision as of 13:31, 26 September 2020

Documentation for this module may be created at Module:Category handler/sandbox/doc

--------------------------------------------------------------------------------
--                                                                            --
--                              CATEGORY HANDLER                              --
--                                                                            --
--      This module implements the {{category handler}} template in Lua,      --
--      with a few improvements: all namespaces and all namespace aliases     --
--      are supported, and namespace names are detected automatically for     --
--      the local wiki. This module requires [[Module:Namespace detect]]      --
--      and [[Module:Yesno]] to be available on the local wiki. It can be     --
--      configured for different wikis by altering the values in              --
--      [[Module:Category handler/config]], and pages can be blacklisted      --
--      from categorisation by using [[Module:Category handler/blacklist]].   --
--                                                                            --
--------------------------------------------------------------------------------

-- Load required modules
local yesno = require('Module:Yesno')

-- Lazily load things we don't always need
local mShared, mappings

local p = {}

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function trimWhitespace(s, removeBlanks)
	if type(s) ~= 'string' then
		return s
	end
	s = s:match('^%s*(.-)%s*$')
	if removeBlanks then
		if s ~= '' then
			return s
		else
			return nil
		end
	else
		return s
	end
end

--------------------------------------------------------------------------------
-- CategoryHandler class
--------------------------------------------------------------------------------

local CategoryHandler = {}
CategoryHandler.__index = CategoryHandler

function CategoryHandler.new(data, args)
	local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
	
	-- Set the title object
	do
		local pagename = obj:parameter('demopage')
		local success, titleObj
		if pagename then
			success, titleObj = pcall(mw.title.new, pagename)
		end
		if success and titleObj then
			obj.title = titleObj
			if titleObj == mw.title.getCurrentTitle() then
				obj._usesCurrentTitle = true
			end
		else
			obj.title = mw.title.getCurrentTitle()
			obj._usesCurrentTitle = true
		end
	end

	-- Set suppression parameter values
	for _, key in ipairs{'nocat', 'categories'} do
		local value = obj:parameter(key)
		value = trimWhitespace(value, true)
		obj['_' .. key] = yesno(value)
	end
	do
		local subpage = obj:parameter('subpage')
		local category2 = obj:parameter('category2')
		if type(subpage) == 'string' then
			subpage = mw.ustring.lower(subpage)
		end
		if type(category2) == 'string' then
			subpage = mw.ustring.lower(category2)
		end
		obj._subpage = trimWhitespace(subpage, true)
		obj._category2 = trimWhitespace(category2) -- don't remove blank values
	end
	return obj
end

function CategoryHandler:parameter(key)
	local parameterNames = self._data.parameters[key]
	local pntype = type(parameterNames)
	if pntype == 'string' or pntype == 'number' then
		return self._args[parameterNames]
	elseif pntype == 'table' then
		for _, name in ipairs(parameterNames) do
			local value = self._args[name]
			if value ~= nil then
				return value
			end
		end
		return nil
	else
		error(string.format(
			'invalid config key "%s"',
			tostring(key)
		), 2)
	end
end

function CategoryHandler:isSuppressedByArguments()
	return
		-- See if a category suppression argument has been set.
		self._nocat == true
		or self._categories == false
		or (
			self._category2
			and self._category2 ~= self._data.category2Yes
			and self._category2 ~= self._data.category2Negative
		)

		-- Check whether we are on a subpage, and see if categories are
		-- suppressed based on our subpage status.
		or self._subpage == self._data.subpageNo and self.title.isSubpage
		or self._subpage == self._data.subpageOnly and not self.title.isSubpage
end

function CategoryHandler:shouldSkipBlacklistCheck()
	-- Check whether the category suppression arguments indicate we
	-- should skip the blacklist check.
	return self._nocat == false
		or self._categories == true
		or self._category2 == self._data.category2Yes
end

function CategoryHandler:matchesBlacklist()
	if self._usesCurrentTitle then
		return self._data.currentTitleMatchesBlacklist
	else
		mShared = mShared or require('Module:Category handler/shared')
		return mShared.matchesBlacklist(
			self.title.prefixedText,
			mw.loadData('Module:Category handler/blacklist')
		)
	end
end

function CategoryHandler:isSuppressed()
	-- Find if categories are suppressed by either the arguments or by
	-- matching the blacklist.
	return self:isSuppressedByArguments()
		or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end

function CategoryHandler:getNamespaceParameters()
	if self._usesCurrentTitle then
		return self._data.currentTitleNamespaceParameters
	else
		if not mappings then
			mShared = mShared or require('Module:Category handler/shared')
			mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
		end
		return mShared.getNamespaceParameters(
			self.title,
			mappings
		)
	end
end

function CategoryHandler:namespaceParametersExist()
	-- Find whether any namespace parameters have been specified.
	-- We use the order "all" --> namespace params --> "other" as this is what
	-- the old template did.
	if self:parameter('all') then
		return true
	end
	if not mappings then
		mShared = mShared or require('Module:Category handler/shared')
		mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
	end
	for ns, params in pairs(mappings) do
		for i, param in ipairs(params) do
			if self._args[param] then
				return true
			end
		end
	end
	if self:parameter('other') then
		return true
	end
	return false
end

function CategoryHandler:getCategories()
	local params = self:getNamespaceParameters()
	local nsCategory
	for i, param in ipairs(params) do
		local value = self._args[param]
		if value ~= nil then
			nsCategory = value
			break
		end
	end
	if nsCategory ~= nil or self:namespaceParametersExist() then
		-- Namespace parameters exist - advanced usage.
		if nsCategory == nil then
			nsCategory = self:parameter('other')
		end
		local ret = {self:parameter('all')}
		local numParam = tonumber(nsCategory)
		if numParam and numParam >= 1 and math.floor(numParam) == numParam then
			-- nsCategory is an integer
			ret[#ret + 1] = self._args[numParam]
		else
			ret[#ret + 1] = nsCategory
		end
		if #ret < 1 then
			return nil
		else
			return table.concat(ret)
		end
	elseif self._data.defaultNamespaces[self.title.namespace] then
		-- Namespace parameters don't exist, simple usage.
		return self._args[1]
	end
	return nil
end

--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------

local p = {}

function p._exportClasses()
	-- Used for testing purposes.
	return {
		CategoryHandler = CategoryHandler
	}
end

function p._main(args, data)
	data = data or mw.loadData('Module:Category handler/data')
	local handler = CategoryHandler.new(data, args)
	if handler:isSuppressed() then
		return nil
	end
	return handler:getCategories()
end

function p.main(frame, data)
	data = data or mw.loadData('Module:Category handler/data')
	local args = require('Module:Arguments').getArgs(frame, {
		wrappers = data.wrappers,
		valueFunc = function (k, v)
			v = trimWhitespace(v)
			if type(k) == 'number' then
				if v ~= '' then
					return v
				else
					return nil
				end
			else
				return v
			end
		end
	})
	return p._main(args, data)
end

return p