Yves.bertin : Page créée avec « local p = {} local Outils = require( 'Module:Outils' ) local trim = Outils.trim local OutilsDates = require( 'Module:Date' ) local modeleDate = OutilsDates.modeleDate loc… »

2020-05-13T14:12:26Z

Page créée avec « local p = {} local Outils = require( 'Module:Outils' ) local trim = Outils.trim local OutilsDates = require( 'Module:Date' ) local modeleDate = OutilsDates.modeleDate loc… »

Nouvelle page

local p = {}
local Outils = require( 'Module:Outils' )
local trim = Outils.trim
local OutilsDates = require( 'Module:Date' )
local modeleDate = OutilsDates.modeleDate

local type_romains = "[IVXL]+"
local type_nombre = "[0-9]+"
local type_1er = "1er"
local type_jour_complementaire = "[1-6]e%*?%-? [Jj]our compl[eé]mentaire"

-- Table des libellés à afficher pour 1er, 2e, 3e, 4e, 5e, 6e
local infobulle = {
["1er"] = "Premier",
["2e"] = "Deuxième",
["3e"] = "Troisième",
["4e"] = "Quatrième",
["5e"] = "Cinquième",
["6e"] = "Sixième"
}

-- Table des noms des mois républicains, avec la casse de la première lettre et les erreurs acceptables
local listeNomsMois = {
{"vendémiaire", "vendémiaire"},
{"vendemiaire", "vendémiaire"},
{"Vendémiaire", "vendémiaire"},
{"Vendemiaire", "vendémiaire"},
{"brumaire", "brumaire"},
{"Brumaire", "brumaire"},
{"frimaire", "frimaire"},
{"Frimaire", "frimaire"},
{"nivôse", "nivôse"},
{"nivose", "nivôse"},
{"Nivôse", "nivôse"},
{"Nivose", "nivôse"},
{"pluviôse", "pluviôse"},
{"pluviose", "pluviôse"},
{"Pluviôse", "pluviôse"},
{"Pluviose", "Pluviôse"},
{"ventôse", "ventôse"},
{"ventose", "ventôse"},
{"Ventôse", "ventôse"},
{"Ventose", "ventôse"},
{"germinal", "germinal"},
{"Germinal", "germinal"},
{"floréal", "floréal"},
{"floreal", "floréal"},
{"Floréal", "floréal"},
{"Floreal", "floréal"},
{"prairial", "prairial"},
{"Prairial", "prairial"},
{"messidor", "messidor"},
{"Messidor", "messidor"},
{"thermidor", "thermidor"},
{"Thermidor", "thermidor"},
{"fructidor", "fructidor"},
{"Fructidor", "fructidor"},
{"jour complémentaire", "jour complémentaire"},
{"jour complementaire", "jour complémentaire"},
{"Jour complémentaire", "jour complémentaire"},
{"Jour complementaire", "jour complémentaire"}
}

-- Table des noms des mois républicains, avec la casse de la première lettre et les erreurs acceptables
local listeOrdreMois = {
["vendémiaire"] = 1,
["brumaire"] = 2,
["frimaire"] = 3,
["nivôse"] = 4,
["pluviôse"] = 5,
["ventôse"] = 6,
["germinal"] = 7,
["floréal"] = 8,
["prairial"] =9,
["messidor"] = 10,
["thermidor"] = 11,
["fructidor"] = 12,
["jour complémentaire"] = 13
}

-- Liste des jours complémentaires
local listeJoursComplementaires = {
{"jour de la vertu", 1},
{"Jour de la vertu", 1},
{"jour du génie", 2},
{"Jour du génie", 2},
{"jour du travail", 3},
{"Jour du travail", 3},
{"jour de l'opinion", 4},
{"Jour de l'opinion", 4},
{"jour des récompenses", 5},
{"Jour des récompenses", 5},
{"jour de la Révolution", 6},
{"Jour de la Révolution", 6},
{"jour de la révolution", 6},
{"Jour de la révolution", 6}
}

