Move to consistent whitespace style

diff --git a/examples/date_arithmetic.lua b/examples/date_arithmetic.lua
index c1148fb8ac232160ba4f85717e69cd8e222208ea..4065122a18fdbf9e42f169cbf68957dff419f71e 100644 (file)
--- 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 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
 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
 
 -- Get a new time object 6 months from now

-local x = now:clone ( )
+local x = now:clone()

 x.month = x.month + 6
 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
 
 -- 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)
 
 -- 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.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
 
 -- 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 deac08b9ed34af5abf49df0b293ed452a595e4ef..ad254cea78b6ef314835e3333505e8ecd494d339 100644 (file)
--- 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 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"
        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
        else -- Localtime

-               timestamp = get_tz ( ):localise ( timestamp )
+               timestamp = get_tz():localise(timestamp)

        end
        end

-       local tt = new_from_timestamp ( timestamp )
+       local tt = new_from_timestamp(timestamp)

        if format_string == "*t" then
                return tt
        else
        if format_string == "*t" then
                return tt
        else

-               return tt:strftime ( format_string )
+               return tt:strftime(format_string)

        end
 end
 
        end
 end
 

diff --git a/luatz/gettime.lua b/luatz/gettime.lua
index d3eee802d205d8266355a09f21e6900cda135d27..4d6f45ad2c95a9a7494f0cb8c2f01fe30706701c 100644 (file)
--- 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
        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
                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
 
                        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
        -- 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
                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
                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
 
                        end
        end
 


@@ -36,18 +36,18 @@ _M.source , _M.resolution , _M.gettime = (function()
                return "unix.gettimeofday()", 1e-6, unix.gettimeofday
        end
 
                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
        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
        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
 
        end
 

-       return "os.time()" , 1 , os.time
+       return "os.time()", 1, os.time

 end)()
 
 return _M
 end)()
 
 return _M

diff --git a/luatz/init.lua b/luatz/init.lua
index 1a6c83533c99a7c1c6274aca03d29352e69ef8db..4423189304874c46efb00e07f3f52077561549f5 100644 (file)
--- a/luatz/init.lua
+++ b/luatz/init.lua
@@ -1,9 +1,9 @@
 local _M = {
 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
 }
 
 --- Top-level aliases for common functions


@@ -13,28 +13,28 @@ _M.get_tz = _M.tzcache.get_tz
 
 --- Handy functions
 
 
 --- 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
 
 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
 
 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
 
 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
 
 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
 end
 
 return _M

diff --git a/luatz/parse.lua b/luatz/parse.lua
index 648d538e2140372c2238452a82b0e352041ef498..089dd0e5bd014646075f7273e507b6993e3ba9c0 100644 (file)
--- 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)
 -- 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
        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
 
        local tz_offset

-       if str:match ("^[Zz]" , patt_end ) then
+       if str:match("^[Zz]", patt_end) then

                tz_offset = 0
        else
                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
                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
 
                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 {
 end
 
 return {

-       rfc_3339 = rfc_3339 ;
+       rfc_3339 = rfc_3339;

 }
 }

diff --git a/luatz/strftime.lua b/luatz/strftime.lua
index a65a7065223f1feada54164c8033f76967595d99..223da0f15e4f82ab04ecb46ca30fa68acb7dc90b 100644 (file)
--- a/luatz/strftime.lua
+++ b/luatz/strftime.lua
@@ -1,21 +1,21 @@
 local strformat = string.format
 local floor = math.floor
 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 = {
 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)
 }
 
 --- 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
        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
 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,
        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
                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
        end

-       local function is_long_year ( year )
-               return long_years [ year % 400 ]
+       local function is_long_year(year)
+               return long_years[year % 400]

        end
        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
                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
                        else

-                               return year , 52 , wday
+                               return year, 52, wday

                        end
                        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
                else

-                       return year , idiv ( n + 10 , 7 ) , wday
+                       return year, idiv(n + 10, 7), wday

                end
        end
 end
 
 --- Specifiers
                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
 end

-function t:A ( locale )
-       return "%s" , locale.day [ self.wday ]
+function t:A(locale)
+       return "%s", locale.day[self.wday]

 end
 end

-function t:b ( locale )
-       return "%s" , locale.abmon [ self.month ]
+function t:b(locale)
+       return "%s", locale.abmon[self.month]

 end
 end

-function t:B ( locale )
-       return "%s" , locale.mon [ self.month ]
+function t:B(locale)
+       return "%s", locale.mon[self.month]

 end
 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
 end
 -- Century

-function t:C ( )
-       return "%02d" , idiv ( self.year , 100 )
+function t:C()
+       return "%02d", idiv(self.year, 100)

 end
 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
 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
 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
 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)
 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
 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
 end
 t.h = t.b

