From: daurnimator Date: Wed, 6 Dec 2017 06:31:40 +0000 (+1100) Subject: Move to consistent whitespace style X-Git-Url: https://git.madduck.net/etc/awesome.git/commitdiff_plain/74d5923767607c935fff45129486ff9c4251c283?hp=a7f02985caf20b40b60fc4d8e0b84b0483ce1865 Move to consistent whitespace style --- diff --git a/examples/date_arithmetic.lua b/examples/date_arithmetic.lua index c1148fb..4065122 100644 --- a/examples/date_arithmetic.lua +++ b/examples/date_arithmetic.lua @@ -1,33 +1,33 @@ local luatz = require "luatz" -- We do this a few times ==> Convert a timestamp to timetable and normalise -local function ts2tt ( ts ) - return luatz.timetable.new_from_timestamp ( ts ) +local function ts2tt(ts) + return luatz.timetable.new_from_timestamp(ts) end -- Get the current time in UTC -local utcnow = luatz.time ( ) -local now = ts2tt ( utcnow ) -print ( now , "now (UTC)" ) +local utcnow = luatz.time() +local now = ts2tt(utcnow) +print(now, "now (UTC)") -- Get a new time object 6 months from now -local x = now:clone ( ) +local x = now:clone() x.month = x.month + 6 -x:normalise ( ) -print ( x , "6 months from now" ) +x:normalise() +print(x, "6 months from now") -- Find out what time it is in Melbourne at the moment -local melbourne = luatz.get_tz ( "Australia/Melbourne" ) -local now_in_melbourne = ts2tt ( melbourne:localise ( utcnow ) ) -print ( now_in_melbourne , "Melbourne" ) +local melbourne = luatz.get_tz("Australia/Melbourne") +local now_in_melbourne = ts2tt(melbourne:localise(utcnow)) +print(now_in_melbourne, "Melbourne") -- Six months from now in melbourne (so month is incremented; but still the same time) -local m = now_in_melbourne:clone ( ) +local m = now_in_melbourne:clone() m.month = m.month + 6 -m:normalise ( ) -print ( m , "6 months from now in melbourne" ) +m:normalise() +print(m, "6 months from now in melbourne") -- Convert time back to utc; a daylight savings transition may have taken place! -- There may be 2 results, but for we'll ignore the second possibility -local c , _ = melbourne:utctime ( m:timestamp( ) ) -print ( ts2tt ( c ) , "6 months from now in melbourne converted to utc" ) +local c, _ = melbourne:utctime(m:timestamp()) +print(ts2tt(c), "6 months from now in melbourne converted to utc") diff --git a/examples/os_date.lua b/examples/os_date.lua index deac08b..ad254ce 100644 --- a/examples/os_date.lua +++ b/examples/os_date.lua @@ -6,19 +6,19 @@ local gettime = require "luatz.gettime".gettime local new_from_timestamp = require "luatz.timetable".new_from_timestamp local get_tz = require "luatz.tzcache".get_tz -local function os_date ( format_string , timestamp ) +local function os_date(format_string, timestamp) format_string = format_string or "%c" - timestamp = timestamp or gettime ( ) - if format_string:sub ( 1 , 1 ) == "!" then -- UTC - format_string = format_string:sub ( 2 ) + timestamp = timestamp or gettime() + if format_string:sub(1, 1) == "!" then -- UTC + format_string = format_string:sub(2) else -- Localtime - timestamp = get_tz ( ):localise ( timestamp ) + timestamp = get_tz():localise(timestamp) end - local tt = new_from_timestamp ( timestamp ) + local tt = new_from_timestamp(timestamp) if format_string == "*t" then return tt else - return tt:strftime ( format_string ) + return tt:strftime(format_string) end end diff --git a/luatz/gettime.lua b/luatz/gettime.lua index d3eee80..4d6f45a 100644 --- a/luatz/gettime.lua +++ b/luatz/gettime.lua @@ -1,34 +1,34 @@ -local _M = { } +local _M = {} -_M.source , _M.resolution , _M.gettime = (function() - local has_syscall , syscall = pcall ( require , "syscall" ) +_M.source, _M.resolution, _M.gettime = (function() + local has_syscall, syscall = pcall(require, "syscall") if has_syscall and syscall.clock_gettime and syscall.c.CLOCK then local clock_id = syscall.c.CLOCK.REALTIME - local function timespec_to_number ( timespec ) - return tonumber ( timespec.tv_sec ) + tonumber ( timespec.tv_nsec ) * 1e-9 + local function timespec_to_number(timespec) + return tonumber(timespec.tv_sec) + tonumber(timespec.tv_nsec) * 1e-9 end - return "syscall.clock_gettime(CLOCK_REALTIME)" , - syscall.clock_getres and timespec_to_number ( syscall.clock_getres ( clock_id ) ) or 1e-9 , - function ( ) - return timespec_to_number ( syscall.clock_gettime ( clock_id ) ) + return "syscall.clock_gettime(CLOCK_REALTIME)", + syscall.clock_getres and timespec_to_number(syscall.clock_getres(clock_id)) or 1e-9, + function() + return timespec_to_number(syscall.clock_gettime(clock_id)) end end - local has_unix , unix = pcall ( require , "unix" ) + local has_unix, unix = pcall(require, "unix") -- On Apple devices lunix only uses gettimeofday() if has_unix and unix.clock_gettime and unix.uname and unix.uname().sysname ~= "Darwin" then - return "unix.clock_gettime(CLOCK_REALTIME)" , 1e-9 , function ( ) - return unix.clock_gettime ( ) + return "unix.clock_gettime(CLOCK_REALTIME)", 1e-9, function() + return unix.clock_gettime() end end if has_syscall and syscall.gettimeofday then - local function timeval_to_number ( timeval ) - return tonumber ( timeval.tv_sec ) + tonumber ( timeval.tv_nsec ) * 1e-6 + local function timeval_to_number(timeval) + return tonumber(timeval.tv_sec) + tonumber(timeval.tv_nsec) * 1e-6 end - return "syscall.gettimeofday()" , 1e-6 , - function ( ) - return timeval_to_number ( syscall.gettimeofday ( ) ) + return "syscall.gettimeofday()", 1e-6, + function() + return timeval_to_number(syscall.gettimeofday()) end end @@ -36,18 +36,18 @@ _M.source , _M.resolution , _M.gettime = (function() return "unix.gettimeofday()", 1e-6, unix.gettimeofday end - local has_socket , socket = pcall ( require , "socket" ) + local has_socket, socket = pcall(require, "socket") if has_socket and socket.gettime then -- on windows, this uses GetSystemTimeAsFileTime, which has resolution of 1e-7 -- on linux, this uses gettimeofday, which has resolution of 1e-6 - return "socket.gettime()" , 1e-6 , socket.gettime + return "socket.gettime()", 1e-6, socket.gettime end if ngx and ngx.now then -- luacheck: ignore 113 - return "ngx.now()" , 1e-3 , ngx.now -- luacheck: ignore 113 + return "ngx.now()", 1e-3, ngx.now -- luacheck: ignore 113 end - return "os.time()" , 1 , os.time + return "os.time()", 1, os.time end)() return _M diff --git a/luatz/init.lua b/luatz/init.lua index 1a6c835..4423189 100644 --- a/luatz/init.lua +++ b/luatz/init.lua @@ -1,9 +1,9 @@ local _M = { - gettime = require "luatz.gettime" ; - parse = require "luatz.parse" ; - strftime = require "luatz.strftime" ; - timetable = require "luatz.timetable" ; - tzcache = require "luatz.tzcache" ; + gettime = require "luatz.gettime"; + parse = require "luatz.parse"; + strftime = require "luatz.strftime"; + timetable = require "luatz.timetable"; + tzcache = require "luatz.tzcache"; } --- Top-level aliases for common functions @@ -13,28 +13,28 @@ _M.get_tz = _M.tzcache.get_tz --- Handy functions -_M.time_in = function ( tz , now ) - return _M.get_tz ( tz ):localize ( now ) +_M.time_in = function(tz, now) + return _M.get_tz(tz):localize(now) end -_M.now = function ( ) - local ts = _M.gettime.gettime ( ) - return _M.timetable.new_from_timestamp ( ts ) +_M.now = function() + local ts = _M.gettime.gettime() + return _M.timetable.new_from_timestamp(ts) end --- C-like functions -_M.gmtime = function ( ts ) - return _M.timetable.new_from_timestamp ( ts ) +_M.gmtime = function(ts) + return _M.timetable.new_from_timestamp(ts) end -_M.localtime = function ( ts ) - ts = _M.time_in ( nil , ts ) - return _M.gmtime ( ts ) +_M.localtime = function(ts) + ts = _M.time_in(nil, ts) + return _M.gmtime(ts) end -_M.ctime = function ( ts ) - return _M.strftime.asctime ( _M.localtime ( ts ) ) +_M.ctime = function(ts) + return _M.strftime.asctime(_M.localtime(ts)) end return _M diff --git a/luatz/parse.lua b/luatz/parse.lua index 648d538..089dd0e 100644 --- a/luatz/parse.lua +++ b/luatz/parse.lua @@ -5,36 +5,36 @@ local new_timetable = require "luatz.timetable".new -- Return value is not normalised (this preserves a leap second) -- If the timestamp is only partial (i.e. missing "Z" or time offset) then `tz_offset` will be nil -- TODO: Validate components are within their boundarys (e.g. 1 <= month <= 12) -local function rfc_3339 ( str , init ) - local year , month , day , hour , min , sec , patt_end = str:match ( "^(%d%d%d%d)%-(%d%d)%-(%d%d)[Tt](%d%d%.?%d*):(%d%d):(%d%d)()" , init ) -- luacheck: ignore 631 +local function rfc_3339(str, init) + local year, month, day, hour, min, sec, patt_end = str:match("^(%d%d%d%d)%-(%d%d)%-(%d%d)[Tt](%d%d%.?%d*):(%d%d):(%d%d)()", init) -- luacheck: ignore 631 if not year then return nil, "Invalid RFC 3339 timestamp" end - year = tonumber ( year ) - month = tonumber ( month ) - day = tonumber ( day ) - hour = tonumber ( hour ) - min = tonumber ( min ) - sec = tonumber ( sec ) + year = tonumber(year) + month = tonumber(month) + day = tonumber(day) + hour = tonumber(hour) + min = tonumber(min) + sec = tonumber(sec) - local tt = new_timetable ( year , month , day , hour , min , sec ) + local tt = new_timetable(year, month, day, hour, min, sec) local tz_offset - if str:match ("^[Zz]" , patt_end ) then + if str:match("^[Zz]", patt_end) then tz_offset = 0 else - local hour_offset , min_offset = str:match ( "^([+-]%d%d):(%d%d)" , patt_end ) + local hour_offset, min_offset = str:match("^([+-]%d%d):(%d%d)", patt_end) if hour_offset then - tz_offset = tonumber ( hour_offset ) * 3600 + tonumber ( min_offset ) * 60 + tz_offset = tonumber(hour_offset) * 3600 + tonumber(min_offset) * 60 else -- luacheck: ignore 542 -- Invalid RFC 3339 timestamp offset (should be Z or (+/-)hour:min) -- tz_offset will be nil end end - return tt , tz_offset + return tt, tz_offset end return { - rfc_3339 = rfc_3339 ; + rfc_3339 = rfc_3339; } diff --git a/luatz/strftime.lua b/luatz/strftime.lua index a65a706..223da0f 100644 --- a/luatz/strftime.lua +++ b/luatz/strftime.lua @@ -1,21 +1,21 @@ local strformat = string.format local floor = math.floor -local function idiv ( n , d ) - return floor ( n / d ) +local function idiv(n, d) + return floor(n / d) end local c_locale = { - abday = { "Sun" , "Mon" , "Tue" , "Wed" , "Thu" , "Fri" , "Sat" } ; - day = { "Sunday" , "Monday" , "Tuesday" , "Wednesday" , "Thursday" , "Friday" , "Saturday" } ; - abmon = { "Jan" , "Feb" , "Mar" , "Apr" , "May" , "Jun" , "Jul" , "Aug" , "Sep" , "Oct" , "Nov" , "Dec" } ; - mon = { "January" , "February" , "March" , "April" , "May" , "June" , - "July" , "August" , "September" , "October" , "November" , "December" } ; - am_pm = { "AM" , "PM" } ; + abday = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; + day = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; + abmon = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; + mon = {"January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December"}; + am_pm = {"AM", "PM"}; } --- ISO-8601 week logic -- ISO 8601 weekday as number with Monday as 1 (1-7) -local function iso_8601_weekday ( wday ) +local function iso_8601_weekday(wday) if wday == 1 then return 7 else @@ -24,7 +24,7 @@ local function iso_8601_weekday ( wday ) end local iso_8601_week do -- Years that have 53 weeks according to ISO-8601 - local long_years = { } + local long_years = {} for _, v in ipairs { 4, 9, 15, 20, 26, 32, 37, 43, 48, 54, 60, 65, 71, 76, 82, 88, 93, 99, 105, 111, 116, 122, 128, 133, 139, 144, 150, 156, 161, 167, @@ -32,179 +32,179 @@ local iso_8601_week do 257, 263, 268, 274, 280, 285, 291, 296, 303, 308, 314, 320, 325, 331, 336, 342, 348, 353, 359, 364, 370, 376, 381, 387, 392, 398 } do - long_years [ v ] = true + long_years[v] = true end - local function is_long_year ( year ) - return long_years [ year % 400 ] + local function is_long_year(year) + return long_years[year % 400] end - function iso_8601_week ( self ) - local wday = iso_8601_weekday ( self.wday ) + function iso_8601_week(self) + local wday = iso_8601_weekday(self.wday) local n = self.yday - wday local year = self.year if n < -3 then year = year - 1 - if is_long_year ( year ) then - return year , 53 , wday + if is_long_year(year) then + return year, 53, wday else - return year , 52 , wday + return year, 52, wday end - elseif n >= 361 and not is_long_year ( year ) then - return year + 1 , 1 , wday + elseif n >= 361 and not is_long_year(year) then + return year + 1, 1, wday else - return year , idiv ( n + 10 , 7 ) , wday + return year, idiv(n + 10, 7), wday end end end --- Specifiers -local t = { } -function t:a ( locale ) - return "%s" , locale.abday [ self.wday ] +local t = {} +function t:a(locale) + return "%s", locale.abday[self.wday] end -function t:A ( locale ) - return "%s" , locale.day [ self.wday ] +function t:A(locale) + return "%s", locale.day[self.wday] end -function t:b ( locale ) - return "%s" , locale.abmon [ self.month ] +function t:b(locale) + return "%s", locale.abmon[self.month] end -function t:B ( locale ) - return "%s" , locale.mon [ self.month ] +function t:B(locale) + return "%s", locale.mon[self.month] end -function t:c ( locale ) - return "%.3s %.3s%3d %.2d:%.2d:%.2d %d" , - locale.abday [ self.wday ] , locale.abmon [ self.month ] , - self.day , self.hour , self.min , self.sec , self.year +function t:c(locale) + return "%.3s %.3s%3d %.2d:%.2d:%.2d %d", + locale.abday[self.wday], locale.abmon[self.month], + self.day, self.hour, self.min, self.sec, self.year end -- Century -function t:C ( ) - return "%02d" , idiv ( self.year , 100 ) +function t:C() + return "%02d", idiv(self.year, 100) end -function t:d ( ) - return "%02d" , self.day +function t:d() + return "%02d", self.day end -- Short MM/DD/YY date, equivalent to %m/%d/%y -function t:D ( ) - return "%02d/%02d/%02d" , self.month , self.day , self.year % 100 +function t:D() + return "%02d/%02d/%02d", self.month, self.day, self.year % 100 end -function t:e ( ) - return "%2d" , self.day +function t:e() + return "%2d", self.day end -- Short YYYY-MM-DD date, equivalent to %Y-%m-%d -function t:F ( ) - return "%d-%02d-%02d" , self.year , self.month , self.day +function t:F() + return "%d-%02d-%02d", self.year, self.month, self.day end -- Week-based year, last two digits (00-99) -function t:g ( ) - return "%02d" , iso_8601_week ( self ) % 100 +function t:g() + return "%02d", iso_8601_week(self) % 100 end -- Week-based year -function t:G ( ) - return "%d" , iso_8601_week ( self ) +function t:G() + return "%d", iso_8601_week(self) end t.h = t.b -function t:H ( ) - return "%02d" , self.hour +function t:H() + return "%02d", self.hour end -function t:I ( ) - return "%02d" , (self.hour-1) % 12 + 1 +function t:I() + return "%02d", (self.hour-1) % 12 + 1 end -function t:j ( ) - return "%03d" , self.yday +function t:j() + return "%03d", self.yday end -function t:m ( ) - return "%02d" , self.month +function t:m() + return "%02d", self.month end -function t:M ( ) - return "%02d" , self.min +function t:M() + return "%02d", self.min end -- New-line character ('\n') -function t:n ( ) -- luacheck: ignore 212 +function t:n() -- luacheck: ignore 212 return "\n" end -function t:p ( locale ) +function t:p(locale) return self.hour < 12 and locale.am_pm[1] or locale.am_pm[2] end -- TODO: should respect locale -function t:r ( locale ) - return "%02d:%02d:%02d %s" , - (self.hour-1) % 12 + 1 , self.min , self.sec , +function t:r(locale) + return "%02d:%02d:%02d %s", + (self.hour-1) % 12 + 1, self.min, self.sec, self.hour < 12 and locale.am_pm[1] or locale.am_pm[2] end -- 24-hour HH:MM time, equivalent to %H:%M -function t:R ( ) - return "%02d:%02d" , self.hour , self.min +function t:R() + return "%02d:%02d", self.hour, self.min end -function t:s ( ) - return "%d" , self:timestamp ( ) +function t:s() + return "%d", self:timestamp() end -function t:S ( ) - return "%02d" , self.sec +function t:S() + return "%02d", self.sec end -- Horizontal-tab character ('\t') -function t:t ( ) -- luacheck: ignore 212 +function t:t() -- luacheck: ignore 212 return "\t" end -- ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S -function t:T ( ) - return "%02d:%02d:%02d" , self.hour , self.min , self.sec +function t:T() + return "%02d:%02d:%02d", self.hour, self.min, self.sec end -function t:u ( ) - return "%d" , iso_8601_weekday ( self.wday ) +function t:u() + return "%d", iso_8601_weekday(self.wday) end -- Week number with the first Sunday as the first day of week one (00-53) -function t:U ( ) - return "%02d" , idiv ( self.yday - self.wday + 7 , 7 ) +function t:U() + return "%02d", idiv(self.yday - self.wday + 7, 7) end -- ISO 8601 week number (00-53) -function t:V ( ) - return "%02d" , select ( 2 , iso_8601_week ( self ) ) +function t:V() + return "%02d", select(2, iso_8601_week(self)) end -- Weekday as a decimal number with Sunday as 0 (0-6) -function t:w ( ) - return "%d" , self.wday - 1 +function t:w() + return "%d", self.wday - 1 end -- Week number with the first Monday as the first day of week one (00-53) -function t:W ( ) - return "%02d" , idiv ( self.yday - iso_8601_weekday ( self.wday ) + 7 , 7 ) +function t:W() + return "%02d", idiv(self.yday - iso_8601_weekday(self.wday) + 7, 7) end -- TODO make t.x and t.X respect locale t.x = t.D t.X = t.T -function t:y ( ) - return "%02d" , self.year % 100 +function t:y() + return "%02d", self.year % 100 end -function t:Y ( ) - return "%d" , self.year +function t:Y() + return "%d", self.year end -- TODO timezones -function t:z ( ) -- luacheck: ignore 212 +function t:z() -- luacheck: ignore 212 return "+0000" end -function t:Z ( ) -- luacheck: ignore 212 +function t:Z() -- luacheck: ignore 212 return "GMT" end -- A literal '%' character. -t["%"] = function ( self ) -- luacheck: ignore 212 +t["%"] = function(self) -- luacheck: ignore 212 return "%%" end -local function strftime ( format_string , timetable ) - return ( string.gsub ( format_string , "%%([EO]?)(.)" , function ( locale_modifier , specifier ) - local func = t [ specifier ] +local function strftime(format_string, timetable) + return (string.gsub(format_string, "%%([EO]?)(.)", function(locale_modifier, specifier) + local func = t[specifier] if func then - return strformat ( func ( timetable , c_locale ) ) + return strformat(func(timetable, c_locale)) else - error ( "invalid conversation specifier '%"..locale_modifier..specifier.."'" , 3 ) + error("invalid conversation specifier '%"..locale_modifier..specifier.."'", 3) end - end ) ) + end)) end -local function asctime ( timetable ) +local function asctime(timetable) -- Equivalent to the format string "%c\n" - return strformat ( t.c ( timetable , c_locale ) ) .. "\n" + return strformat(t.c(timetable, c_locale)) .. "\n" end return { - strftime = strftime ; - asctime = asctime ; + strftime = strftime; + asctime = asctime; } diff --git a/luatz/timetable.lua b/luatz/timetable.lua index 812d497..1a304e2 100644 --- a/luatz/timetable.lua +++ b/luatz/timetable.lua @@ -14,16 +14,16 @@ local idiv do end -local mon_lengths = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } +local mon_lengths = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} -- Number of days in year until start of month; not corrected for leap years -local months_to_days_cumulative = { 0 } +local months_to_days_cumulative = {0} for i = 2, 12 do - months_to_days_cumulative [ i ] = months_to_days_cumulative [ i-1 ] + mon_lengths [ i-1 ] + months_to_days_cumulative[i] = months_to_days_cumulative[i-1] + mon_lengths[i-1] end -- For Sakamoto's Algorithm (day of week) local sakamoto = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4}; -local function is_leap ( y ) +local function is_leap(y) if (y % 4) ~= 0 then return false elseif (y % 100) ~= 0 then @@ -33,72 +33,72 @@ local function is_leap ( y ) end end -local function month_length ( m , y ) +local function month_length(m, y) if m == 2 then - return is_leap ( y ) and 29 or 28 + return is_leap(y) and 29 or 28 else - return mon_lengths [ m ] + return mon_lengths[m] end end -local function leap_years_since ( year ) - return idiv ( year , 4 ) - idiv ( year , 100 ) + idiv ( year , 400 ) +local function leap_years_since(year) + return idiv(year, 4) - idiv(year, 100) + idiv(year, 400) end -local function day_of_year ( day , month , year ) - local yday = months_to_days_cumulative [ month ] - if month > 2 and is_leap ( year ) then +local function day_of_year(day, month, year) + local yday = months_to_days_cumulative[month] + if month > 2 and is_leap(year) then yday = yday + 1 end return yday + day end -local function day_of_week ( day , month , year ) +local function day_of_week(day, month, year) if month < 3 then year = year - 1 end - return ( year + leap_years_since ( year ) + sakamoto[month] + day ) % 7 + 1 + return(year + leap_years_since(year) + sakamoto[month] + day) % 7 + 1 end -local function borrow ( tens , units , base ) +local function borrow(tens, units, base) local frac = tens % 1 units = units + frac * base tens = tens - frac - return tens , units + return tens, units end -local function carry ( tens , units , base ) +local function carry(tens, units, base) if units >= base then - tens = tens + idiv ( units , base ) + tens = tens + idiv(units, base) units = units % base elseif units < 0 then - tens = tens + idiv ( units , base ) - units = ( base + units ) % base + tens = tens + idiv(units, base) + units = (base + units) % base end - return tens , units + return tens, units end -- Modify parameters so they all fit within the "normal" range -local function normalise ( year , month , day , hour , min , sec ) +local function normalise(year, month, day, hour, min, sec) -- `month` and `day` start from 1, need -1 and +1 so it works modulo - month , day = month - 1 , day - 1 + month, day = month - 1, day - 1 -- Convert everything (except seconds) to an integer -- by propagating fractional components down. - year , month = borrow ( year , month , 12 ) + year , month = borrow(year , month, 12) -- Carry from month to year first, so we get month length correct in next line around leap years - year , month = carry ( year , month , 12 ) - month , day = borrow ( month , day , month_length ( floor ( month + 1 ) , year ) ) - day , hour = borrow ( day , hour , 24 ) - hour , min = borrow ( hour , min , 60 ) - min , sec = borrow ( min , sec , 60 ) + year , month = carry(year, month, 12) + month, day = borrow(month, day , month_length(floor(month + 1), year)) + day , hour = borrow(day , hour , 24) + hour , min = borrow(hour , min , 60) + min , sec = borrow(min , sec , 60) -- Propagate out of range values up -- e.g. if `min` is 70, `hour` increments by 1 and `min` becomes 10 -- This has to happen for all columns after borrowing, as lower radixes may be pushed out of range - min , sec = carry ( min , sec , 60 ) -- TODO: consider leap seconds? - hour , min = carry ( hour , min , 60 ) - day , hour = carry ( day , hour , 24 ) + min , sec = carry(min , sec , 60) -- TODO: consider leap seconds? + hour , min = carry(hour, min , 60) + day , hour = carry(day , hour, 24) -- Ensure `day` is not underflowed -- Add a whole year of days at a time, this is later resolved by adding months -- TODO[OPTIMIZE]: This could be slow if `day` is far out of range @@ -108,13 +108,13 @@ local function normalise ( year , month , day , hour , min , sec ) year = year - 1 month = 11 end - day = day + month_length ( month + 1 , year ) + day = day + month_length(month + 1, year) end - year , month = carry ( year , month , 12 ) + year, month = carry(year, month, 12) -- TODO[OPTIMIZE]: This could potentially be slow if `day` is very large while true do - local i = month_length ( month + 1 , year ) + local i = month_length(month + 1, year) if day < i then break end day = day - i month = month + 1 @@ -126,129 +126,129 @@ local function normalise ( year , month , day , hour , min , sec ) -- Now we can place `day` and `month` back in their normal ranges -- e.g. month as 1-12 instead of 0-11 - month , day = month + 1 , day + 1 + month, day = month + 1, day + 1 - return year , month , day , hour , min , sec + return year, month, day, hour, min, sec end -local leap_years_since_1970 = leap_years_since ( 1970 ) -local function timestamp ( year , month , day , hour , min , sec ) - year , month , day , hour , min , sec = normalise ( year , month , day , hour , min , sec ) +local leap_years_since_1970 = leap_years_since(1970) +local function timestamp(year, month, day, hour, min, sec) + year, month, day, hour, min, sec = normalise(year, month, day, hour, min, sec) - local days_since_epoch = day_of_year ( day , month , year ) - + 365 * ( year - 1970 ) + local days_since_epoch = day_of_year(day, month, year) + + 365 * (year - 1970) -- Each leap year adds one day - + ( leap_years_since ( year - 1 ) - leap_years_since_1970 ) - 1 + + (leap_years_since(year - 1) - leap_years_since_1970) - 1 return days_since_epoch * (60*60*24) - + hour * (60*60) - + min * 60 + + hour * (60*60) + + min * 60 + sec end -local timetable_methods = { } +local timetable_methods = {} -function timetable_methods:unpack ( ) - return assert ( self.year , "year required" ) , - assert ( self.month , "month required" ) , - assert ( self.day , "day required" ) , - self.hour or 12 , - self.min or 0 , - self.sec or 0 , - self.yday , +function timetable_methods:unpack() + return assert(self.year , "year required"), + assert(self.month, "month required"), + assert(self.day , "day required"), + self.hour or 12, + self.min or 0, + self.sec or 0, + self.yday, self.wday end -function timetable_methods:normalise ( ) - local year , month , day - year , month , day , self.hour , self.min , self.sec = normalise ( self:unpack ( ) ) +function timetable_methods:normalise() + local year, month, day + year, month, day, self.hour, self.min, self.sec = normalise(self:unpack()) self.day = day self.month = month self.year = year - self.yday = day_of_year ( day , month , year ) - self.wday = day_of_week ( day , month , year ) + self.yday = day_of_year(day, month, year) + self.wday = day_of_week(day, month, year) return self end timetable_methods.normalize = timetable_methods.normalise -- American English -function timetable_methods:timestamp ( ) - return timestamp ( self:unpack ( ) ) +function timetable_methods:timestamp() + return timestamp(self:unpack()) end -function timetable_methods:rfc_3339 ( ) +function timetable_methods:rfc_3339() local year, month, day, hour, min, fsec = self:unpack() local sec, msec = borrow(fsec, 0, 1000) msec = math.floor(msec) - return strformat ( "%04u-%02u-%02uT%02u:%02u:%02d.%03d" , year , month , day , hour , min , sec , msec ) + return strformat("%04u-%02u-%02uT%02u:%02u:%02d.%03d", year, month, day, hour, min, sec, msec) end -function timetable_methods:strftime ( format_string ) - return strftime ( format_string , self ) +function timetable_methods:strftime(format_string) + return strftime(format_string, self) end local timetable_mt -local function coerce_arg ( t ) - if getmetatable ( t ) == timetable_mt then - return t:timestamp ( ) +local function coerce_arg(t) + if getmetatable(t) == timetable_mt then + return t:timestamp() end return t end timetable_mt = { - __index = timetable_methods ; - __tostring = timetable_methods.rfc_3339 ; - __eq = function ( a , b ) - return a:timestamp ( ) == b:timestamp ( ) - end ; - __lt = function ( a , b ) - return a:timestamp ( ) < b:timestamp ( ) - end ; - __sub = function ( a , b ) - return coerce_arg ( a ) - coerce_arg ( b ) - end ; + __index = timetable_methods; + __tostring = timetable_methods.rfc_3339; + __eq = function(a, b) + return a:timestamp() == b:timestamp() + end; + __lt = function(a, b) + return a:timestamp() < b:timestamp() + end; + __sub = function(a, b) + return coerce_arg(a) - coerce_arg(b) + end; } -local function cast_timetable ( tm ) - return setmetatable ( tm , timetable_mt ) +local function cast_timetable(tm) + return setmetatable(tm, timetable_mt) end -local function new_timetable ( year , month , day , hour , min , sec , yday , wday ) +local function new_timetable(year, month, day, hour, min, sec, yday, wday) return cast_timetable { - year = year ; - month = month ; - day = day ; - hour = hour ; - min = min ; - sec = sec ; - yday = yday ; - wday = wday ; + year = year; + month = month; + day = day; + hour = hour; + min = min; + sec = sec; + yday = yday; + wday = wday; } end -function timetable_methods:clone ( ) - return new_timetable ( self:unpack ( ) ) +function timetable_methods:clone() + return new_timetable(self:unpack()) end -local function new_from_timestamp ( ts ) - if type ( ts ) ~= "number" then - error ( "bad argument #1 to 'new_from_timestamp' (number expected, got " .. type ( ts ) .. ")" , 2 ) +local function new_from_timestamp(ts) + if type(ts) ~= "number" then + error("bad argument #1 to 'new_from_timestamp' (number expected, got " .. type(ts) .. ")", 2) end - return new_timetable ( 1970 , 1 , 1 , 0 , 0 , ts ):normalise ( ) + return new_timetable(1970, 1, 1, 0, 0, ts):normalise() end return { - is_leap = is_leap ; - day_of_year = day_of_year ; - day_of_week = day_of_week ; - normalise = normalise ; - timestamp = timestamp ; - - new = new_timetable ; - new_from_timestamp = new_from_timestamp ; - cast = cast_timetable ; - timetable_mt = timetable_mt ; + is_leap = is_leap; + day_of_year = day_of_year; + day_of_week = day_of_week; + normalise = normalise; + timestamp = timestamp; + + new = new_timetable; + new_from_timestamp = new_from_timestamp; + cast = cast_timetable; + timetable_mt = timetable_mt; } diff --git a/luatz/tzcache.lua b/luatz/tzcache.lua index 98ced26..ae32dce 100644 --- a/luatz/tzcache.lua +++ b/luatz/tzcache.lua @@ -2,34 +2,34 @@ local read_tzfile = require "luatz.tzfile".read_tzfile local base_zoneinfo_path = "/usr/share/zoneinfo/" local local_zoneinfo_path = "/etc/localtime" -local tz_cache = { } +local tz_cache = {} -local function name_to_zoneinfo_path ( name ) +local function name_to_zoneinfo_path(name) if name == nil then return local_zoneinfo_path - elseif name:sub ( 1 , 1 ) == "/" then + elseif name:sub(1, 1) == "/" then return name else return base_zoneinfo_path .. name end end -local function clear_tz_cache ( name ) - tz_cache [ name_to_zoneinfo_path ( name ) ] = nil +local function clear_tz_cache(name) + tz_cache[name_to_zoneinfo_path(name)] = nil end -local function get_tz ( name ) - local path = name_to_zoneinfo_path ( name ) +local function get_tz(name) + local path = name_to_zoneinfo_path(name) -- TODO: stat path - local tzinfo = tz_cache [ path ] + local tzinfo = tz_cache[path] if tzinfo == nil then - tzinfo = read_tzfile ( path ) - tz_cache [ path ] = tzinfo + tzinfo = read_tzfile(path) + tz_cache[path] = tzinfo end return tzinfo end return { - get_tz = get_tz ; - clear_tz_cache = clear_tz_cache ; + get_tz = get_tz; + clear_tz_cache = clear_tz_cache; } diff --git a/luatz/tzfile.lua b/luatz/tzfile.lua index 2d64d36..e57db6d 100644 --- a/luatz/tzfile.lua +++ b/luatz/tzfile.lua @@ -45,11 +45,11 @@ else -- luacheck: pop end end -local function read_flags ( fd , n ) - local data , err = fd:read ( n ) - if data == nil then return nil , err end +local function read_flags(fd, n) + local data, err = fd:read(n) + if data == nil then return nil, err end - local res = { } + local res = {} for i=1, n do res[i] = data:byte(i,i) ~= 0 end @@ -57,60 +57,60 @@ local function read_flags ( fd , n ) end local fifteen_nulls = ("\0"):rep(15) -local function read_tz ( fd ) - assert ( fd:read(4) == "TZif" , "Invalid TZ file" ) - local version = assert ( fd:read(1) ) +local function read_tz(fd) + assert(fd:read(4) == "TZif", "Invalid TZ file") + local version = assert(fd:read(1)) if version == "\0" or version == "2" or version == "3" then local MIN_TIME = -2^32+1 - assert ( assert ( fd:read(15) ) == fifteen_nulls , "Expected 15 nulls" ) + assert(assert(fd:read(15)) == fifteen_nulls, "Expected 15 nulls") -- The number of UTC/local indicators stored in the file. - local tzh_ttisgmtcnt = assert ( read_int32be ( fd ) ) + local tzh_ttisgmtcnt = assert(read_int32be(fd)) -- The number of standard/wall indicators stored in the file. - local tzh_ttisstdcnt = assert ( read_int32be ( fd ) ) + local tzh_ttisstdcnt = assert(read_int32be(fd)) -- The number of leap seconds for which data is stored in the file. - local tzh_leapcnt = assert ( read_int32be ( fd ) ) + local tzh_leapcnt = assert(read_int32be(fd)) -- The number of "transition times" for which data is stored in the file. - local tzh_timecnt = assert ( read_int32be ( fd ) ) + local tzh_timecnt = assert(read_int32be(fd)) -- The number of "local time types" for which data is stored in the file (must not be zero). - local tzh_typecnt = assert ( read_int32be ( fd ) ) + local tzh_typecnt = assert(read_int32be(fd)) -- The number of characters of "timezone abbreviation strings" stored in the file. - local tzh_charcnt = assert ( read_int32be ( fd ) ) + local tzh_charcnt = assert(read_int32be(fd)) - local transition_times = { } + local transition_times = {} for i=1, tzh_timecnt do - transition_times [ i ] = assert ( read_int32be ( fd ) ) + transition_times[i] = assert(read_int32be(fd)) end - local transition_time_ind = { assert ( fd:read ( tzh_timecnt ) ):byte ( 1 , -1 ) } + local transition_time_ind = {assert(fd:read(tzh_timecnt)):byte(1, -1)} - local ttinfos = { } + local ttinfos = {} for i=1, tzh_typecnt do - ttinfos [ i ] = { - gmtoff = assert ( read_int32be ( fd ) ) ; - isdst = assert ( fd:read ( 1 ) ) ~= "\0" ; - abbrind = assert ( fd:read ( 1 ) ):byte ( ) ; + ttinfos[i] = { + gmtoff = assert(read_int32be(fd)); + isdst = assert(fd:read(1)) ~= "\0"; + abbrind = assert(fd:read(1)):byte(); } end - local abbreviations = assert ( fd:read ( tzh_charcnt ) ) + local abbreviations = assert(fd:read(tzh_charcnt)) - local leap_seconds = { } -- luacheck: ignore 241 + local leap_seconds = {} -- luacheck: ignore 241 for i=1, tzh_leapcnt do - leap_seconds [ i ] = { - offset = assert ( read_int32be ( fd ) ) ; - n = assert ( read_int32be ( fd ) ) ; + leap_seconds[i] = { + offset = assert(read_int32be(fd)); + n = assert(read_int32be(fd)); } end - local isstd = assert ( read_flags ( fd , tzh_ttisstdcnt ) ) + local isstd = assert(read_flags(fd, tzh_ttisstdcnt)) - local isgmt = assert ( read_flags ( fd , tzh_ttisgmtcnt ) ) + local isgmt = assert(read_flags(fd, tzh_ttisgmtcnt)) local TZ @@ -121,56 +121,56 @@ local function read_tz ( fd ) ]] assert(fd:read(4) == "TZif") assert(fd:read(1) == version) - assert ( assert ( fd:read(15) ) == fifteen_nulls , "Expected 15 nulls" ) + assert(assert(fd:read(15)) == fifteen_nulls, "Expected 15 nulls") MIN_TIME = -2^64+1 -- The number of UTC/local indicators stored in the file. - tzh_ttisgmtcnt = assert ( read_int32be ( fd ) ) + tzh_ttisgmtcnt = assert(read_int32be(fd)) -- The number of standard/wall indicators stored in the file. - tzh_ttisstdcnt = assert ( read_int32be ( fd ) ) + tzh_ttisstdcnt = assert(read_int32be(fd)) -- The number of leap seconds for which data is stored in the file. - tzh_leapcnt = assert ( read_int32be ( fd ) ) + tzh_leapcnt = assert(read_int32be(fd)) -- The number of "transition times" for which data is stored in the file. - tzh_timecnt = assert ( read_int32be ( fd ) ) + tzh_timecnt = assert(read_int32be(fd)) -- The number of "local time types" for which data is stored in the file (must not be zero). - tzh_typecnt = assert ( read_int32be ( fd ) ) + tzh_typecnt = assert(read_int32be(fd)) -- The number of characters of "timezone abbreviation strings" stored in the file. - tzh_charcnt = assert ( read_int32be ( fd ) ) + tzh_charcnt = assert(read_int32be(fd)) - transition_times = { } + transition_times = {} for i=1, tzh_timecnt do - transition_times [ i ] = assert ( read_int64be ( fd ) ) + transition_times[i] = assert(read_int64be(fd)) end - transition_time_ind = { assert ( fd:read ( tzh_timecnt ) ):byte ( 1 , -1 ) } + transition_time_ind = {assert(fd:read(tzh_timecnt)):byte(1, -1)} - ttinfos = { } + ttinfos = {} for i=1, tzh_typecnt do - ttinfos [ i ] = { - gmtoff = assert ( read_int32be ( fd ) ) ; - isdst = assert ( fd:read ( 1 ) ) ~= "\0" ; - abbrind = assert ( fd:read ( 1 ) ):byte ( ) ; + ttinfos[i] = { + gmtoff = assert(read_int32be(fd)); + isdst = assert(fd:read(1)) ~= "\0"; + abbrind = assert(fd:read(1)):byte(); } end - abbreviations = assert ( fd:read ( tzh_charcnt ) ) + abbreviations = assert(fd:read(tzh_charcnt)) - leap_seconds = { } + leap_seconds = {} for i=1, tzh_leapcnt do - leap_seconds [ i ] = { - offset = assert ( read_int64be ( fd ) ) ; - n = assert ( read_int32be ( fd ) ) ; + leap_seconds[i] = { + offset = assert(read_int64be(fd)); + n = assert(read_int32be(fd)); } end - isstd = assert ( read_flags ( fd , tzh_ttisstdcnt ) ) + isstd = assert(read_flags(fd, tzh_ttisstdcnt)) - isgmt = assert ( read_flags ( fd , tzh_ttisgmtcnt ) ) + isgmt = assert(read_flags(fd, tzh_ttisgmtcnt)) --[[ After the second header and data comes a newline-enclosed, POSIX-TZ-environment-variable-style string @@ -188,20 +188,20 @@ local function read_tz ( fd ) between daylight saving and standard time. ]] - assert ( assert ( fd:read ( 1 ) ) == "\n" , "Expected newline at end of version 2 header" ) + assert(assert(fd:read(1)) == "\n", "Expected newline at end of version 2 header") - TZ = assert ( fd:read ( "*l" ) ) + TZ = assert(fd:read("*l")) if #TZ == 0 then TZ = nil end end for i=1, tzh_typecnt do - local v = ttinfos [ i ] - v.abbr = abbreviations:sub ( v.abbrind+1 , v.abbrind+3 ) - v.isstd = isstd [ i ] or false - v.isgmt = isgmt [ i ] or false - setmetatable ( v , tt_info_mt ) + local v = ttinfos[i] + v.abbr = abbreviations:sub(v.abbrind+1, v.abbrind+3) + v.isstd = isstd[i] or false + v.isgmt = isgmt[i] or false + setmetatable(v, tt_info_mt) end --[[ @@ -222,30 +222,30 @@ local function read_tz ( fd ) local res = { future = TZ; [0] = { - transition_time = MIN_TIME ; - info = ttinfos [ first ] ; + transition_time = MIN_TIME; + info = ttinfos[first]; } } for i=1, tzh_timecnt do - res [ i ] = { - transition_time = transition_times [ i ] ; - info = ttinfos [ transition_time_ind [ i ]+1 ] ; + res[i] = { + transition_time = transition_times[i]; + info = ttinfos[transition_time_ind[i]+1]; } end - return setmetatable ( res , tz_info_mt ) + return setmetatable(res, tz_info_mt) else - error ( "Unsupported version" ) + error("Unsupported version") end end -local function read_tzfile ( path ) - local fd = assert ( io.open ( path , "rb" ) ) - local tzinfo = read_tz ( fd ) - fd:close ( ) +local function read_tzfile(path) + local fd = assert(io.open(path, "rb")) + local tzinfo = read_tz(fd) + fd:close() return tzinfo end return { - read_tz = read_tz ; - read_tzfile = read_tzfile ; + read_tz = read_tz; + read_tzfile = read_tzfile; } diff --git a/luatz/tzinfo.lua b/luatz/tzinfo.lua index 3ff0a07..e37483f 100644 --- a/luatz/tzinfo.lua +++ b/luatz/tzinfo.lua @@ -1,51 +1,51 @@ local gettime = require "luatz.gettime".gettime local timetable_mt = require "luatz.timetable".timetable_mt -local function to_timestamp ( o ) - if type ( o ) == "number" then +local function to_timestamp(o) + if type(o) == "number" then return o - elseif getmetatable ( o ) == timetable_mt then - return o:timestamp ( ) + elseif getmetatable(o) == timetable_mt then + return o:timestamp() end end local tz_info_methods = { } local tz_info_mt = { __name = "luatz.tz_info"; - __index = tz_info_methods ; + __index = tz_info_methods; } local tt_info_mt = { __name = "luatz.tt_info"; - __tostring = function ( self ) - return string.format ( "tt_info:%s=%d" , self.abbr , self.gmtoff ) - end ; + __tostring = function(self) + return string.format("tt_info:%s=%d", self.abbr, self.gmtoff) + end; } -- Binary search -local function _find_current ( tzinfo , target , i , j ) +local function find_current(tzinfo, target, i, j) if i >= j then return j end - local half = math.ceil ( (j+i) / 2 ) + local half = math.ceil((j+i) / 2) - if target >= tzinfo [ half ].transition_time then - return _find_current ( tzinfo , target , half , j ) + if target >= tzinfo[half].transition_time then + return find_current(tzinfo, target, half, j) else - return _find_current ( tzinfo , target , i , half-1 ) + return find_current(tzinfo, target, i, half-1) end end -local function find_current_local ( tzinfo , ts_local ) +local function find_current_local(tzinfo, ts_local) -- Find two best possibilities by searching back and forward a day (assumes transition is never by more than 24 hours) - local tz_first = _find_current ( tzinfo , ts_local-86400 , 0 , #tzinfo ) - local tz_last = _find_current ( tzinfo , ts_local+86400 , 0 , #tzinfo ) + local tz_first = find_current(tzinfo, ts_local-86400, 0, #tzinfo) + local tz_last = find_current(tzinfo, ts_local+86400, 0, #tzinfo) local n_candidates = tz_last - tz_first + 1 if n_candidates == 1 then return tz_first elseif n_candidates == 2 then - local tz_first_ob = tzinfo [ tz_first ] - local tz_last_ob = tzinfo [ tz_last ] + local tz_first_ob = tzinfo[tz_first] + local tz_last_ob = tzinfo[tz_last] local first_gmtoffset = tz_first_ob.info.gmtoff local last_gmtoffset = tz_last_ob .info.gmtoff @@ -61,37 +61,37 @@ local function find_current_local ( tzinfo , ts_local ) end -- If we get this far, the local time is ambiguous - return tz_first , tz_last + return tz_first, tz_last else - error ( "Too many transitions in a 2 day period" ) + error("Too many transitions in a 2 day period") end end -function tz_info_methods:find_current ( current ) - current = assert ( to_timestamp ( current ) , "invalid timestamp to :find_current" ) - return self [ _find_current ( self , current , 0 , #self ) ].info +function tz_info_methods:find_current(current) + current = assert(to_timestamp(current), "invalid timestamp to :find_current") + return self[find_current(self, current, 0, #self)].info end -function tz_info_methods:localise ( utc_ts ) - utc_ts = utc_ts or gettime ( ) - return utc_ts + self:find_current ( utc_ts ).gmtoff +function tz_info_methods:localise(utc_ts) + utc_ts = utc_ts or gettime() + return utc_ts + self:find_current(utc_ts).gmtoff end tz_info_methods.localize = tz_info_methods.localise -function tz_info_methods:utctime ( ts_local ) - ts_local = assert ( to_timestamp ( ts_local ) , "invalid timestamp to :utctime" ) - local tz1 , tz2 = find_current_local ( self , ts_local ) - tz1 = self [ tz1 ].info +function tz_info_methods:utctime(ts_local) + ts_local = assert(to_timestamp(ts_local), "invalid timestamp to :utctime") + local tz1, tz2 = find_current_local(self, ts_local) + tz1 = self[tz1].info if tz2 == nil then return ts_local - tz1.gmtoff else -- Local time is ambiguous - tz2 = self [ tz2 ].info + tz2 = self[tz2].info - return ts_local - tz2.gmtoff , ts_local - tz2.gmtoff + return ts_local - tz2.gmtoff, ts_local - tz2.gmtoff end end return { - tz_info_mt = tz_info_mt ; - tt_info_mt = tt_info_mt ; + tz_info_mt = tz_info_mt; + tt_info_mt = tt_info_mt; } diff --git a/spec/parse_spec.lua b/spec/parse_spec.lua index 89c9a26..e38ad38 100644 --- a/spec/parse_spec.lua +++ b/spec/parse_spec.lua @@ -1,17 +1,17 @@ -describe ( "Time parsing library" , function ( ) +describe("Time parsing library", function() local timetable = require "luatz.timetable" local parse = require "luatz.parse" - it ( "#RFC3339 parsing" , function ( ) - assert.same ( timetable.new(2013,10,22,14,17,02) , (parse.rfc_3339 "2013-10-22T14:17:02Z") ) + it("#RFC3339 parsing", function() + assert.same(timetable.new(2013,10,22,14,17,02), (parse.rfc_3339 "2013-10-22T14:17:02Z")) -- Numeric offsets accepted - assert.same ( { timetable.new(2013,10,22,14,17,02) , 10*3600 } , { parse.rfc_3339 "2013-10-22T14:17:02+10:00" } ) + assert.same({timetable.new(2013,10,22,14,17,02), 10*3600 }, {parse.rfc_3339 "2013-10-22T14:17:02+10:00" }) -- Missing offsets parse - assert.same ( timetable.new(2013,10,22,14,17,02) , (parse.rfc_3339 "2013-10-22T14:17:02") ) + assert.same(timetable.new(2013,10,22,14,17,02), (parse.rfc_3339 "2013-10-22T14:17:02")) -- Invalid assert.same(nil, (parse.rfc_3339 "an invalid timestamp")) - end ) -end ) + end) +end) diff --git a/spec/timetable_spec.lua b/spec/timetable_spec.lua index 6c9617e..3713391 100644 --- a/spec/timetable_spec.lua +++ b/spec/timetable_spec.lua @@ -1,108 +1,108 @@ -describe ( "Timetable library" , function ( ) +describe("Timetable library", function() local timetable = require "luatz.timetable" - local function native_normalise ( year , month , day ) - return os.date("*t",os.time{ - year = year ; - month = month ; - day = day ; + local function native_normalise(year, month, day) + return os.date("*t",os.time { + year = year; + month = month; + day = day; }) end - it ( "#is_leap is correct" , function ( ) - assert.same ( false , timetable.is_leap ( 1 ) ) - assert.same ( false , timetable.is_leap ( 3 ) ) - assert.same ( true , timetable.is_leap ( 4 ) ) - assert.same ( true , timetable.is_leap ( 2000 ) ) - assert.same ( true , timetable.is_leap ( 2004 ) ) - assert.same ( true , timetable.is_leap ( 2012 ) ) - assert.same ( false , timetable.is_leap ( 2013 ) ) - assert.same ( false , timetable.is_leap ( 2014 ) ) - assert.same ( false , timetable.is_leap ( 2100 ) ) - assert.same ( true , timetable.is_leap ( 2400 ) ) - end ) - - it ( "#normalise gets #wday (day of week) correct" , function ( ) - - local function assert_same_wday ( year , month , day ) - return assert.are.same ( - native_normalise ( year , month , day ).wday , - timetable.new ( year , month , day ):normalise().wday + it("#is_leap is correct", function() + assert.same(false, timetable.is_leap(1)) + assert.same(false, timetable.is_leap(3)) + assert.same(true , timetable.is_leap(4)) + assert.same(true , timetable.is_leap(2000)) + assert.same(true , timetable.is_leap(2004)) + assert.same(true , timetable.is_leap(2012)) + assert.same(false, timetable.is_leap(2013)) + assert.same(false, timetable.is_leap(2014)) + assert.same(false, timetable.is_leap(2100)) + assert.same(true , timetable.is_leap(2400)) + end) + + it("#normalise gets #wday (day of week) correct", function() + + local function assert_same_wday(year, month, day) + return assert.are.same( + native_normalise(year, month, day).wday, + timetable.new(year, month, day):normalise().wday ) end - assert_same_wday ( 2013 , 7 , 23 ) - assert_same_wday ( 2013 , 7 , 24 ) - assert_same_wday ( 2013 , 7 , 25 ) - assert_same_wday ( 2013 , 7 , 26 ) - assert_same_wday ( 2013 , 7 , 27 ) - assert_same_wday ( 2013 , 7 , 28 ) - assert_same_wday ( 2013 , 7 , 29 ) - assert_same_wday ( 2014 , 1 , 1 ) - assert_same_wday ( 2014 , 1 , 6 ) - assert_same_wday ( 2016 , 2 , 28 ) - assert_same_wday ( 2016 , 2 , 29 ) - assert_same_wday ( 2016 , 3 , 1 ) - end ) - - local function native_timestamp ( year , month , day ) - return assert ( tonumber ( assert ( io.popen ( - string.format('date -u -d "%d-%d-%d" +%%s', year , month , day ) - ) ):read "*l" ) ) + assert_same_wday(2013, 7, 23) + assert_same_wday(2013, 7, 24) + assert_same_wday(2013, 7, 25) + assert_same_wday(2013, 7, 26) + assert_same_wday(2013, 7, 27) + assert_same_wday(2013, 7, 28) + assert_same_wday(2013, 7, 29) + assert_same_wday(2014, 1, 1) + assert_same_wday(2014, 1, 6) + assert_same_wday(2016, 2, 28) + assert_same_wday(2016, 2, 29) + assert_same_wday(2016, 3, 1) + end) + + local function native_timestamp(year, month, day) + return assert(tonumber(assert(io.popen( + string.format('date -u -d "%d-%d-%d" +%%s', year, month, day) + )):read "*l")) end - it ( "#timestamp creation is valid" , function ( ) + it("#timestamp creation is valid", function() for y=1950,2013 do for m=1,12 do - assert.same ( native_timestamp ( y,m,1 ) , timetable.timestamp(y,m,1,0,0,0) ) + assert.same(native_timestamp(y,m,1), timetable.timestamp(y,m,1,0,0,0)) end end - end ) - - it ( "#normalise handles out of range days in a year" , function ( ) - assert.same({ 2014,1,1,0,0,0 }, { timetable.normalise(2013,1,366,0,0,0) }) - assert.same({ 2014,2,4,0,0,0 }, { timetable.normalise(2013,1,400,0,0,0) }) - assert.same({ 2017,2,3,0,0,0 }, { timetable.normalise(2016,1,400,0,0,0) }) - assert.same({ 2016,3,5,0,0,0 }, { timetable.normalise(2015,1,430,0,0,0) }) - assert.same({ 2017,3,5,0,0,0 }, { timetable.normalise(2016,1,430,0,0,0) }) - assert.same({ 2027,5,18,0,0,0 }, { timetable.normalise(2000,1,10000,0,0,0) }) - assert.same({ 29379,1,25,0,0,0 }, { timetable.normalise(2000,1,10000000,0,0,0) }) - end ) - - it ( "#normalise handles out of range days in a #month" , function ( ) - assert.same({ 2012,12,1,0,0,0 }, { timetable.normalise(2013,0,1,0,0,0) }) - assert.same({ 2016,6,1,0,0,0 }, { timetable.normalise(2013,42,1,0,0,0) }) + end) + + it("#normalise handles out of range days in a year", function() + assert.same({2014,1,1,0,0,0}, {timetable.normalise(2013,1,366,0,0,0)}) + assert.same({2014,2,4,0,0,0}, {timetable.normalise(2013,1,400,0,0,0)}) + assert.same({2017,2,3,0,0,0}, {timetable.normalise(2016,1,400,0,0,0)}) + assert.same({2016,3,5,0,0,0}, {timetable.normalise(2015,1,430,0,0,0)}) + assert.same({2017,3,5,0,0,0}, {timetable.normalise(2016,1,430,0,0,0)}) + assert.same({2027,5,18,0,0,0}, {timetable.normalise(2000,1,10000,0,0,0)}) + assert.same({29379,1,25,0,0,0}, {timetable.normalise(2000,1,10000000,0,0,0)}) + end) + + it("#normalise handles out of range days in a #month", function() + assert.same({2012,12,1,0,0,0}, {timetable.normalise(2013,0,1,0,0,0)}) + assert.same({2016,6,1,0,0,0}, {timetable.normalise(2013,42,1,0,0,0)}) -- Correct behaviour around leap days - assert.same({ 2012,3,23,0,0,0 }, { timetable.normalise(2012,2,52,0,0,0) }) - assert.same({ 2013,3,24,0,0,0 }, { timetable.normalise(2013,2,52,0,0,0) }) + assert.same({2012,3,23,0,0,0}, {timetable.normalise(2012,2,52,0,0,0)}) + assert.same({2013,3,24,0,0,0}, {timetable.normalise(2013,2,52,0,0,0)}) - assert.same({ 2012,2,27,0,0,0 }, { timetable.normalise(2012,3,-2,0,0,0) }) - assert.same({ 2013,2,26,0,0,0 }, { timetable.normalise(2013,3,-2,0,0,0) }) + assert.same({2012,2,27,0,0,0}, {timetable.normalise(2012,3,-2,0,0,0)}) + assert.same({2013,2,26,0,0,0}, {timetable.normalise(2013,3,-2,0,0,0)}) -- Also when more fields are out of range - assert.same({ 2016,7,22,0,0,0 }, { timetable.normalise(2013,42,52,0,0,0) }) - assert.same({ 2016,7,24,2,0,0 }, { timetable.normalise(2013,42,52,50,0,0) }) - end ) - - it ( "#normalise handles fractional #month" , function ( ) - assert.same({ 2015,2,15,0,0,0 } , { timetable.normalise(2014,14.5,1,0,0,0) }) - assert.same({ 2016,2,15,12,0,0 } , { timetable.normalise(2015,14.5,1,0,0,0) }) -- leap year, so hours is 12 - assert.same({ 2017,2,15,0,0,0 } , { timetable.normalise(2016,14.5,1,0,0,0) }) - end ) - - it ( "#normalise handles negative carry (issue #10)", function() - assert.same({ 1970,01,01,00,59,00 }, { timetable.normalise(1970,01,01,01,00,-60) }) - assert.same({ 1970,01,01,00,58,58 }, { timetable.normalise(1970,01,01,01,00,-62) }) - assert.same({ 1969,12,31,23,55,58 }, { timetable.normalise(1970,01,01,01,-63,-62) }) - assert.same({ 2017,02,3,0,0,0 }, { timetable.normalise(2017,02,13,0,-14400,0) }) - end ) - - it ( "#normalise handles negative day carry (issue #13)", function() - assert.same({ 2016,11,30,00,00,00 }, { timetable.normalise(2016,12,0,0,0,0) }) - assert.same({ 2017,11,30,00,00,00 }, { timetable.normalise(2017,12,0,0,0,0) }) - assert.same({ 2018,11,30,00,00,00 }, { timetable.normalise(2018,12,0,0,0,0) }) - end ) + assert.same({2016,7,22,0,0,0}, {timetable.normalise(2013,42,52,0,0,0)}) + assert.same({2016,7,24,2,0,0}, {timetable.normalise(2013,42,52,50,0,0)}) + end) + + it("#normalise handles fractional #month", function() + assert.same({2015,2,15,0,0,0}, {timetable.normalise(2014,14.5,1,0,0,0)}) + assert.same({2016,2,15,12,0,0}, {timetable.normalise(2015,14.5,1,0,0,0)}) -- leap year, so hours is 12 + assert.same({2017,2,15,0,0,0}, {timetable.normalise(2016,14.5,1,0,0,0)}) + end) + + it("#normalise handles negative carry (issue #10)", function() + assert.same({1970,01,01,00,59,00}, {timetable.normalise(1970,01,01,01,00,-60)}) + assert.same({1970,01,01,00,58,58}, {timetable.normalise(1970,01,01,01,00,-62)}) + assert.same({1969,12,31,23,55,58}, {timetable.normalise(1970,01,01,01,-63,-62)}) + assert.same({2017,02,3,0,0,0}, {timetable.normalise(2017,02,13,0,-14400,0)}) + end) + + it("#normalise handles negative day carry (issue #13)", function() + assert.same({2016,11,30,00,00,00}, {timetable.normalise(2016,12,0,0,0,0)}) + assert.same({2017,11,30,00,00,00}, {timetable.normalise(2017,12,0,0,0,0)}) + assert.same({2018,11,30,00,00,00}, {timetable.normalise(2018,12,0,0,0,0)}) + end) local function round_trip_add(t, field, x) local before = t:clone() @@ -112,11 +112,11 @@ describe ( "Timetable library" , function ( ) t:normalise(); assert.same(0, t-before) end - it ( "#normalise round trips" , function ( ) + it("#normalise round trips", function() round_trip_add(timetable.new(2000,2,28,0,0,0), "month", 0.5) round_trip_add(timetable.new(2014,8,28,19,23,0), "month", 0.4) round_trip_add(timetable.new(2014,14.5,28,0,0,0), "month", 0.4) - end ) + end) it("#rfc_3339 works with fractional milliseconds", function() -- on lua 5.3 this used to throw an error due to milliseconds not being an integer @@ -129,4 +129,4 @@ describe ( "Timetable library" , function ( ) assert.same("1969-12-31T23:59:59.999", timetable.new_from_timestamp(-0.001):rfc_3339()) assert.same("1969-12-31T23:59:00.000", timetable.new_from_timestamp(-59.9999999):rfc_3339()) end) -end ) +end)