Cross-compile generic module to Scala 3

.github/workflows/ci.yml

@@ -39,4 +39,4 @@ jobs:
         with:
           type: ${{ job.status }}
           job_name: Build
-          url: ${{ secrets.SLACK_WEBHOOK }}
+          url: ${{ secrets.SLACK_WEBHOOK }}

.gitignore

@@ -11,7 +11,17 @@ lib_managed/
 src_managed/
 project/boot/
 project/plugins/project/
-.bsp/
+
+# Bloop
+.bsp
+
+# VS Code
+.vscode/
+
+# Metals
+.bloop/
+.metals/
+metals.sbt
 
 # Scala-IDE specific
 .scala_dependencies
@@ -30,4 +40,8 @@ ignore
 scripts/tmp
 ignored/
 
-.java-version
+.java-version
+
+.bloop/
+.metals/
+.vscode

build.sbt

@@ -72,13 +72,15 @@ lazy val `play-json-generic` = crossProject(JVMPlatform, JSPlatform)
   .crossType(CrossType.Pure)
   .settings(
     commonSettings,
-    crossScalaVersions -= Scala3,
-    scalacOptsFailOnWarn := Some(false),
-    libraryDependencies ++= Seq(
-      shapeless,
+    libraryDependencies ++= (Seq(
       playJson,
       scalaTest % Test
-    ).map(excludeLog4j),
+    ) ++ (CrossVersion.partialVersion(scalaVersion.value) match {
+      case Some((2, v)) if v >= 12 =>
+        Seq(shapeless)
+      case _ =>
+        Seq()
+    })).map(excludeLog4j)
   )
 
 lazy val `play-json-tools` = project

play-json-circe/src/main/scala/com/evolution/playjson/circe/PlayCirceAstConversions.scala

@@ -3,6 +3,7 @@ package com.evolution.playjson.circe
 import cats.Eval
 import io.circe.{Json => CirceJson}
 import play.api.libs.{json => PlayJson}
