Release for Play2.2.x

README.md

@@ -19,23 +19,23 @@ For example, imagine that we want automatic DB transaction management, auth, and
 
 
 ```scala
-def TxAction(f: DBSession => Request[AnyContent] => Result): Action[AnyContent] = {
+def TxAction(f: DBSession => Request[AnyContent] => Future[SimpleResult]): Action[AnyContent] = {
   Action { request =>
     DB localTx { session =>
       f(session)(request)
     }
   }
 }
 
-def AuthAction(authority: Authority)(f: User => DBSession => Request[AnyContent] => Result): Action[AnyContent] = {
+def AuthAction(authority: Authority)(f: User => DBSession => Request[AnyContent] => Future[SimpleResult]): Action[AnyContent] = {
   TxAction { session => request =>
     val user: Either[Result, User] = authorized(authority)(request)
     user.right.map(u => f(u)(session)(request)).merge
   }
 }
 
 type Template = Html => Html
-def PjaxAction(authority: Authority)(f: Template => User => DBSession => Request[AnyContent] => Result): Action[AnyContent] = {
+def PjaxAction(authority: Authority)(f: Template => User => DBSession => Request[AnyContent] => Future[SimpleResult]): Action[AnyContent] = {
   AuthAction(authority) { user => session => request =>
     val template = if (req.headers.keys("X-Pjax")) views.html.pjaxTemplate.apply else views.html.fullTemplate.apply
     f(template)(user)(session)(request)
@@ -55,7 +55,7 @@ So far so good, but what if we need a new action that does both DB transaction m
 We have to create another PjaxAction.
 
 ```scala
