5 files changed, 231 insertions, 13 deletions
diff --git a/src/main/scala/xyz/driver/core/domain.scala b/src/main/scala/xyz/driver/core/domain.scala
index 48943a7..7731345 100644
--- a/src/main/scala/xyz/driver/core/domain.scala
+++ b/src/main/scala/xyz/driver/core/domain.scala
@@ -1,13 +1,14 @@
 package xyz.driver.core
 
+import com.google.i18n.phonenumbers.PhoneNumberUtil
 import scalaz.Equal
-import scalaz.syntax.equal._
 import scalaz.std.string._
+import scalaz.syntax.equal._
 
 object domain {
 
   final case class Email(username: String, domain: String) {
-    override def toString = username + "@" + domain
+    override def toString: String = username + "@" + domain
   }
 
   object Email {
@@ -27,16 +28,13 @@ object domain {
   }
 
   object PhoneNumber {
-    def parse(phoneNumberString: String): Option[PhoneNumber] = {
-      val onlyDigits = phoneNumberString.replaceAll("[^\\d.]", "")
 
-      if (onlyDigits.length < 10) None
-      else {
-        val tenDigitNumber = onlyDigits.takeRight(10)
-        val countryCode    = Option(onlyDigits.dropRight(10)).filter(_.nonEmpty).getOrElse("1")
+    private val phoneUtil = PhoneNumberUtil.getInstance()
 
-        Some(PhoneNumber(countryCode, tenDigitNumber))
-      }
+    def parse(phoneNumber: String): Option[PhoneNumber] = {
+      val phone = phoneUtil.parseAndKeepRawInput(phoneNumber, "US")
+      if (!phoneUtil.isValidNumber(phone)) None
+      else Some(PhoneNumber(phone.getCountryCode.toString, phone.getNationalNumber.toString))
     }
   }
 }
diff --git a/src/main/scala/xyz/driver/core/generators.scala b/src/main/scala/xyz/driver/core/generators.scala
index e3ff326..143044c 100644
--- a/src/main/scala/xyz/driver/core/generators.scala
+++ b/src/main/scala/xyz/driver/core/generators.scala
@@ -3,7 +3,7 @@ package xyz.driver.core
 import java.math.MathContext
 import java.util.UUID
 
-import xyz.driver.core.time.{Time, TimeRange}
+import xyz.driver.core.time.{Time, TimeOfDay, TimeRange}
 import xyz.driver.core.date.{Date, DayOfWeek}
 
 import scala.reflect.ClassTag
@@ -69,6 +69,8 @@ object generators {
 
   def nextTime(): Time = Time(math.abs(nextLong() % System.currentTimeMillis))
 
+  def nextTimeOfDay: TimeOfDay = TimeOfDay(java.time.LocalTime.MIN.plusSeconds(nextLong), java.util.TimeZone.getDefault)
+
   def nextTimeRange(): TimeRange = {
     val oneTime     = nextTime()
     val anotherTime = nextTime()
diff --git a/src/main/scala/xyz/driver/core/json.scala b/src/main/scala/xyz/driver/core/json.scala
index 02a35fd..4d7fa04 100644
--- a/src/main/scala/xyz/driver/core/json.scala
+++ b/src/main/scala/xyz/driver/core/json.scala
@@ -1,7 +1,7 @@
 package xyz.driver.core
 
 import java.net.InetAddress
-import java.util.UUID
+import java.util.{TimeZone, UUID}
 
 import scala.reflect.runtime.universe._
 import scala.util.Try
@@ -14,7 +14,7 @@ import spray.json._
 import xyz.driver.core.auth.AuthCredentials
 import xyz.driver.core.date.{Date, DayOfWeek, Month}
 import xyz.driver.core.domain.{Email, PhoneNumber}
-import xyz.driver.core.time.Time
+import xyz.driver.core.time.{Time, TimeOfDay}
 import eu.timepit.refined.refineV
 import eu.timepit.refined.api.{Refined, Validate}
 import eu.timepit.refined.collection.NonEmpty
@@ -80,6 +80,33 @@ object json {
     }
   }
 
+  implicit object localTimeFormat extends JsonFormat[java.time.LocalTime] {
+    private val formatter = TimeOfDay.getFormatter
+    def read(json: JsValue): java.time.LocalTime = json match {
+      case JsString(chars) =>
+        java.time.LocalTime.parse(chars)
+      case _ => deserializationError(s"Expected time string got ${json.toString}")
+    }
+
+    def write(obj: java.time.LocalTime): JsValue = {
+      JsString(obj.format(formatter))
+    }
+  }
+
+  implicit object timeZoneFormat extends JsonFormat[java.util.TimeZone] {
+    override def write(obj: TimeZone): JsValue = {
+      JsString(obj.getID())
+    }
+
+    override def read(json: JsValue): TimeZone = json match {
+      case JsString(chars) =>
+        java.util.TimeZone.getTimeZone(chars)
+      case _ => deserializationError(s"Expected time zone string got ${json.toString}")
+    }
+  }
+
+  implicit val timeOfDayFormat: RootJsonFormat[TimeOfDay] = jsonFormat2(TimeOfDay.apply)
+
   implicit val dayOfWeekFormat: JsonFormat[DayOfWeek] =
     new EnumJsonFormat[DayOfWeek](DayOfWeek.All.map(w => w.toString -> w)(collection.breakOut): _*)
 
diff --git a/src/main/scala/xyz/driver/core/rest/PatchDirectives.scala b/src/main/scala/xyz/driver/core/rest/PatchDirectives.scala
new file mode 100644
index 0000000..256358c
--- /dev/null
+++ b/src/main/scala/xyz/driver/core/rest/PatchDirectives.scala
@@ -0,0 +1,104 @@
+package xyz.driver.core.rest
+
+import akka.http.javadsl.server.Rejections
+import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
+import akka.http.scaladsl.model.{ContentTypeRange, HttpCharsets, MediaType}
+import akka.http.scaladsl.server._
+import akka.http.scaladsl.unmarshalling.{FromEntityUnmarshaller, Unmarshaller}
+import spray.json._
+
+import scala.concurrent.Future
+import scala.util.{Failure, Success, Try}
+
+trait PatchDirectives extends Directives with SprayJsonSupport {
+
+  /** Media type for patches to JSON values, as specified in [[https://tools.ietf.org/html/rfc7396 RFC 7396]]. */
+  val `application/merge-patch+json`: MediaType.WithFixedCharset =
+    MediaType.applicationWithFixedCharset("merge-patch+json", HttpCharsets.`UTF-8`)
+
+  /** Wraps a JSON value that represents a patch.
+    * The patch must given in the format specified in [[https://tools.ietf.org/html/rfc7396 RFC 7396]]. */
+  case class PatchValue(value: JsValue) {
+
+    /** Applies this patch to a given original JSON value. In other words, merges the original with this "diff". */
+    def applyTo(original: JsValue): JsValue = mergeJsValues(original, value)
+  }
+
+  /** Witness that the given patch may be applied to an original domain value.
+    * @tparam A type of the domain value
+    * @param patch the patch that may be applied to a domain value
+    * @param format a JSON format that enables serialization and deserialization of a domain value */
+  case class Patchable[A](patch: PatchValue, format: RootJsonFormat[A]) {
+
+    /** Applies the patch to a given domain object. The result will be a combination
+      * of the original value, updates with the fields specified in this witness' patch. */
+    def applyTo(original: A): A = {
+      val serialized   = format.write(original)
+      val merged       = patch.applyTo(serialized)
+      val deserialized = format.read(merged)
+      deserialized
+    }
+  }
+
+  implicit def patchValueUnmarshaller: FromEntityUnmarshaller[PatchValue] =
+    Unmarshaller.byteStringUnmarshaller
+      .andThen(sprayJsValueByteStringUnmarshaller)
+      .forContentTypes(ContentTypeRange(`application/merge-patch+json`))
+      .map(js => PatchValue(js))
+
+  implicit def patchableUnmarshaller[A](
+      implicit patchUnmarshaller: FromEntityUnmarshaller[PatchValue],
+      format: RootJsonFormat[A]): FromEntityUnmarshaller[Patchable[A]] = {
+    patchUnmarshaller.map(patch => Patchable[A](patch, format))
+  }
+
+  protected def mergeObjects(oldObj: JsObject, newObj: JsObject, maxLevels: Option[Int] = None): JsObject = {
+    JsObject(oldObj.fields.map({
+      case (key, oldValue) =>
+        val newValue = newObj.fields.get(key).fold(oldValue)(mergeJsValues(oldValue, _, maxLevels.map(_ - 1)))
+        key -> newValue
+    })(collection.breakOut): _*)
+  }
+
+  protected def mergeJsValues(oldValue: JsValue, newValue: JsValue, maxLevels: Option[Int] = None): JsValue = {
+    def mergeError(typ: String): Nothing =
+      deserializationError(s"Expected $typ value, got $newValue")
+
+    if (maxLevels.exists(_ < 0)) oldValue
+    else {
+      (oldValue, newValue) match {
+        case (_: JsString, newString @ (JsString(_) | JsNull)) => newString
+        case (_: JsString, _)                                  => mergeError("string")
+        case (_: JsNumber, newNumber @ (JsNumber(_) | JsNull)) => newNumber
+        case (_: JsNumber, _)                                  => mergeError("number")
+        case (_: JsBoolean, newBool @ (JsBoolean(_) | JsNull)) => newBool
+        case (_: JsBoolean, _)                                 => mergeError("boolean")
+        case (_: JsArray, newArr @ (JsArray(_) | JsNull))      => newArr
+        case (_: JsArray, _)                                   => mergeError("array")
+        case (oldObj: JsObject, newObj: JsObject)              => mergeObjects(oldObj, newObj)
+        case (_: JsObject, JsNull)                             => JsNull
+        case (_: JsObject, _)                                  => mergeError("object")
+        case (JsNull, _)                                       => newValue
+      }
+    }
+  }
+
+  def mergePatch[T](patchable: Patchable[T], retrieve: => Future[Option[T]]): Directive1[T] =
+    Directive { inner => requestCtx =>
+      onSuccess(retrieve)({
+        case Some(oldT) =>
+          Try(patchable.applyTo(oldT))
+            .transform[Route](
+              mergedT => scala.util.Success(inner(Tuple1(mergedT))), {
+                case jsonException: DeserializationException =>
+                  Success(reject(Rejections.malformedRequestContent(jsonException.getMessage, jsonException)))
+                case t => Failure(t)
+              }
+            )
+            .get // intentionally re-throw all other errors
+        case None => reject()
+      })(requestCtx)
+    }
+}
+
+object PatchDirectives extends PatchDirectives
diff --git a/src/main/scala/xyz/driver/core/time.scala b/src/main/scala/xyz/driver/core/time.scala
index 3bcc7bc..bab304d 100644
--- a/src/main/scala/xyz/driver/core/time.scala
+++ b/src/main/scala/xyz/driver/core/time.scala
@@ -4,7 +4,10 @@ import java.text.SimpleDateFormat
 import java.util._
 import java.util.concurrent.TimeUnit
 
+import xyz.driver.core.date.Month
+
 import scala.concurrent.duration._
+import scala.util.Try
 
 object time {
 
@@ -39,6 +42,90 @@ object time {
     }
   }
 
+  /**
+    * Encapsulates a time and timezone without a specific date.
+    */
+  final case class TimeOfDay(localTime: java.time.LocalTime, timeZone: TimeZone) {
+
+    /**
+      * Is this time before another time on a specific day. Day light savings safe. These are zero-indexed
+      * for month/day.
+      */
+    def isBefore(other: TimeOfDay, day: Int, month: Month, year: Int): Boolean = {
+      toCalendar(day, month, year).before(other.toCalendar(day, month, year))
+    }
+
+    /**
+      * Is this time after another time on a specific day. Day light savings safe.
+      */
+    def isAfter(other: TimeOfDay, day: Int, month: Month, year: Int): Boolean = {
+      toCalendar(day, month, year).after(other.toCalendar(day, month, year))
+    }
+
+    def sameTimeAs(other: TimeOfDay, day: Int, month: Month, year: Int): Boolean = {
+      toCalendar(day, month, year).equals(other.toCalendar(day, month, year))
+    }
+
+    /**
+      * Enforces the same formatting as expected by [[java.sql.Time]]
+      * @return string formatted for `java.sql.Time`
+      */
+    def timeString: String = {
+      localTime.format(TimeOfDay.getFormatter)
+    }
+
+    /**
+      * @return a string parsable by [[java.util.TimeZone]]
+      */
+    def timeZoneString: String = {
+      timeZone.getID
+    }
+
+    /**
+      * @return this [[TimeOfDay]] as [[java.sql.Time]] object, [[java.sql.Time.valueOf]] will
+      *         throw when the string is not valid, but this is protected by [[timeString]] method.
+      */
+    def toTime: java.sql.Time = {
+      java.sql.Time.valueOf(timeString)
+    }
+
+    private def toCalendar(day: Int, month: Int, year: Int): Calendar = {
+      val cal = Calendar.getInstance(timeZone)
+      cal.set(year, month, day, localTime.getHour, localTime.getMinute, localTime.getSecond)
+      cal
+    }
+  }
+
+  object TimeOfDay {
+    def now(): TimeOfDay = {
+      TimeOfDay(java.time.LocalTime.now(), TimeZone.getDefault)
+    }
+
+    /**
+      * Throws when [s] is not parsable by [[java.time.LocalTime.parse]], uses default [[java.util.TimeZone]]
+      */
+    def parseTimeString(tz: TimeZone = TimeZone.getDefault)(s: String): TimeOfDay = {
+      TimeOfDay(java.time.LocalTime.parse(s), tz)
+    }
+
+    def fromString(tz: TimeZone)(s: String): Option[TimeOfDay] = {
+      val op = Try(java.time.LocalTime.parse(s)).toOption
+      op.map(lt => TimeOfDay(lt, tz))
+    }
+
+    def fromStrings(zoneId: String)(s: String): Option[TimeOfDay] = {
+      val op = Try(TimeZone.getTimeZone(zoneId)).toOption
+      op.map(tz => TimeOfDay.parseTimeString(tz)(s))
+    }
+
+    /**
+      * Formatter that enforces `HH:mm:ss` which is expected by [[java.sql.Time]]
+      */
+    def getFormatter: java.time.format.DateTimeFormatter = {
+      java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss")
+    }
+  }
+
   object Time {
 
     implicit def timeOrdering: Ordering[Time] = Ordering.by(_.millis)