Module:Date: Difference between revisions
Jump to navigation
Jump to search
Content added Content deleted
(tweak formatted output; extract_date to parse an input date string) |
(major refactor, mostly working now; add/subtract with a date; remove template handling which will be in Module:Age) |
||
Line 19: | Line 19: | ||
local function strip_to_nil(text) |
local function strip_to_nil(text) |
||
-- |
-- If text is a string, return its trimmed content, or nil. |
||
-- Otherwise return text (convenient when Date fields are provided from |
|||
-- If text is a non-blank string, return its content after trimming. |
|||
-- another module which is able to pass, for example, a number). |
|||
-- Otherwise return text (convenient when accessed via another module). |
|||
if type(text) == 'string' then |
if type(text) == 'string' then |
||
text = text:match('(%S.-)%s*$') |
|||
if result == '' then |
|||
return nil |
|||
end |
|||
return result |
|||
end |
|||
if text == nil then |
|||
return nil |
|||
end |
end |
||
return text |
return text |
||
Line 63: | Line 56: | ||
-- Return jd, jdz from a Julian or Gregorian calendar date where |
-- Return jd, jdz from a Julian or Gregorian calendar date where |
||
-- jd = Julian date and its fractional part is zero at noon |
-- jd = Julian date and its fractional part is zero at noon |
||
-- jdz = |
-- jdz = same, but assume time is 00:00:00 if no time given |
||
-- http://www.tondering.dk/claus/cal/julperiod.php#formula |
-- http://www.tondering.dk/claus/cal/julperiod.php#formula |
||
-- Testing shows this works for all dates from year -9999 to 9999! |
-- Testing shows this works for all dates from year -9999 to 9999! |
||
Line 69: | Line 62: | ||
-- 1 January 4713 BC = (-4712, 1, 1) Julian calendar |
-- 1 January 4713 BC = (-4712, 1, 1) Julian calendar |
||
-- 24 November 4714 BC = (-4713, 11, 24) Gregorian calendar |
-- 24 November 4714 BC = (-4713, 11, 24) Gregorian calendar |
||
if not date.isvalid then |
|||
return 0, 0 -- always return numbers to simplify usage |
|||
end |
|||
local floor = math.floor |
local floor = math.floor |
||
local offset |
local offset |
||
Line 82: | Line 72: | ||
end |
end |
||
local m = date.month + 12*a - 3 |
local m = date.month + 12*a - 3 |
||
local |
local jd = date.day + floor((153*m + 2)/5) + 365*y + offset |
||
local time_part, zbias |
|||
if date.hastime then |
if date.hastime then |
||
jd = jd + (date.hour + (date.minute + date.second / 60) /60) / 24 - 0.5 |
|||
return jd, jd |
|||
else |
|||
time_part = 0 |
|||
zbias = -0.5 |
|||
end |
end |
||
return jd, jd - 0.5 |
|||
local jd = date_part + time_part |
|||
return jd, jd + zbias |
|||
end |
end |
||
local function set_date_from_jd(date) |
local function set_date_from_jd(date) |
||
-- Set the fields of table date from its Julian date field. |
-- Set the fields of table date from its Julian date field. |
||
-- Return true if date is valid. |
|||
-- http://www.tondering.dk/claus/cal/julperiod.php#formula |
-- http://www.tondering.dk/claus/cal/julperiod.php#formula |
||
-- This handles the proleptic Julian and Gregorian calendars. |
-- This handles the proleptic Julian and Gregorian calendars. |
||
Line 112: | Line 98: | ||
end |
end |
||
if not (limits[1] <= jd and jd <= limits[2]) then |
if not (limits[1] <= jd and jd <= limits[2]) then |
||
date.isvalid = false |
|||
return |
return |
||
end |
end |
||
date.isvalid = true |
|||
local jdn = floor(jd) |
local jdn = floor(jd) |
||
if date.hastime then |
if date.hastime then |
||
Line 152: | Line 136: | ||
date.month = m + 3 - 12*floor(m/10) |
date.month = m + 3 - 12*floor(m/10) |
||
date.year = 100*b + d - 4800 + floor(m/10) |
date.year = 100*b + d - 4800 + floor(m/10) |
||
return true |
|||
end |
end |
||
Line 189: | Line 174: | ||
date.minute = M -- 0 to 59 |
date.minute = M -- 0 to 59 |
||
date.second = S -- 0 to 59 |
date.second = S -- 0 to 59 |
||
date.isvalid = true |
|||
if type(options) == 'table' then |
if type(options) == 'table' then |
||
for _, k in ipairs({ 'am', 'era' }) do |
for _, k in ipairs({ 'am', 'era' }) do |
||
Line 200: | Line 184: | ||
end |
end |
||
local function make_option_table( |
local function make_option_table(options1, options2) |
||
-- If |
-- If options1 is a string, return a table with its settings, or |
||
-- if it is a table, use its settings. |
|||
-- Otherwise return options (it should already be a table). |
|||
-- Missing options are set from options2 or defaults. |
|||
if type(options) == 'string' then |
|||
-- Valid option settings are: |
|||
-- am: 'am', 'a.m.', 'AM', 'A.M.' |
|||
-- era: 'BCMINUS', 'BCNEGATIVE', 'BC', 'B.C.', 'BCE', 'B.C.E.', 'AD', 'A.D.', 'CE', 'C.E.' |
|||
-- Option am = 'am' does not mean the hour is AM; it means 'am' or 'pm' is used, depending on the hour. |
|||
-- Similarly, era = 'BC' means 'BC' is used if year < 0. |
|||
-- BCMINUS displays a MINUS if year < 0 and the display format does not include %{era}. |
|||
-- BCNEGATIVE is similar but displays a hyphen. |
|||
local result = {} |
|||
if type(options1) == 'table' then |
|||
result = options1 |
|||
elseif type(options1) == 'string' then |
|||
-- Example: 'am:AM era:BC' |
-- Example: 'am:AM era:BC' |
||
for item in options1:gmatch('%S+') do |
|||
local result = {} |
|||
local lhs, rhs = item:match('^(%w+):(.+)$') |
|||
local lhs, rhs = item:match('^(%w+):(.*)$') |
|||
if lhs then |
if lhs then |
||
result[lhs] = rhs |
result[lhs] = rhs |
||
end |
end |
||
end |
end |
||
return result |
|||
end |
end |
||
options2 = type(options2) == 'table' and options2 or {} |
|||
return options |
|||
local defaults = { am = 'am', era = 'BC' } |
|||
for k, v in pairs(defaults) do |
|||
result[k] = result[k] or options2[k] or v |
|||
end |
|||
return result |
|||
end |
|||
local era_text = { |
|||
-- Text for displaying an era with a positive year (after adjusting |
|||
-- by replacing year with 1 - year if date.year <= 0). |
|||
-- options.era = { year<=0 , year>0 } |
|||
['BCMINUS'] = { 'BC' , '' , isbc = true, sign = MINUS }, |
|||
['BCNEGATIVE'] = { 'BC' , '' , isbc = true, sign = '-' }, |
|||
['BC'] = { 'BC' , '' , isbc = true }, |
|||
['B.C.'] = { 'B.C.' , '' , isbc = true }, |
|||
['BCE'] = { 'BCE' , '' , isbc = true }, |
|||
['B.C.E.'] = { 'B.C.E.', '' , isbc = true }, |
|||
['AD'] = { 'BC' , 'AD' }, |
|||
['A.D.'] = { 'B.C.' , 'A.D.' }, |
|||
['CE'] = { 'BCE' , 'CE' }, |
|||
['C.E.'] = { 'B.C.E.', 'C.E.' }, |
|||
} |
|||
local function get_era_for_year(era, year) |
|||
return (era_text[era or 'BC'] or {})[year > 0 and 2 or 1] or '' |
|||
end |
end |
||
Line 220: | Line 238: | ||
-- Return date formatted as a string using codes similar to those |
-- Return date formatted as a string using codes similar to those |
||
-- in the C strftime library function. |
-- in the C strftime library function. |
||
local sformat = string.format |
|||
if not date.isvalid then |
|||
return '(invalid)' |
|||
end |
|||
local shortcuts = { |
local shortcuts = { |
||
['%c'] = '%-I:%M %p %-d %B %Y%{era}', -- date and time: 2:30 pm 1 April 2016 |
['%c'] = '%-I:%M %p %-d %B %-Y %{era}', -- date and time: 2:30 pm 1 April 2016 |
||
['%x'] = '%-d %B %Y%{era}', -- date: 1 April 2016 |
['%x'] = '%-d %B %-Y %{era}', -- date: 1 April 2016 |
||
['%X'] = '%-I:%M %p', -- time: 2:30 pm |
['%X'] = '%-I:%M %p', -- time: 2:30 pm |
||
} |
} |
||
if shortcuts[format] then |
|||
format = shortcuts[format] |
|||
end |
|||
local codes = { |
local codes = { |
||
a = { field = 'dayabbr' }, |
a = { field = 'dayabbr' }, |
||
Line 245: | Line 264: | ||
p = { field = 'hour', special = 'am' }, |
p = { field = 'hour', special = 'am' }, |
||
} |
} |
||
options = make_option_table(options |
options = make_option_table(options, date.options) |
||
local amopt = options.am |
local amopt = options.am |
||
local eraopt = options.era |
local eraopt = options.era |
||
local function replace_code(modifier, id) |
local function replace_code(spaces, modifier, id) |
||
local code = codes[id] |
local code = codes[id] |
||
if code then |
if code then |
||
Line 267: | Line 286: | ||
['A.M.'] = { 'A.M.', 'P.M.' }, |
['A.M.'] = { 'A.M.', 'P.M.' }, |
||
})[amopt] or { 'am', 'pm' } |
})[amopt] or { 'am', 'pm' } |
||
return value < 12 and ap[1] or ap[2] |
return (spaces == '' and '' or ' ') .. (value < 12 and ap[1] or ap[2]) |
||
end |
end |
||
end |
end |
||
if code.field == 'year' then |
if code.field == 'year' then |
||
local sign = (era_text[eraopt] or {}).sign |
|||
if eraopt == 'BCMINUS' or eraopt == 'BCNEGATIVE' then |
|||
if not sign or format:find('%{era}', 1, true) then |
|||
local sign |
|||
sign = '' |
|||
if value <= 0 then |
|||
value = 1 - value |
|||
end |
|||
else |
|||
if value >= 0 then |
if value >= 0 then |
||
sign = '' |
sign = '' |
||
else |
else |
||
sign = eraopt == 'BCMINUS' and MINUS or '-' |
|||
value = -value |
value = -value |
||
end |
end |
||
return sign .. string.format(fmt, value) |
|||
end |
|||
if value <= 0 then |
|||
value = 1 - value |
|||
end |
end |
||
return spaces .. sign .. sformat(fmt, value) |
|||
end |
end |
||
return fmt and |
return spaces .. (fmt and sformat(fmt, value) or value) |
||
end |
end |
||
end |
end |
||
local function replace_property(id) |
local function replace_property(spaces, id) |
||
if id == 'era' then |
|||
-- Special case so can use local era option. |
|||
local result = get_era_for_year(eraopt, date.year) |
|||
if result == '' then |
|||
return '' |
|||
end |
|||
return (spaces == '' and '' or ' ') .. result |
|||
end |
|||
local result = date[id] |
local result = date[id] |
||
if type(result) == 'string' then |
if type(result) == 'string' then |
||
return spaces .. result |
|||
-- Assume era follows a date. |
|||
return ' ' .. result |
|||
end |
|||
return result |
|||
end |
end |
||
if type(result) == 'number' then |
if type(result) == 'number' then |
||
return tostring(result) |
return spaces .. tostring(result) |
||
end |
end |
||
if type(result) == 'boolean' then |
if type(result) == 'boolean' then |
||
return result and '1' or '0' |
return spaces .. (result and '1' or '0') |
||
end |
end |
||
-- This occurs, for example, if id is the name of a function. |
-- This occurs, for example, if id is the name of a function. |
||
return nil |
return nil |
||
end |
|||
if shortcuts[format] then |
|||
format = shortcuts[format] |
|||
end |
end |
||
local PERCENT = '\127PERCENT\127' |
local PERCENT = '\127PERCENT\127' |
||
return (format |
return (format |
||
:gsub('%%%%', PERCENT) |
:gsub('%%%%', PERCENT) |
||
:gsub('%%{(%w+)}', replace_property) |
:gsub('(%s*)%%{(%w+)}', replace_property) |
||
:gsub('%%(-?)(%a)', replace_code) |
:gsub('(%s*)%%(-?)(%a)', replace_code) |
||
:gsub(PERCENT, '%%') |
:gsub(PERCENT, '%%') |
||
) |
) |
||
end |
end |
||
local function |
local function _date_text(date, fmt, options) |
||
-- Return formatted string from given date. |
-- Return formatted string from given date. |
||
if not (type(date) == 'table' and date.isvalid) then |
|||
return '(invalid)' |
|||
end |
|||
if type(fmt) ~= 'string' then |
if type(fmt) ~= 'string' then |
||
fmt = '% |
fmt = '%-d %B %-Y %{era}' |
||
if date.hastime then |
if date.hastime then |
||
if date.second > 0 then |
if date.second > 0 then |
||
fmt = |
fmt = '%H:%M:%S ' .. fmt |
||
else |
else |
||
fmt = |
fmt = '%H:%M ' .. fmt |
||
end |
end |
||
end |
end |
||
return strftime(date, fmt, options |
return strftime(date, fmt, options) |
||
end |
end |
||
if fmt:find('%', 1, true) then |
if fmt:find('%', 1, true) then |
||
Line 345: | Line 363: | ||
f = '%H:%M:%S' |
f = '%H:%M:%S' |
||
elseif item == 'ymd' then |
elseif item == 'ymd' then |
||
f = '%Y |
f = '%Y-%m-%d %{era}' |
||
elseif item == 'mdy' then |
elseif item == 'mdy' then |
||
f = '%B %-d, %Y%{era}' |
f = '%B %-d, %-Y %{era}' |
||
elseif item == 'dmy' then |
elseif item == 'dmy' then |
||
f = '%-d %B %Y%{era}' |
f = '%-d %B %-Y %{era}' |
||
else |
else |
||
return '(invalid format)' |
return '(invalid format)' |
||
Line 418: | Line 436: | ||
end |
end |
||
}) |
}) |
||
local function date_component(named, positional, component) |
|||
-- Return the first of the two arguments (named like {{example|year=2001}} |
|||
-- or positional like {{example|2001}}) that is not nil and is not empty. |
|||
-- If both are nil, return the current date component, if specified. |
|||
-- This translates empty arguments passed to the template to nil, and |
|||
-- optionally replaces a nil argument with a value from the current date. |
|||
named = strip_to_nil(named) |
|||
if named then |
|||
return named |
|||
end |
|||
positional = strip_to_nil(positional) |
|||
if positional then |
|||
return positional |
|||
end |
|||
if component then |
|||
return current[component] |
|||
end |
|||
return nil |
|||
end |
|||
local era_text = { |
|||
-- options.era = { year<0 , year>0 } |
|||
['BCMINUS'] = { MINUS , '' }, |
|||
['BCNEGATIVE'] = { '-' , '' }, |
|||
['BC'] = { 'BC' , '' }, |
|||
['B.C.'] = { 'B.C.' , '' }, |
|||
['BCE'] = { 'BCE' , '' }, |
|||
['B.C.E.'] = { 'B.C.E.', '' }, |
|||
['AD'] = { 'BC' , 'AD' }, |
|||
['A.D.'] = { 'B.C.' , 'A.D.' }, |
|||
['CE'] = { 'BCE' , 'CE' }, |
|||
['C.E.'] = { 'B.C.E.', 'C.E.' }, |
|||
} |
|||
local function extract_date(text) |
local function extract_date(text) |
||
Line 459: | Line 443: | ||
-- or return nothing if date is known to be invalid. |
-- or return nothing if date is known to be invalid. |
||
-- Caller determines if the values in n are valid. |
-- Caller determines if the values in n are valid. |
||
-- A year must be positive ('1' to '9999'); use 'BC' for BC. |
|||
-- Dates of form d/m/y, m/d/y, y/m/d are rejected as ambiguous and undesirable. |
|||
-- In a y-m-d string, the year must be four digits to avoid ambiguity |
|||
-- ('0001' to '9999'). The only way to enter year <= 0 is by specifying |
|||
-- the date as three numeric parameters like ymd Date(-1, 1, 1). |
|||
-- Dates of form d/m/y, m/d/y, y/m/d are rejected as ambiguous. |
|||
local date, options = {}, {} |
local date, options = {}, {} |
||
local function extract_ymd(item) |
local function extract_ymd(item) |
||
Line 537: | Line 525: | ||
end |
end |
||
for item in text:gsub(',', ' '):gmatch('%S+') do |
for item in text:gsub(',', ' '):gmatch('%S+') do |
||
-- Accept options in peculiar places; if duplicated, last wins. |
|||
item_count = item_count + 1 |
item_count = item_count + 1 |
||
if era_text[item] then |
if era_text[item] then |
||
-- Era is accepted in peculiar places. |
|||
if options.era then |
|||
return |
|||
end |
|||
options.era = item |
options.era = item |
||
elseif ampm_options[item] then |
elseif ampm_options[item] then |
||
Line 574: | Line 565: | ||
end |
end |
||
end |
end |
||
end |
|||
if not date.y or date.y == 0 then |
|||
return |
|||
end |
|||
local era = era_text[options.era] |
|||
if era and era.isbc then |
|||
date.y = 1 - date.y |
|||
end |
end |
||
return date, options |
return date, options |
||
end |
|||
local Date, DateDiff, datemt -- forward declarations |
|||
local function is_date(t) |
|||
return type(t) == 'table' and getmetatable(t) == datemt |
|||
end |
|||
local function date_add_sub(lhs, rhs, is_sub) |
|||
-- Return a new date from calculating (lhs + rhs) or (lhs - rhs), |
|||
-- or return nothing if invalid. |
|||
-- Caller ensures that lhs is a date; its properties are copied for the new date. |
|||
local function is_prefix(text, word, minlen) |
|||
local n = #text |
|||
return (minlen or 1) <= n and n <= #word and text == word:sub(1, n) |
|||
end |
|||
local function do_days(n) |
|||
if is_sub then |
|||
n = -n |
|||
end |
|||
return Date(lhs, 'juliandate', lhs.jd + n) |
|||
end |
|||
if type(rhs) == 'number' then |
|||
-- Add days, including fractional days. |
|||
return do_days(rhs) |
|||
end |
|||
if type(rhs) == 'string' then |
|||
-- rhs is a single component like '26m' or '26 months' (unsigned integer only). |
|||
local num, id = rhs:match('^%s*(%d+)%s*(%a+)$') |
|||
if num then |
|||
local y, m |
|||
num = tonumber(num) |
|||
id = id:lower() |
|||
if is_prefix(id, 'years') then |
|||
y = num |
|||
m = 0 |
|||
elseif is_prefix(id, 'months') then |
|||
y = math.floor(num / 12) |
|||
m = num % 12 |
|||
elseif is_prefix(id, 'weeks') then |
|||
return do_days(num * 7) |
|||
elseif is_prefix(id, 'days') then |
|||
return do_days(num) |
|||
elseif is_prefix(id, 'hours') then |
|||
return do_days(num / 24) |
|||
elseif is_prefix(id, 'minutes', 3) then |
|||
return do_days(num / (24 * 60)) |
|||
elseif is_prefix(id, 'seconds') then |
|||
return do_days(num / (24 * 3600)) |
|||
else |
|||
return |
|||
end |
|||
if is_sub then |
|||
y = -y |
|||
m = -m |
|||
end |
|||
assert(-11 <= m and m <= 11) |
|||
y = lhs.year + y |
|||
m = lhs.month + m |
|||
if m > 12 then |
|||
y = y + 1 |
|||
m = m - 12 |
|||
elseif m < 1 then |
|||
y = y - 1 |
|||
m = m + 12 |
|||
end |
|||
local d = math.min(lhs.day, days_in_month(y, m, lhs.calname)) |
|||
return Date(lhs, y, m, d) |
|||
end |
|||
end |
|||
end |
end |
||
-- Metatable for some operations on dates. |
-- Metatable for some operations on dates. |
||
datemt = { -- for forward declaration above |
|||
-- For Lua 5.1, __lt does not work if the metatable is an anonymous table. |
|||
__add = function (lhs, rhs) |
|||
local Date -- forward declaration |
|||
if not is_date(lhs) then |
|||
local datemt = { |
|||
lhs, rhs = rhs, lhs -- put date on left (it must be a date for this to have been called) |
|||
end |
|||
return date_add_sub(lhs, rhs) |
|||
end, |
|||
__sub = function (lhs, rhs) |
|||
if is_date(lhs) then |
|||
if is_date(rhs) then |
|||
return DateDiff(lhs, rhs) |
|||
end |
|||
return date_add_sub(lhs, rhs, true) |
|||
end |
|||
end, |
|||
__concat = function (lhs, rhs) |
|||
return tostring(lhs) .. tostring(rhs) |
|||
end, |
|||
__tostring = function (self) |
|||
return self:text() |
|||
end, |
|||
__eq = function (lhs, rhs) |
__eq = function (lhs, rhs) |
||
-- Return true if dates identify same date/time where, for example, |
-- Return true if dates identify same date/time where, for example, |
||
-- (-4712, 1, 1, 'Julian') == (-4713, 11, 24, 'Gregorian'). |
-- Date(-4712, 1, 1, 'Julian') == Date(-4713, 11, 24, 'Gregorian') is true. |
||
-- This is only called if lhs and rhs have the same metatable. |
|||
return lhs.jdz == rhs.jdz |
|||
end, |
end, |
||
__lt = function (lhs, rhs) |
__lt = function (lhs, rhs) |
||
-- Return true if lhs < rhs |
-- Return true if lhs < rhs, for example, |
||
-- Date('1 Jan 2016') < Date('06:00 1 Jan 2016') is true. |
|||
if not lhs.isvalid then |
|||
-- This is only called if lhs and rhs have the same metatable. |
|||
return true |
|||
end |
|||
if not rhs.isvalid then |
|||
return false |
|||
end |
|||
return lhs.jdz < rhs.jdz |
return lhs.jdz < rhs.jdz |
||
end, |
end, |
||
Line 611: | Line 694: | ||
value = self.jd - first + 1 -- day-of-year 1 to 366 |
value = self.jd - first + 1 -- day-of-year 1 to 366 |
||
elseif key == 'era' then |
elseif key == 'era' then |
||
-- Era text from year and options. |
-- Era text (not a negative sign) from year and options. |
||
value = get_era_for_year(self.options.era, self.year) |
|||
local sign |
|||
if self.year == 0 then |
|||
sign = (eraopt == 'BCMINUS' or eraopt == 'BCNEGATIVE') and 2 or 1 |
|||
else |
|||
sign = self.year > 0 and 2 or 1 |
|||
end |
|||
value = era_text[eraopt][sign] |
|||
elseif key == 'gsd' then |
elseif key == 'gsd' then |
||
-- GSD = 1 from 00:00:00 to 23:59:59 on 1 January 1 AD Gregorian calendar, |
-- GSD = 1 from 00:00:00 to 23:59:59 on 1 January 1 AD Gregorian calendar, |
||
Line 642: | Line 718: | ||
end, |
end, |
||
} |
} |
||
local function _month_days(date, month) |
|||
return days_in_month(date.year, month, date.calname) |
|||
end |
|||
--[[ Examples of syntax to construct a date: |
--[[ Examples of syntax to construct a date: |
||
Line 649: | Line 729: | ||
Date('currentdate') |
Date('currentdate') |
||
Date('currentdatetime') |
Date('currentdatetime') |
||
LATER: Following are not yet implemented: |
|||
Date('currentdate', H, M, S) current date with given time |
|||
Date('1 April 1995', 'julian') parse date from text |
Date('1 April 1995', 'julian') parse date from text |
||
Date('1 April 1995 AD', 'julian') |
Date('1 April 1995 AD', 'julian') using an era sets a flag to do the same for output |
||
Date('04:30:59 1 April 1995', 'julian') |
Date('04:30:59 1 April 1995', 'julian') |
||
Date(date) copy of an existing date |
|||
LATER: Following is not yet implemented: |
|||
Date('currentdate', H, M, S) current date with given time |
|||
]] |
]] |
||
function Date(...) -- for forward declaration above |
function Date(...) -- for forward declaration above |
||
-- Return a table |
-- Return a table holding a date assuming a uniform calendar always applies |
||
-- (proleptic Gregorian calendar or proleptic Julian calendar), or |
|||
-- If invalid, return an empty table which is regarded as invalid. |
|||
-- return nothing if date is invalid. |
|||
local is_copy |
|||
local calendars = { julian = 'Julian', gregorian = 'Gregorian' } |
local calendars = { julian = 'Julian', gregorian = 'Gregorian' } |
||
local result = { |
local result = { |
||
isvalid = false, -- false avoids __index lookup |
|||
calname = 'Gregorian', -- default is Gregorian calendar |
calname = 'Gregorian', -- default is Gregorian calendar |
||
hastime = false, -- true if input sets a time |
hastime = false, -- true if input sets a time |
||
Line 666: | Line 748: | ||
minute = 0, |
minute = 0, |
||
second = 0, |
second = 0, |
||
month_days = |
month_days = _month_days, |
||
options = make_option_table(), |
|||
return days_in_month(self.year, month, self.calname) |
|||
text = _date_text, |
|||
end, |
|||
-- Valid option settings are: |
|||
-- am: 'am', 'a.m.', 'AM', 'A.M.' |
|||
-- era: 'BCMINUS', 'BCNEGATIVE', 'BC', 'B.C.', 'BCE', 'B.C.E.', 'AD', 'A.D.', 'CE', 'C.E.' |
|||
options = { am = 'am', era = 'BC' }, |
|||
text = date_text, |
|||
} |
} |
||
local argtype, datetext |
local argtype, datetext |
||
Line 684: | Line 761: | ||
elseif calendars[vlower] then |
elseif calendars[vlower] then |
||
result.calname = calendars[vlower] |
result.calname = calendars[vlower] |
||
elseif is_date(v) then |
|||
-- Copy existing date (items can be overridden by other arguments). |
|||
if is_copy then |
|||
return |
|||
end |
|||
is_copy = true |
|||
result.calname = v.calname |
|||
result.hastime = v.hastime |
|||
result.options = v.options |
|||
result.year = v.year |
|||
result.month = v.month |
|||
result.day = v.day |
|||
result.hour = v.hour |
|||
result.minute = v.minute |
|||
result.second = v.second |
|||
else |
else |
||
local num = tonumber(v) |
local num = tonumber(v) |
||
Line 706: | Line 798: | ||
end |
end |
||
elseif argtype then |
elseif argtype then |
||
return |
return |
||
elseif type(v) == 'string' then |
elseif type(v) == 'string' then |
||
if v == 'currentdate' or v == 'currentdatetime' or v == 'juliandate' then |
if v == 'currentdate' or v == 'currentdatetime' or v == 'juliandate' then |
||
Line 715: | Line 807: | ||
end |
end |
||
else |
else |
||
return |
return |
||
end |
end |
||
end |
end |
||
Line 723: | Line 815: | ||
set_date_from_numbers(result, |
set_date_from_numbers(result, |
||
extract_date(datetext))) then |
extract_date(datetext))) then |
||
return |
return |
||
end |
end |
||
elseif argtype == 'juliandate' then |
elseif argtype == 'juliandate' then |
||
result.jd = numbers[1] |
|||
if not (numbers.n == 1 and set_date_from_jd(result)) then |
|||
result.jd = numbers[1] |
|||
return |
|||
set_date_from_jd(result) |
|||
else |
|||
return {} |
|||
end |
end |
||
elseif argtype == 'currentdate' or argtype == 'currentdatetime' then |
elseif argtype == 'currentdate' or argtype == 'currentdatetime' then |
||
Line 743: | Line 833: | ||
end |
end |
||
result.calname = 'Gregorian' -- ignore any given calendar name |
result.calname = 'Gregorian' -- ignore any given calendar name |
||
result.isvalid = true |
|||
elseif argtype == 'setdate' then |
elseif argtype == 'setdate' then |
||
if not set_date_from_numbers(result, numbers) then |
if not set_date_from_numbers(result, numbers) then |
||
return |
return |
||
end |
end |
||
elseif not is_copy then |
|||
else |
|||
return |
return |
||
end |
end |
||
return setmetatable(result, datemt) |
return setmetatable(result, datemt) |
||
end |
end |
||
function DateDiff(date1, date2) -- for forward declaration above |
|||
-- Return a table |
-- Return a table with the difference between the two dates (date1 - date2). |
||
-- |
-- The difference is negative if date2 is more recent than date1. |
||
-- Return nothing if invalid. |
|||
-- TODO Replace with something using Julian dates? |
|||
if not (date1 and date2 and date1.calname == date2.calname) then |
|||
-- Who checks for isvalid()? |
|||
return |
|||
-- Handle calname == 'Julian' |
|||
end |
|||
local calname = 'Gregorian' -- TODO fix |
|||
local isnegative |
local isnegative |
||
if |
if date1 < date2 then |
||
isnegative = true |
isnegative = true |
||
date1, date2 = date2, date1 |
date1, date2 = date2, date1 |
||
end |
end |
||
-- It is known that date1 |
-- It is known that date1 >= date2. |
||
local y1, m1 = date1.year, date1.month |
local y1, m1 = date1.year, date1.month |
||
local y2, m2 = date2.year, date2.month |
local y2, m2 = date2.year, date2.month |
||
local years, months, days = |
local years, months, days = y1 - y2, m1 - m2, date1.day - date2.day |
||
if days < 0 then |
if days < 0 then |
||
days = days + days_in_month( |
days = days + days_in_month(y2, m2, date2.calname) |
||
months = months - 1 |
months = months - 1 |
||
end |
end |
||
Line 804: | Line 893: | ||
end, |
end, |
||
} |
} |
||
end |
|||
local function message(msg, nocat) |
|||
-- Return formatted message text for an error. |
|||
-- Can append "#FormattingError" to URL of a page with a problem to find it. |
|||
local anchor = '<span id="FormattingError" />' |
|||
local category |
|||
if not nocat and mw.title.getCurrentTitle():inNamespaces(0, 10) then |
|||
-- Category only in namespaces: 0=article, 10=template. |
|||
category = '[[Category:Age error]]' |
|||
else |
|||
category = '' |
|||
end |
|||
return anchor .. |
|||
'<strong class="error">Error: ' .. |
|||
msg .. |
|||
'</strong>' .. |
|||
category .. '\n' |
|||
end |
|||
local function age_days(frame) |
|||
-- Return age in days between two given dates, or |
|||
-- between given date and current date. |
|||
-- This code implements the logic in [[Template:Age in days]]. |
|||
-- Like {{Age in days}}, a missing argument is replaced from the current |
|||
-- date, so can get a bizarre mixture of specified/current y/m/d. |
|||
local args = frame:getParent().args |
|||
local date1 = Date( |
|||
date_component(args.year1 , args[1], 'year' ), |
|||
date_component(args.month1, args[2], 'month'), |
|||
date_component(args.day1 , args[3], 'day' ) |
|||
) |
|||
local date2 = Date( |
|||
date_component(args.year2 , args[4], 'year' ), |
|||
date_component(args.month2, args[5], 'month'), |
|||
date_component(args.day2 , args[6], 'day' ) |
|||
) |
|||
if not (date1.isvalid and date2.isvalid) then |
|||
return message('Need valid year, month, day') |
|||
end |
|||
local sign = '' |
|||
local result = date2.jd - date1.jd |
|||
if result < 0 then |
|||
sign = MINUS |
|||
result = -result |
|||
end |
|||
return sign .. tostring(result) |
|||
end |
|||
local function age_ym(frame) |
|||
-- Return age in years and months between two given dates, or |
|||
-- between given date and current date. |
|||
local args = frame:getParent().args |
|||
local fields = {} |
|||
for i = 1, 6 do |
|||
fields[i] = strip_to_nil(args[i]) |
|||
end |
|||
local date1, date2 |
|||
if fields[1] and fields[2] and fields[3] then |
|||
date1 = Date(fields[1], fields[2], fields[3]) |
|||
end |
|||
if not (date1 and date1.isvalid) then |
|||
return message('Need valid year, month, day') |
|||
end |
|||
if fields[4] and fields[5] and fields[6] then |
|||
date2 = Date(fields[4], fields[5], fields[6]) |
|||
if not date2.isvalid then |
|||
return message('Second date should be year, month, day') |
|||
end |
|||
else |
|||
date2 = Date('currentdate') |
|||
end |
|||
return DateDiff(date1, date2):age_ym() |
|||
end |
|||
local function gsd_ymd(frame) |
|||
-- Return Gregorian serial date of the given date, or the current date. |
|||
-- Like {{Gregorian serial date}}, a missing argument is replaced from the |
|||
-- current date, so can get a bizarre mixture of specified/current y/m/d. |
|||
-- This also accepts positional arguments, although the original template does not. |
|||
-- The returned value is negative for dates before 1 January 1 AD despite |
|||
-- the fact that GSD is not defined for earlier dates. |
|||
local args = frame:getParent().args |
|||
local date = Date( |
|||
date_component(args.year , args[1], 'year' ), |
|||
date_component(args.month, args[2], 'month'), |
|||
date_component(args.day , args[3], 'day' ) |
|||
) |
|||
if date.isvalid then |
|||
return tostring(date.gsd) |
|||
end |
|||
return message('Need valid year, month, day') |
|||
end |
|||
local function ymd_from_jd(frame) |
|||
-- Return formatted date from a Julian date. |
|||
-- The result is y-m-d or y-m-d H:M:S if input includes a fraction. |
|||
-- The word 'Julian' is accepted for the Julian calendar. |
|||
local args = frame:getParent().args |
|||
local date = Date('juliandate', args[1], args[2]) |
|||
if date.isvalid then |
|||
return date:text() |
|||
end |
|||
return message('Need valid Julian date number') |
|||
end |
|||
local function ymd_to_jd(frame) |
|||
-- Return Julian date (a number) from a date (y-m-d), or datetime (y-m-d H:M:S), |
|||
-- or the current date ('currentdate') or current datetime ('currentdatetime'). |
|||
-- The word 'Julian' is accepted for the Julian calendar. |
|||
local args = frame:getParent().args |
|||
local date = Date(args[1], args[2], args[3], args[4], args[5], args[6], args[7]) |
|||
if date.isvalid then |
|||
return tostring(date.jd) |
|||
end |
|||
return message('Need valid year/month/day or "currentdate"') |
|||
end |
end |
||
return { |
return { |
||
_current = current, |
|||
age_ym = age_ym, |
|||
_Date = Date, |
_Date = Date, |
||
_DateDiff = DateDiff, |
|||
days_in_month = days_in_month, |
|||
_days_in_month = days_in_month, |
|||
gsd = gsd_ymd, |
|||
JULIANDAY = ymd_to_jd, |
|||
ymd_from_jd = ymd_from_jd, |
|||
ymd_to_jd = ymd_to_jd, |
|||
} |
} |
Revision as of 03:58, 7 March 2016
Documentation for this module may be created at Module:Date/doc
-- Date functions for implementing templates and for use by other modules.
-- I18N and time zones are not supported.
local MINUS = '−' -- Unicode U+2212 MINUS SIGN
local function collection()
-- Return a table to hold items.
return {
n = 0,
add = function (self, item)
self.n = self.n + 1
self[self.n] = item
end,
join = function (self, sep)
return table.concat(self, sep)
end,
}
end
local function strip_to_nil(text)
-- If text is a string, return its trimmed content, or nil.
-- Otherwise return text (convenient when Date fields are provided from
-- another module which is able to pass, for example, a number).
if type(text) == 'string' then
text = text:match('(%S.-)%s*$')
end
return text
end
local function number_name(number, singular, plural, sep)
-- Return the given number, converted to a string, with the
-- separator (default space) and singular or plural name appended.
plural = plural or (singular .. 's')
sep = sep or ' '
return tostring(number) .. sep .. ((number == 1) and singular or plural)
end
local function is_leap_year(year, calname)
-- Return true if year is a leap year.
if calname == 'Julian' then
return year % 4 == 0
end
return (year % 4 == 0 and year % 100 ~= 0) or year % 400 == 0
end
local function days_in_month(year, month, calname)
-- Return number of days (1..31) in given month (1..12).
local month_days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
if month == 2 and is_leap_year(year, calname) then
return 29
end
return month_days[month]
end
local function julian_date(date)
-- Return jd, jdz from a Julian or Gregorian calendar date where
-- jd = Julian date and its fractional part is zero at noon
-- jdz = same, but assume time is 00:00:00 if no time given
-- http://www.tondering.dk/claus/cal/julperiod.php#formula
-- Testing shows this works for all dates from year -9999 to 9999!
-- JDN 0 is the 24-hour period starting at noon UTC on Monday
-- 1 January 4713 BC = (-4712, 1, 1) Julian calendar
-- 24 November 4714 BC = (-4713, 11, 24) Gregorian calendar
local floor = math.floor
local offset
local a = floor((14 - date.month)/12)
local y = date.year + 4800 - a
if date.calname == 'Julian' then
offset = floor(y/4) - 32083
else
offset = floor(y/4) - floor(y/100) + floor(y/400) - 32045
end
local m = date.month + 12*a - 3
local jd = date.day + floor((153*m + 2)/5) + 365*y + offset
if date.hastime then
jd = jd + (date.hour + (date.minute + date.second / 60) /60) / 24 - 0.5
return jd, jd
end
return jd, jd - 0.5
end
local function set_date_from_jd(date)
-- Set the fields of table date from its Julian date field.
-- Return true if date is valid.
-- http://www.tondering.dk/claus/cal/julperiod.php#formula
-- This handles the proleptic Julian and Gregorian calendars.
-- Negative Julian dates are not defined but they work.
local floor = math.floor
local calname = date.calname
local jd = date.jd
local limits -- min/max limits for date ranges −9999-01-01 to 9999-12-31
if calname == 'Julian' then
limits = { -1931076.5, 5373557.49999 }
elseif calname == 'Gregorian' then
limits = { -1930999.5, 5373484.49999 }
else
limits = { 1, 0 } -- impossible
end
if not (limits[1] <= jd and jd <= limits[2]) then
return
end
local jdn = floor(jd)
if date.hastime then
local time = jd - jdn
local hour
if time >= 0.5 then
jdn = jdn + 1
time = time - 0.5
hour = 0
else
hour = 12
end
time = floor(time * 24 * 3600 + 0.5) -- number of seconds after hour
date.second = time % 60
time = floor(time / 60)
date.minute = time % 60
date.hour = hour + floor(time / 60)
else
date.second = 0
date.minute = 0
date.hour = 0
end
local b, c
if calname == 'Julian' then
b = 0
c = jdn + 32082
else -- Gregorian
local a = jdn + 32044
b = floor((4*a + 3)/146097)
c = a - floor(146097*b/4)
end
local d = floor((4*c + 3)/1461)
local e = c - floor(1461*d/4)
local m = floor((5*e + 2)/153)
date.day = e - floor((153*m + 2)/5) + 1
date.month = m + 3 - 12*floor(m/10)
date.year = 100*b + d - 4800 + floor(m/10)
return true
end
local function set_date_from_numbers(date, numbers, options)
-- Set the fields of table date from numeric values.
-- Return true if date is valid.
if type(numbers) ~= 'table' then
return
end
local y = numbers.y or numbers[1]
local m = numbers.m or numbers[2]
local d = numbers.d or numbers[3]
local H = numbers.H or numbers[4]
local M = numbers.M or numbers[5] or 0
local S = numbers.S or numbers[6] or 0
if not (y and m and d) then
return
end
if not (-9999 <= y and y <= 9999 and 1 <= m and m <= 12 and
1 <= d and d <= days_in_month(y, m, date.calname)) then
return
end
if H then
date.hastime = true
else
H = 0
end
if not (0 <= H and H <= 23 and
0 <= M and M <= 59 and
0 <= S and S <= 59) then
return
end
date.year = y -- -9999 to 9999 ('n BC' → year = 1 - n)
date.month = m -- 1 to 12
date.day = d -- 1 to 31
date.hour = H -- 0 to 59
date.minute = M -- 0 to 59
date.second = S -- 0 to 59
if type(options) == 'table' then
for _, k in ipairs({ 'am', 'era' }) do
if options[k] then
date.options[k] = options[k]
end
end
end
return true
end
local function make_option_table(options1, options2)
-- If options1 is a string, return a table with its settings, or
-- if it is a table, use its settings.
-- Missing options are set from options2 or defaults.
-- Valid option settings are:
-- am: 'am', 'a.m.', 'AM', 'A.M.'
-- era: 'BCMINUS', 'BCNEGATIVE', 'BC', 'B.C.', 'BCE', 'B.C.E.', 'AD', 'A.D.', 'CE', 'C.E.'
-- Option am = 'am' does not mean the hour is AM; it means 'am' or 'pm' is used, depending on the hour.
-- Similarly, era = 'BC' means 'BC' is used if year < 0.
-- BCMINUS displays a MINUS if year < 0 and the display format does not include %{era}.
-- BCNEGATIVE is similar but displays a hyphen.
local result = {}
if type(options1) == 'table' then
result = options1
elseif type(options1) == 'string' then
-- Example: 'am:AM era:BC'
for item in options1:gmatch('%S+') do
local lhs, rhs = item:match('^(%w+):(.+)$')
if lhs then
result[lhs] = rhs
end
end
end
options2 = type(options2) == 'table' and options2 or {}
local defaults = { am = 'am', era = 'BC' }
for k, v in pairs(defaults) do
result[k] = result[k] or options2[k] or v
end
return result
end
local era_text = {
-- Text for displaying an era with a positive year (after adjusting
-- by replacing year with 1 - year if date.year <= 0).
-- options.era = { year<=0 , year>0 }
['BCMINUS'] = { 'BC' , '' , isbc = true, sign = MINUS },
['BCNEGATIVE'] = { 'BC' , '' , isbc = true, sign = '-' },
['BC'] = { 'BC' , '' , isbc = true },
['B.C.'] = { 'B.C.' , '' , isbc = true },
['BCE'] = { 'BCE' , '' , isbc = true },
['B.C.E.'] = { 'B.C.E.', '' , isbc = true },
['AD'] = { 'BC' , 'AD' },
['A.D.'] = { 'B.C.' , 'A.D.' },
['CE'] = { 'BCE' , 'CE' },
['C.E.'] = { 'B.C.E.', 'C.E.' },
}
local function get_era_for_year(era, year)
return (era_text[era or 'BC'] or {})[year > 0 and 2 or 1] or ''
end
local function strftime(date, format, options)
-- Return date formatted as a string using codes similar to those
-- in the C strftime library function.
local sformat = string.format
local shortcuts = {
['%c'] = '%-I:%M %p %-d %B %-Y %{era}', -- date and time: 2:30 pm 1 April 2016
['%x'] = '%-d %B %-Y %{era}', -- date: 1 April 2016
['%X'] = '%-I:%M %p', -- time: 2:30 pm
}
if shortcuts[format] then
format = shortcuts[format]
end
local codes = {
a = { field = 'dayabbr' },
A = { field = 'dayname' },
b = { field = 'monthabbr' },
B = { field = 'monthname' },
u = { fmt = '%d' , field = 'dowiso' },
w = { fmt = '%d' , field = 'dow' },
d = { fmt = '%02d', fmt2 = '%d', field = 'day' },
m = { fmt = '%02d', fmt2 = '%d', field = 'month' },
Y = { fmt = '%04d', fmt2 = '%d', field = 'year' },
H = { fmt = '%02d', fmt2 = '%d', field = 'hour' },
M = { fmt = '%02d', fmt2 = '%d', field = 'minute' },
S = { fmt = '%02d', fmt2 = '%d', field = 'second' },
j = { fmt = '%03d', fmt2 = '%d', field = 'doy' },
I = { fmt = '%02d', fmt2 = '%d', field = 'hour', special = 'hour12' },
p = { field = 'hour', special = 'am' },
}
options = make_option_table(options, date.options)
local amopt = options.am
local eraopt = options.era
local function replace_code(spaces, modifier, id)
local code = codes[id]
if code then
local fmt = code.fmt
if modifier == '-' and code.fmt2 then
fmt = code.fmt2
end
local value = date[code.field]
local special = code.special
if special then
if special == 'hour12' then
value = value % 12
value = value == 0 and 12 or value
elseif special == 'am' then
local ap = ({
['a.m.'] = { 'a.m.', 'p.m.' },
['AM'] = { 'AM', 'PM' },
['A.M.'] = { 'A.M.', 'P.M.' },
})[amopt] or { 'am', 'pm' }
return (spaces == '' and '' or ' ') .. (value < 12 and ap[1] or ap[2])
end
end
if code.field == 'year' then
local sign = (era_text[eraopt] or {}).sign
if not sign or format:find('%{era}', 1, true) then
sign = ''
if value <= 0 then
value = 1 - value
end
else
if value >= 0 then
sign = ''
else
value = -value
end
end
return spaces .. sign .. sformat(fmt, value)
end
return spaces .. (fmt and sformat(fmt, value) or value)
end
end
local function replace_property(spaces, id)
if id == 'era' then
-- Special case so can use local era option.
local result = get_era_for_year(eraopt, date.year)
if result == '' then
return ''
end
return (spaces == '' and '' or ' ') .. result
end
local result = date[id]
if type(result) == 'string' then
return spaces .. result
end
if type(result) == 'number' then
return spaces .. tostring(result)
end
if type(result) == 'boolean' then
return spaces .. (result and '1' or '0')
end
-- This occurs, for example, if id is the name of a function.
return nil
end
local PERCENT = '\127PERCENT\127'
return (format
:gsub('%%%%', PERCENT)
:gsub('(%s*)%%{(%w+)}', replace_property)
:gsub('(%s*)%%(-?)(%a)', replace_code)
:gsub(PERCENT, '%%')
)
end
local function _date_text(date, fmt, options)
-- Return formatted string from given date.
if type(fmt) ~= 'string' then
fmt = '%-d %B %-Y %{era}'
if date.hastime then
if date.second > 0 then
fmt = '%H:%M:%S ' .. fmt
else
fmt = '%H:%M ' .. fmt
end
end
return strftime(date, fmt, options)
end
if fmt:find('%', 1, true) then
return strftime(date, fmt, options)
end
local t = collection()
for item in fmt:gmatch('%S+') do
local f
if item == 'hm' then
f = '%H:%M'
elseif item == 'hms' then
f = '%H:%M:%S'
elseif item == 'ymd' then
f = '%Y-%m-%d %{era}'
elseif item == 'mdy' then
f = '%B %-d, %-Y %{era}'
elseif item == 'dmy' then
f = '%-d %B %-Y %{era}'
else
return '(invalid format)'
end
t:add(f)
end
return strftime(date, t:join(' '), options)
end
local day_info = {
-- 0=Sun to 6=Sat
[0] = { 'Sun', 'Sunday' },
{ 'Mon', 'Monday' },
{ 'Tue', 'Tuesday' },
{ 'Wed', 'Wednesday' },
{ 'Thu', 'Thursday' },
{ 'Fri', 'Friday' },
{ 'Sat', 'Saturday' },
}
local month_info = {
-- 1=Jan to 12=Dec
{ 'Jan', 'January' },
{ 'Feb', 'February' },
{ 'Mar', 'March' },
{ 'Apr', 'April' },
{ 'May', 'May' },
{ 'Jun', 'June' },
{ 'Jul', 'July' },
{ 'Aug', 'August' },
{ 'Sep', 'September' },
{ 'Oct', 'October' },
{ 'Nov', 'November' },
{ 'Dec', 'December' },
}
local function month_number(text)
if type(text) == 'string' then
local month_names = {
jan = 1, january = 1,
feb = 2, february = 2,
mar = 3, march = 3,
apr = 4, april = 4,
may = 5,
jun = 6, june = 6,
jul = 7, july = 7,
aug = 8, august = 8,
sep = 9, september = 9,
oct = 10, october = 10,
nov = 11, november = 11,
dec = 12, december = 12
}
return month_names[text:lower()]
end
end
-- A table to get the current year/month/day (UTC), but only if needed.
local current = setmetatable({}, {
__index = function (self, key)
local d = os.date('!*t')
self.year = d.year
self.month = d.month
self.day = d.day
self.hour = d.hour
self.minute = d.min
self.second = d.sec
return rawget(self, key)
end
})
local function extract_date(text)
-- Parse the date/time in text and return n, o where
-- n = table of numbers with date/time fields
-- o = table of options for AM/PM or AD/BC, if any
-- or return nothing if date is known to be invalid.
-- Caller determines if the values in n are valid.
-- A year must be positive ('1' to '9999'); use 'BC' for BC.
-- In a y-m-d string, the year must be four digits to avoid ambiguity
-- ('0001' to '9999'). The only way to enter year <= 0 is by specifying
-- the date as three numeric parameters like ymd Date(-1, 1, 1).
-- Dates of form d/m/y, m/d/y, y/m/d are rejected as ambiguous.
local date, options = {}, {}
local function extract_ymd(item)
local ystr, mstr, dstr = item:match('^(%d%d%d%d)-(%w+)-(%d%d?)$')
if ystr then
local m
if mstr:match('^%d%d?$') then
m = tonumber(mstr)
else
m = month_number(mstr)
end
if m then
date.y = tonumber(ystr)
date.m = m
date.d = tonumber(dstr)
return true
end
end
end
local function extract_month(item)
-- A month must be given as a name or abbreviation; a number would be ambiguous.
local m = month_number(item)
if m then
date.m = m
return true
end
end
local function extract_time(item)
local h, m, s = item:match('^(%d%d?):(%d%d)(:?%d*)$')
if date.H or not h then
return
end
if s ~= '' then
s = s:match('^:(%d%d)$')
if not s then
return
end
end
date.H = tonumber(h)
date.M = tonumber(m)
date.S = tonumber(s) -- nil if empty string
return true
end
local ampm_options = {
['am'] = 'am',
['AM'] = 'AM',
['a.m.'] = 'a.m.',
['A.M.'] = 'A.M.',
['pm'] = 'am', -- same as am
['PM'] = 'AM',
['p.m.'] = 'a.m.',
['P.M.'] = 'A.M.',
}
local item_count = 0
local index_time
local function set_ampm(item)
local H = date.H
if H and not options.am and index_time + 1 == item_count then
options.am = ampm_options[item]
if item:match('^[Aa]') then
if not (1 <= H and H <= 12) then
return
end
if H == 12 then
date.H = 0
end
else
if not (1 <= H and H <= 23) then
return
end
if H <= 11 then
date.H = H + 12
end
end
return true
end
end
for item in text:gsub(',', ' '):gmatch('%S+') do
item_count = item_count + 1
if era_text[item] then
-- Era is accepted in peculiar places.
if options.era then
return
end
options.era = item
elseif ampm_options[item] then
if not set_ampm(item) then
return
end
elseif item:find(':', 1, true) then
if not extract_time(item) then
return
end
index_time = item_count
elseif date.d and date.m then
if date.y then
return -- should be nothing more so item is invalid
end
if not item:match('^(%d%d?%d?%d?)$') then
return
end
date.y = tonumber(item)
elseif date.d then
if not extract_month(item) then
return
end
elseif date.m then
if not item:match('^(%d%d?)$') then
return
end
date.d = tonumber(item)
elseif not extract_ymd(item) then
if item:match('^(%d%d?)$') then
date.d = tonumber(item)
elseif not extract_month(item) then
return
end
end
end
if not date.y or date.y == 0 then
return
end
local era = era_text[options.era]
if era and era.isbc then
date.y = 1 - date.y
end
return date, options
end
local Date, DateDiff, datemt -- forward declarations
local function is_date(t)
return type(t) == 'table' and getmetatable(t) == datemt
end
local function date_add_sub(lhs, rhs, is_sub)
-- Return a new date from calculating (lhs + rhs) or (lhs - rhs),
-- or return nothing if invalid.
-- Caller ensures that lhs is a date; its properties are copied for the new date.
local function is_prefix(text, word, minlen)
local n = #text
return (minlen or 1) <= n and n <= #word and text == word:sub(1, n)
end
local function do_days(n)
if is_sub then
n = -n
end
return Date(lhs, 'juliandate', lhs.jd + n)
end
if type(rhs) == 'number' then
-- Add days, including fractional days.
return do_days(rhs)
end
if type(rhs) == 'string' then
-- rhs is a single component like '26m' or '26 months' (unsigned integer only).
local num, id = rhs:match('^%s*(%d+)%s*(%a+)$')
if num then
local y, m
num = tonumber(num)
id = id:lower()
if is_prefix(id, 'years') then
y = num
m = 0
elseif is_prefix(id, 'months') then
y = math.floor(num / 12)
m = num % 12
elseif is_prefix(id, 'weeks') then
return do_days(num * 7)
elseif is_prefix(id, 'days') then
return do_days(num)
elseif is_prefix(id, 'hours') then
return do_days(num / 24)
elseif is_prefix(id, 'minutes', 3) then
return do_days(num / (24 * 60))
elseif is_prefix(id, 'seconds') then
return do_days(num / (24 * 3600))
else
return
end
if is_sub then
y = -y
m = -m
end
assert(-11 <= m and m <= 11)
y = lhs.year + y
m = lhs.month + m
if m > 12 then
y = y + 1
m = m - 12
elseif m < 1 then
y = y - 1
m = m + 12
end
local d = math.min(lhs.day, days_in_month(y, m, lhs.calname))
return Date(lhs, y, m, d)
end
end
end
-- Metatable for some operations on dates.
datemt = { -- for forward declaration above
__add = function (lhs, rhs)
if not is_date(lhs) then
lhs, rhs = rhs, lhs -- put date on left (it must be a date for this to have been called)
end
return date_add_sub(lhs, rhs)
end,
__sub = function (lhs, rhs)
if is_date(lhs) then
if is_date(rhs) then
return DateDiff(lhs, rhs)
end
return date_add_sub(lhs, rhs, true)
end
end,
__concat = function (lhs, rhs)
return tostring(lhs) .. tostring(rhs)
end,
__tostring = function (self)
return self:text()
end,
__eq = function (lhs, rhs)
-- Return true if dates identify same date/time where, for example,
-- Date(-4712, 1, 1, 'Julian') == Date(-4713, 11, 24, 'Gregorian') is true.
-- This is only called if lhs and rhs have the same metatable.
return lhs.jdz == rhs.jdz
end,
__lt = function (lhs, rhs)
-- Return true if lhs < rhs, for example,
-- Date('1 Jan 2016') < Date('06:00 1 Jan 2016') is true.
-- This is only called if lhs and rhs have the same metatable.
return lhs.jdz < rhs.jdz
end,
__index = function (self, key)
local value
if key == 'dayabbr' then
value = day_info[self.dow][1]
elseif key == 'dayname' then
value = day_info[self.dow][2]
elseif key == 'dow' then
value = (self.jd + 1) % 7 -- day-of-week 0=Sun to 6=Sat
elseif key == 'dowiso' then
value = (self.jd % 7) + 1 -- ISO day-of-week 1=Mon to 7=Sun
elseif key == 'doy' then
local first = Date(self.year, 1, 1, self.calname).jd
value = self.jd - first + 1 -- day-of-year 1 to 366
elseif key == 'era' then
-- Era text (not a negative sign) from year and options.
value = get_era_for_year(self.options.era, self.year)
elseif key == 'gsd' then
-- GSD = 1 from 00:00:00 to 23:59:59 on 1 January 1 AD Gregorian calendar,
-- which is JDN = 1721426, and is from jd 1721425.5 to 1721426.49999.
value = math.floor(self.jd - 1721424.5)
elseif key == 'jd' or key == 'jdz' then
local jd, jdz = julian_date(self)
rawset(self, 'jd', jd)
rawset(self, 'jdz', jdz)
return key == 'jd' and jd or jdz
elseif key == 'is_leap_year' then
value = is_leap_year(self.year, self.calname)
elseif key == 'monthabbr' then
value = month_info[self.month][1]
elseif key == 'monthname' then
value = month_info[self.month][2]
end
if value ~= nil then
rawset(self, key, value)
return value
end
end,
}
local function _month_days(date, month)
return days_in_month(date.year, month, date.calname)
end
--[[ Examples of syntax to construct a date:
Date(y, m, d, 'julian') default calendar is 'gregorian'
Date(y, m, d, H, M, S, 'julian')
Date('juliandate', jd, 'julian') if jd contains "." text output includes H:M:S
Date('currentdate')
Date('currentdatetime')
Date('1 April 1995', 'julian') parse date from text
Date('1 April 1995 AD', 'julian') using an era sets a flag to do the same for output
Date('04:30:59 1 April 1995', 'julian')
Date(date) copy of an existing date
LATER: Following is not yet implemented:
Date('currentdate', H, M, S) current date with given time
]]
function Date(...) -- for forward declaration above
-- Return a table holding a date assuming a uniform calendar always applies
-- (proleptic Gregorian calendar or proleptic Julian calendar), or
-- return nothing if date is invalid.
local is_copy
local calendars = { julian = 'Julian', gregorian = 'Gregorian' }
local result = {
calname = 'Gregorian', -- default is Gregorian calendar
hastime = false, -- true if input sets a time
hour = 0, -- always set hour/minute/second so don't have to handle nil
minute = 0,
second = 0,
month_days = _month_days,
options = make_option_table(),
text = _date_text,
}
local argtype, datetext
local numbers = collection()
for _, v in ipairs({...}) do
v = strip_to_nil(v)
local vlower = type(v) == 'string' and v:lower() or nil
if v == nil then
-- Ignore empty arguments after stripping so modules can directly pass template parameters.
elseif calendars[vlower] then
result.calname = calendars[vlower]
elseif is_date(v) then
-- Copy existing date (items can be overridden by other arguments).
if is_copy then
return
end
is_copy = true
result.calname = v.calname
result.hastime = v.hastime
result.options = v.options
result.year = v.year
result.month = v.month
result.day = v.day
result.hour = v.hour
result.minute = v.minute
result.second = v.second
else
local num = tonumber(v)
if not num and argtype == 'setdate' and numbers.n == 1 then
num = month_number(v)
end
if num then
if not argtype then
argtype = 'setdate'
end
numbers:add(num)
if argtype == 'juliandate' then
if type(v) == 'string' then
if v:find('.', 1, true) then
result.hastime = true
end
elseif num ~= math.floor(num) then
-- The given value was a number. The time will be used
-- if the fractional part is nonzero.
result.hastime = true
end
end
elseif argtype then
return
elseif type(v) == 'string' then
if v == 'currentdate' or v == 'currentdatetime' or v == 'juliandate' then
argtype = v
else
argtype = 'datetext'
datetext = v
end
else
return
end
end
end
if argtype == 'datetext' then
if not (numbers.n == 0 and
set_date_from_numbers(result,
extract_date(datetext))) then
return
end
elseif argtype == 'juliandate' then
result.jd = numbers[1]
if not (numbers.n == 1 and set_date_from_jd(result)) then
return
end
elseif argtype == 'currentdate' or argtype == 'currentdatetime' then
result.year = current.year
result.month = current.month
result.day = current.day
if argtype == 'currentdatetime' then
result.hour = current.hour
result.minute = current.minute
result.second = current.second
result.hastime = true
end
result.calname = 'Gregorian' -- ignore any given calendar name
elseif argtype == 'setdate' then
if not set_date_from_numbers(result, numbers) then
return
end
elseif not is_copy then
return
end
return setmetatable(result, datemt)
end
function DateDiff(date1, date2) -- for forward declaration above
-- Return a table with the difference between the two dates (date1 - date2).
-- The difference is negative if date2 is more recent than date1.
-- Return nothing if invalid.
if not (date1 and date2 and date1.calname == date2.calname) then
return
end
local isnegative
if date1 < date2 then
isnegative = true
date1, date2 = date2, date1
end
-- It is known that date1 >= date2.
local y1, m1 = date1.year, date1.month
local y2, m2 = date2.year, date2.month
local years, months, days = y1 - y2, m1 - m2, date1.day - date2.day
if days < 0 then
days = days + days_in_month(y2, m2, date2.calname)
months = months - 1
end
if months < 0 then
months = months + 12
years = years - 1
end
return {
years = years,
months = months,
days = days,
isnegative = isnegative,
age_ym = function (self)
-- Return text specifying difference in years, months.
local sign = self.isnegative and MINUS or ''
local mtext = number_name(self.months, 'month')
local result
if self.years > 0 then
local ytext = number_name(self.years, 'year')
if self.months == 0 then
result = ytext
else
result = ytext .. ', ' .. mtext
end
else
if self.months == 0 then
sign = ''
end
result = mtext
end
return sign .. result
end,
}
end
return {
_current = current,
_Date = Date,
_DateDiff = DateDiff,
_days_in_month = days_in_month,
}