Modulo:Data: differenze tra le versioni

Versione delle 06:46, 12 giu 2015

Versione delle 18:00, 17 mar 2016

Riga 6:

local getArgs = require('Modulo:Arguments').getArgs

require('Modulo:No globals')

local errorCategory = '[[Categoria:Voci con errori del modulo Data]]'

local Date = {}

-------------------------------------------------------------------------------

-- Funzioni di utilità

-------------------------------------------------------------------------------

-- Error handler per xpcall, formatta l'errore

local function errhandler(msg)

local cat = mw.title.getCurrentTitle().namespace == 0 and errorCategory or ''

return string.format('<span class="error">Errore: %s</span>%s', msg, cat)

end

local function isValidDate(date)

Line 15 ⟶ 23:

end

-- Controlla args.iniziole edate inserite args.finedall'utente e lile ritornarestituisce income Unixoggetti timeDate

local function parseArgs(args, isCompare)

local data1, data2, label1, label2

if not args.inizio then

error('la data di partenza è obbligatoria', 2)

if isCompare then

elseif not isValidDate(args.inizio) then

data1, data2 = 'data1', 'data2'

error('la data di partenza non è valida', 2)

label1, label2 = 'prima data', 'seconda data'

elseif not args.fine then

else

error('la data di arrivo è obbligatoria', 2)

data1, data2 = 'inizio', 'fine'

elseif not isValidDate(args.fine) then

