Module:Protection banner: Difference between revisions

From TEPwiki, Urth's Encyclopedia
Jump to navigation Jump to search
Content added Content deleted
(move the parameter functions to the top level of the blurb class and add a new one)
(add some more blurb parameter functions)
Line 47: Line 47:
self._expiry = args.expiry or 'indef'
self._expiry = args.expiry or 'indef'
self._section = args.section
self._section = args.section
self._protectionDate = args.date
self._username = args.user
end
end


Line 67: Line 69:
function ProtectionStatus:getSection()
function ProtectionStatus:getSection()
return self._section
return self._section
end

function ProtectionStatus:getProtectionDate()
return self._protectionDate
end

function ProtectionStatus:getUsername()
return self._username
end
end


Line 167: Line 177:


parameterFuncs[9] = function ()
parameterFuncs[9] = function ()
return self:_makeDisputeLinkParameter() -- A link to the page history or the move log
-- A link to the page history or the move log
return self:_makeDisputeLinkParameter()
end
end


Line 187: Line 198:


parameterFuncs[14] = function ()
parameterFuncs[14] = function ()
return self:_makeSubjectPageLinksParameter() -- Adds links to edit requests and the talk page if we are on a subject page
-- Adds links to edit requests and the talk page if we are on a
-- subject page
return self:_makeSubjectPageLinksParameter()
end
end


Line 259: Line 272:
function Blurb:_makeProtectionDateParameter()
function Blurb:_makeProtectionDateParameter()
-- parameter $5
-- parameter $5
local protectionDate = self._protectionStatusObj:getProtectionDate()
if self._protectionDate then
if protectionDate then
local lang = mw.language.getContentLanguage()
local lang = mw.language.getContentLanguage()
local success, date = pcall(
local success, date = pcall(
Line 265: Line 279:
lang,
lang,
'j F Y',
'j F Y',
protectionDate
self._protectionDate
)
)
if success and date then
if success and date then
Line 271: Line 285:
end
end
end
end
end

function Blurb:_makeVandalTemplateParameter()
local mVandalM = require('Module:Vandal-m')
local username = self._protectionStatusObj:getUsername()
username = username or self._titleObj.baseText
return mVandalM.luaMain{username}
end
end



Revision as of 02:40, 16 June 2014

Documentation for this module may be created at Module:Protection banner/doc

-- This module implements {{pp-meta}} and its daughter templates such as
-- {{pp-dispute}}, {{pp-vandalism}} and {{pp-sock}}.

-- Initialise necessary modules.
require('Module:No globals')
local class = require('Module:Middleclass').class
local mArguments = require('Module:Arguments')
local mFileLink = require('Module:File link')
local mProtectionLevel = require('Module:Effective protection level')
local yesno = require('Module:Yesno')

--------------------------------------------------------------------------------
-- ProtectionStatus class
--------------------------------------------------------------------------------

local ProtectionStatus = class('ProtectionStatus')

function ProtectionStatus:initialize(args, titleObj)
	-- Set action
	do
		local actions = {
			create = true,
			edit = true,
			move = true,
			autoreview = true
		}
		if args.action and actions[args.action] then
			self._action = args.action
		else
			self._action = 'edit'
		end
	end

	-- Set level
	do
		local level = mProtectionLevel._main(self._action, titleObj)
		if level == 'accountcreator' then
			-- Lump titleblacklisted pages in with template-protected pages,
			-- since templateeditors can do both.
			level = 'templateeditor'
		end
		self._level = level or '*'
	end

	-- Set other params
	self._reason = args.reason
	self._expiry = args.expiry or 'indef'
	self._section = args.section
	self._protectionDate = args.date
	self._username = args.user
end

function ProtectionStatus:getAction()
	return self._action
end

function ProtectionStatus:getLevel()
	return self._level
end

function ProtectionStatus:getReason()
	return self._reason
end

function ProtectionStatus:getExpiry()
	return self._expiry
end

function ProtectionStatus:getSection()
	return self._section
end

function ProtectionStatus:getProtectionDate()
	return self._protectionDate
end

function ProtectionStatus:getUsername()
	return self._username
end

--------------------------------------------------------------------------------
-- Config class
--------------------------------------------------------------------------------

local Config = class('Config')

function Config:initialize()
	self._cfg = mw.loadData('Module:Protection banner/config')
end

function Config:getBannerConfig(protectionStatusObj)
	local cfg = self._cfg
	local action = protectionStatusObj:getAction()
	local reason = protectionStatusObj:getReason()
	if cfg.banners[action][reason] then
		return cfg.banners[action][reason]
	else
		return cfg.defaultBanners[action]
	end
end

function Config:getConfigTable(key)
	local blacklist = {
		banners = true,
		defaultBanners = true
	}
	if not blacklist[key] then
		return self._cfg[key]
	else
		return nil
	end
