Scala3 enum support (#660)

* add scala3 enum support

* imports

* some tests

* adt tests

Author: pjfanning

src/main/scala-2.+/com/fasterxml/jackson/module/scala/DefaultScalaModule.scala

@@ -0,0 +1,37 @@
+package com.fasterxml.jackson.module.scala
+
+import com.fasterxml.jackson.module.scala.deser.{ScalaNumberDeserializersModule, ScalaObjectDeserializerModule, UntypedObjectDeserializerModule}
+import com.fasterxml.jackson.module.scala.introspect.ScalaAnnotationIntrospectorModule
+
+/**
+ * Complete module with support for all features, with the exception of [[BitSetDeserializerModule]].
+ *
+ * This class aggregates all of the feature modules into a single concrete class.
+ * Its use is recommended for new users and users who want things to "just work".
+ * If more customized support is desired, consult each of the constituent traits.
+ *
+ * @see [[com.fasterxml.jackson.module.scala.JacksonModule]]
+ *
+ * @since 1.9.0
+ */
+class DefaultScalaModule
+  extends JacksonModule
+     with IteratorModule
+     with EnumerationModule
+     with OptionModule
+     with SeqModule
+     with IterableModule
+     with TupleModule
+     with MapModule
+     with SetModule
+     with ScalaNumberDeserializersModule
+     with ScalaObjectDeserializerModule
+     with ScalaAnnotationIntrospectorModule
+     with UntypedObjectDeserializerModule
+     with EitherModule
+     with SymbolModule
+{
+  override def getModuleName: String = "DefaultScalaModule"
+}
+
+object DefaultScalaModule extends DefaultScalaModule

src/main/scala/com/fasterxml/jackson/module/scala/DefaultScalaModule.scala renamed to src/main/scala-3/com/fasterxml/jackson/module/scala/DefaultScalaModule.scala

@@ -22,6 +22,7 @@ class DefaultScalaModule
   extends JacksonModule
      with IteratorModule
      with EnumerationModule
+     with EnumModule // Scala 3 only
      with OptionModule
      with SeqModule
      with IterableModule

src/main/scala-3/com/fasterxml/jackson/module/scala/EnumModule.scala

@@ -0,0 +1,10 @@
+package com.fasterxml.jackson.module.scala
+
+import com.fasterxml.jackson.module.scala.deser.EnumDeserializerModule
+import com.fasterxml.jackson.module.scala.ser.EnumSerializerModule
+
+trait EnumModule extends EnumSerializerModule with EnumDeserializerModule {
+  override def getModuleName: String = "EnumModule"
+}
+
+object EnumModule extends EnumModule

src/main/scala-3/com/fasterxml/jackson/module/scala/deser/EnumDeserializerModule.scala

@@ -0,0 +1,130 @@
+package com.fasterxml.jackson.module.scala.deser
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.deser.{Deserializers, KeyDeserializers}
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
+import com.fasterxml.jackson.databind._
+import com.fasterxml.jackson.module.scala.JacksonModule
+
+import java.lang.reflect.InvocationTargetException
+import scala.languageFeature.postfixOps
+import scala.reflect.Enum
+import scala.util.Try
+
+private object EnumDeserializerShared {
+  val IntClass = classOf[Int]
+  val StringClass = classOf[String]
+  val EnumClass = classOf[Enum]
+
+  def tryValueOf(clz: Class[_], key: String): Option[_] = {
+    Try(clz.getMethod("valueOf", EnumDeserializerShared.StringClass)).toOption.map { method =>
+      method.invoke(None.orNull, key)
+    }
+  }
+
+  def matchBasedOnOrdinal(clz: Class[_], key: String): Option[_] = {
+    val className = clz.getName
+    val companionObjectClassOption = if (className.endsWith("$")) {
+      Some(clz)
+    } else {
+      Try(Class.forName(className + "$")).toOption
+    }
+    companionObjectClassOption.flatMap { companionObjectClass =>
+      Try(companionObjectClass.getField("MODULE$")).toOption.flatMap { moduleField =>
+        val instance = moduleField.get(None.orNull)
+        Try(clz.getMethod("fromOrdinal", IntClass)).toOption.flatMap { method =>
+          var i = 0
+          var matched: Option[_] = None
+          var complete = false
+          while (!complete) {
+            try {
+              val enumValue = method.invoke(instance, i)
+              if (enumValue.toString == key) {
+                matched = Some(enumValue)
+                complete = true
+              }
+            } catch {
+              case _: NoSuchElementException => {
+                matched = None
+                complete = true
+              }
+              case itex: InvocationTargetException => {
+                Option(itex.getCause) match {
+                  case Some(e) if e.isInstanceOf[NoSuchElementException] => {
+                    matched = None
+                    complete = true
+                  }
+                  case Some(e) => throw e
+                  case _ => throw itex 
+                }
+              }
+            }
+            i += 1
+          }
+          matched
+        }
+      }
+    }
+  }
+}
+
+private case class EnumDeserializer[T <: Enum](clazz: Class[T]) extends StdDeserializer[T](clazz) {
+  private val clazzName = clazz.getName
+
+  override def deserialize(p: JsonParser, ctxt: DeserializationContext): T = {
+    val result = Option(p.getValueAsString).flatMap { text =>
+      val objectClassOption = if(clazzName.endsWith("$")) {
+        Try(Class.forName(clazzName.substring(0, clazzName.length - 1))).toOption
+      } else {
+        Some(clazz)
+      }
+      objectClassOption.flatMap { objectClass =>
+        Try {
+          EnumDeserializerShared.tryValueOf(objectClass, text)
+            .orElse(EnumDeserializerShared.matchBasedOnOrdinal(objectClass, text))
+        }.toOption.flatten
+      }.asInstanceOf[Option[T]]
+    }
+    result.getOrElse(throw new IllegalArgumentException(s"Failed to create Enum instance for ${p.getValueAsString}"))
+  }
+}
+
+private case class EnumKeyDeserializer[T <: Enum](clazz: Class[T]) extends KeyDeserializer {
+  private val clazzName = clazz.getName
+
+  override def deserializeKey(key: String, ctxt: DeserializationContext): AnyRef = {
+    val objectClassOption = if(clazzName.endsWith("$")) {
+      Try(Class.forName(clazzName.substring(0, clazzName.length - 1))).toOption
+    } else {
+      Some(clazz)
+    }
+    val result = objectClassOption.flatMap { objectClass =>
+      Try {
+        EnumDeserializerShared.tryValueOf(objectClass, key)
+          .orElse(EnumDeserializerShared.matchBasedOnOrdinal(objectClass, key))
+      }.toOption.flatten
+    }
+    val enumResult = result.getOrElse(throw new IllegalArgumentException(s"Failed to create Enum instance for $key"))
+    enumResult.asInstanceOf[AnyRef]
+  }
+}
+
+private object EnumDeserializerResolver extends Deserializers.Base {
+  override def findBeanDeserializer(javaType: JavaType, config: DeserializationConfig, beanDesc: BeanDescription): JsonDeserializer[Enum] =
+    if (EnumDeserializerShared.EnumClass isAssignableFrom javaType.getRawClass)
+      EnumDeserializer(javaType.getRawClass.asInstanceOf[Class[Enum]])
+    else None.orNull
+}
+
+private object EnumKeyDeserializerResolver extends KeyDeserializers {
+  override def findKeyDeserializer(javaType: JavaType, config: DeserializationConfig, beanDesc: BeanDescription): KeyDeserializer =
+    if (EnumDeserializerShared.EnumClass isAssignableFrom javaType.getRawClass)
+      EnumKeyDeserializer(javaType.getRawClass.asInstanceOf[Class[Enum]])
+    else None.orNull
+}
+
+trait EnumDeserializerModule extends JacksonModule {
+  override def getModuleName: String = "EnumDeserializerModule"
+  this += { _ addDeserializers EnumDeserializerResolver }
+  this += { _ addKeyDeserializers EnumKeyDeserializerResolver }
+}

src/main/scala-3/com/fasterxml/jackson/module/scala/ser/EnumSerializerModule.scala

@@ -0,0 +1,44 @@
+package com.fasterxml.jackson.module.scala.ser
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind.ser.Serializers
+import com.fasterxml.jackson.databind._
+import com.fasterxml.jackson.databind.deser.KeyDeserializers
+import com.fasterxml.jackson.module.scala.JacksonModule
+
+import scala.languageFeature.postfixOps
+import scala.reflect.Enum
+
+private object EnumSerializerShared {
+  val EnumClass = classOf[Enum]
+}
+
+private object EnumSerializer extends JsonSerializer[Enum] {
+  def serialize(value: Enum, jgen: JsonGenerator, provider: SerializerProvider): Unit =
+    provider.defaultSerializeValue(value.toString, jgen)
+}
+
+private object EnumKeySerializer extends JsonSerializer[Enum] {
+  def serialize(value: Enum, jgen: JsonGenerator, provider: SerializerProvider): Unit =
+    jgen.writeFieldName(value.toString)
+}
+
+private object EnumSerializerResolver extends Serializers.Base {
+  override def findSerializer(config: SerializationConfig, javaType: JavaType, beanDesc: BeanDescription): JsonSerializer[Enum] =
+    if (EnumSerializerShared.EnumClass.isAssignableFrom(javaType.getRawClass))
+      EnumSerializer
+    else None.orNull
+}
+
+private object EnumKeySerializerResolver extends Serializers.Base {
+  override def findSerializer(config: SerializationConfig, javaType: JavaType, beanDesc: BeanDescription): JsonSerializer[Enum] =
+    if (EnumSerializerShared.EnumClass isAssignableFrom javaType.getRawClass)
+      EnumKeySerializer
+    else None.orNull
+}
+
+trait EnumSerializerModule extends JacksonModule {
+  override def getModuleName: String = "EnumSerializerModule"
+  this += { _ addSerializers EnumSerializerResolver }
+  this += { _ addKeySerializers EnumKeySerializerResolver }
+}

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/Car.scala

@@ -0,0 +1,3 @@
+package com.fasterxml.jackson.module.scala.`enum`
+
+case class Car(make: String, color: ColorEnum)

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/ColorEnum.scala

@@ -0,0 +1,5 @@
+package com.fasterxml.jackson.module.scala.`enum`
+
+enum ColorEnum { case Red, Green, Blue }
+
+case class Colors(set: Set[ColorEnum])

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/Ctx.scala

@@ -0,0 +1,7 @@
+package com.fasterxml.jackson.module.scala.`enum`
+
+object Ctx {
+  enum ColorEnum { case Red, Green, Blue }
+}
+
+case class CtxCar(make: String, color: Ctx.ColorEnum)

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/EnumDeserializerSpec.scala

@@ -0,0 +1,53 @@
+package com.fasterxml.jackson.module.scala.`enum`
+
+import com.fasterxml.jackson.core.`type`.TypeReference
+import com.fasterxml.jackson.databind.exc.InvalidDefinitionException
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.module.scala.DefaultScalaModule
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpec
+
+class EnumDeserializerSpec extends AnyWordSpec with Matchers {
+  private val mapper = JsonMapper.builder().addModule(DefaultScalaModule).build()
+
+  "EnumModule" should {
+    "deserialize ColorEnum" in {
+      val red = s""""${ColorEnum.Red}""""
+      mapper.readValue(red, classOf[ColorEnum]) shouldEqual ColorEnum.Red
+    }
+    "fail deserialization of invalid ColorEnum" in {
+      val json = s""""xyz""""
+      intercept[IllegalArgumentException] {
+        mapper.readValue(json, classOf[ColorEnum])
+      }
+    }
+    "deserialize Colors" in {
+      val colors = Colors(Set(ColorEnum.Red, ColorEnum.Green))
+      val json = mapper.writeValueAsString(colors)
+      mapper.readValue(json, classOf[Colors]) shouldEqual colors
+    }
+    "deserialize ColorEnum with non-singleton EnumModule" in {
+      val red = s""""${ColorEnum.Red}""""
+      mapper.readValue(red, classOf[ColorEnum]) shouldEqual ColorEnum.Red
+    }
+    "deserialize JavaCompatibleColorEnum" in {
+      mapper.writeValueAsString(JavaCompatibleColorEnum.Red) shouldEqual s""""${JavaCompatibleColorEnum.Red}""""
+    }
+    "deserialize Car with ColorEnum" in {
+      val red = s"""{"make":"Perodua","color":"${ColorEnum.Green}"}"""
+      mapper.readValue(red, classOf[Car]) shouldEqual Car("Perodua", ColorEnum.Green)
+    }
+    "deserialize CtxCar with Ctx.ColorEnum" in {
+      val red = s"""{"make":"Perodua","color":"${Ctx.ColorEnum.Green}"}"""
+      mapper.readValue(red, classOf[CtxCar]) shouldEqual CtxCar("Perodua", Ctx.ColorEnum.Green)
+    }
+    "deserialize Enum as Map Key" in {
+      val json = s"""{"Green":"green","Red":"red"}"""
+      val map = mapper.readValue(json, new TypeReference[Map[ColorEnum, String]] {})
+      map should have size 2
+      map(ColorEnum.Green) shouldEqual "green"
+      map(ColorEnum.Red) shouldEqual "red"
+    }
+
+  }
+}

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/EnumSerializerSpec.scala

@@ -0,0 +1,40 @@
+package com.fasterxml.jackson.module.scala.`enum`
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.module.scala.DefaultScalaModule
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpec
+
+class EnumSerializerSpec extends AnyWordSpec with Matchers {
+  private val mapper = JsonMapper.builder().addModule(DefaultScalaModule).build()
+
+  "EnumModule" should {
+    "not serialize None" in {
+      mapper.writeValueAsString(None) should not equal s""""$None""""
+    }
+    "serialize ColorEnum" in {
+      mapper.writeValueAsString(ColorEnum.Red) shouldEqual s""""${ColorEnum.Red}""""
+    }
+    "serialize Colors" in {
+      val json = mapper.writeValueAsString(Colors(Set(ColorEnum.Red, ColorEnum.Green)))
+      json should startWith("""{"set":[""")
+      json should include(""""Red"""")
+      json should include(""""Green"""")
+    }
+    "serialize ColorEnum with non-singleton EnumModule" in {
+      mapper.writeValueAsString(ColorEnum.Red) shouldEqual s""""${ColorEnum.Red}""""
+    }
+    "serialize JavaCompatibleColorEnum" in {
+      mapper.writeValueAsString(ColorEnum.Red) shouldEqual s""""${ColorEnum.Red}""""
+    }
+    "serialize Car with ColorEnum" in {
+      mapper.writeValueAsString(Car("Perodua", ColorEnum.Green)) shouldEqual s"""{"make":"Perodua","color":"${ColorEnum.Green}"}"""
+    }
+    "serialize CtxCar with Ctx.ColorEnum" in {
+      mapper.writeValueAsString(CtxCar("Perodua", Ctx.ColorEnum.Green)) shouldEqual s"""{"make":"Perodua","color":"${Ctx.ColorEnum.Green}"}"""
+    }
+    "serialize Enum as Map Key" in {
+      mapper.writeValueAsString(Map(ColorEnum.Green -> "green")) shouldEqual s"""{"Green":"green"}"""
+    }
+  }
+}

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/JavaCompatibleColorEnum.scala

@@ -0,0 +1,3 @@
+package com.fasterxml.jackson.module.scala.`enum`
+
+enum JavaCompatibleColorEnum extends java.lang.Enum[JavaCompatibleColorEnum] { case Red, Green, Blue }

src/test/scala-3/com/fasterxml/jackson/module/scala/enum/adt/AdtDeserializerSpec.scala

@@ -0,0 +1,28 @@
+package com.fasterxml.jackson.module.scala.`enum`.adt
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.module.scala.DefaultScalaModule
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpec
+
+class AdtDeserializerSpec extends AnyWordSpec with Matchers {
+  private val mapper = JsonMapper.builder().addModule(DefaultScalaModule).build()
+
+  "EnumModule" should {
+    "deserialize Color ADT" in {
+      val red = s""""${Color.Red}""""
+      mapper.readValue(red, classOf[Color]) shouldEqual Color.Red
+    }
+    "fail deserialization of invalid Color ADT" in {
+      val json = s""""xyz""""
+      intercept[IllegalArgumentException] {
+        mapper.readValue(json, classOf[Color])
+      }
+    }
+    "deserialize ColorSet" in {
+      val colors = ColorSet(Set(Color.Red, Color.Green))
+      val json = mapper.writeValueAsString(colors)
+      mapper.readValue(json, classOf[ColorSet]) shouldEqual colors
+    }
+  }
+}