Forma: Data

 - [[
* Modul pentru efectuarea operațiunilor la date.
* Folosit de șabloane precum {{Wikipedian age}} și {{Time scurs}}.
]]

require ( „Formular: fără globali” )

local getArgs = require ( 'Modul: Argumente' ). getArgs
local errorCategory = '[[Categorie: intrări din formularul de date cu erori]]'
- clasa exportată
local data = {}

-------------------------------------------------- -----------------------------
- Funcții utilitare
-------------------------------------------------- -----------------------------

- Handler de eroare pentru xpcall, formatați eroarea
funcție locală errhandler ( msg )
local cat = mw . titlu . getCurrentTitle (). spațiu de nume == 0 și errorCategory sau "
return string.format ( '<span class = "error"> Eroare:% s </span>% s' , msg , cat )
Sfârșit

funcția locală esteValidDată ( dată )
PCALL return (function () mw. GetContentLanguage (): FormatDate ( '', dates) end)
Sfârșit

- Verifică datele introduse de utilizator și le returnează ca obiecte Date
funcție locală parseArgs ( args , isCompare )
locală date1, date2, Label1, Label2

dacă esteCompară atunci
data1 , data2 = 'data1' , 'data2'
label1 , label2 = 'prima dată' , 'a doua dată'
altceva
DATE1, DATE2 = 'start', 'end'
label1 , label2 = 'data plecării' , 'data de încheiere'
Sfârșit

dacă nu args [ data1 ] atunci
eroare ( string.format ( '% s este necesar' , eticheta1 ), 2 )
elseif not isValidDate ( args [ data1 ]) atunci
eroare ( string.format ( '% s este nevalid' , eticheta1 ), 2 )
elsef not args [ data2 ] atunci
eroare ( string.format ( '% s este necesar' , eticheta2 ), 2 )
elseif not isValidDate ( args [ data2 ]) atunci
eroare ( string.format ( '% s este nevalid' , eticheta2 ), 2 )
Sfârșit

întoarce {
d1 = Data : nou ( args [ data1 ]),
d2 = Data : nou ( args [ data2 ])
}
Sfârșit

-------------------------------------------------- -----------------------------
- Clasa dată
-------------------------------------------------- -----------------------------

funcție locală date_eq ( t , t2 )
întoarce t . ut == t2 . ut
Sfârșit

funcția locală date_lt ( t , t2 )
întoarce t . ut < t2 . ut
Sfârșit

- Construiește un obiect Date dintr-un șir în format
- acceptat de funcția parser #time.
funcție Data : nou ( str , precizie )
auto local = {}
setmetatable ( self , { __index = Date , __eq = date_eq , __lt = date_lt })
sinele . ut = ToNumber (mw. getContentLanguage (): FormatDate ( 'U', str, true))
sinele . precizie = precizie sau 11
întoarcere de sine
Sfârșit

- Construiește un obiect Date pornind de la un șir în format:
- „zi lună_pentru_ anul extins” sau „lună_pentru anul_extins” sau „an”.
funcție Data : newDMY ( str )
luni locale = {
Ianuarie = 1 , februarie = 2 , martie = 3 , aprilie = 4 , mai = 5 , iunie = 6 ,
Iulie = 7 , august = 8 , septembrie = 9 , octombrie = 10 , noiembrie = 11 , decembrie = 12
}
succes local , rezultat = pcall ( function ()
zi locală , lună , an = str : meci ( "(% d +) (% a +) (% d +)" )
dacă ziua atunci
Data returnării : nou ( string.format ( '% d-% d-% d' , an , luni [ lună ], zi ))
altceva
lună , an = str : match ( "(% a +) (% d +)" )
dacă lună atunci
Data returnării : new ( string.format ( '% d-% d' , an , luni [ lună ]), 10 )
altceva
Data returnării : new ( string.format ( '% d' , str : match ( "(% d +)" ))), 9 )
Sfârșit
Sfârșit
sfârșit )
întoarce succesul și rezultatul sau nul
Sfârșit

