Fix warnings + build for scala 2.12

build.sbt

@@ -20,7 +20,14 @@ lazy val commonSettings = Seq(
     "-Xfuture",
     "-Ywarn-unused",
     "-Ywarn-unused-import"
-  ),
+  ) ++ (CrossVersion.partialVersion(scalaVersion.value) match {
+    case Some((2, 12)) => Nil
+      Seq(
+        "-Ywarn-unused:-params"
+      )
+    case _ =>
+      Nil
+  }),
   devMode := Option(System.getProperty("devMode")).isDefined,
   writeClasspath := {
     val f = file(s"/tmp/classpath_${organization.value}.${name.value}")
@@ -148,7 +155,7 @@ lazy val cuttle =
       libraryDependencies ++= Seq(
         "de.sciss" %% "fingertree" % "1.5.2",
         "org.scala-stm" %% "scala-stm" % "0.8",
-        "org.scala-lang" % "scala-reflect" % "2.11.9",
+        "org.scala-lang" % "scala-reflect" % scalaVersion.value,
         "org.typelevel" %% "cats" % "0.9.0",
         "codes.reactive" %% "scala-time" % "0.4.1",
         "com.zaxxer" % "nuprocess" % "1.1.0"

core/src/main/scala/com/criteo/cuttle/App.scala

@@ -176,7 +176,7 @@ private[cuttle] case class App[S <: Scheduling](project: CuttleProject[S], execu
       }
       events match {
         case "true" | "yes" =>
-          sse(getStats, asJson)
+          sse(getStats _, asJson)
         case _ =>
           Ok(asJson(getStats().get))
       }
@@ -228,7 +228,7 @@ private[cuttle] case class App[S <: Scheduling](project: CuttleProject[S], execu
       }
       events match {
         case "true" | "yes" =>
-          sse(getExecutions, asJson)
+          sse(getExecutions _, asJson)
         case _ =>
           getExecutions().map(e => Ok(asJson(e))).getOrElse(NotFound)
       }
@@ -237,7 +237,7 @@ private[cuttle] case class App[S <: Scheduling](project: CuttleProject[S], execu
       def getExecution() = executor.getExecution(scheduler.allContexts, id)
       events match {
         case "true" | "yes" =>
-          sse(getExecution, (e: ExecutionLog) => e.asJson)
+          sse(getExecution _, (e: ExecutionLog) => e.asJson)
         case _ =>
           getExecution().map(e => Ok(e.asJson)).getOrElse(NotFound)
       }

core/src/main/scala/com/criteo/cuttle/Database.scala

@@ -40,7 +40,7 @@ private[cuttle] object Database {
   )
 
   implicit val ExecutionStatusMeta: Meta[ExecutionStatus] = Meta[Boolean].xmap(
-    x => if (x != null && x) ExecutionSuccessful else ExecutionFailed,
+    x => if (x) ExecutionSuccessful else ExecutionFailed,
     x =>
       x match {
         case ExecutionSuccessful => true

core/src/main/scala/com/criteo/cuttle/Executor.scala

@@ -471,7 +471,7 @@ class Executor[S <: Scheduling] private[cuttle] (
     toCancel.foreach(_.cancel())
 
     val runningFutures = atomic { implicit tx =>
-      runningState.map({ case (k, v) => v })
+      runningState.map({ case (_, v) => v })
     }
 
     Future

core/src/main/scala/com/criteo/cuttle/platforms/WaitingExecutionQueue.scala

@@ -78,7 +78,7 @@ private[cuttle] trait WaitingExecutionQueue {
     }
 
     maybeToRun.foreach {
-      case entry @ (execution, DelayedResult(effect, _, promise, _, _)) =>
+      case entry @ (_, DelayedResult(effect, _, promise, _, _)) =>
         val effectResult = try {
           effect()
         } catch {

core/src/main/scala/com/criteo/cuttle/platforms/http/HttpPlatform.scala

@@ -50,7 +50,7 @@ case class HttpPlatform(maxConcurrentRequests: Int, rateLimits: Seq[(String, Htt
             ))
       }
       rateLimiters.zipWithIndex.foldLeft(index) {
-        case (routes, ((pattern, rateLimiter), i)) =>
+        case (routes, ((_, rateLimiter), i)) =>
           routes.orElse(rateLimiter.routes(s"/api/platforms/http/rate-limiters/$i"))
       }
     }

timeseries/src/main/scala/com/criteo/cuttle/timeseries/Database.scala

@@ -128,7 +128,7 @@ private[timeseries] object Database {
     val stateJson = state.toList.map {
       case (job, im) =>
         (job.id, im.toList.filter {
-          case (interval, jobState) =>
+          case (_, jobState) =>
             jobState match {
               case Done => true
               case Todo(_) => true

timeseries/src/main/scala/com/criteo/cuttle/timeseries/TimeSeriesApp.scala

@@ -118,7 +118,7 @@ private[timeseries] trait TimeSeriesApp { self: TimeSeriesScheduler =>
       }
 
       if (request.headers.get(h"Accept").exists(_ == h"text/event-stream"))
-        sse(watchState, getExecutions)
+        sse(watchState _, getExecutions)
       else
         Ok(getExecutions())
 
@@ -211,7 +211,7 @@ private[timeseries] trait TimeSeriesApp { self: TimeSeriesScheduler =>
                       .nonEmpty)
               if (gridView.aggregationFactor == 1)
                 jobStatesOnIntervals match {
-                  case (executionInterval, state) :: Nil =>
+                  case (_, state) :: Nil =>
                     Some(JobExecution(interval, getStatusLabelFromState(state), inBackfill))
                   case _ => None
                 } else
@@ -275,7 +275,7 @@ private[timeseries] trait TimeSeriesApp { self: TimeSeriesScheduler =>
       }
 
       if (request.headers.get(h"Accept").exists(_ == h"text/event-stream"))
-        sse(watchState, getFocusView)
+        sse(watchState _, getFocusView)
       else
         Ok(getFocusView())
 
@@ -335,7 +335,7 @@ private[timeseries] trait TimeSeriesApp { self: TimeSeriesScheduler =>
       }
 
       if (request.headers.get(h"Accept").exists(_ == h"text/event-stream"))
-        sse(watchState, getCalendar)
+        sse(watchState _, getCalendar)
       else
         Ok(getCalendar())
 
@@ -422,7 +422,7 @@ private[timeseries] trait TimeSeriesApp { self: TimeSeriesScheduler =>
       }
        events match {
         case "true" | "yes" =>
-          sse(allExecutions, asTotalJson)
+          sse(allExecutions _, asTotalJson)
         case _ =>
           allExecutions().map(e => Ok(asTotalJson(e))).getOrElse(NotFound)
       }

timeseries/src/main/scala/com/criteo/cuttle/timeseries/TimeSeriesScheduler.scala

@@ -40,6 +40,8 @@ sealed trait TimeSeriesGrid {
     interval match {
       case Interval(Finite(lo), Finite(hi)) =>
         go(ceil(lo), hi).grouped(maxPeriods).map(xs => (xs.head._1, xs.last._2))
+      case _ =>
+        sys.error("panic")
     }
   }
   private[timeseries] def split(interval: Interval[Instant]) = {
@@ -51,6 +53,8 @@ sealed trait TimeSeriesGrid {
     interval match {
       case Interval(Finite(lo), Finite(hi)) =>
         go(lo, hi)
+      case _ =>
+        sys.error("panic")
     }
   }
 }
@@ -274,12 +278,12 @@ case class TimeSeriesScheduler(logger: Logger) extends Scheduler[TimeSeries] wit
         .queryBackfills(Some(sql"""status = 'RUNNING'"""))
         .list
         .map(_.map {
-          case (id, name, description, jobsIdsString, priority, start, end, created_at, status, created_by) =>
+          case (id, name, description, jobsIdsString, priority, start, end, _, status, createdBy) =>
             val jobsIds = jobsIdsString.split(",")
             val jobs = workflow.vertices.filter { job =>
               jobsIds.contains(job.id)
             }
-            Backfill(id, start, end, jobs, priority, name, description, status, created_by)
+            Backfill(id, start, end, jobs, priority, name, description, status, createdBy)
         })
         .transact(xa)
         .unsafePerformIO
@@ -305,12 +309,11 @@ case class TimeSeriesScheduler(logger: Logger) extends Scheduler[TimeSeries] wit
         case(_,_,effect) => effect.isCompleted
       }
 
-      val now = Instant.now
       val (stateSnapshot, completedBackfills, toRun) = atomic { implicit txn =>
         val (stateSnapshot, newBackfills, completedBackfills) =
-          collectCompletedJobs(workflow, now, _state(), _backfills(), completed)
+          collectCompletedJobs(_state(), _backfills(), completed)
 
-        val toRun = jobsToRun(workflow, stateSnapshot, now)
+        val toRun = jobsToRun(workflow, stateSnapshot, Instant.now)
 
         _state() = stateSnapshot
         _backfills() = newBackfills
@@ -373,8 +376,6 @@ case class TimeSeriesScheduler(logger: Logger) extends Scheduler[TimeSeries] wit
   }
 
   private[timeseries] def collectCompletedJobs(
-    workflow : Workflow[TimeSeries],
-    now : Instant, 
     state : State,
     backfills : Set[Backfill],
     completed : Set[Run]) : (State, Set[Backfill], Set[Backfill]) = {

timeseries/src/main/scala/com/criteo/cuttle/timeseries/intervals/IntervalMap.scala

@@ -57,15 +57,15 @@ private[timeseries] object IntervalMap {
       val (leftOfLow, rightOfLow) = tree.span(lower(interval))
 
       val withoutLow = leftOfLow.viewRight match {
-        case ViewRightCons(_, (Interval(lo, hi), v)) if hi > interval.lo =>
+        case ViewRightCons(_, (Interval(_, hi), v)) if hi > interval.lo =>
           (Interval(interval.lo, hi) -> v) +: rightOfLow
         case _ =>
           rightOfLow
       }
       val (leftOfHigh, rightOfHigh) = withoutLow.span(greater(interval))
 
       val newTree = rightOfHigh.viewLeft match {
-        case ViewLeftCons((Interval(lo, hi), v), _) if lo < interval.hi =>
+        case ViewLeftCons((Interval(lo, _), v), _) if lo < interval.hi =>
           leftOfHigh :+ (Interval(lo, interval.hi) -> v)
         case _ =>
           leftOfHigh