madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Move to consistent whitespace style
authordaurnimator <quae@daurnimator.com>
Wed, 6 Dec 2017 06:31:40 +0000 (17:31 +1100)
committerdaurnimator <quae@daurnimator.com>
Wed, 6 Dec 2017 06:33:59 +0000 (17:33 +1100)
12 files changed:
examples/date_arithmetic.lua
examples/os_date.lua
luatz/gettime.lua
luatz/init.lua
luatz/parse.lua
luatz/strftime.lua
luatz/timetable.lua
luatz/tzcache.lua
luatz/tzfile.lua
luatz/tzinfo.lua
spec/parse_spec.lua
spec/timetable_spec.lua

index c1148fb8ac232160ba4f85717e69cd8e222208ea..4065122a18fdbf9e42f169cbf68957dff419f71e 100644 (file)
@@ -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")
index deac08b9ed34af5abf49df0b293ed452a595e4ef..ad254cea78b6ef314835e3333505e8ecd494d339 100644 (file)
@@ -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
 
index d3eee802d205d8266355a09f21e6900cda135d27..4d6f45ad2c95a9a7494f0cb8c2f01fe30706701c 100644 (file)
@@ -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
index 1a6c83533c99a7c1c6274aca03d29352e69ef8db..4423189304874c46efb00e07f3f52077561549f5 100644 (file)
@@ -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
index 648d538e2140372c2238452a82b0e352041ef498..089dd0e5bd014646075f7273e507b6993e3ba9c0 100644 (file)
@@ -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;
 }
index a65a7065223f1feada54164c8033f76967595d99..223da0f15e4f82ab04ecb46ca30fa68acb7dc90b 100644 (file)
@@ -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;
 }
index 812d497bd40ba51ca2a1d1cc5f8e4d6d97a2bb4c..1a304e21ef58f468b477b32c1667f2cee42cb371 100644 (file)
@@ -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;
 }
index 98ced26947a3d84e012cf1f4099e67c44a79899b..ae32dceddd08abf8eb65ac52b8eaaddea1260f6c 100644 (file)
@@ -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;
 }
index 2d64d369b0658b86cfd9ebfb625bbfc2cf0f70dc..e57db6d8fa82dbcf719eaa2b135825a9e1930499 100644 (file)
@@ -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;
 }
index 3ff0a075f2327c6ff4cab4510735d55952411ad4..e37483f81a562828e28b392735b7c9f9c18339b4 100644 (file)
@@ -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;
 }
index 89c9a26c5a445137d482f359c2b2600e7777fbbc..e38ad3842673b3ad5bd5d3d4e75588e927529363 100644 (file)
@@ -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)
index 6c9617e2c2dcce2a1e59dc94a0f0407c6534568b..3713391eb305e4052e2f4658090186260b450516 100644 (file)
-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)