Merge branch 'master' of https://github.com/ngocdaothanh/xitrum

Author: Dao Ngoc

CHANGELOG

@@ -1,11 +1,18 @@
-2.13 (planned):
+2.14:
+* #244 Easier way to get request content as string and JSON
+* #245 Rename "atJs" to "atJson"
+* #248 Collect all routes
+* #249 Improve inheritance rule of route annotations
+* #250 CORS allow-origin should not be set for domain not specified in xitrum.conf
+
+2.13:
+* #239 Readd feature: One action can have multiple routes
+* #236 Remove Swagger related routes when it is disabled
+* #145 Split Knockout.js to a separate module
 * #234 xitrum.js: Fix bug XITRUM_BASE_URL does not exist
 * #237 xitrum.js: Add withBaseUrl
-* #239 Readd feature: One action can have multiple routes
 * #242 Add atJs; atJs("key") returns the JSON form of at("key")
-* #236 Remove Swagger related routes when it is disabled
 * #238 CSRF token can be set in header
-* #145 Split Knockout.js to a separate module
 
 2.12:
 * #230 Fix bug Routes with trailing '/' are not matched

build.sbt

@@ -2,7 +2,7 @@ organization := "tv.cntt"
 
 name := "xitrum"
 
-version := "2.13-SNAPSHOT"
+version := "2.14-SNAPSHOT"
 
 scalaVersion := "2.10.3"
 

dev/README.rst

@@ -60,14 +60,21 @@ Create dependency graph
 Demo:
 http://ngocdaothanh.github.io/xitrum/guide/deps.html
 
-See https://github.com/jrudolph/sbt-dependency-graph.
+Generate target/dependencies-compile.dot:
+
+::
+
+  sbt dependency-dot
 
 Convert dependencies-compile.dot to deps.png:
 
 ::
 
   dot -Tpng dependencies-compile.dot > deps.png
 
+See:
+https://github.com/jrudolph/sbt-dependency-graph.
+
 Publish to local
 ----------------
 

project/plugins.sbt

@@ -1,5 +1,5 @@
-// Run sbt/sbt eclipse to create Eclipse project file
+// Run sbt eclipse to create Eclipse project file
 addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "2.4.0")
 
-// Run sbt/sbt gen-idea to create IntelliJ project file
+// Run sbt gen-idea to create IntelliJ project file
 addSbtPlugin("com.github.mpeltonen" % "sbt-idea" % "1.5.2")

src/main/scala/xitrum/annotation/ActionAnnotations.scala

