Improve the support for Map[,]

Shu Zhang · Shu Zhang · commit d32b697a2785 · 2014-04-15T19:55:11.000+08:00
diff --git a/modules/swagger-core/src/main/scala/com/wordnik/swagger/converter/MapConverter.scala b/modules/swagger-core/src/main/scala/com/wordnik/swagger/converter/MapConverter.scala
@@ -0,0 +1,21 @@
+package com.wordnik.swagger.converter
+
+import com.wordnik.swagger.model._
+import com.wordnik.swagger.core.util.ClassWrapper
+import scala.collection.mutable
+
+class MapConverter extends ModelConverter with BaseConverter {
+
+  def read(cls: ClassWrapper, typeMap: Map[String, String]): Option[Model] = {
+    if (cls.getRawClass.getSimpleName == "Map") {
+      Some(Model(
+        toName(cls),
+        toName(cls),
+        cls.getName,
+        new mutable.LinkedHashMap[String, ModelProperty]()
+      ))
+    } else {
+      None
+    }
+  }
+}
diff --git a/modules/swagger-core/src/main/scala/com/wordnik/swagger/converter/ModelConverters.scala b/modules/swagger-core/src/main/scala/com/wordnik/swagger/converter/ModelConverters.scala
@@ -12,6 +12,7 @@ object ModelConverters {
   private val LOGGER = LoggerFactory.getLogger(ModelConverters.getClass)
 
   val converters = new ListBuffer[ModelConverter]() ++ List(
+    new MapConverter,
     new JodaDateTimeConverter,
     new SwaggerSchemaConverter
   )
diff --git a/modules/swagger-core/src/main/scala/com/wordnik/swagger/core/SwaggerContext.scala b/modules/swagger-core/src/main/scala/com/wordnik/swagger/core/SwaggerContext.scala
@@ -24,6 +24,7 @@ object SwaggerContext {
           case "List" => classOf[List[_]]
           case "Array" => classOf[Array[_]]
           case "Set" => classOf[Set[_]]
+          case "Map" => classOf[Map[_,_]]
           case name => Class.forName(name, true, classLoader)
         })
       } catch {
diff --git a/modules/swagger-core/src/main/scala/com/wordnik/swagger/model/SwaggerSerializers.scala b/modules/swagger-core/src/main/scala/com/wordnik/swagger/model/SwaggerSerializers.scala
@@ -58,45 +58,57 @@ object SwaggerSerializers extends Serializers {
       )
     }, {
     case x: Model =>
-      implicit val fmts = formats
-      val required: List[String] = (for((name, prop) <- x.properties) yield {
-        if(prop.required) Some(name)
-        else None
-      }).flatten.toList
-      ("id" -> x.id) ~  
-      ("description" -> x.description) ~
-      ("required" -> (required.size match {
-        case 0 => JNothing
-        case _ => Extraction.decompose(required)
-      })) ~
-      ("extends" -> {
-        x.baseModel match {
-          case Some(e) if(e != "void" && e != "java.lang.Void") => Extraction.decompose(e)
-          case _ =>JNothing
+      val ContainerMatcher = "(List|Array|Set)\\[(.*)\\].*?".r
+      val MapMatcher = "Map\\[([^\\],]*),\\s*([^\\],]*)\\].*?".r
+      x.name match {
+        case ContainerMatcher(container, value) => {
+          ("id" -> x.id) ~ toJsonSchemaContainer(value)
         }
-      }) ~
-      ("discriminator" -> {
-        x.discriminator match {
-          case Some(e) if (e.trim != "" && e.trim != "void") => Extraction.decompose(e)
-          case _ => JNothing
+        case MapMatcher(key, value) => {
+          ("id" -> x.id) ~ toJsonSchemaMap(value)
         }
-      }) ~
-      ("properties" -> {
-        x.properties match {
-          case e: LinkedHashMap[String, ModelProperty] => {
-            (for((key, value) <- e) yield (key -> Extraction.decompose(value))).toList
-          }
-          case _ => List.empty
-        }
-      }) ~
-      ("subTypes" -> {
-        x.subTypes match {
-          case e: List[String] if (e.size > 0) => {
-            Extraction.decompose(for(m <- e) yield ModelUtil.cleanDataType(m))
-          }
-          case _ => JNothing
+        case _ => {
+          implicit val fmts = formats
+          val required: List[String] = (for((name, prop) <- x.properties) yield {
+            if(prop.required) Some(name)
+            else None
+          }).flatten.toList
+          ("id" -> x.id) ~
+          ("description" -> x.description) ~
+          ("required" -> (required.size match {
+            case 0 => JNothing
+            case _ => Extraction.decompose(required)
+          })) ~
+          ("extends" -> {
+            x.baseModel match {
+              case Some(e) if(e != "void" && e != "java.lang.Void") => Extraction.decompose(e)
+              case _ =>JNothing
+            }
+          }) ~
+          ("discriminator" -> {
+            x.discriminator match {
+              case Some(e) if (e.trim != "" && e.trim != "void") => Extraction.decompose(e)
+              case _ => JNothing
+            }
+          }) ~
+          ("properties" -> {
+            x.properties match {
+              case e: LinkedHashMap[String, ModelProperty] => {
+                (for((key, value) <- e) yield (key -> Extraction.decompose(value))).toList
+              }
+              case _ => List.empty
+            }
+          }) ~
+          ("subTypes" -> {
+            x.subTypes match {
+              case e: List[String] if (e.size > 0) => {
+                Extraction.decompose(for(m <- e) yield ModelUtil.cleanDataType(m))
+              }
+              case _ => JNothing
+            }
+          })
         }
-      })
+      }
     }
   ))
 
@@ -115,6 +127,7 @@ object SwaggerSerializers extends Serializers {
       case "date-time" => (name -> "string")  ~ ("format" -> "date-time")
       case _           => {
         val ContainerMatcher = "(List|Array|Set)\\[(.*)\\].*?".r
+        val MapMatcher = "Map\\[([^\\],]*),\\s*([^\\],]*)\\].*?".r
         `type` match {
           case ContainerMatcher(container, value) =>
             toJsonSchemaContainer(container) ~ {
@@ -123,6 +136,8 @@ object SwaggerSerializers extends Serializers {
                 else
                   toJsonSchema("$ref", value)})
             }
+          case MapMatcher(key, value) =>
+            toJsonSchemaMap(value)
           case _ => (name -> `type`)    ~ ("format" -> JNothing)
         }
       }
@@ -138,6 +153,16 @@ object SwaggerSerializers extends Serializers {
     }
   }
 
