[WIP] Fixes #227; add mill clean

main/src/mill/main/MainModule.scala

@@ -1,10 +1,12 @@
 package mill.main
 
+import ammonite.ops.Path
 import mill.define.{NamedTask, Task}
 import mill.eval.{Evaluator, Result}
-import mill.util.{EitherOps, ParseArgs, PrintLogger, Watched}
+import mill.util.{ParseArgs, 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) = {
@@ -35,6 +37,9 @@ trait MainModule extends mill.Module{
     println(res)
     res
   }
+
+  private val OutDir: String = "out"
+
   /**
     * Resolves a mill query string and prints out the tasks it resolves to.
     */
@@ -177,4 +182,32 @@ trait MainModule extends mill.Module{
       }
     }
   }
+
+  /**
+    * Deletes the given targets from the out directory. Providing no targets
+    * will clean everything.
+    */
+  def clean(evaluator: Evaluator[Any], targets: String*) = mill.T.command {
+
+    val rootDir = ammonite.ops.pwd / OutDir
+
+    val pathsToRemove =
+      if (targets.isEmpty)
+        Right(List(rootDir))
+      else
+        RunScript.resolveTasks(
+          mill.main.ResolveSegments, evaluator, targets, multiSelect = true
+        ).map(_.map { segments =>
+          Evaluator.resolveDestPaths(rootDir, segments).out
+        })
+
+    pathsToRemove match {
+      case Left(err) =>
+        Result.Failure(err)
+      case Right(paths) =>
+        paths.foreach(ammonite.ops.rm)
+        Result.Success(())
+    }
+  }
+
 }

main/src/mill/main/Resolve.scala

@@ -86,6 +86,61 @@ object ResolveMetadata extends Resolve[String]{
   }
 }
 
+object ResolveSegments extends Resolve[Segments] {
+
+  override def endResolveCross(obj: Module,
+                               revSelectorsSoFar: List[Segment],
+                               last: List[String],
+                               discover: Discover[_],
+                               rest: Seq[String]): Either[String, Seq[Segments]] = {
+    obj match{
+      case c: Cross[Module] =>
+        Right(c.items.map(_._2.millModuleSegments))
+      case _ =>
+        Left(
+          Resolve.unableToResolve(Segment.Cross(last), revSelectorsSoFar) +
+            Resolve.hintListLabel(revSelectorsSoFar)
+        )
+    }
+  }
+
+  def endResolveLabel(obj: Module,
+                      revSelectorsSoFar: List[Segment],
+                      last: String,
+                      discover: Discover[_],
+                      rest: Seq[String]): Either[String, Seq[Segments]] = {
+    val target =
+      obj
+        .millInternal
+        .reflect[Target[_]]
+        .find(_.label == last)
+        .map(t => Right(t.ctx.segments))
+
+    val command =
+      Resolve
+        .invokeCommand(obj, last, discover, rest)
+        .headOption
+        .map(_.map(_.ctx.segments))
+
+    val module =
+      obj.millInternal
+        .reflectNestedObjects[Module]
+        .find(_.millOuterCtx.segment == Segment.Label(last))
+        .map(m => Right(m.millModuleSegments))
+
+    command orElse target orElse module match {
+      case None =>
+        Resolve.errorMsgLabel(
+          singleModuleMeta(obj, discover, revSelectorsSoFar.isEmpty),
+          last,
+          revSelectorsSoFar
+        )
+
+      case Some(either) => either.right.map(Seq(_))
+    }
+  }
+}
+
 object ResolveTasks extends Resolve[NamedTask[Any]]{
 
 

readme.md

@@ -67,6 +67,17 @@ You can get Mill to show the JSON-structured output for a particular `Target` or
 
 Output will be generated into a the `./out` folder.
 
+You can clean the project using `clean`:
+
+```bash
+# Clean entire project.
+mill clean
+# Clean a single target.
+mill clean main
+# Clean multiple targets.
+mill clean main core
+```
+
 If you are repeatedly testing Mill manually by running it against the `build.sc`
 file in the repository root, you can skip the assembly process and directly run
 it via: