merged from 2.10 branch

Author: fehguy

modules/swagger-annotations/src/main/java/com/wordnik/swagger/annotations/ApiModel.java

@@ -43,4 +43,5 @@
   Class<?> parent() default Void.class;
   /** for models with a base class, a discriminator can be provided for polymorphic use cases */
   String discriminator() default "";
+  Class<?>[] subTypes() default {};
 }

modules/swagger-core/src/main/scala/com/wordnik/swagger/converter/ModelConverters.scala

@@ -38,6 +38,23 @@ object ModelConverters {
     val output = new HashMap[String, Model]
     var model = read(cls)
     val propertyNames = new HashSet[String]
+
+    // add subTypes
+    model.map(_.subTypes.map(typeRef => {
+      try{
+        LOGGER.debug("loading subtype " + typeRef)
+        val cls = SwaggerContext.loadClass(typeRef)
+        read(cls) match {
+          case Some(model) => output += cls.getName -> model
+          case _ =>
+        }
+      }
+      catch {
+        case e: Exception => LOGGER.error("can't load class " + typeRef)
+      }
+    }))
+
+    // add properties
     model.map(m => {
       output += cls.getName -> m
       val checkedNames = new HashSet[String]

modules/swagger-core/src/main/scala/com/wordnik/swagger/converter/SwaggerSchemaConverter.scala

@@ -3,6 +3,8 @@ package com.wordnik.swagger.converter
 import com.wordnik.swagger.model._
 import com.wordnik.swagger.annotations.ApiModel
 
+import com.fasterxml.jackson.annotation.{ JsonTypeInfo, JsonSubTypes }
+
 import org.slf4j.LoggerFactory
 
 import scala.collection.mutable.LinkedHashMap
@@ -24,15 +26,27 @@ class SwaggerSchemaConverter
         val sortedProperties = new LinkedHashMap[String, ModelProperty]()
         p.sortWith(_._1 < _._1).foreach(e => sortedProperties += e._2 -> e._3)
 
-        val baseModel = Option(cls.getAnnotation(classOf[ApiModel])) match {
-          case Some(e) => Option(e.parent.getName)
+        val parent = Option(cls.getAnnotation(classOf[ApiModel])) match {
+          case Some(e) => Some(e.parent.getName)
           case _ => None
         }
-        val discriminator = Option(cls.getAnnotation(classOf[ApiModel])) match {
-          case Some(e) => Option(e.discriminator)
-          case _ => None
+        val discriminator = {
+          val v = 
+            if(cls.getAnnotation(classOf[ApiModel]) != null)
+              cls.getAnnotation(classOf[ApiModel]).discriminator
+            else if(cls.getAnnotation(classOf[JsonTypeInfo]) != null)
+              cls.getAnnotation(classOf[JsonTypeInfo]).property
+            else ""
+          if(v != null && v != "") Some(v)
+          else None
+        }
+        val subTypes = {
+          if(cls.getAnnotation(classOf[ApiModel]) != null)
+            cls.getAnnotation(classOf[ApiModel]).subTypes.map(_.getName).toList
+          else if(cls.getAnnotation(classOf[JsonSubTypes]) != null)
+            (for(subType <- cls.getAnnotation(classOf[JsonSubTypes]).value) yield (subType.value.getName)).toList
+          else List()
         }
-
         sortedProperties.size match {
           case 0 => None
           case _ => Some(Model(
@@ -41,8 +55,9 @@ class SwaggerSchemaConverter
             cls.getName,
             sortedProperties,
             toDescriptionOpt(cls),
-            baseModel,
-            discriminator
+            parent,
+            discriminator,
+            subTypes
           ))
         }
       }

modules/swagger-core/src/main/scala/com/wordnik/swagger/core/filter/SpecFilter.scala

@@ -17,6 +17,8 @@
 package com.wordnik.swagger.core.filter
 
 import com.wordnik.swagger.model._
+import com.wordnik.swagger.core.SwaggerContext
+import com.wordnik.swagger.converter.ModelConverters
 import com.wordnik.swagger.converter.ModelInheritenceUtil
 
 import org.slf4j.LoggerFactory
@@ -48,7 +50,7 @@ class SpecFilter {
           Some(op.copy(parameters = filteredParams))
         }
         else None
-      }).flatten.toList
+      }).flatten.toList.sortWith(_.position < _.position)
       filteredOps.size match {
         case 0 => None
         case _ => Some(api.copy(operations = filteredOps))
@@ -63,11 +65,13 @@ class SpecFilter {
   def filterModels(allModels: Option[Map[String, Model]], apis: List[ApiDescription]) = {
     val modelNames = requiredModels(allModels, apis)
     val existingModels = allModels.getOrElse(Map[String, Model]())
+    LOGGER.debug("existingModels: " + modelNames)
     val output = (for(model <- modelNames) yield {
       if(existingModels.contains(model))
         Some(model, existingModels(model))
       else None
     }).flatten.toMap
+
     val filtered = ModelInheritenceUtil.expand(output)
     if(output.size > 0) Some(filtered)
     else None
@@ -82,6 +86,7 @@ class SpecFilter {
         op.responseMessages.foreach(_.responseModel.map{modelNames += _})
       }
     })
+    LOGGER.debug("requiredModels: " + modelNames)
     val topLevelModels = (for(model <- modelNames) yield {
       model match {
         case ComplexTypeMatcher(basePart) => {
@@ -92,8 +97,22 @@ class SpecFilter {
         case _ => model
       }
     }).toList
+    val subTypes = (for(model <- topLevelModels) yield {
+      allModels match {
+        case Some(models) if(models.contains(model)) => {
+          val m = models(model)
+          (for(subType <- m.subTypes) yield {
+            val cls = SwaggerContext.loadClass(subType)
+            for(model <- ModelConverters.readAll(cls)) yield {
+              model.name
+            }
+          }).flatten.toList
+        }
+        case _ => List()
+      }
+    }).flatten.toList
     val properties = requiredProperties(topLevelModels, allModels.getOrElse(Map()), new HashSet[String]())
-    topLevelModels ++ properties
+    topLevelModels ++ subTypes ++ properties
   }
 
   def requiredProperties(models: List[String], allModels: Map[String, Model], inspectedTypes: HashSet[String]): List[String] = {

modules/swagger-core/src/main/scala/com/wordnik/swagger/model/SwaggerModels.scala

@@ -51,7 +51,8 @@ case class Model(
   properties: LinkedHashMap[String, ModelProperty],
   description: Option[String] = None,
   baseModel: Option[String] = None,
-  discriminator: Option[String] = None)
+  discriminator: Option[String] = None,
+  subTypes: List[String] = List.empty)
 
 case class ModelProperty(
   `type`: String,

modules/swagger-core/src/main/scala/com/wordnik/swagger/model/SwaggerSerializers.scala

@@ -1,6 +1,7 @@
 package com.wordnik.swagger.model
 
 import com.wordnik.swagger.core.SwaggerSpec
+import com.wordnik.swagger.core.util.ModelUtil
 
 import org.json4s._
 import org.json4s.JsonDSL._
@@ -19,7 +20,7 @@ object SwaggerSerializers extends Serializers {
     new JsonSchemaModelRefSerializer + 
     new AllowableValuesSerializer + 
     new JsonSchemaParameterSerializer +
-    new OperationSerializer +
+    new JsonSchemaOperationSerializer +
     new ResponseMessageSerializer +
     new ApiDescriptionSerializer +
     new ApiListingReferenceSerializer +
@@ -68,7 +69,7 @@ object SwaggerSerializers extends Serializers {
       })) ~
       ("extends" -> {
         x.baseModel match {
-          case Some(e) if(e != "void") => Extraction.decompose(e)
+          case Some(e) if(e != "void" && e != "java.lang.Void") => Extraction.decompose(e)
           case _ =>JNothing
         }
       }) ~
@@ -85,6 +86,14 @@ object SwaggerSerializers extends Serializers {
           }
           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
+        }
       })
     }
   ))