end

function Config:getMessage(key)
	return self._cfg.msg[key]
end

--------------------------------------------------------------------------------
-- Blurb class
--------------------------------------------------------------------------------

local Blurb = class('Blurb')

function Blurb:initialize(configObj, protectionStatusObj, titleObj)
	self._configObj = configObj
	self._protectionStatusObj = protectionStatusObj
	self._bannerConfig = configObj:getBannerConfig(protectionStatusObj)
	self._titleObj = titleObj
end

function Blurb:_substituteParameters(msg)
	if not self._params then
		local params, parameterFuncs = {}, {}
		setmetatable(params, {
			__index = function (t, k)
				local param
				if parameterFuncs[k] then
					param = parameterFuncs[k]()
				end
				param = param or ''
				params[k] = param
				return param
			end
		})
	
		parameterFuncs[1] = function ()
			return self:_makeIntroParameter()
		end
		
		parameterFuncs[2] = function ()
			return self:_makeUntilParameter()
		end
		
		parameterFuncs[3] = function ()
			return self:_makeDisputesParameter()
		end
	
		parameterFuncs[4] = function ()
			return self:_makePagetypeParameter()
		end
	
		parameterFuncs[5] = function ()
			return self:_makeProtectionDateParameter()
		end

		parameterFuncs[6] = function ()
			return self:_makeVandalTemplateParameter()
		end

		parameterFuncs[7] = function ()
			return self:_makeProtectionLevelParameter()
		end

		parameterFuncs[8] = function ()
			return self:_makeExpiryParameter()
		end

		parameterFuncs[9] = function ()
			-- A link to the page history or the move log
			return self:_makeDisputeLinkParameter()
		end

		parameterFuncs[10] = function ()
			return self:_makeProtectionLogParameter()
		end

		parameterFuncs[11] = function ()
			return self:_makeTalkLinkParameter()
		end

		parameterFuncs[12] = function ()
			return self:_makeEditRequestParameter()
		end

		parameterFuncs[13] = function ()
			return self:_makeRequestUnprotectionParameter()
		end

		parameterFuncs[14] = function ()
			-- Adds links to edit requests and the talk page if we are on a
			-- subject page
			return self:_makeSubjectPageLinksParameter()
		end

		parameterFuncs[15] = function ()
			return self:_makeDeletionDiscussionParameter()
		end

		parameterFuncs[16] = function ()
			return self:_makeDeletionLogParameter()
		end
		
		self._params = params
	end
	return mw.message.newRawMessage(msg):params(self._params):plain()
end

function Blurb:_makeIntroParameter()
	-- parameter $1
	local key
	local action = self._protectionStatusObj:getAction()
	local level = self._protectionStatusObj:getLevel()
	if action == 'edit' and level == 'autoconfirmed' then
		key = 'reason-text-semi'
	elseif action == 'move' then
		key = 'reason-text-move'
	elseif action == 'create' then
		key = 'reason-text-create'
	else
		key = 'reason-text-default'
	end
	local msg = self._configObj:getMessage(key)
	return self:_substituteParameters(msg)
end

function Blurb:_makeUntilParameter()
	-- parameter $2
	-- "until" or "or until" depending on the expiry
	local expiry = self._protectionStatusObj:getExpiry()
	if expiry then
		return 'or until'
	else
		return 'until'
	end
end

function Blurb:_makeDisputesParameter()
	-- parameter $3
	-- "disputes", with or without a section link
	local section = self._protectionStatusObj:getSection()
	local disputes = self.configObj:getMessage('dispute-section-link-display')
	if section then
		return string.format(
			'[[%s:%s#%s|%s]]',
			mw.site.namespaces[self._titleObj.namespace].talk.name,
			self._titleObj.text,
			section,
			disputes
		)
	else
		return disputes
	end
end

function Blurb:_makePagetypeParameter()
	-- parameter $4
	local pagetypes = self._configObj:getConfigTable('pagetypeNamespaces')
	local namespace = self._titleObj:getNamespace()
	return pagetypes[namespace] or pagetypes.default or 'page'
end

function Blurb:_makeProtectionDateParameter()
	-- parameter $5
	local protectionDate = self._protectionStatusObj:getProtectionDate()
	if protectionDate then
		local lang = mw.language.getContentLanguage()
		local success, date = pcall(
			lang.formatDate,
			lang,
			'j F Y',
			protectionDate
		)
		if success and date then
			return date
		end
	end
end

function Blurb:_makeVandalTemplateParameter()
	local mVandalM = require('Module:Vandal-m')
	local username = self._protectionStatusObj:getUsername()
	username = username or self._titleObj.baseText
	return mVandalM.luaMain{username}
end