+  def toJsonSchemaMap(value: String): JObject = {
+    ("type" -> "object") ~ ("patternProperties" ->
+      (".*" -> {
+          if(isSimpleType(value))
+            toJsonSchema("type", value)
+          else
+            toJsonSchema("$ref", value)
+      }))
+  }
+
   def isSimpleType(name: String) = {
     Set("int", "long", "float", "double", "string", "byte", "boolean", "Date", "date", "date-time", "array").contains(name)
   }
@@ -154,6 +179,16 @@ object SwaggerSerializers extends Serializers {
         case "Set"       => ("type" -> "array")   ~ ("uniqueItems" -> true)
       }
     }
+    else if (prop.`type`.startsWith("Map[")) {
+      val MapMatcher = "Map\\[([^\\],]*),\\s*([^\\],]*)\\].*?".r
+      prop.`type` match {
+        case MapMatcher(key, value) => {
+          toJsonSchemaMap(value)
+        }
+        case _ =>
+          ("$ref" -> prop.`type`) ~ ("format" -> JNothing)
+      }
+    }
     else ("$ref" -> prop.`type`)                  ~ ("format" -> JNothing)
   }
 
@@ -403,26 +438,6 @@ object SwaggerSerializers extends Serializers {
   ))
 }
 
-object SwaggerJsonSchemaSerializers extends Serializers {
-// object SwaggerSerializers extends Serializers {
-  implicit val formats = DefaultFormats + 
-    new ModelSerializer + 
-    new ModelPropertySerializer +
-    new ModelRefSerializer + 
-    new AllowableValuesSerializer + 
-    new ParameterSerializer +
-    new OperationSerializer +
-    new ResponseMessageSerializer +
-    new SampleSerializer +
-    new ApiDescriptionSerializer +
-    new ApiListingReferenceSerializer +
-    new ResourceListingSerializer +
-    new ApiInfoSerializer +
-    new ApiListingSerializer +
-    new AuthorizationTypeSerializer + 
-    new AuthorizationSerializer
-}
-
 trait Serializers {
   import ValidationMessage._
   val validationMessages = ListBuffer.empty[ValidationMessage]
@@ -861,116 +876,6 @@ trait Serializers {
     }
   ))
 