-- Table temporaire pour éviter les requêtes de test d'existence des articles.
-- Liste des articles existants sur les jours/mois, à remplacer par un table externe
local listeArticlesJours = {
["1er vendémiaire"] = true,
["7 vendémiaire"] = true,
["13 vendémiaire"] = true,
["14 vendémiaire"] = true,
["15 vendémiaire"] = true,
["16 vendémiaire"] = true,
["17 vendémiaire"] = true,
["18 vendémiaire"] = true,
["19 vendémiaire"] = true,
["20 vendémiaire"] = true,

["18 brumaire"] = true,
["19 brumaire"] = true,
["20 brumaire"] = true,
["21 brumaire"] = true,
["22 brumaire"] = true,
["12 brumaire"] = true,
["23 brumaire"] = true,
["24 brumaire"] = true,

["4 frimaire"] = true,
["10 frimaire"] = true,
["11 frimaire"] = true,

["25 nivôse"] = true,
["13 nivôse"] = true,

["13 pluviôse"] = true,
["16 pluviôse"] = true,

["19 ventôse"] = true,

["16 germinal"] = true,
["11 germinal"] = true,

["10 floréal"] = true,

["25 prairial"] = true,
["30 prairial"] = true,

["8 messidor"] = true,
["23 messidor"] = true,
["30 messidor"] = true,

["9 thermidor"] = true,

["18 fructidor"] = true,
["20 fructidor"] = true,
["30 fructidor"] = true,
["6 fructidor"] = true
}

-- Table temporaire pour éviter les requêtes de test d'existence des articles.
-- Liste des articles existants sur les mois/année, à remplacer par un table externe
local listeArticlesMois = {
["floréal an LXXIX"] = true,
["prairial an LXXIX"] = true,
["vendémiaire an II"] = true
}

-- liste des chiffres romains pour contrôle mise en forme de l'infobulle
local listeRomains = { ["I"] = "1",
["II"] = "2",
["III"] = "3",
["IV"] = "4",
["V"] = "5",
["VI"] = "6",
["VII"] = "7",
["VIII"] = "8",
["IX"] = "9",
["X"] = "10",
["XI"] = "11",
["XII"] = "12",
["XIII"] = "13",
["XIV"] = "14",
["LXXIX"] = "79"
}

-- extrait une chaîne de caractère (jour, mois ou année) du type passé en paramètre (string ou pattern),
-- en restituant :
-- § la chaîne exacte obtenue
-- § l'argument de départ délesté de cette chaîne
-- § un booléen indiquant la présence d'un indicateur d'affichage de l'éléments (-)
-- § un booléen indiquant la présence d'un indicateur de mise en place d'un lien sur l'élément (*)
function p.extraction_argument (argument, chaine)
local x, position = 0, 0
local lien, afficher = true, true
local extrait = ''
local chaine2 = ''
position = mw.ustring.find (argument, chaine)
if position then
chaine2 = mw.ustring.match(argument, chaine)
x = position + mw.ustring.len(chaine2)
if x < (mw.ustring.len(argument) + 1) then
if mw.ustring.sub(argument, x, x) == '*' then
lien = false
x=x+1
else
if mw.ustring.sub(argument, x, x) == '-' then
afficher = false
x=x+1
end
end
end
extrait = mw.ustring.sub(argument, position, x - 1)
argument = mw.ustring.sub(argument, 1, position - 1)..mw.ustring.sub(argument, x)
end

return argument, extrait, afficher, lien
end

-- Extraction d'éventuels jour, mois et année du calendrier républicain.
--
-- Le paramètre en entrée est sous la forme d'une chaîne, le séparateur étant l'espace
-- l'année doit être en chiffres romains
-- "an" peut être omis devant l'année ;
-- si l'affichage de l'année seul est demandé, "an" sera omis également à l'affichage
-- Ce cas est utile pour les formes : ans I, II et III
-- sont acceptés : an, An, de l'an, de l'An, de l’an, de l’An
-- le jour doit être numérique, "er" est accepté pour le premier jour de chaque mois
-- les paramètres peuvent être présentés dans n'importe quel ordre
-- les mois doivent être orthographiés correctement, mais les accents peuvent être omis
-- La majuscule n'est prise en compte que pour les nots possiblement en début de phrase :
-- § le mois est affiché et il n'y a pas de numéro de jour devant
-- § l'année est affichée et il n'a a pas d'autre élément devant
function p.test_argument (argument)
local tab = { test = true,
message = '',
quantieme = '',
exposant_jour = '',
test_quantieme = false,
test_jour_complementaire = false,
mois = '',
test_mois = false,
an = '',
test_an = false,
lien_jour = true,
lien_mois = true,
lien_an = true,
afficher_jour = true,
afficher_mois = true,
afficher_an = true,
jour_saisi = '',
complementaire_saisi = '',
mois_saisi = '',
an_saisi = '',
libelle_an = ''
}
local position = 0

