updated to match 1.3.3-SNAPSHOT

Author: fehguy

modules/swagger-play2/app/play/modules/swagger/PlayApiReader.scala

@@ -20,6 +20,8 @@ import java.lang.reflect.Method
 import javax.ws.rs.core.Context
 import javax.ws.rs._
 
+import scala.collection.mutable.ListBuffer
+
 case class RouteEntry(httpMethod: String, path: String)
 
 object SwaggerUtils {
@@ -29,9 +31,120 @@ object SwaggerUtils {
 }
 
 class PlayApiReader(val routes: Option[Routes]) extends JaxrsApiReader {
-
   private var _routesCache: Map[String, RouteEntry] = null
 
+  override
+  def readRecursive(
+    docRoot: String, 
+    parentPath: String, cls: Class[_], 
+    config: SwaggerConfig,
+    operations: ListBuffer[Tuple3[String, String, ListBuffer[Operation]]],
+    parentMethods: ListBuffer[Method]): Option[ApiListing] = {
+    val api = cls.getAnnotation(classOf[Api])
+
+    // must have @Api annotation to process!
+    if(api != null) {
+      val consumes = Option(api.consumes) match {
+        case Some(e) if(e != "") => e.split(",").map(_.trim).toList
+        case _ => cls.getAnnotation(classOf[Consumes]) match {
+          case e: Consumes => e.value.toList
+          case _ => List()
+        }
+      }
+      val produces = Option(api.produces) match {
+        case Some(e) if(e != "") => e.split(",").map(_.trim).toList
+        case _ => cls.getAnnotation(classOf[Produces]) match {
+          case e: Produces => e.value.toList
+          case _ => List()
+        }
+      }
+      val protocols = Option(api.protocols) match {
+        case Some(e) if(e != "") => e.split(",").map(_.trim).toList
+        case _ => List()
+      }
+      val description = api.description match {
+        case e: String if(e != "") => Some(e)
+        case _ => None
+      }
+      // look for method-level annotated properties
+      val parentParams: List[Parameter] = (for(field <- getAllFields(cls)) 
+        yield {
+          // only process fields with @ApiParam, @QueryParam, @HeaderParam, @PathParam
+          if(field.getAnnotation(classOf[QueryParam]) != null || field.getAnnotation(classOf[HeaderParam]) != null ||
+            field.getAnnotation(classOf[HeaderParam]) != null || field.getAnnotation(classOf[PathParam]) != null ||
+            field.getAnnotation(classOf[ApiParam]) != null) { 
+            val param = new MutableParameter
+            param.dataType = field.getType.getName
+            Option (field.getAnnotation(classOf[ApiParam])) match {
+              case Some(annotation) => toAllowableValues(annotation.allowableValues)
+              case _ =>
+            }
+            val annotations = field.getAnnotations
+            processParamAnnotations(param, annotations)
+          }
+          else None
+        }
+      ).flatten.toList
+
+      for(method <- cls.getMethods) {
+        val returnType = findSubresourceType(method)
+        val path = method.getAnnotation(classOf[Path]) match {
+          case e: Path => e.value()
+          case _ => ""
+        }
+        val endpoint = (parentPath + pathFromMethod(method)).replace("//", "/")
+        Option(returnType.getAnnotation(classOf[Api])) match {
+          case Some(e) => {
+            val root = docRoot + api.value + pathFromMethod(method)
+            parentMethods += method
+            readRecursive(root, endpoint, returnType, config, operations, parentMethods)
+            parentMethods -= method
+          }
+          case _ => {
+            if(method.getAnnotation(classOf[ApiOperation]) != null) {
+              readMethod(method, parentParams, parentMethods) match {
+                case Some(op) => appendOperation(endpoint, path, op, operations)
+                case None =>
+              }
+            }
+          }
+        }
+      }
+      // sort them by min position in the operations
+      val s = (for(op <- operations) yield {
+        (op, op._3.map(_.position).toList.min)
+      }).sortWith(_._2 < _._2).toList
+      val orderedOperations = new ListBuffer[Tuple3[String, String, ListBuffer[Operation]]]
+      s.foreach(op => {
+        val ops = op._1._3.sortWith(_.position < _.position)
+        orderedOperations += Tuple3(op._1._1, op._1._2, ops)
+      })
+      val apis = (for ((endpoint, resourcePath, operationList) <- orderedOperations) yield {
+        val orderedOperations = new ListBuffer[Operation]
+        operationList.sortWith(_.position < _.position).foreach(e => orderedOperations += e)
+        ApiDescription(
+          addLeadingSlash(endpoint),
+          None,
+          orderedOperations.toList)
+      }).toList
+      val models = ModelUtil.modelsFromApis(apis)
+      Some(ApiListing (
+        apiVersion = config.apiVersion,
+        swaggerVersion = config.swaggerVersion,
+        basePath = config.basePath,
+        resourcePath = addLeadingSlash(api.value),
+        apis = ModelUtil.stripPackages(apis),
+        models = models,
+        description = description,
+        produces = produces,
+        consumes = consumes,
+        protocols = protocols,
+        position = api.position)
+      )
+    }
+    else None
+  }
+
   override def read(docRoot: String, cls: Class[_], config: SwaggerConfig): Option[ApiListing] = {
     Logger("swagger").debug("ControllerReader: read(docRoot = %s, cls = %s, config = %s)".format(docRoot, cls.getName, config.toString))
     val api = cls.getAnnotation(classOf[Api])
@@ -353,10 +466,10 @@ class PlayApiReader(val routes: Option[Routes]) extends JaxrsApiReader {
    * @deprecated - do not be tempted to use this.... this is here to cover the method in the superclass.
    */
   @Deprecated
-  override def readMethod(method : java.lang.reflect.Method, parentParams : scala.List[com.wordnik.swagger.model.Parameter], parentMethods : scala.collection.mutable.ListBuffer[java.lang.reflect.Method]) : com.wordnik.swagger.model.Operation = {
+  override def readMethod(method: Method, parentParams : List[Parameter], parentMethods : ListBuffer[Method]) : Option[Operation] = {
    // don't use this - it is specific to Jax-RS models.
     throw new RuntimeException("method not in use..")
-   null
+    None
   }
 
   def findSubresourceType(method: Method): Class[_] = {