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))