support ADT style enums (#2)

Author: pjfanning

build.sbt

@@ -21,7 +21,7 @@ libraryDependencies ++= Seq(
   "com.github.swagger-akka-http" %% "swagger-scala-module" % "2.8.2",
   "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.14.1",
   "org.scalatest" %% "scalatest" % "3.2.14" % Test,
-  "org.slf4j" % "slf4j-simple" % "2.0.5" % Test
+  "org.slf4j" % "slf4j-simple" % "2.0.6" % Test
 )
 
 homepage := Some(new URL("https://github.com/swagger-akka-http/swagger-scala3-enum-module"))

src/main/scala/com/github/swagger/scala3enum/converter/SwaggerScala3EnumModelConverter.scala

@@ -10,20 +10,25 @@ import io.swagger.v3.oas.annotations.media.{ArraySchema, Schema as SchemaAnnotat
 import io.swagger.v3.oas.models.media.Schema
 
 import java.lang.annotation.Annotation
+import java.lang.reflect.InvocationTargetException
 import java.util.Iterator
 import scala.reflect.Enum
+import scala.util.Try
 
 class SwaggerScala3EnumModelConverter extends ModelResolver(Json.mapper()) {
   private val enumEntryClass = classOf[Enum]
+  private val IntClass = classOf[Int]
 
   override def resolve(annotatedType: AnnotatedType, context: ModelConverterContext, chain: Iterator[ModelConverter]): Schema[_] = {
     val javaType = _mapper.constructType(annotatedType.getType)
     val cls = javaType.getRawClass
     if (isEnum(cls)) {
       val sp: Schema[String] = PrimitiveType.STRING.createProperty().asInstanceOf[Schema[String]]
       setRequired(annotatedType)
-      getValues(cls).foreach { v =>
-        sp.addEnumItemObject(v)
+      tryValues(cls).toOption.orElse(matchBasedOnOrdinals(cls)).map { values =>
+        values.foreach { v =>
+          sp.addEnumItemObject(v)
+        }
       }
       nullSafeList(annotatedType.getCtxAnnotations).foreach {
         case p: Parameter => {
@@ -63,12 +68,48 @@ class SwaggerScala3EnumModelConverter extends ModelResolver(Json.mapper()) {
 
   private def isEnum(cls: Class[_]): Boolean = enumEntryClass.isAssignableFrom(cls)
 
-  private def getValues(cls: Class[_]): Seq[String] = {
+  private def tryValues(cls: Class[_]): Try[Seq[String]] = Try {
     val enumCompanion = Class.forName(cls.getName + "$").getField("MODULE$").get(null)
     val enumArray = enumCompanion.getClass.getDeclaredMethod("values").invoke(enumCompanion).asInstanceOf[Array[Enum]]
     enumArray.sortBy(_.ordinal).map(_.toString).toSeq
   }
 
+  private def matchBasedOnOrdinals(clz: Class[_]): Option[Seq[String]] = {
+    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.map { method =>
+          var i = 0
+          var matched: Seq[String] = Seq.empty[String]
+          var complete = false
+          while (!complete) {
+            try {
+              val enumValue = method.invoke(instance, i)
+              matched = matched :+ enumValue.toString
+            } catch {
+              case _: NoSuchElementException => complete = true
+              case itex: InvocationTargetException => {
+                Option(itex.getCause) match {
+                  case Some(e) if e.isInstanceOf[NoSuchElementException] => complete = true
+                  case Some(e) => throw e
+                  case _ => throw itex
+                }
+              }
+            }
+            i += 1
+          }
+          matched
+        }
+      }
+    }
+  }
+
   private def setRequired(annotatedType: AnnotatedType): Unit = annotatedType match {
     case _: AnnotatedTypeForOption => // not required
     case _ => {

src/test/scala/com/github/swagger/scala3enum/converter/adt/Color.scala

@@ -0,0 +1,11 @@
+package com.github.swagger.scala3enum.converter.adt
+
+enum Color(val rgb: Int):
+  case Red   extends Color(0xFF0000)
+  case Green extends Color(0x00FF00)
+  case Blue  extends Color(0x0000FF)
+  case Mix(mix: Int) extends Color(mix)
+
+case class ColorSet(set: Set[Color])
+
+case class Car(make: String, color: Color)

src/test/scala/com/github/swagger/scala3enum/converter/adt/SwaggerAdtConverterSpec.scala

@@ -0,0 +1,56 @@
+package com.github.swagger.scala3enum.converter.adt
+
+import io.swagger.v3.core.converter.ModelConverters
+import io.swagger.v3.oas.models.media.{ArraySchema, Schema, StringSchema}
+import org.scalatest.OptionValues
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpec
+
+import scala.jdk.CollectionConverters.*
+import scala.reflect.Enum
+
+class SwaggerAdtConverterSpec extends AnyWordSpec with Matchers with OptionValues {
+  "SwaggerScala3EnumModelConverter" should {
+    "get model for Car" in {
+      val converter = ModelConverters.getInstance()
+      val schemas = converter.readAll(classOf[Car]).asScala.toMap
+      val model = findModel(schemas, "Car")
+      model should be(defined)
+      model.get.getProperties should not be (null)
+      val field = model.value.getProperties.get("color")
+      field shouldBe a[StringSchema]
+      nullSafeList(field.asInstanceOf[StringSchema].getEnum) shouldEqual Seq("Red", "Green", "Blue")
+      nullSafeList(field.getRequired) shouldBe empty
+      nullSafeList(model.value.getRequired) shouldEqual Seq("color", "make")
+    }
+    "get model for ColorSet" in {
+      val converter = ModelConverters.getInstance()
+      val schemas = converter.readAll(classOf[ColorSet]).asScala.toMap
+      val model = findModel(schemas, "ColorSet")
+      model should be (defined)
+      model.get.getProperties should not be (null)
+      val field = model.value.getProperties.get("set")
+      field shouldBe an [ArraySchema]
+      val arraySchema = field.asInstanceOf[ArraySchema]
+      nullSafeList(arraySchema.getItems.getEnum) shouldEqual Seq("Red", "Green", "Blue")
+      nullSafeList(arraySchema.getRequired) shouldBe empty
+      nullSafeList(model.value.getRequired) shouldEqual Seq("set")
+    }
+  }
+
+  private def findModel(schemas: Map[String, Schema[_]], name: String): Option[Schema[_]] = {
+    schemas.get(name) match {
+      case Some(m) => Some(m)
+      case None =>
+        schemas.keys.find { case k => k.startsWith(name) } match {
+          case Some(key) => schemas.get(key)
+          case None => schemas.values.headOption
+        }
+    }
+  }
+
+  private def nullSafeList[T](list: java.util.List[T]): List[T] = Option(list) match {
+    case None => List[T]()
+    case Some(l) => l.asScala.toList
+  }
+}