- Returnează un șir care reprezintă data, fără ora.
funcție Data : getDateString ()
local fmt = self . precizie == 9 și „Y” sau
( auto . precizie == 10 și „F Y” sau
( auto . precizie == 11 și „j F Y” sau „j F Y” ))
return ( mw . getContentLanguage (): formatDate ( fmt , '@' .. self . ut ): gsub ( '^ 1% s' , '1º' ))
Sfârșit

- Returnează un nou obiect Date a cărui dată a avansat cu numărul specificat de zile.
funcție Data : addDays ( zile )
Data returnării : nou ( „@” .. ( auto . ut + zile * 86400 ))
Sfârșit

- Funcția de utilitate pentru Date: diffYMD și Date: diff
- Adaugă orice prefix și sufix la rezultat în locul semnului.
- Ultimul parametru diffVal este utilizat doar de diff pentru a preveni acest lucru
- {{#invoke: Date | diff | start = 2016/01/01 | end = 2015/12/31 | magnitude = years}} returnează „-0 ani”.
Funcția locală formatResult (rezultat, DATE1, DATE2, dir, diffVal)
local ret
dacă dir atunci
- returnează „fa” și cu date1.ut == date2.ut (poate fi configurat cu un parametru)
ret = data1 . ut < data2 . ut și „tra” .. rezultat sau rezultat .. „fa”
altceva
ret = ( data1 . ut <= date2 . ut sau diffVal == 0 ) și rezultat sau '-' .. rezultat
Sfârșit
retur ret
Sfârșit

- Returnează diferența cu data2 în ani, luni și zile.
Funcția Data: diffYMD (DATE2, rawTable, dir)
zile lunare locale = { 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 }
local d1 , d2 = os.date ( '* t' , self . ut ), os.date ( '* t' , date2 . ut )
local ret = { seconds = math.abs ( self . ut - date2 . ut ) }

dacă eul . ut > = data2 . ut apoi d1, d2 = d2, sfârșitul d1  

-- ani
ret . ani = d2 . an - d1 . an
dacă ret . ani > 0 și ( d1 . lună > d2 . lună sau ( d1 . lună == d2 . lună și d1 . zi > d2 . zi )) apoi
ret . ani = ret . ani - 1
Sfârșit
-- luni
ret . luni = ( d2 . lună - d1 . lună + 12 ) % 12
dacă d1 . zi > d2 . zi atunci
ret . luni = (r. luni == 0 și d1. an <d2. an) și 11 sau ret. luni - 1
Sfârșit
- zile
ret . zile = d2 . zi > = d1 . ziua și d2 . zi - d1 . zi sau ( zile lunare [ d1 . lună ] - d1 . zi ) + d2 . zi

- utilizați secvența pentru a returna și versiunea text
dacă ret . ani > 0 atunci
table.insert ( ret , string.format ( '% s% s' , ret . years , ret . years == 1 and 'anno' or 'anni' ))
Sfârșit
dacă ret . luni > 0 atunci
table.insert ( ret , string.format ( '% s% s' , ret . luni , ret . luni == 1 și 'lună' sau 'luni' ))
Sfârșit
dacă ret . zile > 0 sau ret . ani + ret . luni + ret . zile == 0 atunci
table.insert ( ret , string.format ( '% s% s' , ret . zile , ret . zile == 1 și 'zi' sau 'zile' ))
Sfârșit

returnează RawTable și ret sau formatează Rezultatul ( mw . text . listToText ( ret , ', & # 32;' , '& # 32; și & # 32;' ), self , date2 , dir )
Sfârșit

- Funcția de utilitate pentru Data: dif
funcție locală getMagnitude ( diff , magnitude_min )
unități locale = { 
secunde = 0 , minute = 1 , ore = 2 , zile = 3 , săptămâni = 4 , luni = 5 , ani = 6
}
local ret

dacă dif . secunde < 120 apoi - mai puțin de două minute
ret = 'secunde'
elseif dif . secunde < 7200 apoi - mai puțin de două ore
ret = 'minute'
elseif dif . secunde < 172800 apoi - mai puțin de două zile
ret = 'ore'
elseif dif . ani == 0 și dif. luni < 2 apoi - mai puțin de două luni
ret = 'zile'
elseif dif . ani < 2 atunci - mai puțin de doi ani
ret = 'luni'
altceva
ret = 'ani'
Sfârșit
- utilizarea magnitude_min (valoarea minimă când este automată)
dacă min_magnitude și unități [ min_magnitude ] atunci
ret = units [ magnitude_min ] > units [ ret ] și magnitude_min sau ret
Sfârșit

retur ret
Sfârșit

- Funcția de utilitate pentru Data: dif
conversie funcție locală ( secunde , unitate , text , text2 )
local ret = math.floor ( secunde / unitate )
return ret , string.format ( '% s% s' , ret , ret == 1 și text sau text2 )
Sfârșit

- Returnează diferența cu data d2 doar într-una dintre unități:
- ani, luni, săptămâni, zile, ore, minute și secunde.
funcție Data : dif ( data2 , magnitudine , magnitudine_min , dir )
dif local , ret , val , rezultat

dif = sine: diffYMD (DATE2, true)
magnitude = magnitude or getMagnitude ( diff , magnitude_min )

dacă magnitudine == „secunde” atunci
val, rezultat = conversie (dif. secunde, 1, „secundă”, „secunde”)
elseif magnitude == 'minute' atunci
val, rezultat = convert (dif. secunde, 60, „minut”, „minute”)
elseif magnitude == „ore” atunci
val , rezultat = conversie ( dif . secunde , 3600 , „oră” , „ore” )
elseif magnitude == „zile” atunci
val result = convert (dif. secunde, 86400, „zi”, „zile”)
elseif magnitude == „săptămâni” atunci
val result = convert (dif. secunde, 604800, „săptămână”, „săptămâni”)
elseif magnitude == 'luni' atunci
val = dif . ani * 12 + dif . luni
result = string.format ( '% s% s' , val , val == 1 și 'lună' sau 'luni' )
altceva
val = dif . ani
rezultat = string.format ( '% s% s', dif. de ani, dif. ani == 1 și 'an' sau 'ani')
Sfârșit
 
return formatResultat ( rezultat , auto , data2 , dir , val )
Sfârșit

-------------------------------------------------- -----------------------------
- API
-------------------------------------------------- -----------------------------

local p = { Data = Data }

- Punct de intrare pentru {{#invoke: Data | diff}}
funcția p . dif ( cadru )
argumente locale = getArgs ( cadru )
succes local , rezultat = xpcall ( function () return parseArgs ( args ) end , errhandler )
întoarce succesul și rezultatul . d1 : dif ( rezultat . d2 , arg . magnitudine , args [ „min magnitudine” ], arg . dir ) sau rezultat
Sfârșit

- Punct de intrare pentru {{#invoke: Data | diff_ymd}}
funcția p . diff_ymd ( cadru )
argumente locale = getArgs ( cadru )
succes local , rezultat = xpcall ( function () return parseArgs ( args ) end , errhandler )
întoarce succesul și rezultatul . d1 : diffYMD ( rezultat . d2 , fals , arg . dir ) sau rezultat
Sfârșit

- Punct de intrare pentru {{#invoke: Data | compare}}
funcția p . compara ( cadru )
succes local , rezultat = xpcall ( function () return parseArgs ( getArgs ( frame ), true ) end , errhandler )
returnează succesul și ( rezultatul . d1 == rezultatul . d2 și 0 sau ( rezultatul . d1 < rezultatul . d2 și - 1 sau 1 )) sau rezultatul
Sfârșit

retur p