« Module:Date » : différence entre les versions

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
m modifications proposées par Hunsu sur WP:DIPP
m demandé sur WP:DIPP
Ligne 171 : Ligne 171 :
annee = 0 - annee
annee = 0 - annee
else
else
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
return Outils.erreur( 'Année invalide (' .. bannee .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|A]]')
if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
return Outils.erreur( 'Année invalide (' .. bannee .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|A]]')
else
return Outils.erreur( 'Année invalide (' .. bannee .. ')')
end
end
end
end
end
Ligne 188 : Ligne 193 :
end
end
if mois == nil then
if mois == nil then
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
return Outils.erreur( 'Mois invalide (' .. bmois .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|M]]' )
if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
return Outils.erreur( 'Mois invalide (' .. bmois .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|M]]')
else
return Outils.erreur( 'Mois invalide (' .. bmois .. ')')
end
else
else
Ligne 202 : Ligne 212 :
jour = 1
jour = 1
else
else
return Outils.erreur( 'Jour invalide (' .. bjour .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|J]]' )
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
return Outils.erreur( 'Jour invalide (' .. bjour .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|J]]')
else
return Outils.erreur( 'Jour invalide (' .. bjour .. ')')
end
end
end
end
end
Ligne 209 : Ligne 224 :
return Outils.erreur( 'Jour invalide (' .. bjour .. ')' )
return Outils.erreur( 'Jour invalide (' .. bjour .. ')' )
elseif jour > liste_mois[numMois].nJour then
elseif jour > liste_mois[numMois].nJour then
return Outils.erreur( 'Jour invalide (' .. bjour .. ' ' .. mois .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|J]]' )
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
return Outils.erreur( 'Année invalide (' .. bjour .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|J]]')
else
return Outils.erreur( 'Année invalide (' .. bjour .. ')')
end
-- l'année bisextile n'est pas testée pour accepter les dates juliennes.
-- l'année bisextile n'est pas testée pour accepter les dates juliennes.
end
end

Version du 12 janvier 2014 à 22:56

Attention, certaines fonctions de ce module sont utilisées par les modèles {{ouvrage}}, {{article}} et {{archives}} (100 000 pages).

Utilisation