-- On remplace les éventuels espaces insécables par des espaces simples pour simplifier le traitement qui suit
argument = argument
-- nbsp
:gsub( '\194\160', ' ' )
:gsub( ' ', ' ' )
:gsub( ' ', ' ' )
-- narrow nbsp
:gsub( '\226\128\175', ' ' )
:gsub( ' ', ' ' )
-- thin space
:gsub( '\226\128\137', ' ' )
:gsub( ' ', ' ' )
:gsub( ' ', ' ' )
-- simple space
:gsub( ' ', ' ' )

-- On retire l'éventuel "er" de "1er" pour simplifier le traitement qui suit
if argument:match (type_1er) then
argument=argument:gsub('1er', '1')
end

-- On recherche si c'est sous la forme "6e jour complémentaire" pour écarter le "e"
if mw.ustring.find(argument, type_jour_complementaire) then
tab.exposant_jour = 'e'
position = mw.ustring.find (argument, type_jour_complementaire)
if position then
if position == 1 then
argument=mw.ustring.sub(argument, 1, 1)..mw.ustring.sub(argument, 3)
else
argument=mw.ustring.sub(argument, 1, position)..mw.ustring.sub(argument, position + 2)
end
end
end

-- On recherche le mois, s'il existe il est retiré de la chaîne de caractère analysée
for _, nomMois in ipairs( listeNomsMois ) do
if mw.ustring.find (argument, nomMois[1]) then
argument, tab.mois_saisi, tab.afficher_mois, tab.lien_mois = p.extraction_argument (argument, nomMois[1])
tab.mois = nomMois[2]
tab.test_mois = true
break
end
end

-- On recherche s'il s'agit d'un des six "jours complémentaires", si c'est le cas il est retiré de la chaîne de caractère analysée
-- On conserve le libellé du jour
for _, jourComplementaire in ipairs( listeJoursComplementaires ) do
if mw.ustring.find (argument, jourComplementaire[1]) then
argument, tab.complementaire_saisi, tab.afficher_jour, tab.lien_jour = p.extraction_argument (argument, jourComplementaire[1])
tab.test_jour_complementaire = true
tab.quantieme = tab.complementaire_saisi
if not(tab.afficher_jour and tab.lien_jour) then
tab.quantieme = mw.ustring.sub (tab.quantieme, 1, mw.ustring.len(tab.quantieme) - 1)
end
break
end
end

-- On recherche le jour en chiffres. Si on le trouve, il est retiré de la chaîne analysée
if argument:match (type_nombre) then
tab.test_quantieme = true
tab.quantieme = argument:match (type_nombre)
if tab.quantieme == '1' then
tab.exposant_jour = 'er'
end
argument, tab.jour_saisi, tab.afficher_jour, tab.lien_jour = p.extraction_argument (argument, tab.quantieme)
if (tonumber(tab.quantieme) < 1) or (tonumber(tab.quantieme) > 30) then
tab.test = false
tab.message = 'le jour doit être compris entre 1 et 30 (' .. tab.quantieme .. ')'
return tab
end
end

-- Si la chaîne analysée est vide, le traitement est terminé
argument=trim(argument)
if argument then
-- On extrait l'année, donc on "élimine" les formulations du type "an" ou "de l'an" pour
-- récupérer le numéro d'année en chiffres romains
argument, tab.libelle_an = p.extraction_argument (argument, "de l[%'’][Aa]n")
if tab.libelle_an == '' then
argument, tab.libelle_an = p.extraction_argument (argument, 'An')
if tab.libelle_an == '' then
argument, tab.libelle_an = p.extraction_argument (argument, 'an')
end
else
tab.libelle_an = mw.ustring.lower (tab.libelle_an)
end
-- On vérifie si la chaîne qui reste est une année sous la forme "XX"
if argument:match (type_romains) then
tab.test_an = true
tab.an = argument:match (type_romains)
argument, tab.an_saisi, tab.afficher_an, tab.lien_an = p.extraction_argument (argument, tab.an)
end