-def PjaxAction(f: Template => DBSession => Request[AnyContent] => Result): Action[AnyContent] = {
+def PjaxAction(f: Template => DBSession => Request[AnyContent] => Future[SimpleResult]): Action[AnyContent] = {
   TxAction { session => request =>
     val template = if (req.headers.keys("X-Pjax")) html.pjaxTemplate.apply else views.html.fullTemplate.apply
     f(template)(session)(request)
@@ -79,7 +79,7 @@ As an alternative, this module offers Composable Action composition using the po
       case object AuthKey extends RequestAttributeKey[User]
       case object AuthorityKey extends RequestAttributeKey[Authority]
 
-      override def proceed[A](req: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Result): Result = {
+      override def proceed[A](req: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Future[SimpleResult]): Future[SimpleResult] = {
         (for {
           authority <- req.get(AuthorityKey).toRight(authorizationFailed(req)).right
           user      <- authorized(authority)(req).right
@@ -97,7 +97,7 @@ As an alternative, this module offers Composable Action composition using the po
 
       case object DBSessionKey extends RequestAttributeKey[DB]
 
-      abstract override def proceed[A](req: RequestWithAtrributes[A])(f: RequestWithAttributes[A] => Result): Result = {
+      abstract override def proceed[A](req: RequestWithAtrributes[A])(f: RequestWithAttributes[A] => Future[SimpleResult]): Future[SimpleResult] = {
         val db = DB.connect()
         db.begin()
         super.proceed(req.set(DBSessionKey, db))(f)
@@ -117,7 +117,7 @@ As an alternative, this module offers Composable Action composition using the po
         }
       }
 
-      override def cleanupOnFailed[A](req: RequestWithAttributes[A], e: Exception): Unit = {
+      override def cleanupOnFailed[A](req: RequestWithAttributes[A], e: Throwable): Unit = {
         try {
           req.getAs[DB](DBSessionKey).map { db =>
             db.rollbackIfActive()
@@ -141,7 +141,7 @@ As an alternative, this module offers Composable Action composition using the po
 
       case object TemplateKey extends RequestAttributeKey[Template]
 
-      override def proceed[A](req: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Result): Result = {
+      override def proceed[A](req: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Future[SimpleResult]): Future[SimpleResult] = {
         val template = if (req.headers.keys("X-Pjax")) views.html.pjaxTemplate else views.html.fullTemplate
         super.proceed(req.set(TemplateKey, template))(f)
       }

core/src/main/scala/jp/t2v/lab/play2/stackc/StackableController.scala

@@ -2,47 +2,48 @@ package jp.t2v.lab.play2.stackc
 
 import play.api.mvc._
 import scala.collection.concurrent.TrieMap
-import scala.concurrent.ExecutionContext
+import scala.concurrent.{Future, ExecutionContext}
 import scala.util.{Failure, Success}
 import scala.util.control.{NonFatal, ControlThrowable}
 
 trait StackableController {
     self: Controller =>
 
-  private object ExecutionContextKey extends RequestAttributeKey[ExecutionContext]
-
-  final def StackAction[A](p: BodyParser[A], params: (RequestAttributeKey[_], Any)*)(f: RequestWithAttributes[A] => Result)(implicit ctx: ExecutionContext = ExecutionContext.Implicits.global): Action[A] = Action(p) { req =>
-    val request = new RequestWithAttributes(req, new TrieMap[RequestAttributeKey[_], Any] ++= params += (ExecutionContextKey -> ctx))
-    try {
-      cleanup(request, proceed(request)(f))
-    } catch {
-      case e: ControlThrowable => cleanupOnSucceeded(request); throw e
-      case NonFatal(e: Exception) => cleanupOnFailed(request, e); throw e
+  final class StackActionBuilder(params: (RequestAttributeKey[_], Any)*) extends ActionBuilder[RequestWithAttributes] {
+    def invokeBlock[A](req: Request[A], block: (RequestWithAttributes[A]) => Future[SimpleResult]): Future[SimpleResult] = {
+      val request = new RequestWithAttributes(req, new TrieMap[RequestAttributeKey[_], Any] ++= params)
+      try {
+        cleanup(request, proceed(request)(block))(StackActionExecutionContext(request))
+      } catch {
+        case e: ControlThrowable => cleanupOnSucceeded(request); throw e
+        case NonFatal(e) => cleanupOnFailed(request, e); throw e
+      }
     }
   }
 
-  def StackAction(params: (RequestAttributeKey[_], Any)*)(f: RequestWithAttributes[AnyContent] => Result): Action[AnyContent] = StackAction(parse.anyContent, params: _*)(f)
+  final def AsyncStack[A](p: BodyParser[A], params: (RequestAttributeKey[_], Any)*)(f: RequestWithAttributes[A] => Future[SimpleResult]): Action[A] = new StackActionBuilder(params: _*).async(p)(f)
+  final def AsyncStack(params: (RequestAttributeKey[_], Any)*)(f: RequestWithAttributes[AnyContent] => Future[SimpleResult]): Action[AnyContent] = new StackActionBuilder(params: _*).async(f)
+  final def AsyncStack(f: RequestWithAttributes[AnyContent] => Future[SimpleResult]): Action[AnyContent] = new StackActionBuilder().async(f)
 
-  def StackAction(f: RequestWithAttributes[AnyContent] => Result): Action[AnyContent] = StackAction()(f)
+  final def StackAction[A](p: BodyParser[A], params: (RequestAttributeKey[_], Any)*)(f: RequestWithAttributes[A] => SimpleResult): Action[A] = new StackActionBuilder(params: _*).apply(p)(f)
+  final def StackAction(params: (RequestAttributeKey[_], Any)*)(f: RequestWithAttributes[AnyContent] => SimpleResult): Action[AnyContent] = new StackActionBuilder(params: _*).apply(f)
+  final def StackAction(f: RequestWithAttributes[AnyContent] => SimpleResult): Action[AnyContent] = new StackActionBuilder().apply(f)
 
-  def proceed[A](request: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Result): Result = f(request)
+  def proceed[A](request: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Future[SimpleResult]): Future[SimpleResult] = f(request)
 
   def cleanupOnSucceeded[A](request: RequestWithAttributes[A]): Unit = ()
 
-  def cleanupOnFailed[A](request: RequestWithAttributes[A], e: Exception): Unit = ()
+  def cleanupOnFailed[A](request: RequestWithAttributes[A], e: Throwable): Unit = ()
 
-  private def cleanup[A](request: RequestWithAttributes[A], result: Result)(implicit ctx: ExecutionContext): Result = result match {
-    case p: PlainResult => {cleanupOnSucceeded(request); p}
-    case AsyncResult(f) => AsyncResult {
-      f andThen {
-        case Success(r)            => cleanup(request, r)
-        case Failure(e: Exception) => cleanupOnFailed(request, e)
-      }
-    }
+  private def cleanup[A](request: RequestWithAttributes[A], result: Future[SimpleResult])(implicit ctx: ExecutionContext): Future[SimpleResult] = result andThen {
+    case Success(p) => cleanupOnSucceeded(request)
+    case Failure(e) => cleanupOnFailed(request, e)
   }
 
+  protected object ExecutionContextKey extends RequestAttributeKey[ExecutionContext]
+
   protected def StackActionExecutionContext(implicit req: RequestWithAttributes[_]): ExecutionContext =
-    req.get(ExecutionContextKey).getOrElse(ExecutionContext.Implicits.global)
+    req.get(ExecutionContextKey).getOrElse(play.api.libs.concurrent.Execution.defaultContext)
 
 }
 
@@ -64,3 +65,4 @@ class RequestWithAttributes[A](underlying: Request[A], attributes: TrieMap[Reque
   }
 
 }
+

project/Build.scala

@@ -6,7 +6,7 @@ object StackableControllerProjects extends Build {
 
   lazy val _organization = "jp.t2v"
 
-  lazy val _version = "0.2.1"
+  lazy val _version = "0.3.0-SNAPSHOT"
 
   def _publishTo(v: String) = {
     val nexus = "https://oss.sonatype.org/"
@@ -52,13 +52,13 @@ object StackableControllerProjects extends Build {
       organization := _organization,
       name := "stackable-controller",
       version := _version,
-      scalaVersion := "2.10.0",
+      scalaVersion := "2.10.2",
       publishTo <<= version { (v: String) => _publishTo(v) },
       publishMavenStyle := true,
       resolvers ++= _resolvers,
       libraryDependencies ++= Seq(
           // scope: compile
-          "play" %% "play" % "2.1.0"
+          "com.typesafe.play" %% "play" % "2.2.0-RC1"
       ),
       sbtPlugin := false,
       scalacOptions ++= _scalacOptions,
@@ -72,21 +72,21 @@ object StackableControllerProjects extends Build {
   lazy val sampleDependencies = Seq(
     // Add your project dependencies here,
     jdbc,
-    "play"               %% "play"                      % "2.1.0",
-    "jp.t2v"             %% "play21.auth"               % "0.7",
-    "com.github.seratch" %% "scalikejdbc"               % "[1.4,)",
-    "com.github.seratch" %% "scalikejdbc-interpolation" % "[1.4,)",
-    "com.github.seratch" %% "scalikejdbc-play-plugin"   % "[1.4,)",
+    "com.typesafe.play"  %% "play"                      % "2.2.0-RC1",
+//    "jp.t2v"             %% "play2.auth"                % "0.10.1",
+    "com.github.seratch" %% "scalikejdbc"               % "[1.6,)",
+    "com.github.seratch" %% "scalikejdbc-interpolation" % "[1.6,)",
+    "com.github.seratch" %% "scalikejdbc-play-plugin"   % "[1.6,)",
     "org.slf4j"          %  "slf4j-simple"              % "[1.7,)"
   )
 
   lazy val sample =  play.Project("sample", _version, sampleDependencies, path = file("sample")).settings(
-    scalaVersion := "2.10.0"
+    scalaVersion := "2.10.2"
     // Add your own project settings here
   ) dependsOn(core)
 
   lazy val root = Project(id = "root", base = file(".")).settings(
-    scalaVersion := "2.10.0"
+    scalaVersion := "2.10.2"
   ).aggregate(core, sample) 
 
 }

project/build.properties

@@ -1 +1 @@
-sbt.version=0.12.2
+sbt.version=0.13.0

project/plugins.sbt

@@ -5,4 +5,4 @@ logLevel := Level.Warn
 resolvers += "Typesafe repository" at "http://repo.typesafe.com/typesafe/releases/"
 
 // Use the Play sbt plugin for Play projects
-addSbtPlugin("play" % "sbt-plugin" % "2.1.0")
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.2.0-RC1")

sample/app/controllers/Application.scala

@@ -1,25 +1,25 @@
 package controllers
 
 import play.api.mvc._
-import jp.t2v.lab.play20.auth.Auth
 import models._
 import views._
 import controllers.stack._
+import jp.t2v.lab.play2.stackc.RequestWithAttributes
 
-object Application extends Controller with DBSessionElement with AuthElement with Auth with AuthConfigImpl {
+object Application extends Controller with DBSessionElement {
 
   def index = Action {
     Ok(views.html.index("Your new application is ready."))
   }
 
-  def messages = StackAction(AuthorityKey -> NormalUser) { implicit req =>
+  def messages = StackAction { implicit req =>
     val messages = Message.findAll
-    Ok(html.messages(messages)(loggedIn))
+    Ok(views.html.messages(messages))
   }
 
-  def editMessage(id: MessageId) = StackAction(AuthorityKey -> Administrator) { implicit req =>
+  def editMessage(id: MessageId) = StackAction { implicit req =>
     val messages = Message.findAll
-    Ok(html.messages(messages)(loggedIn))
+    Ok(views.html.messages(messages))
   }
 
 }

sample/app/controllers/stack/DBSessionElement.scala

@@ -1,15 +1,16 @@
 package controllers.stack
 
-import play.api.mvc.{Result, Controller}
+import play.api.mvc.{SimpleResult, Result, Controller}
 import scalikejdbc._
 import jp.t2v.lab.play2.stackc.{RequestWithAttributes, RequestAttributeKey, StackableController}
+import scala.concurrent.Future
 
 trait DBSessionElement extends StackableController {
     self: Controller =>
 
   case object DBSessionKey extends RequestAttributeKey[(DB, DBSession)]
 
-  override def proceed[A](req: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Result): Result = {
+  override def proceed[A](req: RequestWithAttributes[A])(f: RequestWithAttributes[A] => Future[SimpleResult]): Future[SimpleResult] = {
     val db = DB.connect()
     val tx = db.newTx
     tx.begin()
@@ -27,7 +28,7 @@ trait DBSessionElement extends StackableController {
     }
   }
 
-  override def cleanupOnFailed[A](req: RequestWithAttributes[A], e: Exception): Unit = {
+  override def cleanupOnFailed[A](req: RequestWithAttributes[A], e: Throwable): Unit = {
     try {
       req.get(DBSessionKey).map { case (db, session) =>
         db.currentTx.rollback()

sample/app/views/messages.scala.html

@@ -1,4 +1,4 @@
-@(messages: Seq[Message])(account: Account)
+@(messages: Seq[Message])
 
 @main("Messages") {