Fonctions utilisables depuis un modèle

  • modeleDate(frame) – affiche une date avec les liens les plus pertinents (précisions ci-dessous).
  • modeleInscriptionDate(frame) – affiche une date correctement formatée, sans lien. L'année est obligatoire. Paramètres nommés année, mois, jour. (utilisé par module Biblio). Étonnamment elle se trouve implémentée en réalité dans Module:Biblio/Commun.
  • 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.
  • 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ée) 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

  • nomDuMois( num ) – retourne le nom français du mois n° num.
  • valideMois( mois ) – retourne le nom français et le n° de mois (nom français, abrégé, anglais, ou nombre entre 1 et 12).
  • determinationMois( mois, frame ) - similaire à valideMois, mais le numéro du mois n'est pas limité (14 → février), et peut même être une expression si un objet frame est fourni ( 6 + 3 → septembre )
  • do_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 table
  • julianDay( 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 Modèle: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 - qualificatif
  • age 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.
  • 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.
  • paramètres page - Si un modèle {{date}} contient ce paramètre, les paramètres julien, avJC et qualificatif seront appliqués à toutes les dates de la page, sauf si une autre valeur de ces paramètres est indiquée. Le modèle date qui contient ce paramètre n'a pas besoin d'être affiché par le module Date, et peut être en commentaire dans la page. La page doit être purgée pour que ce paramètre soit pris en compte.
  • qualificatif - qualificatif à appliquer sur toute la page. Ne fonctionne qu'en liaison avec le paramètre paramètres page

Fonctionnement

  • 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 ».
  • pour éviter de répéter le même qualificatif sur toute les dates de la page, il suffit d'avoir quelque part dans le texte de la page, même en commentaire mais pas amené par un modèle, le texte {{Date|paramètres page= |qualificatif= mon qualificatif}}. Le modèle peut contenir d'autre paramètres. Seul le premier modèle date contenant ce paramètre sera pris en compte.

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 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
date ancienne (1700 - 1943), jour =1 1|octobre|1842 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 1
date très ancienne (<1700), jour = 1er 1|janvier|537 Erreur Lua à la ligne 248 : 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 258 : 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 258 : attempt to index field 'parametresPage' (a nil value). 4 / 2
avec qualificatif 14|Octobre|2001|en astronautique Erreur Lua à la ligne 258 : 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 258 : attempt to index field 'parametresPage' (a nil value). 4 / 0
pas de jour |octobre|2001 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
pas de jour avec qualificatif |Octobre|2001|en astronautique Erreur Lua à la ligne 258 : 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 258 : attempt to index field 'parametresPage' (a nil value). 4 / 1
qualificatif avec page mensuelle existante 14|octobre|2008|en France Erreur Lua à la ligne 258 : 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 258 : 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 258 : attempt to index field 'parametresPage' (a nil value). 4 / 2
date ancienne avec qualificatif 14|octobre|1845|en aéronautique Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 4 / 1
date négative 13|octobre|-63 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
date av. J.-C. (orthographe de la page) 1|octobre|63 av. J.-C. Jour invalide (Modèle:1er) 1 / 0
date avJC (orthographe abrégée) 13|octobre|63 avJC Erreur Lua à la ligne 248 : 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 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
année invalide 14|octobre|2001 en sport Année invalide (2001 en sport) 1 / 0
jour + mois avec majuscule 14|Octobre|2001 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
mois en abrégé 14|oct.|2001 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
mois en chiffre 14|10|2001 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
mois invalide 14|otcobre|2001 Mois invalide (otcobre) 1 / 0
jour invalide jeudi 14|octobre|2001 Jour invalide (jeudi 14) 1 / 0
jour invalide (trop grand pour le mois) 31|septembre|2001 Année invalide (31) 1 / 0
uniquement l’année ||2001 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 1 / 0
uniquement l’année avec qualificatif ||2001|en littérature Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 1 / 0
sans année 14|octobre Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 0 / 0
jour uniquement 14 Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 0 / 0
mois uniquement |Octobre Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 0 / 0
sans argument Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value). 0 / 0
date du calendrier julien 1|octobre|2001|julien=oui Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
date du calendrier julien (changement de mois) 25|octobre|2001|julien=oui Erreur Lua à la ligne 248 : 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 248 : attempt to index field 'parametresPage' (a nil value).
date de naissance 14|octobre|2001|age=oui Erreur Lua à la ligne 248 : 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 Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
avec qualificatif 1|août|2006|en Suisse|age=oui Modèle:Date de naissance Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value).
date ancienne 2|1|598|age=oui Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
l'an dernier 2|1|2012|age=oui Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
cette année 2|1|2013|age=oui Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
l'an prochain 2|1|2014|age=oui Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
sans jour |8|2006|âge=oui Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).
annee seule ||2006|âge=oui Modèle:Date de naissance Erreur Lua à la ligne 248 : attempt to index field 'parametresPage' (a nil value).

Comparaison avec {{date sport}}

  • lorsqu'il n'y a pas de qualificatif, « en sport » est ajouté pour tester le module.
Motif testé Chaîne testée Modèle Date sport Module Fonctions coûteuses
modèle / module
simple 1|2|1980 Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 1 / 0
avec qualificatif 12|2|1980|en gymnastique Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 2 / 0
qualificatif avec page possible pour cette année 12|2|1977|en gymnastique Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 3 / 1
avec qualificatif et âge 12|2|1980|en gymnastique|age=oui Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 2 / 0
date ancienne 12|2|1843 Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 1 / 0
date récente avec page mensuelle 12|2|2006 Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 1 / 0
date récente avec page mensuelle et qualif 12|2|2006|en gymnastique Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 2 / 0
date trop récente sans page mensuelle 1|8|2013 Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 1 / 1
date trop récente sans page mensuelle
et qualif avec page annuelle possible
1|8|2013|en gymnastique Modèle:Date sport Erreur Lua à la ligne 258 : attempt to index field 'parametresPage' (a nil value). 3 / 2