@@ -107,7 +116,7 @@ object SwaggerSerializers extends Serializers {
           case ComplexTypeMatcher(container, value) => 
             toJsonSchemaContainer(container) ~ {
               ("items" -> {if(isSimpleType(value))
-                  toJsonSchema("items", value)
+                  toJsonSchema("type", value)
                 else
                   toJsonSchema("$ref", value)})
             }
@@ -160,6 +169,79 @@ object SwaggerSerializers extends Serializers {
     }
   }
 
+  class JsonSchemaOperationSerializer extends CustomSerializer[Operation](formats => ({
+    case json =>
+      implicit val fmts: Formats = formats
+      Operation(
+        (json \ "method").extractOrElse({
+          !!(json, OPERATION, "method", "missing required field", ERROR)
+          ""
+        }),
+        (json \ "summary").extract[String],
+        (json \ "notes").extractOrElse(""),
+        (json \ "responseClass").extractOrElse({
+          !!(json, OPERATION, "responseClass", "missing required field", ERROR)
+          ""
+        }),
+        (json \ "nickname").extractOrElse({
+          !!(json, OPERATION, "nickname", "missing required field", ERROR)
+          ""
+        }),
+        (json \ "position").extractOrElse(0),
+        (json \ "produces").extractOrElse(List()),
+        (json \ "consumes").extractOrElse(List()),
+        (json \ "protocols").extractOrElse(List()),
+        (json \ "authorizations").extractOrElse(List()),
+        (json \ "parameters").extract[List[Parameter]],
+        (json \ "responseMessages").extract[List[ResponseMessage]],
+        (json \ "deprecated").extractOpt[String]
+      )
+    }, {
+      case x: Operation =>
+      implicit val fmts = formats
+
+      val output = toJsonSchema("type", x.responseClass)
+
+      ("method" -> x.method) ~
+      ("summary" -> x.summary) ~
+      ("notes" -> x.notes) ~
+      output ~
+      ("nickname" -> x.nickname) ~
+      ("produces" -> {
+        x.produces match {
+          case e: List[String] if(e.size > 0) => Extraction.decompose(e)
+          case _ => JNothing
+        }
+      }) ~
+      ("consumes" -> {
+        x.consumes match {
+          case e: List[String] if(e.size > 0) => Extraction.decompose(e)
+          case _ => JNothing
+        }
+      }) ~
+      ("protocols" -> {
+        x.protocols match {
+          case e: List[String] if(e.size > 0) => Extraction.decompose(e)
+          case _ => JNothing
+        }
+      }) ~
+      ("authorizations" -> {
+        x.authorizations match {
+          case e: List[String] if(e.size > 0) => Extraction.decompose(e)
+          case _ => JNothing
+        }
+      }) ~
+      ("parameters" -> Extraction.decompose(x.parameters)) ~
+      ("responseMessages" -> {
+        x.responseMessages match {
+          case e: List[ResponseMessage] if(e.size > 0) => Extraction.decompose(e)
+          case _ => JNothing
+        }
+      }) ~
+      ("deprecated" -> x.`deprecated`)
+    }
+  ))
+
   class JsonSchemaModelPropertySerializer extends CustomSerializer[ModelProperty] (formats => ({
     case json =>
       implicit val fmts: Formats = formats
@@ -272,8 +354,8 @@ object SwaggerSerializers extends Serializers {
           ""
         }),
         (json \ "allowableValues").extract[AllowableValues],
-        (json \ "paramType").extractOrElse({
-          !!(json, OPERATION_PARAM, "paramType", "missing required field", ERROR)
+        (json \ "type").extractOrElse({
+          !!(json, OPERATION_PARAM, "type", "missing required field", ERROR)
           ""
         }),
         (json \ "paramAccess").extractOpt[String]

modules/swagger-core/src/test/scala/converter/JacksonSubTypeModelTest.scala

@@ -0,0 +1,58 @@
+package converter
+
+import converter.models._
+
+import com.wordnik.swagger.model._
+import com.wordnik.swagger.converter._
+
+import com.wordnik.swagger.core.util._
+import com.wordnik.swagger.annotations.ApiModelProperty
+
+
+import org.json4s._
+import org.json4s.JsonDSL._
+import org.json4s.jackson.JsonMethods._
+import org.json4s.jackson.Serialization.{read, write}
+
+import java.util.Date
+
+import org.junit.runner.RunWith
+import org.scalatest.junit.JUnitRunner
+import org.scalatest.FlatSpec
+import org.scalatest.matchers.ShouldMatchers
+
+import scala.reflect.BeanProperty
+
+@RunWith(classOf[JUnitRunner])
+class JacksonSubTypeModelTest extends FlatSpec with ShouldMatchers {
+  implicit val formats = SwaggerSerializers.formats
+
+  it should "read a model with subTypes" in {
+    val model = ModelConverters.read(classOf[JAnimal]).getOrElse(fail("no model found"))
+    model.subTypes.size should be (2)
+
+    write(model) should be ("""{"id":"JAnimal","discriminator":"type","properties":{"type":{"type":"string","description":"type of animal"},"date":{"type":"string","format":"date-time","description":"Date added to the zoo"}},"subTypes":["JWildAnimal","JDomesticAnimal"]}""")
+
+/*
+{
+  "id": "JAnimal",
+  "discriminator": "type",
+  "properties": {
+    "type": {
+      "type": "string",
+      "description": "type of animal"
+    },
+    "date": {
+      "type": "string",
+      "format": "date-time",
+      "description": "Date added to the zoo"
+    }
+  },
+  "subTypes": [
+    "JWildAnimal",
+    "JDomesticAnimal"
+  ]
+}
+*/
+  }
+}

modules/swagger-core/src/test/scala/converter/ModelPropertyParserTest.scala

@@ -25,6 +25,5 @@ class ModelPropertyParserTest extends FlatSpec with ShouldMatchers {
     implicit val properties = new scala.collection.mutable.LinkedHashMap[String, ModelProperty]
     val parser = new ModelPropertyParser(cls)
     parser.parse
-    println(properties)
   }
 }