-function t:H ( )
-       return "%02d" , self.hour
+function t:H()
+       return "%02d", self.hour

 end
 end

-function t:I ( )
-       return "%02d" , (self.hour-1) % 12 + 1
+function t:I()
+       return "%02d", (self.hour-1) % 12 + 1

 end
 end

-function t:j ( )
-       return "%03d" , self.yday
+function t:j()
+       return "%03d", self.yday

 end
 end

-function t:m ( )
-       return "%02d" , self.month
+function t:m()
+       return "%02d", self.month

 end
 end

-function t:M ( )
-       return "%02d" , self.min
+function t:M()
+       return "%02d", self.min

 end
 -- New-line character ('\n')
 end
 -- New-line character ('\n')

-function t:n ( ) -- luacheck: ignore 212
+function t:n() -- luacheck: ignore 212

        return "\n"
 end
        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
        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
                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
 end

-function t:s ( )
-       return "%d" , self:timestamp ( )
+function t:s()
+       return "%d", self:timestamp()

 end
 end

-function t:S ( )
-       return "%02d" , self.sec
+function t:S()
+       return "%02d", self.sec

 end
 -- Horizontal-tab character ('\t')
 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
        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
 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)
 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)
 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)
 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)
 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
 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
 end

-function t:Y ( )
-       return "%d" , self.year
+function t:Y()
+       return "%d", self.year

 end
 -- TODO timezones
 end
 -- TODO timezones

-function t:z ( ) -- luacheck: ignore 212
+function t:z() -- luacheck: ignore 212

        return "+0000"
 end
        return "+0000"
 end

-function t:Z ( ) -- luacheck: ignore 212
+function t:Z() -- luacheck: ignore 212

        return "GMT"
 end
 -- A literal '%' character.
        return "GMT"
 end
 -- A literal '%' character.

-t["%"] = function ( self ) -- luacheck: ignore 212
+t["%"] = function(self) -- luacheck: ignore 212

        return "%%"
 end
 
        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
                if func then

-                       return strformat ( func ( timetable , c_locale ) )
+                       return strformat(func(timetable, c_locale))

                else
                else

-                       error ( "invalid conversation specifier '%"..locale_modifier..specifier.."'" , 3 )
+                       error("invalid conversation specifier '%"..locale_modifier..specifier.."'", 3)

                end
                end

-       end ) )
+       end))

 end
 
 end
 

-local function asctime ( timetable )
+local function asctime(timetable)

        -- Equivalent to the format string "%c\n"
        -- 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 {
 end
 
 return {

-       strftime = strftime ;
-       asctime = asctime ;
+       strftime = strftime;
+       asctime = asctime;

 }
 }

diff --git a/luatz/timetable.lua b/luatz/timetable.lua
index 812d497bd40ba51ca2a1d1cc5f8e4d6d97a2bb4c..1a304e21ef58f468b477b32c1667f2cee42cb371 100644 (file)
--- a/luatz/timetable.lua
+++ b/luatz/timetable.lua
@@ -14,16 +14,16 @@ local idiv do
 end
 
 
 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
 -- 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
 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};
 
 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
        if (y % 4) ~= 0 then
                return false
        elseif (y % 100) ~= 0 then


@@ -33,72 +33,72 @@ local function is_leap ( y )
        end
 end
 
        end
 end
 

-local function month_length ( m , y )
+local function month_length(m, y)

        if m == 2 then
        if m == 2 then

-               return is_leap ( y ) and 29 or 28
+               return is_leap(y) and 29 or 28

        else
        else

-               return mon_lengths [ m ]
+               return mon_lengths[m]

        end
 end
 
        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
 
 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
 
                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
        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
 
 end
 

-local function borrow ( tens , units , base )
+local function borrow(tens, units, base)

        local frac = tens % 1
        units = units + frac * base
        tens = tens - frac
        local frac = tens % 1
        units = units + frac * base
        tens = tens - frac

-       return tens , units
+       return tens, units

 end
 
 end
 

-local function carry ( tens , units , base )
+local function carry(tens, units, base)

        if units >= base then
        if units >= base then

-               tens  = tens + idiv ( units , base )
+               tens  = tens + idiv(units, base)

                units = units % base
        elseif units < 0 then
                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
        end

