Scala 2.12 Upgrade

.editorconfig

@@ -15,6 +15,12 @@ insert_final_newline = true
 [*.scala]
 indent_size = 2
 
+[*.sc]
+indent_size = 2
+
+[*.sbt]
+indent_size = 2
+
 [*.conf]
 indent_size = 2
 

admin/app/controllers/TroubleshooterController.scala

@@ -10,7 +10,6 @@ import com.amazonaws.services.ec2.{AmazonEC2, AmazonEC2ClientBuilder}
 import com.amazonaws.services.ec2.model.{DescribeInstancesRequest, Filter}
 
 import scala.collection.JavaConverters._
-import scala.collection.JavaConversions._
 import scala.concurrent.Future
 import scala.concurrent.duration._
 import conf.Configuration.aws.credentials
@@ -110,8 +109,8 @@ class TroubleshooterController(wsClient: WSClient, val controllerComponents: Con
       }.asJavaCollection
       val instancesDnsName: Seq[String] = awsEc2Client.map(
         _.describeInstances(new DescribeInstancesRequest().withFilters(tagsAsFilters))
-          .getReservations
-          .flatMap(_.getInstances)
+          .getReservations.asScala
+          .flatMap(_.getInstances.asScala)
           .map(_.getPrivateDnsName)
       ).toSeq.flatten
       Random.shuffle(instancesDnsName).headOption

admin/app/dfp/AdvertiserAgent.scala

@@ -1,14 +1,14 @@
 package dfp
 
