gbolt - minor modifications to SwaggerSerializers and ModelPropertyParser to better unbox Option[_] and Seq[_] types per Spray-Swagger Issue #31

Author: gbolt

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

@@ -206,10 +206,10 @@ class ModelPropertyParser(cls: Class[_], t: Map[String, String] = Map.empty) (im
                   else simpleTypeRef
                 }
                 simpleName = containerType
-                if(isComplex(simpleTypeRef)) {
-                  Some(ModelRef(null, Some(simpleTypeRef), Some(basePart)))
+                if(isComplex(typeRef)) {
+                  Some(ModelRef(null, Some(typeRef), Some(basePart)))
                 }
-                else Some(ModelRef(simpleTypeRef, None, Some(basePart)))
+                else Some(ModelRef(typeRef, None, Some(basePart)))
               }
               case _ => None
             }

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

@@ -175,6 +175,15 @@ object SwaggerSerializers extends Serializers {
     }
   }
 
+  def toJsonSchemaTypeFromRef(ref: ModelRef): JObject = {
+    // see if primitive
+    if(SwaggerSpec.baseTypes.contains(ref.`type`)) {
+      toJsonSchema("type", ref.`type`)
+    } else {
+      ("type" -> ref.`type`)
+    }
+  }
+
   class JsonSchemaOperationSerializer extends CustomSerializer[Operation](formats => ({
     case json =>
       implicit val fmts: Formats = formats
@@ -337,23 +346,22 @@ object SwaggerSerializers extends Serializers {
   ))
 
   class JsonSchemaModelRefSerializer extends CustomSerializer[ModelRef](formats => ({
-    case json =>
+    case json => {
       implicit val fmts: Formats = formats
       ModelRef(
         (json \ "type").extractOrElse(null: String),
         (json \ "$ref").extractOpt[String]
       )
-    }, {
-      case x: ModelRef =>
+    }}, {
+    case x: ModelRef => {
       implicit val fmts = formats
-      ("type" -> {
-        x.`type` match {
-          case e:String => Some(e)
-          case _ => None
-        }
-      }) ~
-      ("$ref" -> x.ref)
+      val output: JObject = x.`type` match {
+        case e: String => toJsonSchemaTypeFromRef(x)
+        case _ => ("type" -> None)
+      }
+      output ~ ("$ref" -> x.ref)
     }
+  }
   ))
 
   class JsonSchemaParameterSerializer extends CustomSerializer[Parameter](formats => ({

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

@@ -30,7 +30,11 @@ class FormatTest extends FlatSpec with Matchers {
     val model = ModelConverters.read(classOf[SetModel]).getOrElse(fail("no model found"))
     model.properties.size should be (1)
 
-    write(model) should be ("""{"id":"SetModel","properties":{"longs":{"type":"array","uniqueItems":true,"items":{"type":"long"}}}}""")
+    // gbolt; 11/9/2014 - Unclear why the type is expected to be "long"?  As far as I understand, long is not one of the
+    // 7 primitive types defined in JSON Schema.  It should be integer with format of int64.
+   // write(model) should be ("""{"id":"SetModel","properties":{"longs":{"type":"array","uniqueItems":true,"items":{"type":"long"}}}}""")
+   write(model) should be ("""{"id":"SetModel","properties":{"longs":{"type":"array","uniqueItems":true,"items":{"type":"integer","format":"int64"}}}}""")
+
   }
 }