Writers weakteam#14

Author: Ssstlis

core/src/main/scala/io/github/weakteam/mongo/bson/BsonWriter.scala

@@ -1,14 +1,71 @@
 package io.github.weakteam.mongo.bson
 
+import java.util.regex.Pattern
+
 import cats.Contravariant
+import io.github.weakteam.mongo.bson.BsonSubtype.UserDefinedSubtype
+import io.github.weakteam.mongo.bson.BsonValue.{
+  BsonArray,
+  BsonBinary,
+  BsonBoolean,
+  BsonDocument,
+  BsonFloat,
+  BsonInt,
+  BsonLong,
+  BsonNull,
+  BsonRegex,
+  BsonString
+}
 import simulacrum.typeclass
 
+import scala.util.matching.Regex
+
 @typeclass
 trait BsonWriter[-T] { self =>
   def writeBson(arg: T): BsonValue
 }
 
-object BsonWriter {
+trait Instances {
+  implicit val identityWriter: BsonWriter[BsonValue] = identity(_)
+  implicit val intWriter: BsonWriter[Int]            = BsonInt(_)
+  implicit val stringWriter: BsonWriter[String]      = BsonString(_)
+  implicit val longWriter: BsonWriter[Long]          = BsonLong(_)
+  implicit val doubleWriter: BsonWriter[Double]      = BsonFloat(_)
+  implicit val floatWriter: BsonWriter[Float]        = float => BsonFloat(float.toDouble)
+  implicit val booleanWriter: BsonWriter[Boolean]    = BsonBoolean(_)
+  implicit val regexWriter: BsonWriter[Regex]        = reg => BsonRegex(reg.regex)
+  implicit val patternWriter: BsonWriter[Pattern]    = reg => BsonRegex(reg.pattern())
+}
+
+trait LowPriorityInstances {
+
+  implicit def optionWriter[A](implicit W: BsonWriter[A]): BsonWriter[Option[A]] = {
+    case Some(value) => W.writeBson(value)
+    case _           => BsonNull
+  }
+
+  implicit def eitherWriter[L, R](implicit LW: BsonWriter[L], RW: BsonWriter[R]): BsonWriter[Either[L, R]] = {
+    _.fold(LW.writeBson, RW.writeBson)
+  }
+
+  implicit def listWriter[A](implicit W: BsonWriter[A]): BsonWriter[List[A]] = { list =>
+    BsonArray(list.map(W.writeBson))
+  }
+
+  implicit def setWriter[A](implicit W: BsonWriter[A]): BsonWriter[Set[A]] = { set =>
+    BsonArray(set.map(W.writeBson).toList)
+  }
+
+  implicit def mapWriter[K, V](implicit K: BsonKeyWriter[K], W: BsonWriter[V]): BsonWriter[Map[K, V]] = { map =>
+    BsonDocument(map.map { case (k, v) => (K.writeKey(k), W.writeBson(v)) })
+  }
+
+  implicit def enum[T <: Enumeration](e: T): BsonWriter[e.Value] = { e =>
+    BsonBinary(UserDefinedSubtype(0x05), e.id.toString.getBytes("UTF-8"))
+  }
+}
+
+object BsonWriter extends Instances with LowPriorityInstances {
   def instance[A](f: A => BsonValue): BsonWriter[A] = f(_)
 
   implicit val bsonWriterContravariantInstance: Contravariant[BsonWriter] = new Contravariant[BsonWriter] {

core/src/main/scala_2.13-/CollectionFactory.scala

@@ -0,0 +1,13 @@
+import scala.collection.generic.CanBuildFrom
+import scala.collection.mutable.Builder
+
+/**
+ * Shim for compatibility between scala 2.11/2.12 and 2.13
+ */
+class CollectionFactory[-A, +C](private val cbf: CanBuildFrom[_, A, C]) extends AnyVal {
+  def newBuilder: Builder[A, C] = cbf()
+}
+
+object CollectionFactory {
+  implicit def factory[A, C](implicit cbf: CanBuildFrom[_, A, C]) = new CollectionFactory(cbf)
+}

core/src/main/scala_2.13/CollectionFactory.scala

@@ -0,0 +1,13 @@
+import scala.collection.Factory
+import scala.collection.mutable.Builder
+
+/**
+ * Shim for compatibility between scala 2.11/2.12 and 2.13
+ */
+class CollectionFactory[-A, +C](private val f: Factory[A,C]) extends AnyVal {
+  def newBuilder: Builder[A, C] = f.newBuilder
+}
+
+object CollectionFactory {
+  implicit def factory[A, C](implicit f: Factory[A, C]): CollectionFactory[A, C] = new CollectionFactory(f)
+}

core/src/test/scala/io/github/weakteam/mongo/bson/BsonWriterSpec.scala

@@ -1,22 +1,23 @@
 package io.github.weakteam.mongo.bson
 
-import io.github.weakteam.mongo.bson.BsonValue.BsonInt
+import java.util.regex.Pattern
+
+import io.github.weakteam.mongo.bson.BsonValue._
 import org.scalatest.matchers.must.Matchers
 import org.scalatest.wordspec.AnyWordSpec
 import io.github.weakteam.mongo.implicits._
 import cats.syntax.contravariant._
 
+import scala.util.matching.Regex
+
 class BsonWriterSpec extends AnyWordSpec with Matchers {
   "BsonWriter" should {
     "return right value" in {
-      implicit val intBsonWriter: BsonWriter[Int] = BsonInt(_)
-
-      1.writeBson mustBe BsonInt(1)
+      BsonWriter.instance(BsonInt).writeBson(1) mustBe BsonInt(1)
     }
 
     "return right value with contramap" in {
-      implicit val intBsonWriter: BsonWriter[Int] = BsonInt(_)
-      implicit val anyBsonWriter: BsonWriter[Any] = intBsonWriter.contramap {
+      implicit val anyBsonWriter: BsonWriter[Any] = BsonWriter.intWriter.contramap {
         case i: Int => i
         case _      => 0
       }
@@ -27,9 +28,85 @@ class BsonWriterSpec extends AnyWordSpec with Matchers {
     }
 
     "return right value with manual instance creation" in {
-      implicit val intBsonWriter: BsonWriter[Int] = BsonWriter.instance(BsonInt)
+      val intBsonWriter: BsonWriter[Int] = BsonWriter.instance(BsonInt)
 
-      1.writeBson mustBe BsonInt(1)
+      intBsonWriter.writeBson(1) mustBe BsonInt(1)
     }
   }
+
+  "BsonWriter#instances" should {
+    "write identity" in {
+      BsonWriter[BsonValue].writeBson(BsonString("bson")) mustBe BsonString("bson")
+    }
+
+    "write int" in {
+      BsonWriter[Int].writeBson(42) mustBe BsonInt(42)
+    }
+
+    "write long" in {
+      BsonWriter[Long].writeBson(42L) mustBe BsonLong(42L)
+    }
+
+    "write boolean" in {
+      BsonWriter[Boolean].writeBson(true) mustBe BsonBoolean(true)
+    }
+
+    "write double" in {
+      BsonWriter[Double].writeBson(42.52d) mustBe BsonFloat(42.52d)
+    }
+
+    "write float" in {
+      BsonWriter[Float].writeBson(42.52f) mustBe BsonFloat(42.52f)
+    }
+
+    "write regex" in {
+      BsonWriter[Regex].writeBson("foo".r) mustBe BsonRegex("foo")
+    }
+
+    "write pattern" in {
+      BsonWriter[Pattern].writeBson("foo".r.pattern) mustBe BsonRegex("foo")
+    }
+  }
+
+  "BsonWriter#wrapped-instances" should {
+    implicit def implConv[A: BsonWriter](value: A): BsonValue = value.writeBson
+
+    "write option" in {
+      BsonWriter[Option[Int]].writeBson(Some(4)) mustBe BsonInt(4)
+      BsonWriter[Option[Int]].writeBson(None) mustBe BsonNull
+    }
+
+    "write either" in {
+      BsonWriter[Either[Boolean, String]].writeBson(Right("foo")) mustBe BsonString("foo")
+      BsonWriter[Either[Boolean, String]].writeBson(Left(true)) mustBe BsonBoolean(true)
+    }
+
+    "write list" in {
+      BsonWriter[List[Int]].writeBson(List(1, 4, 5)) mustBe BsonArray(1, 4, 5)
+    }
+
+    "write set" in {
+      BsonWriter[Set[String]].writeBson(Set("foo", "foo", "bar")) mustBe BsonArray("foo", "bar")
+    }
+
+    "write map" in {
+      implicit val stringBsonKeyWriter: BsonKeyWriter[String] = identity(_)
+
+      BsonWriter[Map[String, Int]]
+        .writeBson(Map("foo" -> 3, "foo" -> 4, "bar" -> 5)) mustBe BsonDocument("foo" := 4, "bar" := 5)
+    }
+
+//    "write Enum" in {
+//      def wr: BsonWriter[TestEnum.Value] = TestEnum
+//      wr.writeBson(TestEnum.A) mustBe BsonBinary(UserDefinedSubtype(0x05), 1.toString.getBytes("UTF-8"))
+//
+//      wr.writeBson(TestEnum.B) mustBe BsonBinary(UserDefinedSubtype(0x05), 2.toString.getBytes("UTF-8"))
+//    }
+  }
 }
+
+//object BsonWriterSpec {
+//  object TestEnum extends Enumeration {
+//    val A, B = Value
+//  }
+//}