Update for Nim 0.19.0, add trimNanoSec

tests/ttimeutils.nim

@@ -12,57 +12,45 @@ suite "timeutils":
       interval.format("mm:ss") == "01:10"
 
   test "DateTime difference":
-    var t1 = getLocalTime(getTime())
+    var t1 = getTime().local
     var t2 = t1 + 30.seconds
-    check t2 - t1 == 30.seconds
+    check timeutils.`-`(t2, t1) == initDuration(seconds = 30)
 
     t1 = parse("2016-10-10 09:45:00", "yyyy-MM-dd HH:mm:ss")
     t2 = parse("2016-10-11 09:45:00", "yyyy-MM-dd HH:mm:ss")
-    check t2 - t1 == seconds(24 * 60 * 60)
+    check timeutils.`-`(t2, t1) == initDuration(seconds = 24 * 60 * 60)
 
     t2 = parse("2016-10-11 10:00:00", "yyyy-MM-dd HH:mm:ss")
-    check t2 - t1 == seconds((24 * 60 + 15) * 60)
+    check timeutils.`-`(t2, t1) == initDuration(seconds = (24 * 60 + 15) * 60)
 
   test "DateTime comparisons":
-    let t1 = getLocalTime(getTime())
+    let t1 = getTime().local
 
     check:
-      t1 < t1 + 10.seconds
+      timeutils.`<`(t1, t1 + 10.seconds)
-      not (t1 + 10.seconds < t1)
+      not timeutils.`<`(t1 + 10.seconds, t1)
-      not (t1 > t1)
+      not timeutils.`<`(t1, t1)
 
-      t1 + 10.seconds > t1
+      timeutils.`<=`(t1, t1 + 10.seconds)
-      not (t1 > t1 + 10.seconds)
+      timeutils.`<=`(t1, t1)
-      not (t1 < t1)
+      not timeutils.`<=`(t1 + 10.seconds, t1)
-
-      t1 + 10.seconds >= t1
-      t1 >= t1
-      not (t1 >= t1 + 10.seconds)
-
-      t1 <= t1 + 10.seconds
-      t1 <= t1
-      not (t1 + 10.seconds <= t1)
  
+      t1.between(t1 - 10.seconds, t1 + 10.seconds)
+      t1.between(t1, t1 + 10.seconds)     # start is inclusive
+      not t1.between(t1 - 10.seconds, t1) # end is exclusive
+
   test "TimeInterval comparisons":
     check:
-      30.seconds > 10.seconds
+      timeutils.`<`(10.minutes, 1.hours)
-      not (10.seconds > 30.seconds)
+      not timeutils.`<`(1.hours, 10.minutes)
-      not (10.seconds > 10.seconds)
+      not timeutils.`<`(1.hours, 1.hours)
 
-      10.minutes < 1.hours
+      timeutils.`<=`(60.seconds, 1.minutes)
-      not (1.hours < 10.minutes)
+      timeutils.`<=`(60.seconds, 2.minutes)
-      not (1.hours < 1.hours)
+      not timeutils.`<=`(2.minutes, 60.seconds)
-
-      60.seconds >= 1.minutes
-      60.seconds >= 1.minutes
-      not (60.seconds >= 2.minutes)
-
-      60.seconds <= 1.minutes
-      60.seconds <= 2.minutes
-      not (2.minutes <= 60.seconds)
 
   test "DateTime cmp":
-    let t1 = getLocalTime(getTime())
+    let t1 = getTime().local
 
     check cmp(t1, t1) == 0
     check cmp(t1, t1 + 10.seconds) == -1
@@ -88,7 +76,7 @@ suite "timeutils":
     # mentioned above.
     check:
       # Start of week = Monday
-      startOfWeek(t1) == startOfDay(getLocalTime(toTime(parse("2015-12-28 12:01:00", dtFormat))))
+      startOfWeek(t1) == startOfDay(toTime(parse("2015-12-28 12:01:00", dtFormat)).local)
       startOfWeek(t1).weekday == dMon
       startOfWeek(startOfWeek(t1)) == startOfWeek(t1)
 
@@ -108,5 +96,20 @@ suite "timeutils":
     let t2 = fixedParse("2015-06-01 12:00:00", dtFormat)
 
     check: # test both in DST and out of DST
