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)
blackwiki>Mr. Stradivarius
(start converting this to an OOP framework)
Line 14: Line 14:
 
--------------------------------------------------------------------------------
 
--------------------------------------------------------------------------------
  
local data = mw.loadData('Module:Category handler/data')
+
-- Load required modules
 
+
local class = require('Module:Middleclass').class
-- Get dependent modules
 
 
local mNamespaceDetect = require('Module:Namespace detect')
 
local mNamespaceDetect = require('Module:Namespace detect')
 
local yesno = require('Module:Yesno')
 
local yesno = require('Module:Yesno')
Line 22: Line 21:
 
local p = {}
 
local p = {}
  
local function needsCategory(titleObj, args)
+
--------------------------------------------------------------------------------
-- This function finds whether we need to return a category or not.
+
-- CategoryHandler class
 +
--------------------------------------------------------------------------------
 +
 
 +
local CategoryHandler = class('CategoryHandler')
 +
 
 +
function CategoryHandler:initialize(data, args)
 +
self._data = data
 +
self._args = args
 
 
-- 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 = self:parameter('demopage')
or (
+
local success, titleObj = pcall(mw.title.new, pagename)
args[data.category2]
+
if success and titleObj then
and args[data.category2] ~= data.category2Yes  
+
self.title = titleObj
and args[data.category2] ~= data.category2Negative
+
else
)
+
self.title = mw.title.getCurrentTitle()
then
+
self._usesCurrentTitle = true
return false
+
end
 +
end
 +
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)
 +
))
 +
end
 +
end
 +
 
 +
function CategoryHandler:isSuppressedByArguments()
 +
-- First, see if a category suppression argument has been set.
 +
if yesno(self:parameter('nocat')) then
 +
return true
 +
elseif yesno(self:parameter('categories')) == false then
 +
return true
 +
else
 +
local category2 = self:parameter('category2')
 +
if category2
 +
and category2 ~= self._data.category2Yes
 +
and category2 ~= self._data.category2Negative
 +
then
 +
return true
 +
end
 
end
 
end
  
-- If there is no titleObj available, then that either means that we are over
+
-- Next, check whether we are on a subpage, and see if categories are
-- the expensive function limit or that the title specified was invalid. Invalid
+
-- suppressed based on our subpage status.
-- titles will probably only be a problem during testing, so we choose the best
+
local subpage = self:parameter('subpage')
-- fallback for being over the expensive function limit. The fallback behaviour
+
if subpage == self._data.subpageNo and self.title.isSubpage then
-- of the old template was to assume the page was not a subpage, so we will do
+
return true
-- the same here.
 
if args[data.subpage] == data.subpageNo and titleObj and titleObj.isSubpage then
 
return false
 
 
end
 
end
if args[data.subpage] == data.subpageOnly  
+
if subpage == self._data.subpageOnly and not self.title.isSubpage then
and (not titleObj or (titleObj and not titleObj.isSubpage))
+
return true
then
 
return false
 
 
end
 
end
return true
+
 +
return false
 
end
 
end
  
-- Find whether we need to check the blacklist or not.
+
function CategoryHandler:shouldCheckBlacklist()
local function needsBlacklistCheck(args)
+
if yesno(self:parameter('nocat')) == false
if yesno(args[data.nocat]) == false
+
or yesno(self:parameter('categories')) == true
or yesno(args[data.categories]) == true
+
or self:parameter('category2') == self._data.category2Yes
or args[data.category2] == data.category2Yes
 
 
then
 
then
 
return false
 
return false
Line 83: Line 122:
 
end
 
end
  
function p.matchesBlacklist(page, blacklist)
+
function p.matchesBlacklist(page)
 
-- Wrapper function to maintain backwards compatibility. This is not always
 
-- Wrapper function to maintain backwards compatibility. This is not always
 
-- needed, so the /shared module is only loaded when required.
 
-- needed, so the /shared module is only loaded when required.
return require('Module:Category handler/shared').matchesBlacklist
+
return require('Module:Category handler/shared').matchesBlacklist(page, blacklist)
 
end
 
end
  
Line 99: Line 138:
 
 
 
