More date things.

Author: markhibberd

doc/dates.md

@@ -291,6 +291,31 @@ E4|A1|3|2010-03-03T14:30:00+1100
 ```
 
 
+Daylight Savings Time
+---------------------
+
+Some extra treatment for daylight savings time.
+
+Facts are stored with milliseconds since the start of the day. On
+daylight savings cross over days where an hour is _gained_ there is an
+overlap where multiple hour / minutes all map to the same "second of
+day" measure used by most date / time libraries (for example
+joda). Currently ivory handles this in the same way where "second of
+day" is computed only from the hour, minute and second - independent
+of DST related timezone offset changes.
+
+To address this we could do one of two things:
+   - annotate DST overlapped hours with an extra bit in the time field; or
+   - offset time by an additional interval to handle the gained time.
+
+However, both of these things require non-standard treament of "second
+of day" and will require code changes to ivory to handle.
+
+To be clear, at this point ivory handles "second of day" based only on
+hour, minute and second of day. But in the future further information
+may be added to provide additional mechanisms to deal with DST
+overlaps.
+
 
 Current Status
 --------------

ivory-benchmark/src/main/scala/com/ambiata/ivory/benchmark/DatesBench.scala

@@ -53,16 +53,25 @@ case class DatesBench() extends SimpleScalaBenchmark {
   def time_hand_less_bad(n: Int) =
     hand_less_alloc(n, "201x-01-01")
 
+  def time_actual_ok(n: Int) =
+    actual(n, "2012-01-01")
+
+  def time_actual_invalid(n: Int) =
+    actual(n, "2012-99-01")
+
+  def time_actual_bad(n: Int) =
+    actual(n, "201x-01-01")
+
   /*
    * The basic joda approach, note: parseLocalDate throws exceptions so the catch is required.
    */
   def joda(n: Int, s: String) = {
     val f = DateTimeFormat.forPattern("yyyy-MM-dd")
-    repeat[String \/ Date](n) {
+    repeat[Option[Date]](n) {
       try {
         val d = f.parseLocalDate(s)
-        Date.unsafe(d.getYear.toShort, d.getMonthOfYear.toByte, d.getDayOfMonth.toByte).right[String]
-      } catch { case e: Throwable => "bad".left }
+        Date.unsafe(d.getYear.toShort, d.getMonthOfYear.toByte, d.getDayOfMonth.toByte).some
+      } catch { case e: Throwable => None }
     }
   }
 
@@ -71,12 +80,12 @@ case class DatesBench() extends SimpleScalaBenchmark {
    */
   def regex(n: Int, s: String) = {
     val DateParser = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
-    repeat[String \/ Date](n) {
+    repeat[Option[Date]](n) {
        s match {
          case DateParser(y, m, d) =>
-           try Date.create(y.toShort, m.toByte, d.toByte).get.right
-           catch { case e: Throwable => "bad".left }
-         case _ => "bad".left
+           try Date.create(y.toShort, m.toByte, d.toByte)
+           catch { case e: Throwable => None }
+         case _ => None
        }
     }
   }
@@ -85,26 +94,34 @@ case class DatesBench() extends SimpleScalaBenchmark {
    * A crude parser that unpacks things by hand.
    */
   def hand(n: Int, s: String) =
-    repeat[String \/ Date](n) {
+    repeat[Option[Date]](n) {
        if (s.length != 10 || s.charAt(4) != '-' || s.charAt(7) != '-')
-         "bad".left
+         None
        else try
-         Date.create(s.substring(0, 4).toShort, s.substring(5, 7).toByte, s.substring(9, 10).toByte).get.right
-       catch { case e: Throwable => "bad".left }
+         Date.create(s.substring(0, 4).toShort, s.substring(5, 7).toByte, s.substring(8, 10).toByte)
+       catch { case e: Throwable => None }
     }
 
   /*
    * A crude parser that unpacks things by hand with less allocation
    */
   def hand_less_alloc(n: Int, s: String) =
-    repeat[String \/ Date](n) {
+    repeat[Option[Date]](n) {
        if (s.length != 10 || s.charAt(4) != '-' || s.charAt(7) != '-')
-         "bad".left
+         None
        else try {
          val y = s.substring(0, 4).toShort
          val m = s.substring(5, 7).toByte
-         val d = s.substring(9, 10).toByte
-         if (Date.isValid(y, m, d)) Date.unsafe(y, m, d).right else "bad".left
-       } catch { case e: Throwable => "bad".left }
+         val d = s.substring(8, 10).toByte
+         if (Date.isValid(y, m, d)) Date.unsafe(y, m, d).some else None
+       } catch { case e: Throwable => None }
+    }
+
+  /*
+   * A crude parser that unpacks things by hand with less allocation
+   */
+  def actual(n: Int, s: String) =
+    repeat[Option[Date]](n) {
+      Dates.date(s)
     }
 }

ivory-core/src/main/scala/com/ambiata/ivory/core/Dates.scala

@@ -1,10 +1,29 @@
 package com.ambiata.ivory.core
-
 import scalaz._, Scalaz._
 import org.joda.time.LocalDate
 import com.ambiata.mundane.parse.ListParser
 
 object Dates {
   def parse(s: String): Date \/ DateTime =
     ???
+
+  // FIX It would be nice if we could avoid the joda overhead here, but we would need to
+  //     implement something to handle daylight savings offsets before we could.
+  def datetime(s: String): Option[DateTime] =
+    try {
+      ???
+//      val d = DateTimeFormat.forPattern("yyyy-MM-ddTHH:mm:ss").parseLocalDateTime(s)
+//
+//      DateTime.create(d.getYear.toShort, d.getMonthOfYear.toByte, d.getDayOfMonth.toByte, d.getMillisOfDay)
+    } catch { case e: Throwable => None }
+
+  def date(s: String): Option[Date] =
+    if (s.length != 10 || s.charAt(4) != '-' || s.charAt(7) != '-')
+      None
+    else try {
+      val y = s.substring(0, 4).toShort
+      val m = s.substring(5, 7).toByte
+      val d = s.substring(8, 10).toByte
+      if (Date.isValid(y, m, d)) Some(Date.unsafe(y, m, d)) else None
+    } catch { case e: Throwable => None }
 }

ivory-core/src/main/scala/com/ambiata/ivory/core/Time.scala

@@ -25,8 +25,11 @@ object Time {
   def unsafe(seconds: Int): Time =
     new Time(seconds)
 
+  def isValid(seconds: Int): Boolean =
+    seconds >= 0 && seconds < (60 * 60 * 24)
+
   def create(seconds: Int): Option[Time] =
-    (seconds >= 0 && seconds < (60 * 60 * 24)).option(unsafe(seconds))
+    isValid(seconds).option(unsafe(seconds))
 
   object Macros {
     import scala.reflect.macros.Context

ivory-core/src/test/scala/com/ambiata/ivory/core/DatesSpec.scala

@@ -0,0 +1,52 @@
+package com.ambiata.ivory.core
+
+import com.ambiata.ivory.core.Arbitraries._
+import org.specs2._, matcher._, specification._
+import org.scalacheck._, Arbitrary._
+import org.joda.time._, format.DateTimeFormat
+import scalaz._, Scalaz._
+
+class DatesSpec extends Specification with ScalaCheck { def is = s2"""
+
+Date Parsing
+------------
+
+  Symmetric                                       $symmetric
+  Invalid year                                    $year
+  Invalid month                                   $month
+  Invalid day                                     $day
+  Edge cases                                      $edge
+  Exceptional - non numeric values                $exceptional
+  Round-trip with joda                            $joda
+  Parses same as joda                             $jodaparse
+
+
+"""
+
+  def symmetric = prop((d: Date) =>
+    Dates.date(d.hyphenated) must beSome(d))
+
+  def year = prop((d: Date) =>
+    Dates.date("0100-%02d-%02d".format(d.month, d.day)) must beNone)
+
+  def month = prop((d: Date) =>
+    Dates.date("%4d-13-%02d".format(d.year, d.day)) must beNone)
+
+  def day = prop((d: Date) =>
+    Dates.date("%4d-%02d-32".format(d.year, d.month)) must beNone)
+
+  def exceptional = prop((d: Date) =>
+    Dates.date(d.hyphenated.replaceAll("""\d""", "x")) must beNone)
+
+  def joda = prop((d: Date) =>
+    Dates.date(new LocalDate(d.year, d.month, d.day).toString("yyyy-MM-dd")) must beSome(d))
+
+  def jodaparse = prop((d: Date) => {
+    val j = DateTimeFormat.forPattern("yyyy-MM-dd").parseLocalDate(d.hyphenated)
+    (j.getYear, j.getMonthOfYear, j.getDayOfMonth) must_== ((d.year.toInt, d.month.toInt, d.day.toInt)) })
+
+  def edge = {
+    (Dates.date("2000-02-29") must beSome(Date(2000, 2, 29))) and
+    (Dates.date("2001-02-29") must beNone)
+  }
+}