-      t1 == getLocalTime(toTime(t1))
+      t1 == toTime(t1).local
-      t2 == getLocalTime(toTime(t2))
+      t2 == toTime(t2).local
+
+  test "parseIso8601":
+    let t1 = parseIso8601("2018-01-01T12:00:00-05:00")
+    let t2 = parseIso8601("2018-01-01T17:00:00Z")
+
+    check:
+      t1 == t2
+
+  test "formatIso8601":
+    let t1 = parseIso8601("2018-01-01T12:00:00-05:00")
+    let t2 = parseIso8601("2018-01-01T17:00:00Z")
+
+    check:
+      t1 == parseIso8601(formatIso8601(t1))
+      t2 == parseIso8601(formatIso8601(t2))

timeutils.nim

@@ -1,58 +1,59 @@
 import times
 
-const zeroTime = fromSeconds(0)
+const zeroTime = fromUnix(0)
+const ISO_8601_FULL_FORMAT = "yyyy-MM-dd'T'HH:mm:sszzz"
 
 proc format*(ti: TimeInterval, fmt: string): string =
-  let info = getGMTime(fromSeconds(0) + ti)
+  let info = (fromUnix(0) + ti).utc
   return info.format(fmt)
 
-proc `-`*(a, b: DateTime): TimeInterval =
+# Will be deprecated in Nim 0.18.1 as it will exist in the standard times module.
-  return seconds(cast[int](a.toTime - b.toTime))
+proc `-`*(a, b: DateTime): Duration {.deprecated} =
+  return times.`-`(a,b)
 
-#[
+proc `<`*(a, b: DateTime): bool {.deprecated} =
-# Deprecated as it exists in the standard times module now.
+  return times.`<`(a,b)
-proc `>`*(a, b: TimeInfo): bool =
-  return a.toTime > b.toTime
 
-proc `<`*(a, b: TimeInfo): bool =
+proc `<=`*(a, b: DateTime): bool {.deprecated} =
-  return a.toTime < b.toTime
+  return times.`<=`(a,b)
-
-proc `>=`*(a, b: TimeInfo): bool =
-  return a.toTime >= b.toTime
-
-proc `<=`*(a, b: TimeInfo): bool =
-  return a.toTime <= b.toTime
-]#
-
-proc `>`*(a, b: TimeInterval): bool =
-  return (zeroTime + a) > (zeroTime + b)
 
 proc `<`*(a, b: TimeInterval): bool =
   return (zeroTime + a) < (zeroTime + b)
 
-proc `>=`*(a, b: TimeInterval): bool =
-  return (zeroTime + a) >= (zeroTime + b)
-
 proc `<=`*(a, b: TimeInterval): bool =
   return (zeroTime + a) <= (zeroTime + b)
 
+proc between*(a, s, e: DateTime): bool =
+  return times.`<=`(s, a) and times.`<`(a, e)
+
 proc cmp*(a, b: DateTime): int =
   if b == a: return 0
-  elif a > b: return 1
+  elif times.`<`(a, b): return -1
-  else: return -1
+  else: return 1
 
-proc startOfDay*(ti: DateTime): DateTime =
+proc startOfDay*(dt: DateTime): DateTime =
-  result = ti
+  result = dt
   result.hour = 0
   result.minute = 0
   result.second = 0
+  result.nanosecond = 0
+
+proc trimNanoSec*(dt: DateTime): DateTime =
+  result = dt
+  result.nanosecond = 0
 
 proc startOfWeek*(ti: DateTime, startDay = dMon): DateTime =
   var diff = (ti.weekday.ord - startDay.ord)
   if diff < 0: diff += 7
   return (ti - diff.days).startOfDay
 
+proc parseIso8601*(val: string): DateTime =
+  return val.parse(ISO_8601_FULL_FORMAT)
+
+proc formatIso8601*(d: DateTime): string =
+  return d.format(ISO_8601_FULL_FORMAT)
+
 # This is a workaround needed due a bug in Nim's times.parse procedure.
 # see: https://github.com/nim-lang/Nim/issues/4922
-{.deprecated.}
+template fixedParse*(value, format: string): DateTime {.deprecated.} =
-template fixedParse*(value, format: string): DateTime = parse(value, format)
+  parse(value, format)

timeutils.nimble

@@ -1,11 +1,11 @@
 # Package
 
-version       = "0.2.2"
+version       = "0.4.0"
 author        = "Jonathan Bernard"
 description   = "Utility methods to fill in the lacking time support in Nim\'s stdlib. This is holding me over until I can write a proper time module for the stdlib and submit it."
 license       = "BSD3"
 
 # Dependencies
 
-requires "nim >= 0.18.1"
+requires "nim >= 0.19.0"