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.

test/ttimeutils.nim

@@ -1,66 +0,0 @@
-import times, timeutils, unittest
-
-suite "timeutils":
-  test "format TimeInterval":
-    let interval = seconds(70)
-    check:
-      interval.format("ss's'") == "10s"
-      interval.format("mm'm' ss's'") == "01m 10s"
-      interval.format("mm:ss") == "01:10"
-
-  test "TimeInfo difference":
-    var t1 = getLocalTime(getTime())
-    var t2 = t1 + 30.seconds
-    check t2 - t1 == 30.seconds
-
-    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 == 1.days
-
-    t2 = parse("2016-10-11 10:00:00", "yyyy-MM-dd HH:mm:ss")
-    check t2 - t1 == (1.days + 15.minutes)
-
-  test "TimeInfo comparisons":
-    let t1 = getLocalTime(getTime())
-
-    check:
-      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
-      not (t1 + 10.seconds <= t1)
- 
-  test "TimeInterval comparisons":
-    check:
-      30.seconds > 10.seconds
-      not (10.seconds > 30.seconds)
-      not (10.seconds > 10.seconds)
-
-      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)
-
-  test "TimeInfo cmp":
-    let t1 = getLocalTime(getTime())
-
-    check cmp(t1, t1) == 0
-    check cmp(t1, t1 + 10.seconds) == -1
-    check cmp(t1 + 10.seconds, t1) == 1

tests/ttimeutils.nim

@@ -0,0 +1,115 @@
+import times, unittest
+import "../timeutils"
+
+let dtFormat = "yyyy-MM-dd HH:mm:ss"
+
+suite "timeutils":
+  test "format TimeInterval":
+    let interval = seconds(70)
+    check:
+      interval.format("ss's'") == "10s"
+      interval.format("mm'm' ss's'") == "01m 10s"
+      interval.format("mm:ss") == "01:10"
+
+  test "DateTime difference":
+    var t1 = getTime().local
+    var 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 == initDuration(seconds = 24 * 60 * 60)
+
+    t2 = parse("2016-10-11 10:00:00", "yyyy-MM-dd HH:mm:ss")
+    check t2 - t1 == initDuration(seconds = (24 * 60 + 15) * 60)
+
+  test "DateTime comparisons":
+    let t1 = getTime().local
+
+    check:
+      not (t1 < t1)
+      t1 < t1 + 10.seconds
+      not (t1 + 10.seconds < t1)
+
+      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:
+      timeutils.`<`(10.minutes, 1.hours)
+      not timeutils.`<`(1.hours, 10.minutes)
+      not timeutils.`<`(1.hours, 1.hours)
+
+      timeutils.`<=`(60.seconds, 1.minutes)
+      timeutils.`<=`(60.seconds, 2.minutes)
+      not timeutils.`<=`(2.minutes, 60.seconds)
+
+  test "DateTime cmp":
+    let t1 = getTime().local
+
+    check cmp(t1, t1) == 0
+    check cmp(t1, t1 + 10.seconds) == -1
+    check cmp(t1 + 10.seconds, t1) == 1
+
+  test "startOfDay":
+    let t1 = parse("13:42:19", "HH:mm:ss")
+    let t2 = parse("2015-12-31 23:59:59", dtFormat)
+
+    check:
+      parse("00:00:00", "HH:mm:ss") == startOfDay(t1)
+
+      #check parse("2015-12-31 00:00:00", dtFormat) == startOfDay(t2)
+
+      startOfDay(startOfDay(t1)) == startOfDay(t1)
+
+  test "startOfWeek":
+    let t1 = parse("2015-12-31 23:59:59", dtFormat)
+    let t2 = parse("2015-12-26 23:59:59", dtFormat)
+    let t3 = parse("2016-01-01 23:59:59", dtFormat)
+
+    # Not parsing the start of the day in order to work around the bug
+    # mentioned above.
+    check:
+      # Start of week = Monday
+      startOfWeek(t1) == startOfDay(toTime(parse("2015-12-28 12:01:00", dtFormat)).local)
+      startOfWeek(t1).weekday == dMon
+      startOfWeek(startOfWeek(t1)) == startOfWeek(t1)
+
+      startOfWeek(t2) == startOfDay(parse("2015-12-21 01:00:00", dtFormat))
+      startOfWeek(t3) == startOfDay(parse("2015-12-28 01:00:00", dtFormat))
+
+      # Start of week = Sunday
+      startOfWeek(t1, dSun) == startOfDay(parse("2015-12-27 01:00:00", dtFormat))
+      startOfWeek(t1, dSun).weekday == dSun
+      startOfWeek(startOfWeek(t1, dSun), dSun) == startOfWeek(t1, dSun)
+
+      startOfWeek(t2, dSun) == startOfDay(parse("2015-12-20 01:00:00", dtFormat))
+      startOfWeek(t3, dSun) == startOfDay(parse("2015-12-27 01:00:00", dtFormat))
+
+  test "fixedParse":
+    let t1 = fixedParse("2015-12-01 12:00:00", dtFormat)
+    let t2 = fixedParse("2015-06-01 12:00:00", dtFormat)
+
+    check: # test both in DST and out of DST
+      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,39 +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: TimeInfo): TimeInterval =
-  return seconds(cast[int](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: 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 cmp(a, b: TimeInfo): int =
+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 b > a: return 1
-  else: return -1
+  elif times.`<`(a, b): return -1
+  else: return 1
+
+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
+template fixedParse*(value, format: string): DateTime {.deprecated.} =
+  parse(value, format)

timeutils.nimble

@@ -1,11 +1,10 @@
 # Package
 
-version       = "0.1.1"
+version       = "0.5.4"
 author        = "Jonathan Bernard"
-description   = "Utility methods to fill in the horrid 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.15.0"
-
+requires "nim >= 1.3.1"