+import io.circe.JsonObject
 
 object PlayCirceAstConversions {
   private type Field[T] = (String, T)
@@ -22,7 +23,7 @@ object PlayCirceAstConversions {
               as.foldLeft(evalZero[PlayJson.JsValue])((acc, c) => inner(Eval.now(c)).flatMap(p => acc.map(_ :+ p)))
             }
             .map(PlayJson.JsArray),
-        jsonObject = obj =>
+        jsonObject = (obj: JsonObject) =>
           Eval
             .defer {
               obj.toIterable.foldLeft(evalZero[Field[PlayJson.JsValue]]) { case (acc, (k, c)) =>

play-json-generic/src/main/scala/com/evolution/playjson/generic/EnumMappings.scala → play-json-generic/src/main/scala-2/com/evolution/playjson/generic/EnumMappings.scala

@@ -2,11 +2,13 @@ package com.evolution.playjson.generic
 
 import shapeless.{:+:, CNil, Coproduct, LabelledGeneric, Witness}
 import shapeless.labelled.FieldType
+import scala.annotation.nowarn
 
 case class EnumMappings[A](labels: Map[A, String])
 
 object EnumMappings {
 
+  @nowarn("cat=unused")
   implicit def enumMappings[A, Repr <: Coproduct](implicit
     gen: LabelledGeneric.Aux[A, Repr], // this is USED to generate `Enumeration`, not sure how, though
     e: MappingsAux[A, Repr]

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/EnumMappings.scala

@@ -0,0 +1,15 @@
+package com.evolution.playjson.generic
+
+import scala.deriving.Mirror
+import scala.compiletime.summonAll
+
+case class EnumMappings[A](labels: Map[A, String])
+
+object EnumMappings:
+  inline given valueMap[E](using m: Mirror.SumOf[E]): EnumMappings[E] =
+    // First, we make a compile-time check that all of subtypes of E are singletons
+    // (i.e. case objects) by requiring that there's an instance of ValueOf for each subtype.
+    val singletons = summonAll[Tuple.Map[m.MirroredElemTypes, ValueOf]]
+    // Then, we can safely obtain a list of ValueOf instances and map each subtype to its string representation.
+    val elems = singletons.toList.asInstanceOf[List[ValueOf[E]]]
+    EnumMappings(elems.view.map(_.value).map(e => e -> e.toString).toMap)

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/Enumeration.scala

@@ -0,0 +1,25 @@
+package com.evolution.playjson.generic
+
+import play.api.libs.json._
+
+class Enumeration[A] private(enumMappings: EnumMappings[A]):
+
+  def format(using nameCodingStrategy: NameCodingStrategy): Format[A] = new Format[A]:
+
+    val labelsLookup: Map[A, String] = enumMappings.labels.map { case (k, v) => (k, nameCodingStrategy(v)) }
+    val valuesLookup: Map[String, A] = labelsLookup.map(_.swap)
+
+    def writes(o: A): JsValue = JsString(labelsLookup(o))
+
+    def reads(json: JsValue): JsResult[A] = {
+      for {
+        s <- json.validate[JsString]
+        v <- valuesLookup.get(s.value) match {
+          case Some(v) => JsSuccess(v)
+          case None    => JsError(s"Cannot parse ${ s.value }")
+        }
+      } yield v
+    }
+
+object Enumeration:
+  def apply[A](using enumMappings: EnumMappings[A]) = new Enumeration[A](enumMappings)

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/FlatTypeFormat.scala

@@ -0,0 +1,16 @@
+package com.evolution.playjson.generic
+
+import play.api.libs.json._
+
+/**
+  * This is a helper class for creating a `Format` instance for a sealed trait hierarchy.
+  * 
+  * When reading from JSON, it will look for a `type` field in the JSON object and use its value to determine which 
+  * subtype to use. The `type` field will be removed from the JSON object before the subtype's `Reads` is called.
+  * 
+  * When writing to JSON, it will add a `type` field to the JSON object with the value of the subtype's simple name
+  * (without package prefix).
+  */
+object FlatTypeFormat:
+  def apply[A](using reads: FlatTypeReads[A], writes: FlatTypeWrites[A]): OFormat[A] =
+    OFormat(reads.reads(_), writes.writes(_))

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/FlatTypeReads.scala

@@ -0,0 +1,99 @@
+package com.evolution.playjson.generic
+
+import scala.deriving.Mirror
+import scala.compiletime.*
+import play.api.libs.json.*
+import scala.annotation.nowarn
+
+/**
+  * This is a helper class for creating a `Reads` instance for a sealed trait hierarchy.
+  * It will look for a `type` field in the JSON object and use its value to determine which subtype to use.
+  * The `type` field will be removed from the JSON object before the subtype's `Reads` is called.
+  * 
+  * The difference between this class and `NestedTypeReads` is that this class uses the simple name of the subtype
+  * instead of the full prefixed name. This means that you cannot use the same simple name for multiple subtypes.
+  * 
+  * Example:
+  * 
+  * {{{
+  * 
+  * sealed trait Parent
+  * case class Child1(field1: String) extends Parent
+  * case class Child2(field2: Int) extends Parent
+  *  
+  * object Child1:
+  *   given Reads[Child1] = Json.reads[Child1]
+  * object Child2:
+  *   given Reads[Child2] = Json.reads[Child2]
+  * 
+  * val reads: FlatTypeReads[Parent] = summon[FlatTypeReads[Parent]]
+  * 
+  * val json: JsValue = Json.parse("""{"type": "Child1", "field1": "value"}""")
+  * val result: JsResult[Parent]  = reads.reads(json) // JsSuccess(Child1(value),)
+  * }}}
+  */
+trait FlatTypeReads[T] extends Reads[T]:
+  override def reads(jsValue: JsValue): JsResult[T]
+
+object FlatTypeReads:
+  def create[A](f: JsValue => JsResult[A]): FlatTypeReads[A] =
+    (json: JsValue) => f(json)
+
+  def apply[A](using ev: FlatTypeReads[A]): FlatTypeReads[A] = ev
+
+  /**
+    * This is the first method that will be called when the compiler is looking for an instance of `FlatTypeReads`.
+    * It will look for a `type` field in the JSON object and use its value to determine which subtype of `A` to use.
+    * Then, it will look for an instance of `Reads` for that subtype and use it to read the JSON object.
+    */
+  inline given deriveFlatTypeReads[A](using
+      m: Mirror.SumOf[A],
+      nameCodingStrategy: NameCodingStrategy
+  ): FlatTypeReads[A] =
+    create[A] { json =>
+      for {
+        obj <- json.validate[JsObject]
+        typ <- (obj \ "type").validate[String]
+        result <- deriveReads[A](typ) match
+          case Some(reads) => reads.reads(obj - "type")
+          case None        => JsError("Failed to find decoder")
+      } yield result
+    }
+
+  /**
+    * Recursively search the given tuple of types for one that matches the given type name and has a `Reads` instance.
+    *
+    * @param typ the type name to search for
+    * @param nameCodingStrategy the naming strategy to use when comparing the type name to the names of the types in 
+    *        the tuple
+    */
+  private inline def deriveReadsForSum[A, T <: Tuple](
+      typ: String
+  )(using nameCodingStrategy: NameCodingStrategy): Option[Reads[A]] =
+    inline erasedValue[T] match
+      case _: EmptyTuple => None
+      case _: (h *: t) =>
+        deriveReads[h](typ) match
+          case None        => deriveReadsForSum[A, t](typ)
+          case Some(value) => Some(value.asInstanceOf[Reads[A]])
+
+  private inline def deriveReads[A](typ: String)(using nameCodingStrategy: NameCodingStrategy): Option[Reads[A]] =
+    summonFrom {
+      case m: Mirror.ProductOf[A] =>
+        // product (case class or case object)
+        val name = constValue[m.MirroredLabel]
+        if typ == nameCodingStrategy(name)
+        then Some(summonInline[Reads[A]])
+        else None
+      case m: Mirror.SumOf[A] =>
+        // sum (trait)
+        deriveReadsForSum[A, m.MirroredElemTypes](typ)
+      case v: ValueOf[A] =>
+        // Singleton type (object without `case` modifier)
+        val name = singletonName[A]
+        if typ == nameCodingStrategy(name)
+        then Some(summonInline[Reads[A]])
+        else None
+    }
+  end deriveReads
+end FlatTypeReads

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/FlatTypeWrites.scala

@@ -0,0 +1,79 @@
+package com.evolution.playjson.generic
+
+import play.api.libs.json.*
+
+import scala.deriving.Mirror
+import scala.compiletime.*
+
+/**
+  * This is a helper class for creating a `Writes` instance for a sealed trait hierarchy.
+  * It will add a `type` field to the JSON object with the value of the subtype's simple name (without package prefix).
+  * 
+  * Example:
+  * 
+  * {{{
+  * sealed trait Parent
+  * case class Child1(field1: String) extends Parent
+  * case class Child2(field2: Int) extends Parent
+  * 
+  * object Child1:
+  *   given OWrites[Child1] = Json.writes[Child1]
+  * object Child2:
+  *   given OWrites[Child2] = Json.writes[Child2]
+  * 
+  * val writes: FlatTypeWrites[Parent] = summon[FlatTypeWrites[Parent]]
+  * 
+  * val json: JsValue = writes.writes(Child1("value")) // {"type": "Child1", "field1": "value"}
+  * }}}
+  */
+trait FlatTypeWrites[A] extends Writes[A]:
+  override def writes(o: A): JsObject
+
+object FlatTypeWrites:
+  def apply[A](using ev: FlatTypeWrites[A]): FlatTypeWrites[A] = ev
+
+  def create[A](f: A => JsObject): FlatTypeWrites[A] = (o: A) => f(o)
+
+  inline given deriveFlatTypeWrites[A](using
+      m: Mirror.SumOf[A],
+      nameCodingStrategy: NameCodingStrategy
+  ): FlatTypeWrites[A] =
+    // Generate writes instances for all subtypes of A and pick 
+    // the one that matches the type of the passed value.
+    val writes = summonWrites[m.MirroredElemTypes]
+    create { value =>
+      writes(m.ordinal(value)).asInstanceOf[FlatTypeWrites[A]].writes(value)
+    }
+
+  /**
+    * Recursively summon `FlatTypeWrites` instances for all types in the given tuple.
+    */
+  private inline def summonWrites[T <: Tuple](using
+      nameCodingStrategy: NameCodingStrategy
+  ): List[FlatTypeWrites[?]] =
+    inline erasedValue[T] match
+      case _: EmptyTuple => Nil
+      case _: (head *: tail) =>
+        summonWrite[head].asInstanceOf[FlatTypeWrites[?]] :: summonWrites[tail]
+
+  private inline def summonWrite[A](using
+      nameCodingStrategy: NameCodingStrategy
+  ): FlatTypeWrites[A] =
+    summonFrom {
+      case m: Mirror.ProductOf[A] =>
+        val name = constValue[m.MirroredLabel]
+        val writes = summonEnrichedWrites[A](nameCodingStrategy(name))
+        create(value => writes.writes(value))
+      case m: Mirror.SumOf[A] =>
+        val allWrites = summonWrites[m.MirroredElemTypes]
+        create { value =>
+          val idx = m.ordinal(value)
+          allWrites(idx).asInstanceOf[FlatTypeWrites[A]].writes(value)
+        }
+      case valueOf: ValueOf[A] =>
+        // Singleton type (object without `case` modifier)
+        val name = singletonName[A]
+        val writes = summonEnrichedWrites[A](nameCodingStrategy(name))
+        create(value => writes.writes(value))
+    }
+end FlatTypeWrites

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/NameCodingStrategy.scala

@@ -0,0 +1,28 @@
+package com.evolution.playjson.generic
+
+trait NameCodingStrategy extends ((String) => String)
+
+trait LowPriority:
+  given default: NameCodingStrategy = new NameCodingStrategy() {
+    override def apply(s: String): String = s
+  }
+
+object NameCodingStrategy extends LowPriority
+
+object NameCodingStrategies:
+
+  private def lowerCaseSepCoding(sep: String): NameCodingStrategy = new NameCodingStrategy() {
+    override def apply(s: String): String = s.split("(?<!^)(?=[A-Z])").map(_.toLowerCase).mkString(sep)
+  }
+
+  given kebabCase: NameCodingStrategy = lowerCaseSepCoding("-")
+
+  given snakeCase: NameCodingStrategy = lowerCaseSepCoding("_")
+
+  given noSepCase: NameCodingStrategy = new NameCodingStrategy() {
+    override def apply(s: String): String = s.toLowerCase
+  }
+
+  given upperCase: NameCodingStrategy = new NameCodingStrategy() {
+    override def apply(s: String): String = s.toUpperCase
+  }

play-json-generic/src/main/scala-3/com/evolution/playjson/generic/NestedTypeFormat.scala

@@ -0,0 +1,7 @@
+package com.evolution.playjson.generic
+
+import play.api.libs.json.OFormat
+
+object NestedTypeFormat:
+  def apply[A](using reads: NestedTypeReads[A], writes: NestedTypeWrites[A]): OFormat[A] =
+    OFormat(reads.reads(_), writes.writes(_))