if tab.test_an then
if not listeRomains[tab.an] then
tab.test = false
tab.message = 'année hors du calendrier républicain (' .. tab.an .. ')'
return tab
end
end
argument=trim(argument)
if argument then
-- La chaîne n'est pas sous un format attendu, message d'erreur
tab.test = false
tab.message = 'format de date incorrect (' .. argument .. ')'
end
end
return tab
end

-- Mise en forme de l'année affichée
-- § le paramètre année en entrée doit être sous la forme de chiffres romains
-- § le paramètre lien_annee indique si faut formater un lien vers un article de wikipédia
-- § le paramètre libelle_an indique le format de présentation : exemples : "de l'an", "An", etc.
function p.annee_affichee(annee, lien_annee, libelle_an)
local chaine = ''
local annee_affichee = ''
local premier_car = ''
local avant_an = ''
local test = true
local message = ''

if annee then
-- Vérification de la syntaxe en chiffres romains
if annee:match(type_romains) then
if libelle_an then
-- gestion du cas des formats du type "de l'an" pour récupérer la typo (apostrophe) et éviter que
-- le lien porte sur autre chose que "an NN" pour donner "de l'[[an NN]]" et non pas "[[An NN|de l'an NN]]"
if mw.ustring.sub(libelle_an, 1, 1) == 'd' then
annee_affichee = 'an '
avant_an = mw.ustring.sub(libelle_an, 1, 5)
else
annee_affichee = libelle_an..' '
end
else
annee_affichee = 'an '
end
-- Récupération de la valeur affichée dans l'infobulle
annee_affichee = annee_affichee..'<abbr class="abbr" title="'..listeRomains[annee]..'">'..annee..'</abbr>'
if lien_annee then
-- Cas particulier de l'an I
if annee == 'I' then
chaine = '[[An I du calendrier républicain|'..annee_affichee..']]'
else
chaine = '[[An '..annee..'|'..annee_affichee..']]'
end
else
chaine = annee_affichee
end
chaine = avant_an..chaine
return test, chaine
end
else
test = false
message = 'aucune année passée en paramètre (annee_affichee)'
return test, message
end
end

-- Fonction calculant une date du calendrier grégorien à partir d'une date du calendrier républicain
function p.conversion_Gregorien (jour, mois, an)
-- table du nombre de jour écoulé depuis le début de l'année jusqu'au premier de chaque mois du calendrier grégorien
-- (sans tenir compte des années bissextiles)
local rang_mois_Greg = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }
local x = 0
local jour_Rep, mois_Rep, an_Rep, jour_Greg, mois_Greg, an_Greg = '', '', '', '', '', ''
local test = true
local message = ''

-- Fonction permettant de connaître le nombre de jours bissextiles entre deux années
local function nb_jours_complement_bissextile (an)
local nb = 0
for i = 1792, 1791+an do
if OutilsDates.isLeapYear(i) then
nb = nb + 1
end
end
return nb
end

-- Si la date se présente sous la forme "nom de jour complémentaire an XX", on détermine le rang chronologique du jour en question
if (mois == 'jour complémentaire') and (jour:match('^[Jj]our')) then
for _, jourComplementaire in ipairs( listeJoursComplementaires ) do
if jourComplementaire[1] == jour then
jour_Rep = jourComplementaire[2]
break
end
end
else
jour_Rep = tonumber(jour)
end

-- Valeurs numériques de l'année et du mois républicains
an_Rep = tonumber(listeRomains[an])
mois_Rep = listeOrdreMois[mois]

-- contrôles ?
-- if not (an_Rep < 14) and not (mois_Rep < 4)
-- then
-- if not (an_Rep == 79)
-- then
-- return false, 'Pas de conversion pour les dates non officielles'
-- end
-- end

