Migrate to 2.6.0 (#111)

* Migrate to Play 2.6.0

This was done against a local snapshot in order to validate our
Migration docs:

https://playframework.com/documentation/2.6.x/Migration26

Except some minor details, all the changes here are already
documented at the page above.

* Remove use of deprecated APIs

This is not documented at the migration guide, but the user
would be guided by the deprecated messages.

* Update to Play RC1

* Remove unnecessary self type

* Remove deprecated APIs calls

* Remove actor

* Update sbt-web plugins

* Proper CSP configuration

* Fix merge problems

* Fix scalacOptions config

Author: marcospereira

app/actors/Actors.scala

@@ -2,14 +2,13 @@ package actors
 
 import java.io.File
 
-import akka.actor.{ ActorSystem, ActorRef }
-import javax.inject.{Provider, Inject, Singleton}
 import com.google.inject.AbstractModule
+import com.typesafe.config.Config
+import javax.inject.{Inject, Provider, Singleton}
 import models.documentation._
 import play.api._
-import play.api.i18n.{MessagesApi, Lang}
-import play.api.libs.concurrent.{AkkaGuiceSupport, Akka}
-import scala.collection.JavaConversions._
+import play.api.i18n.Lang
+import play.api.libs.concurrent.AkkaGuiceSupport
 
 class ActorsModule extends AbstractModule with AkkaGuiceSupport {
   def configure() = {
@@ -21,56 +20,55 @@ class ActorsModule extends AbstractModule with AkkaGuiceSupport {
 }
 
 @Singleton
-class DocumentationRedirectsProvider @Inject() (configuration: Configuration) extends Provider[DocumentationRedirects] {
-  override def get: DocumentationRedirects = {
-    configuration.getConfigList("documentation.redirects") match {
-      case Some(redirectsConfig) => DocumentationRedirects(
-        redirectsConfig.map { config =>
-          RedirectPage(
-            from = config.getString("from").getOrElse(""),
-            to = config.getString("to").getOrElse("")
-          )
-        }
+class DocumentationRedirectsProvider @Inject()(configuration: Configuration) extends Provider[DocumentationRedirects] {
+  override def get: DocumentationRedirects = DocumentationRedirects(
+    configuration.get[Seq[Config]]("documentation.redirects").map { config =>
+      RedirectPage(
+        from = config.getString("from"),
+        to = config.getString("to")
       )
-      case None => DocumentationRedirects(Seq.empty)
     }
-  }
+  )
 }
 
 @Singleton
 class DocumentationConfigProvider @Inject() (environment: Environment, configuration: Configuration) extends Provider[DocumentationConfig] {
 
-  lazy val get = loadConfig.getOrElse(DocumentationConfig(
+  lazy val get: DocumentationConfig = loadConfig.getOrElse(DocumentationConfig(
     TranslationConfig(Lang("en"), environment.rootPath, None, "origin", None, None), Nil))
 
   private def loadConfig: Option[DocumentationConfig] = {
     for {
-      docsConfig <- configuration.getConfig("documentation")
-      path <- docsConfig.getString("path").map(basePath)
-      mainConfig <- docsConfig.getConfig("main")
+      docsConfig <- configuration.getOptional[Configuration]("documentation")
+      path <- docsConfig.getOptional[String]("path").map(basePath)
+      mainConfig <- docsConfig.getOptional[Configuration]("main")
       mainTranslation <- loadTranslationConfig(path, mainConfig)
-      translations <- docsConfig.getConfigList("translations")
+      translations <- docsConfig.getOptional[Seq[Config]]("translations")
     } yield {
       DocumentationConfig(mainTranslation,
         translations.toList.collect(Function.unlift(loadTranslationConfig(path, _))))
     }
   }
 
+  private def loadTranslationConfig(base: File, config: Config): Option[TranslationConfig] = {
+    loadTranslationConfig(base, Configuration(config))
+  }
+
   private def loadTranslationConfig(base: File, config: Configuration): Option[TranslationConfig] = {
     for {
-      lang <- config.getString("lang")
-      repo <- config.getString("repo") if verifyTranslationPath(base, repo, lang)
+      lang <- config.getOptional[String]("lang")
+      repo <- config.getOptional[String]("repo") if verifyTranslationPath(base, repo, lang)
     } yield {
       TranslationConfig(
         Lang(lang),
         new File(base, repo).getCanonicalFile,
-        config.getString("path"),
-        config.getString("remote").getOrElse("origin"),
+        config.getOptional[String]("path"),
+        config.getOptional[String]("remote").getOrElse("origin"),
         for {
-          file <- config.getString("versionFile")
-          pattern <- config.getString("versionPattern")
+          file <- config.getOptional[String]("versionFile")
+          pattern <- config.getOptional[String]("versionPattern")
         } yield MasterVersion(file, pattern.r),
-        config.getString("gitHubSource")
+        config.getOptional[String]("gitHubSource")
       )
     }
   }

app/assets/javascripts/munchkin.js

@@ -0,0 +1,20 @@
+(function () {
+    var didInit = false;
+    function initMunchkin() {
+        if (didInit === false) {
+            didInit = true;
+            Munchkin.init('558-NCX-702');
+        }
+    }
+    var s = document.createElement('script');
+    s.type = 'text/javascript';
+    s.async = true;
+    s.src = '//munchkin.marketo.net/munchkin.js';
+    s.onreadystatechange = function () {
+        if (this.readyState == 'complete' || this.readyState == 'loaded') {
+            initMunchkin();
+        }
+    };
+    s.onload = initMunchkin;
+    document.getElementsByTagName('head')[0].appendChild(s);
+})();

app/controllers/Application.scala

@@ -7,8 +7,8 @@ import models._
 import models.certification.Certification
 import org.apache.commons.io.IOUtils
 import play.api._
-import play.api.cache.CacheApi
-import play.api.i18n.{I18nSupport, Lang, MessagesApi}
+import play.api.cache.SyncCacheApi
+import play.api.i18n.{I18nSupport, Lang}
 import play.api.mvc._
 import play.twirl.api.Html
 import services.certification.CertificationDao
@@ -21,12 +21,12 @@ import scala.concurrent.{ExecutionContext, Future}
 class Application @Inject() (
   environment: Environment,
   configuration: Configuration,
-  val messagesApi: MessagesApi,
   certificationDao: CertificationDao,
   releases: PlayReleases,
   exampleProjectsService: PlayExampleProjectsService,
-  cacheApi: CacheApi
-)(implicit ec: ExecutionContext) extends Controller with Common with I18nSupport {
+  components: ControllerComponents,
+  cacheApi: SyncCacheApi
+)(implicit ec: ExecutionContext, val reverseRouter: documentation.ReverseRouter) extends AbstractController(components) with Common with I18nSupport {
 
   private val VulnerableVersions = Set(
     "2.0", "2.0.1", "2.0.2", "2.0.3", "2.0.4", "2.0.5",
@@ -84,7 +84,7 @@ class Application @Inject() (
     val selectedPlatform = Platform(platform.orElse(request.headers.get("User-Agent")))
     Ok(html.allreleases(releases, selectedPlatform))
   }
-  
+
   def changelog = markdownAction("public/markdown/changelog.md", { implicit request =>
     views.html.changelog(_)
   })

app/controllers/Code.scala

@@ -1,11 +1,15 @@
 package controllers
 
 import javax.inject.Inject
-import play.api.mvc._
-import play.api.libs.concurrent.Execution.Implicits._
+
+import play.api.mvc.{AbstractController, ControllerComponents}
 import services.github.ContributorsSummariser
 
-class Code @Inject() (contributorsSummariser: ContributorsSummariser) extends Controller {
+import scala.concurrent.ExecutionContext
+
+class Code @Inject() (
+  contributorsSummariser: ContributorsSummariser,
+  components: ControllerComponents)(implicit executionContext: ExecutionContext, reverseRouter: documentation.ReverseRouter) extends AbstractController(components) {
 
   def index = Action.async { implicit req =>
     contributorsSummariser.fetchContributors.map { contributors =>

app/controllers/Common.scala

@@ -1,9 +1,10 @@
 package controllers
 
 import play.api.mvc._
+import play.api.mvc.Results._
 
 trait Common {
-  self: Controller =>
-
   def notFound(implicit request: RequestHeader) = NotFound(views.html.notfound())
+
+  implicit def reverseRouter: documentation.ReverseRouter
 }

app/controllers/Modules.scala

@@ -6,10 +6,13 @@ import play.api.libs.json._
 import services.modules._
 import models.modules._
 
+import scala.concurrent.ExecutionContext
+
 @Singleton
 class Modules @Inject() (
   modulesLookup: ModulesLookup,
-  moduleDao: ModuleDao) extends Controller {
+  moduleDao: ModuleDao,
+  components: ControllerComponents)(implicit ec: ExecutionContext, reverseRouter: documentation.ReverseRouter) extends AbstractController(components) {
 
   def index(keyword: String) = Action { implicit request =>
     render {

app/controllers/Outreachy.scala

@@ -1,11 +1,13 @@
 package controllers
 
-import play.api.mvc._
+import javax.inject.Inject
+
+import play.api.mvc.{ AbstractController, ControllerComponents }
 
 /**
  * The outreachy controller
  */
-class Outreachy extends Controller {
+class Outreachy @Inject() (components: ControllerComponents)(implicit reverseRouter: documentation.ReverseRouter) extends AbstractController(components) {
 
   def outreachy = Action(Redirect(routes.Outreachy.round15()))
 

app/controllers/Security.scala

@@ -1,15 +1,17 @@
 package controllers
 
-import javax.inject.{ Inject, Singleton }
-import play.api.mvc.{Action, Controller}
-import play.api.{Environment, Play}
+import javax.inject.{Inject, Singleton}
+
+import play.api.mvc.{BaseController, ControllerComponents}
+import play.api.Environment
 import play.twirl.api.Html
 import utils.Markdown
 import org.apache.commons.io.IOUtils
 import java.io.File
 
 @Singleton
-class Security @Inject() (environment: Environment) extends Controller with Common {
+class Security @Inject() (environment: Environment, val controllerComponents: ControllerComponents)
+                         (implicit val reverseRouter: documentation.ReverseRouter) extends BaseController with Common {
 
   def vulnerability(name: String) = Action { implicit req =>
     val path = "public/markdown/vulnerabilities/" + name
@@ -32,7 +34,7 @@ class Security @Inject() (environment: Environment) extends Controller with Comm
   }
 
   def index = Action { implicit req =>
-    Ok(views.html.vulnerabilities(req)).withHeaders(CACHE_CONTROL -> "max-age=1000")
+    Ok(views.html.vulnerabilities()).withHeaders(CACHE_CONTROL -> "max-age=1000")
   }
 
 }

app/controllers/documentation/DocumentationController.scala

@@ -12,11 +12,9 @@ import org.joda.time.format.DateTimeFormat
 import play.api.http.HttpEntity
 import play.api.i18n.{MessagesApi, Lang}
 import play.api.mvc._
-import scala.concurrent.Future
+import scala.concurrent.{ ExecutionContext, Future }
 import scala.concurrent.duration._
 
-import play.api.libs.MimeTypes
-import play.api.libs.concurrent.Execution.Implicits.defaultContext
 
 import scala.reflect.ClassTag
 
@@ -25,9 +23,8 @@ class DocumentationController @Inject()(
   messages: MessagesApi,
   documentationRedirects: DocumentationRedirects,
   @Named("documentation-actor") documentationActor: ActorRef,
-  releases: PlayReleases) extends Controller {
-
-  import DocumentationController._
+  releases: PlayReleases,
+  components: ControllerComponents)(implicit executionContext: ExecutionContext, reverseRouter: ReverseRouter) extends AbstractController(components) {
 
   private implicit val timeout = Timeout(5.seconds)
 
@@ -114,7 +111,7 @@ class DocumentationController @Inject()(
   //
 
   def v1Home(lang: Option[Lang], version: String) = Action {
-    Redirect(ReverseRouter.page(lang, version, "home"))
+    Redirect(reverseRouter.page(lang, version, "home"))
   }
 
   def v1Page(lang: Option[Lang], v: String, page: String) = VersionAction(v) { (actor, version) => implicit req =>
@@ -156,7 +153,7 @@ class DocumentationController @Inject()(
   //
 
   def home(lang: Option[Lang], version: String) = Action {
-    Redirect(ReverseRouter.page(lang, version, "Home"))
+    Redirect(reverseRouter.page(lang, version))
   }
 
   def page(lang: Option[Lang], v: String, page: String) = VersionAction(v) { (actor, version) => implicit req =>
@@ -170,7 +167,7 @@ class DocumentationController @Inject()(
         documentationRedirects.redirectFor(page) match {
           case Some(redirect) =>
             pageExists(version, redirect.to).map {
-              case Some(_) => Results.MovedPermanently(ReverseRouter.page(lang, v, redirect.to))
+              case Some(_) => Results.MovedPermanently(reverseRouter.page(lang, v, redirect.to))
               case None => Results.MovedPermanently(redirect.to)
             }
           case None =>
@@ -192,14 +189,14 @@ class DocumentationController @Inject()(
 
   // -- API
   def v1Api(lang: Option[Lang], version: String) = Action {
-    Redirect(ReverseRouter.api(version, "index.html"))
+    Redirect(reverseRouter.api(version, "index.html"))
   }
 
   def api(lang: Option[Lang], v: String, path: String) =
     ResourceAction(v, path, (version, etag) => LoadApi(version, etag, path))
 
   def apiRedirect(lang: Option[Lang], version: String, path: String) =
-    Action(MovedPermanently(ReverseRouter.api(version, path)))
+    Action(MovedPermanently(reverseRouter.api(version, path)))
 
   // -- Latest
 
@@ -229,7 +226,7 @@ class DocumentationController @Inject()(
           }
       }
       version.map { v =>
-        val url = ReverseRouter.home(selectedLang, v.name)
+        val url = reverseRouter.home(selectedLang, v.name)
         Redirect(s"$url/$path").withHeaders(VARY -> ACCEPT_LANGUAGE)
       }.getOrElse(pageNotFound(summary.translationContext, path, Nil))
     }
@@ -259,7 +256,7 @@ class DocumentationController @Inject()(
           } else {
             Seq(CONTENT_DISPOSITION -> s"""attachment; filename="$fileName"""")
           }
-          val entity = HttpEntity.Streamed(source, Some(size), Some(MimeTypes.forFileName(fileName).getOrElse(BINARY)))
+          val entity = HttpEntity.Streamed(source, Some(size), Some(fileMimeTypes.forFileName(fileName).getOrElse(BINARY)))
           cacheable(Ok.sendEntity(entity).withHeaders(contentDisposition: _*), cacheId)
       }
     }
@@ -284,17 +281,17 @@ class DocumentationController @Inject()(
       VersionAction(v) { (actor, version) => implicit req =>
         actorRequest(actor, page, msg(lang, version, etag(req), page)) {
           case PageExists(true, cacheId) =>
-            cacheable(TemporaryRedirect(ReverseRouter.page(lang, version.name, page)), cacheId)
+            cacheable(TemporaryRedirect(reverseRouter.page(lang, version.name, page)), cacheId)
           case PageExists(false, cacheId) =>
-            cacheable(TemporaryRedirect(ReverseRouter.page(lang, version.name, home)), cacheId)
+            cacheable(TemporaryRedirect(reverseRouter.page(lang, version.name, home)), cacheId)
         }
       }
   }
 
   def withLangHeaders(result: Result, page: String, context: TranslationContext)(implicit req: RequestHeader) = {
     val linkHeader = context.alternatives.filterNot(_.lang == context.lang).collect {
       case AlternateTranslation(l, isDefault, Some(v)) =>
-        val url = Call("GET", ReverseRouter.page(Some(l).filterNot(_ => isDefault), v.name, page)).absoluteURL()
+        val url = Call("GET", reverseRouter.page(Some(l).filterNot(_ => isDefault), v.name, page)).absoluteURL()
         s"""<$url>; rel="alternate"; hreflang="${l.code}""""
     }.mkString(", ")
     if (linkHeader.nonEmpty) {

app/controllers/documentation/Router.scala

@@ -74,10 +74,6 @@ class Router @Inject() (
   }
 }
 
-object ReverseRouter extends ReverseRouter(new Provider[Router] {
-  def get = play.api.Play.current.injector.instanceOf[Router]
-})
-
 @Singleton
 class ReverseRouter @Inject() (routerProvider: Provider[Router]) {
   private def router: Router = routerProvider.get