Merge pull request #407 from AVSystem/mongo-poly-data

`MongoPolyDataCompanion`

Author: ghik

commons-macros/src/main/scala/com/avsystem/commons/macros/serialization/MongoMacros.scala

@@ -14,6 +14,7 @@ class MongoMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) {
   lazy val MapApplySym: Symbol = typeOf[scala.collection.Map[Any, Any]].member(TermName("apply"))
   lazy val TypedMapApplySym: Symbol = getType(tq"$MiscPkg.TypedMap[$ScalaPkg.Any]").member(TermName("apply"))
   lazy val AdtAsSym: Symbol = getType(tq"$MongoTypedPkg.AbstractMongoDataCompanion[Any, Any]#macroDslExtensions").member(TermName("as"))
+  lazy val PolyAdtAsSym: Symbol = getType(tq"$MongoTypedPkg.AbstractMongoPolyDataCompanion[Any, Any]#macroDslExtensions").member(TermName("as"))
 
   // check if some symbol is an abstract method of a sealed trait/class implemented in every case class
   // by a field with exactly the same type
@@ -52,7 +53,8 @@ class MongoMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) {
         case body: Ident if body.symbol == param.symbol =>
           c.prefix.tree
 
-        case TypeApply(Select(Apply(_, List(prefix)), TermName("as")), List(subtpe)) if body.symbol == AdtAsSym =>
+        case TypeApply(Select(Apply(_, List(prefix)), TermName("as")), List(subtpe))
+          if body.symbol == AdtAsSym || body.symbol == PolyAdtAsSym =>
           q"${extractRefStep(prefix)}.as[$subtpe]"
 
         case Select(prefix, name: TermName) =>

commons-mongo/jvm/src/main/scala-2.12/com/avsystem/commons/mongo/typed/MongoPolyDataCompanion.scala

@@ -0,0 +1,10 @@
+package com.avsystem.commons
+package mongo.typed
+
+// MongoPolyDataCompanion is a 2.13 only feature
+// This serves only to avoid writing macro code cross-compiled for Scala 2.12
+private trait AbstractMongoPolyDataCompanion {
+  trait macroDslExtensions {
+    def as[C]: C = sys.error("stub")
+  }
+}

commons-mongo/jvm/src/main/scala-2.13/com/avsystem/commons/mongo/typed/MongoPolyDataCompanion.scala

@@ -0,0 +1,53 @@
+package com.avsystem.commons
+package mongo.typed
+
+import com.avsystem.commons.annotation.explicitGenerics
+import com.avsystem.commons.meta.MacroInstances
+import com.avsystem.commons.mongo.BsonGenCodecs
+import com.avsystem.commons.serialization.{GenCodec, GenObjectCodec}
+
+import scala.annotation.compileTimeOnly
+
+trait MongoPolyAdtInstances[D[_]] {
+  // needed by MongoAdtFormat.materialize for generic type
+  protected final implicit def codecFromFormat[T: MongoFormat]: GenCodec[T] = MongoFormat[T].codec
+
+  def codec[T: GenCodec]: GenObjectCodec[D[T]]
+  def format[T: MongoFormat]: MongoAdtFormat[D[T]]
+}
+
+abstract class AbstractMongoPolyDataCompanion[Implicits, D[_]](implicits: Implicits)(
+  implicit instances: MacroInstances[Implicits, MongoPolyAdtInstances[D]]
+) {
+  implicit def codec[T: GenCodec]: GenObjectCodec[D[T]] = instances(implicits, this).codec[T]
+  implicit def format[T: MongoFormat]: MongoAdtFormat[D[T]] = instances(implicits, this).format[T]
+
+  implicit def isMongoAdtOrSubtype[C <: D[_]]: IsMongoAdtOrSubtype[C] = null
+
+  implicit class macroDslExtensions[T](value: D[T]) {
+    @explicitGenerics
+    @compileTimeOnly("the .as[Subtype] construct can only be used inside lambda passed to .ref(...) macro")
+    def as[C <: D[T]]: C = sys.error("stub")
+  }
+
+  @explicitGenerics
+  def dsl[T: MongoFormat]: DataTypeDsl[D[T]] = new DataTypeDsl[D[T]] {
+    def SelfRef: MongoRef[D[T], D[T]] = MongoRef.RootRef(format[T])
+  }
+}
+
+/**
+  * Like [[MongoDataCompanion]] buf for generic types (with exactly one unbounded type parameter).
+  *
+  * @example
+  * {{{
+  *   case class Point[+T](x: T, y: T)
+  *   object Point extends MongoPolyDataCompanion[Point] {
+  *     def XRef[T: MongoFormat]: MongoPropertyRef[Point[T], T] =
+  *       Point.dsl[T].ref(_.x)
+  *   }
+  * }}}
+  */
+abstract class MongoPolyDataCompanion[D[_]](
+  implicit instances: MacroInstances[BsonGenCodecs.type, MongoPolyAdtInstances[D]]
+) extends AbstractMongoPolyDataCompanion[BsonGenCodecs.type, D](BsonGenCodecs)

commons-mongo/jvm/src/test/scala-2.13/com/avsystem/commons/mongo/typed/MongoPolyDataTest.scala

@@ -0,0 +1,31 @@
+package com.avsystem.commons
+package mongo.typed
+
+import com.avsystem.commons.serialization.flatten
+import org.scalatest.funsuite.AnyFunSuite
+
+@flatten sealed trait PolyMongoUnion[+T]
+object PolyMongoUnion extends MongoPolyDataCompanion[PolyMongoUnion] {
+  case class CaseOne[+T](value: T, str: String) extends PolyMongoUnion[T]
+  case class CaseTwo[+T](foo: T, int: Int) extends PolyMongoUnion[T]
+  case object CaseThree extends PolyMongoUnion[Nothing]
+}
+
+case class PolyMongoRecord[+T](value: T, meta: String)
+object PolyMongoRecord extends MongoPolyDataCompanion[PolyMongoRecord]
+
+class MongoPolyDataTest extends AnyFunSuite {
+  final val Pmr = PolyMongoRecord
+  final val Pmu = PolyMongoUnion
+
+  test("filterPath") {
+    assert(Pmr.dsl[Int].ref(_.value).rawPath == "value")
+    assert(Pmu.dsl[Int].ref(_.as[PolyMongoUnion.CaseOne[Int]].value).rawPath == "value")
+    assert(Pmu.dsl[Int].as[PolyMongoUnion.CaseOne[Int]].ref(_.value).rawPath == "value")
+    assert(Pmu.dsl[Int].ref(_.as[PolyMongoUnion.CaseOne[Int]].str).rawPath == "str")
+    assert(Pmu.dsl[PolyMongoUnion[Int]].ref(x =>
+      x.as[PolyMongoUnion.CaseOne[PolyMongoUnion[Int]]].value
+        .as[PolyMongoUnion.CaseOne[Int]].str
+    ).rawPath == "value.str")
+  }
+}

commons-redis/src/main/scala/com/avsystem/commons/redis/commands/ReplyDecoders.scala

@@ -309,8 +309,8 @@ object ReplyDecoders {
   val multiBulkAsXGroupInfo: ReplyDecoder[XGroupInfo] =
     flatMultiBulkAsMap(bulkAsUTF8, undecoded).andThen(XGroupInfo)
 
-  def multiBulkAsXStreamInfoOf[Record: RedisRecordCodec]: ReplyDecoder[XStreamInfo[Record]] =
-    flatMultiBulkAsMap(bulkAsUTF8, undecoded).andThen(XStreamInfo[Record](_))
+  def multiBulkAsXStreamInfoOf[Rec: RedisRecordCodec]: ReplyDecoder[XStreamInfo[Rec]] =
+    flatMultiBulkAsMap(bulkAsUTF8, undecoded).andThen(XStreamInfo[Rec](_))
 
   def multiBulkAsGroupedSeq[T](size: Int, elementDecoder: ReplyDecoder[T]): ReplyDecoder[Seq[Seq[T]]] = {
     case ArrayMsg(elements) =>

commons-redis/src/main/scala/com/avsystem/commons/redis/commands/streams.scala

@@ -447,12 +447,12 @@ case class XConsumerInfo(raw: BMap[String, ValidRedisMsg]) {
   def idle: Long = integerAsLong(raw("idle"))
 }
 
-case class XStreamInfo[Record: RedisRecordCodec](raw: BMap[String, ValidRedisMsg]) {
+case class XStreamInfo[Rec: RedisRecordCodec](raw: BMap[String, ValidRedisMsg]) {
   def length: Long = integerAsLong(raw("length"))
   def radixTreeKeys: Int = integerAsInt(raw("radis-tree-keys"))
   def radixTreeNodes: Int = integerAsInt(raw("radis-tree-nodes"))
   def groups: Int = integerAsInt(raw("groups"))
   def lastGeneratedId: XEntryId = bulkAsXEntryId(raw("last-generated-id"))
-  def firstEntry: XEntry[Record] = multiBulkAsXEntryOf[Record].apply(raw("first-entry"))
-  def lastEntry: XEntry[Record] = multiBulkAsXEntryOf[Record].apply(raw("last-entry"))
+  def firstEntry: XEntry[Rec] = multiBulkAsXEntryOf[Rec].apply(raw("first-entry"))
+  def lastEntry: XEntry[Rec] = multiBulkAsXEntryOf[Rec].apply(raw("last-entry"))
 }

project/build.properties

@@ -1,2 +1,2 @@
 # suppress inspection "UnusedProperty"
-sbt.version=1.5.5
+sbt.version=1.5.7