if not needsCategory(titleObj, args)
 
if not needsCategory(titleObj, args)
or (needsBlacklistCheck(args) and (
+
or (
 +
needsBlacklistCheck(args) and (
 
args[data.demopage] and p.matchesBlacklist(
 
args[data.demopage] and p.matchesBlacklist(
 
titleObj.prefixedText,
 
titleObj.prefixedText,
Line 217: Line 257:
 
return p._main(args)
 
return p._main(args)
 
end
 
end
 +
 +
--------------------------------------------------------------------------------
 +
-- Exports
 +
--------------------------------------------------------------------------------
 +
 +
-- local p = {}
 +
 +
function p._exportClasses()
 +
-- Used for testing purposes.
 +
return {
 +
CategoryHandler = CategoryHandler
 +
}
 +
end
 +
 +
--[[
 +
function p._main(args)
 +
-- Load config data
 +
local data = mw.loadData('Module:Category handler/data')
 +
end
 +
 +
function p.main(frame)
 +
end
 +
--]]
  
 
return p
 
return p

Revision as of 07:51, 7 July 2014

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 class = require('Module:Middleclass').class
local mNamespaceDetect = require('Module:Namespace detect')
local yesno = require('Module:Yesno')

local p = {}

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

local CategoryHandler = class('CategoryHandler')

function CategoryHandler:initialize(data, args)
	self._data = data
	self._args = args
	
	-- Set the title object
	do
		local pagename = self:parameter('demopage')
		local success, titleObj = pcall(mw.title.new, pagename)
		if success and titleObj then
			self.title = titleObj
		else
			self.title = mw.title.getCurrentTitle()
			self._usesCurrentTitle = true
		end
	end
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)
		))
	end
end

function CategoryHandler:isSuppressedByArguments()
	-- First, see if a category suppression argument has been set.
	if yesno(self:parameter('nocat')) then
		return true
	elseif yesno(self:parameter('categories')) == false then
		return true
	else
		local category2 = self:parameter('category2')
		if category2
			and category2 ~= self._data.category2Yes
			and category2 ~= self._data.category2Negative
		then
			return true
		end
	end

	-- Next, check whether we are on a subpage, and see if categories are
	-- suppressed based on our subpage status.
	local subpage = self:parameter('subpage')
	if subpage == self._data.subpageNo and self.title.isSubpage then
		return true
	end
	if subpage == self._data.subpageOnly and not self.title.isSubpage then
		return true
	end
	
	return false
end

function CategoryHandler:shouldCheckBlacklist()
	if yesno(self:parameter('nocat')) == false
		or yesno(self:parameter('categories')) == true
		or self:parameter('category2') == self._data.category2Yes
	then
		return false
	else
		return true
	end
end

-- Find whether any namespace parameters have been specified.
-- Mappings is the table of parameter mappings taken from
-- [[Module:Namespace detect]].
local function nsParamsExist(mappings, args)
	if args[data.all] or args[data.other] then
		return true
	end
	for ns, params in pairs(mappings) do
		for i, param in ipairs(params) do
			if args[param] then
				return true
			end
		end
	end
	return false
end

function p.matchesBlacklist(page)
	-- Wrapper function to maintain backwards compatibility. This is not always
	-- needed, so the /shared module is only loaded when required.
	return require('Module:Category handler/shared').matchesBlacklist(page, blacklist)
end

-- The main structure of the module. Checks whether we need to categorise,
-- 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
		end
	else
		origArgs = frame
	end

	-- Trim whitespace and remove blank arguments for the following args:
	-- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page".
	local args = {}
	for k, v in pairs(origArgs) do
		if type(v) == 'string' then
			v = mw.text.trim(v) -- Trim whitespace.
		end
		if type(k) == 'number'
			or k == data.nocat
			or k == data.categories
			or k == data.subpage
			or k == data.page
		then
			if v ~= '' then
				args[k] = v
			end
		else
			args[k] = v
		end
	end
	
	-- 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

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

-- local p = {}

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

--[[
function p._main(args)
	-- Load config data
	local data = mw.loadData('Module:Category handler/data')
end

function p.main(frame)
end
--]]

return p