made MongoPolyDataCompanion a 2.13 only feature

Author: Roman Janusz

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 <: D[T]]: 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[T].ref(_.x)
+  *   }
+  * }}}
+  */
+abstract class MongoPolyDataCompanion[D[_]](
+  implicit instances: MacroInstances[BsonGenCodecs.type, MongoPolyAdtInstances[D]]
+) extends AbstractMongoPolyDataCompanion[BsonGenCodecs.type, D](BsonGenCodecs)

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

@@ -4,7 +4,7 @@ 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 com.avsystem.commons.serialization.GenObjectCodec
 
 import scala.annotation.{compileTimeOnly, implicitNotFound}
 
@@ -13,14 +13,6 @@ trait MongoAdtInstances[T] {
   def format: MongoAdtFormat[T]
 }
 
-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]]
-}
-
 trait MongoEntityInstances[E <: BaseMongoEntity] extends MongoAdtInstances[E] {
   def meta: MongoEntityMeta[E]
 }
@@ -55,28 +47,6 @@ abstract class AbstractMongoDataCompanion[Implicits, E](implicits: Implicits)(
   implicit val format: MongoAdtFormat[E] = instances(implicits, this).format
 }
 
-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")
-  }
-
-  def apply[T: MongoFormat]: DataTypeDsl[D[T]] = new DataTypeDsl[D[T]] {
-    def SelfRef: MongoRef[D[T], D[T]] = MongoRef.RootRef(format[T])
-  }
-
-  // for Scala 2.12 which has some problems with overloaded apply
-  def refs[T: MongoFormat]: DataTypeDsl[D[T]] = apply[T]
-}
-
 abstract class AbstractMongoEntityCompanion[Implicits, E <: BaseMongoEntity](implicits: Implicits)(
   implicit instances: MacroInstances[Implicits, MongoEntityInstances[E]]
 ) extends BaseMongoCompanion[E] {
@@ -109,19 +79,3 @@ abstract class MongoDataCompanion[E](
 abstract class MongoEntityCompanion[E <: BaseMongoEntity](
   implicit instances: MacroInstances[BsonGenCodecs.type, MongoEntityInstances[E]]
 ) extends AbstractMongoEntityCompanion[BsonGenCodecs.type, E](BsonGenCodecs)
-
-/**
-  * 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[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-mongo/jvm/src/test/scala/com/avsystem/commons/mongo/typed/MongoRefTest.scala

@@ -7,8 +7,6 @@ class MongoRefTest extends AnyFunSuite {
   final val Rte = RecordTestEntity
   final val Ute = UnionTestEntity
   final val Ir = InnerRecord
-  final val Pmr = PolyMongoRecord
-  final val Pmu = PolyMongoUnion
 
   test("filterPath") {
     assert(Rte.IdRef.rawPath == "_id")
@@ -32,19 +30,11 @@ class MongoRefTest extends AnyFunSuite {
     assert(Rte.ref(_.union.as[CaseOne].data).rawPath == "union.data")
     assert(Rte.ref(_.union.as[HasInner].inner).rawPath == "union.inner")
     assert(Rte.ref(_.union).as[HasInner].ref(_.inner).rawPath == "union.inner")
-    assert(Pmr.refs[Int].ref(_.value).rawPath == "value")
     assert(Ute.ref(_.as[HasInner].inner).rawPath == "inner")
     assert(Ute.as[HasInner].ref(_.inner).rawPath == "inner")
     assert(Ute.ref(_.as[HasInner].inner.union.as[HasInner].inner).rawPath == "inner.union.inner")
     assert((Ute.ref(_.as[HasInner].inner) andThen Rte.ref(_.union.as[HasInner].inner)).rawPath == "inner.union.inner")
     assert((Rte.ref(_.union.as[HasInner].inner) compose Ute.ref(_.as[HasInner].inner)).rawPath == "inner.union.inner")
-    assert(Pmu[Int].ref(_.as[PolyMongoUnion.CaseOne[Int]].value).rawPath == "value")
-    assert(Pmu[Int].as[PolyMongoUnion.CaseOne[Int]].ref(_.value).rawPath == "value")
-    assert(Pmu[Int].ref(_.as[PolyMongoUnion.CaseOne[Int]].str).rawPath == "str")
-    assert(Pmu[PolyMongoUnion[Int]].ref(x =>
-      x.as[PolyMongoUnion.CaseOne[PolyMongoUnion[Int]]].value
-        .as[PolyMongoUnion.CaseOne[Int]].str
-    ).rawPath == "value.str")
   }
 
   test("projectionPath") {

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

@@ -70,16 +70,6 @@ case class CaseTwo(id: String, str: String, data: Int, inner: RecordTestEntity)
 case class CaseThree(id: String, str: String, data: String, inner: RecordTestEntity) extends HasInner
 object UnionTestEntity extends MongoEntityCompanion[UnionTestEntity]
 
-@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]
-
 case class TestAutoId(id: ObjectId) extends AnyVal
 object TestAutoId extends ObjectIdWrapperCompanion[TestAutoId]
 

project/build.properties

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