Added startOfDay, startOfWeek, and fixedParse.

* `startOfDay(TimeInfo): TimeInfo` returns a new `TimeInfo` representing
  midnight at the beginning of the given day.
* `startOfWeek(TimeInfo, WeekDay): TimeInfo` returns a new `TimeInfo`
  representing midnight at the beginning of the first day of the week. By
  default Monday is used as the start of the week (to be consistent with
  `times` view of the day order), but the user can pass in any other day to
  "start" the week. Because this find the start of the *current* week, the
  returned `TimeInfo` will always be a date in the past or present, never a
  date in the future.

test/ttimeutils.nim

@@ -1,5 +1,7 @@
 import times, timeutils, unittest
 
+let dtFormat = "yyyy-MM-dd HH:mm:ss"
+
 suite "timeutils":
   test "format TimeInterval":
     let interval = seconds(70)
@@ -64,3 +66,61 @@ suite "timeutils":
     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))

timeutils.nim

@@ -33,7 +33,28 @@ 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: TimeInfo): int =
   if b == a: return 0
-  elif b > a: return 1
+  elif a > b: return 1
   else: return -1
+
+proc startOfDay*(ti: TimeInfo): TimeInfo =
+  result = ti
+  result.hour = 0
+  result.minute = 0
+  result.second = 0
+
+proc startOfWeek*(ti: TimeInfo, startDay = dMon): TimeInfo =
+  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
+

timeutils.nimble

@@ -1,8 +1,8 @@
 # Package
 
-version       = "0.1.1"
+version       = "0.2.0"
 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. This is holding me over until I can write a proper time module for the stdlib and submit it."
 license       = "BSD3"
 
 # Dependencies