test/ttimeutils.nim

@@ -0,0 +1,126 @@
+import times, timeutils, unittest
+
+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 "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
+
+  test "startOfDay":
+    let t1 = fixedParse("13:42:19", "HH:mm:ss")
+    let t2 = fixedParse("2015-12-31 23:59:59", dtFormat)
+
+    check:
+      fixedParse("00:00:00", "HH:mm:ss") == startOfDay(t1)
+
+      #check fixedParse("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)
+
+    # 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).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))
+
+      # Start of week = Sunday
+      startOfWeek(t1, dSun) == startOfDay(fixedParse("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))
+
+  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 == getLocalTime(toTime(t1))
+      t2 == getLocalTime(toTime(t2))

tests/ttimeutils.nim

@@ -1,115 +0,0 @@
-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,74 +1,60 @@
 import times
 
-const zeroTime = fromUnix(0)
+const zeroTime = fromSeconds(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 = (zeroTime + ti).utc
+  let info = getGMTime(fromSeconds(0) + ti)
   return info.format(fmt)
 
-proc format*(d: Duration, fmt: string): string =
+proc `-`*(a, b: TimeInfo): TimeInterval =
-  let info = (fromUnix(0) + d).utc
+  return seconds(cast[int](a.toTime - b.toTime))
-  return info.format(fmt)
+
+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 `<`*(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 =
+proc cmp*(a, b: TimeInfo): int =
-  return times.`<=`(s, a) and times.`<`(a, e)
-
-proc cmp*(a, b: DateTime): int =
   if b == a: return 0
-  elif times.`<`(a, b): return -1
+  elif a > b: return 1
-  else: return 1
+  else: return -1
 
-proc startOfDay*(dt: DateTime): DateTime =
+proc startOfDay*(ti: TimeInfo): TimeInfo =
-  result = initDateTime(
+  result = ti
-    dt.monthday,
+  result.hour = 0
-    dt.month,
+  result.minute = 0
-    dt.year,
+  result.second = 0
-    0, 0, 0, 0, # hour, minute, second, nanosecond
-    dt.timezone)
 
-proc trimNanoSec*(dt: DateTime): DateTime =
+proc startOfWeek*(ti: TimeInfo, startDay = dMon): TimeInfo =
-  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.} =
+proc fixedParse*(value, format: string): TimeInfo =
-  parse(value, format)
+  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
+

timeutils.nimble

@@ -1,10 +1,11 @@
 # Package
 
-version       = "0.5.4"
+version       = "0.2.0"
 author        = "Jonathan Bernard"
-description   = "Utility methods to fill in the lacking time support in Nim\'s stdlib."
+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 >= 1.3.1"
+requires "nim >= 0.15.0"
+