Updated to scalaz 7.0.0-RC1

jdegoes · Apr 2, 2013 · cfff146 · cfff146
1 parent 3bca5b8
commit cfff146
Show file tree

Hide file tree

Showing 9 changed files with 58 additions and 51 deletions.
diff --git a/core/src/main/scala/blueeyes/core/data/Bijection.scala b/core/src/main/scala/blueeyes/core/data/Bijection.scala
@@ -3,7 +3,7 @@ package blueeyes.core.data
 import blueeyes.json.JValue
 import scala.xml.NodeSeq
 
-import scalaz.{ Validation, Failure, ValidationNEL }
+import scalaz.{ Validation, Failure, ValidationNel }
 import scalaz.Scalaz._
 
 sealed trait Unapply[A, B] {
@@ -70,7 +70,7 @@ trait IdentityBijections extends Bijections {
 
 object Bijection extends Bijections with IdentityBijections 
 
-trait PartialBijection[A, B] extends Function1[A, ValidationNEL[String, B]] with Unapply[ValidationNEL[String, A], B] { self =>
+trait PartialBijection[A, B] extends Function1[A, ValidationNel[String, B]] with Unapply[ValidationNel[String, A], B] { self =>
   //TODO: make this not discard errors
   def compose[C](next: PartialBijection[C, A]): PartialBijection[C, B] = new PartialBijection[C, B] {
     def apply(c: C) = next(c).flatMap(self) 
@@ -102,11 +102,11 @@ trait PartialBijection[A, B] extends Function1[A, ValidationNEL[String, B]] with
 }
 
 sealed class PartialBiject[A](a: A) {
-  def as[B](implicit f: PartialBiject.E[A, B]): ValidationNEL[String, B] = f.fold(_ apply a, _ unapply a)
+  def as[B](implicit f: PartialBiject.E[A, B]): ValidationNel[String, B] = f.fold(_ apply a, _ unapply a)
 }
 
 object PartialBiject {
-  type E[A, B] = Either[Function1[A, ValidationNEL[String, B]], Unapply[ValidationNEL[String, B], A]] 
+  type E[A, B] = Either[Function1[A, ValidationNel[String, B]], Unapply[ValidationNel[String, B], A]] 
 }
 
 object PartialBijections {
@@ -116,7 +116,7 @@ object PartialBijections {
   }
 
   implicit def partialBiject[A](a: A): PartialBiject[A] = new PartialBiject(a)
-  implicit def forwardEither[A, B](implicit a: Function1[A, ValidationNEL[String, B]]): PartialBiject.E[A, B]= Left(a)
-  implicit def reverseEither[A, B](implicit b: Unapply[ValidationNEL[String, B], A]): PartialBiject.E[A, B] = Right(b)
+  implicit def forwardEither[A, B](implicit a: Function1[A, ValidationNel[String, B]]): PartialBiject.E[A, B]= Left(a)
+  implicit def reverseEither[A, B](implicit b: Unapply[ValidationNel[String, B], A]): PartialBiject.E[A, B] = Right(b)
 }
 
diff --git a/json/src/main/scala/blueeyes/json/JValue.scala b/json/src/main/scala/blueeyes/json/JValue.scala
@@ -150,9 +150,9 @@ sealed trait JValue extends Merge.Mergeable with Diff.Diffable with Product with
   /**
    * A safe merge function that ensures that values are not overwritten.
    */
-  def insertAll(other: JValue): ValidationNEL[Throwable, JValue] = {
-    other.flattenWithPath.foldLeft[ValidationNEL[Throwable, JValue]](success(self)) {
-      case (acc, (path, value)) => acc flatMap { (_: JValue).insert(path, value).toValidationNEL }
+  def insertAll(other: JValue): ValidationNel[Throwable, JValue] = {
+    other.flattenWithPath.foldLeft[ValidationNel[Throwable, JValue]](success(self)) {
+      case (acc, (path, value)) => acc flatMap { (_: JValue).insert(path, value).toValidationNel }
     }
   }
 
@@ -933,15 +933,22 @@ case class JObject(fields: Map[String, JValue]) extends JValue {
   }
 
   private def fieldsEq(m1: Map[String, JValue], m2: Map[String, JValue]): Boolean = {
-    assert(m1.keys != null && m2.keys != null)
-    val keys = (m1.keys ++ m2.keys).toArray
-    quickSort(keys)
-    keys.foreach { key =>
-      val v1 = m1.getOrElse(key, JUndefined)
-      val v2 = m2.getOrElse(key, JUndefined)
-      if (!v1.equals(v2)) return false
-    }
-    true
+    try {
+      assert(m1.keys != null && m2.keys != null)
+      val allKeys: Iterable[String] = m1.keys ++ m2.keys
+      assert(allKeys != null)
+      assert(implicitly[ClassManifest[String]] != null)
+      val keys = allKeys.toArray
+      quickSort(keys)
+      keys.foreach { key =>
+        val v1 = m1.getOrElse(key, JUndefined)
+        val v2 = m2.getOrElse(key, JUndefined)
+        if (!v1.equals(v2)) return false
+      }
+      true
+    } catch {
+      case ex => ex.printStackTrace; throw ex
+    } 
   }
 
   override def equals(other: Any) = other match {

diff --git a/mongo/src/main/scala/blueeyes/persistence/mongo/BijectionsMongoValue.scala b/mongo/src/main/scala/blueeyes/persistence/mongo/BijectionsMongoValue.scala
@@ -7,7 +7,7 @@ import com.mongodb.{BasicDBObject, DBObject}
 import org.bson.types.ObjectId
 
 import scala.collection.JavaConverters._
-import scalaz.{Success, NonEmptyList, ValidationNEL}
+import scalaz.{Success, NonEmptyList, ValidationNel}
 import scalaz.Validation._
 import scalaz.Scalaz._
 
@@ -28,15 +28,15 @@ class MongoObjectBijection extends MongoBijection[MongoValue, MongoField, MongoO
   def buildField(name: String, value: MongoValue)    = MongoField(name, value)
   def buildObject(fields: Seq[MongoField])           = MongoObject(fields.toList)
 
-  def unapply(mobject: MongoObject): ValidationNEL[String, DBObject] = {
+  def unapply(mobject: MongoObject): ValidationNel[String, DBObject] = {
     mobject.fields.foldLeft(success[NonEmptyList[String], BasicDBObject](new BasicDBObject)) {
       case (Success(obj), MongoField(name, value)) => toStorageValue(value).map(obj.append(name, _))
       case (failure, _) => failure
     }
   }
 
-  private def toStorageValue(mvalue: MongoValue): ValidationNEL[String, Any] = mvalue match {
-    case MongoArray(values)   => values.map(toStorageValue).sequence[({type N[B] = ValidationNEL[String, B]})#N, Any].map(_.asJava)
+  private def toStorageValue(mvalue: MongoValue): ValidationNel[String, Any] = mvalue match {
+    case MongoArray(values)   => values.map(toStorageValue).sequence[({type N[B] = ValidationNel[String, B]})#N, Any].map(_.asJava)
     case MongoInt(value)      => success(new java.lang.Integer(value))
     case MongoLong(value)     => success(new java.lang.Long(value))
     case MongoFloat(value)    => success(new java.lang.Float(value))

diff --git a/mongo/src/main/scala/blueeyes/persistence/mongo/Mongo.scala b/mongo/src/main/scala/blueeyes/persistence/mongo/Mongo.scala
@@ -96,7 +96,7 @@ object Database {
 
 private[mongo] trait DatabaseCollection{
   def aggregation(pipeline: JArray, output: Option[String]): Option[JObject]
-  def insert(objects: List[JObject])//: ValidationNEL[String, Unit]
+  def insert(objects: List[JObject])//: ValidationNel[String, Unit]
   def select(selection : MongoSelection, filter: Option[MongoFilter], sort: Option[MongoSort], skip: Option[Int],
              limit: Option[Int], hint: Option[Hint], isSnapshot : Boolean): IterableView[JObject, Iterator[JObject]]
   def explain(selection : MongoSelection, filter: Option[MongoFilter], sort: Option[MongoSort], skip: Option[Int],

diff --git a/mongo/src/main/scala/blueeyes/persistence/mongo/MongoBijection.scala b/mongo/src/main/scala/blueeyes/persistence/mongo/MongoBijection.scala
@@ -7,37 +7,37 @@ import org.bson.types.ObjectId
 
 import scala.collection.JavaConverters._
 import scalaz.Validation
-import scalaz.ValidationNEL
+import scalaz.ValidationNel
 import scalaz.Scalaz._
 
 
 trait MongoBijection[V, F, O <: V] extends PartialBijection[DBObject, O] {
-  def extractString (value: String): ValidationNEL[String, V]
-  def extractInteger(value: java.lang.Integer): ValidationNEL[String, V]
-  def extractLong   (value: java.lang.Long): ValidationNEL[String, V]
-  def extractFloat  (value: java.lang.Float): ValidationNEL[String, V]
-  def extractDouble (value: java.lang.Double): ValidationNEL[String, V]
-  def extractBoolean(value: java.lang.Boolean): ValidationNEL[String, V]
-  def extractDate   (value: java.util.Date): ValidationNEL[String, V]
-  def extractRegex  (value: java.util.regex.Pattern): ValidationNEL[String, V]
-  def extractBinary (value: Array[Byte]): ValidationNEL[String, V]
-  def extractId     (value: ObjectId): ValidationNEL[String, V]
-  def extractOther  (value: Any) = ("No extractor configured for value of type " + value.getClass.getName).failure.toValidationNEL
-  def buildNull: ValidationNEL[String, V]
+  def extractString (value: String): ValidationNel[String, V]
+  def extractInteger(value: java.lang.Integer): ValidationNel[String, V]
+  def extractLong   (value: java.lang.Long): ValidationNel[String, V]
+  def extractFloat  (value: java.lang.Float): ValidationNel[String, V]
+  def extractDouble (value: java.lang.Double): ValidationNel[String, V]
+  def extractBoolean(value: java.lang.Boolean): ValidationNel[String, V]
+  def extractDate   (value: java.util.Date): ValidationNel[String, V]
+  def extractRegex  (value: java.util.regex.Pattern): ValidationNel[String, V]
+  def extractBinary (value: Array[Byte]): ValidationNel[String, V]
+  def extractId     (value: ObjectId): ValidationNel[String, V]
+  def extractOther  (value: Any) = ("No extractor configured for value of type " + value.getClass.getName).failure.toValidationNel
+  def buildNull: ValidationNel[String, V]
 
   def buildArray  (values: Seq[V]): V
   def buildField  (name: String, value: V): F
   def buildObject (fields: Seq[F]): O
 
-  def apply(dbObject: DBObject): ValidationNEL[String, O] = {
-    val fields: Seq[ValidationNEL[String, F]] = {
+  def apply(dbObject: DBObject): ValidationNel[String, O] = {
+    val fields: Seq[ValidationNel[String, F]] = {
       dbObject.keySet.asScala.map(key => fromDBValue(dbObject.get(key)).map(buildField(key, _)))(collection.breakOut)
     }
 
-    fields.toList.sequence[({type N[B] = ValidationNEL[String, B]})#N, F].map(buildObject)
+    fields.toList.sequence[({type N[B] = ValidationNel[String, B]})#N, F].map(buildObject)
   }
 
-  private def fromDBValue(value: Any): ValidationNEL[String, V] = value match {
+  private def fromDBValue(value: Any): ValidationNel[String, V] = value match {
     case x: String                  => extractString(x)
     case x: java.lang.Long          => extractLong(x)
     case x: java.lang.Integer       => extractInteger(x)
@@ -48,7 +48,7 @@ trait MongoBijection[V, F, O <: V] extends PartialBijection[DBObject, O] {
     case x: java.util.Date          => extractDate(x)
     case x: Array[Byte]             => extractBinary(x)
     case x: ObjectId    => extractId(x)
-    case x: java.util.ArrayList[_]  => x.asScala.map(fromDBValue).toList.sequence[({type N[B] = ValidationNEL[String, B]})#N, V].map(buildArray)
+    case x: java.util.ArrayList[_]  => x.asScala.map(fromDBValue).toList.sequence[({type N[B] = ValidationNel[String, B]})#N, V].map(buildArray)
     case x: DBObject                => apply(x)
     case null                       => buildNull
     case other                      => extractOther(other)

diff --git a/mongo/src/main/scala/blueeyes/persistence/mongo/RealMongo.scala b/mongo/src/main/scala/blueeyes/persistence/mongo/RealMongo.scala
@@ -118,7 +118,7 @@ private[mongo] class RealDatabase(actorSystem: ActorSystem, val mongo: Mongo, va
 }
 
 private[mongo] class RealDatabaseCollection(val collection: DBCollection, database: RealDatabase) extends DatabaseCollection{
-  type V[B] = ValidationNEL[String, B]
+  type V[B] = ValidationNel[String, B]
 
   def requestDone() { collection.getDB.requestDone() }
 
@@ -235,7 +235,7 @@ private[mongo] class RealDatabaseCollection(val collection: DBCollection, databa
   private def toMongoKeys(keysPaths: Iterable[JPath]): JObject = JObject(keysPaths.map(key => JField(JPathExtension.toMongoField(key), JNum(1))).toList)
   private def toMongoFilter(filter: Option[MongoFilter])       = filter.map(_.filter.asInstanceOf[JObject]).getOrElse(JObject(Nil))
 
-  private implicit def unvalidated(v: ValidationNEL[String, JObject]): JObject = v valueOr {
+  private implicit def unvalidated(v: ValidationNel[String, JObject]): JObject = v valueOr {
     errors => sys.error("An error occurred deserializing the database object: " + errors.list.mkString("; "))
   }
 

diff --git a/mongo/src/main/scala/blueeyes/persistence/mongo/json/BijectionsMongoJson.scala b/mongo/src/main/scala/blueeyes/persistence/mongo/json/BijectionsMongoJson.scala
@@ -13,7 +13,7 @@ import org.joda.time.format.ISODateTimeFormat
 
 import scala.collection.JavaConverters._
 
-import scalaz.{Validation, Success, NonEmptyList, ValidationNEL}
+import scalaz.{Validation, Success, NonEmptyList, ValidationNel}
 import scalaz.Validation._
 import scalaz.NonEmptyList._
 import scalaz.syntax.validation._
@@ -30,16 +30,16 @@ object MongoJValueBijection extends MongoBijection[JValue, JField, JObject] {
   override def extractDouble (value: java.lang.Double)        = JNum(value.doubleValue).success
   override def extractBoolean(value: java.lang.Boolean)       = JBool(value).success
   override def extractDate   (value: java.util.Date)          = JString(ISO8601.print(new DateTime(value.getTime, DateTimeZone.UTC))).success
-  override def extractRegex  (value: java.util.regex.Pattern) = "Regex type is not supported".failure.toValidationNEL
-  override def extractBinary (value: Array[Byte])             = "Binary type is not supported".failure.toValidationNEL
+  override def extractRegex  (value: java.util.regex.Pattern) = "Regex type is not supported".failure.toValidationNel
+  override def extractBinary (value: Array[Byte])             = "Binary type is not supported".failure.toValidationNel
   override def extractId     (value: ObjectId)                = JString("ObjectId(\"" + Hex.encodeHexString(value.toByteArray) + "\")").success
   override def buildNull                                      = JNull.success
 
   override def buildArray(value: Seq[JValue])                 = JArray(value.toList)
   override def buildField(name: String, value: JValue)        = JField(name, value)
   override def buildObject(fields: Seq[JField])               = JObject(fields.toList)
 
-  def unapply(jobject: JObject): ValidationNEL[String, DBObject] = {
+  def unapply(jobject: JObject): ValidationNel[String, DBObject] = {
     jobject.fields.foldLeft(success[NonEmptyList[String], BasicDBObject](new BasicDBObject)) {
       case (success @ Success(obj), JField(name, JUndefined)) => success
       case (Success(obj), JField(name, value)) => toStorageValue(value).map(obj.append(name, _))
@@ -49,13 +49,13 @@ object MongoJValueBijection extends MongoBijection[JValue, JField, JObject] {
 
   private val ObjectIdPattern = """ObjectId\("([0-9a-f]*)"\)""".r
 
-  private def toStorageValue(v: JValue): ValidationNEL[String, Any] = (v: @unchecked) match {
+  private def toStorageValue(v: JValue): ValidationNel[String, Any] = (v: @unchecked) match {
     case JNull | JUndefined => success(null)
     case JString(ObjectIdPattern(id)) => new ObjectId(Hex.decodeHex(id.toCharArray)).success
     case JString(x) => x.success
     case JNum(x)    => x.doubleValue.success
     case JBool(x)   => x.success
-    case JArray(x)  => x.map(toStorageValue).sequence[({type N[B] = ValidationNEL[String, B]})#N, Any].map(_.asJava)
+    case JArray(x)  => x.map(toStorageValue).sequence[({type N[B] = ValidationNel[String, B]})#N, Any].map(_.asJava)
     case jobject @ JObject(_) => unapply(jobject)
   }
 }

diff --git a/project/Build.scala b/project/Build.scala
@@ -60,7 +60,7 @@ object BlueEyesBuild extends Build {
     }
   )
 
-  val scalazVersion = "7.0.0-M8"
+  val scalazVersion = "7.0.0-RC1"
 
   val commonSettings = Seq(
     scalaVersion := "2.9.2",

diff --git a/project/build.properties b/project/build.properties
@@ -1 +1 @@
-sbt.version=0.11.3
+sbt.version=0.12.2