Apply standard scala formatting. (#2650)

Formats all .scala files according to `scalafmt`'s (opinionated) style. 
Adds Travis checks for correctly formatted code.

Author: markusthoemmes

.scalafmt.conf

@@ -0,0 +1,6 @@
+style = intellij
+danglingParentheses = false
+maxColumn = 120
+docstrings = JavaDoc
+rewrite.rules = [SortImports]
+project.git = true

build.gradle

@@ -0,0 +1,13 @@
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath "cz.alenkacz:gradle-scalafmt:${gradle.scalafmt.version}"
+    }
+}
+
+subprojects {
+    apply plugin: 'scalafmt'
+    scalafmt.configFilePath = gradle.scalafmt.config
+}

settings.gradle

@@ -26,3 +26,8 @@ gradle.ext.scala = [
     version: '2.11.8',
     compileFlags: ['-feature', '-unchecked', '-deprecation', '-Xfatal-warnings', '-Ywarn-unused-import']
 ]
+
+gradle.ext.scalafmt = [
+    version: '1.5.0',
+    config: new File(rootProject.projectDir, '.scalafmt.conf')
+]

tests/src/test/scala/actionContainers/ActionContainer.scala

@@ -46,124 +46,127 @@ import whisk.core.entity.Exec
  * container as blocking method calls of this interface.
  */
 trait ActionContainer {
-    def init(value: JsValue): (Int, Option[JsObject])
-    def run(value: JsValue): (Int, Option[JsObject])
+  def init(value: JsValue): (Int, Option[JsObject])
+  def run(value: JsValue): (Int, Option[JsObject])
 }
 
 trait ActionProxyContainerTestUtils extends FlatSpec with Matchers {
-    import ActionContainer.{ filterSentinel, sentinel }
-
-    def initPayload(code: String, main: String = "main") = {
-        JsObject("value" -> JsObject(
-            "code" -> { if (code != null) JsString(code) else JsNull },
-            "main" -> JsString(main),
-            "binary" -> JsBoolean(Exec.isBinaryCode(code))))
+  import ActionContainer.{filterSentinel, sentinel}
+
+  def initPayload(code: String, main: String = "main") = {
+    JsObject(
+      "value" -> JsObject(
+        "code" -> { if (code != null) JsString(code) else JsNull },
+        "main" -> JsString(main),
+        "binary" -> JsBoolean(Exec.isBinaryCode(code))))
+  }
+
+  def runPayload(args: JsValue, other: Option[JsObject] = None) = {
+    JsObject(Map("value" -> args) ++ (other map { _.fields } getOrElse Map()))
+  }
+
+  def checkStreams(out: String, err: String, additionalCheck: (String, String) => Unit, sentinelCount: Int = 1) = {
+    withClue("expected number of stdout sentinels") {
+      sentinelCount shouldBe StringUtils.countMatches(out, sentinel)
     }
-
-    def runPayload(args: JsValue, other: Option[JsObject] = None) = {
-        JsObject(Map("value" -> args) ++ (other map { _.fields } getOrElse Map()))
+    withClue("expected number of stderr sentinels") {
+      sentinelCount shouldBe StringUtils.countMatches(err, sentinel)
     }
 
-    def checkStreams(out: String, err: String, additionalCheck: (String, String) => Unit, sentinelCount: Int = 1) = {
-        withClue("expected number of stdout sentinels") {
-            sentinelCount shouldBe StringUtils.countMatches(out, sentinel)
-        }
-        withClue("expected number of stderr sentinels") {
-            sentinelCount shouldBe StringUtils.countMatches(err, sentinel)
-        }
-
-        val (o, e) = (filterSentinel(out), filterSentinel(err))
-        o should not include (sentinel)
-        e should not include (sentinel)
-        additionalCheck(o, e)
-    }
+    val (o, e) = (filterSentinel(out), filterSentinel(err))
+    o should not include (sentinel)
+    e should not include (sentinel)
+    additionalCheck(o, e)
+  }
 }
 
 object ActionContainer {
-    private lazy val dockerBin: String = {
-        List("/usr/bin/docker", "/usr/local/bin/docker").find { bin =>
-            new File(bin).isFile()
-        }.getOrElse(???) // This fails if the docker binary couldn't be located.
+  private lazy val dockerBin: String = {
+    List("/usr/bin/docker", "/usr/local/bin/docker")
+      .find { bin =>
+        new File(bin).isFile()
+      }
+      .getOrElse(???) // This fails if the docker binary couldn't be located.
+  }
+
+  private lazy val dockerCmd: String = {
+    val hostStr = if (WhiskProperties.onMacOSX()) {
+      s" --host tcp://${WhiskProperties.getMainDockerEndpoint()} "
+    } else {
+      " "
     }
-
-    private lazy val dockerCmd: String = {
-        val hostStr = if (WhiskProperties.onMacOSX()) {
-            s" --host tcp://${WhiskProperties.getMainDockerEndpoint()} "
-        } else {
-            " "
-        }
-        s"$dockerBin $hostStr"
+    s"$dockerBin $hostStr"
+  }
+
+  private def docker(command: String): String = s"$dockerCmd $command"
+
+  // Runs a process asynchronously. Returns a future with (exitCode,stdout,stderr)
+  private def proc(cmd: String): Future[(Int, String, String)] = Future {
+    blocking {
+      val out = new ByteArrayOutputStream
+      val err = new ByteArrayOutputStream
+      val outW = new PrintWriter(out)
+      val errW = new PrintWriter(err)
+      val v = cmd ! (ProcessLogger(outW.println, errW.println))
+      outW.close()
+      errW.close()
+      (v, out.toString, err.toString)
     }
-
-    private def docker(command: String): String = s"$dockerCmd $command"
-
-    // Runs a process asynchronously. Returns a future with (exitCode,stdout,stderr)
-    private def proc(cmd: String): Future[(Int, String, String)] = Future {
-        blocking {
-            val out = new ByteArrayOutputStream
-            val err = new ByteArrayOutputStream
-            val outW = new PrintWriter(out)
-            val errW = new PrintWriter(err)
-            val v = cmd ! (ProcessLogger(outW.println, errW.println))
-            outW.close()
-            errW.close()
-            (v, out.toString, err.toString)
-        }
+  }
+
+  // Tying it all together, we have a method that runs docker, waits for
+  // completion for some time then returns the exit code, the output stream
+  // and the error stream.
+  private def awaitDocker(cmd: String, t: Duration): (Int, String, String) = {
+    Await.result(proc(docker(cmd)), t)
+  }
+
+  // Filters out the sentinel markers inserted by the container (see relevant private code in Invoker.scala)
+  val sentinel = "XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX"
+  def filterSentinel(str: String) = str.replaceAll(sentinel, "").trim
+
+  def withContainer(imageName: String, environment: Map[String, String] = Map.empty)(code: ActionContainer => Unit)(
+    implicit actorSystem: ActorSystem): (String, String) = {
+    val rand = { val r = Random.nextInt; if (r < 0) -r else r }
+    val name = imageName.toLowerCase.replaceAll("""[^a-z]""", "") + rand
+    val envArgs = environment.toSeq.map {
+      case (k, v) => s"-e ${k}=${v}"
+    } mkString (" ")
+
+    // We create the container...
+    val runOut = awaitDocker(s"run --name $name $envArgs -d $imageName", 10 seconds)
+    assert(runOut._1 == 0, "'docker run' did not exit with 0: " + runOut)
+
+    // ...find out its IP address...
+    val ipOut = awaitDocker(s"""inspect --format '{{.NetworkSettings.IPAddress}}' $name""", 10 seconds)
+    assert(ipOut._1 == 0, "'docker inspect did not exit with 0")
+    val ip = ipOut._2.replaceAll("""[^0-9.]""", "")
+
+    // ...we create an instance of the mock container interface...
+    val mock = new ActionContainer {
+      def init(value: JsValue) = syncPost(ip, 8080, "/init", value)
+      def run(value: JsValue) = syncPost(ip, 8080, "/run", value)
     }
 
-    // Tying it all together, we have a method that runs docker, waits for
-    // completion for some time then returns the exit code, the output stream
-    // and the error stream.
-    private def awaitDocker(cmd: String, t: Duration): (Int, String, String) = {
-        Await.result(proc(docker(cmd)), t)
+    try {
+      // ...and finally run the code with it.
+      code(mock)
+      // I'm told this is good for the logs.
+      Thread.sleep(100)
+      val (_, out, err) = awaitDocker(s"logs $name", 10 seconds)
+      (out, err)
+    } finally {
+      awaitDocker(s"kill $name", 10 seconds)
+      awaitDocker(s"rm $name", 10 seconds)
     }
+  }
 
-    // Filters out the sentinel markers inserted by the container (see relevant private code in Invoker.scala)
-    val sentinel = "XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX"
-    def filterSentinel(str: String) = str.replaceAll(sentinel, "").trim
-
-    def withContainer(imageName: String, environment: Map[String, String] = Map.empty)(
-        code: ActionContainer => Unit)(implicit actorSystem: ActorSystem): (String, String) = {
-        val rand = { val r = Random.nextInt; if (r < 0) -r else r }
-        val name = imageName.toLowerCase.replaceAll("""[^a-z]""", "") + rand
-        val envArgs = environment.toSeq.map {
-            case (k, v) => s"-e ${k}=${v}"
-        } mkString (" ")
-
-        // We create the container...
-        val runOut = awaitDocker(s"run --name $name $envArgs -d $imageName", 10 seconds)
-        assert(runOut._1 == 0, "'docker run' did not exit with 0: " + runOut)
-
-        // ...find out its IP address...
-        val ipOut = awaitDocker(s"""inspect --format '{{.NetworkSettings.IPAddress}}' $name""", 10 seconds)
-        assert(ipOut._1 == 0, "'docker inspect did not exit with 0")
-        val ip = ipOut._2.replaceAll("""[^0-9.]""", "")
-
-        // ...we create an instance of the mock container interface...
-        val mock = new ActionContainer {
-            def init(value: JsValue) = syncPost(ip, 8080, "/init", value)
-            def run(value: JsValue) = syncPost(ip, 8080, "/run", value)
-        }
-
-        try {
-            // ...and finally run the code with it.
-            code(mock)
-            // I'm told this is good for the logs.
-            Thread.sleep(100)
-            val (_, out, err) = awaitDocker(s"logs $name", 10 seconds)
-            (out, err)
-        } finally {
-            awaitDocker(s"kill $name", 10 seconds)
-            awaitDocker(s"rm $name", 10 seconds)
-        }
-    }
-
-    private def syncPost(host: String, port: Int, endPoint: String, content: JsValue): (Int, Option[JsObject]) = {
-        whisk.core.containerpool.docker.HttpUtils.post(host, port, endPoint, content)
-    }
+  private def syncPost(host: String, port: Int, endPoint: String, content: JsValue): (Int, Option[JsObject]) = {
+    whisk.core.containerpool.docker.HttpUtils.post(host, port, endPoint, content)
+  }
 
-    private class ActionContainerImpl() extends ActionContainer {
-        override def init(value: JsValue) = ???
-        override def run(value: JsValue) = ???
-    }
+  private class ActionContainerImpl() extends ActionContainer {
+    override def init(value: JsValue) = ???
+    override def run(value: JsValue) = ???
+  }
 }