--------------------------------------------------------------------------------
-- Image class
--------------------------------------------------------------------------------

local Image = class('Image')

function Image:initialize(configObj, protectionStatusObj, titleObj)
	self._configObj = configObj
	self._protectionStatusObj = protectionStatusObj
	self._titleObj = titleObj
end

function Image:setFilename(filename)
	if filename then
		self._filename = filename
	else
		local images, action, level, reason, namespace
		do
			local configObj = self._configObj
			local protectionStatusObj = self._protectionStatusObj
			local titleObj = self._titleObj
			images = configObj:getConfigTable('images')
			action = protectionStatusObj:getAction()
			level = protectionStatusObj:getLevel()
			reason = protectionStatusObj:getReason()
			namespace = titleObj:getNamespace()
		end

		local image
		if reason == 'office' or reason == 'reset' then
			image = images.office
		elseif namespace == 10 or namespace == 828 then
			-- We are in the template or module namespaces.
			if level == 'templateeditor' then
				image = images.template
			elseif level == 'sysop' then
				image = images.indef
			end
		elseif action == 'create' then
			image = images.create
		elseif action == 'move'
			and (
				level == 'templateeditor'
				or level == 'sysop'
			)
		then
			image = images.move
		elseif action == 'edit' then
			if level == 'sysop' then
				image = images.full
			elseif level == 'autoconfirmed' then
				image = images.semi
			end
		elseif action == 'autoreview' then
			if level == 'autoconfirmed' then
				image = images.pc1
			elseif level == 'reviewer' then
				image = images.pc2
			end
		end
		self._filename = image
	end
end

function Image:setWidth(width)
	self._width = width
end

function Image:setAlt(alt)
	self._alt = alt
end

function Image:setLink(link)
	self._link = link
end

function Image:setCaption(caption)
	self._caption = caption
end

function Image:export()
	return mFileLink.new(self._filename or 'Transparent.gif')
		:width(self._width or 20)
		:alt(self._alt)
		:link(self._link)
		:caption(self._caption)
		:render()
end

--------------------------------------------------------------------------------
-- BannerTemplate class
--------------------------------------------------------------------------------

local BannerTemplate = class('BannerTemplate')

function BannerTemplate:initialize()
end

function BannerTemplate:render()
end

--------------------------------------------------------------------------------
-- Banner class
--------------------------------------------------------------------------------

local Banner = BannerTemplate:subclass('Banner')

--------------------------------------------------------------------------------
-- Padlock class
--------------------------------------------------------------------------------

local Padlock = BannerTemplate:subclass('Padlock')

--------------------------------------------------------------------------------
-- Category class
--------------------------------------------------------------------------------

local Category = class('Category')

function Category:initialize()
end

function Category:setName(name)
	self._name = name
end

function Category:export()
	if self._categoryName then
		return string.format(
			'[[%s:%s]]',
			mw.site.namespaces[14].name,
			self._categoryName
		)
	else
		return ''
	end
end

--------------------------------------------------------------------------------
-- ProtectionCategory class
--------------------------------------------------------------------------------

local ProtectionCategory = Category:subclass('ProtectionCategory')