-       return tens , units
+       return tens, units

 end
 
 -- Modify parameters so they all fit within the "normal" range
 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` 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.
 
        -- 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
        -- 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
 
        -- 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
        -- 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
                        year = year - 1
                        month = 11
                end

-               day = day + month_length ( month + 1 , year )
+               day = day + month_length(month + 1, year)

        end
        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
 
        -- 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
                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
 
        -- 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
 
 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
                -- 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)
 
        return days_since_epoch * (60*60*24)

-               + hour  * (60*60)
-               + min   * 60
+               + hour * (60*60)
+               + min  * 60

                + sec
 end
 
 
                + 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
 
                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.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
 
 
        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
 
 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)
        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
 
 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
 
 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 = {
        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
 
 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 {
        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
 
        }
 end
 

-function timetable_methods:clone ( )
-       return new_timetable ( self:unpack ( ) )
+function timetable_methods:clone()
+       return new_timetable(self:unpack())

 end
 
 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
        end

-       return new_timetable ( 1970 , 1 , 1 , 0 , 0 , ts ):normalise ( )
+       return new_timetable(1970, 1, 1, 0, 0, ts):normalise()

 end
 
 return {
 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 98ced26947a3d84e012cf1f4099e67c44a79899b..ae32dceddd08abf8eb65ac52b8eaaddea1260f6c 100644 (file)
--- 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 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
        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
 
                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
 
 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
        -- TODO: stat path

-       local tzinfo = tz_cache [ path ]
+       local tzinfo = tz_cache[path]

        if tzinfo == nil then
        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 {
        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 2d64d369b0658b86cfd9ebfb625bbfc2cf0f70dc..e57db6d8fa82dbcf719eaa2b135825a9e1930499 100644 (file)
--- a/luatz/tzfile.lua
+++ b/luatz/tzfile.lua
@@ -45,11 +45,11 @@ else -- luacheck: pop
        end
 end
 
        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
        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)
 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
 
        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.
 
                -- 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.
 
                -- 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.
 
                -- 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.
 
                -- 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).
 
                -- 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.
 
                -- 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
                for i=1, tzh_timecnt do

-                       transition_times [ i ] = assert ( read_int32be ( fd ) )
+                       transition_times[i] = assert(read_int32be(fd))

                end
                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
                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
 
                        }
                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
                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
 
                        }
                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
 
 
                local TZ
 


@@ -121,56 +121,56 @@ local function read_tz ( fd )
                        ]]
                        assert(fd:read(4) == "TZif")
                        assert(fd:read(1) == version)
                        ]]
                        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.
 
                        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.
 
                        -- 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.
 
                        -- 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.
 
                        -- 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).
 
                        -- 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.
 
                        -- 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
                        for i=1, tzh_timecnt do

-                               transition_times [ i ] = assert ( read_int64be ( fd ) )
+                               transition_times[i] = assert(read_int64be(fd))

                        end
                        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
                        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
 
                                }
                        end
 

-                       abbreviations = assert ( fd:read ( tzh_charcnt ) )
+                       abbreviations = assert(fd:read(tzh_charcnt))

 
 

-                       leap_seconds = { }
+                       leap_seconds = {}

                        for i=1, tzh_leapcnt do
                        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
 
                                }
                        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
 
                        --[[
                        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.
                        ]]
 
                        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
                        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
 
                --[[
                end
 
                --[[


@@ -222,30 +222,30 @@ local function read_tz ( fd )
                local res = {
                        future = TZ;
                        [0] = {
                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
                        }
                }
                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
                        }
                end

-               return setmetatable ( res , tz_info_mt )
+               return setmetatable(res, tz_info_mt)

        else
        else

-               error ( "Unsupported version" )
+               error("Unsupported version")

        end
 end
 
        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 {
        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 3ff0a075f2327c6ff4cab4510735d55952411ad4..e37483f81a562828e28b392735b7c9f9c18339b4 100644 (file)
--- 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 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
                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";
        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";
 }
 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
 }
 
 -- 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
 
        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
        else

-               return _find_current ( tzinfo , target , i , half-1 )
+               return find_current(tzinfo, target, i, half-1)

        end
 end
 
        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)
        -- 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 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
 
                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
                end
 
                -- If we get this far, the local time is ambiguous

-               return tz_first , tz_last
+               return tz_first, tz_last

        else
        else

-               error ( "Too many transitions in a 2 day period" )
+               error("Too many transitions in a 2 day period")

        end
 end
 
        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
 
 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
 
 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
        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 {
        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 89c9a26c5a445137d482f359c2b2600e7777fbbc..e38ad3842673b3ad5bd5d3d4e75588e927529363 100644 (file)
--- 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"
 
        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
 
                -- 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
 
                -- 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"))
 
                -- 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 6c9617e2c2dcce2a1e59dc94a0f0407c6534568b..3713391eb305e4052e2f4658090186260b450516 100644 (file)
--- 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 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
 
                })
        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
 
                        )
                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
 
        end
 

-       it ( "#timestamp creation is valid" , function ( )
+       it("#timestamp creation is valid", function()

                for y=1950,2013 do
                        for m=1,12 do
                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
                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
 
                -- 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
 
                -- 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()
 
        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
                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)
                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
 
        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)
                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)