change to play 2.3.2

app/controllers/Mock.scala

@@ -1,6 +1,6 @@
 package controllers
 
-import play.api.mvc.{Controller, SimpleResult, Action}
+import play.api.mvc.{Controller, Result, Action}
 import scala.concurrent.Future
 import play.api.libs.concurrent.Promise
 import play.api.libs.concurrent.Execution.Implicits._
@@ -14,15 +14,15 @@ object Mock extends Controller {
 
   def mock(serviceName: String) = Action.async {
     serviceName match {
-      case "wvyp" => respond(data = "56", delay = 10)
+      case "wvyp" => respond(data = "56", delay = 10000)
       case "search" => respond(data = "10", delay = 3000)
       case "likes" => respond(data = "150", delay = 40)
       case "comments" => respond(data = "14", delay = 20)
     }
 
   }
 
-  private def respond(data: String, delay: Long): Future[SimpleResult] = {
+  private def respond(data: String, delay: Long): Future[Result] = {
     Promise.timeout(Ok(data), delay)
   }
 }

app/controllers/WvypStreamJava.java

@@ -1,7 +1,7 @@
 package controllers;
 
 import data.ServiceClientJ;
-import play.api.templates.Html;
+import play.twirl.api.Html;
 import play.libs.F;
 import play.mvc.Controller;
 import play.mvc.Result;

app/data/ServiceClient.scala

@@ -2,6 +2,7 @@ package data
 
 import scala.concurrent.Future
 import play.api.libs.ws.WS
+import play.api.Play.current
 import play.api.libs.concurrent.Execution.Implicits._
 
 /**

app/data/ServiceClientJ.java

@@ -1,16 +1,17 @@
 package data;
 
 import play.libs.F;
-import play.libs.WS;
+import play.libs.ws.WS;
+import play.libs.ws.WSResponse;
 
 public class ServiceClientJ
 {
   public static F.Promise<String> makeServiceCall(String serviceName)
   {
-    return WS.url("http://localhost:9000/mock/" + serviceName).get().map(new F.Function<WS.Response, String>()
+    return WS.url("http://localhost:9000/mock/" + serviceName).get().map(new F.Function<WSResponse, String>()
     {
       @Override
-      public String apply(WS.Response response) throws Throwable
+      public String apply(WSResponse response) throws Throwable
       {
         return response.getBody();
       }

app/ui/HtmlStream.scala

@@ -1,14 +1,15 @@
 package ui
 
 import play.api.libs.iteratee.{Iteratee, Enumeratee, Enumerator}
-import play.api.templates.{HtmlFormat, Html}
-import play.templates.{Format, Appendable}
+import play.twirl.api.{HtmlFormat, Html}
+import play.twirl.api.{Format, Appendable}
 import scala.concurrent.Future
-import play.api.mvc.{Codec, SimpleResult}
+import play.api.mvc.{Codec, Result}
 import play.api.libs.concurrent.Execution.Implicits._
 import play.mvc.Results.Chunks.Out
 import play.api.http.{Writeable, ContentTypeOf}
 import play.mvc.Results.Chunks
+import scala.language.implicitConversions
 
 /**
  * A custom Appendable that lets us have .scala.stream templates instead of .scala.html. These templates can mix Html
@@ -58,22 +59,22 @@ object HtmlStream {
   }
 
   /**
-   * Create an HtmlStream from the body of the SimpleResult.
+   * Create an HtmlStream from the body of the Result.
    *
    * @param result
    * @return
    */
-  def fromResult(result: SimpleResult): HtmlStream = {
+  def fromResult(result: Result): HtmlStream = {
     HtmlStream(result.body.map(bytes => Html(new String(bytes, "UTF-8"))))
   }
 
   /**
-   * Create an HtmlStream from a the body of a Future[SimpleResult].
+   * Create an HtmlStream from a the body of a Future[Result].
    *
    * @param result
    * @return
    */
-  def fromResult(result: Future[SimpleResult]): HtmlStream = {
+  def fromResult(result: Future[Result]): HtmlStream = {
     flatten(result.map(fromResult))
   }
 
@@ -144,6 +145,11 @@ object HtmlStreamFormat extends Format[HtmlStream] {
   def escape(text: String): HtmlStream = {
     raw(HtmlFormat.escape(text).body)
   }
+
+  def empty: HtmlStream = HtmlStream("")
+
+  def fill(elements: scala.collection.immutable.Seq[HtmlStream]): HtmlStream = HtmlStream.interleave(elements:_*)
+
 }
 
 /**

app/ui/Pagelet.scala

@@ -1,9 +1,9 @@
 package ui
 
-import play.api.templates.Html
+import play.twirl.api.Html
 import scala.concurrent.Future
 import play.api.libs.concurrent.Execution.Implicits._
-import play.api.mvc.{Cookie, Cookies, Codec, SimpleResult}
+import play.api.mvc.{Cookie, Cookies, Codec, Result}
 import play.api.libs.iteratee.Iteratee
 import play.api.http.HeaderNames
 import play.libs.F.Promise
@@ -14,14 +14,14 @@ import play.libs.F.Promise
 object Pagelet {
 
   /**
-   * Read the body of a SimpleResult as Html. Since the body is an Enumerator and may not be available yet, this method
+   * Read the body of a Result as Html. Since the body is an Enumerator and may not be available yet, this method
    * returns a Future.
    *
    * @param result
    * @param codec
    * @return
    */
-  def readBody(result: SimpleResult)(implicit codec: Codec): Future[Html] = {
+  def readBody(result: Result)(implicit codec: Codec): Future[Html] = {
     result.body.run(Iteratee.consume()).map(bytes => Html(new String(bytes, codec.charset)))
   }
 
@@ -31,7 +31,7 @@ object Pagelet {
    * @param results
    * @return
    */
-  def mergeCookies(results: SimpleResult*): Seq[Cookie] = {
+  def mergeCookies(results: Result*): Seq[Cookie] = {
     results.flatMap(result => result.header.headers.get(HeaderNames.SET_COOKIE).map(Cookies.decode).getOrElse(Seq.empty))
   }
 

app/ui/StaticContent.scala

@@ -1,7 +1,7 @@
 package ui
 
-import play.api.mvc.SimpleResult
-import play.api.templates.Html
+import play.api.mvc.Result
+import play.twirl.api.Html
 import scala.concurrent.Future
 import play.api.libs.concurrent.Execution.Implicits._
 
@@ -29,7 +29,7 @@ object StaticContent {
    * @param results
    * @return
    */
-  def mergeCssHeaders(results: SimpleResult*): Seq[String] = {
+  def mergeCssHeaders(results: Result*): Seq[String] = {
     mergeHeaderValues(cssHeaderName, parseCssHeader, results:_*)
   }
 
@@ -39,11 +39,11 @@ object StaticContent {
    * @param results
    * @return
    */
-  def mergeJsHeaders(results: SimpleResult*): Seq[String] = {
+  def mergeJsHeaders(results: Result*): Seq[String] = {
     mergeHeaderValues(jsHeaderName, parseJsHeader, results:_*)
   }
 
-  private def mergeHeaderValues(headerName: String, parseHeader: SimpleResult => Seq[String], results: SimpleResult*): Seq[String] = {
+  private def mergeHeaderValues(headerName: String, parseHeader: Result => Seq[String], results: Result*): Seq[String] = {
     results.flatMap(parseHeader).distinct
   }
 
@@ -53,15 +53,15 @@ object StaticContent {
    * @param result
    * @return
    */
-  def parseCssHeader(result: SimpleResult): Seq[String] = parseHeader(cssHeaderName, result)
+  def parseCssHeader(result: Result): Seq[String] = parseHeader(cssHeaderName, result)
 
   /**
    * Read the JS header from the given Result, which should define the CSS dependencies for the Result
    *
    * @param result
    * @return
    */
-  def parseJsHeader(result: SimpleResult): Seq[String] = parseHeader(jsHeaderName, result)
+  def parseJsHeader(result: Result): Seq[String] = parseHeader(jsHeaderName, result)
 
   /**
    * Render the given sequence of CSS URLs as link tags
@@ -85,7 +85,7 @@ object StaticContent {
    * @param results
    * @return
    */
-  def mergeJsFromResults(results: Future[SimpleResult]*): HtmlStream = {
+  def mergeJsFromResults(results: Future[Result]*): HtmlStream = {
     mergeDependenciesFromResults(parseJsHeader, renderJsDependencies, results)
   }
 
@@ -95,15 +95,15 @@ object StaticContent {
    * @param results
    * @return
    */
-  def mergeCssFromResults(results: Future[SimpleResult]*): HtmlStream = {
+  def mergeCssFromResults(results: Future[Result]*): HtmlStream = {
     mergeDependenciesFromResults(parseCssHeader, renderCssDependencies, results)
   }
 
-  private def parseHeader(headerName: String, result: SimpleResult): Seq[String] = {
+  private def parseHeader(headerName: String, result: Result): Seq[String] = {
     result.header.headers.get(headerName).map(_.split(",").toVector).getOrElse(Vector.empty)
   }
 
-  private def mergeDependenciesFromResults(parseHeader: SimpleResult => Seq[String], render: Seq[String] => Html, resultFutures: Seq[Future[SimpleResult]]): HtmlStream = {
+  private def mergeDependenciesFromResults(parseHeader: Result => Seq[String], render: Seq[String] => Html, resultFutures: Seq[Future[Result]]): HtmlStream = {
     val allResultsFuture = Future.sequence(resultFutures)
 
     val htmlFuture = allResultsFuture.map { results =>

build.sbt

@@ -2,14 +2,20 @@ name := "ping-conference"
 
 version := "1.0-SNAPSHOT"  
 
-play.Project.playScalaSettings
+scalaVersion := "2.11.1"
+
+lazy val root = (project in file(".")).enablePlugins(PlayScala)
 
 // Add a new template type for streaming templates
-play.Keys.templatesTypes ++= Map("stream" -> "ui.HtmlStreamFormat")
+play.twirl.sbt.Import.TwirlKeys.templateFormats ++= Map("stream" -> "ui.HtmlStreamFormat")
 
 // Add some useful default imports for streaming templates
-play.Keys.templatesImport ++= Vector("_root_.ui.HtmlStream", "_root_.ui.HtmlStream._", "_root_.ui.StaticContent")
+play.twirl.sbt.Import.TwirlKeys.templateImports ++= Vector("_root_.ui.HtmlStream", "_root_.ui.HtmlStream._")
 
 libraryDependencies ++= Seq(
+  ws,
+  javaWs,
   "com.typesafe.play" %% "play-java" % play.core.PlayVersion.current
-)
+)
+
+scalacOptions += "-feature"

project/build.properties

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

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("com.typesafe.play" % "sbt-plugin" % "2.2.1")
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.3.2")