function ProtectionCategory:setName(
		name,
		configObj,
		protectionStatusObj,
		namespace
	)
	--[[
	-- Sets the protection category. If a category name is not provided, this
	-- method gets a category name from the module config, given a combination
	-- of the protection type, the protection level, the namespace number, the
	-- reason for protection, and the expiry date.
	--]]
	
	-- If a name was provided, use that.
	if name then
		Category.setName(self, name)
	end
	
	-- Get the namespace category key from the namespace number.
	local nskey
	do
		local categoryNamespaces = configObj:getConfigTable('categoryNamespaces')
		if not namespace or type(namespace) ~= 'number' then
			nskey = nil
		else
			nskey = categoryNamespaces[ns]
			if not nskey and ns % 2 == 1 then
					nskey = 'talk'
			end
		end
	end
 
	--[[
	-- Define the properties table. Each property is a table containing the
	-- canonical order that the property is tested in, the position the
	-- property has in the category key strings, and the property value itself.
	--]]
	local properties = {
		expiry = {order = 1, keypos = 5, val = protectionStatusObj:getExpiry()},
		namespace = {order = 2, keypos = 3, val = nskey},
		reason = {order = 3, keypos = 4, val = protectionStatusObj:getReason()},
		level = {order = 4, keypos = 2, val = protectionStatusObj:getLevel()},
		action = {order = 5, keypos = 1, val = protectionStatusObj:getAction()}
	}
 
	--[[
	-- Apply the category order configuration, if any. The configuration value
	-- will be a property string, e.g. 'reason', 'namespace', etc. The property
	-- corresponding to that string is tested last (i.e. it is the most
	-- important, because it keeps its specified value the longest) and the
	-- other properties are tested in the canonical order. If no configuration
	-- value is specified then the canonical order is used.
	--]]
	local configOrder = {}
	do
		local bannerConfig = configObj:getBannerConfig(protectionStatusObj)
		local categoryOrder = bannerConfig.categoryOrder
		for propertiesKey, t in pairs(properties) do
			configOrder[t.order] = t
		end
		if categoryOrder then
			local property = properties[categoryOrder]
			if not property then
				local msg = '"'
					.. categoryOrder
					.. '" is not a valid value of cfg.reasons.'
					.. reason
					.. '.categoryOrder'
				error(msg)
			end
			table.insert(configOrder, table.remove(configOrder, property.order))
		end
	end
 
	--[[
	-- Define the attempt order. Properties with no value defined are moved
	-- to the end, where they will later be given the value "all". This is
	-- to cut down on the number of table lookups in the cats table, which
	-- grows exponentially with the number of properties with valid values.
	-- We keep track of the number of active properties with the noActive
	-- parameter.
	--]]
	local noActive, attemptOrder
	do
		local active, inactive = {}, {}
		for i, t in ipairs(configOrder) do
			if t.val then
				active[#active + 1] = t
			else
				inactive[#inactive + 1] = t
			end
		end
		noActive = #active
		attemptOrder = active
		for i, t in ipairs(inactive) do
			attemptOrder[#attemptOrder + 1] = t
		end
	end
 
	--[[
	-- Check increasingly generic key combinations until we find a match.
	-- If a specific category exists for the combination of properties
	-- we are given, that match will be found first. If not, we keep
	-- trying different key combinations until we match using the key
	-- "all-all-all-all-all".
	--
	-- To generate the keys, we index the property subtables using a
	-- binary matrix with indexes i and j. j is only calculated up to
	-- the number of active properties. For example, if there were three
	-- active properties, the matrix would look like this, with 0
	-- corresponding to the string "all", and 1 corresponding to the
	-- val field in the property table:
	-- 
	--   j 1  2  3
	-- i  
	-- 1   1  1  1
	-- 2   0  1  1
	-- 3   1  0  1
	-- 4   0  0  1
	-- 5   1  1  0
	-- 6   0  1  0
	-- 7   1  0  0
	-- 8   0  0  0
	-- 
	-- Values of j higher than the number of active properties are set
	-- to the string "all".
	--
	-- A key for the category table is constructed for each value of i.
	-- The correct position of the value in the key is determined by the
	-- pos field in the property table.
	--]]
	local cats = configObj:getConfigTable('categories')
	local cat
	for i = 1, 2^noActive do
		local key = {}
		for j, t in ipairs(attemptOrder) do
			if j > noActive then
				key[t.keypos] = 'all'
			else
				local quotient = i / 2 ^ (j - 1)
				quotient = math.ceil(quotient)
				if quotient % 2 == 1 then
					key[t.keypos] = t.val
				else
					key[t.keypos] = 'all'
				end
			end
		end
		key = table.concat(key, '-')
		local attempt = cats[key]
		if attempt then
			cat = attempt
			break
		end
	end
	if cat then
		Category.setName(self, cat)
	else
		error(
			'No category match found;'
			.. ' please define the category for key "all-all-all-all-all"'
		)
	end
end

--------------------------------------------------------------------------------
-- ExpiryCategory class
--------------------------------------------------------------------------------

local ExpiryCategory = Category:subclass('ExpiryCategory')

--------------------------------------------------------------------------------
-- ErrorCategory class
--------------------------------------------------------------------------------

local ErrorCategory = Category:subclass('ErrorCategory')

--------------------------------------------------------------------------------
-- ProtectionBanner class
--------------------------------------------------------------------------------

local ProtectionBanner = {}

function ProtectionBanner.exportToWiki(frame, title)
	local args = mArguments.getArgs(frame)
	return ProtectionBanner.exportToLua(args, title)
end

function ProtectionBanner.exportToLua(args, title)
	title = title or mw.title.getCurrentTitle()

	-- Get data objects
	local theProtectionStatus = ProtectionStatus:new(args, title)
	local theConfig = Config:new()

	local ret = {}

	-- Render the banner
	
	-- Render the categories

	return table.concat(ret)	
end

function ProtectionBanner._exportClasses()
	-- This is used to export the classes for testing purposes.
	return {
		ProtectionStatus = ProtectionStatus,
		Config = Config,
		Image = Image,
		Blurb = Blurb,
		BannerTemplate = BannerTemplate,
		Banner = Banner,
		Padlock = Padlock,
		Category = Category,
		ProtectionCategory = ProtectionCategory,
		ErrorCategory = ErrorCategory,
		ExpiryCategory = ExpiryCategory,
	}
end

return ProtectionBanner