-import common.AkkaAgent
+import com.gu.Box
 import common.dfp.GuAdvertiser
 import tools.BlockingOperations
 
 import scala.concurrent.{ExecutionContext, Future}
 
 class AdvertiserAgent(blockingOperations: BlockingOperations, dfpApi: DfpApi) {
 
-  private lazy val cache = AkkaAgent(Seq.empty[GuAdvertiser])
+  private lazy val cache = Box(Seq.empty[GuAdvertiser])
 
   def refresh()(implicit executionContext: ExecutionContext): Future[Seq[GuAdvertiser]] = {
     blockingOperations.executeBlocking(dfpApi.getAllAdvertisers).flatMap { freshData =>

admin/app/dfp/CreativeTemplateAgent.scala

@@ -1,14 +1,14 @@
 package dfp
 
-import common.AkkaAgent
+import com.gu.Box
 import common.dfp.GuCreativeTemplate
 import tools.BlockingOperations
 
 import scala.concurrent.{ExecutionContext, Future}
 
 class CreativeTemplateAgent(blockingOperations: BlockingOperations, dfpApi: DfpApi) {
 
-  private lazy val cache = AkkaAgent(Seq.empty[GuCreativeTemplate])
+  private lazy val cache = Box(Seq.empty[GuCreativeTemplate])
 
   def refresh()(implicit executionContext: ExecutionContext): Future[Seq[GuCreativeTemplate]] = {
     blockingOperations.executeBlocking(dfpApi.readActiveCreativeTemplates()).flatMap { freshData =>

admin/app/dfp/DataAgent.scala

@@ -1,6 +1,7 @@
 package dfp
 
-import common.{AkkaAgent, Logging}
+import com.gu.Box
+import common.Logging
 import tools.BlockingOperations
 
 import scala.concurrent.{ExecutionContext, Future}
@@ -9,7 +10,7 @@ import scala.util.{Failure, Success, Try}
 trait DataAgent[K, V] extends Logging with implicits.Strings {
 
   private val initialCache: DataCache[K, V] = DataCache(Map.empty[K, V])
-  private lazy val cache = AkkaAgent(initialCache)
+  private lazy val cache = Box(initialCache)
 
   def blockingOperations: BlockingOperations
 

admin/app/dfp/OrderAgent.scala

@@ -1,14 +1,14 @@
 package dfp
 
-import common.AkkaAgent
+import com.gu.Box
 import common.dfp.GuOrder
 import tools.BlockingOperations
 
 import scala.concurrent.{ExecutionContext, Future}
 
 class OrderAgent(blockingOperations: BlockingOperations, dfpApi: DfpApi) {
 
-  private lazy val cache = AkkaAgent(Seq.empty[GuOrder])
+  private lazy val cache = Box(Seq.empty[GuOrder])
 
   def refresh()(implicit executionContext: ExecutionContext): Future[Seq[GuOrder]] = {
     blockingOperations.executeBlocking(dfpApi.getAllOrders).flatMap { freshData =>

admin/app/jobs/AnalyticsSanityCheckJob.scala

@@ -9,7 +9,7 @@ import model.diagnostics.CloudWatch
 import org.joda.time.DateTime
 import services.{CloudWatchStats, OphanApi}
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters._
 import scala.concurrent.{ExecutionContext, Future}
 
 class AnalyticsSanityCheckJob(ophanApi: OphanApi) extends Logging {
@@ -47,7 +47,7 @@ class AnalyticsSanityCheckJob(ophanApi: OphanApi) extends Logging {
       ophanViewsCount <- fOphanViews
     } yield {
 
-      def metricLastSum(stats: GetMetricStatisticsResult): Long = stats.getDatapoints.headOption.map(_.getSum.longValue).getOrElse(0L)
+      def metricLastSum(stats: GetMetricStatisticsResult): Long = stats.getDatapoints.asScala.headOption.map(_.getSum.longValue).getOrElse(0L)
 
       rawPageViews.set(metricLastSum(rawPageViewsStats))
       googlePageViews.set(metricLastSum(googlePageViewsStats))

admin/app/jobs/ExpiringSwitchesEmailJob.scala

@@ -32,11 +32,11 @@ case class ExpiringSwitchesEmailJob(emailService: EmailService) extends Logging
           subject = "Expiring Feature Switches",
           htmlBody = Some(htmlBody))
 
-        eventualResult onSuccess {
-          case result => log.info(s"Message sent successfully with ID: ${result.getMessageId}")
+        eventualResult.foreach {
+          result => log.info(s"Message sent successfully with ID: ${result.getMessageId}")
         }
 
-        eventualResult onFailure {
+        eventualResult.failed.foreach {
           case NonFatal(e) => log.error(s"Message failed: ${e.getMessage}")
         }
 

admin/app/jobs/MissingVideoEncodingsJob.scala

@@ -1,6 +1,6 @@
 package jobs
 
-import common.{AkkaAgent, AkkaAsync, Edition, Logging}
+import common.{AkkaAsync, Edition, Logging}
 import conf.switches.Switches
 import model.{Content, Video}
 
@@ -10,14 +10,15 @@ import contentapi.ContentApiClient
 import scala.concurrent.{ExecutionContext, Future}
 import scala.concurrent.duration._
 import akka.util.Timeout
+import com.gu.Box
 import play.api.libs.ws.WSClient
 import services.MissingVideoEncodings
 import model.diagnostics.video.DynamoDbStore
 
 
 class VideoEncodingsJob(contentApiClient: ContentApiClient, wsClient: WSClient) extends Logging  {
 
-  private val videoEncodingsAgent = AkkaAgent[Map[String, List[MissingEncoding]]](Map.empty)
+  private val videoEncodingsAgent = Box[Map[String, List[MissingEncoding]]](Map.empty)
   implicit val timeout = Timeout(5 seconds)
 
   def getReport(report: String): Option[List[MissingEncoding]] = videoEncodingsAgent().get(report)
@@ -46,41 +47,39 @@ class VideoEncodingsJob(contentApiClient: ContentApiClient, wsClient: WSClient)
             response.results.map(Content.apply).collect { case v: Video => v }
      }
 
-     apiVideoResponse.onSuccess {
-       case allVideoContent =>
-         val missingVideoEncodings = Future.sequence(allVideoContent.map { video =>
-           val videoAssets = video.elements.videos.filter(_.properties.isMain).flatMap(_.videos.videoAssets).flatMap(_.url)
-
-           val missingVideoAsssets = Future.sequence(
-             videoAssets.map { encoding =>
-               doesEncodingExist(encoding) map {
-                 case true => Some(encoding)
-                 case false => None
-               }
-             }).map(_.flatten)
-
-           missingVideoAsssets.map {
-             missingEncodings => missingEncodings.map { missingEncoding => MissingEncoding(video, missingEncoding)}
-           }
-         }).map(_.flatten)
-
-         missingVideoEncodings.onSuccess { case missingEncodings =>
-           missingEncodings.map { missingEncoding: MissingEncoding =>
-             DynamoDbStore.haveSeenMissingEncoding(missingEncoding.encodingSrc, missingEncoding.url) map {
-               case true => log.debug(s"Already seen missing encoding: ${missingEncoding.encodingSrc} for url: ${missingEncoding.url}")
-               case false =>
-                 log.info(s"Send notification for missing video encoding: ${missingEncoding.encodingSrc} for url: ${missingEncoding.url}")
-                 MissingVideoEncodings.sendMessage(akkaAsync)(missingEncoding.encodingSrc, missingEncoding.url, missingEncoding.title)
-                 DynamoDbStore.storeMissingEncoding(missingEncoding.encodingSrc, missingEncoding.url)
+     apiVideoResponse.foreach { allVideoContent =>
+       val missingVideoEncodings = Future.sequence(allVideoContent.map { video =>
+         val videoAssets = video.elements.videos.filter(_.properties.isMain).flatMap(_.videos.videoAssets).flatMap(_.url)
+
+         val missingVideoAsssets = Future.sequence(
+           videoAssets.map { encoding =>
+             doesEncodingExist(encoding) map {
+               case true => Some(encoding)
+               case false => None
              }
+           }).map(_.flatten)
+
+         missingVideoAsssets.map {
+           missingEncodings => missingEncodings.map { missingEncoding => MissingEncoding(video, missingEncoding)}
+         }
+       }).map(_.flatten)
+
+       missingVideoEncodings.foreach { missingEncodings =>
+         missingEncodings.map { missingEncoding: MissingEncoding =>
+           DynamoDbStore.haveSeenMissingEncoding(missingEncoding.encodingSrc, missingEncoding.url) map {
+             case true => log.debug(s"Already seen missing encoding: ${missingEncoding.encodingSrc} for url: ${missingEncoding.url}")
+             case false =>
+               log.info(s"Send notification for missing video encoding: ${missingEncoding.encodingSrc} for url: ${missingEncoding.url}")
+               MissingVideoEncodings.sendMessage(akkaAsync)(missingEncoding.encodingSrc, missingEncoding.url, missingEncoding.title)
+               DynamoDbStore.storeMissingEncoding(missingEncoding.encodingSrc, missingEncoding.url)
            }
-           videoEncodingsAgent.send(old => old + ("missing-encodings" -> List()))
          }
+         videoEncodingsAgent.send(old => old + ("missing-encodings" -> List()))
+       }
      }
 
-     apiVideoResponse.onFailure{
-       case error: Throwable =>
-         log.error(s"Unable to retrieve video content from api: ${error.getMessage}")
+     apiVideoResponse.failed.foreach { error: Throwable =>
+       log.error(s"Unable to retrieve video content from api: ${error.getMessage}")
      }
   }
 }

admin/app/jobs/RebuildIndexJob.scala

@@ -77,8 +77,8 @@ class RebuildIndexJob(contentApiClient: ContentApiClient)(implicit executionCont
 
   implicit class RichFuture[A](future: Future[A]) {
     def withErrorLogging: Future[A] = {
-      future onFailure {
-        case throwable: Throwable => log.error("Error rebuilding index", throwable)
+      future.failed.foreach {
+        throwable: Throwable => log.error("Error rebuilding index", throwable)
       }
 
       future

admin/app/model/abtests/AbTests.scala

@@ -7,9 +7,10 @@ import org.joda.time.DateTime
 
 import scala.concurrent.{ExecutionContext, Future}
 import awswrappers.cloudwatch._
+import com.gu.Box
 
 object AbTests {
-  private val abTests = common.AkkaAgent[Map[String, Seq[String]]](Map.empty)
+  private val abTests = Box[Map[String, Seq[String]]](Map.empty)
 
   def getTests(): Map[String, Seq[String]] = {
     abTests.get()

admin/app/model/diagnostics/video/DynamoDbStore.scala

@@ -22,10 +22,9 @@ object DynamoDbStore extends Logging {
         ("web_url", new AttributeValue().withS(webUrl))
     ).asJava)
 
-    client.updateItemFuture(updateItemRequest) onFailure {
-      case error: Throwable =>
-        val message = error.getMessage
-        log.error(s"Unable to record missing video encoding with Dynamo DB: $message")
+    client.updateItemFuture(updateItemRequest).failed.foreach { error: Throwable =>
+      val message = error.getMessage
+      log.error(s"Unable to record missing video encoding with Dynamo DB: $message")
     }
   }
 

admin/app/pagepresser/HtmlCleaner.scala

@@ -6,7 +6,7 @@ import org.jsoup.Jsoup
 import org.jsoup.nodes.{Element, Document}
 import conf.Configuration
 
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters._
 
 abstract class HtmlCleaner extends Logging {
   lazy val fallbackCacheBustId = Configuration.r2Press.fallbackCachebustId
@@ -31,7 +31,7 @@ abstract class HtmlCleaner extends Logging {
   }
 
   def repairStaticLinks(document: Document): Document = {
-    document.getAllElements.filter { el =>
+    document.getAllElements.asScala.filter { el =>
       el.hasAttr("href") && el.attr("href").contains("/static/")
     }.foreach { el =>
       val staticLink = staticRegEx.findFirstMatchIn(el.attr("href"))
@@ -55,7 +55,7 @@ abstract class HtmlCleaner extends Logging {
   }
 
   def repairStaticSources(document: Document): Document = {
-    val elementsWithSrc = document.getAllElements.filter { el =>
+    val elementsWithSrc = document.getAllElements.asScala.filter { el =>
       el.hasAttr("src") && el.attr("src").contains("/static/")
     }
     elementsWithSrc.foreach { el =>
@@ -81,7 +81,7 @@ abstract class HtmlCleaner extends Logging {
 
   def replaceLinks(document: Document): Document = {
     try {
-      document.getAllElements.filter{ el =>
+      document.getAllElements.asScala.filter{ el =>
         (el.hasAttr("href") && el.attr("href").contains("http://")) || (el.hasAttr("src") && el.attr("src").contains("http://"))
       }.foreach{ el =>
 
@@ -101,18 +101,18 @@ abstract class HtmlCleaner extends Logging {
   }
 
   def removeScripts(document: Document): Document = {
-    document.getElementsByTag("script").toList.foreach(_.remove())
+    document.getElementsByTag("script").asScala.toList.foreach(_.remove())
     document
   }
 
   def removeAds(document: Document): Document = {
     val element = document.getElementById("sub-header")
 
     if (element != null) {
-      val ads = element.children().toList.filterNot(e => e.attr("class") == "top-navigation twelve-col top-navigation-js")
+      val ads = element.children().asScala.toList.filterNot(e => e.attr("class") == "top-navigation twelve-col top-navigation-js")
       ads.foreach(_.remove())
 
-      val htmlComments = element.childNodes().filter(node => node.nodeName().equals("#comment"))
+      val htmlComments = element.childNodes().asScala.filter(node => node.nodeName().equals("#comment"))
       htmlComments.foreach(_.remove())
 
       val promo = document.getElementById("promo")
@@ -129,12 +129,12 @@ abstract class HtmlCleaner extends Logging {
   }
 
   def removeByClass(document: Document, className: String): Document = {
-    document.getElementsByClass(className).foreach(_.remove())
+    document.getElementsByClass(className).asScala.foreach(_.remove())
     document
   }
 
   def removeByTagName(document: Document, tagName: String): Document = {
-    document.getElementsByTag(tagName).foreach(_.remove())
+    document.getElementsByTag(tagName).asScala.foreach(_.remove())
     document
   }
 
@@ -151,7 +151,7 @@ abstract class HtmlCleaner extends Logging {
   }
 
   def deComboLinks(document: Document): Document = {
-    document.getAllElements.filter( elementContainsCombo ) .foreach { el =>
+    document.getAllElements.asScala.filter( elementContainsCombo ) .foreach { el =>
 
       val combinerRegex = """//combo.guim.co.uk/(\w+)/(.+)(\.\w+)$""".r("cacheBustId", "paths", "extension")
       val microAppRegex = """^m-(\d+)~(.+)""".r

admin/app/pagepresser/InteractiveHtmlCleaner.scala

@@ -3,7 +3,7 @@ package pagepresser
 import com.netaporter.uri.Uri._
 import org.jsoup.Jsoup
 import org.jsoup.nodes.{Element, Document}
-import scala.collection.JavaConversions._
+import scala.collection.JavaConverters._
 import scala.io.Source
 
 object InteractiveHtmlCleaner extends HtmlCleaner with implicits.WSRequests {
@@ -22,11 +22,11 @@ object InteractiveHtmlCleaner extends HtmlCleaner with implicits.WSRequests {
   }
 
   override def removeScripts(document: Document): Document = {
-    val scripts = document.getElementsByTag("script")
+    val scripts = document.getElementsByTag("script").asScala
     val needsJquery = scripts.exists(_.html().toLowerCase.contains("jquery"))
 
     val (interactiveScripts, nonInteractiveScripts) = scripts.partition { e =>
-      val parentIds = e.parents().map(p => p.id()).toList
+      val parentIds = e.parents().asScala.map(p => p.id()).toList
       parentIds.contains("interactive-content")
     }
     nonInteractiveScripts.toList.foreach(_.remove())