Changes to support Nim 0.18 (with new times implementation).

tests/ttimeutils.nim

@@ -1,4 +1,5 @@
-import times, timeutils, unittest
+import times, unittest
+import "../timeutils"
 
 let dtFormat = "yyyy-MM-dd HH:mm:ss"
 
@@ -10,19 +11,19 @@ suite "timeutils":
       interval.format("mm'm' ss's'") == "01m 10s"
       interval.format("mm:ss") == "01:10"
 
-  test "TimeInfo difference":
+  test "DateTime 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
+    check t2 - t1 == seconds(24 * 60 * 60)
 
     t2 = parse("2016-10-11 10:00:00", "yyyy-MM-dd HH:mm:ss")
-    check t2 - t1 == (1.days + 15.minutes)
+    check t2 - t1 == seconds((24 * 60 + 15) * 60)
 
-  test "TimeInfo comparisons":
+  test "DateTime comparisons":
     let t1 = getLocalTime(getTime())
 
     check:
@@ -60,7 +61,7 @@ suite "timeutils":
       60.seconds <= 2.minutes
       not (2.minutes <= 60.seconds)
 
-  test "TimeInfo cmp":
+  test "DateTime cmp":
     let t1 = getLocalTime(getTime())
 
     check cmp(t1, t1) == 0
@@ -68,54 +69,39 @@ suite "timeutils":
     check cmp(t1 + 10.seconds, t1) == 1
 
   test "startOfDay":
-    let t1 = fixedParse("13:42:19", "HH:mm:ss")
-    let t2 = fixedParse("2015-12-31 23:59:59", dtFormat)
+    let t1 = parse("13:42:19", "HH:mm:ss")
+    let t2 = parse("2015-12-31 23:59:59", dtFormat)
 
     check:
-      fixedParse("00:00:00", "HH:mm:ss") == startOfDay(t1)
+      parse("00:00:00", "HH:mm:ss") == startOfDay(t1)
 
-      #check fixedParse("2015-12-31 00:00:00", dtFormat) == startOfDay(t2)
+      #check parse("2015-12-31 00:00:00", dtFormat) == startOfDay(t2)
 
       startOfDay(startOfDay(t1)) == startOfDay(t1)
 
   test "startOfWeek":
-    let t1 = fixedParse("2015-12-31 23:59:59", dtFormat)
-    let t2 = fixedParse("2015-12-26 23:59:59", dtFormat)
-    let t3 = fixedParse("2016-01-01 23:59:59", dtFormat)
+    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(getLocalTime(toTime(fixedParse("2015-12-28 12:01:00", dtFormat))))
+      startOfWeek(t1) == startOfDay(getLocalTime(toTime(parse("2015-12-28 12:01:00", dtFormat))))
       startOfWeek(t1).weekday == dMon
       startOfWeek(startOfWeek(t1)) == startOfWeek(t1)
 
-      startOfWeek(t2) == startOfDay(fixedParse("2015-12-21 01:00:00", dtFormat))
-      startOfWeek(t3) == startOfDay(fixedParse("2015-12-28 01:00:00", dtFormat))
+      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(fixedParse("2015-12-27 01:00:00", dtFormat))
+      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(fixedParse("2015-12-20 01:00:00", dtFormat))
-      startOfWeek(t3, dSun) == startOfDay(fixedParse("2015-12-27 01:00:00", dtFormat))
-
-  test "times.parse is still broken":
-    let t1 = parse("2015-12-01 12:00:00", dtFormat)
-    let t2 = parse("2015-06-01 12:00:00", dtFormat)
-
-    # parse is broken in that is uses the DST setting of the current time when
-    # parsing dates when it should figure out the DST time for that date. So
-    # depending on if you are currently in DST or not, one of the above dates
-    # will not parse correctly. We want to check that one of those fails to
-    # parse correctly. When they both parse correctly, the times.parse bug has
-    # been fixed and fixedParse is no longer necessary.
-
-    # This test works because passing the time through getLocalTime(toTime())
-    # correctly the DST setting for the time.
-    check t1 != getLocalTime(toTime(t1)) or t2 != getLocalTime(toTime(t2))
+      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)

timeutils.nim

@@ -6,9 +6,11 @@ proc format*(ti: TimeInterval, fmt: string): string =
   let info = getGMTime(fromSeconds(0) + ti)
   return info.format(fmt)
 
-proc `-`*(a, b: TimeInfo): TimeInterval =
+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
 
@@ -20,6 +22,7 @@ proc `>=`*(a, b: TimeInfo): bool =
 
 proc `<=`*(a, b: TimeInfo): bool =
   return a.toTime <= b.toTime
+]#
 
 proc `>`*(a, b: TimeInterval): bool =
   return (zeroTime + a) > (zeroTime + b)
@@ -33,28 +36,23 @@ proc `>=`*(a, b: TimeInterval): bool =
 proc `<=`*(a, b: TimeInterval): bool =
   return (zeroTime + a) <= (zeroTime + b)
 
-proc cmp*(a, b: TimeInfo): int =
+proc cmp*(a, b: DateTime): int =
   if b == a: return 0
   elif a > b: return 1
   else: return -1
 
-proc startOfDay*(ti: TimeInfo): TimeInfo =
+proc startOfDay*(ti: DateTime): DateTime =
   result = ti
   result.hour = 0
   result.minute = 0
   result.second = 0
 
-proc startOfWeek*(ti: TimeInfo, startDay = dMon): TimeInfo =
+proc startOfWeek*(ti: DateTime, startDay = dMon): DateTime =
   var diff = (ti.weekday.ord - startDay.ord)
   if diff < 0: diff += 7
   return (ti - diff.days).startOfDay
 
 # This is a workaround needed due a bug in Nim's times.parse procedure.
 # see: https://github.com/nim-lang/Nim/issues/4922
-proc fixedParse*(value, format: string): TimeInfo =
-  let firstParsed = parse(value, format)
-  let rectified = getLocalTime(toTime(firstParsed))
-  if firstParsed.isDST and not rectified.isDST: return rectified + 1.hours
-  elif not firstParsed.isDST and rectified.isDST: return rectified - 1.hours
-  else: return rectified
-
+{.deprecated.}
+template fixedParse*(value, format: string): DateTime = parse(value, format)

timeutils.nimble

@@ -1,11 +1,11 @@
 # Package
 
-version       = "0.2.0"
+version       = "0.2.2"
 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.15.0"
+requires "nim >= 0.18.1"