Add ISO8601 date format (yyyy-MM-dd) to parseIso8601 utility function.

Change `startOfDay` and `trimNanoSec` to use `initDateTime` instead of
mutating the new copy via the deprecated property accessors.

Updated the test suite to reflect functions that moved from this library
to the standard library. We're still testing the expected functionality
to make sure that the contract is maintained for users of this library.

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 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 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 t2 - t1 == initDuration(seconds = (24 * 60 + 15) * 60)
 
   test "DateTime comparisons":
-    let t1 = getLocalTime(getTime())
+    let t1 = getTime().local
 
     check:
+      not (t1 < t1)
       t1 < t1 + 10.seconds
       not (t1 + 10.seconds < t1)
-      not (t1 > t1)
 
-      t1 + 10.seconds > t1
-      not (t1 > t1 + 10.seconds)
-      not (t1 < t1)
-
-      t1 + 10.seconds >= t1
-      t1 >= t1
-      not (t1 >= t1 + 10.seconds)
-
-      t1 <= t1 + 10.seconds
       t1 <= t1
+      t1 <= t1 + 10.seconds
       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
-      not (10.seconds > 30.seconds)
-      not (10.seconds > 10.seconds)
+      timeutils.`<`(10.minutes, 1.hours)
+      not timeutils.`<`(1.hours, 10.minutes)
+      not timeutils.`<`(1.hours, 1.hours)
 
-      10.minutes < 1.hours
-      not (1.hours < 10.minutes)
-      not (1.hours < 1.hours)
-
-      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)
+      timeutils.`<=`(60.seconds, 1.minutes)
+      timeutils.`<=`(60.seconds, 2.minutes)
+      not timeutils.`<=`(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))
-      t2 == getLocalTime(toTime(t2))
+      t1 == toTime(t1).local
+      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,74 @@
 import times
 
-const zeroTime = fromSeconds(0)
+const zeroTime = fromUnix(0)
+const ISO_8601_FORMATS = @[
+  "yyyy-MM-dd",
+  "yyyy-MM-dd'T'HH:mm:ssz",
+  "yyyy-MM-dd'T'HH:mm:sszzz",
+  "yyyy-MM-dd'T'HH:mm:ss'.'fffzzz",
+  "yyyy-MM-dd HH:mm:ssz",
+  "yyyy-MM-dd HH:mm:sszzz",
+  "yyyy-MM-dd HH:mm:ss'.'fffzzz"
+]
 
 proc format*(ti: TimeInterval, fmt: string): string =
-  let info = getGMTime(fromSeconds(0) + ti)
+  let info = (zeroTime + ti).utc
   return info.format(fmt)
 
-proc `-`*(a, b: DateTime): TimeInterval =
-  return seconds(cast[int](a.toTime - b.toTime))
-
-#[
-# Deprecated as it exists in the standard times module now.
-proc `>`*(a, b: TimeInfo): bool =
-  return a.toTime > b.toTime
-
-proc `<`*(a, b: TimeInfo): bool =
-  return a.toTime < b.toTime
-
-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 format*(d: Duration, fmt: string): string =
+  let info = (fromUnix(0) + d).utc
+  return info.format(fmt)
 
 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
-  else: return -1
+  elif times.`<`(a, b): return -1
+  else: return 1
 
-proc startOfDay*(ti: DateTime): DateTime =
-  result = ti
-  result.hour = 0
-  result.minute = 0
-  result.second = 0
+proc startOfDay*(dt: DateTime): DateTime =
+  result = initDateTime(
+    dt.monthday,
+    dt.month,
+    dt.year,
+    0, 0, 0, 0, # hour, minute, second, nanosecond
+    dt.timezone)
+
+proc trimNanoSec*(dt: DateTime): DateTime =
+  result = dt
+  result = initDateTime(
+    dt.monthday,
+    dt.month,
+    dt.year,
+    dt.hour,
+    dt.minute,
+    dt.second,
+    0,
+    dt.timezone)
 
 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 =
+  var errString = ""
+  for df in ISO_8601_FORMATS:
+    try: return val.parse(df)
+    except: errString &= "\n" & getCurrentExceptionMsg()
+  raise newException(Exception, "Could not parse date. Tried:" & errString)
+
+proc formatIso8601*(d: DateTime): string =
+  return d.format(ISO_8601_FORMATS[2])
+
 # 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 = parse(value, format)
+template fixedParse*(value, format: string): DateTime {.deprecated.} =
+  parse(value, format)

timeutils.nimble

@@ -1,11 +1,10 @@
 # Package
 
-version       = "0.2.2"
+version       = "0.5.4"
 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."
+description   = "Utility methods to fill in the lacking time support in Nim\'s stdlib."
 license       = "BSD3"
 
 # Dependencies
 
-requires "nim >= 0.18.1"
-
+requires "nim >= 1.3.1"