Cleanup

4 files changed, 63 insertions, 52 deletions

diff --git a/main/src/mill/Main.scala b/main/src/mill/Main.scala
index fceb5c9f..203f92e1 100644
--- a/main/src/mill/Main.scala
+++ b/main/src/mill/Main.scala
@@ -55,7 +55,10 @@ object Main {
             welcomeBanner = None
           )
 
-        val runner = new mill.main.MainRunner(config, System.out, System.err, System.in)
+        val runner = new mill.main.MainRunner(
+          config.copy(home = pwd / "out" / ".ammonite"),
+          System.out, System.err, System.in
+        )
         if (repl){
           runner.printInfo("Loading...")
           runner.runRepl()
diff --git a/main/src/mill/main/MainModule.scala b/main/src/mill/main/MainModule.scala
index 3ec99f12..07ba37a9 100644
--- a/main/src/mill/main/MainModule.scala
+++ b/main/src/mill/main/MainModule.scala
@@ -1,7 +1,27 @@
 package mill.main
 
+import mill.define.NamedTask
+import mill.eval.{Evaluator, Result}
 import mill.util.{PrintLogger, Watched}
 import pprint.{Renderer, Truncated}
+import upickle.Js
+object MainModule{
+  def resolveTasks[T](evaluator: Evaluator[Any], targets: Seq[String], multiSelect: Boolean)
+                     (f: List[NamedTask[Any]] => T) = {
+    RunScript.resolveTasks(evaluator, targets, multiSelect) match{
+      case Left(err) => Result.Failure(err)
+      case Right(tasks) => Result.Success(f(tasks))
+    }
+  }
+  def evaluateTasks[T](evaluator: Evaluator[Any], targets: Seq[String], multiSelect: Boolean)
+                      (f: Seq[(Any, Option[Js.Value])] => T) = {
+    RunScript.evaluateTasks(evaluator, targets, multiSelect) match{
+      case Left(err) => Result.Failure(err)
+      case Right((watched, Left(err))) => Result.Failure(err, Some(Watched((), watched)))
+      case Right((watched, Right(res))) => Result.Success(Watched((), watched))
+    }
+  }
+}
 
 trait MainModule extends mill.Module{
 
@@ -9,49 +29,41 @@ trait MainModule extends mill.Module{
   implicit def millScoptTasksReads[T] = new mill.main.Tasks.Scopt[T]()
   implicit def millScoptEvaluatorReads[T] = new mill.main.EvaluatorScopt[T]()
 
-  def resolve(evaluator: mill.eval.Evaluator[Any], targets: String*) = mill.T.command{
-    RunScript.resolveTargets(evaluator, targets, multiSelect = true) match{
-      case Left(err) => mill.eval.Result.Failure(err)
-      case Right(tasks) => mill.eval.Result.Success(tasks.foreach(println))
+  def resolve(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+    MainModule.resolveTasks(evaluator, targets, multiSelect = true){ tasks =>
+      tasks.foreach(println)
     }
   }
 
-  def describe(evaluator: mill.eval.Evaluator[Any], targets: String*) = mill.T.command{
-    RunScript.resolveTargets(evaluator, targets, multiSelect = true) match{
-      case Left(err) => mill.eval.Result.Failure(err)
-      case Right(tasks) =>
-        for{
-          task <- tasks
-          tree = ReplApplyHandler.pprintTask(task, evaluator)
-          val defaults = pprint.PPrinter()
-          val renderer = new Renderer(
-            defaults.defaultWidth,
-            defaults.colorApplyPrefix,
-            defaults.colorLiteral,
-            defaults.defaultIndent
-          )
-          val rendered = renderer.rec(tree, 0, 0).iter
-          val truncated = new Truncated(rendered, defaults.defaultWidth, defaults.defaultHeight)
-          str <- truncated ++ Iterator("\n")
-        } {
-          print(str)
-        }
-        mill.eval.Result.Success(())
+  def describe(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+    MainModule.resolveTasks(evaluator, targets, multiSelect = true){ tasks =>
+      for{
+        task <- tasks
+        tree = ReplApplyHandler.pprintTask(task, evaluator)
+        val defaults = pprint.PPrinter()
+        val renderer = new Renderer(
+          defaults.defaultWidth,
+          defaults.colorApplyPrefix,
+          defaults.colorLiteral,
+          defaults.defaultIndent
+        )
+        val rendered = renderer.rec(tree, 0, 0).iter
+        val truncated = new Truncated(rendered, defaults.defaultWidth, defaults.defaultHeight)
+        str <- truncated ++ Iterator("\n")
+      } {
+        print(str)
+      }
     }
   }
 
-  def all(evaluator: mill.eval.Evaluator[Any],
-          targets: String*) = mill.T.command{
-    RunScript.evaluateTarget(evaluator, targets, multiSelect = true) match{
-      case Left(err) => mill.eval.Result.Failure(err)
-      case Right((watched, Left(err))) => mill.eval.Result.Failure(err, Some(Watched((), watched)))
-      case Right((watched, Right(res))) => mill.eval.Result.Success(Watched((), watched))
+  def all(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+    MainModule.evaluateTasks(evaluator, targets, multiSelect = true) {res =>
+      res.flatMap(_._2)
     }
   }
 
-  def show(evaluator: mill.eval.Evaluator[Any],
-           targets: String*) = mill.T.command{
-    RunScript.evaluateTarget(
+  def show(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+    MainModule.evaluateTasks(
       evaluator.copy(
         // When using `show`, redirect all stdout of the evaluated tasks so the
         // printed JSON is the only thing printed to stdout.
@@ -62,14 +74,10 @@ trait MainModule extends mill.Module{
       ),
       targets,
       multiSelect = false
-    ) match{
-      case Left(err) => mill.eval.Result.Failure(err)
-      case Right((watched, Left(err))) => mill.eval.Result.Failure(err, Some(Watched((), watched)))
-      case Right((watched, Right(res))) =>
-        for(json <- res.flatMap(_._2)){
-          println(json)
-        }
-        mill.eval.Result.Success(Watched((), watched))
+    ) {res =>
+      for(json <- res.flatMap(_._2)){
+        println(json)
+      }
     }
   }
 }
diff --git a/main/src/mill/main/MainScopts.scala b/main/src/mill/main/MainScopts.scala
index f8f99c88..653a299d 100644
--- a/main/src/mill/main/MainScopts.scala
+++ b/main/src/mill/main/MainScopts.scala
@@ -9,7 +9,7 @@ object Tasks{
     def arity = 1
 
     def reads = s => {
-      RunScript.resolveTargets(Evaluator.currentEvaluator.get, Seq(s), multiSelect = false) match{
+      RunScript.resolveTasks(Evaluator.currentEvaluator.get, Seq(s), multiSelect = false) match{
         case Left(err) => throw new Exception(err)
         case Right(tasks) => Tasks(tasks).asInstanceOf[Tasks[T]]
       }
diff --git a/main/src/mill/main/RunScript.scala b/main/src/mill/main/RunScript.scala
index 5b5eb429..4ee16ac3 100644
--- a/main/src/mill/main/RunScript.scala
+++ b/main/src/mill/main/RunScript.scala
@@ -52,7 +52,7 @@ object RunScript{
 
     val evaluated = for{
       evaluator <- evalRes
-      (evalWatches, res) <- Res(evaluateTarget(evaluator, scriptArgs, multiSelect = false))
+      (evalWatches, res) <- Res(evaluateTasks(evaluator, scriptArgs, multiSelect = false))
     } yield {
       val alreadyStale = evalWatches.exists(p => p.sig != new PathRef(p.path, p.quick).sig)
       // If the file changed between the creation of the original
@@ -129,9 +129,9 @@ object RunScript{
     } yield (module, discover)
   }
 
-  def resolveTargets[T](evaluator: Evaluator[T],
-                        scriptArgs: Seq[String],
-                        multiSelect: Boolean) = {
+  def resolveTasks[T](evaluator: Evaluator[T],
+                      scriptArgs: Seq[String],
+                      multiSelect: Boolean) = {
     for {
       parsed <- ParseArgs(scriptArgs, multiSelect = multiSelect)
       (selectors, args) = parsed
@@ -172,10 +172,10 @@ object RunScript{
     } yield taskss.flatten
   }
 
-  def evaluateTarget[T](evaluator: Evaluator[T],
-                        scriptArgs: Seq[String],
-                        multiSelect: Boolean) = {
-    for (targets <- resolveTargets(evaluator, scriptArgs, multiSelect)) yield {
+  def evaluateTasks[T](evaluator: Evaluator[T],
+                       scriptArgs: Seq[String],
+                       multiSelect: Boolean) = {
+    for (targets <- resolveTasks(evaluator, scriptArgs, multiSelect)) yield {
       val (watched, res) = evaluate(evaluator, Agg.from(targets.distinct))
 
       val watched2 = for{