@@ -38,6 +38,37 @@ object ActionAnnotations {
   val typeOfCachePageHour   = universe.typeOf[CachePageHour]
   val typeOfCachePageMinute = universe.typeOf[CachePageMinute]
   val typeOfCachePageSecond = universe.typeOf[CachePageSecond]
+
+  def fromUniverse(annotations: Seq[universe.Annotation]): ActionAnnotations = {
+    var ret = ActionAnnotations()
+
+    annotations.foreach { a =>
+      val tpe = a.tpe
+
+      if (tpe <:< typeOfRoute)
+        ret = ret.copy(routes = ret.routes :+ a)
+
+      else if (tpe <:< typeOfRouteOrder)
+        ret = ret.copy(routeOrder = Some(a))
+
+      else if (tpe <:< typeOfSockJsCookieNeeded)
+        ret = ret.copy(sockJsCookieNeeded = Some(a))
+
+      else if (tpe <:< typeOfSockJsNoWebSocket)
+        ret = ret.copy(sockJsNoWebSocket = Some(a))
+
+      else if (tpe <:< typeOfError)
+        ret = ret.copy(error = Some(a))
+
+      else if (tpe <:< typeOfCache)
+        ret = ret.copy(cache = Some(a))
+
+      else if (tpe <:< typeOfSwagger)
+        ret = ret.copy(swaggers = ret.swaggers :+ a)
+    }
+
+    ret
+  }
 }
 
 case class ActionAnnotations(
@@ -55,41 +86,42 @@ case class ActionAnnotations(
 ) {
   import ActionAnnotations._
 
-  def overrideMe(other: ActionAnnotations) = ActionAnnotations(
-    routes ++ other.routes,
-    other.routeOrder         orElse routeOrder,
-    other.sockJsCookieNeeded orElse sockJsCookieNeeded,
-    other.sockJsNoWebSocket  orElse sockJsNoWebSocket,
-    other.error              orElse error,
-    other.cache              orElse cache,
-    swaggers ++ other.swaggers
+  /**
+   * Only inherit sockJsCookieNeeded, sockJsNoWebSocket, cache, and swaggers.
+   * Do not inherit routes, routeOrder, and error.
+   * Current values if exist will override those in ancestor.
+   */
+  def inherit(ancestor: ActionAnnotations) = ActionAnnotations(
+    routes,
+    routeOrder,
+    sockJsCookieNeeded orElse ancestor.sockJsCookieNeeded,
+    sockJsNoWebSocket  orElse ancestor.sockJsNoWebSocket,
+    error,
+    cache              orElse ancestor.cache,
+    ancestor.swaggers ++ swaggers
   )
 
-  def overrideMe(annotations: Seq[universe.Annotation]): ActionAnnotations = {
+  /**
+   * Only inherit sockJsCookieNeeded, sockJsNoWebSocket, cache, and swaggers.
+   * Do not inherit routes, routeOrder, and error.
+   * Current values if exist will override those in ancestor.
+   */
+  def inherit(annotations: Seq[universe.Annotation]): ActionAnnotations = {
     var ret = this
     annotations.foreach { a =>
       val tpe = a.tpe
 
-      if (tpe <:< typeOfRoute)
-        ret = ret.copy(routes = ret.routes :+ a)
-
-      else if (tpe <:< typeOfRouteOrder)
-        ret = ret.copy(routeOrder = Some(a))
-
-      else if (tpe <:< typeOfSockJsCookieNeeded)
+      if (sockJsCookieNeeded.isEmpty && tpe <:< typeOfSockJsCookieNeeded)
         ret = ret.copy(sockJsCookieNeeded = Some(a))
 
-      else if (tpe <:< typeOfSockJsNoWebSocket)
+      else if (sockJsNoWebSocket.isEmpty && tpe <:< typeOfSockJsNoWebSocket)
         ret = ret.copy(sockJsNoWebSocket = Some(a))
 
-      else if (tpe <:< typeOfError)
-        ret = ret.copy(error = Some(a))
-
-      else if (tpe <:< typeOfCache)
+      else if (cache.isEmpty && tpe <:< typeOfCache)
         ret = ret.copy(cache = Some(a))
 
       else if (tpe <:< typeOfSwagger)
-        ret = ret.copy(swaggers = ret.swaggers :+ a)
+        ret = ret.copy(swaggers = a +: ret.swaggers)
     }
     ret
   }

src/main/scala/xitrum/handler/down/SetCORS.scala

@@ -48,10 +48,7 @@ class SetCORS extends ChannelDownstreamHandler with Log {
           else
             HttpHeaders.setHeader(response, ACCESS_CONTROL_ALLOW_ORIGIN, requestOrigin)
         } else {
-          if (corsAllowOrigins.contains(requestOrigin))
-            HttpHeaders.setHeader(response, ACCESS_CONTROL_ALLOW_ORIGIN, requestOrigin)
-          else
-            HttpHeaders.setHeader(response, ACCESS_CONTROL_ALLOW_ORIGIN, corsAllowOrigins.mkString(", "))
+          if (corsAllowOrigins.contains(requestOrigin)) HttpHeaders.setHeader(response, ACCESS_CONTROL_ALLOW_ORIGIN, requestOrigin)
         }
       }
 

src/main/scala/xitrum/routing/ActionTreeBuilder.scala

@@ -1,5 +1,6 @@
 package xitrum.routing
 
+import java.lang.reflect.Modifier
 import scala.collection.mutable.ArrayBuffer
 import scala.reflect.runtime.universe
 
@@ -10,43 +11,46 @@ import xitrum.annotation.ActionAnnotations
  * Intended for use by RouteCollector.
  *
  * For each .class file, RouteCollector uses ASM's ClassReader to load it, then
- * calls "addBranches" to pass its class name and interface names. Action is a
- * trait. Traits are seen by ASM as interfaces. At this step, we build trees of
- * interface -> children.
+ * calls "addBranches" to pass its class name, super class name, and interface names.
+ * At this step, we build trees of parent -> children.
  *
  * Lastly, RouteCollector calls "getConcreteActionsAndAnnotations" to get
- * concrete (non-trait) action classes and their annotations.
+ * concrete (non-trait, non-abstract) action classes and their annotations.
  *
  * This class is immutable because it will be serialized to routes.cache.
  *
- * @param interface2Children Map to save trees; names are class names
+ * @param parent2Children Map to save trees; names are class names
  */
-private case class ActionTreeBuilder(interface2Children: Map[String, Seq[String]] = Map()) {
+private case class ActionTreeBuilder(parent2Children: Map[String, Seq[String]] = Map()) {
   def addBranches(
-      childInternalName:   String,
-      parentInternalNames: Array[String]
+      childInternalName:      String,
+      superInternalName:      String,
+      interfaceInternalNames: Array[String]
   ): ActionTreeBuilder = {
-    // Class name: xitrum.Action
-    // Internal name: xitrum/Action
-    def internalName2ClassName(internalName: String) = internalName.replace('/', '.')
+    if (superInternalName == null || interfaceInternalNames == null) return this
 
-    if (parentInternalNames == null) return this
+    // Optimize: Ignore Java and Scala default classes; these can be thousands
+    if (childInternalName.startsWith("java/")  ||
+        childInternalName.startsWith("javax/") ||
+        childInternalName.startsWith("scala/") ||
+        childInternalName.startsWith("sun/")   ||
+        childInternalName.startsWith("com/sun/")) return this
 
-    val childClassName = internalName2ClassName(childInternalName)
+    val parentInternalNames = Seq(superInternalName) ++ interfaceInternalNames
+    val parentClassNames    = parentInternalNames.map(internalName2ClassName _)
 
-    var i2c = interface2Children
-    parentInternalNames.foreach { parentInternalName =>
-      val parentClassName = internalName2ClassName(parentInternalName)
-      if (interface2Children.isDefinedAt(parentClassName)) {
-        val children    = interface2Children(parentClassName)
+    val childClassName = internalName2ClassName(childInternalName)
+    val p2c            = parentClassNames.foldLeft(parent2Children) { case (acc, parentClassName) =>
+      if (acc.isDefinedAt(parentClassName)) {
+        val children    = parent2Children(parentClassName)
         val newChildren = children :+ childClassName
-        i2c += parentClassName -> newChildren
+        acc + (parentClassName -> newChildren)
       } else {
-        i2c += parentClassName -> Seq(childClassName)
+        acc + (parentClassName -> Seq(childClassName))
       }
     }
 
-    ActionTreeBuilder(i2c)
+    ActionTreeBuilder(p2c)
   }
 
   /**
@@ -69,19 +73,22 @@ private case class ActionTreeBuilder(interface2Children: Map[String, Seq[String]
         case Some(aa) => aa
 
         case None =>
-          val parents = klass.getInterfaces
-          val parentAnnotations = parents.foldLeft(ActionAnnotations()) { case (acc, parent) =>
-            if (classOf[Action].isAssignableFrom(parent)) {
-              val aa = getActionAccumulatedAnnotations(parent.asInstanceOf[Class[_ <: Action]])
-              acc.overrideMe(aa)
+          val parentClasses     = Seq(klass.getSuperclass) ++ klass.getInterfaces
+          val parentAnnotations = parentClasses.foldLeft(ActionAnnotations()) { case (acc, parentClass) =>
+            // parentClass is null if klass is a trait/interface
+            if (parentClass == null) {
+              acc
+            } else if (classOf[Action].isAssignableFrom(parentClass)) {
+              val aa = getActionAccumulatedAnnotations(parentClass.asInstanceOf[Class[_ <: Action]])
+              acc.inherit(aa)
             } else {
               acc
             }
           }
 
-          val annotations = runtimeMirror.classSymbol(klass).asClass.annotations
-          val ret         = parentAnnotations.overrideMe(annotations)
-
+          val universeAnnotations = runtimeMirror.classSymbol(klass).asClass.annotations
+          val thisAnnotationsOnly = ActionAnnotations.fromUniverse(universeAnnotations)
+          val ret                 = thisAnnotationsOnly.inherit(parentAnnotations)
           cache += klass -> ret
           ret
       }
@@ -92,15 +99,20 @@ private case class ActionTreeBuilder(interface2Children: Map[String, Seq[String]
 
   //----------------------------------------------------------------------------
 
+  // Class name: xitrum.Action
+  // Internal name: xitrum/Action
+  private def internalName2ClassName(internalName: String) = internalName.replace('/', '.')
+
   private def getConcreteActions: Set[Class[_ <: Action]] = {
     var concreteActions = Set[Class[_ <: Action]]()
 
     def traverseActionTree(className: String) {
-      if (interface2Children.isDefinedAt(className)) {
-        val children = interface2Children(className)
+      if (parent2Children.isDefinedAt(className)) {
+        val children = parent2Children(className)
         children.foreach { className =>
-          val klass = Class.forName(className).asInstanceOf[Class[_ <: Action]]
-          if (!klass.isInterface) concreteActions += klass  // Not interface => concrete
+          val klass    = Class.forName(className)
+          val concrete = !klass.isInterface && !Modifier.isAbstract(klass.getModifiers)
+          if (concrete) concreteActions += klass.asInstanceOf[Class[_ <: Action]]
           traverseActionTree(className)
         }
       }

src/main/scala/xitrum/routing/RouteCollector.scala

@@ -45,7 +45,7 @@ class RouteCollector extends Log {
     try {
       if (entry.relPath.endsWith(".class")) {
         val reader = new ClassReader(entry.bytes)
-        acc.addBranches(reader.getClassName, reader.getInterfaces)
+        acc.addBranches(reader.getClassName, reader.getSuperName, reader.getInterfaces)
       } else {
         acc
       }

src/main/scala/xitrum/scope/request/RequestEnv.scala

@@ -5,6 +5,7 @@ import scala.collection.mutable.{Map => MMap}
 import xitrum.{Config, Action}
 import xitrum.handler.HandlerEnv
 import xitrum.routing.Route
+import xitrum.util.Json
 
 object RequestEnv {
   def inspectParamsWithFilter(params: MMap[String, _ <: Seq[AnyRef]]): String = {
@@ -73,5 +74,14 @@ trait RequestEnv extends ParamAccess {
 
   lazy val at = new At
 
-  def atJs(key: String) = at.toJson(key)
+  def atJson(key: String) = at.toJson(key)
+
+  lazy val requestContentString = {
+    val channelBuffer = request.getContent
+    channelBuffer.toString(Config.xitrum.request.charset)
+  }
+
+  /** Ex: val json = requestContentJson[Map[String, String]] */
+  def requestContentJson[T](implicit m: Manifest[T]): T =
+    Json.parse[T](requestContentString)(m)
 }

src/main/scala/xitrum/view/Responder.scala

@@ -347,8 +347,7 @@ trait Responder extends Js with Flash {
 
   /**
    * To respond event source, call this method as many time as you want.
-   * Event Source response is a special kind of chunked response.
-   * Data must be Must be  UTF-8.
+   * Event Source response is a special kind of chunked response, data must be UTF-8.
    * See:
    * - http://sockjs.github.com/sockjs-protocol/sockjs-protocol-0.3.3.html#section-94
    * - http://dev.w3.org/html5/eventsource/