Modèle:Projet Scribunto

local fun = {}

local TableBuilder = require( 'Module:TableBuilder' )
local Outils = require( 'Module:Outils' )


-- 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 trim = Outils.trim

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( mw.text.trim( 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 type( data ) ~= 'table' 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
    local aucun = tonumber( data.aucun )
    if aucun and annee <= aucun 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 or seul == tonumber( v ) then
                    return lien
                end
            end
        end
        -- partie aucun et pas de lien => nil
        return nil
    elseif type( data.tous ) == 'table' then
        local tous1, tous2 = tonumber( data.tous[1] ), tonumber( data.tous[2] )
        if tous1 and tous2 and annee >= tous1 and annee <= tous2 then
            -- l'année est dans la partie 'tous' donc on retourne le lien
            return lien
        end
    end
    -- l'annee n'est ni dans la partie aucun, ni dans la partie tous donc il faut tester si la page existe.
    mw.log( 'ifexist : ' .. lien )
    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 = Outils.extractArgs( frame )
    
    -- 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 = args[3 + decalage]
    if Outils.notEmpty( bannee ) then
        annee = tonumber( bannee )
        if annee == nil and type( bannee ) == 'string'  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
            	local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
       			if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
               		return Outils.erreur( 'Année invalide (' .. bannee .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|A]]')
               else
               		return Outils.erreur( 'Année invalide (' .. bannee .. ')')
               end
            end
        end
    else
        annee = nil
    end

    -- on traite le mois
    local bmois = args[2 + decalage]
    if Outils.notEmpty( 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 
            local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
       			if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
               		return Outils.erreur( 'Mois invalide (' .. bmois .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|M]]')
               else
               		return Outils.erreur( 'Mois invalide (' .. bmois .. ')')
               	end
        else
        
            -- on traite le jour si présent
            local bjour = args[1 + decalage]
            if Outils.notEmpty( bjour ) then
                jour = tonumber( bjour )
                if jour == nil and type( bjour ) == 'string' then
                	bjour = mw.text.trim( bjour )
                    if bjour == '1er' 
                        or bjour == '<abbr class="abbr" title="Premier" >1<sup>er</sup></abbr>' -- correspond à {{1er}}
                    then
                        jour = 1
                    else
                        local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
       					if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
               				return Outils.erreur( 'Jour invalide (' .. bjour .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|J]]')
		               	else
               				return Outils.erreur( 'Jour invalide (' .. bjour .. ')')
               			end
                    end
                end
                -- on valide que le jour est correct
                if jour < 1 or jour > 31 then
                    return Outils.erreur( 'Jour invalide (' .. bjour .. ')' )
                elseif jour > liste_mois[numMois].nJour then
                    local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
       				if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
               			return Outils.erreur( 'Année invalide (' .. bjour .. ')[[Catégorie:Page utilisant le modèle date avec une syntaxe erronée|J]]')
               		else
               			return Outils.erreur( 'Année invalide (' .. bjour .. ')')
               		end
                    -- 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 Outils.erreur("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.julianToGregorian( annee, numMois, jour )
        elseif julien == 'oui' then  
            gannee, gmois, gjour = fun.julianToGregorian( 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
    local dataCat = dataLiens[dataQualificatif.cat]
    if type( dataCat ) ~= 'table' or dataCat == dataQualificatif then
        dataCat = { qualificatif = '' }
    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
    local qualifJour = ''
    if jour then
        -- éphémérides du qualificatif, ou de sa catégorie, ou générale.
        qualifJour = dataQualificatif.jour and dataQualificatif.qualificatif
            or dataCat.jour and dataCat.qualificatif
            or ''
        local lien = jour .. ' ' .. mois .. ' ' .. qualifJour
        if jour == 1 then
            jour = '<abbr class="abbr" title="premier">1<sup>er</sup></abbr>'
            lien = '1er ' .. mois .. ' ' .. qualifJour
        end
        -- s'il n'y a pas de lien sur le mois, il sera affiché avec le jour. 
        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 ) or existDate( dataCat, annee, mois )
            if lien == nil and qualificatif and qualifJour == '' then
                -- test nouveau test sans le qualificatif uniquement s'il n'y a pas d'éphémérides pour ce qualificatif.
                lien = existDate( dataLiens[''], 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 ) or existDate( dataCat, 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 .. '&nbsp;<abbr class="abbr" title="' 
                    .. annneeAvJc .. ' avant Jésus-Christ">av.&nbsp;J.-C.</abbr>'
            end
        end
        lien = lien or annee
        if mois and #wikiListe == 0 then
            -- si le mois n'a pas de lien et n'est pas affiché avec le jour, il est affiché avec l'année.
            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( '&nbsp;' )
    -- 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.inscriptionDate( frame )
	local args = Outils.extractArgs( frame )
	local annee = Outils.notEmpty( args['année'], args.annee, args.year )
	if annee then
		-- si l'année est renseigné, on essaye de trouver le mois
		local mois = Outils.notEmpty( args.mois, args.month )
		
		if mois then
			mois = fun.determinationMois( mois, frame ) or mois
			local jour = Outils.notEmpty( args.jour, args.day, args['quantième'] )
			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
				return jour .. '&nbsp;' .. mois .. '&nbsp;' .. annee
			else
				return mois .. '&nbsp;' .. annee
			end
		else 
			return annee
		end
	else
		-- si annee n'est pas précisé, on utilise la paramètre date
		local date = Outils.validTextArg( args, 'date' )
		if date then 
			return '<span class="nowrap">' .. date .. '</span>'
		else 
			return ''
		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 args = Outils.extractArgs( frame )
	local annee = Outils.notEmpty( args['année'], args.annee, args.year, args.date )
	-- extraction de l'année 
	if type( annee ) == 'string' then 
		annee = ( tonumber( annee )	-- match '2013'
				or string.match ( annee, '%D(%d%d%d%d)%D' ) -- match  '[[2013 en musique|2013]]'
				or string.match ( annee, '%D(%d%d%d%d)$' )  -- match '17 septembre 2013'
				or string.match ( annee, '^(%d%d%d%d)%D' )  -- match '2013-09-17'
		 )
	end
	annee = tonumber( annee )
	
	-- le format de date iso est défini suivant le calendrier grégorien. 
	-- Avant l'année 1583 la date est calendrier est probablement du calendrier julien, 
	-- donc autant s'abstenir.
	if annee and annee > 1582  then
		local mois = Outils.notEmpty( args.mois, args.month )
		-- num mois trouve le numéro du mois, qu'il soit numérique ou texte, complet ou abrégé.
		local nomMois, numMois = fun.determinationMois( mois )
		if numMois then
			mois = '-' .. string.sub( '0' .. numMois, -2 )
			
			local jour = Outils.notEmpty( args.jour, args.day, args['quantième'] )
			if type( jour ) == 'string' then
				jour = tonumber( jour ) or tonumber( string.match ( jour, '%d+') )
			end
			jour = tonumber( jour )
			if jour and jour <= liste_mois[numMois].nJour then
				jour = '-' .. string.sub( '0' .. jour, -2 )
				return annee .. mois .. jour
			else
				return annee .. mois
			end
		else
			return tostring( annee )
		end
	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 (Suit le calendrier grégorien)
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]) .. "&nbsp;" .. 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 Outils.erreur( "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 Outils.erreur("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, min, sec )
    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 + ( min or 0 ) / 1440 + ( sec 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, min, sec )
    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 + ( min or 0 ) / 1440 + ( sec or 0 ) / 86400
           - 32205.5
    return julian
