Bump up coverage.

cli/src/main/scala/scalafix/cli/Cli.scala

@@ -8,16 +8,15 @@ import scalafix.util.FileOps
 import scalafix.util.LoggerOps._
 
 import java.io.File
+import java.io.OutputStream
 
 object Cli {
   case class Config(
       files: Set[File] = Set.empty[File],
       rewrites: Seq[Rewrite] = Rewrite.default,
       inPlace: Boolean = false,
       debug: Boolean = false
-  ) {
-    def paths: Set[String] = files.map(_.getAbsolutePath)
-  }
+  )
 
   def nameMap[T](t: sourcecode.Text[T]*): Map[String, T] = {
     t.map(x => x.source -> x.value).toMap
@@ -46,6 +45,14 @@ object Cli {
       .maxOccurs(1)
       .action((_, c) => c.copy(inPlace = true))
 
+    help("help").text("prints this usage text")
+
+    note("""
+           |Example usages:
+           |
+           |  // Overwrite file with fixed contents.
+           |  scalafix -f fixme.scala -i
+           |""".stripMargin)
   }
 
   def handleFile(file: File, config: Config): Unit = {

cli/src/test/scala/scalafix/cli/CliSuite.scala

@@ -11,37 +11,66 @@ class CliSuite extends FunSuite with DiffAssertions {
 
   test("testMain") {
     val expected = Cli.Config(
-        Set(new File("foo"), new File("bar"))
+        Set(new File("foo"), new File("bar")),
+        inPlace = true
+    )
+    val obtained = Cli.parser.parse(
+        Seq(
+            "--files",
+            "bar",
+            "--files",
+            "foo",
+            "-i"
+        ),
+        Cli.default
     )
-    val obtained = Cli.parser.parse(Seq(
-                                        "--files",
-                                        "bar",
-                                        "--files",
-                                        "foo"
-                                    ),
-                                    Cli.default)
     assert(obtained.get === expected)
   }
 
+  val original = """
+                   |object Main {
+                   |  def foo() {
+                   |   println(1)
+                   |  }
+                   |}
+                 """.stripMargin
+  val expected = """
+                   |object Main {
+                   |  def foo(): Unit = {
+                   |    println(1)
+                   |  }
+                   |}
+                 """.stripMargin
+
   test("write fix to file") {
-    val original = """
-                     |object Main {
-                     |  def foo() {
-                     |   println(1)
-                     |  }
-                     |}
-      """.stripMargin
-    val expected = """
-                     |object Main {
-                     |  def foo(): Unit = {
-                     |    println(1)
-                     |  }
-                     |}
-      """.stripMargin
     val file = File.createTempFile("prefix", ".scala")
     FileOps.writeFile(file, original)
     Cli.runOn(Cli.Config(Set(file), inPlace = true))
-
     assertNoDiff(FileOps.readFile(file), expected)
   }
+
+  test("print to stdout does not write to file") {
+    val file = File.createTempFile("prefix", ".scala")
+    FileOps.writeFile(file, original)
+    Cli.runOn(Cli.Config(Set(file)))
+    assertNoDiff(FileOps.readFile(file), original)
+  }
+
+  test("write fix to directory") {
+    val dir = File.createTempFile("project/src/main/scala", "sbt")
+    dir.delete()
+    dir.mkdirs()
+    assert(dir.isDirectory)
+
+    def createFile(): File = {
+      val file = File.createTempFile("file", ".scala", dir)
+      FileOps.writeFile(file, original)
+      file
+    }
+    val file1, file2 = createFile()
+
+    Cli.runOn(Cli.Config(Set(dir), inPlace = true))
+    assertNoDiff(FileOps.readFile(file1), expected)
+    assertNoDiff(FileOps.readFile(file2), expected)
+  }
 }

core/src/main/scala/scalafix/Scalafix.scala

@@ -3,7 +3,7 @@ package scalafix
 import scalafix.rewrite.Rewrite
 
 object Scalafix {
-  def fix(code: String, rewriters: Seq[Rewrite]): FixResult = {
+  def fix(code: String, rewriters: Seq[Rewrite] = Rewrite.default): FixResult = {
     rewriters.foldLeft[FixResult](FixResult.Success(code)) {
       case (newCode: FixResult.Success, rewriter) =>
         rewriter.rewrite(newCode.code)

core/src/test/scala/scalafix/ScalafixSuite.scala

@@ -45,4 +45,9 @@ class ScalafixSuite extends FunSuite with DiffAssertions {
         |}""".stripMargin
   )
 
+  test("on parse error") {
+    val obtained = Scalafix.fix("object A {")
+    assert(obtained.isInstanceOf[FixResult.ParseError])
+  }
+
 }