error('lalabel1, label2 = 'data di arrivopartenza', non'data èdi validafine', 2)

end

if not args[data1] then

return {

error(string.format('la %s è obbligatoria', label1), 2)

d1_ut = tonumber(mw.getContentLanguage():formatDate('U', args.inizio, true)),

elseif not isValidDate(args[data1]) then

d2_ut = tonumber(mw.getContentLanguage():formatDate('U', args.fine, true))

error(string.format('la %s non è valida', label1), 2)

elseif not args[data2] then

error(string.format('la %s è obbligatoria', label2), 2)

elseif not isValidDate(args[data2]) then

error(string.format('la %s non è valida', label2), 2)

end

return {

d1 = Date:new(args[data1]),

d2 = Date:new(args[data2])

}

end

-------------------------------------------------------------------------------

-- Error handler per xpcall, formatta l'errore

-- classe Date

local function errhandler(msg)

-------------------------------------------------------------------------------

return string.format('<span class="error">Errore: %s</span>', msg)

local function date_eq(t, t2)

return t.ut == t2.ut

end

local function date_lt(t, t2)

-- Aggiunge un eventuale prefisso e suffisso al risultato invece del segno.

return t.ut < t2.ut

-- L'ultimo parametro diffVal è utilizzato solo da dateDiff per evitare che

-- {{#invoke:Data|diff|inizio=2016/01/01|fine=2015/12/31|magnitudine=anni}} ritorni "-0 anni".

local function formatResult(result, d1_ut, d2_ut, dir, diffVal)

local ret

if dir then

-- ritorna il 'fa' anche con d1_ut == d2_ut (si potrebbe configurare con un parametro)

ret = d1_ut < d2_ut and 'tra ' .. result or result .. ' fa'

else

ret = (d1_ut <= d2_ut or diffVal == 0) and result or '-' .. result

end

return ret

end

function Date:new(str)

-------------------------------------------------------------------------------

local self = {}

-- dateDiffYMD

setmetatable(self, { __index = Date, __eq = date_eq, __lt = date_lt })

-------------------------------------------------------------------------------

self.ut = tonumber(mw.getContentLanguage():formatDate('U', str, true))

return self

end

function Date:getDateString()

return (mw.getContentLanguage():formatDate('j F Y', '@' .. self.ut):gsub('^1%s', '1º '))

end

function Date:addDays(days)

return Date:new('@' .. (self.ut + days * 86400))

end

function Date:diffYMD(date2, rawTable, dir)

-- Ritorna la differenza in anni, mesi e giorni tra le date d1_ut e d2_ut (Unix time).

-- Se rawTable è true ritorna una table con le chiavi: year, month, day, seconds.

local function dateDiffYMD(d1_ut, d2_ut, rawTable, dir)

local monthdays = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

local d1, d2 = os.date('*t', d1_utself.ut), os.date('*t', d2_utdate2.ut)

local ret = { seconds = math.abs(d1_utself.ut - d2_utdate2.ut) }

if d1_utself.ut >= d2_utdate2.ut then d1, d2 = d2, d1 end

-- anni

Line 89 ⟶ 109:

end

return rawTable and ret or self:formatResult(mw.text.listToText(ret, ',&#32;', '&#32;e&#32;'), d1_ut, d2_utdate2, dir)

end

-- Funzione di utilità per Date:diff

-------------------------------------------------------------------------------

-- dateDiff

-------------------------------------------------------------------------------

-- Funzione di utilità per dateDiff

local function getMagnitudine(diff, magnitudine_min)

local units = {

Line 124 ⟶ 140:

end

-- Funzione di utilità per dateDiffDate:diff

local function convert(seconds, unit, text, text2)

local ret = math.floor(seconds / unit)

return ret, string.format('%s %s', ret, ret == 1 and text or text2)

end

-- Aggiunge un eventuale prefisso e suffisso al risultato invece del segno.

-- L'ultimo parametro diffVal è utilizzato solo da diff per evitare che

-- {{#invoke:Data|diff|inizio=2016/01/01|fine=2015/12/31|magnitudine=anni}} ritorni "-0 anni".

function Date:formatResult(result, d2, dir, diffVal)

local ret

if dir then

-- ritorna il 'fa' anche con self.ut == d2.ut (si potrebbe configurare con un parametro)

ret = self.ut < d2.ut and 'tra ' .. result or result .. ' fa'

else

ret = (self.ut <= d2.ut or diffVal == 0) and result or '-' .. result

end

return ret

end

-- Ritorna la differenza tra le date d1 e d2 (Unix time) in solo una tra le unità:

-- anni, mesi, settimane, giorni, ore, minuti e secondi.

local function dateDiffDate:diff(d1_ut, d2_utd2, magnitudine, magnitudine_min, dir)

local diff, ret, val, result

diff = dateDiffYMDself:diffYMD(d1_ut, d2_utd2, true)

magnitudine = magnitudine or getMagnitudine(diff, magnitudine_min)

Line 156 ⟶ 186:

end

return self:formatResult(result, d1_ut, d2_utd2, dir, val)

end

Line 163 ⟶ 193:

-------------------------------------------------------------------------------

local p = { Date = Date }

-- Entry point per {{#invoke:Data|diff}}

-- Per utilizzare diff da un altro modulo.

function p._diffdiff(argsframe)

local args = getArgs(frame)

local success, result = xpcall(function() return parseArgs(args) end, errhandler)

return success and dateDiff(result.d1_ut, d1:diff(result.d2_utd2, args.magnitudine, args['magnitudine min'], args.dir) or result

end

-- Entry point per {{#invoke:Data|diff_ymd}}

-- Per utilizzare diff_ymd da un altro modulo.

function p._diff_ymddiff_ymd(argsframe)

local args = getArgs(frame)

local success, result = xpcall(function() return parseArgs(args) end, errhandler)

return success and dateDiffYMD(result.d1_ut, d1:diffYMD(result.d2_utd2, false, args.dir) or result

end

-- Entry point per {{#invoke:Data|diffcompare}}

function p.diffcompare(frame)

local success, result = xpcall(function() return p._diffparseArgs(getArgs(frame), true) end, errhandler)

return success and (result.d1 == result.d2 and 0 or ( result.d1 < result.d2 and -1 or 1 )) or result

end

-- Entry point per {{#invoke:Data|diff_ymd}}

function p.diff_ymd(frame)

return p._diff_ymd(getArgs(frame))

end