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

De Lagny-sur-Marne Wiki
Aller à la navigation Aller à la recherche
Modification suivante →
0x010D (discussion | contributions)
0 modification
Nouvelle page : -- Translates and format date range sand other non punctual dates --inspired by Commons:Module:Other dates local datemodule = require('Module:Date') local p = {} --[[ wikibase...
 
0x010D (discussion | contributions)
0 modification
Aucun résumé des modifications
Ligne 1 : Ligne 1 :
-- Translates and format date range sand other non punctual dates
--inspired by [[Commons:Module:Other dates]]
local datemodule = require('Module:Date')
local datemodule = require('Module:Date')
local linguistic = require('Module:Linguisique')
local p = {}
local p = {}
--[[ wikibase format
precision =
0: 1 Gigayear
1: 100 Megayears
2: 10 Megayears
3: Megayear
4: 100 Kiloyears
5: 10 Kiloyears
6: Kiloyear
7: 100 years
8: 10 years
9: years
10: months
11: days
12: hours
13: minutes
14: seconds
]]--


local function totext(obj, lang, case)
local numericprecision = { -- convertir les précisions en valeurs numériques = à celles utilisées par Wikidata
return datemodule.Wikibasedate(obj, lang, case)
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
end


local function from(startpoint, lang)
local function centuryString(centurynumber)
local precision = tonumber(startpoint.precision)
return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { century }} .. '<sup>e</sup> siècle'
local value =
function()
if precision > 10 then -- precision > month
return "à partir du " .. totext(startpoint, lang)
else
return "à partir de " .. totext(startpoint, lang)
end
end
return value()
end
end


local function decadeString(decadenumber)
return 'années ' .. decade .. '0'
end


local function fromuntil(startpoint, endpoint, lang)
function p.simplestring(dateobject) -- transforme un object date ponctuel en texte
local precision = tonumber(startpoint.precision) -- may need 2 precisions for start and end
local str
local value =  
local year, month, day = dateobject.year, dateobject.month, dateobject.day
function() -- could actually be better should be "d'octobre à mars 2013' not "de octore 2013 à mars 2013"
local era = dateobject.era
if precision > 10 then -- precision > month
local precision = dateobject.precision
return "du " .. totext(startpoint, lang) .. " au " .. totext(endpoint, lang)
if object.precision == 7 then
else
local century = tostring(math.floor(year/100))
-- "DE septebmbre" / "D'octobre"
str = centuryString(century)
return require('Module:Linguistic').of(totext(startpoint, 'fr'), 'fr') .. " à " .. totext(endpoint, lang)
elseif precision == 8 then
end
local decade = tostring(math.floor(year/10))
str = decadestring(decade)
elseif precision == 9 then
str = tostring(year)
elseif precision == 10 then
str =mw.language.new('fr'):formatDate('F Y', year .. '-' .. month) -- devrait utiliser module date mais ne faut pas de lien
elseif precision == 11  then
str = mw.language.new('fr'):formatDate('j F Y', day .. '-' .. year .. '-' .. month)
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
end
return value()
end
if era == '-' then
str = str .. ' av. J.-C.'
end
return str
end
end


 
local function fromdate(d) -- retourne "à partir de date" en langage naturel
local function upto(endpoint, lang)
local str = simplestring(d)
local precision = tonumber(endpoint.precision) -- may need 2 precisions for start and end
local value =
if d.precision >= 11 then
function()
return 'à partir du ' .. datestring
if precision > 10 then -- precision > month
else
return "jusqu'au " .. totext(endpoint, lang)
if vowelfirst(str) then
else
return "à partir d'" .. datestring
return "jusqu'à " .. totext(endpoint, lang)
else
end
return 'à partir de ' .. datestring
end
end
return value()
end
end
end


function p.wikibasedaterange(timedata, lang, case)
function p.upto(d) -- retourne "jusqu'à date' en langage naturel
local startpoint, endpoint, timepoint = timedata.startpoint, timedata.endpoint, timedata.timepoint
local datestring = p.simplestring(d)
if startpoint and endpoint then
local precision = d.precision
return fromuntil(startpoint, endpoint, lang)
if (precision >= 11) then  
return 'jusqu\'au ' .. datestring
elseif (precision >= 9) then
return "jusqu'à " .. datestring
else
return "jusqu\'en " .. datestring
end
end
if startpoint then
end
return from(startpoint, lang)
 
end
local function fromuntil(startpoint, endpoint)
if endpoint then
local precision = endpoint.precision -- may need 2 precisions for start and end dates
return upto(endpoint, lang)
local startstr = p.simplestring(startpoint)
end
local endstr = p.simplestring(endpoint)
if timepoint then
-- à améliorer pour éviter les tournures répétitives comme  "du 13 septembre 2006 au 18 september 2006"
return datemodule.Wikibasedate(timepoint, lang)
-- on dit "du 3 au 14 janvier" mais "de septembe à octobre
if precision >= 11 then -- >= day
return "du " .. startsr .. " au " ..  endstr
else
if vowelfirst(startstr) then
return "d'" .. startstr .. " à ".. endstr
else
return "de " .. startstr .. " à " .. endstr
end
end
end
end
end


function p.compactdaterange(timedata, lang) -- YXXX-YXXX format
function p.fuzzydate(dateobjet)
local startyear, endyear = '', ''
local str = simplestring(dateobject)
if timedata.startpoint then
return "vers " .. str
startyear = string.sub(timedata.startpoint.time, 9, 12)
end
 
function p.daterange(startpointobject, endpointobject)
if startpointobject and endpointobject then
return fromuntil(startpointobject, endpointobject)
elseif startpointobject then
return fromdate(startpointobject)
elseif endpointobject then
return upto(endpointobject)
else
return nil
end
end
if timedata.endpoint then
endyear = string.sub(timedata.endpoint.time, 9, 12)
end
-- remove leading zeros
while string.sub(startyear, 1,1) == '0' do
startyear = string.sub(startyear, 2)
end
while string.sub(endyear, 1,1) == '0' do
endyear = string.sub(endyear, 2)
end
return startyear .. '-' .. endyear
end
end
return p
return p

Version du 18 janvier 2015 à 14:42

local datemodule = require('Module:Date') local linguistic = require('Module:Linguisique') 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 centuryString(centurynumber) return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { century }} .. 'e siècle' end

local function decadeString(decadenumber) return 'années ' .. decade .. '0' end

function p.simplestring(dateobject) -- transforme un object date ponctuel en texte local str local year, month, day = dateobject.year, dateobject.month, dateobject.day local era = dateobject.era local precision = dateobject.precision if object.precision == 7 then local century = tostring(math.floor(year/100)) str = centuryString(century) elseif precision == 8 then local decade = tostring(math.floor(year/10)) str = decadestring(decade) elseif precision == 9 then str = tostring(year) elseif precision == 10 then str =mw.language.new('fr'):formatDate('F Y', year .. '-' .. month) -- devrait utiliser module date mais ne faut pas de lien elseif precision == 11 then str = mw.language.new('fr'):formatDate('j F Y', day .. '-' .. year .. '-' .. month) if day == 1 then -- ajustement "1 janvier" -> 1er janvier str = string.gsub(t, '1', "1er", 1) -- remplacer "1 janvier" par "1er janvier" end end if era == '-' then str = str .. ' av. J.-C.' end return str end

local function fromdate(d) -- retourne "à partir de date" en langage naturel local str = simplestring(d)

if d.precision >= 11 then return 'à partir du ' .. datestring else if vowelfirst(str) then return "à partir d'" .. datestring else return 'à partir de ' .. datestring end end end

function p.upto(d) -- retourne "jusqu'à date' en langage naturel local datestring = p.simplestring(d) local precision = d.precision if (precision >= 11) then return 'jusqu\'au ' .. datestring elseif (precision >= 9) then return "jusqu'à " .. datestring else return "jusqu\'en " .. datestring end end

local function fromuntil(startpoint, endpoint) local precision = endpoint.precision -- 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"

-- on dit "du 3 au 14 janvier" mais "de septembe à octobre if precision >= 11 then -- >= day return "du " .. startsr .. " au " .. endstr else if vowelfirst(startstr) then return "d'" .. startstr .. " à ".. endstr else return "de " .. startstr .. " à " .. endstr end end end

function p.fuzzydate(dateobjet) local str = simplestring(dateobject) return "vers " .. str end

function p.daterange(startpointobject, endpointobject) if startpointobject and endpointobject then return fromuntil(startpointobject, endpointobject) elseif startpointobject then return fromdate(startpointobject) elseif endpointobject then return upto(endpointobject) else return nil end end

return p

Récupérée de « https://lagny-sur-marne.wiki/index.php?title=Module:Date_complexe&oldid=8702 »