Modifica di Modulo:Criteri cancellazione immediata/sandbox

--[[
* Modulo che implementa i template {{Criterio cancellazione immediata}} e
* {{Criteri cancellazione immediata}}.
]]

require('strict')

-- Legge Modulo:Criteri cancellazione immediata/Configurazione.json
-- oppure Modulo:Criteri cancellazione immediata/sandbox/Configurazione.json
local cfg = mw.loadJsonData(mw.getCurrentFrame():getTitle() .. '/Configurazione.json')

-- =============================================================================
--                           enum NamespaceType
-- =============================================================================
local NamespaceType = setmetatable({
	ANY = {
		value = 'any'
	},
	EVEN = {
		value = 'ns pari'
	},
	ODD = {
		value = 'ns dispari'
	}
}, {
	__index = function (t, key)
		if key == 'findByValue' then
			return function (value)
				for _, ns_type in pairs(t) do
					if ns_type.value == value then
						return ns_type
					end
				end
			end
		end
	end
})

-- =============================================================================
--                           enum Namespace
-- =============================================================================

local Namespace = setmetatable({
	DEFAULT = {
		id = 'default',
		type = NamespaceType.ANY,
		name = 'default'
	},
	PRINCIPALE = {
		id = 0,
		type = NamespaceType.EVEN,
		name = 'Principale'
	}
}, {
	__index = function (t, key)
		if key == 'findById' then
			return function (id)
				for _, ns in pairs(t) do
					if ns.id == tonumber(id) then
						return ns
					end
				end
			end
		elseif key == 'findByName' then
			return function (name)
				for _, ns in pairs(t) do
					if ns.name == name then
						return ns
					end
				end
			end
		end
	end
})

for _, ns in pairs(mw.site.namespaces) do
	if ns.id ~= 0 then
		Namespace[ns.name:gsub(' ', '_'):upper()] = {
			id = ns.id,
			type = ns.id % 2 == 0 and NamespaceType.EVEN or NamespaceType.ODD,
			name = ns.name
		}
	end
end

-- =============================================================================
--                           enum ListType
-- =============================================================================

local ListType = setmetatable({
	DROPDOWN_LIST = {
		arg = 'a discesa',
		prefix = '**',
		section = setmetatable({
			[6] = '* Motivi comuni di cancellazione'
		}, {
			__index = function (t, key)
				return '* Cancellazione immediata'
			end
		})
	},
	BULLETED_LIST = {
		arg = 'puntato',
		prefix = '*',
		section = setmetatable({}, {
			__index = function (t, key)
				return ''
			end
		})
	}
}, {
	__index = function (t, key)
		if key == 'findByArg' then
			return function (arg)
				for _, list_type in pairs(t) do
					if list_type.arg == arg then
						return list_type
					end
				end
			end
		elseif key == 'getDefault' then
			return function ()
				return t.DROPDOWN_LIST
			end
		end
	end
})

-- =============================================================================
--                           enum TextType
-- =============================================================================

local TextType = setmetatable({
	SYSTEM_MESSAGE = {
		arg = 'messaggio di sistema',
		get = 'getSystemMessage',
		set = 'setSystemMessage'
	},
	DEFINITION = {
		arg = 'definizione',
		get = 'getDefinition',
		set = 'setDefinition'
	}
}, {
	__index = function (t, key)
		if key == 'findByArg' then
			return function (arg)
				for _, text_type in pairs(t) do
					if text_type.arg == arg then
						return text_type
					end
				end
			end
		elseif key == 'getDefault' then
			return function ()
				return t.SYSTEM_MESSAGE
			end
		end
	end
})

-- =============================================================================
--                           classe Criterion
-- =============================================================================

local Criterion = {}

-- Costruttore della classe Criterion
function Criterion:new(code)
	local self = {}
	setmetatable(self, { __index = Criterion })

	self.code = code
	self.current_ns = Namespace.DEFAULT
	self.order = { default = 0 }
	self.add_link = false
	self.link = { default = string.format('[[WP:IMMEDIATA|%s]]', code) }
	self.system_message = { default = '' }
	self.definition = { default = '' }
	self.validity = { default = true }

	return self
end

function Criterion:getCode()
	return self.code
end

function Criterion:getOrder()
	return self.order[self.current_ns.id] or self.order.default
end

function Criterion:getLink()
	return self.link[self.current_ns.id] or self.link.default
end

function Criterion:getSystemMessage()
	return string.format('(%s) %s',
		self.add_link and self:getLink() or self:getCode(),
		self.system_message[self.current_ns.id] or self.system_message.default)
end

function Criterion:getDefinition()
	return string.format('(%s) %s',
		self.add_link and self:getLink() or self:getCode(),
		self.definition[self.current_ns.id] or self.definition.default)
end

function Criterion:isValid()
	if self.validity[self.current_ns.id] ~= nil then
		return self.validity[self.current_ns.id]
	elseif self.validity[self.current_ns.type.value] ~= nil then
		return self.validity[self.current_ns.type.value]
	else
		return self.validity.default
	end
end

function Criterion:setCurrentNs(ns)
	self.current_ns = ns
	return self
end

function Criterion:setOrder(order)
	self.order[self.current_ns.id] = order
	return self
end

