dependencyTree output path WIP

Author: ryan-williams

src/main/scala/net/virtualvoid/sbt/graph/DependencyGraphSettings.scala

@@ -16,6 +16,8 @@
 
 package net.virtualvoid.sbt.graph
 
+import java.nio.file.{ Files, Path, Paths }
+
 import net.virtualvoid.sbt.graph.GraphTransformations.reverseGraphStartingAt
 import net.virtualvoid.sbt.graph.backend.{ IvyReport, SbtUpdateReport }
 import net.virtualvoid.sbt.graph.model.{ FilterRule, ModuleGraph, ModuleId }
@@ -80,7 +82,17 @@ object DependencyGraphSettings {
       moduleGraph.value,
       filterRulesParser.parsed: _*
     ),
-    dependencyTree := streams.value.log.info(asciiTree.evaluated),
+    dependencyTree := {
+      dependencyTreeOutputPathParser.parsed match {
+        case Some(path) ⇒
+          val os = Files.newOutputStream(path)
+          os.write(asciiTree.evaluated.getBytes)
+          os.close()
+        case _ ⇒
+          streams.value.log.info(asciiTree.evaluated)
+      }
+
+    },
     dependencyGraphMLFile := { target.value / "dependencies-%s.graphml".format(config.toString) },
     dependencyGraphML := dependencyGraphMLTask.value,
     dependencyDotFile := { target.value / "dependencies-%s.dot".format(config.toString) },
@@ -174,27 +186,40 @@ object DependencyGraphSettings {
       }.mkString("\n\n")
     streams.log.info(output)
   }
-  val shouldForceParser: State ⇒ Parser[Boolean] = { (state: State) ⇒
-    import sbt.complete.DefaultParsers._
 
+  import sbt.complete.DefaultParsers._
+
+  val shouldForceParser: State ⇒ Parser[Boolean] = { (state: State) ⇒
     (Space ~> token("--force")).?.map(_.isDefined)
   }
 
+  val dependencyTreeOutputPathParser: State ⇒ Parser[Option[Path]] = { (state: State) ⇒
+    (
+      Space ~
+        (token("--out") | token("-o")) ~>
+        StringBasic
+    )
+    .map(Paths.get(_))
+    .?
+  }
+
+  val filterRulesParser_ = {
+    (Space ~> token(StringBasic, "filter")).*.map {
+      _.map(FilterRule(_))
+    }
+  }
+
   val filterRulesParser: Def.Initialize[State ⇒ Parser[Seq[FilterRule]]] =
     resolvedScoped { ctx ⇒
       (state: State) ⇒
-        import sbt.complete.DefaultParsers._
-        (Space ~> token(StringBasic, "filter")).*.map {
-          _.map(FilterRule(_))
-        }
+      filterRulesParser_
     }
 
   val artifactIdParser: Def.Initialize[State ⇒ Parser[ModuleId]] =
     resolvedScoped { ctx ⇒
       (state: State) ⇒
         val graph = loadFromContext(moduleGraphStore, ctx, state) getOrElse ModuleGraph(Nil, Nil)
 
-        import sbt.complete.DefaultParsers._
         graph
           .nodes
           .map(_.id)