« Module:Date » : différence entre les versions
ifexist et dateISO : correction bugs |
Modèle Date prend en compte Date/Data, age, julien, avJC |
||
Ligne 30 : | Ligne 30 : | ||
end |
end |
||
return str |
return str |
||
end |
|||
-- nettoie un paramètre non nommé (vire les espaces au début et à la fin) |
|||
-- retourne nil si le texte est vide ou n'est pas du texte. Attention c'est important pour les fonction qui l'utilise. |
|||
local function trim( texte ) |
|||
if type( texte ) == "string" and texte ~= "" then |
|||
return mw.text.trim( texte ) |
|||
end |
|||
end |
|||
local function ucfirst( str ) |
|||
return mw.ustring.upper( mw.ustring.sub( str, 1, 1 ) ) .. mw.ustring.sub( str, 2 ) |
|||
end |
end |
||
Ligne 35 : | Ligne 47 : | ||
-- liste des mois, écriture exacte et simplifiée, en minuscule |
-- liste des mois, écriture exacte et simplifiée, en minuscule |
||
local liste_mois = { |
local liste_mois = { |
||
{ "janvier", "jan.", "janv.", "jan", "janv", "january" }, |
{ "janvier", "jan.", "janv.", "jan", "janv", "january", nJour = 31 }, |
||
{ "février", "fevrier", "fev.", "fev", "fév.", "fév", "february" }, |
{ "février", "fevrier", "fev.", "fev", "fév.", "fév", "february", nJour = 29 }, |
||
{ "mars", "mar.", "mar", "march" }, |
{ "mars", "mar.", "mar", "march", nJour = 31 }, |
||
{ "avril", "avr.", "avr", "apr", "april" }, |
{ "avril", "avr.", "avr", "apr", "april", nJour = 30 }, |
||
{ "mai", "may" }, |
{ "mai", "may", nJour = 31 }, |
||
{ "juin", "jun", "june" }, |
{ "juin", "jun", "june", nJour = 30 }, |
||
{ "juillet", "juil.", "juil", "juill.", "juill", "jul", "july" }, |
{ "juillet", "juil.", "juil", "juill.", "juill", "jul", "july", nJour = 31 }, |
||
{ "août", "aout","aou", "aug", "august" }, |
{ "août", "aout","aou", "aug", "august", nJour = 31 }, |
||
{ "septembre", "sept.", "sept", "sep.", "sep", "september" }, |
{ "septembre", "sept.", "sept", "sep.", "sep", "september", nJour = 30 }, |
||
{ "octobre", "oct.", "oct", "october" }, |
{ "octobre", "oct.", "oct", "october", nJour = 31 }, |
||
{ "novembre", "nov.", "nov", "november" }, |
{ "novembre", "nov.", "nov", "november", nJour = 30 }, |
||
{ "décembre", "decembre", "déc.", "dec.", "dec", "déc", "december" } |
{ "décembre", "decembre", "déc.", "dec.", "dec", "déc", "december", nJour = 31 }, |
||
} |
} |
||
-- nom du mois à partir du numéro |
-- nom du mois à partir du numéro |
||
function fun.nomDuMois(num) |
function fun.nomDuMois( num ) |
||
if |
if type( num ) ~= "number" or num < 1 or num > 12 then |
||
return nil |
return nil |
||
end |
end |
||
return liste_mois[num][1] |
|||
if ((num < 1) or (num > 12)) then |
|||
return nil |
|||
end |
|||
return (liste_mois[num]) |
|||
end |
end |
||
Ligne 63 : | Ligne 72 : | ||
-- retourne le nom complet ou nil si non reconnu |
-- retourne le nom complet ou nil si non reconnu |
||
-- si reconnu, retourne aussi le numéro du mois [1-12] |
-- si reconnu, retourne aussi le numéro du mois [1-12] |
||
function fun.valideMois(mois) |
function fun.valideMois( mois ) |
||
if type( mois ) ~= "string" then |
|||
local m = mw.ustring.lower(mois) |
|||
return nil |
|||
end |
|||
local m = mw.ustring.lower( mois ) |
|||
for i = 1, 12 do |
for i = 1, 12 do |
||
local j = 1 |
local j = 1 |
||
while |
while liste_mois[i][j] ~= nil do |
||
if |
if liste_mois[i][j] == m then |
||
return liste_mois[i][1], i |
return liste_mois[i][1], i |
||
end |
end |
||
Ligne 75 : | Ligne 88 : | ||
end |
end |
||
end |
end |
||
-- pas trouvé |
-- pas trouvé = return nil |
||
return nil |
|||
end |
end |
||
-- trouve le numéro du mois et son nom, |
-- determinationMois trouve le numéro du mois et son nom, |
||
-- à partir de son nom, de son numéro ou d'une expression mathématique. |
|||
-- l'objet frame est facultatif, mais permet de tester si mois est une expression type '2+3' |
-- l'objet frame est facultatif, mais permet de tester si mois est une expression type '2+3' |
||
function fun.determinationMois(mois, frame) |
function fun.determinationMois( mois, frame ) |
||
local num, nom |
local num, nom |
||
if tonumber(mois) then |
if tonumber( mois ) then |
||
num = math.floor( math.fmod( tonumber(mois) - 1, 12 ) ) + 1 |
num = math.floor( math.fmod( tonumber( mois ) - 1, 12 ) ) + 1 |
||
elseif type(mois) == "string" then |
elseif type( mois ) == "string" then |
||
nom, num = fun.valideMois(mois) |
nom, num = fun.valideMois( mois ) |
||
if nom == nil and frame and frame.callParserFunction then |
if nom == nil and frame and frame.callParserFunction then |
||
-- essai de détermination d'un nombre avec le parser #expr de Mediawiki. |
-- essai de détermination d'un nombre avec le parser #expr de Mediawiki. |
||
-- la fonction s'appelle |
-- la fonction s'appelle sans l'objet frame pour ne pas tourner en boucle. |
||
nom, num = fun.determinationMois |
nom, num = fun.determinationMois( frame:callParserFunction( '#expr', mois ) ) |
||
end |
end |
||
end |
end |
||
if num and not nom then |
if num and not nom then |
||
nom = liste_mois |
nom = liste_mois[num][1] |
||
end |
end |
||
return nom, num |
return nom, num |
||
Ligne 100 : | Ligne 113 : | ||
-- fonction interne à modeleDate, pour déterminer si on peut se passer de faire un ifexit |
|||
-- émule le modèle {{m|Date}}. Pas complet. |
|||
local function existDate( dataQualificatif, annee, mois ) |
|||
function fun.modeleDate(frame) |
|||
local data |
|||
if mois then |
|||
data = dataQualificatif.mois |
|||
--[[ |
|||
else |
|||
data = dataQualificatif.annee |
|||
1 : jour (numéro ou "1er"). optionnel, si absent pas de jour |
|||
end |
|||
2 : mois (en toutes lettres) |
|||
if data == nil then |
|||
-- si data n'existe pas c'est que l'on considère qu'il n'y a pas de lien. |
|||
4 : optionnel, spécialité de l'année |
|||
return |
|||
Comportement spécial ("truc à deux balles au lieu d'utiliser un |
|||
end |
|||
paramètre nommé du genre "sans année=oui"...") : si 1 est vide |
|||
-- le qualificatif est remplacer par celui de la base de donnée, ce qui permet des alias. |
|||
mais que le reste est complet → on n'affiche pas l'année |
|||
local lien = annee .. ( dataQualificatif.qualificatif or '' ) |
|||
]]-- |
|||
local seul = annee |
|||
if mois then |
|||
lien = mois .. ' ' .. lien |
|||
seul = ucfirst( mois ) .. ' ' .. annee |
|||
end |
|||
if type( data.aucun ) == 'number' and annee <= (data.aucun or 0) then |
|||
-- si la l'année est dans la partie 'aucun' on teste s'il y a malgré tout un lien isolé |
|||
if type( data.seul ) == 'table' then |
|||
for i, v in ipairs( data.seul ) do |
|||
if seul == v then |
|||
return lien |
|||
end |
|||
end |
|||
end |
|||
-- partie aucun et pas de lien => nil |
|||
return nil |
|||
elseif type( data.tous ) == 'table' |
|||
and type( data.tous[1] ) == 'number' |
|||
and type( data.tous[2] ) == 'number' |
|||
and annee >= data.tous[1] |
|||
and annee <= data.tous[2] |
|||
then |
|||
-- l'année est dans la partie 'tous' donc on retourne le lien |
|||
return lien |
|||
end |
|||
-- l'annee n'est ni dans la partie aucun, ni dans la partie tous donc il faut tester si la page existe. |
|||
print( 'ifexist' ) |
|||
if mw.title.new( lien ).exists then |
|||
return lien |
|||
end |
|||
end |
|||
-- émule le modèle {{m|Date}}. |
|||
-- Paramètres : |
|||
-- 1 : jour (numéro ou "1er"). optionnel, si absent pas de jour |
|||
-- 2 : mois (en toutes lettres) |
|||
-- 3 : année (nombre) |
|||
-- 4 : optionnel, spécialité de l'année |
|||
-- Comportement spécial ("truc à deux balles au lieu d'utiliser un |
|||
-- paramètre nommé du genre "sans année=oui"...") : si 1 est vide |
|||
-- mais que le reste est complet → on n'affiche pas l'année |
|||
function fun.modeleDate( frame ) |
|||
local args = frame.args or frame |
|||
if args[1] == nil and args[3] == nil and frame.getParent then |
|||
args = frame:getParent().args |
|||
end |
|||
-- chargement de la base de donnée répertoriant certaines pages existant ou n'existant pas pour éviter les "ifexist". |
|||
local dataLiens |
|||
local success, resultat = pcall ( mw.loadData, 'Module:Date/Data' ) |
|||
if success then |
|||
dataLiens = resultat |
|||
else |
|||
-- protection au cas ou le sous module serait mal modifié |
|||
dataLiens = { [''] = { mois = { aucun = 1000, tous = { 1938, 2013 } }, }, parametresPage = { } } |
|||
end |
|||
local annee, mois, numMois, jour |
|||
local decalage = 0 |
local decalage = 0 |
||
-- si pas de jour mais que args[2] est un mois on décale tout et on |
-- si pas de jour mais que args[2] est un mois on décale tout et on |
||
-- n'affiche pas l'année |
-- n'affiche pas l'année |
||
if ( |
if trim( args[1] ) == nil and fun.valideMois( trim( args[3] ) ) ~= nil then |
||
decalage = 1 |
decalage = 1 |
||
end |
end |
||
-- on traite l'année |
|||
local bjour = fun.nettoie(args[1+decalage]) |
|||
local bannee = trim( args[3 + decalage] ) |
|||
-- on traite le jour si présent |
|||
if |
if bannee then |
||
annee = tonumber( bannee ) |
|||
if |
if annee == nil then |
||
-- test si l'année contient av. J.-C. |
|||
annee = mw.ustring.match( mw.ustring.upper( bannee ), '^(%d+)%sAV%.?%s?J%.?%-?C' ) |
|||
jour = 1 |
|||
annee = tonumber( annee ) |
|||
if annee then |
|||
annee = 0 - annee |
|||
else |
else |
||
return |
return erreurDate( 'Année invalide (' .. bannee .. ')' ) |
||
end |
end |
||
else |
|||
jour = tmp |
|||
end |
|||
-- on valide que le jour est correct |
|||
if ((jour < 1) or (jour > 31)) then |
|||
-- note : il faudrait valider le jour en fonction du mois (30/31 ou 28/29) |
|||
return fun.erreurDate("Jour invalide (" .. bjour .. ")") |
|||
end |
end |
||
else |
else |
||
annee = nil |
|||
end |
end |
||
-- on traite le mois |
-- on traite le mois |
||
local bmois = |
local bmois = trim (args[2 + decalage] ) |
||
if |
if bmois then |
||
mois, numMois = fun.valideMois( bmois ) |
|||
if mois == nil then |
|||
end |
|||
-- on teste si le mois est fourni sous forme numérique |
|||
local mois, num = fun.valideMois(bmois) |
|||
numMois = tonumber( bmois ) |
|||
if (mois == nil) then |
|||
mois = fun.nomDuMois( numMois ) |
|||
return fun.erreurDate("Mois invalide (" .. bmois .. ")") |
|||
end |
|||
-- on regarde si la première lettre est en majuscule |
|||
if (mw.ustring.match(bmois, "^%u") ~= nil) then |
|||
if (jour == nil) then -- interdit si le jour est indiqué |
|||
-- oui, on passe la première lettre en majuscule |
|||
local debut = mw.ustring.match(mois, "^.") |
|||
local fin = mw.ustring.match(mois, "^.(.*)$") |
|||
mois = mw.ustring.upper(debut) .. fin |
|||
end |
end |
||
if mois == nil then |
|||
return erreurDate( 'Mois invalide (' .. bmois .. ')' ) |
|||
else |
|||
-- on traite le jour si présent |
|||
local bjour = trim( args[1 + decalage] ) |
|||
if bjour then |
|||
jour = tonumber( bjour ) |
|||
if jour == nil then |
|||
if bjour == '1er' |
|||
or bjour == '<abbr class="abbr" title="Premier" >1<sup>er</sup></abbr>' -- correspond à {{1er}} |
|||
then |
|||
jour = 1 |
|||
else |
|||
return erreurDate( 'Jour invalide (' .. bjour .. ')' ) |
|||
end |
|||
end |
|||
-- on valide que le jour est correct |
|||
if jour < 1 or jour > 31 then |
|||
return erreurDate( 'Jour invalide (' .. bjour .. ')' ) |
|||
elseif jour > liste_mois[numMois].nJour then |
|||
return erreurDate( 'Jour invalide (' .. bjour .. ' ' .. mois .. ')' ) |
|||
-- l'année bisextile n'est pas testée pour accepter les dates juliennes. |
|||
end |
|||
else |
|||
-- S'il n'y a pas de jour on regarde si la première lettre du mois est en majuscule |
|||
if mw.ustring.match( bmois, '^%u' ) then |
|||
-- oui, on passe la première lettre en majuscule |
|||
mois = ucfirst( mois ) |
|||
end |
|||
-- s'il n'y a pas d'année non plus on retourne le mois simple |
|||
end |
|||
end |
|||
-- else |
|||
-- return erreurDate("Le mois est obligatoire") |
|||
end |
end |
||
-- on traite |
-- on traite le champs optionnel |
||
local |
local qualificatif = trim( args[4 + decalage] ) or dataLiens.parametresPage.qualificatif |
||
if (bannee == "") then |
|||
-- on traite l'age |
|||
return fun.erreurDate("L'année est obligatoire") |
|||
local age = trim( args['âge'] or args['age'] ) |
|||
end |
|||
age = age and fun.age( annee, numMois, jour ) |
|||
local tmp = tonumber(bannee) |
|||
if (tmp == nil) then |
|||
-- on traite le calendrier |
|||
return fun.erreurDate("Année avalide (" .. bannee .. ")") |
|||
local gannee, gmois, gjour = annee, numMois, jour -- date suivant le calendrier grégorien pour <time> |
|||
end |
|||
local jannee, jmois, jjour, julien = annee, mois, jour -- servira éventuellement à a affiché la date selon le calendrier julien |
|||
annee = tmp |
|||
local julien1, julien2, julien3 = '', '', '' -- servira éventuellement à a affiché des parenthèses |
|||
local julien = trim( string.lower( args.julien or dataLiens.parametresPage.julien or '' ) ) |
|||
-- le champs optionnel |
|||
if annee and jour then |
|||
local opt = fun.nettoie(args[4+decalage]) |
|||
local amj = annee * 10000 + numMois * 100 + jour |
|||
if (opt == "") then |
|||
if amj < 15821014 then |
|||
gannee, gmois, gjour = fun.jullianToGregorian( annee, numMois, jour ) |
|||
elseif julien == 'oui' then |
|||
gannee, gmois, gjour = fun.jullianToGregorian( annee, numMois, jour ) |
|||
annee, numMois, jour = gannee, liste_mois[gmois][1], gjour |
|||
end |
|||
end |
end |
||
-- on génère le résultat |
-- on génère le résultat |
||
-- Déclarations des variables |
|||
local wikiListe = TableBuilder.new() -- reçois le texte affiché pour chaque paramètre |
|||
local iso = TableBuilder.new() -- reçois le format date ISO de ce paramètre |
|||
local dataQualificatif = dataLiens[qualificatif or ''] |
|||
-- le jour si présent |
|||
if ( |
if type( dataQualificatif ) ~= 'table' then |
||
-- si le qualifiquatif n'est pas dans la base de donnée, on crée une table minimum, |
|||
if (jour == 1) then |
|||
-- qui imposera un test sur l'annee, mais considère qu'il n'y a pas de lien sur le jour ou le mois |
|||
res = res .. "[[1er " .. mois .. '|<abbr class="abbr" title="premier">1<sup>er</sup></abbr>' .. "]] " |
|||
dataQualificatif = { qualificatif = ' ' .. qualificatif, annee = { } } |
|||
end |
|||
-- Date julienne |
|||
if jjour ~= jour then |
|||
wikiListe.insert( '<abbr title="selon le calendrier julien" >' .. jjour ) |
|||
julien1 = '(' |
|||
if jannee ~= annee then |
|||
wikiListe.insert( jmois ) |
|||
wikiListe.insert( jannee .. '</abbr>' ) |
|||
julien3 = ')' |
|||
else |
else |
||
wikiListe.insert( jmois .. '</abbr>' ) |
|||
julien2 = ')' |
|||
end |
end |
||
end |
|||
-- le jour si présent |
|||
if jour then |
|||
local lien = jour .. ' ' .. mois |
|||
if jour == 1 then |
|||
jour = '<abbr class="abbr" title="premier">1<sup>er</sup></abbr>' |
|||
end |
|||
if jour == 1 then |
|||
lien = '1er ' .. mois |
|||
end |
|||
lien = lien .. ( dataQualificatif.jour or '' ) |
|||
wikiListe.insert( julien1 .. '[[' .. lien .. '|' .. jour .. ']]' ) |
|||
wikiListe.insert( julien1 .. '[[' .. lien .. '|' .. jour .. ' '.. mois .. ']]' .. julien2 ) |
|||
iso.insert( 1, string.sub( '0' .. gjour, -2 ) ) |
|||
end |
end |
||
-- le mois |
-- le mois |
||
if mois then |
|||
local lien |
|||
if (fun.ifexist(tmp)) then |
|||
if annee then |
|||
res = res .. "[[" .. tmp .. "|" .. mois .. "]]" |
|||
lien = existDate( dataQualificatif, annee, mois ) |
|||
else |
|||
if ( |
if lien == nil and qualificatif and (jour == nil or dataQualificatif.jour == nil) then |
||
-- test nouveau test sans le qualificatif uniquement s'il n'y a pas d'éphémérides pour ce qualificatif. |
|||
res = res .. "[[Mars (mois)|" .. mois .. "]]" |
|||
lien = existDate( dataLiens[''].mois, annee, mois ) |
|||
end |
|||
end |
|||
if lien then |
|||
-- s'il y a un lien on retire le lien affichant 'jour mois' pour ajouter '[[mois annee|mois']] |
|||
wikiListe.remove() |
|||
wikiListe.insert( '[[' .. lien .. '|' .. mois .. ']]' .. julien2 ) |
|||
else |
else |
||
-- sinon on retire le lien affichant 'jour' pour ne garder que le lien 'jour mois' |
|||
res = res .. "[[" .. mois .. "]]" |
|||
wikiListe.remove( #wikiListe - 1 ) |
|||
end |
|||
-- s'il n'y avait pas je jour, la liste est vide mais ça ne pose pas de problème |
|||
end |
|||
-- si |
-- sauf si l'année n'est pas affichée : |
||
if ( |
if #wikiListe == 0 and ( annee == nil or decalage > 0 ) then |
||
return mois |
|||
end |
|||
end |
|||
iso.insert( 1, string.sub( '0' .. gmois, -2 ) ) |
|||
end |
end |
||
-- l'année |
-- l'année |
||
if |
if annee and decalage == 0 then -- seulement si on doit l'affichée |
||
local lien = existDate( dataQualificatif, annee ) |
|||
local texte = annee |
|||
if annee < 0 then |
|||
local annneeAvJc = 0 - annee |
|||
lien = lien or ( annneeAvJc .. ' av. J.-C.' ) |
|||
local avJC = trim( string.lower( args.avJC or dataLiens.parametresPage.avJC or '' ) ) |
|||
if args.avJC == 'non' then |
|||
texte = annneeAvJc |
|||
else |
|||
texte = annneeAvJc .. ' <abbr class="abbr" title="' |
|||
.. annneeAvJc .. ' avant Jésus-Christ">av. J.-C.</abbr>' |
|||
end |
|||
end |
end |
||
lien = lien or annee |
|||
if mois and #wikiListe == 0 then |
|||
res = res .. "[[" .. tmp .. "|" .. annee .. "]]" |
|||
texte = mois .. ' ' .. texte |
|||
end |
|||
wikiListe.insert( '[[' .. lien .. '|' .. texte .. ']]' .. julien3 ) |
|||
iso.insert( 1, string.sub( '000' .. annee , -4 ) ) |
|||
end |
|||
-- l'age |
|||
local classAge |
|||
if type( age ) == 'number' and age >= 0 then |
|||
if age == 0 then |
|||
age = '<span class="noprint"> (moins d\'1 an)</span>' |
|||
elseif age == 1 then |
|||
age = '<span class="noprint"> (1 an)</span>' |
|||
else |
else |
||
age = '<span class="noprint"> (' .. age .. 'ans)</span>' |
|||
end |
end |
||
classAge = 'class="bday" ' |
|||
else |
|||
age = '' |
|||
classAge = '' |
|||
end |
end |
||
-- |
-- compilation du résultat |
||
local wikiText = wikiListe.concat( ' ' ) |
|||
local iso = fun.prepend(tostring(annee), '0', 4) .. "-" .. fun.prepend(tostring(num), '0', 2) |
|||
-- On ajoute un peu de sémantique. La date doit être dans le calendrier grégorien proleptique |
|||
if (jour ~= nil) then |
|||
-- ce formatage ne s'applique pas avant J.C. |
|||
iso = iso .. "-" .. fun.prepend(tostring(jour), '0', 2) |
|||
if wikiText ~= '' and ( gannee == nil or gannee > 0) then |
|||
wikiText = '<time '.. classAge .. 'datetime="' .. iso.concat( '-' ) .. '">' .. wikiText .. '</time>' |
|||
end |
end |
||
res = "<time datetime=\"" .. iso .. "\">" .. res .. "</time>" |
|||
return wikiText .. age |
|||
return res |
|||
end |
end |
||
Ligne 407 : | Ligne 574 : | ||
result = result .. " de l'an " .. fun.toRoman(arguments[1]) |
result = result .. " de l'an " .. fun.toRoman(arguments[1]) |
||
return result |
return result |
||
end |
|||
-- Voir Modèle:Âge |
|||
-- retourne l'age en fonction de la ou les dates fournies. La valeur retounée est de type 'number' |
|||
-- Parammètres : |
|||
-- 1, 2, 3 : année, mois jour de naissance (supposé dans le calendrier grégorien) |
|||
-- 4, 5, 6 : année, mois, joue du calcul (facultatif, par défaut la date UTC courante). |
|||
function fun.age( an, mn, jn, ac, mc, jc ) |
|||
local an = tonumber( an ) |
|||
if an == nil then |
|||
-- pas de message d'erreur qui risque de faire planter la fonction appelante |
|||
-- à elle de gérer ce retour. |
|||
return |
|||
end |
|||
-- les jours et mois sont par défaut égal à 1, pour pouvoir calculer un age même si la date est incompète. |
|||
local mn = tonumber( mn ) or 1 |
|||
local jn = tonumber( jn ) or 1 |
|||
local today = os.date( '!*t' ) |
|||
local ac = tonumber( ac ) or today.year |
|||
local mc = tonumber( mc ) or today.month |
|||
local jc = tonumber( jc ) or today.day |
|||
local age = ac - an |
|||
if mc < mn or ( mc == mn and jc < jn ) then |
|||
age = age - 1 |
|||
end |
|||
return age |
|||
end |
|||
function fun.modeleAge( frame ) |
|||
args = frame.getParent().args |
|||
local annee = args[1] or args['année'] |
|||
if annee == nil then |
|||
return erreurDate( "Il faut au minimum l'année pour calculer un âge" ) |
|||
end |
|||
local age = fun.age ( |
|||
args[1] or args['année'], |
|||
args[2] or args['mois'], |
|||
args[3] or args['jour'], |
|||
args[4], |
|||
args[5], |
|||
args[6] |
|||
) |
|||
if age then |
|||
return age |
|||
else |
|||
return erreurDate("les paramètres doivent être des chiffres" ) |
|||
end |
|||
end |
|||
-- calcul du jour julien à partir d'une date du calendrier grégorien |
|||
function fun.julianDay( year, month, day, hour, minute, second ) |
|||
local julian |
|||
julian = math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) * 1461 / 4 ) |
|||
- math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) / 100 ) |
|||
+ math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) / 400 ) |
|||
+ math.floor( ( math.fmod( month + 57609, 12 ) + 4 ) * 153 / 5 ) |
|||
+ day + ( hour or 12 ) / 24 + ( minute or 0 ) / 1440 + ( second or 0 ) / 86400 |
|||
- 32167.5 |
|||
return julian |
|||
end |
|||
-- calcul du jour julien à partir d'une date du calendrier julier |
|||
function fun.julianDayJulian( year, month, day, hour, minute, second ) |
|||
local julian |
|||
julian = math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) * 1461 / 4 ) |
|||
+ math.floor( ( math.fmod( month + 57609, 12 ) + 4 ) * 153 / 5 ) |
|||
+ day + ( hour or 12 ) / 24 + ( minute or 0 ) / 1440 + ( second or 0 ) / 86400 |
|||
- 32205.5 |
|||
return julian |
|||
end |
|||
-- calcul d'une date dans le calendrier Grégorien à partir du jour julien |
|||
function fun.jullianDayToGregorian( jd ) |
|||
local base = math.floor( jd + 32044.5 ) -- 1 March -4800 (proleptic Gregorian date) |
|||
local nCentury = math.floor( ( base * 4 + 3 ) / 146097 ) |
|||
local sinceCentury = base - math.floor( nCentury * 146097 / 4 ) |
|||
local nYear = math.floor( ( sinceCentury * 4 + 3 ) / 1461 ) |
|||
local sinceYear = sinceCentury - math.floor( nYear * 1461 / 4 ) |
|||
local nMonth = math.floor( ( sinceYear * 5 + 2 ) / 153 ) |
|||
local day = sinceYear - math.floor( ( nMonth * 153 + 2 ) / 5 ) + 1 |
|||
local month = nMonth - math.floor( nMonth / 10 ) * 12 + 3 |
|||
local year = math.floor( sinceYear / 306 ) + nYear + 100 * nCentury - 4800 |
|||
return year, month, day |
|||
end |
|||
function fun.jullianToGregorian( year, month, day ) |
|||
return fun.jullianDayToGregorian( fun.julianDayJulian( year, month, day ) ) |
|||
end |
|||
-- erreurModuleData affiche d'un message d'erreur si le Module:Langue/Data n'a pas été chargé correctement, |
|||
-- pour la page de discussion de la base de donnée et ceux qui veulent surveiller cette page. |
|||
function fun.erreurModuleData() |
|||
local success, resultat = pcall ( mw.loadData, 'Module:Date/Data' ) |
|||
if success == false then |
|||
local message = [[<strong class="error">Le chargement du module Date/Data génère une erreur : </strong><br />%s<br /> |
|||
<span class="error">Cette erreur doit être corrigée au plus vite car des milliers de page ne s'affichent pas correctement</span> |
|||
]] |
|||
return string.format( message, resultat ) |
|||
end |
|||
end |
|||
function fun.checkDataCat( frame ) |
|||
local category = frame.args[1] |
|||
local monthLinks = frame .args[2] == 'oui' |
|||
local all = frame.args[3] == 'oui' |
|||
local dataLink = mw.loadData( 'Module:Date/Data' ) |
|||
local wikiList = TableBuilder.new() |
|||
local currentYear = tonumber( os.date( '%Y' ) ) |
|||
local newSection |
|||
if monthLink then |
|||
newSection = '\n\n== %s ==\n\n=== Années ===\n{{Colonnes|taille=5|1=' |
|||
else |
|||
newSection ='\n\n== %s ==\n{{Colonnes|taille=5|1=' |
|||
end |
|||
for field, dataField in pairs( dataLink ) do |
|||
-- boucle sur tous les qualificatif ayant pour catégorie le premier paramère |
|||
if dataField.cat == category then |
|||
local monthInitialYear, initialYear |
|||
-- définition de l'année à partir de laquelle on va tester toutes les année / mois |
|||
if dataField.qualificatif == ' ' .. field then |
|||
if dataField.annee and dataField.annee.aucun and dataField.annee.aucun < currentYear then |
|||
local aucun = dataField.annee.aucun |
|||
initialYear = math.min( aucun - math.ceil( (currentYear - aucun) / 4 ), 1980 ) |
|||
else |
|||
initialYear = currentYear - 50 |
|||
end |
|||
if dataField.mois and dataField.mois.aucun and dataField.mois.aucun < currentYear then |
|||
local aucun = dataField.mois.aucun |
|||
monthInitialYear = math.min( aucun - math.ceil( (currentYear - aucun) / 4 ), currentYear - 8 ) |
|||
else |
|||
monthInitialYear = currentYear - 8 |
|||
end |
|||
elseif all then |
|||
-- si le paramètre 2 est défini on teste aussi tous les alias depuis 1980. |
|||
initialYear = currentYear - 50 |
|||
monthInitialYear = currentYear - 8 |
|||
end |
|||
-- création de l'ensembles des liens |
|||
if initialYear then |
|||
-- ajout de lien vers les pages annuelles de l'année en court + 5 jusqu'à initialYear |
|||
wikiList.insert( string.format( newSection, field ) ) |
|||
field = ' ' .. field |
|||
for year = ( currentYear + 5 ), initialYear, -1 do |
|||
wikiList.insert( '\n* [[' .. year .. field ..'|' .. year .. ']]' ) |
|||
end |
|||
wikiList.insert( '\n}}' ) |
|||
if monthLinks then |
|||
-- insertstion de liens vers les mois de l'année en court + 1 jusqu'à monthInitialYear |
|||
wikiList.insert( '\n\n=== Mois ===' ) |
|||
local month, sep |
|||
for year = ( currentYear + 1 ), monthInitialYear, -1 do |
|||
wikiList.insert( '\n* ' .. year .. ' : ' ) |
|||
sep = ' • ' |
|||
for j = 1, 12 do |
|||
month = ucfirst( liste_mois[j][1] ) .. ' ' |
|||
if j == 12 then sep = '' |
|||
end |
|||
wikiList.insert( '[[' .. month .. year .. ' ' .. field .. '|' .. ']]' .. sep ) |
|||
end |
|||
end |
|||
-- insertion de quelques date pour tester les éphémérides |
|||
wikiList.insert( '\n\n=== Jours ===' ) |
|||
wikiList.insert( '\n* [[1er janvier ' .. field .. ']]' ) |
|||
wikiList.insert( '\n* [[14 mars ' .. field .. ']]' ) |
|||
wikiList.insert( '\n* [[22 juin ' .. field .. ']]' ) |
|||
wikiList.insert( '\n* [[3 septembre ' .. field .. ']]' ) |
|||
end |
|||
end |
|||
end |
|||
end |
|||
return table.concat( wikiList ) |
|||
end |
end |
||
Version du 31 août 2013 à 01:30
Utilisation
Fonctions utilisables depuis un modèle
modeleDate(frame)
– affiche une date, optionnellement avec les liens les plus pertinents (précisions ci-dessous).dateISO(frame)
– similaire à modeleInscriptionDate mais la date est au format aaaa-mm-jj. Paramètres nommés année, mois, jour. Pour respecter l'ISO 8601 qui définit la date uniquement selon le calendrier grégorien, cette fonction ne retourne rien pour les dates avant 1583.dateInfobox(frame)
affiche une date avec les liens pertinents, gère correctement les paramètres contenant déjà un modèle date, ou avec du texte suivant la date (précisions ci-dessous). Prévu pour être utilisé dans les Infobox.dureeInfobox(frame)
affiche la durée entre deux dates, si elle n'est pas déjà incluse. Prévu pour être utilisé dans les Infobox.dateRepublicain(frame)
– affiche une date grégorienne au format républicain (sans liens). Paramètres 1=année, 2=mois, 3=jour.modeleAge(frame)
- retourne l'âge (nombre d'années) depuis une date ou entre deux dates. Paramètres 1=année, 2=mois, 3=jour, 4=année, 5=mois, 6=jour.erreurModuleData()
- retourne un message d'erreur si Module:Date/Data ne se charge pas correctement.checkDataCat(frame)
- retourne une liste de pages annuelle et mensuelle pour faciliter les mises à jour de Date/Data. Paramètres 1=cat, mois=liste de mois si 'oui', alias = liste tous les alias si 'oui'
Fonctions utilisables depuis un autre module
determinationMois( mois )
- à partir d'un nom de mois, de son numéro ou d'une abréviation, retourne, si le mois a bien été trouvé, son nom canonique et son numérodeterminationSaison( saison )
- à partir d'un nom de saison, retourne, si la saison a bien été trouvée, son nom canoniquedo_dayRank(arguments)
- Rang du jour dans l'année. Paramètre arguments = { année, mois, jour } ou { year = année, month = mois, day = jour }isLeapYear(year)
- retourne true si year est une année bissextile dans le calendrier grégorien.toRoman(number)
- transforme number en une chaine le représentant en « chiffres romains ».age( an, mn, jn, ac, mc, jc )
- similaire à modeleAge, mais les paramètres ne sont pas dans une tablejulianDay( year, month, day, hour, minute, second )
- retourne le jour julien de la date transmise, suivant le calendrier grégorien astronomique (avec année 0)julianDayJulian( year, month, day, hour, minute, second )
- retourne le jour julien d'une date du calendrier julien astronomique (avec année 0)julianDayToGregorian( jd )
- retourne trois variables année, mois, jour représentant la date du calendrier grégorien astronomique correspondant à ce jour julien.julianDayToJulian( jd )
- retourne trois variables année, mois, jour représentant la date du calendrier julien correspondant à ce jour julien.julianToGregorian( year, month, day )
- transforme une date du calendrier julien en date du calendrier grégorien.gregorianToJulian( year, month, day )
- transforme une date du calendrier grégorien en date du calendrier julien.
Modules externes dont ce module a besoin pour fonctionner
Date/Data
- Base de donnée permettant de ne pas tester les pages que l'on sait existantes, ou n'existant pas.TableBuilder
– Utilise.insert
et.concat
pour simplifier la syntaxe.
modeleDate( frame )
Paramètres
1
- jour ou vide - numérique, exception possible pour 1er ou 1er.2
- mois ou jour - numérique ou nom français ou anglais, éventuellement une abréviation courante.3
- année ou mois - Un nombre sera considéré comme année. Les années sont considérées comme suivant le calendrier grégorien après le 14 octobre 1582 (sauf si julien = 'oui') et le calendrier julien avant, sans année 0.4
- qualificatif ou année - texte correspondant à une page type « en photographie » pour « 2008 en photographie »5
- qualificatifage
ouâge
- non vide pour afficher l'âge (aucun âge n'est affiché pour les dates dans le futur)julien
- 'oui' pour que la date soit considérée comme suivant le calendrier julien après le 14 octobre 1582. La date grégorienne avec liens est affichée suivie de la date julienne entre parenthèses.compact
- 'oui' pour abréger le nom du mois.avJC
- 'non' pour ne pas afficher 'av. J.-C.' après l'année si elle représente une année avant Jésus-Christ. Utile pour éviter les répétitions.liens
- 'oui' pour forcer l'ajout de liens quand la date ne contient pas de qualificatif.nolinks
- 'oui' pour empêcher l'ajout de liens (a précédence surliens
).
Fonctionnement
- par défaut, le modèle n'ajoute des liens que si un qualificatif a été renseigné.
- le modèle cherche à afficher la date avec des liens vers les pages liées au qualificatif. S'il n'y a pas de page liée au qualificatif un lien sera fait vers la page générale.
- le premier paramètre est vide et le troisième correspond à un mois (texte uniquement), tous les paramètres sont considérés comme décalés et l'année ne sera pas affichée.
- s'il n'y a pas de page spécifique pour ce mois-année, le mois sera affiché lié avec le jour à l'éphéméride. Priorité est donnée à l'éphéméride du qualificatif sur le lien mois-année sans qualificatif.
- le modèle s'aide de la base de donnée Date/Data pour éviter d'utiliser la fonction mw.title (équivalent du parser #ifexist:).
- cette base permet de remplacer le qualificatif par une catégorie plus générique. Si le qualificatif est « en tennis », l'éphéméride et la page mensuelle sera liée au qualificatif « en sport ».
Fonction modeleDate
Motif testé | Chaîne testée | Module | Fonctions coûteuses modèle d'avant / module |
---|---|---|---|
date récente | 14|octobre|2001 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
date ancienne (1700 - 1943), jour =1 | 1|octobre|1842 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 1 |
date très ancienne (<1700), jour = 1er | 1|janvier|537 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
qualificatif qui n'est pas dans la base | 14|octobre|2010|en animation asiatique | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 1 |
date ancienne, qualificatif qui n'est pas dans la base | 14|octobre|1842|en animation asiatique | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 2 |
avec qualificatif | 14|Octobre|2001|en astronautique | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 3 / 0 |
avec qualificatif avec éphémérides | 14|octobre|2005|dans les chemins de fer | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 0 |
pas de jour | |octobre|2001 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
pas de jour avec qualificatif | |Octobre|2001|en astronautique | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 3 / 0 |
qualificatif avec page annuelle qui pourrait exister | 14|octobre|2006|en Égypte | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 1 |
qualificatif avec page mensuelle existante | 14|octobre|2008|en France | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 3 / 0 |
qualificatif avec page mensuelle qui pourrait exister | 14|octobre|2012|en France | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 1 |
qualificatif avec page annuelle et mensuelle qui pourrait exister | 14|octobre|2012|en économie | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 2 |
date ancienne avec qualificatif | 14|octobre|1845|en aéronautique | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 4 / 1 |
date négative | 13|octobre|-63 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
date av. J.-C. (orthographe de la page) | 1|octobre|63 av. J.-C. | Erreur Lua à la ligne 236 : attempt to call global 'erreurDate' (a nil value). | 1 / 0 |
date avJC (orthographe abrégée) | 13|octobre|63 avJC | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
date négative, paramètre pour cacher av. J.-C. | 13|octobre|-63|avJC=non | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
année invalide | 14|octobre|2001 en sport | Erreur Lua à la ligne 206 : attempt to call global 'erreurDate' (a nil value). | 1 / 0 |
jour + mois avec majuscule | 14|Octobre|2001 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
mois en abrégé | 14|oct.|2001 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
mois en chiffre | 14|10|2001 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
mois invalide | 14|otcobre|2001 | Erreur Lua à la ligne 223 : attempt to call global 'erreurDate' (a nil value). | 1 / 0 |
jour invalide | jeudi 14|octobre|2001 | Erreur Lua à la ligne 236 : attempt to call global 'erreurDate' (a nil value). | 1 / 0 |
jour invalide (trop grand pour le mois) | 31|septembre|2001 | Erreur Lua à la ligne 243 : attempt to call global 'erreurDate' (a nil value). | 1 / 0 |
uniquement l’année | ||2001 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
uniquement l’année avec qualificatif | ||2001|en littérature | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | 1 / 0 |
sans année | 14|octobre | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 0 / 0 |
jour uniquement | 14 | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 0 / 0 |
mois uniquement | |Octobre | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 0 / 0 |
sans argument | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | 0 / 0 | |
date du calendrier julien | 1|octobre|2001|julien=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | |
date du calendrier julien (changement de mois) | 25|octobre|2001|julien=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | |
date du calendrier julien (changement d'année) | 25|décembre|2001|julien=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | |
date de naissance | 14|octobre|2001|age=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
Comparaison avec {{date de naissance}}
- les fonctions coûteuses sont les mêmes que celles du modèle Date
- sans l'âge, voir comparaison avec {{Date}}
Motif testé | Chaîne testée | Modèle Date de naissance | Module |
---|---|---|---|
simple | 1|8|2006|âge=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
avec qualificatif | 1|août|2006|en Suisse|age=oui | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 270 : attempt to index field 'parametresPage' (a nil value). |
date ancienne | 2|1|598|age=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
l'an dernier | 2|1|2012|age=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
cette année | 2|1|2013|age=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
l'an prochain | 2|1|2014|age=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
sans jour | |8|2006|âge=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
annee seule | ||2006|âge=oui | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). | Erreur Lua à la ligne 260 : attempt to index field 'parametresPage' (a nil value). |
dateInfobox( frame )
Fonction destinée aux infobox, notamment pour afficher les dates de naissance et de mort. Les dates sont affichées avec des liens. Gère les cas où le paramètre contient déjà un modèle date. Le contenu du paramètre situé après la date (par exemple un lieu, une référence) est conservé.
Paramètres
- 1 : type de date à afficher (naissance / n, mort / m, ou date / d)
- 2 : Date ou date de naissance
- 3 : Date de mort si type n ou m
qualificatif
: suffixe des pages de date à lier (exemple : en musique)nolinks
: n'affiche pas de lienpréfixe
: préfixe à afficher s'il y a un jour (par défaut vide)préfixe sans jour
: préfixe à afficher s'il n'y a pas de jour (par défaut vide)
Ces paramètres doivent être directement dans le #invoke appelant la fonction.
Exemples
{{#invoke:Date|dateInfobox|date|13 juillet 1927}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|naissance|13 juillet 1927|}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|naissance|13 juillet 1927|14 mai 2017}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|naissance|30 juin 2017-}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|mort|13 juillet 1927|30 juin 2017}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|mort||30 juin 2017}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|mort|13 juillet 1927|}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|13 juillet 1927| qualificatif = en France}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|13 juillet 1927| préfixe = le}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|13 juillet 1927| préfixe = le | préfixe sans jour = en}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|juillet 1927| préfixe = le}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|juillet 1927| préfixe = le | préfixe sans jour = en}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|13 juillet [[1927]]}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|13 juillet [[1927 en France|1927]]}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.{{#invoke:Date|dateInfobox|date|{{date|13 juillet 1927|en France}}}}
→ Erreur de script : la fonction « dateInfobox » n’existe pas.
dureeInfobox( frame )
Fonction destinée aux infobox, pour afficher la durée entre deux dates, notamment pour un poste ou une fonction. Gère les cas où la durée est déjà spécifiée dans l'une des valeurs. La durée est préfixée d'un retour à la ligne (<br />
) et écrite en petit (<small>
).
Paramètres
- 1 : Date de début
- 2 : Date de fin (optionnelle, date du jour par défaut)
Ces paramètres doivent être directement dans le #invoke appelant la fonction.
Exemples
{{#invoke:Date|dureeInfobox|8 septembre 2022}}
→ Erreur de script : la fonction « dureeInfobox » n’existe pas.{{#invoke:Date|dureeInfobox|{{date|27 juin 1940-}}|{{date|6 septembre 1940}}}}
→ Erreur de script : la fonction « dureeInfobox » n’existe pas.
Voir aussi : les tests unitaires et ceux du bac à sable.
La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (modifier).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.
local fun = {}
-- génère une erreur
function fun.erreurDate(texte)
return '<span class="error">' .. (texte or "''aucune erreur indiquée''") .. "</span>"
end
-- nettoie un paramètre non nommé (vire les espaces au début et à la fin)
function fun.nettoie(texte)
if (texte == nil or texte == "" or type(texte) ~= "string") then
return ""
end
return mw.text.trim(texte)
end
-- fonction "#ifexist", en attendant que mw.title soit intégré et fournisse cette fonctionnalité
function fun.ifexist(page)
if (type(page) == "string" and page ~= "") then
return mw.title.new( page ).exists
end
end
-- Ajoute autant de caractère c que nécessaire à la chaîne str pour arriver à la ongeur length
function fun.prepend(str, c, length)
local lenstr = mw.ustring.len( str )
if lenstr < length then
str = mw.ustring.rep( c, length - lenstr)
end
return str
end
-- nettoie un paramètre non nommé (vire les espaces au début et à la fin)
-- retourne nil si le texte est vide ou n'est pas du texte. Attention c'est important pour les fonction qui l'utilise.
local function trim( texte )
if type( texte ) == "string" and texte ~= "" then
return mw.text.trim( texte )
end
end
local function ucfirst( str )
return mw.ustring.upper( mw.ustring.sub( str, 1, 1 ) ) .. mw.ustring.sub( str, 2 )
end
-- liste des mois, écriture exacte et simplifiée, en minuscule
local liste_mois = {
{ "janvier", "jan.", "janv.", "jan", "janv", "january", nJour = 31 },
{ "février", "fevrier", "fev.", "fev", "fév.", "fév", "february", nJour = 29 },
{ "mars", "mar.", "mar", "march", nJour = 31 },
{ "avril", "avr.", "avr", "apr", "april", nJour = 30 },
{ "mai", "may", nJour = 31 },
{ "juin", "jun", "june", nJour = 30 },
{ "juillet", "juil.", "juil", "juill.", "juill", "jul", "july", nJour = 31 },
{ "août", "aout","aou", "aug", "august", nJour = 31 },
{ "septembre", "sept.", "sept", "sep.", "sep", "september", nJour = 30 },
{ "octobre", "oct.", "oct", "october", nJour = 31 },
{ "novembre", "nov.", "nov", "november", nJour = 30 },
{ "décembre", "decembre", "déc.", "dec.", "dec", "déc", "december", nJour = 31 },
}
-- nom du mois à partir du numéro
function fun.nomDuMois( num )
if type( num ) ~= "number" or num < 1 or num > 12 then
return nil
end
return liste_mois[num][1]
end
-- valide que la chaîne passée est un mois valide.
-- retourne le nom complet ou nil si non reconnu
-- si reconnu, retourne aussi le numéro du mois [1-12]
function fun.valideMois( mois )
if type( mois ) ~= "string" then
return nil
end
local m = mw.ustring.lower( mois )
for i = 1, 12 do
local j = 1
while liste_mois[i][j] ~= nil do
if liste_mois[i][j] == m then
return liste_mois[i][1], i
end
j = j + 1
end
end
-- pas trouvé = return nil
end
-- determinationMois trouve le numéro du mois et son nom,
-- à partir de son nom, de son numéro ou d'une expression mathématique.
-- l'objet frame est facultatif, mais permet de tester si mois est une expression type '2+3'
function fun.determinationMois( mois, frame )
local num, nom
if tonumber( mois ) then
num = math.floor( math.fmod( tonumber( mois ) - 1, 12 ) ) + 1
elseif type( mois ) == "string" then
nom, num = fun.valideMois( mois )
if nom == nil and frame and frame.callParserFunction then
-- essai de détermination d'un nombre avec le parser #expr de Mediawiki.
-- la fonction s'appelle sans l'objet frame pour ne pas tourner en boucle.
nom, num = fun.determinationMois( frame:callParserFunction( '#expr', mois ) )
end
end
if num and not nom then
nom = liste_mois[num][1]
end
return nom, num
end
-- fonction interne à modeleDate, pour déterminer si on peut se passer de faire un ifexit
local function existDate( dataQualificatif, annee, mois )
local data
if mois then
data = dataQualificatif.mois
else
data = dataQualificatif.annee
end
if data == nil then
-- si data n'existe pas c'est que l'on considère qu'il n'y a pas de lien.
return
end
-- le qualificatif est remplacer par celui de la base de donnée, ce qui permet des alias.
local lien = annee .. ( dataQualificatif.qualificatif or '' )
local seul = annee
if mois then
lien = mois .. ' ' .. lien
seul = ucfirst( mois ) .. ' ' .. annee
end
if type( data.aucun ) == 'number' and annee <= (data.aucun or 0) then
-- si la l'année est dans la partie 'aucun' on teste s'il y a malgré tout un lien isolé
if type( data.seul ) == 'table' then
for i, v in ipairs( data.seul ) do
if seul == v then
return lien
end
end
end
-- partie aucun et pas de lien => nil
return nil
elseif type( data.tous ) == 'table'
and type( data.tous[1] ) == 'number'
and type( data.tous[2] ) == 'number'
and annee >= data.tous[1]
and annee <= data.tous[2]
then
-- l'année est dans la partie 'tous' donc on retourne le lien
return lien
end
-- l'annee n'est ni dans la partie aucun, ni dans la partie tous donc il faut tester si la page existe.
print( 'ifexist' )
if mw.title.new( lien ).exists then
return lien
end
end
-- émule le modèle {{m|Date}}.
-- Paramètres :
-- 1 : jour (numéro ou "1er"). optionnel, si absent pas de jour
-- 2 : mois (en toutes lettres)
-- 3 : année (nombre)
-- 4 : optionnel, spécialité de l'année
-- Comportement spécial ("truc à deux balles au lieu d'utiliser un
-- paramètre nommé du genre "sans année=oui"...") : si 1 est vide
-- mais que le reste est complet → on n'affiche pas l'année
function fun.modeleDate( frame )
local args = frame.args or frame
if args[1] == nil and args[3] == nil and frame.getParent then
args = frame:getParent().args
end
-- chargement de la base de donnée répertoriant certaines pages existant ou n'existant pas pour éviter les "ifexist".
local dataLiens
local success, resultat = pcall ( mw.loadData, 'Module:Date/Data' )
if success then
dataLiens = resultat
else
-- protection au cas ou le sous module serait mal modifié
dataLiens = { [''] = { mois = { aucun = 1000, tous = { 1938, 2013 } }, }, parametresPage = { } }
end
local annee, mois, numMois, jour
local decalage = 0
-- si pas de jour mais que args[2] est un mois on décale tout et on
-- n'affiche pas l'année
if trim( args[1] ) == nil and fun.valideMois( trim( args[3] ) ) ~= nil then
decalage = 1
end
-- on traite l'année
local bannee = trim( args[3 + decalage] )
if bannee then
annee = tonumber( bannee )
if annee == nil then
-- test si l'année contient av. J.-C.
annee = mw.ustring.match( mw.ustring.upper( bannee ), '^(%d+)%sAV%.?%s?J%.?%-?C' )
annee = tonumber( annee )
if annee then
annee = 0 - annee
else
return erreurDate( 'Année invalide (' .. bannee .. ')' )
end
end
else
annee = nil
end
-- on traite le mois
local bmois = trim (args[2 + decalage] )
if bmois then
mois, numMois = fun.valideMois( bmois )
if mois == nil then
-- on teste si le mois est fourni sous forme numérique
numMois = tonumber( bmois )
mois = fun.nomDuMois( numMois )
end
if mois == nil then
return erreurDate( 'Mois invalide (' .. bmois .. ')' )
else
-- on traite le jour si présent
local bjour = trim( args[1 + decalage] )
if bjour then
jour = tonumber( bjour )
if jour == nil then
if bjour == '1er'
or bjour == '<abbr class="abbr" title="Premier" >1<sup>er</sup></abbr>' -- correspond à {{1er}}
then
jour = 1
else
return erreurDate( 'Jour invalide (' .. bjour .. ')' )
end
end
-- on valide que le jour est correct
if jour < 1 or jour > 31 then
return erreurDate( 'Jour invalide (' .. bjour .. ')' )
elseif jour > liste_mois[numMois].nJour then
return erreurDate( 'Jour invalide (' .. bjour .. ' ' .. mois .. ')' )
-- l'année bisextile n'est pas testée pour accepter les dates juliennes.
end
else
-- S'il n'y a pas de jour on regarde si la première lettre du mois est en majuscule
if mw.ustring.match( bmois, '^%u' ) then
-- oui, on passe la première lettre en majuscule
mois = ucfirst( mois )
end
-- s'il n'y a pas d'année non plus on retourne le mois simple
end
end
-- else
-- return erreurDate("Le mois est obligatoire")
end
-- on traite le champs optionnel
local qualificatif = trim( args[4 + decalage] ) or dataLiens.parametresPage.qualificatif
-- on traite l'age
local age = trim( args['âge'] or args['age'] )
age = age and fun.age( annee, numMois, jour )
-- on traite le calendrier
local gannee, gmois, gjour = annee, numMois, jour -- date suivant le calendrier grégorien pour <time>
local jannee, jmois, jjour, julien = annee, mois, jour -- servira éventuellement à a affiché la date selon le calendrier julien
local julien1, julien2, julien3 = '', '', '' -- servira éventuellement à a affiché des parenthèses
local julien = trim( string.lower( args.julien or dataLiens.parametresPage.julien or '' ) )
if annee and jour then
local amj = annee * 10000 + numMois * 100 + jour
if amj < 15821014 then
gannee, gmois, gjour = fun.jullianToGregorian( annee, numMois, jour )
elseif julien == 'oui' then
gannee, gmois, gjour = fun.jullianToGregorian( annee, numMois, jour )
annee, numMois, jour = gannee, liste_mois[gmois][1], gjour
end
end
-- on génère le résultat
-- Déclarations des variables
local wikiListe = TableBuilder.new() -- reçois le texte affiché pour chaque paramètre
local iso = TableBuilder.new() -- reçois le format date ISO de ce paramètre
local dataQualificatif = dataLiens[qualificatif or '']
if type( dataQualificatif ) ~= 'table' then
-- si le qualifiquatif n'est pas dans la base de donnée, on crée une table minimum,
-- qui imposera un test sur l'annee, mais considère qu'il n'y a pas de lien sur le jour ou le mois
dataQualificatif = { qualificatif = ' ' .. qualificatif, annee = { } }
end
-- Date julienne
if jjour ~= jour then
wikiListe.insert( '<abbr title="selon le calendrier julien" >' .. jjour )
julien1 = '('
if jannee ~= annee then
wikiListe.insert( jmois )
wikiListe.insert( jannee .. '</abbr>' )
julien3 = ')'
else
wikiListe.insert( jmois .. '</abbr>' )
julien2 = ')'
end
end
-- le jour si présent
if jour then
local lien = jour .. ' ' .. mois
if jour == 1 then
jour = '<abbr class="abbr" title="premier">1<sup>er</sup></abbr>'
end
if jour == 1 then
lien = '1er ' .. mois
end
lien = lien .. ( dataQualificatif.jour or '' )
wikiListe.insert( julien1 .. '[[' .. lien .. '|' .. jour .. ']]' )
wikiListe.insert( julien1 .. '[[' .. lien .. '|' .. jour .. ' '.. mois .. ']]' .. julien2 )
iso.insert( 1, string.sub( '0' .. gjour, -2 ) )
end
-- le mois
if mois then
local lien
if annee then
lien = existDate( dataQualificatif, annee, mois )
if lien == nil and qualificatif and (jour == nil or dataQualificatif.jour == nil) then
-- test nouveau test sans le qualificatif uniquement s'il n'y a pas d'éphémérides pour ce qualificatif.
lien = existDate( dataLiens[''].mois, annee, mois )
end
end
if lien then
-- s'il y a un lien on retire le lien affichant 'jour mois' pour ajouter '[[mois annee|mois']]
wikiListe.remove()
wikiListe.insert( '[[' .. lien .. '|' .. mois .. ']]' .. julien2 )
else
-- sinon on retire le lien affichant 'jour' pour ne garder que le lien 'jour mois'
wikiListe.remove( #wikiListe - 1 )
-- s'il n'y avait pas je jour, la liste est vide mais ça ne pose pas de problème
-- sauf si l'année n'est pas affichée :
if #wikiListe == 0 and ( annee == nil or decalage > 0 ) then
return mois
end
end
iso.insert( 1, string.sub( '0' .. gmois, -2 ) )
end
-- l'année
if annee and decalage == 0 then -- seulement si on doit l'affichée
local lien = existDate( dataQualificatif, annee )
local texte = annee
if annee < 0 then
local annneeAvJc = 0 - annee
lien = lien or ( annneeAvJc .. ' av. J.-C.' )
local avJC = trim( string.lower( args.avJC or dataLiens.parametresPage.avJC or '' ) )
if args.avJC == 'non' then
texte = annneeAvJc
else
texte = annneeAvJc .. ' <abbr class="abbr" title="'
.. annneeAvJc .. ' avant Jésus-Christ">av. J.-C.</abbr>'
end
end
lien = lien or annee
if mois and #wikiListe == 0 then
texte = mois .. ' ' .. texte
end
wikiListe.insert( '[[' .. lien .. '|' .. texte .. ']]' .. julien3 )
iso.insert( 1, string.sub( '000' .. annee , -4 ) )
end
-- l'age
local classAge
if type( age ) == 'number' and age >= 0 then
if age == 0 then
age = '<span class="noprint"> (moins d\'1 an)</span>'
elseif age == 1 then
age = '<span class="noprint"> (1 an)</span>'
else
age = '<span class="noprint"> (' .. age .. 'ans)</span>'
end
classAge = 'class="bday" '
else
age = ''
classAge = ''
end
-- compilation du résultat
local wikiText = wikiListe.concat( ' ' )
-- On ajoute un peu de sémantique. La date doit être dans le calendrier grégorien proleptique
-- ce formatage ne s'applique pas avant J.C.
if wikiText ~= '' and ( gannee == nil or gannee > 0) then
wikiText = '<time '.. classAge .. 'datetime="' .. iso.concat( '-' ) .. '">' .. wikiText .. '</time>'
end
return wikiText .. age
end
-- voir émule le modèle:Inscription date
-- la détection des arguments permet d'utilisé la fonction depuis un modèle, depuis invoke, ou depuis une autre fonction.
-- pour facilité l'écriture de lua, annee (sans accent) est accepté lors de l'appel depuis lua.
function fun.modeleInscriptionDate(frame)
local annee, mois, jour
if frame.getParent then
annee = frame:getParent().args ['année'] or frame.args ['année'] or frame.args.annee or ''
mois = frame:getParent().args.mois or frame.args.mois or ''
jour = frame:getParent().args.jour or frame:getParent().args ['quantième'] or frame.args.jour or ''
else
annee = frame ['année'] or frame.annee or ''
mois = frame.mois or ''
jour = frame.jour or ''
end
if annee == '' then
-- si annee n'est pas précisé, on utilise la paramètre date
annee = frame.getParent and (frame:getParent().args.date or frame.args.date) or frame.date or ''
if annee == '' then
return ''
else
return '<span class="nowrap">' .. annee .. '</span>'
end
else
-- si l'année est renseigné, on essaye de trouver le mois
mois = fun.determinationMois (mois, frame)
if mois then
mois = mois .. ' '
if jour ~= '' then
-- si le mois est valide on détermine le jour
jour = tonumber(jour) or jour -- suppresion des 0 qui trainent
if jour == 1 or jour == '1er' then
jour = '<abbr class="abbr" title="Premier">1<sup>er</sup></abbr>'
end
jour = jour .. ' '
end
return jour .. mois .. annee
else
return annee
end
end
end
-- la fonction dateISO renvoie un date au format aaaa-mm-jj (sans liens)
-- l'année peut être sous la forme 2013 ou [[2013 en litérature|2013]]
-- le mois peut être en lettre ou en chiffres
-- le jour peut être sous la forme '05', '{{1er}}' ou 'vendredi 13'
function fun.dateISO(frame)
local annee, mois, jour
if frame.getParent then
annee = frame:getParent().args ['année'] or frame.args ['année'] or frame.args.annee or ''
mois = frame:getParent().args.mois or frame.args.mois or ''
jour = frame:getParent().args.jour or frame:getParent().args ['quantième'] or frame.args.jour or ''
else
annee = frame ['année'] or frame.annee or ''
mois = frame.mois or ''
jour = frame.jour or ''
end
annee = tonumber ( annee ) or string.match ( annee, '%D(-? ?%d?%d?%d%d)%D')
if annee then
annee = fun.prepend ( tostring ( annee ), '0', 4 )
local nomMois, numMois = fun.determinationMois( mois, frame )
if numMois then
if numMois < 10 then
mois = '-0' .. numMois
else
mois = '-' .. numMois
end
local bjour = tonumber(jour) or tonumber( string.match ( jour, '%D?(%d?%d)%D?') )
if bjour then
if bjour < 10 then
jour = '-0' .. bjour
else
jour = '-' .. bjour
end
else
jour = ''
end
else
mois = ''
jour = ''
end
return annee .. mois .. jour
end
end
-- Rang du jour dans l'année
-- Usage : do_dayRank{année,mois,jour}
function fun.do_dayRank(arguments)
local yr = tonumber(arguments.year or arguments[1]) or 1
local mt = tonumber(arguments.month or arguments[2]) or 1
local dy = tonumber(arguments.day or arguments[3]) or 1
-- Rangs des premiers des mois
local ranks = {0,31,59,90,120,151,181,212,243,273,304,334}
local rank = (ranks[mt] or 0) + dy - 1
if(fun.isLeapYear(yr) and (mt >= 3)) then
rank = rank+1
end
return rank
end
-- Nombre de jours entre deux années (du 1er janvier au 1er janvier)
-- Suit le calendrier grégorien
function fun.do_daysBetween(arguments)
local yr1 = tonumber(arguments[1]) or 0
local yr2 = tonumber(arguments[2]) or 0
return fun.daysSinceOrigin(yr2) - fun.daysSinceOrigin(yr1)
end
-- Nombre de jours depuis l'année 1 (du 1er janvier au 1er janvier)
function fun.daysSinceOrigin(year)
local yr = year-1
return 365*yr + math.floor(yr/4) - math.floor(yr/100) + math.floor(yr/400)
end
-- Test d'année bissextile
function fun.isLeapYear(year)
local yr = tonumber(year) or 1
return (yr%4 == 0) and ((yr%100 ~= 0) or (yr%400 == 0))
end
-- Conversion d'un nombre en chiffres romains
function fun.toRoman(number)
local n = math.floor(number)
local letters = {"I","V","X","L","C","D","M","",""}
local pattern = {"","0","00","000","01","1","10","100","1000","02"}
local result = ""
if(n<=0 or n>=4000) then
result = "---"
else
for i=1,7,2 do
p = pattern[n%10 + 1]
for j=0,2 do
p = string.gsub(p,tostring(j),letters[i+j])
end
result = p .. result
n = math.floor(n/10)
end
end
return result
end
-- Conversion et affichage d'une date dans le calendrier républicain
function fun.dateRepublicain(frame)
local pframe = frame:getParent()
local arguments = pframe.args
return fun.formatRepCal(fun.do_toRepCal(arguments))
end
-- Calcul d'une date dans le calendrier républicain
-- On suppose que les années 4n+3 sont sextiles (3, 7, 11...)
function fun.do_toRepCal(arguments)
local yr = tonumber(arguments.year or arguments[1]) or 2000
-- rang absolu du jour demandé, le jour 0 étant le 22 septembre 1792 (1er jour de l'an I)
local repDays = fun.do_dayRank(arguments) + fun.do_daysBetween{1792,yr} - fun.do_dayRank{1792,9,22}
local repYear = math.floor((repDays+731)/365.25) - 1
local repDayRank = repDays - 365*(repYear-1) - math.floor(repYear/4)
local repMonth, repDay = math.floor(repDayRank/30)+1, (repDayRank%30)+1
return {repYear, repMonth, repDay}
end
-- Formatage d'une date selon le calendrier républicain
-- Usage : fun.formatRepCal{année,mois,jour}
function fun.formatRepCal(arguments)
local months = {"Vendémiaire","Brumaire","Frimaire","Nivôse","Pluviôse","Ventôse","Germinal","Floréal","Prairial","Messidor","Thermidor","Fructidor"}
local extras = {"de la vertu","du génie","du travail","des récompenses","de l'opinion","de la révolution"}
local result = ""
if(arguments[2] < 13) then
result = result .. tostring(arguments[3]) .. " " .. months[arguments[2]]
else
result = result .. "jour " .. extras[arguments[3]]
end
result = result .. " de l'an " .. fun.toRoman(arguments[1])
return result
end
-- Voir Modèle:Âge
-- retourne l'age en fonction de la ou les dates fournies. La valeur retounée est de type 'number'
-- Parammètres :
-- 1, 2, 3 : année, mois jour de naissance (supposé dans le calendrier grégorien)
-- 4, 5, 6 : année, mois, joue du calcul (facultatif, par défaut la date UTC courante).
function fun.age( an, mn, jn, ac, mc, jc )
local an = tonumber( an )
if an == nil then
-- pas de message d'erreur qui risque de faire planter la fonction appelante
-- à elle de gérer ce retour.
return
end
-- les jours et mois sont par défaut égal à 1, pour pouvoir calculer un age même si la date est incompète.
local mn = tonumber( mn ) or 1
local jn = tonumber( jn ) or 1
local today = os.date( '!*t' )
local ac = tonumber( ac ) or today.year
local mc = tonumber( mc ) or today.month
local jc = tonumber( jc ) or today.day
local age = ac - an
if mc < mn or ( mc == mn and jc < jn ) then
age = age - 1
end
return age
end
function fun.modeleAge( frame )
args = frame.getParent().args
local annee = args[1] or args['année']
if annee == nil then
return erreurDate( "Il faut au minimum l'année pour calculer un âge" )
end
local age = fun.age (
args[1] or args['année'],
args[2] or args['mois'],
args[3] or args['jour'],
args[4],
args[5],
args[6]
)
if age then
return age
else
return erreurDate("les paramètres doivent être des chiffres" )
end
end
-- calcul du jour julien à partir d'une date du calendrier grégorien
function fun.julianDay( year, month, day, hour, minute, second )
local julian
julian = math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) * 1461 / 4 )
- math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) / 100 )
+ math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) / 400 )
+ math.floor( ( math.fmod( month + 57609, 12 ) + 4 ) * 153 / 5 )
+ day + ( hour or 12 ) / 24 + ( minute or 0 ) / 1440 + ( second or 0 ) / 86400
- 32167.5
return julian
end
-- calcul du jour julien à partir d'une date du calendrier julier
function fun.julianDayJulian( year, month, day, hour, minute, second )
local julian
julian = math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) * 1461 / 4 )
+ math.floor( ( math.fmod( month + 57609, 12 ) + 4 ) * 153 / 5 )
+ day + ( hour or 12 ) / 24 + ( minute or 0 ) / 1440 + ( second or 0 ) / 86400
- 32205.5
return julian
end
-- calcul d'une date dans le calendrier Grégorien à partir du jour julien
function fun.jullianDayToGregorian( jd )
local base = math.floor( jd + 32044.5 ) -- 1 March -4800 (proleptic Gregorian date)
local nCentury = math.floor( ( base * 4 + 3 ) / 146097 )
local sinceCentury = base - math.floor( nCentury * 146097 / 4 )
local nYear = math.floor( ( sinceCentury * 4 + 3 ) / 1461 )
local sinceYear = sinceCentury - math.floor( nYear * 1461 / 4 )
local nMonth = math.floor( ( sinceYear * 5 + 2 ) / 153 )
local day = sinceYear - math.floor( ( nMonth * 153 + 2 ) / 5 ) + 1
local month = nMonth - math.floor( nMonth / 10 ) * 12 + 3
local year = math.floor( sinceYear / 306 ) + nYear + 100 * nCentury - 4800
return year, month, day
end
function fun.jullianToGregorian( year, month, day )
return fun.jullianDayToGregorian( fun.julianDayJulian( year, month, day ) )
end
-- erreurModuleData affiche d'un message d'erreur si le Module:Langue/Data n'a pas été chargé correctement,
-- pour la page de discussion de la base de donnée et ceux qui veulent surveiller cette page.
function fun.erreurModuleData()
local success, resultat = pcall ( mw.loadData, 'Module:Date/Data' )
if success == false then
local message = [[<strong class="error">Le chargement du module Date/Data génère une erreur : </strong><br />%s<br />
<span class="error">Cette erreur doit être corrigée au plus vite car des milliers de page ne s'affichent pas correctement</span>
]]
return string.format( message, resultat )
end
end
function fun.checkDataCat( frame )
local category = frame.args[1]
local monthLinks = frame .args[2] == 'oui'
local all = frame.args[3] == 'oui'
local dataLink = mw.loadData( 'Module:Date/Data' )
local wikiList = TableBuilder.new()
local currentYear = tonumber( os.date( '%Y' ) )
local newSection
if monthLink then
newSection = '\n\n== %s ==\n\n=== Années ===\n{{Colonnes|taille=5|1='
else
newSection ='\n\n== %s ==\n{{Colonnes|taille=5|1='
end
for field, dataField in pairs( dataLink ) do
-- boucle sur tous les qualificatif ayant pour catégorie le premier paramère
if dataField.cat == category then
local monthInitialYear, initialYear
-- définition de l'année à partir de laquelle on va tester toutes les année / mois
if dataField.qualificatif == ' ' .. field then
if dataField.annee and dataField.annee.aucun and dataField.annee.aucun < currentYear then
local aucun = dataField.annee.aucun
initialYear = math.min( aucun - math.ceil( (currentYear - aucun) / 4 ), 1980 )
else
initialYear = currentYear - 50
end
if dataField.mois and dataField.mois.aucun and dataField.mois.aucun < currentYear then
local aucun = dataField.mois.aucun
monthInitialYear = math.min( aucun - math.ceil( (currentYear - aucun) / 4 ), currentYear - 8 )
else
monthInitialYear = currentYear - 8
end
elseif all then
-- si le paramètre 2 est défini on teste aussi tous les alias depuis 1980.
initialYear = currentYear - 50
monthInitialYear = currentYear - 8
end
-- création de l'ensembles des liens
if initialYear then
-- ajout de lien vers les pages annuelles de l'année en court + 5 jusqu'à initialYear
wikiList.insert( string.format( newSection, field ) )
field = ' ' .. field
for year = ( currentYear + 5 ), initialYear, -1 do
wikiList.insert( '\n* [[' .. year .. field ..'|' .. year .. ']]' )
end
wikiList.insert( '\n}}' )
if monthLinks then
-- insertstion de liens vers les mois de l'année en court + 1 jusqu'à monthInitialYear
wikiList.insert( '\n\n=== Mois ===' )
local month, sep
for year = ( currentYear + 1 ), monthInitialYear, -1 do
wikiList.insert( '\n* ' .. year .. ' : ' )
sep = ' • '
for j = 1, 12 do
month = ucfirst( liste_mois[j][1] ) .. ' '
if j == 12 then sep = ''
end
wikiList.insert( '[[' .. month .. year .. ' ' .. field .. '|' .. ']]' .. sep )
end
end
-- insertion de quelques date pour tester les éphémérides
wikiList.insert( '\n\n=== Jours ===' )
wikiList.insert( '\n* [[1er janvier ' .. field .. ']]' )
wikiList.insert( '\n* [[14 mars ' .. field .. ']]' )
wikiList.insert( '\n* [[22 juin ' .. field .. ']]' )
wikiList.insert( '\n* [[3 septembre ' .. field .. ']]' )
end
end
end
end
return table.concat( wikiList )
end
return fun