function Criterion:setAddLink(add_link)
	self.add_link = add_link
	return self
end

function Criterion:setLink(link)
	self.link[self.current_ns.id] = link
	return self
end

function Criterion:setSystemMessage(text)
	self.system_message[self.current_ns.id] = text
	return self
end

function Criterion:setDefinition(text)
	self.definition[self.current_ns.id] = text
	return self
end

function Criterion:setValid(valid)
	self.validity[self.current_ns.id] = valid
	return self
end

function Criterion:setValidForNsType(valid, ns_type)
	self.validity[ns_type.value] = valid
	return self
end

-- =============================================================================
--                            Funzioni di utilità
-- =============================================================================

local function to_criterion(criterion_code, criterion_cfg)
	local criterion = Criterion:new(criterion_code)

	for ns, props in pairs(criterion_cfg) do
		ns = Namespace.findByName(ns)

		if ns and type(props) == 'table' then
			criterion:setCurrentNs(ns)

			if type(props.ordine) == 'number' then
				criterion:setOrder(props.ordine)
			end

			if type(props.link) == 'string' then
				criterion:setLink(props.link)
			end

			if type(props.testi) == 'table' then
				for text_type, text in pairs(props.testi) do
					text_type = TextType.findByArg(text_type)

					if text_type then
						criterion[text_type.set](criterion, text)
					end
				end
			end

			if ns == Namespace.DEFAULT then
				if type(props['validità']) == 'table' then
					for ns_type, valid in pairs(props['validità']) do
						ns_type = NamespaceType.findByValue(ns_type)

						if ns_type and type(valid) == 'boolean' then
							criterion:setValidForNsType(valid, ns_type)
						end
					end
				end
			elseif type(props['validità']) == 'boolean' then
				criterion:setValid(props['validità'])
			end
		end
	end

	return criterion
end

local function compare_criteria(a, b)
	if a:getOrder() == b:getOrder() then
		return a:getCode() < b:getCode()
	else
		return a:getOrder() < b:getOrder()
	end
end

local function get_suppressed_criteria(arg)
	local suppressed_criteria = setmetatable({}, {
		__index = function (t, key)
			return false
		end
	})

	if arg then
		for criterion_code in string.gmatch(arg, '[%s,]*([^,]*[^%s,])') do
			suppressed_criteria[criterion_code] = true
		end
	end

	return suppressed_criteria
end

local function get_args(frame)
	local args = require('Module:Arguments').getArgs(frame, { parentOnly = true })

	if args[1] and args.criterio == nil then
		args.criterio, args[1] = args[1], nil
	end

	args.ns = Namespace.findByName(args.ns) or Namespace.findById(args.ns) or Namespace.DEFAULT
	args['tipo elenco'] = ListType.findByArg(args['tipo elenco']) or ListType.getDefault()
	args['tipo testo'] = TextType.findByArg(args['tipo testo']) or TextType.getDefault()
	args.link = args.link ~= 'no' and true or false
	args.ancore = (args.ancore == 'sì' or args.ancore == 'si') and true or false
	args['escludi criteri'] = get_suppressed_criteria(args['escludi criteri'])

	return args
end

-- =============================================================================
--                            Funzioni esportate
-- =============================================================================

local p = {}

function p.get_default_list_type()
	return ListType.getDefault()
end

function p.get_default_text_type()
	return TextType.getDefault()
end

function p.get_list_types()
	local list_types = {}

	for _, list_type in pairs(ListType) do
		table.insert(list_types, string.format('"%s"', list_type.arg))
	end

	return table.concat(list_types, ', ')
end

function p.get_text_types()
	local text_types = {}

	for _, text_type in pairs(TextType) do
		table.insert(text_types, string.format('"%s"', text_type.arg))
	end

	return table.concat(text_types, ', ')
end

function p.get_criterion(frame)
	local args = get_args(frame)
	local text_type = args['tipo testo']
	local ns, criterion_code, add_link = args.ns, args.criterio, args.link

	if criterion_code and cfg[criterion_code] then
		local criterion = to_criterion(criterion_code, cfg[criterion_code])

		criterion:setCurrentNs(ns):setAddLink(add_link)

		if criterion:isValid() then
			return criterion[text_type.get](criterion)
		end
	end
end

function p.list_criteria(frame)
	local args = get_args(frame)
	local list_type, text_type = args['tipo elenco'], args['tipo testo']
	local ns, add_anchor, add_link = args.ns, args.ancore, args.link
	local suppressed_criteria = args['escludi criteri']
	local list = list_type.section[ns.id]
	local valid_criteria = {}

	for criterion_code, criterion_cfg in pairs(cfg) do
		local criterion = to_criterion(criterion_code, criterion_cfg)

		criterion:setCurrentNs(ns):setAddLink(add_link)

		if criterion:isValid() and suppressed_criteria[criterion:getCode()] == false then
			table.insert(valid_criteria, criterion)
		end
	end

	table.sort(valid_criteria, compare_criteria)

	for _, criterion in ipairs(valid_criteria) do
		list = string.format('%s\n%s ', list, list_type.prefix)

		if add_anchor then
			list = string.format('%s<span id=%s></span>', list, criterion:getCode())
		end

		list = list .. criterion[text_type.get](criterion)
	end

	return mw.text.trim(list)
end

return p