-- On détermine le nombre de jour entre la date transmise et le 1er janvier 1792. On connaît le nombre de jour entre le 1er janvier
-- et le 22 septembre 1792, première journée du calendrier républicain : 265
-- On multiplie le nombre d'années écoulées avant l'année en cours par 365, et on ajoute un jour par année sextile (pour les périodes considérées,
-- durant lesquelles ce calendrier a été officiel, tous les quatre ans à partir de l'an III).
-- On multiplie le nomdre de mois écoulés avant le mois en cours par 30
-- On ajoute le quantième du jour transmis ou calculé
jour_Greg = 365*(an_Rep -1) + 30*(mois_Rep - 1) + jour_Rep + math.floor(an_Rep/4) + 265

-- On ajoute le résultat de la division de la partie entière du nombre de jours trouvé par la durée d'une année,
-- en tenant compte des années bissextiles comprises dans la période
an_Greg = 1792 + math.floor((jour_Greg - nb_jours_complement_bissextile (an_Rep)-1)/365)

-- On calcule le reste de jours en tenant compte des années bissextiles
-- (une toutes les 4 ans sauf celles qui sont divisibles par 4 et par cent mais pas par 400)
jour_Greg = jour_Greg - (an_Greg-1792)*365 - math.floor((an_Greg-1789)/4) + math.floor(an_Greg/1801) + math.floor(an_Greg/1901)

-- On détermine le mois correspondant au résultat
local n = 1
local m = 1
local r = 0
local bissextile = OutilsDates.isLeapYear(an_Greg)
for i = 1, 12 do
r = rang_mois_Greg[i]
-- Prise en compte d'un éventuel 29 février (années bissextiles, via isLeapYear(year) du module Date)
if bissextile then
if i > 2 then
r = r + 1
end
end
if not(r < jour_Greg) then
i = 12
else
n = r
m = i
end
end

mois_Greg = m
jour_Greg = jour_Greg - n

return test, message, jour_Greg, mois_Greg, an_Greg

end

-- Contrôle et mise en forme
function p._date_republicaine (aucun_lien, args)
local tab = { test = true,
nocat = false,
message = '',
quantieme = '',
exposant_jour = '',
test_quantieme = false,
test_jour_complementaire = false,
mois = '',
test_mois = false,
an = '',
test_an = false,
lien_jour = true,
lien_mois = true,
lien_an = true,
afficher_jour = true,
afficher_mois = true,
afficher_an = true,
jour_saisi = '',
complementaire_saisi = '',
mois_saisi = '',
an_saisi = '',
libelle_an = ''
}
local test_conversion, test_conversion_sans_lien = false, false
local conv_jour_mois, conv_jour, conv_an, conv_mois_an = false, false, false, false
local deux_points = false
local parametres, chaine = '', ''

-- Test pour ne pas catégoriser les pages indésirables dans les catégories spéciales de maintenance
if args.nocat then
if args.nocat == '' then
tab.nocat = true
end
end
-- § Les paramètres peuvent se présenter sous la forme d'une seule chaîne ou de 3 paramètres séparés.
-- Dans ce dernier cas, on constitue une chaîne en utilisant l'espace comme séparateur, ce qui permet un traitement unique pour les 2 cas
-- § Si "conversion" ou "grégorien" est spécifié, on stocke l'info mais on ne l'inclut pas dans la chaîne ; il faut en plus
-- vérifier :
-- §§ si * est présisé (dans ce cas, pas de liens sur la date grégorienne convertie)
-- §§ si le caractère ":" apparaît, pour savoir si le séparateur est ":", sinon ce sont des parenthèes
-- §§ si une des séquences "jm", "j", "ma" ou "a" sont présentes, pour déterminer quels éléments de la date grégorienne
-- doivent être affiché (j=jour, m=mois, a=an)
for i = 1, 4 do
if args[i] then
if (mw.ustring.match (args[i], '[Cc]onversion')) or (mw.ustring.match (args[i], '[Gg]régorien')) then
if not mw.ustring.match (args[i], 'jma') then
if mw.ustring.match (args[i], 'jm') then
conv_jour_mois = true
elseif mw.ustring.match (args[i], 'j') then
conv_jour = true
elseif mw.ustring.match (args[i], 'ma') then
conv_mois_an = true
elseif mw.ustring.match (args[i], 'a') then
conv_an = true
end
end
if mw.ustring.match (args[i], ':') then
deux_points = true
end
if mw.ustring.match (args[i], '%*') then
test_conversion_sans_liens = true
else
test_conversion = true
end
else
parametres = parametres..args[i]..' '
end
end
end

if parametres then
tab = p.test_argument (parametres)
else
tab.test = false
tab.message = p.categorie_erreur (tab.nocat, 'Aucun paramètre transmis')
return tab.message
end

-- Contrôle sur le nombre de jours si c'est un jour complémentaire
if tab.mois and tab.quantieme then
if (tab.mois == 'jour complémentaire') then
if (tonumber(tab.quantieme) > 6) then
tab.test = false
tab.message = 'Il n\'y a que 6 jours complémentaires au maximum (' .. tab.quantieme .. ')'
else
if tab.an then
if (tonumber(tab.quantieme) == 6) and not ((tab.an == 'III') or (tab.an == 'VII') or (tab.an == 'XI')) then
tab.test = false
tab.message = 'Il n\'y a que 5 jours complémentaires cette année là (' .. tab.quantieme .. ')'
end
end
end
end
end

if not tab.test then
tab.message = p.categorie_erreur (tab.nocat, tab.message)
return tab.message
end

if aucun_lien then
tab.lien_jour, tab.lien_mois, tab.lien_an = false, false, false
end

-- Début de la mise en forme typographique et de l'établissement des liens possibles sur une date du calendrier républicain
-- le paramètre "date_affiche" reçoit les éléments au fur et à mesure de l'analyse
local date_affichee = ''
local jour = ''
local jour_affiche = ''
local article = ''

-- Si on a le jour mais pas le mois, c'est un cas invalide
if tab.test_quantieme and not(tab.test_mois) then
tab.message = p.categorie_erreur (tab.nocat, 'date invalide, mois manquant')
return tab.message
else
-- on ne peut pas avoir en même temps un jour complémentaire et un numéro de jour ou un mois
if (tab.test_quantieme or tab.test_mois) and tab.test_jour_complementaire then
tab.test = false
tab.message = p.categorie_erreur (tab.nocat, 'date invalide, paramètres incompatibles')
return tab.message
end
end

-- Cas où l'année n'est pas spécifiée
if not tab.test_an then
-- Cas où on a le jour (en chiffres) et le mois
if tab.test_quantieme and tab.test_mois then
if tab.afficher_jour then
-- Cas particulier pour la mise en forme de "1er", "2e", etc.
if not (tab.exposant_jour == '') then
jour = tab.quantieme..tab.exposant_jour
jour_affiche = '<abbr class="abbr" title="'..infobulle[jour]..'" >'..tab.quantieme..''..tab.exposant_jour..'</abbr>'
else
jour = tab.quantieme
jour_affiche = tab.quantieme
end
if tab.lien_jour then
article = jour..' '..tab.mois
if listeArticlesJours[article] then
-- Si l'index formé par l'ensemble jour-mois existe dans la table, c'est qu'un article wikipédia existe => lien [[jour mois]
-- Sinon => lien sur le mois seulement (les articles sur les mois existent dans tous les cas)
date_affichee = date_affichee..'[['..article..'|'..jour_affiche..']]'
else
date_affichee = date_affichee..jour_affiche
end
else
date_affichee = date_affichee..jour_affiche
end
end
if tab.afficher_mois then
if date_affichee == '' then
tab.mois = string.sub(tab.mois_saisi, 1, 1)..string.sub(tab.mois, 2)
end
if tab.lien_mois then
date_affichee = date_affichee..' [['..tab.mois..']]'
else
date_affichee = date_affichee..' '..tab.mois
end
end
else
-- Cas où seul le nom précis d'un des jours complémentaires est présent,
-- si demandé on affiche le lien (les articles sur ces jours existent dans tous les cas)
if tab.test_jour_complementaire and tab.afficher_jour then
if tab.lien_jour then
date_affichee = '[['..tab.quantieme..']]'
else
date_affichee = tab.quantieme
end
else
-- Cas où seul le mois est présent, si demandé on affiche le lien (les articles sur les mois existent dans tous les cas)
if tab.test_mois and tab.afficher_mois then
tab.mois = string.sub(mois_saisi, 1, 1)..string.sub(tab_mois, 2)
if tab.lien_mois then
date_affichee = '[['..tab.mois..']]'
else
date_affichee = tab.mois
end
end
end
end
else
-- Cas où l'année est renseignée

-- Cas des dates sous la forme jour_complémentaire année
-- Traitement du jour
if tab.test_jour_complementaire and tab.afficher_jour then
if tab.lien_jour then
-- On vérifie dans la table s'il existe un article dont le lien est de la forme [[jour complémentaire an XX]]
-- Si ce n'est pas le cas, on affiche un lien sur le jour seul
article = tab.quantieme..' an '..tab.an
if listeArticlesMois[article] then
date_affichee = '[['..article..'|'..tab.quantieme..']]'
else
date_affichee = '[['..tab.quantieme..']]'
end
else
-- Pas de lien demandé
date_affichee = date_affichee..tab.quantieme
end
if tab.afficher_an then
-- Traitement de l'année
tab.test, chaine = p.annee_affichee(tab.an, tab.lien_an)
date_affichee = date_affichee..' '..chaine
end
end

-- Cas des dates sous la forme jour mois année
-- Traitement du jour
if tab.test_quantieme and tab.test_mois then
if tab.afficher_jour then
-- Cas particulier pour la mise en forme de "1er", "2e", etc.
if not (tab.exposant_jour == '') then
jour = tab.quantieme..tab.exposant_jour
jour_affiche = '<abbr class="abbr" title="'..infobulle[jour]..'" >'..tab.quantieme..''..tab.exposant_jour..'</abbr>'
else
jour = tab.quantieme
jour_affiche = tab.quantieme
end
article = jour..' '..tab.mois
-- Si l'index formé par l'ensemble jour-mois existe dans la table, c'est qu'un article wikipédia existe => lien [[jour mois|jour]]
-- Sinon => lien sur le mois seulement (les articles sur les mois existent dans tous les cas)
if tab.lien_jour and listeArticlesJours[article] then
date_affichee = '[['..article..'|'..jour_affiche..']]'
else
date_affichee = jour_affiche
end
end
if tab.afficher_mois then
if tab.lien_mois then
if date_affichee == '' then
tab.mois = string.sub(tab.mois_saisi, 1, 1)..string.sub(tab.mois, 2)
end
article = tab.mois..' an '..tab.an
if listeArticlesMois[article] then
date_affichee = date_affichee..' [['..article..'|'..tab.mois..']]'
else
date_affichee = date_affichee..' [['..tab.mois..']]'
end
else
date_affichee = date_affichee..' '..tab.mois
end
end

if tab.afficher_an then
if not (date_affichee == '')
and ((string.upper(string.sub (tab.libelle_an, 1, 1)) == 'A') or (tab.libelle_an == '')) then
tab.libelle_an = nil
end
tab.test, chaine = p.annee_affichee (tab.an, tab.lien_an, tab.libelle_an)
if not tab.test then
return chaine
else
date_affichee = date_affichee..' '..chaine
end
end
end

-- Cas où il n'y a pas de numéro de jour, date de la forme mois année
-- On vérifie dans la table s'il existe un article dont le lien est de la forme [[mois an XX]]
-- Si ce n'est pas le cas, on affiche un lien sur le mois seul
if tab.test_mois and not tab.test_quantieme and tab.afficher_mois then
if date_affichee == '' then
tab.mois = string.sub(tab.mois_saisi, 1, 1)..string.sub(tab.mois, 2)
end
article = tab.mois..' an '..tab.an
if tab.lien_mois then
if listeArticlesMois[article] then
date_affichee = '[['..article..'|'..tab.mois..']]'
else
date_affichee = '[['..tab.mois..']]'
end
else
date_affichee = tab.mois
end

if tab.afficher_an then
tab.test, chaine = p.annee_affichee (tab.an, tab.lien_an)
date_affichee = date_affichee..' '..chaine
end
end
-- Cas où on n'affiche que l'année
if tab.afficher_an and (date_affichee == '') then
tab.test, date_affichee = p.annee_affichee(tab.an, tab.lien_an, tab.libelle_an)
if not tab.test then
date_affichee = p.categorie_erreur (tab.nocat, date_affichee)
return date_affichee
end
end
end

-- Si la date présente des espaces, on les rend insécables
if date_affichee:match( ' ' ) then
date_affichee = ''..date_affichee..''
end

-- Mise en forme de l'éventuelle date correspondante dans le calendrier grégorien

-- Cette possibilité est activée par le passage d'une chaine de caracère contenant "conversion" ou "grégorien"
if test_conversion or test_conversion_sans_liens then
if ((tab.test_quantieme and tab.test_mois) or tab.test_jour_complementaire) and tab.test_an then
if tab.test_jour_complementaire then
tab.mois = 'jour complémentaire'
end
tab.test, tab.message, jour_Greg, mois_Greg, an_Greg = p.conversion_Gregorien(tab.quantieme, tab.mois, tab.an)
if tab.test then
-- Si le paramètre contenant la chaine conversion présente le caractère « : » (deux points),
-- le résultat est présenté sous la forme date républicaine : date gégorienne
-- Sinon, le le résultat est présenté sous la forme date républicaine (date gégorienne)
if deux_points then
date_affichee = date_affichee..' : '
else
date_affichee = date_affichee..' ('
end
-- § La mention facultative de j, jm, a, etc. permet de selectionner ce qui est conservé à l'affichage de la date grégorienne
-- cela permet de faire appel au module date en utilisant les "-" qui masquent l'affichage des éléments non souhaités
-- § conversion* permet d'afficher la date grégorienne sans liens
if test_conversion_sans_liens then
if conv_jour_mois then
date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg..'-', nolinks="oui"})
elseif conv_jour then
date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg..'-', an_Greg..'-', nolinks="oui"})
elseif conv_mois_an then
date_affichee = date_affichee..modeleDate({nil, mois_Greg, an_Greg, nolinks="oui"})
elseif conv_an then
date_affichee = date_affichee..an_Greg
else
date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg, nolinks="oui"})
end
else
if conv_jour_mois then
date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg..'-'})
elseif conv_jour then
date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg..'-', an_Greg..'-'})
elseif conv_mois_an then
date_affichee = date_affichee..modeleDate({nil, mois_Greg, an_Greg})
elseif conv_an then
date_affichee = date_affichee..'[['..an_Greg..']]'
else
date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg})
end
end
if not deux_points then
date_affichee = date_affichee..')'
end
else
date_affichee = date_affichee..message
end
else
tab.test = false
date_affichee = 'conversion impossible, date incomplète'
end
end