-  class ModelSerializer extends CustomSerializer[Model](formats => ({
-    case json =>
-      implicit val fmts: Formats = formats
-      val output = new LinkedHashMap[String, ModelProperty]
-      val properties = (json \ "properties") match {
-        case JObject(entries) => {
-          entries.map({
-            case (key, value) => output += key -> value.extract[ModelProperty]
-          })
-        }
-        case _ =>
-      }
-
-      Model(
-        (json \ "id").extractOrElse({
-          !!(json, MODEL, "id", "missing required field", ERROR)
-          ""
-        }),
-        (json \ "name").extractOrElse((json \ "id").extract[String]),
-        (json \ "qualifiedType").extractOrElse(""),
-        output,
-        (json \ "description").extractOpt[String],
-        (json \ "extends").extractOpt[String],
-        (json \ "discriminator").extractOpt[String]
-      )
-    }, {
-    case x: Model =>
-      implicit val fmts = formats
-      ("id" -> x.id) ~
-      ("name" -> x.name) ~
-      ("properties" -> {
-        x.properties match {
-          case e: LinkedHashMap[String, ModelProperty] => Extraction.decompose(e.toMap)
-          case _ => JNothing
-        }
-      }) ~
-      ("description" -> x.description) ~
-      ("extends" -> {
-        x.baseModel match {
-          case Some(e) if(e != "void") => Extraction.decompose(e)
-          case _ => JNothing
-        }
-      }) ~
-      ("discriminator" -> {
-        x.discriminator match {
-          case Some(e) if (e.trim != "" && e.trim != "void") => Extraction.decompose(e)
-          case _ => JNothing
-        }
-      })
-    }
-  ))
-
-  class ModelPropertySerializer extends CustomSerializer[ModelProperty] (formats => ({
-    case json =>
-      implicit val fmts: Formats = formats
-      ModelProperty(
-        `type` = (json \ "type").extractOrElse(""),
-        qualifiedType = (json \ "type").extractOrElse(""),
-        position = (json \ "position").extractOrElse(0),
-        (json \ "required") match {
-          case e:JString => e.s.toBoolean
-          case e:JBool => e.value
-          case _ => false
-        },
-        description = (json \ "description").extractOpt[String],
-        allowableValues = (json \ "allowableValues").extract[AllowableValues],
-        items = {
-          (json \ "items").extractOpt[ModelRef] match {
-            case Some(e: ModelRef) if(e.`type` != null || e.ref != None) => Some(e)
-            case _ => None
-          }
-        }
-      )
-    }, {
-    case x: ModelProperty =>
-      implicit val fmts = formats
-      ("type" -> x.`type`) ~
-      ("required" -> x.required) ~
-      ("description" -> x.description) ~
-      ("allowableValues" -> {
-        x.allowableValues match {
-          case AnyAllowableValues => JNothing // don't serialize when not a concrete type
-          case e:AllowableValues => Extraction.decompose(x.allowableValues)
-          case _ => JNothing
-        }
-      }) ~
-      ("items" -> Extraction.decompose(x.items))
-    }
-  ))
-
-  class ModelRefSerializer extends CustomSerializer[ModelRef](formats => ({
-    case json =>
-      implicit val fmts: Formats = formats
-      ModelRef(
-        (json \ "type").extractOrElse(null: String),
-        (json \ "$ref").extractOpt[String]
-      )
-    }, {
-      case x: ModelRef =>
-      implicit val fmts = formats
-      ("type" -> {
-        x.`type` match {
-          case e:String => Some(e)
-          case _ => None
-        }
-      }) ~
-      ("$ref" -> x.ref)
-    }
-  ))
-
   class AuthorizationTypeSerializer extends CustomSerializer[AuthorizationType](formats => ({
     case json =>
       implicit val fmts: Formats = formats
diff --git a/modules/swagger-jaxrs/src/test/scala/PathParamTargetTest.scala b/modules/swagger-jaxrs/src/test/scala/PathParamTargetTest.scala
@@ -89,7 +89,7 @@ class JavaPathParamTargetTest extends FlatSpec with ShouldMatchers {
 
     // verify the 2nd api
     val detailsOps = apis.filter(_.path == "/javaPathParamTest/{id}/details").head.operations
-    val detailOp = detailsOps.head
+    val detailOp = detailsOps.filter(_.method == "POST").head
 
     detailOp.parameters.size should be (3)
 

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ object ModelConverters {`
`12`	`12`	`private val LOGGER = LoggerFactory.getLogger(ModelConverters.getClass)`
`13`	`13`
`14`	`14`	`val converters = new ListBuffer[ModelConverter]() ++ List(`
	`15`	`+ new MapConverter,`
`15`	`16`	`new JodaDateTimeConverter,`
`16`	`17`	`new SwaggerSchemaConverter`
`17`	`18`	`)`