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

From blackwiki
Jump to navigation Jump to search
blackwiki>Mr. Stradivarius
(start converting this to an OOP framework)
m (35 revisions imported)
 
(31 intermediate revisions by 3 users not shown)
Line 15: Line 15:
  
 
-- Load required modules
 
-- Load required modules
local class = require('Module:Middleclass').class
 
local mNamespaceDetect = require('Module:Namespace detect')
 
 
local yesno = require('Module:Yesno')
 
local yesno = require('Module:Yesno')
 +
 +
-- Lazily load things we don't always need
 +
local mShared, mappings
  
 
local p = {}
 
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
  
 
--------------------------------------------------------------------------------
 
--------------------------------------------------------------------------------
Line 25: Line 46:
 
--------------------------------------------------------------------------------
 
--------------------------------------------------------------------------------
  
local CategoryHandler = class('CategoryHandler')
+
local CategoryHandler = {}
 +
CategoryHandler.__index = CategoryHandler
  
function CategoryHandler:initialize(data, args)
+
function CategoryHandler.new(data, args)
self._data = data
+
local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
self._args = args
 
 
 
 
-- Set the title object
 
-- Set the title object
 
do
 
do
local pagename = self:parameter('demopage')
+
local pagename = obj:parameter('demopage')
local success, titleObj = pcall(mw.title.new, pagename)
+
local success, titleObj
 +
if pagename then
 +
success, titleObj = pcall(mw.title.new, pagename)
 +
end
 
if success and titleObj then
 
if success and titleObj then
self.title = titleObj
+
obj.title = titleObj
 +
if titleObj == mw.title.getCurrentTitle() then
 +
obj._usesCurrentTitle = true
 +
end
 
else
 
else
self.title = mw.title.getCurrentTitle()
+
obj.title = mw.title.getCurrentTitle()
self._usesCurrentTitle = true
+
obj._usesCurrentTitle = true
 
end
 
end
 
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
 
end
  
Line 61: Line 108:
 
'invalid config key "%s"',
 
'invalid config key "%s"',
 
tostring(key)
 
tostring(key)
))
+
), 2)
 
end
 
end
 
end
 
end
  
 
function CategoryHandler:isSuppressedByArguments()
 
function CategoryHandler:isSuppressedByArguments()
-- First, see if a category suppression argument has been set.
+
return
if yesno(self:parameter('nocat')) then
+
-- See if a category suppression argument has been set.
return true
+
self._nocat == true
elseif yesno(self:parameter('categories')) == false then
+
or self._categories == false
return true
+
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
 
else
local category2 = self:parameter('category2')
+
mShared = mShared or require('Module:Category handler/shared')
if category2
+
return mShared.matchesBlacklist(
and category2 ~= self._data.category2Yes
+
self.title.prefixedText,
and category2 ~= self._data.category2Negative
+
mw.loadData('Module:Category handler/blacklist')
then
+
)
return true
 
end
 
 
end
 
end
 +
end
  
-- Next, check whether we are on a subpage, and see if categories are
+
function CategoryHandler:isSuppressed()
-- suppressed based on our subpage status.
+
-- Find if categories are suppressed by either the arguments or by
local subpage = self:parameter('subpage')
+
-- matching the blacklist.
if subpage == self._data.subpageNo and self.title.isSubpage then
+
return self:isSuppressedByArguments()
return true
+
or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end
 
if subpage == self._data.subpageOnly and not self.title.isSubpage then
 
return true
 
end
 
 
return false
 
 
end
 
end
  
function CategoryHandler:shouldCheckBlacklist()
+
function CategoryHandler:getNamespaceParameters()
if yesno(self:parameter('nocat')) == false
+
if self._usesCurrentTitle then
or yesno(self:parameter('categories')) == true
+
return self._data.currentTitleNamespaceParameters
or self:parameter('category2') == self._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)
+
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(page, blacklist)
+
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]].
 
function p._main(args)
 
-- 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
 
 
local ret = {}
 
if not nsParamsExist(mappings, args) then
 
-- No namespace parameters exist; basic usage. Pass args[1] to
 
-- [[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
 
ndargs.page = args.page
 
ndargs.demospace = args.demospace
 
local ndresult = mNamespaceDetect._main(ndargs)
 
if ndresult then
 
ret[#ret + 1] = ndresult
 
end
 
else
 
-- 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
 
 
-- Get the arguments to pass to [[Module:Namespace detect]].
 
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
 
-- "data" is not a number, so return it as it is.
 
if type(data) == 'string' then
 
ret[#ret + 1] = data
 
end
 
end
 
end
 
return table.concat(ret)
 
end
 
 
 
function p.main(frame)
 
-- If called via #invoke, use the args passed into the invoking
 
-- template, or the args passed to #invoke if any exist. Otherwise
 
-- assume args are being passed directly in.
 
local origArgs
 
if frame == mw.getCurrentFrame() then
 
origArgs = frame:getParent().args
 
for k, v in pairs(frame.args) do
 
origArgs = frame.args
 
 
break
 
break
 
end
 
end
else
 
origArgs = frame
 
 
end
 
end
 
+
if nsCategory ~= nil or self:namespaceParametersExist() then
-- Trim whitespace and remove blank arguments for the following args:
+
-- Namespace parameters exist - advanced usage.
-- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page".
+
if nsCategory == nil then
local args = {}
+
nsCategory = self:parameter('other')
for k, v in pairs(origArgs) do
 
if type(v) == 'string' then
 
v = mw.text.trim(v) -- Trim whitespace.
 
 
end
 
end
if type(k) == 'number'
+
local ret = {self:parameter('all')}
or k == data.nocat
+
local numParam = tonumber(nsCategory)
or k == data.categories
+
if numParam and numParam >= 1 and math.floor(numParam) == numParam then
or k == data.subpage
+
-- nsCategory is an integer
or k == data.page
+
ret[#ret + 1] = self._args[numParam]
then
 
if v ~= '' then
 
args[k] = v
 
end
 
 
else
 
else
args[k] = v
+
ret[#ret + 1] = nsCategory
 
end
 
end
end
+
if #ret < 1 then
+
return nil
-- Lower-case "nocat", "categories", "category2", and "subpage". These
+
else
-- parameters are put in lower case whenever they appear in the old
+
return table.concat(ret)
-- 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
 +
elseif self._data.defaultNamespaces[self.title.namespace] then
 +
-- Namespace parameters don't exist, simple usage.
 +
return self._args[1]
 
end
 
end
+
return nil
return p._main(args)
 
 
end
 
end
  
Line 262: Line 234:
 
--------------------------------------------------------------------------------
 
--------------------------------------------------------------------------------
  
-- local p = {}
+
local p = {}
  
 
function p._exportClasses()
 
function p._exportClasses()
Line 271: Line 243:
 
end
 
end
  
--[[
+
function p._main(args, data)
function p._main(args)
+
data = data or mw.loadData('Module:Category handler/data')
-- Load config data
+
local handler = CategoryHandler.new(data, args)
local data = mw.loadData('Module:Category handler/data')
+
if handler:isSuppressed() then
 +
return nil
 +
end
 +
return handler:getCategories()
 
end
 
end
  
function p.main(frame)
+
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
 
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