Modulo:Periodo attività musicale/sandbox

--[[
* Modulo a supporto del template Artista musicale per generare la riga
* "Periodo di attività musicale" e la relativa categorizzazione, a partire dai  
* parametri "anno inizio attività N", "anno fine attività N" e "note periodo attività N".
]]--

require('Modulo:No globals')

local getArgs = require('Modulo:Arguments').getArgs
local cfg = mw.loadData('Modulo:Periodo attività musicale/Configurazione')
local errorCategory = '[[Categoria:Voci con template Artista musicale con periodo errato]]'
local trackingCategory = 'Categoria:Voci con template Artista musicale con periodo attività con singolo anno'
local maxIntervals = 10
local p = {}

local function errhandler(msg)
	local cat = mw.title.getCurrentTitle().namespace == 0 and errorCategory or ''
	return string.format('<span class="error">%s</span>%s', msg, cat)
end

-- Parsifica i parametri relativi al periodo di attività musicale:
-- "anno inizio attività N", "anno fine attività N" e "note periodo attività N".
-- Restituisce una sequence Lua con elementi con chiavi
-- "start", "ending" ("end" è una parola riservata) e "note".
local function parseArgs(args)
	local ret = {}

	for i = 1, maxIntervals do
		local n = i == 1 and '' or (' ' .. i)
		local interval = {
			start = args['anno inizio attività' .. n],
			ending = args['anno fine attività' .. n],
			note = args['note periodo attività' .. n]
		}
		if interval.start or interval.ending then
			if interval.start then
				if not tonumber(interval.start) then
					error('anno inizio attività' .. n .. ' non valido', 3)
				end
			end
			if interval.ending then
				if not tonumber(interval.ending) and interval.ending ~= 'in attività' then
					error('anno fine attività' .. n .. ' non valido', 3)
				end
			end
			table.insert(ret, interval)
		else
			break
		end
	end

	return ret
end

-- Formatta il valore del parametro 'anno inizio attività' del primo intervallo
local function formatStartYear(value, confCat)
	local ret, cat
	if value then
		cat = confCat.inizio and (confCat.inizio .. ' ' .. value) or nil
		ret = cat and string.format('[[:%s|%s]]', cat, value) or string.format('[[%s]]', value)
	else
		cat = confCat.inizio_assente
		ret = '?'
	end
	return ret, cat
end

-- Formatta il valore del parametro 'anno fine attività' dell'ultimo intervallo
local function formatEndYear(value, confCat)
	local ret, cat
	if value then
		if value == 'in attività' then
			cat = confCat.in_attivita
			ret = cat and string.format('[[:%s|%s]]', cat, value) or value
		else
			cat = confCat.fine and (confCat.fine .. ' ' .. value) or nil
			ret = cat and string.format('[[:%s|%s]]', cat, value) or string.format('[[%s]]', value)
		end
	else
		cat = confCat.fine_assente
		ret = '?'
	end
	return ret, cat
end

-- Genera il contenuto della riga "Periodo di attività musicale" e la relativa categorizzazione,
-- in base ai parametri "tipo artista", "anno inizio attività N", "anno fine attività N", "note periodo attività N"
function p._main(args)
	local formattedIntervals, categories = {}, {}
	local ns0 = mw.title.getCurrentTitle().namespace == 0
	local sepCat = args.debug and '<br />' or ''
	
	-- categorie configurate per il 'tipo artista' richiesto
	local tipo_artista = mw.ustring.lower(args['tipo artista'])
	local confCat = cfg.categorie[cfg.alias[tipo_artista] or tipo_artista] or {}

	-- parsifica gli intervalli richiesti
	local intervals = parseArgs(args)

	-- formatta gli intervalli ottenuti
	for idx, interval in ipairs(intervals) do
		local start, ending, cat, formattedInterval
		if idx == 1 then
			start, cat = formatStartYear(interval.start, confCat)
			table.insert(categories, cat)
		else
			if interval.start then
				start = string.format('[[%s]]', interval.start)
			elseif idx < #intervals then
				start = '?'
			end
		end

		if idx == #intervals then
			ending, cat = formatEndYear(interval.ending, confCat)
			table.insert(categories, cat)
		else
			ending = interval.ending and string.format('[[%s]]', interval.ending) or nil
		end

		-- per l'ultimo intervallo ci deve essere sempre la fine, per gli altri l'inizio
		if #intervals > 1 and idx == #intervals then
			formattedInterval = start and string.format('%s&nbsp;–&nbsp;%s', start, ending) or ending
		else
			formattedInterval = ending and string.format('%s&nbsp;–&nbsp;%s', start, ending) or start
		end
		if interval.note then
			local fmt = interval.note:sub(1, 1) == string.char(127) and
						'%s<small>%s</small>' or '%s <small>(%s)</small>'
			formattedInterval = string.format(fmt, formattedInterval, interval.note)
		end
		table.insert(formattedIntervals, formattedInterval)
	end

	if #intervals > 1 then
		if confCat.intermedi then
			table.insert(categories, confCat.intermedi)
		end
		-- categorizza le voci con uno o più periodi costituiti da un singolo anno
		for idx, v in ipairs(intervals) do
			local years = idx == #intervals and { v.ending, v.start } or { v.start, v.ending }
			if years[1] and not years[2] then
				table.insert(categories, trackingCategory)
				break
			end
		end
	end

	for i = 1, #categories do
		categories[i] = string.format('[[%s%s]]', args.debug and ':' or '', categories[i])
	end

	return table.concat(formattedIntervals, '<br />') .. sepCat ..
		   ((ns0 or args.debug) and table.concat(categories, sepCat) or '')
end

-- Funzione per {{#invoke:Periodo attività musicale|main}}
function p.main(frame)
	return select(2, xpcall(function()
		return p._main(getArgs(frame, { parentOnly = false }))
	end, errhandler))
end

-- Funzione temporanea per la transizione graduale al modulo
function p.valid_args(frame)
	local args = getArgs(frame, { parentOnly = false })
	if args['tipo artista'] then 
		if args['anno inizio attività 2'] or 
			(not args['periodi attività intermedi'] and
			 (not args['anno inizio attività'] or tonumber(args['anno inizio attività'])) and
			 (not args['anno fine attività'] or tonumber(args['anno fine attività']) or args['anno fine attività'] == 'in attività')) then
			return 1
		end
	end
end

return p