Module:Date complexe : Différence entre versions
m |
|||
| Ligne 35 : | Ligne 35 : | ||
end | end | ||
| − | local function | + | local function milleniumString(centurynumber) |
return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { centurynumber + 1 }} .. '<sup>e</sup> millénaire' | return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { centurynumber + 1 }} .. '<sup>e</sup> millénaire' | ||
end | end | ||
| Ligne 56 : | Ligne 56 : | ||
local era = dateobject.era | local era = dateobject.era | ||
| − | local precision = dateobject.precision or guessprecision(dateobject) | + | local precision = tonumber(dateobject.precision) or numericprecision[dateobject.precision] or guessprecision(dateobject) |
| − | |||
if precision == 6 then | if precision == 6 then | ||
local century = tostring(math.floor(dateobject.year/100)) | local century = tostring(math.floor(dateobject.year/100)) | ||
| − | str = | + | str = milleniumString(century) |
elseif precision == 7 then | elseif precision == 7 then | ||
local century = tostring(math.floor(dateobject.year/100)) | local century = tostring(math.floor(dateobject.year/100)) | ||
| Ligne 150 : | Ligne 149 : | ||
end | end | ||
| − | function p.daterange( | + | function p.daterange(startpoint, endpoint) |
| − | if | + | if startpoint and endpoint then |
| − | return fromuntil( | + | return fromuntil(startpoint, endpoint) |
| − | elseif | + | elseif startpoint then |
| − | return fromdate( | + | return fromdate(startpoint) |
| − | elseif | + | elseif endpoint then |
| − | return upto( | + | return upto(endpoint) |
else | else | ||
return nil | return nil | ||
| Ligne 162 : | Ligne 161 : | ||
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 | return p | ||
Version du 23 janvier 2015 à 07:35
La documentation pour ce module peut être créée à Module:Date complexe/doc
local datemodule = require('Module:Date')
local linguistic = require('Module:Linguistique')
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) -- précision des dates qui ne viennent pas de Module:Wikidata/Dates
local prec = 0
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(centurynumber)
return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { centurynumber + 1 }} .. '<sup>e</sup> siècle'
end
local function milleniumString(centurynumber)
return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { centurynumber + 1 }} .. '<sup>e</sup> millénaire'
end
local function decadeString(decadenumber)
return 'années ' .. decade .. '0'
end
function p.simplestring(dateobject)
-- 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
local yearstr, monthstr, daystr= tostring(dateobject.year), tostring(dateobject.month), tostring(dateobject.day)
-- adaptation à mw.formatDate en attendant de passer par Module:Date
if yearstr then
while #yearstr < 4 do
yearstr = 0 .. yearstr
end
end
local era = dateobject.era
local precision = tonumber(dateobject.precision) or numericprecision[dateobject.precision] or guessprecision(dateobject)
if precision == 6 then
local century = tostring(math.floor(dateobject.year/100))
str = milleniumString(century)
elseif precision == 7 then
local century = tostring(math.floor(dateobject.year/100))
str = centuryString(century)
elseif precision == 8 then
local decade = tostring(math.floor(dateobject.year/10))
str = decadestring(decade)
elseif precision == 9 then
str = yearstr
elseif precision == 10 then
str =mw.language.new('fr'):formatDate('F Y', yearstr .. '-' .. monthstr )
if dateobject.year < 1000 then -- enlève les zéros en trop
str = string.gsub(str, '0', '')
end
elseif precision == 11 then
str = mw.language.new('fr'):formatDate('j F Y', yearstr .. '-' .. monthstr .. '-' .. daystr)
if day == 1 then -- ajustement "1 janvier" -> 1er janvier
str = string.gsub(t, '1', "1<sup>er</sup>", 1) -- remplacer "1 janvier" par "1er janvier"
end
if dateobject.year < 1000 then
str = string.gsub(str, '0', '')
end
end
if era == '-' then
str = str .. ' av. J.-C.'
end
return str or 'date invalide'
end
local function fromdate(d) -- retourne "à partir de date" en langage naturel
local precision = d.precision or guessprecision(d)
local datestr = p.simplestring(d)
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) -- retourne "jusqu'à date' en langage naturel
local datestring = p.simplestring(d)
local precision = d.precision or 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)
local precision = endpoint.precision or guessprecision(endpoint) -- may need 2 precisions for start and end dates
local startstr = p.simplestring(startpoint)
local endstr = p.simplestring(endpoint)
-- à 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)
local str = p.simplestring(dateobject)
return "vers " .. str
end
function p.daterange(startpoint, endpoint)
if startpoint and endpoint then
return fromuntil(startpoint, endpoint)
elseif startpoint then
return fromdate(startpoint)
elseif endpoint then
return upto(endpoint)
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
