Module:Date complexe
La documentation pour ce module peut être créée à Module:Date complexe/doc
-- TODO: améliorer les synergies avec Module:Date (gestion par module:Date de dates sans lien et de "XIe siècle en astronautique"
local datemodule = require 'Module:Date'
local linguistic = require 'Module:Linguistique'
local roman = require 'Module:Romain'
local p = {}
local numericprecision = { -- convertir les précisions en valeurs numériques = à celles utilisées par Wikidata
gigayear = 0,
megayear = 3,
millenium = 6,
century = 7,
decade = 8,
year = 9,
month = 10,
day = 11,
hour = 12,
minute = 12,
second = 14,
}
local function vowelfirst(str)
return linguistic.vowelfirst(str)
end
local function guessprecision(obj, displayformat) -- précision des dates qui ne viennent pas de Module:Wikidata/Dates
local precision = displayformat.precision or obj.precision
precision = tonumber(precision) or numericprecision[precision]
if precision then
return precision
end
precision = 0
if type(obj) == 'string' then
return prec
end
for i, j in pairs(obj) do
if (numericprecision[i] or 0) > prec then
prec = numericprecision[i]
end
end
return prec
end
local function centuryString(century, era)
local str = roman.toRoman(century) .. '<sup>e</sup> siècle'
if era == '-' then
str = str .. ' av. J.-C.'
end
return '' -- trop d'erreurs sur Wikidata, en attente du UI correcte
end
local function milleniumString(millenium, era)
local str = roman.toRoman(millenium) .. '<sup>e</sup> millénaire'
if era == '-' then
str = str .. ' av. J.-C.'
end
return str
end
local function decadeString(decade, era)
local str = 'années ' .. decade .. '0'
if era == '-' then
str = str .. ' av. J.-C.'
end
return str
end
function p.simplestring(dateobject, displayformat, precison)
-- transforme un object date ponctuel en texte
-- les dates de type ISO devraient passer par Module:Date, mais il faut pouvoir désactiver les liens
if type(dateobject) == 'string' or type(dateobject) == 'nil' then
return dateobject
end
local yearstr, monthstr, daystr= tostring(dateobject.year), tostring(dateobject.month), tostring(dateobject.day)
-- adaptation à mw.formatDate en attendant de passer par Module:Date
local era = dateobject.era
if not displayformat then
displayformat = {}
end
local linktopic = displayformat.linktopic
local nolinks
if linktopic == '-' then
nolinks = true
end
precision = precision or guessprecision(dateobject, displayformat)
if type(precision) == 'string' then
precision = numericprecision[precision]
end
if not precision then
precision = guessprecision(dateobject)
end
if precision == 6 then
local millenium = math.floor(dateobject.year/1000)
if era ~= '-' then
millenium = millenium + 1
end
str = milleniumString(millenium, era)
elseif precision == 7 then
local century = math.floor(dateobject.year/100)
if era ~= '-' then
century = century + 1
end
str = centuryString(century, era)
elseif precision == 8 then
local decade = tostring(math.floor(dateobject.year/10))
if era ~= '-' then
decade = decade + 1
end
str = decadeString(decade, era)
elseif precision == 9 then
str = datemodule.modeleDate{nil, nil, yearstr, linktopic, nolinks = nolinks}
elseif precision == 10 then
daystr = nil
str = datemodule.modeleDate{nil, monthstr, yearstr, linktopic, nolinks = nolinks}
else
str = datemodule.modeleDate{daystr, monthstr, yearstr, linktopic, nolinks = nolinks}
end
return str
end
local function fromdate(d, displayformat) -- retourne "à partir de date" en langage naturel
local precision = guessprecision(d, displayformat)
local datestr = p.simplestring(d, displayformat, precision)
if displayformat and displayformat.textformat == 'minimum' then
return datestr -- par exemple pour les classements MH, juste afficher la date de début
end
if (precision >= 11) or (precision == 7) or (precision == 6) then -- ont dit "à partir du pour les dates avec jour, les siècles, les millénaires
return 'à partir du ' .. datestr
else
if vowelfirst(str) then
return "à partir d'" .. datestr
else
return 'à partir de ' .. datestr
end
end
end
local function upto(d, displayformat) -- retourne "jusqu'à date' en langage naturel
local datestring = p.simplestring(d, displayformat)
local precision = guessprecision(d)
if (precision >= 11) or (precision == 7) or (precision == 6) then --on dit "jusqu'au" pour les dates avec jour, et pour les siècles
return 'jusqu\'au ' .. datestring
elseif (precision >= 9) then
return "jusqu'à " .. datestring
else
return "jusqu\'en " .. datestring
end
end
local function fromuntillong(startstr, endstr) -- inutile ?
-- on dit "du 3 au 14 janvier" mais "de septembe à octobre
if precision >= 11 then -- >= day
return "du " .. startstr .. " au " .. endstr
else
if vowelfirst(startstr) then
return "d'" .. startstr .. " à ".. endstr
else
return "de " .. startstr .. " à " .. endstr
end
end
end
local function fromuntil(startpoint, endpoint, displayformat)
local precision = guessprecision(displayformat, endpoint)
local startstr = p.simplestring(startpoint, displayformat)
local endstr = p.simplestring(endpoint, displayformat)
-- à améliorer pour éviter les tournures répétitives comme "du 13 septembre 2006 au 18 september 2006"
if not params then
params = {}
end
if params.displayformat == 'long' then
return fromuntillong(startstr, endstr)
else
return startstr .. '-' .. endstr
end
end
function p.fuzzydate(dateobjet, displayformat)
local str = p.simplestring(dateobject, displayformat)
return "vers " .. str
end
function p.daterange(startpoint, endpoint, displayformat)
if startpoint and endpoint then
return fromuntil(startpoint, endpoint, displayformat)
elseif startpoint then
return fromdate(startpoint, displayformat)
elseif endpoint then
return upto(endpoint, displayformat)
else
return nil
end
end
function p.duration(start, ending)
if (not start) or (not ending) then
return nil -- ?
end
return datemodule.age(start.year, start.month, start.day, ending.year, ending.month, ending.day)
end
return p