if not tab.test then
date_affichee = p.categorie_erreur (date_affichee)
end

return date_affichee
end

function p.categorie_erreur (nocat, message)
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
-- local namespaceCategorisation = { [4] = true }
if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] and (nocat=='') then
return message .. '[[Catégorie:Page avec une erreur de paramètre du modèle Date républicaine]]'
else
return message
end
end

-- Fonction permettant la mie en forme typographique et l'établissement des liens possibles sur une date du calendrier républicain
-- en vigueur en France entre 1792 et 1806 ainsi qu'en 1871 pendant la Commune. Il est également possible de faire afficher
-- la date grégorienne correspondante en indiquant "conversion" en paramètre.
function p.date_republicaine (frame)
local args = Outils.extractArgs(frame)
local aucun_lien = false

local chaine = p._date_republicaine (aucun_lien, args)

return chaine
end

-- Fonction permettant la mie en forme typographique sur une date du calendrier républicain
-- en vigueur en France entre 1792 et 1806 ainsi qu'en 1871 pendant la Commune. Il est également possible de faire afficher
-- la date grégorienne correspondante en indiquant "conversion" en paramètre.
function p.date_republicaine_sans_liens (frame)
local args = Outils.extractArgs(frame)
local aucun_lien = true

local chaine = p._date_republicaine (aucun_lien, args)

return chaine
end

return p

Module:Date républicaine - Historique des versions

Yves.bertin : Page créée avec « local p = {} local Outils = require( 'Module:Outils' ) local trim = Outils.trim local OutilsDates = require( 'Module:Date' ) local modeleDate = OutilsDates.modeleDate loc… »