end

---
-- calcul d'une date dans le calendrier grégorien à partir du jour julien
function fun.julianDayToGregorian( julianDay )
    local base = math.floor( julianDay + 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

---
-- calcul d'une date dans le calendrier julien à partir du jour julien
-- calcul basé sur l'algorythme de la page fr.wikipedia.org/wiki/Jour_julien (1/10/2013)
function fun.julianDayToJulian( julianDay )
	local year = math.modf( ( julianDay * 4 - 6884469 ) / 1461 )
	local r2 = julianDay - math.modf( ( 1461 * year + 6884472 ) / 4 ) 
	local month = math.modf( ( 5 * r2 + 461 ) / 153 )
	local day = r2 - math.modf( ( 153 * month - 457 ) / 5 ) + 1
	if month > 12 then
		year = year + 1
		month = month - 12
	end
	return year, month, day
end

---
-- calcul d'une date dans le calendrier grégorien à partir d'une date dans le calendrier julien
function fun.julianToGregorian( year, month, day )
    return fun.julianDayToGregorian( fun.julianDayJulian( year, month, day ) )
end

---
-- calcul d'une date dans le calendrier julien à partir d'une date dans le calendrier grégorien
function fun.gregorianToJulian( year, month, day )
	year = tonumber(year)
	if month then month = tonumber(month) else month = 6 end --prend une valeur centrale pour donner un best "guess"
	if day then day = tonumber(day) else day = 15 end
    return fun.julianDayToJulian( fun.julianDay( 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

---
-- checkDataCat génère des liens vers les pages annuelles, mensuelles et d'éphémérides liè aux
-- catégories du Module:Date/Data. La date la plus ancienne dépend de 'aucun' et 'seul[1]'
-- Paramètres : 
-- 	1 : la catégorie. Il y aura une section par qualificatif de cette catégorie.
-- 	mois : oui pour avoir les liens vers les pages mensuelles et éphémérides (4 jours dans l'année)
-- 	alias : pour avoir des lien pour les alias en plus des qualificatif
function fun.checkDataCat( frame )
    local category = trim(frame.args[1])
    local monthLinks = frame .args.mois == 'oui'
    local alias = frame.args.alias == 'oui'
    local dataLink = mw.loadData( 'Module:Date/Data' )
    local wikiList =  TableBuilder.new()
    local currentYear = tonumber( os.date( '%Y' ) )
    local columns = '<div style="-moz-column-width:5em;-webkit-column-width:5em;column-width:5em;-moz-column-gap:1em;-webkit-column-gap:1em;column-gap:1em;text-align:left;">'
    local newSection 
    if monthLinks then 
        newSection = '\n\n== %s ==\n\n=== Années ===\n' .. columns
    else
        newSection ='\n\n== %s ==\n' .. columns
    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 or ( category == 'cat' and dataField.cat == field ) 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 or ( category == 'cat' and dataField.cat == field ) then
                if dataField.annee and dataField.annee.aucun and dataField.annee.aucun < currentYear then
                    local aucun = ( dataField.annee.seul and dataField.annee.seul[1] ) or dataField.annee.aucun
                    initialYear = math.min( aucun - math.ceil( (currentYear - aucun) / 4 ), currentYear - 50 )
                else 
                    initialYear = currentYear - 50
                end
                if dataField.mois and tonumber( dataField.mois.aucun ) and ( tonumber( 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 alias then
                -- si le paramètre alias est défini on teste aussi tous les alias, sinon ils sont ignorés
                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 ) )
                local fieldLink = ' ' .. field
                if category == 'cat' then 
                    fieldLink = ' ' .. dataField.qualificatif
                end
                for year = ( currentYear + 5 ), initialYear, -1  do
                    wikiList.insert( '\n* [[' .. year .. fieldLink ..'|' .. year .. ']]' )
                end
                wikiList.insert( '\n</div>' )
                
                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 .. ' ' .. fieldLink .. '|' .. month .. ']]' .. sep )
                        end
                    end
                    
                    -- insertion de quelques date pour tester les éphémérides
                    wikiList.insert( '\n\n=== Jours ==='  )
                    wikiList.insert( '\n* [[1er janvier ' .. fieldLink .. ']]' )
                    wikiList.insert( '\n* [[14 mars ' .. fieldLink .. ']]' )
                    wikiList.insert( '\n* [[22 juin ' .. fieldLink .. ']]' )
                    wikiList.insert( '\n* [[3 septembre ' .. fieldLink .. ']]' )
                end
            end
        end
    end
    
    return table.concat( wikiList )
end

return fun