diff options
Diffstat (limited to 'core/src/main/scala')
27 files changed, 0 insertions, 2731 deletions
diff --git a/core/src/main/scala/mill/Main.scala b/core/src/main/scala/mill/Main.scala deleted file mode 100644 index 3025994c..00000000 --- a/core/src/main/scala/mill/Main.scala +++ /dev/null @@ -1,83 +0,0 @@ -package mill - -import ammonite.main.Cli.{formatBlock, genericSignature, replSignature} -import ammonite.ops._ -import ammonite.util.Util - -object Main { - case class Config(home: ammonite.ops.Path = pwd/'out/'ammonite, - colored: Option[Boolean] = None, - help: Boolean = false, - repl: Boolean = false, - watch: Boolean = false) - - def main(args: Array[String]): Unit = { - - import ammonite.main.Cli - - var show = false - val showCliArg = Cli.Arg[Cli.Config, Unit]( - "show", - None, - "Display the json-formatted value of the given target, if any", - (x, _) => { - show = true - x - } - ) - val removed = Set("predef-code", "home", "no-home-predef") - val millArgSignature = (Cli.genericSignature :+ showCliArg).filter(a => !removed(a.name)) - Cli.groupArgs( - args.toList, - millArgSignature, - Cli.Config(remoteLogging = false) - ) match{ - case Left(msg) => - System.err.println(msg) - System.exit(1) - case Right((cliConfig, _)) if cliConfig.help => - val leftMargin = millArgSignature.map(ammonite.main.Cli.showArg(_).length).max + 2 - System.out.println( - s"""Mill Build Tool - |usage: mill [mill-options] [target [target-options]] - | - |${formatBlock(millArgSignature, leftMargin).mkString(Util.newLine)}""".stripMargin - ) - System.exit(0) - case Right((cliConfig, leftoverArgs)) => - - val repl = leftoverArgs.isEmpty - val config = - if(!repl) cliConfig - else cliConfig.copy( - predefCode = - """import $file.build, build._ - |implicit val replApplyHandler = mill.main.ReplApplyHandler( - | interp.colors(), - | repl.pprinter(), - | build.millSelf.get, - | build.millDiscover - |) - |repl.pprinter() = replApplyHandler.pprinter - |import replApplyHandler.generatedEval._ - | - """.stripMargin, - welcomeBanner = None - ) - - val runner = new mill.main.MainRunner( - config, show, - System.out, System.err, System.in - ) - if (repl){ - runner.printInfo("Loading...") - runner.runRepl() - } else { - val result = runner.runScript(pwd / "build.sc", leftoverArgs) - System.exit(if(result) 0 else 1) - } - } - } -} - - diff --git a/core/src/main/scala/mill/define/Applicative.scala b/core/src/main/scala/mill/define/Applicative.scala deleted file mode 100644 index 69c506f7..00000000 --- a/core/src/main/scala/mill/define/Applicative.scala +++ /dev/null @@ -1,108 +0,0 @@ -package mill.define - -import scala.annotation.{StaticAnnotation, compileTimeOnly} -import scala.language.higherKinds -import scala.reflect.macros.blackbox.Context - -/** - * A generic Applicative-functor macro: translates calls to - * - * Applier.apply{ ... applyable1.apply() ... applyable2.apply() ... } - * - * into - * - * Applier.zipMap(applyable1, applyable2){ (a1, a2, ctx) => ... a1 ... a2 ... } - */ -object Applicative { - trait ApplyHandler[M[+_]]{ - def apply[T](t: M[T]): T - } - object ApplyHandler{ - @compileTimeOnly("Target#apply() can only be used with a T{...} block") - implicit def defaultApplyHandler[M[+_]]: ApplyHandler[M] = ??? - } - trait Applyable[M[+_], +T]{ - def self: M[T] - def apply()(implicit handler: ApplyHandler[M]): T = handler(self) - } - class ImplicitStub extends StaticAnnotation - type Id[+T] = T - - trait Applyer[W[_], T[_], Z[_], Ctx] extends ApplyerGenerated[T, Z, Ctx] { - def ctx()(implicit c: Ctx) = c - def underlying[A](v: W[A]): T[_] - - def zipMap[R]()(cb: Ctx => Z[R]) = mapCtx(zip()){ (_, ctx) => cb(ctx)} - def zipMap[A, R](a: T[A])(f: (A, Ctx) => Z[R]) = mapCtx(a)(f) - def zip(): T[Unit] - def zip[A](a: T[A]): T[Tuple1[A]] - } - - def impl[M[_], T: c.WeakTypeTag, Ctx: c.WeakTypeTag](c: Context) - (t: c.Expr[T]): c.Expr[M[T]] = { - impl0(c)(t.tree)(implicitly[c.WeakTypeTag[T]], implicitly[c.WeakTypeTag[Ctx]]) - } - def impl0[M[_], T: c.WeakTypeTag, Ctx: c.WeakTypeTag](c: Context) - (t: c.Tree): c.Expr[M[T]] = { - import c.universe._ - def rec(t: Tree): Iterator[c.Tree] = Iterator(t) ++ t.children.flatMap(rec(_)) - - val bound = collection.mutable.Buffer.empty[(c.Tree, ValDef)] - val targetApplySym = typeOf[Applyable[Nothing, _]].member(TermName("apply")) - - // Derived from @olafurpg's - // https://gist.github.com/olafurpg/596d62f87bf3360a29488b725fbc7608 - val defs = rec(t).filter(_.isDef).map(_.symbol).toSet - - val ctxName = TermName(c.freshName("ctx")) - val ctxSym = c.internal.newTermSymbol(c.internal.enclosingOwner, ctxName) - c.internal.setInfo(ctxSym, weakTypeOf[Ctx]) - - val transformed = c.internal.typingTransform(t) { - case (t @ q"$fun.apply()($handler)", api) if t.symbol == targetApplySym => - - val localDefs = rec(fun).filter(_.isDef).map(_.symbol).toSet - val banned = rec(t).filter(x => defs(x.symbol) && !localDefs(x.symbol)) - - if (banned.hasNext){ - val banned0 = banned.next() - c.abort( - banned0.pos, - "Target#apply() call cannot use `" + banned0.symbol + "` defined within the T{...} block" - ) - } - val tempName = c.freshName(TermName("tmp")) - val tempSym = c.internal.newTermSymbol(c.internal.enclosingOwner, tempName) - c.internal.setInfo(tempSym, t.tpe) - val tempIdent = Ident(tempSym) - c.internal.setType(tempIdent, t.tpe) - c.internal.setFlag(tempSym, (1L << 44).asInstanceOf[c.universe.FlagSet]) - bound.append((q"${c.prefix}.underlying($fun)", c.internal.valDef(tempSym))) - tempIdent - case (t, api) - if t.symbol != null - && t.symbol.annotations.exists(_.tree.tpe =:= typeOf[ImplicitStub]) => - - val tempIdent = Ident(ctxSym) - c.internal.setType(tempIdent, t.tpe) - c.internal.setFlag(ctxSym, (1L << 44).asInstanceOf[c.universe.FlagSet]) - tempIdent - - case (t, api) => api.default(t) - } - - val (exprs, bindings) = bound.unzip - - - val ctxBinding = c.internal.valDef(ctxSym) - - val callback = c.typecheck(q"(..$bindings, $ctxBinding) => $transformed ") - - val res = q"${c.prefix}.zipMap(..$exprs){ $callback }" - - c.internal.changeOwner(transformed, c.internal.enclosingOwner, callback.symbol) - - c.Expr[M[T]](res) - } - -} diff --git a/core/src/main/scala/mill/define/Cross.scala b/core/src/main/scala/mill/define/Cross.scala deleted file mode 100644 index b51064be..00000000 --- a/core/src/main/scala/mill/define/Cross.scala +++ /dev/null @@ -1,90 +0,0 @@ -package mill.define -import language.experimental.macros -import scala.reflect.macros.blackbox - - -object Cross{ - case class Factory[T](make: (Product, mill.define.Ctx) => T) - - object Factory{ - implicit def make[T]: Factory[T] = macro makeImpl[T] - def makeImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Factory[T]] = { - import c.universe._ - val tpe = weakTypeOf[T] - - val primaryConstructorArgs = - tpe.typeSymbol.asClass.primaryConstructor.typeSignature.paramLists.head - - val argTupleValues = - for((a, n) <- primaryConstructorArgs.zipWithIndex) - yield q"v.productElement($n).asInstanceOf[${a.info}]" - - val instance = c.Expr[(Product, mill.define.Ctx) => T]( - q"{ (v, ctx0) => new $tpe(..$argTupleValues){ override def millOuterCtx = ctx0 } }" - ) - - reify { mill.define.Cross.Factory[T](instance.splice) } - } - } - - trait Resolver[-T]{ - def resolve[V <: T](c: Cross[V]): V - } -} - -/** - * Models "cross-builds": sets of duplicate builds which differ only in the - * value of one or more "case" variables whose values are determined at runtime. - * Used via: - * - * object foo extends Cross[FooModule]("bar", "baz", "qux") - * class FooModule(v: String) extends Module{ - * ... - * } - */ -class Cross[T](cases: Any*) - (implicit ci: Cross.Factory[T], - ctx: mill.define.Ctx) extends mill.define.Module()(ctx) { - - override lazy val millModuleDirectChildren = - this.millInternal.reflectNestedObjects[Module] ++ - items.collect{case (k, v: mill.define.Module) => v} - - val items = for(c0 <- cases.toList) yield{ - val c = c0 match{ - case p: Product => p - case v => Tuple1(v) - } - val crossValues = c.productIterator.toList - val relPath = ctx.segment.pathSegments - val sub = ci.make( - c, - ctx.copy( - segments = ctx.segments ++ Seq(ctx.segment), - basePath = ctx.basePath / relPath, - segment = Segment.Cross(crossValues) - ) - ) - (crossValues, sub) - } - val itemMap = items.toMap - - /** - * Fetch the cross module corresponding to the given cross values - */ - def get(args: Seq[Any]) = itemMap(args.toList) - - /** - * Fetch the cross module corresponding to the given cross values - */ - def apply(arg0: Any, args: Any*) = itemMap(arg0 :: args.toList) - - /** - * Fetch the relevant cross module given the implicit resolver you have in - * scope. This is often the first cross module whose cross-version is - * compatible with the current module. - */ - def apply[V >: T]()(implicit resolver: Cross.Resolver[V]): T = { - resolver.resolve(this.asInstanceOf[Cross[V]]).asInstanceOf[T] - } -}
\ No newline at end of file diff --git a/core/src/main/scala/mill/define/Ctx.scala b/core/src/main/scala/mill/define/Ctx.scala deleted file mode 100644 index 6d685521..00000000 --- a/core/src/main/scala/mill/define/Ctx.scala +++ /dev/null @@ -1,69 +0,0 @@ -package mill.define - -import ammonite.main.Router.Overrides -import ammonite.ops.{Path, RelPath} - -import scala.annotation.implicitNotFound - -sealed trait Segment{ - def pathSegments: Seq[String] = this match{ - case Segment.Label(s) => List(s) - case Segment.Cross(vs) => vs.map(_.toString) - } -} -object Segment{ - case class Label(value: String) extends Segment - case class Cross(value: Seq[Any]) extends Segment -} - -case class BasePath(value: Path) - - -/** - * Models a path with the Mill build hierarchy, e.g. - * - * amm.util[2.11].test.compile - * - * .-separated segments are [[Segment.Label]]s, while []-delimited - * segments are [[Segment.Cross]]s - */ -case class Segments(value: Segment*){ - def ++(other: Seq[Segment]): Segments = Segments(value ++ other:_*) - def ++(other: Segments): Segments = Segments(value ++ other.value:_*) - def render = value match { - case Nil => "" - case Segment.Label(head) :: rest => - val stringSegments = rest.map{ - case Segment.Label(s) => "." + s - case Segment.Cross(vs) => "[" + vs.mkString(",") + "]" - } - head + stringSegments.mkString - } -} - -@implicitNotFound("Modules, Targets and Commands can only be defined within a mill Module") -case class Ctx(enclosing: String, - lineNum: Int, - segment: Segment, - basePath: Path, - segments: Segments, - overrides: Int){ -} - -object Ctx{ - implicit def make(implicit millModuleEnclosing0: sourcecode.Enclosing, - millModuleLine0: sourcecode.Line, - millName0: sourcecode.Name, - millModuleBasePath0: BasePath, - segments0: Segments, - overrides0: Overrides): Ctx = { - Ctx( - millModuleEnclosing0.value, - millModuleLine0.value, - Segment.Label(millName0.value), - millModuleBasePath0.value, - segments0, - overrides0.value - ) - } -}
\ No newline at end of file diff --git a/core/src/main/scala/mill/define/Discover.scala b/core/src/main/scala/mill/define/Discover.scala deleted file mode 100644 index 52f4ab77..00000000 --- a/core/src/main/scala/mill/define/Discover.scala +++ /dev/null @@ -1,57 +0,0 @@ -package mill.define -import language.experimental.macros -import ammonite.main.Router.EntryPoint - -import scala.collection.mutable -import scala.reflect.macros.blackbox - -case class Discover(value: Map[Class[_], Seq[EntryPoint[_]]]) -object Discover { - def apply[T]: Discover = macro applyImpl[T] - - def applyImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Discover] = { - import c.universe._ - import compat._ - val seen = mutable.Set.empty[Type] - def rec(tpe: Type): Unit = { - if (!seen(tpe)){ - seen.add(tpe) - for{ - m <- tpe.members - memberTpe = m.typeSignature - if memberTpe.resultType <:< typeOf[mill.define.Module] && memberTpe.paramLists.isEmpty - } rec(memberTpe.resultType) - - if (tpe <:< typeOf[mill.define.Cross[_]]){ - val inner = typeOf[Cross[_]] - .typeSymbol - .asClass - .typeParams - .head - .asType - .toType - .asSeenFrom(tpe, typeOf[Cross[_]].typeSymbol) - - rec(inner) - } - } - } - rec(weakTypeOf[T]) - - val router = new ammonite.main.Router(c) - val mapping = for{ - discoveredModuleType <- seen - val routes = router.getAllRoutesForClass( - discoveredModuleType.asInstanceOf[router.c.Type], - _.returnType <:< weakTypeOf[mill.define.Command[_]].asInstanceOf[router.c.Type] - ).map(_.asInstanceOf[c.Tree]) - if routes.nonEmpty - } yield { - val lhs = q"classOf[${discoveredModuleType.typeSymbol.asClass}]" - val rhs = q"scala.Seq[ammonite.main.Router.EntryPoint[${discoveredModuleType.typeSymbol.asClass}]](..$routes)" - q"$lhs -> $rhs" - } - - c.Expr[Discover](q"mill.define.Discover(scala.collection.immutable.Map(..$mapping))") - } -} diff --git a/core/src/main/scala/mill/define/Graph.scala b/core/src/main/scala/mill/define/Graph.scala deleted file mode 100644 index f06dca11..00000000 --- a/core/src/main/scala/mill/define/Graph.scala +++ /dev/null @@ -1,61 +0,0 @@ -package mill.define - -import mill.eval.Tarjans -import mill.util.MultiBiMap -import mill.util.Strict.Agg - -object Graph { - class TopoSorted private[Graph](val values: Agg[Task[_]]) - def groupAroundImportantTargets[T](topoSortedTargets: TopoSorted) - (important: PartialFunction[Task[_], T]): MultiBiMap[T, Task[_]] = { - - val output = new MultiBiMap.Mutable[T, Task[_]]() - for ((target, t) <- topoSortedTargets.values.flatMap(t => important.lift(t).map((t, _)))) { - - val transitiveTargets = new Agg.Mutable[Task[_]] - def rec(t: Task[_]): Unit = { - if (transitiveTargets.contains(t)) () // do nothing - else if (important.isDefinedAt(t) && t != target) () // do nothing - else { - transitiveTargets.append(t) - t.inputs.foreach(rec) - } - } - rec(target) - output.addAll(t, topoSorted(transitiveTargets).values) - } - output - } - - def transitiveTargets(sourceTargets: Agg[Task[_]]): Agg[Task[_]] = { - val transitiveTargets = new Agg.Mutable[Task[_]] - def rec(t: Task[_]): Unit = { - if (transitiveTargets.contains(t)) () // do nothing - else { - transitiveTargets.append(t) - t.inputs.foreach(rec) - } - } - - sourceTargets.items.foreach(rec) - transitiveTargets - } - /** - * Takes the given targets, finds all the targets they transitively depend - * on, and sort them topologically. Fails if there are dependency cycles - */ - def topoSorted(transitiveTargets: Agg[Task[_]]): TopoSorted = { - - val indexed = transitiveTargets.indexed - val targetIndices = indexed.zipWithIndex.toMap - - val numberedEdges = - for(t <- transitiveTargets.items) - yield t.inputs.collect(targetIndices) - - val sortedClusters = Tarjans(numberedEdges) - val nonTrivialClusters = sortedClusters.filter(_.length > 1) - assert(nonTrivialClusters.isEmpty, nonTrivialClusters) - new TopoSorted(Agg.from(sortedClusters.flatten.map(indexed))) - } -} diff --git a/core/src/main/scala/mill/define/Module.scala b/core/src/main/scala/mill/define/Module.scala deleted file mode 100644 index e42ce798..00000000 --- a/core/src/main/scala/mill/define/Module.scala +++ /dev/null @@ -1,104 +0,0 @@ -package mill.define - -import java.lang.reflect.Modifier - -import ammonite.main.Router.{EntryPoint, Overrides} -import ammonite.ops.Path - -import scala.language.experimental.macros -import scala.reflect.ClassTag -import scala.reflect.macros.blackbox -/** - * `Module` is a class meant to be extended by `trait`s *only*, in order to - * propagate the implicit parameters forward to the final concrete - * instantiation site so they can capture the enclosing/line information of - * the concrete instance. - */ -class Module(implicit outerCtx0: mill.define.Ctx) extends mill.moduledefs.Cacher{ outer => - - /** - * Miscellaneous machinery around traversing & querying the build hierarchy, - * that should not be needed by normal users of Mill - */ - object millInternal extends Module.Internal(this) - - lazy val millModuleDirectChildren = millInternal.reflectNestedObjects[Module] - def millOuterCtx = outerCtx0 - def basePath: Path = millOuterCtx.basePath / millOuterCtx.segment.pathSegments - implicit def millModuleBasePath: BasePath = BasePath(basePath) - implicit def millModuleSegments: Segments = { - millOuterCtx.segments ++ Seq(millOuterCtx.segment) - } -} - -object Module{ - class Internal(outer: Module){ - def traverse[T](f: Module => Seq[T]): Seq[T] = { - def rec(m: Module): Seq[T] = f(m) ++ m.millModuleDirectChildren.flatMap(rec) - rec(outer) - } - lazy val segmentsToModules = traverse{m => Seq(m.millModuleSegments -> m)} - .toMap - - lazy val targets = traverse{_.millInternal.reflect[Target[_]]}.toSet - - lazy val segmentsToTargets = targets - .map(t => (t.ctx.segments, t)) - .toMap - - // Ensure we do not propagate the implicit parameters as implicits within - // the body of any inheriting class/trait/objects, as it would screw up any - // one else trying to use sourcecode.{Enclosing,Line} to capture debug info - lazy val millModuleEnclosing = outer.millOuterCtx.enclosing - lazy val millModuleLine = outer.millOuterCtx.lineNum - - def reflect[T: ClassTag] = { - outer - .getClass - .getMethods - .filter(!_.getName.contains('$')) - .filter(_.getParameterCount == 0) - .filter(x => (x.getModifiers & Modifier.STATIC) == 0) - .filter(implicitly[ClassTag[T]].runtimeClass isAssignableFrom _.getReturnType) - .map(_.invoke(outer).asInstanceOf[T]) - } - def reflectNames[T: ClassTag] = { - outer - .getClass - .getMethods - .filter(x => (x.getModifiers & Modifier.STATIC) == 0) - .filter(implicitly[ClassTag[T]].runtimeClass isAssignableFrom _.getReturnType) - .map(_.getName) - } - // For some reason, this fails to pick up concrete `object`s nested directly within - // another top-level concrete `object`. This is fine for now, since Mill's Ammonite - // script/REPL runner always wraps user code in a wrapper object/trait - def reflectNestedObjects[T: ClassTag] = { - reflect[T] ++ - outer - .getClass - .getClasses - .filter(implicitly[ClassTag[T]].runtimeClass isAssignableFrom _) - .flatMap(c => c.getFields.find(_.getName == "MODULE$").map(_.get(c).asInstanceOf[T])) - } - } -} -trait TaskModule extends Module { - def defaultCommandName(): String -} - -class BaseModule(basePath0: Path) - (implicit millModuleEnclosing0: sourcecode.Enclosing, - millModuleLine0: sourcecode.Line, - millName0: sourcecode.Name, - overrides0: Overrides) - extends Module()( - mill.define.Ctx.make(implicitly, implicitly, implicitly, BasePath(basePath0), Segments(), implicitly) - ){ - // A BaseModule should provide an empty Segments list to it's children, since - // it is the root of the module tree, and thus must not include it's own - // sourcecode.Name as part of the list, - override implicit def millModuleSegments: Segments = Segments() - override implicit def millModuleBasePath: BasePath = BasePath(millOuterCtx.basePath) - override def basePath = millOuterCtx.basePath -}
\ No newline at end of file diff --git a/core/src/main/scala/mill/define/Task.scala b/core/src/main/scala/mill/define/Task.scala deleted file mode 100644 index 90908e4e..00000000 --- a/core/src/main/scala/mill/define/Task.scala +++ /dev/null @@ -1,308 +0,0 @@ -package mill.define - -import mill.define.Applicative.Applyable -import mill.eval.{PathRef, Result} - -import upickle.default.{ReadWriter => RW, Reader => R, Writer => W} - -import scala.language.experimental.macros -import scala.reflect.macros.blackbox.Context - -/** - * Models a single node in the Mill build graph, with a list of inputs and a - * single output of type [[T]]. - * - * Generally not instantiated manually, but instead constructed via the - * [[Target.apply]] & similar macros. - */ -abstract class Task[+T] extends Task.Ops[T] with Applyable[Task, T]{ - /** - * What other Targets does this Target depend on? - */ - val inputs: Seq[Task[_]] - - /** - * Evaluate this target - */ - def evaluate(args: mill.util.Ctx): Result[T] - - /** - * Even if this target's inputs did not change, does it need to re-evaluate - * anyway? - */ - def sideHash: Int = 0 - - def flushDest: Boolean = true - - def asTarget: Option[Target[T]] = None - def asCommand: Option[Command[T]] = None - def asPersistent: Option[Persistent[T]] = None - def self = this -} - -trait NamedTask[+T] extends Task[T]{ - def ctx: mill.define.Ctx - def label = ctx.segment match{case Segment.Label(v) => v} -} -trait Target[+T] extends NamedTask[T]{ - override def asTarget = Some(this) - def readWrite: RW[_] -} - -object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Result, mill.util.Ctx] { - - implicit def apply[T](t: T) - (implicit r: R[T], - w: W[T], - ctx: mill.define.Ctx): Target[T] = macro targetImpl[T] - - def targetImpl[T: c.WeakTypeTag](c: Context) - (t: c.Expr[T]) - (r: c.Expr[R[T]], - w: c.Expr[W[T]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = { - import c.universe._ - val lhs = Applicative.impl0[Task, T, mill.util.Ctx](c)(reify(Result.Success(t.splice)).tree) - - mill.moduledefs.Cacher.impl0[TargetImpl[T]](c)( - reify( - new TargetImpl[T](lhs.splice, ctx.splice, RW(w.splice.write, r.splice.read)) - ) - ) - } - - implicit def apply[T](t: Result[T]) - (implicit r: R[T], - w: W[T], - ctx: mill.define.Ctx): Target[T] = macro targetResultImpl[T] - - def targetResultImpl[T: c.WeakTypeTag](c: Context) - (t: c.Expr[Result[T]]) - (r: c.Expr[R[T]], - w: c.Expr[W[T]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = { - import c.universe._ - mill.moduledefs.Cacher.impl0[Target[T]](c)( - reify( - new TargetImpl[T]( - Applicative.impl0[Task, T, mill.util.Ctx](c)(t.tree).splice, - ctx.splice, - RW(w.splice.write, r.splice.read) - ) - ) - ) - } - - def apply[T](t: Task[T]) - (implicit r: R[T], - w: W[T], - ctx: mill.define.Ctx): Target[T] = macro targetTaskImpl[T] - - def targetTaskImpl[T: c.WeakTypeTag](c: Context) - (t: c.Expr[Task[T]]) - (r: c.Expr[R[T]], - w: c.Expr[W[T]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = { - import c.universe._ - mill.moduledefs.Cacher.impl0[Target[T]](c)( - reify( - new TargetImpl[T](t.splice, ctx.splice, RW(w.splice.write, r.splice.read)) - ) - ) - } - - def source(value: Result[ammonite.ops.Path]) - (implicit r: R[PathRef], - w: W[PathRef], - ctx: mill.define.Ctx): Input[PathRef] = macro sourceImpl - - def sourceImpl(c: Context) - (value: c.Expr[Result[ammonite.ops.Path]]) - (r: c.Expr[R[PathRef]], - w: c.Expr[W[PathRef]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Input[PathRef]] = { - import c.universe._ - val wrapped: c.Expr[Result[PathRef]] = reify(value.splice match{ - case Result.Success(p) => Result.Success(PathRef(p)) - case x: Result.Failing => x - }) - mill.moduledefs.Cacher.impl0[Input[PathRef]](c)( - reify( - new Input[PathRef]( - Applicative.impl0[Task, PathRef, mill.util.Ctx](c)(wrapped.tree).splice, - ctx.splice, - RW(w.splice.write, r.splice.read), - ) - ) - ) - } - - def input[T](value: Result[T]) - (implicit r: R[T], - w: W[T], - ctx: mill.define.Ctx): Input[T] = macro inputImpl[T] - - def inputImpl[T: c.WeakTypeTag](c: Context) - (value: c.Expr[T]) - (r: c.Expr[R[T]], - w: c.Expr[W[T]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Input[T]] = { - import c.universe._ - - mill.moduledefs.Cacher.impl0[Input[T]](c)( - reify( - new Input[T]( - Applicative.impl[Task, T, mill.util.Ctx](c)(value).splice, - ctx.splice, - RW(w.splice.write, r.splice.read) - ) - ) - ) - } - - def command[T](t: Task[T]) - (implicit ctx: mill.define.Ctx, - w: W[T]): Command[T] = new Command(t, ctx, w) - - def command[T](t: Result[T]) - (implicit w: W[T], - ctx: mill.define.Ctx): Command[T] = macro commandImpl[T] - - def commandImpl[T: c.WeakTypeTag](c: Context) - (t: c.Expr[T]) - (w: c.Expr[W[T]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Command[T]] = { - import c.universe._ - reify( - new Command[T](Applicative.impl[Task, T, mill.util.Ctx](c)(t).splice, ctx.splice, w.splice) - ) - } - - def task[T](t: Result[T]): Task[T] = macro Applicative.impl[Task, T, mill.util.Ctx] - - def persistent[T](t: Result[T])(implicit r: R[T], - w: W[T], - ctx: mill.define.Ctx): Target[T] = macro persistentImpl[T] - - def persistentImpl[T: c.WeakTypeTag](c: Context) - (t: c.Expr[T]) - (r: c.Expr[R[T]], - w: c.Expr[W[T]], - ctx: c.Expr[mill.define.Ctx]): c.Expr[Persistent[T]] = { - import c.universe._ - - - mill.moduledefs.Cacher.impl0[Persistent[T]](c)( - reify( - new Persistent[T]( - Applicative.impl[Task, T, mill.util.Ctx](c)(t).splice, - ctx.splice, - RW(w.splice.write, r.splice.read) - ) - ) - ) - } - - type TT[+X] = Task[X] - def makeT[X](inputs0: Seq[TT[_]], evaluate0: mill.util.Ctx => Result[X]) = new Task[X] { - val inputs = inputs0 - def evaluate(x: mill.util.Ctx) = evaluate0(x) - } - - def underlying[A](v: Task[A]) = v - def mapCtx[A, B](t: Task[A])(f: (A, mill.util.Ctx) => Result[B]) = t.mapDest(f) - def zip() = new Task.Task0(()) - def zip[A](a: Task[A]) = a.map(Tuple1(_)) - def zip[A, B](a: Task[A], b: Task[B]) = a.zip(b) -} - -case class Caller[A](value: A) -object Caller { - def apply[T]()(implicit c: Caller[T]) = c.value - implicit def generate[T]: Caller[T] = macro impl[T] - def impl[T: c.WeakTypeTag](c: Context): c.Tree = { - import c.universe._ - q"new _root_.mill.define.Caller[${weakTypeOf[T]}](this)" - } -} - -class TargetImpl[+T](t: Task[T], - ctx0: mill.define.Ctx, - val readWrite: RW[_]) extends Target[T] { - val ctx = ctx0.copy(segments = ctx0.segments ++ Seq(ctx0.segment)) - val inputs = Seq(t) - def evaluate(args: mill.util.Ctx) = args[T](0) - override def toString = ctx.enclosing + "@" + Integer.toHexString(System.identityHashCode(this)) -} -class Command[+T](t: Task[T], - ctx0: mill.define.Ctx, - val writer: W[_]) extends NamedTask[T] { - val ctx = ctx0.copy(segments = ctx0.segments ++ Seq(ctx0.segment)) - val inputs = Seq(t) - def evaluate(args: mill.util.Ctx) = args[T](0) - override def asCommand = Some(this) -} -class Persistent[+T](t: Task[T], - ctx0: mill.define.Ctx, - readWrite: RW[_]) - extends TargetImpl[T](t, ctx0, readWrite) { - - override def flushDest = false - override def asPersistent = Some(this) -} -class Input[T](t: Task[T], - ctx0: mill.define.Ctx, - val readWrite: RW[_]) extends Target[T]{ - val ctx = ctx0.copy(segments = ctx0.segments ++ Seq(ctx0.segment)) - val inputs = Seq(t) - def evaluate(args: mill.util.Ctx) = args[T](0) - override def sideHash = util.Random.nextInt() -} - -object Task { - - - - - class Task0[T](t: T) extends Task[T]{ - lazy val t0 = t - val inputs = Nil - def evaluate(args: mill.util.Ctx) = t0 - } - - abstract class Ops[+T]{ this: Task[T] => - def map[V](f: T => V) = new Task.Mapped(this, f) - def mapDest[V](f: (T, mill.util.Ctx) => Result[V]) = new Task.MappedDest(this, f) - - def filter(f: T => Boolean) = this - def withFilter(f: T => Boolean) = this - def zip[V](other: Task[V]) = new Task.Zipped(this, other) - - } - - def traverse[T, V](source: Seq[T])(f: T => Task[V]) = { - new Sequence[V](source.map(f)) - } - def sequence[T](source: Seq[Task[T]]) = new Sequence[T](source) - - class Sequence[+T](inputs0: Seq[Task[T]]) extends Task[Seq[T]]{ - val inputs = inputs0 - def evaluate(args: mill.util.Ctx) = { - for (i <- 0 until args.length) - yield args(i).asInstanceOf[T] - } - - } - class Mapped[+T, +V](source: Task[T], f: T => V) extends Task[V]{ - def evaluate(args: mill.util.Ctx) = f(args(0)) - val inputs = List(source) - } - class MappedDest[+T, +V](source: Task[T], f: (T, mill.util.Ctx) => Result[V]) extends Task[V]{ - def evaluate(args: mill.util.Ctx) = f(args(0), args) - val inputs = List(source) - } - class Zipped[+T, +V](source1: Task[T], source2: Task[V]) extends Task[(T, V)]{ - def evaluate(args: mill.util.Ctx) = (args(0), args(1)) - val inputs = List(source1, source2) - } -} diff --git a/core/src/main/scala/mill/define/Worker.scala b/core/src/main/scala/mill/define/Worker.scala deleted file mode 100644 index 3d35d2e0..00000000 --- a/core/src/main/scala/mill/define/Worker.scala +++ /dev/null @@ -1,32 +0,0 @@ -package mill.define - - -/** - * Worker serves three purposes: - * - * - Cache in-memory state between tasks (e.g. object initialization) - * - Including warm classloaders with isolated bytecode - * - Mutex to limit concurrency - * - Manage out-of-process subprocesses <-- skip this for now - * - * Key usage: - * - * - T{ - * ZincWorker().compile(a() + b()) - * } - * - * Desugars into: - * - * - T.zipMap(ZincWorker, a, b){ (z, a1, b1) => z.compile(a1, b1) } - * - * Workers are shoehorned into the `Task` type. This lets them fit nicely in - * the `T{...}` syntax, as well as being statically-inspectable before - * evaluating the task graph. The Worker defines how it is evaluated, but it's - * evaluation/caching/lifecycle are controlled by the `Evaluator` - */ -trait Worker[V] extends Task[V] with mill.util.Ctx.Loader[V]{ - val inputs = Nil - def make(): V - def evaluate(args: mill.util.Ctx) = args.load(this) - def path = this.getClass.getCanonicalName.filter(_ != '$').split('.') -} diff --git a/core/src/main/scala/mill/eval/Evaluator.scala b/core/src/main/scala/mill/eval/Evaluator.scala deleted file mode 100644 index 44f24275..00000000 --- a/core/src/main/scala/mill/eval/Evaluator.scala +++ /dev/null @@ -1,285 +0,0 @@ -package mill.eval - -import java.net.URLClassLoader - -import ammonite.ops._ -import ammonite.runtime.SpecialClassLoader -import mill.define.{Graph, NamedTask, Segment, Segments, Target, Task} -import mill.util -import mill.util.Ctx.Loader -import mill.util._ -import mill.util.Strict.Agg - -import scala.collection.mutable -import scala.util.control.NonFatal -case class Labelled[T](target: NamedTask[T], - segments: Segments){ - def format = target match{ - case t: Target[T] => Some(t.readWrite.asInstanceOf[upickle.default.ReadWriter[T]]) - case _ => None - } - def writer = target match{ - case t: mill.define.Command[T] => Some(t.writer.asInstanceOf[upickle.default.Writer[T]]) - case t: Target[T] => Some(t.readWrite.asInstanceOf[upickle.default.ReadWriter[T]]) - case _ => None - } -} -object RootModuleLoader extends Loader[mill.Module] { - def make() = ??? -} -class Evaluator[T](val workspacePath: Path, - val basePath: Path, - val rootModule: mill.Module, - log: Logger, - val classLoaderSig: Seq[(Path, Long)] = Evaluator.classLoaderSig){ - - - val workerCache = mutable.Map.empty[Ctx.Loader[_], Any] - workerCache(RootModuleLoader) = rootModule - def evaluate(goals: Agg[Task[_]]): Evaluator.Results = { - mkdir(workspacePath) - - val transitive = Graph.transitiveTargets(goals) - val topoSorted = Graph.topoSorted(transitive) - val sortedGroups = Graph.groupAroundImportantTargets(topoSorted){ - case t: NamedTask[Any] => - val segments = t.ctx.segments - val (finalTaskOverrides, enclosing) = t match{ - case t: Target[_] => rootModule.millInternal.segmentsToTargets(segments).ctx.overrides -> t.ctx.enclosing - case c: mill.define.Command[_] => 0 -> c.ctx.enclosing - } - val additional = - if (finalTaskOverrides == t.ctx.overrides) Nil - else Seq(Segment.Label("overriden"), Segment.Label(enclosing)) - - Right(Labelled(t, segments ++ additional)) - case t if goals.contains(t) => Left(t) - } - - val evaluated = new Agg.Mutable[Task[_]] - val results = mutable.LinkedHashMap.empty[Task[_], Result[Any]] - - for (((terminal, group), i) <- sortedGroups.items().zipWithIndex){ - // Increment the counter message by 1 to go from 1/10 to 10/10 instead of 0/10 to 9/10 - val counterMsg = (i+1) + "/" + sortedGroups.keyCount - val (newResults, newEvaluated) = evaluateGroupCached(terminal, group, results, counterMsg) - for(ev <- newEvaluated){ - evaluated.append(ev) - } - for((k, v) <- newResults) results.put(k, v) - - } - - val failing = new util.MultiBiMap.Mutable[Either[Task[_], Labelled[_]], Result.Failing] - for((k, vs) <- sortedGroups.items()){ - failing.addAll(k, vs.items.flatMap(results.get).collect{case f: Result.Failing => f}) - } - Evaluator.Results( - goals.indexed.map(results), - evaluated, - transitive, - failing, - results - ) - } - - - def evaluateGroupCached(terminal: Either[Task[_], Labelled[_]], - group: Agg[Task[_]], - results: collection.Map[Task[_], Result[Any]], - counterMsg: String): (collection.Map[Task[_], Result[Any]], Seq[Task[_]]) = { - - - val externalInputs = group.items.flatMap(_.inputs).filter(!group.contains(_)) - - val inputsHash = - externalInputs.map(results).toVector.hashCode + - group.toIterator.map(_.sideHash).toVector.hashCode() + - classLoaderSig.hashCode() - - terminal match{ - case Left(task) => - evaluateGroup( - group, - results, - groupBasePath = None, - paths = None, - maybeTargetLabel = None, - counterMsg = counterMsg - ) - case Right(labelledTarget) => - val paths = Evaluator.resolveDestPaths(workspacePath, labelledTarget.segments) - val groupBasePath = basePath / Evaluator.makeSegmentStrings(labelledTarget.segments) - mkdir(paths.out) - val cached = for{ - json <- scala.util.Try(upickle.json.read(read(paths.meta))).toOption - (cachedHash, terminalResult) <- scala.util.Try(upickle.default.readJs[(Int, upickle.Js.Value)](json)).toOption - if cachedHash == inputsHash - reader <- labelledTarget.format - parsed <- reader.read.lift(terminalResult) - } yield parsed - - cached match{ - case Some(parsed) => - val newResults = mutable.LinkedHashMap.empty[Task[_], Result[Any]] - newResults(labelledTarget.target) = parsed - (newResults, Nil) - - case _ => - - val Seq(first, rest @_*) = labelledTarget.segments.value - val msgParts = Seq(first.asInstanceOf[Segment.Label].value) ++ rest.map{ - case Segment.Label(s) => "." + s - case Segment.Cross(s) => "[" + s.mkString(",") + "]" - } - - if (labelledTarget.target.flushDest) rm(paths.dest) - val (newResults, newEvaluated) = evaluateGroup( - group, - results, - groupBasePath = Some(groupBasePath), - paths = Some(paths), - maybeTargetLabel = Some(msgParts.mkString), - counterMsg = counterMsg - ) - - newResults(labelledTarget.target) match{ - case Result.Success(v) => - val terminalResult = labelledTarget - .writer - .asInstanceOf[Option[upickle.default.Writer[Any]]] - .map(_.write(v)) - - for(t <- terminalResult){ - write.over(paths.meta, upickle.default.write(inputsHash -> t, indent = 4)) - } - case _ => - // Wipe out any cached meta.json file that exists, so - // a following run won't look at the cached metadata file and - // assume it's associated with the possibly-borked state of the - // destPath after an evaluation failure. - rm(paths.meta) - } - - - - (newResults, newEvaluated) - } - } - } - - - def evaluateGroup(group: Agg[Task[_]], - results: collection.Map[Task[_], Result[Any]], - groupBasePath: Option[Path], - paths: Option[Evaluator.Paths], - maybeTargetLabel: Option[String], - counterMsg: String) = { - - - val newEvaluated = mutable.Buffer.empty[Task[_]] - val newResults = mutable.LinkedHashMap.empty[Task[_], Result[Any]] - - val nonEvaluatedTargets = group.indexed.filterNot(results.contains) - - maybeTargetLabel.foreach { targetLabel => - val inputResults = for { - target <- nonEvaluatedTargets - item <- target.inputs.filterNot(group.contains) - } yield results(item) - - val logRun = inputResults.forall(_.isInstanceOf[Result.Success[_]]) - - if(logRun) { log.ticker(s"[$counterMsg] $targetLabel ") } - } - - val multiLogger = resolveLogger(paths.map(_.log)) - - for (target <- nonEvaluatedTargets) { - - newEvaluated.append(target) - val targetInputValues = target.inputs - .map(x => newResults.getOrElse(x, results(x))) - .collect{ case Result.Success(v) => v } - - val res = - if (targetInputValues.length != target.inputs.length) Result.Skipped - else { - val args = new Ctx( - targetInputValues.toArray[Any], - paths.map(_.dest).orNull, - groupBasePath.orNull, - multiLogger, - new Ctx.LoaderCtx{ - def load[T](x: Ctx.Loader[T]): T = { - workerCache.getOrElseUpdate(x, x.make()).asInstanceOf[T] - } - } - ) - - val out = System.out - val err = System.err - try{ - System.setErr(multiLogger.errorStream) - System.setOut(multiLogger.outputStream) - Console.withOut(multiLogger.outputStream){ - Console.withErr(multiLogger.errorStream){ - target.evaluate(args) - } - } - }catch{ case NonFatal(e) => - val currentStack = new Exception().getStackTrace - Result.Exception(e, currentStack) - }finally{ - System.setErr(err) - System.setOut(out) - } - } - - newResults(target) = res - } - - multiLogger.close() - - (newResults, newEvaluated) - } - - def resolveLogger(logPath: Option[Path]): Logger = logPath match{ - case None => log - case Some(path) => - rm(path) - MultiLogger(log.colored, log, FileLogger(log.colored, path)) - } -} - - -object Evaluator{ - case class Paths(out: Path, - dest: Path, - meta: Path, - log: Path) - def makeSegmentStrings(segments: Segments) = segments.value.flatMap{ - case Segment.Label(s) => Seq(s) - case Segment.Cross(values) => values.map(_.toString) - } - def resolveDestPaths(workspacePath: Path, segments: Segments): Paths = { - val segmentStrings = makeSegmentStrings(segments) - val targetPath = workspacePath / segmentStrings - Paths(targetPath, targetPath / 'dest, targetPath / "meta.json", targetPath / 'log) - } - - // check if the build itself has changed - def classLoaderSig = Thread.currentThread().getContextClassLoader match { - case scl: SpecialClassLoader => scl.classpathSignature - case ucl: URLClassLoader => SpecialClassLoader.initialClasspathSignature(ucl) - case _ => Nil - - } - case class Results(rawValues: Seq[Result[Any]], - evaluated: Agg[Task[_]], - transitive: Agg[Task[_]], - failing: MultiBiMap[Either[Task[_], Labelled[_]], Result.Failing], - results: collection.Map[Task[_], Result[Any]]){ - def values = rawValues.collect{case Result.Success(v) => v} - } -} diff --git a/core/src/main/scala/mill/eval/PathRef.scala b/core/src/main/scala/mill/eval/PathRef.scala deleted file mode 100644 index 0a629a14..00000000 --- a/core/src/main/scala/mill/eval/PathRef.scala +++ /dev/null @@ -1,70 +0,0 @@ -package mill.eval - -import java.io.IOException -import java.nio.file.attribute.BasicFileAttributes -import java.nio.file.{FileVisitResult, FileVisitor} -import java.nio.{file => jnio} -import java.security.MessageDigest -import upickle.default.{ReadWriter => RW} -import ammonite.ops.Path -import mill.util.JsonFormatters - - -/** - * A wrapper around `ammonite.ops.Path` that calculates it's hashcode based - * on the contents of the filesystem underneath it. Used to ensure filesystem - * changes can bust caches which are keyed off hashcodes. - */ -case class PathRef(path: ammonite.ops.Path, quick: Boolean = false){ - val sig = { - val digest = MessageDigest.getInstance("MD5") - - val buffer = new Array[Byte](16 * 1024) - jnio.Files.walkFileTree( - path.toNIO, - new FileVisitor[jnio.Path] { - def preVisitDirectory(dir: jnio.Path, attrs: BasicFileAttributes) = { - digest.update(dir.toAbsolutePath.toString.getBytes) - FileVisitResult.CONTINUE - } - - def visitFile(file: jnio.Path, attrs: BasicFileAttributes) = { - digest.update(file.toAbsolutePath.toString.getBytes) - if (quick){ - val value = (path.mtime.toMillis, path.size).hashCode() - digest.update((value >>> 24).toByte) - digest.update((value >>> 16).toByte) - digest.update((value >>> 8).toByte) - digest.update(value.toByte) - }else { - val is = jnio.Files.newInputStream(file) - - def rec(): Unit = { - val length = is.read(buffer) - if (length != -1) { - digest.update(buffer, 0, length) - rec() - } - } - rec() - - is.close() - } - FileVisitResult.CONTINUE - } - - def visitFileFailed(file: jnio.Path, exc: IOException) = FileVisitResult.CONTINUE - def postVisitDirectory(dir: jnio.Path, exc: IOException) = FileVisitResult.CONTINUE - } - ) - - java.util.Arrays.hashCode(digest.digest()) - - } - override def hashCode() = sig -} - -object PathRef{ - private implicit val pathFormat: RW[Path] = JsonFormatters.pathReadWrite - implicit def jsonFormatter: RW[PathRef] = upickle.default.macroRW -} diff --git a/core/src/main/scala/mill/eval/Result.scala b/core/src/main/scala/mill/eval/Result.scala deleted file mode 100644 index a9b2c70b..00000000 --- a/core/src/main/scala/mill/eval/Result.scala +++ /dev/null @@ -1,14 +0,0 @@ -package mill.eval - -sealed trait Result[+T] -object Result{ - implicit def create[T](t: => T): Result[T] = { - try Success(t) - catch { case e: Throwable => Exception(e, new java.lang.Exception().getStackTrace) } - } - case class Success[T](value: T) extends Result[T] - case object Skipped extends Result[Nothing] - sealed trait Failing extends Result[Nothing] - case class Failure(msg: String) extends Failing - case class Exception(throwable: Throwable, outerStack: Seq[StackTraceElement]) extends Failing -}
\ No newline at end of file diff --git a/core/src/main/scala/mill/eval/Tarjans.scala b/core/src/main/scala/mill/eval/Tarjans.scala deleted file mode 100644 index ade335a9..00000000 --- a/core/src/main/scala/mill/eval/Tarjans.scala +++ /dev/null @@ -1,51 +0,0 @@ -package mill.eval - -import scala.collection.mutable - -// Adapted from -// https://github.com/indy256/codelibrary/blob/c52247216258e84aac442a23273b7d8306ef757b/java/src/SCCTarjan.java -object Tarjans { - def apply(graph0: TraversableOnce[TraversableOnce[Int]]): Seq[Seq[Int]] = { - val graph = graph0.map(_.toArray).toArray - val n = graph.length - val visited = new Array[Boolean](n) - val stack = mutable.ArrayBuffer.empty[Integer] - var time = 0 - val lowlink = new Array[Int](n) - val components = mutable.ArrayBuffer.empty[Seq[Int]] - - - for (u <- 0 until n) { - if (!visited(u)) dfs(u) - } - - def dfs(u: Int): Unit = { - lowlink(u) = time - time += 1 - visited(u) = true - stack.append(u) - var isComponentRoot = true - for (v <- graph(u)) { - if (!visited(v)) dfs(v) - if (lowlink(u) > lowlink(v)) { - lowlink(u) = lowlink(v) - isComponentRoot = false - } - } - if (isComponentRoot) { - val component = mutable.Buffer.empty[Int] - - var done = false - while (!done) { - val x = stack.last - stack.remove(stack.length - 1) - component.append(x) - lowlink(x) = Integer.MAX_VALUE - if (x == u) done = true - } - components.append(component) - } - } - components - } -} diff --git a/core/src/main/scala/mill/main/MainRunner.scala b/core/src/main/scala/mill/main/MainRunner.scala deleted file mode 100644 index 5281b886..00000000 --- a/core/src/main/scala/mill/main/MainRunner.scala +++ /dev/null @@ -1,116 +0,0 @@ -package mill.main -import java.io.{InputStream, OutputStream, PrintStream} - -import ammonite.Main -import ammonite.interp.{Interpreter, Preprocessor} -import ammonite.ops.Path -import ammonite.util._ -import mill.define.Discover -import mill.eval.{Evaluator, PathRef} -import mill.util.PrintLogger -import upickle.Js - -/** - * Customized version of [[ammonite.MainRunner]], allowing us to run Mill - * `build.sc` scripts with mill-specific tweaks such as a custom - * `scriptCodeWrapper` or with a persistent evaluator between runs. - */ -class MainRunner(config: ammonite.main.Cli.Config, - show: Boolean, - outprintStream: PrintStream, - errPrintStream: PrintStream, - stdIn: InputStream) - extends ammonite.MainRunner( - config, outprintStream, errPrintStream, - stdIn, outprintStream, errPrintStream - ){ - var lastEvaluator: Option[(Seq[(Path, Long)], Evaluator[_], Discover)] = None - - override def runScript(scriptPath: Path, scriptArgs: List[String]) = - watchLoop( - isRepl = false, - printing = true, - mainCfg => { - val (result, interpWatched) = RunScript.runScript( - mainCfg.wd, - scriptPath, - mainCfg.instantiateInterpreter(), - scriptArgs, - lastEvaluator, - new PrintLogger( - colors != ammonite.util.Colors.BlackWhite, - colors, - if (show) errPrintStream else outprintStream, - errPrintStream, - errPrintStream - ) - ) - - result match{ - case Res.Success(data) => - val (eval, discover, evaluationWatches, res) = data - - lastEvaluator = Some((interpWatched, eval, discover)) - - (Res(res), interpWatched ++ evaluationWatches) - case _ => (result, interpWatched) - } - } - ) - - override def handleWatchRes[T](res: Res[T], printing: Boolean) = { - res match{ - case Res.Success(value) => - if (show){ - for(json <- value.asInstanceOf[Seq[Js.Value]]){ - outprintStream.println(json) - } - } - - true - - case _ => super.handleWatchRes(res, printing) - } - - } - override def initMain(isRepl: Boolean) = { - super.initMain(isRepl).copy( - scriptCodeWrapper = CustomCodeWrapper, - // Ammonite does not properly forward the wd from CliConfig to Main, so - // force forward it outselves - wd = config.wd - ) - } - object CustomCodeWrapper extends Preprocessor.CodeWrapper { - def top(pkgName: Seq[Name], imports: Imports, indexedWrapperName: Name) = { - val wrapName = indexedWrapperName.backticked - s""" - |package ${pkgName.head.encoded} - |package ${Util.encodeScalaSourcePath(pkgName.tail)} - |$imports - |import mill._ - | - |object $wrapName extends mill.define.BaseModule(ammonite.ops.Path(${pprint.Util.literalize(config.wd.toString)})) with $wrapName{ - | // Stub to make sure Ammonite has something to call after it evaluates a script, - | // even if it does nothing... - | def $$main() = Iterator[String]() - | - | val millDiscover: mill.define.Discover = mill.define.Discover[this.type] - | // Need to wrap the returned Module in Some(...) to make sure it - | // doesn't get picked up during reflective child-module discovery - | val millSelf = Some(this) - |} - | - |sealed trait $wrapName extends mill.Module{ - |""".stripMargin - } - - - def bottom(printCode: String, indexedWrapperName: Name, extraCode: String) = { - // We need to disable the `$main` method definition inside the wrapper class, - // because otherwise it might get picked up by Ammonite and run as a static - // class method, which blows up since it's defined as an instance method - "\n}" - } - } -} diff --git a/core/src/main/scala/mill/main/ParseArgs.scala b/core/src/main/scala/mill/main/ParseArgs.scala deleted file mode 100644 index dc848418..00000000 --- a/core/src/main/scala/mill/main/ParseArgs.scala +++ /dev/null @@ -1,142 +0,0 @@ -package mill.main - -import mill.util.EitherOps -import fastparse.all._ -import mill.define.Segment - -object ParseArgs { - - def apply(scriptArgs: Seq[String]) - : Either[String, (List[List[Segment]], Seq[String])] = { - val (selectors, args, isMultiSelectors) = extractSelsAndArgs(scriptArgs) - for { - _ <- validateSelectors(selectors) - expandedSelectors <- EitherOps - .sequence(selectors.map(expandBraces)) - .map(_.flatten) - _ <- validateExpanded(expandedSelectors, isMultiSelectors) - selectors <- EitherOps.sequence(expandedSelectors.map(extractSegments)) - } yield (selectors.toList, args) - } - - def extractSelsAndArgs( - scriptArgs: Seq[String]): (Seq[String], Seq[String], Boolean) = { - val multiFlags = Seq("--all", "--seq") - val isMultiSelectors = scriptArgs.headOption.exists(multiFlags.contains) - - if (isMultiSelectors) { - val dd = scriptArgs.indexOf("--") - val selectors = (if (dd == -1) scriptArgs - else scriptArgs.take(dd)).filterNot(multiFlags.contains) - val args = if (dd == -1) Seq.empty else scriptArgs.drop(dd + 1) - - (selectors, args, isMultiSelectors) - } else { - (scriptArgs.take(1), scriptArgs.drop(1), isMultiSelectors) - } - } - - private def validateSelectors( - selectors: Seq[String]): Either[String, Unit] = { - if (selectors.isEmpty || selectors.exists(_.isEmpty)) - Left("Selector cannot be empty") - else Right(()) - } - - private def validateExpanded(expanded: Seq[String], - isMulti: Boolean): Either[String, Unit] = { - if (!isMulti && expanded.length > 1) - Left("Please use --all flag to run multiple tasks") - else Right(()) - } - - def expandBraces(selectorString: String): Either[String, List[String]] = { - parseBraceExpansion(selectorString) match { - case f: Parsed.Failure => Left(s"Parsing exception ${f.msg}") - case Parsed.Success(expanded, _) => Right(expanded.toList) - } - } - - private sealed trait Fragment - private object Fragment { - case class Keep(value: String) extends Fragment - case class Expand(values: List[List[Fragment]]) extends Fragment - - def unfold(fragments: List[Fragment]): Seq[String] = { - fragments match { - case head :: rest => - val prefixes = head match { - case Keep(v) => Seq(v) - case Expand(Nil) => Seq("{}") - case Expand(List(vs)) => unfold(vs).map("{" + _ + "}") - case Expand(vss) => vss.flatMap(unfold) - } - for { - prefix <- prefixes - suffix <- unfold(rest) - } yield prefix + suffix - - case Nil => Seq("") - } - } - } - - private object BraceExpansionParser { - val plainChars = - P(CharsWhile(c => c != ',' && c != '{' && c != '}')).!.map(Fragment.Keep) - - val toExpand: P[Fragment] = - P("{" ~ braceParser.rep(1).rep(sep = ",") ~ "}").map( - x => Fragment.Expand(x.toList.map(_.toList)) - ) - - val braceParser = P(toExpand | plainChars) - - val parser = P(braceParser.rep(1).rep(sep = ",") ~ End) - } - - private def parseBraceExpansion(input: String) = { - def unfold(vss: List[Seq[String]]): Seq[String] = { - vss match { - case Nil => Seq("") - case head :: rest => - for { - str <- head - r <- unfold(rest) - } yield - r match { - case "" => str - case _ => str + "," + r - } - } - } - - BraceExpansionParser.parser - .map { vss => - val stringss = vss.map(x => Fragment.unfold(x.toList)).toList - unfold(stringss) - } - .parse(input) - } - - def extractSegments(selectorString: String): Either[String, List[Segment]] = - parseSelector(selectorString) match { - case f: Parsed.Failure => Left(s"Parsing exception ${f.msg}") - case Parsed.Success(selector, _) => Right(selector) - } - - private def parseSelector(input: String) = { - val segment = - P(CharsWhileIn(('a' to 'z') ++ ('A' to 'Z') ++ ('0' to '9')).!).map( - Segment.Label - ) - val crossSegment = - P("[" ~ CharsWhile(c => c != ',' && c != ']').!.rep(1, sep = ",") ~ "]") - .map(Segment.Cross) - val query = P(segment ~ ("." ~ segment | crossSegment).rep ~ End).map { - case (h, rest) => h :: rest.toList - } - query.parse(input) - } - -} diff --git a/core/src/main/scala/mill/main/ReplApplyHandler.scala b/core/src/main/scala/mill/main/ReplApplyHandler.scala deleted file mode 100644 index 97efb6e5..00000000 --- a/core/src/main/scala/mill/main/ReplApplyHandler.scala +++ /dev/null @@ -1,124 +0,0 @@ -package mill.main - - -import mill.define.Applicative.ApplyHandler -import mill.define.Segment.Label -import mill.define._ -import mill.eval.{Evaluator, Result} -import mill.util.Strict.Agg - -import scala.collection.mutable -object ReplApplyHandler{ - def apply[T](colors: ammonite.util.Colors, - pprinter0: pprint.PPrinter, - rootModule: mill.Module, - discover: Discover) = { - new ReplApplyHandler( - pprinter0, - new mill.eval.Evaluator( - ammonite.ops.pwd / 'out, - ammonite.ops.pwd, - rootModule, - new mill.util.PrintLogger( - colors != ammonite.util.Colors.BlackWhite, - colors, - System.out, - System.err, - System.err - ) - ), - discover - ) - } -} -class ReplApplyHandler(pprinter0: pprint.PPrinter, - evaluator: Evaluator[_], - discover: Discover) extends ApplyHandler[Task] { - // Evaluate classLoaderSig only once in the REPL to avoid busting caches - // as the user enters more REPL commands and changes the classpath - val classLoaderSig = Evaluator.classLoaderSig - override def apply[V](t: Task[V]) = { - val res = evaluator.evaluate(Agg(t)) - res.values match{ - case Seq(head: V) => head - case Nil => - val msg = new mutable.StringBuilder() - msg.append(res.failing.keyCount + " targets failed\n") - for((k, vs) <- res.failing.items){ - msg.append(k match{ - case Left(t) => "Anonymous Task\n" - case Right(k) => k.segments.render + "\n" - }) - - for(v <- vs){ - v match{ - case Result.Failure(m) => msg.append(m + "\n") - case Result.Exception(t, outerStack) => - msg.append( - t.toString + t.getStackTrace.dropRight(outerStack.length).map("\n " + _).mkString + "\n" - ) - - } - } - } - throw new Exception(msg.toString) - } - } - - val generatedEval = new EvalGenerated(evaluator) - - val millHandlers: PartialFunction[Any, pprint.Tree] = { - case c: Cross[_] => - pprint.Tree.Lazy( ctx => - Iterator(c.millOuterCtx.enclosing , ":", c.millOuterCtx.lineNum.toString, ctx.applyPrefixColor("\nChildren:").toString) ++ - c.items.iterator.map(x => - "\n (" + x._1.map(pprint.PPrinter.BlackWhite.apply(_)).mkString(", ") + ")" - ) - ) - case m: mill.Module if evaluator.rootModule.millModuleDirectChildren.contains(m) => - pprint.Tree.Lazy( ctx => - Iterator(m.millInternal.millModuleEnclosing, ":", m.millInternal.millModuleLine.toString) ++ - (if (m.millInternal.reflect[mill.Module].isEmpty) Nil - else - ctx.applyPrefixColor("\nChildren:").toString +: - m.millInternal.reflect[mill.Module].map("\n ." + _.millOuterCtx.segments.render)) ++ - (discover.value.get(m.getClass) match{ - case None => Nil - case Some(commands) => - ctx.applyPrefixColor("\nCommands:").toString +: commands.map{c => - "\n ." + c.name + "(" + - c.argSignatures.map(s => s.name + ": " + s.typeString).mkString(", ") + - ")()" - } - }) ++ - (if (m.millInternal.reflect[Target[_]].isEmpty) Nil - else { - Seq(ctx.applyPrefixColor("\nTargets:").toString) ++ - m.millInternal.reflect[Target[_]].sortBy(_.label).map(t => - "\n ." + t.label + "()" - ) - }) - - ) - case t: mill.define.Target[_] if evaluator.rootModule.millInternal.targets.contains(t) => - val seen = mutable.Set.empty[Task[_]] - def rec(t: Task[_]): Seq[Segments] = { - if (seen(t)) Nil // do nothing - else t match { - case t: Target[_] if evaluator.rootModule.millInternal.targets.contains(t) => - Seq(t.ctx.segments) - case _ => - seen.add(t) - t.inputs.flatMap(rec) - } - } - pprint.Tree.Lazy(ctx => - Iterator(t.ctx.enclosing, ":", t.ctx.lineNum.toString, "\n", ctx.applyPrefixColor("Inputs:").toString) ++ - t.inputs.iterator.flatMap(rec).map("\n " + _.render) - ) - - } - val pprinter = pprinter0.copy( - additionalHandlers = millHandlers orElse pprinter0.additionalHandlers - ) -} diff --git a/core/src/main/scala/mill/main/Resolve.scala b/core/src/main/scala/mill/main/Resolve.scala deleted file mode 100644 index ed4c4f80..00000000 --- a/core/src/main/scala/mill/main/Resolve.scala +++ /dev/null @@ -1,81 +0,0 @@ -package mill.main - -import mill.define._ -import mill.define.TaskModule -import ammonite.main.Router -import ammonite.main.Router.EntryPoint - -object Resolve { - def resolve[T, V](remainingSelector: List[Segment], - obj: mill.Module, - discover: Discover, - rest: Seq[String], - remainingCrossSelectors: List[List[String]], - revSelectorsSoFar: List[Segment]): Either[String, Task[Any]] = { - - remainingSelector match{ - case Segment.Cross(_) :: Nil => Left("Selector cannot start with a [cross] segment") - case Segment.Label(last) :: Nil => - val target = - obj - .millInternal - .reflect[Target[_]] - .find(_.label == last) - .map(Right(_)) - - def invokeCommand[V](target: mill.Module, name: String) = { - for(cmd <- discover.value.get(target.getClass).toSeq.flatten.find(_.name == name)) - yield cmd.asInstanceOf[EntryPoint[mill.Module]].invoke(target, ammonite.main.Scripts.groupArgs(rest.toList)) match { - case Router.Result.Success(v) => Right(v) - case _ => Left(s"Command failed $last") - } - } - - val runDefault = for{ - child <- obj.millInternal.reflectNestedObjects[mill.Module] - if child.millOuterCtx.segment == Segment.Label(last) - res <- child match{ - case taskMod: TaskModule => Some(invokeCommand(child, taskMod.defaultCommandName())) - case _ => None - } - } yield res - - val command = invokeCommand(obj, last) - - command orElse target orElse runDefault.headOption.flatten match{ - case None => Left("Cannot resolve task " + - Segments((Segment.Label(last) :: revSelectorsSoFar).reverse:_*).render - ) - // Contents of `either` *must* be a `Task`, because we only select - // methods returning `Task` in the discovery process - case Some(either) => either.right.map{ case x: Task[Any] => x } - } - - - case head :: tail => - val newRevSelectorsSoFar = head :: revSelectorsSoFar - head match{ - case Segment.Label(singleLabel) => - obj.millInternal.reflectNestedObjects[mill.Module].find{ - _.millOuterCtx.segment == Segment.Label(singleLabel) - } match{ - case Some(child: mill.Module) => resolve(tail, child, discover, rest, remainingCrossSelectors, newRevSelectorsSoFar) - case None => Left("Cannot resolve module " + Segments(newRevSelectorsSoFar.reverse:_*).render) - } - - case Segment.Cross(cross) => - obj match{ - case c: Cross[_] => - c.itemMap.get(cross.toList) match{ - case Some(m: mill.Module) => resolve(tail, m, discover, rest, remainingCrossSelectors, newRevSelectorsSoFar) - case None => Left("Cannot resolve cross " + Segments(newRevSelectorsSoFar.reverse:_*).render) - - } - case _ => Left("Cannot resolve cross " + Segments(newRevSelectorsSoFar.reverse:_*).render) - } - } - - case Nil => Left("Selector cannot be empty") - } - } -} diff --git a/core/src/main/scala/mill/main/RunScript.scala b/core/src/main/scala/mill/main/RunScript.scala deleted file mode 100644 index aa254048..00000000 --- a/core/src/main/scala/mill/main/RunScript.scala +++ /dev/null @@ -1,210 +0,0 @@ -package mill.main - -import java.nio.file.NoSuchFileException - -import ammonite.interp.Interpreter -import ammonite.ops.{Path, read} -import ammonite.runtime.SpecialClassLoader -import ammonite.util.Util.CodeSource -import ammonite.util.{Name, Res, Util} -import mill.{PathRef, define} -import mill.define.{Discover, Segment, Task} -import mill.eval.{Evaluator, Result} -import mill.util.{EitherOps, Logger} -import mill.util.Strict.Agg -import upickle.Js - -/** - * Custom version of ammonite.main.Scripts, letting us run the build.sc script - * directly without going through Ammonite's main-method/argument-parsing - * subsystem - */ -object RunScript{ - def runScript(wd: Path, - path: Path, - instantiateInterpreter: => Either[(Res.Failing, Seq[(Path, Long)]), ammonite.interp.Interpreter], - scriptArgs: Seq[String], - lastEvaluator: Option[(Seq[(Path, Long)], Evaluator[_], Discover)], - log: Logger) - : (Res[(Evaluator[_], Discover, Seq[(Path, Long)], Either[String, Seq[Js.Value]])], Seq[(Path, Long)]) = { - - val (evalRes, interpWatched) = lastEvaluator match{ - case Some((prevInterpWatchedSig, prevEvaluator, prevDiscover)) - if watchedSigUnchanged(prevInterpWatchedSig) => - - (Res.Success(prevEvaluator -> prevDiscover), prevInterpWatchedSig) - - case _ => - instantiateInterpreter match{ - case Left((res, watched)) => (res, watched) - case Right(interp) => - interp.watch(path) - val eval = - for((mapping, discover) <- evaluateMapping(wd, path, interp)) - yield ( - new Evaluator( - wd / 'out, wd, mapping, log, - mapping.getClass.getClassLoader.asInstanceOf[SpecialClassLoader].classpathSignature - ), - discover - ) - (eval, interp.watchedFiles) - } - } - - val evaluated = for{ - (evaluator, discover) <- evalRes - (evalWatches, res) <- Res(evaluateTarget(evaluator, discover, scriptArgs)) - } 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 - // `PathRef` and the current moment, use random junk .sig values - // to force an immediate re-run. Otherwise calculate the - // pathSignatures the same way Ammonite would and hand over the - // values, so Ammonite can watch them and only re-run if they - // subsequently change - val evaluationWatches = - if (alreadyStale) evalWatches.map(_.path -> util.Random.nextLong()) - else evalWatches.map(p => p.path -> Interpreter.pathSignature(p.path)) - - (evaluator, discover, evaluationWatches, res.map(_.flatMap(_._2))) - } - (evaluated, interpWatched) - } - - def watchedSigUnchanged(sig: Seq[(Path, Long)]) = { - sig.forall{case (p, l) => Interpreter.pathSignature(p) == l} - } - - def evaluateMapping(wd: Path, - path: Path, - interp: ammonite.interp.Interpreter): Res[(mill.Module, Discover)] = { - - val (pkg, wrapper) = Util.pathToPackageWrapper(Seq(), path relativeTo wd) - - for { - scriptTxt <- - try Res.Success(Util.normalizeNewlines(read(path))) - catch { case e: NoSuchFileException => Res.Failure("Script file not found: " + path) } - - processed <- interp.processModule( - scriptTxt, - CodeSource(wrapper, pkg, Seq(Name("ammonite"), Name("$file")), Some(path)), - autoImport = true, - extraCode = "", - hardcoded = true - ) - - buildClsName <- processed.blockInfo.lastOption match { - case Some(meta) => Res.Success(meta.id.wrapperPath) - case None => Res.Skip - } - - buildCls = interp - .evalClassloader - .loadClass(buildClsName) - - module <- try { - Util.withContextClassloader(interp.evalClassloader) { - Res.Success( - buildCls.getMethod("millSelf") - .invoke(null) - .asInstanceOf[Some[mill.Module]] - .get - ) - } - } catch { - case e: Throwable => Res.Exception(e, "") - } - discover <- try { - Util.withContextClassloader(interp.evalClassloader) { - Res.Success( - buildCls.getMethod("millDiscover") - .invoke(null) - .asInstanceOf[Discover] - ) - } - } catch { - case e: Throwable => Res.Exception(e, "") - } -// _ <- Res(consistencyCheck(mapping)) - } yield (module, discover) - } - - def evaluateTarget[T](evaluator: Evaluator[_], - discover: Discover, - scriptArgs: Seq[String]) = { - for { - parsed <- ParseArgs(scriptArgs) - (selectors, args) = parsed - targets <- { - val selected = selectors.map { sel => - val crossSelectors = sel.map { - case Segment.Cross(x) => x.toList.map(_.toString) - case _ => Nil - } - mill.main.Resolve.resolve( - sel, evaluator.rootModule, - discover, - args, crossSelectors, Nil - ) - } - EitherOps.sequence(selected) - } - (watched, res) = evaluate(evaluator, targets) - } yield (watched, res) - } - - def evaluate(evaluator: Evaluator[_], - targets: Seq[Task[Any]]): (Seq[PathRef], Either[String, Seq[(Any, Option[upickle.Js.Value])]]) = { - val evaluated = evaluator.evaluate(Agg.from(targets)) - val watched = evaluated.results - .iterator - .collect { - case (t: define.Input[_], Result.Success(p: PathRef)) => p - } - .toSeq - - val errorStr = - (for((k, fs) <- evaluated.failing.items()) yield { - val ks = k match{ - case Left(t) => t.toString - case Right(t) => t.segments.render - } - val fss = fs.map{ - case Result.Exception(t, outerStack) => - t.toString + t.getStackTrace.dropRight(outerStack.length).map("\n " + _).mkString - case Result.Failure(t) => t - } - s"$ks ${fss.mkString(", ")}" - }).mkString("\n") - - evaluated.failing.keyCount match { - case 0 => - val json = for(t <- targets) yield { - t match { - case t: mill.define.NamedTask[_] => - val jsonFile = Evaluator - .resolveDestPaths(evaluator.workspacePath, t.ctx.segments) - .meta - val metadata = upickle.json.read(jsonFile.toIO) - Some(metadata(1)) - - case _ => None - } - } - - watched -> Right(evaluated.values.zip(json)) - case n => watched -> Left(s"$n targets failed\n$errorStr") - } - } - -// def consistencyCheck[T](mapping: Discovered.Mapping[T]): Either[String, Unit] = { -// val consistencyErrors = Discovered.consistencyCheck(mapping) -// if (consistencyErrors.nonEmpty) { -// Left(s"Failed Discovered.consistencyCheck: ${consistencyErrors.map(_.render)}") -// } else { -// Right(()) -// } -// } -} diff --git a/core/src/main/scala/mill/modules/Jvm.scala b/core/src/main/scala/mill/modules/Jvm.scala deleted file mode 100644 index 888a687b..00000000 --- a/core/src/main/scala/mill/modules/Jvm.scala +++ /dev/null @@ -1,259 +0,0 @@ -package mill.modules - -import java.io.FileOutputStream -import java.lang.reflect.Modifier -import java.net.URLClassLoader -import java.nio.file.attribute.PosixFilePermission -import java.util.jar.{JarEntry, JarFile, JarOutputStream} - -import ammonite.ops._ -import mill.define.Task -import mill.eval.PathRef -import mill.util.Ctx -import mill.util.Ctx.LogCtx -import mill.util.Loose.Agg - -import scala.annotation.tailrec -import scala.collection.mutable - - -object Jvm { - def gatherClassloaderJars(): Agg[Path] = { - val allJars = new Agg.Mutable[Path]() - var currentClassloader = Thread.currentThread().getContextClassLoader - while(currentClassloader != null){ - currentClassloader match{ - case u: URLClassLoader => allJars.appendAll(u.getURLs.map(x => Path(x.getFile))) - case _ => - } - currentClassloader = currentClassloader.getParent - } - allJars - } - - def interactiveSubprocess(mainClass: String, - classPath: Agg[Path], - options: Seq[String] = Seq.empty): Unit = { - import ammonite.ops.ImplicitWd._ - %("java", "-cp", classPath.mkString(":"), mainClass, options) - } - - def inprocess(mainClass: String, - classPath: Agg[Path], - options: Seq[String] = Seq.empty) - (implicit ctx: Ctx): Unit = { - inprocess(classPath, classLoaderOverrideSbtTesting = false, cl => { - getMainMethod(mainClass, cl).invoke(null, options.toArray) - }) - } - - private def getMainMethod(mainClassName: String, cl: ClassLoader) = { - val mainClass = cl.loadClass(mainClassName) - val method = mainClass.getMethod("main", classOf[Array[String]]) - // jvm allows the actual main class to be non-public and to run a method in the non-public class, - // we need to make it accessible - method.setAccessible(true) - val modifiers = method.getModifiers - if (!Modifier.isPublic(modifiers)) - throw new NoSuchMethodException(mainClassName + ".main is not public") - if (!Modifier.isStatic(modifiers)) - throw new NoSuchMethodException(mainClassName + ".main is not static") - method - } - - - def inprocess[T](classPath: Agg[Path], - classLoaderOverrideSbtTesting: Boolean, - body: ClassLoader => T): T = { - val cl = if (classLoaderOverrideSbtTesting) { - val outerClassLoader = getClass.getClassLoader - new URLClassLoader( - classPath.map(_.toIO.toURI.toURL).toArray, - ClassLoader.getSystemClassLoader().getParent()){ - override def findClass(name: String) = { - if (name.startsWith("sbt.testing.")){ - outerClassLoader.loadClass(name) - }else{ - super.findClass(name) - } - } - } - } else { - new URLClassLoader( - classPath.map(_.toIO.toURI.toURL).toArray, - ClassLoader.getSystemClassLoader().getParent()) - } - val oldCl = Thread.currentThread().getContextClassLoader - Thread.currentThread().setContextClassLoader(cl) - try { - body(cl) - }finally{ - Thread.currentThread().setContextClassLoader(oldCl) - cl.close() - } - } - - def subprocess(mainClass: String, - classPath: Agg[Path], - jvmOptions: Seq[String] = Seq.empty, - options: Seq[String] = Seq.empty, - workingDir: Path = null) - (implicit ctx: Ctx) = { - - val commandArgs = - Vector("java") ++ - jvmOptions ++ - Vector("-cp", classPath.mkString(":"), mainClass) ++ - options - - val workingDir1 = Option(workingDir).getOrElse(ctx.dest) - mkdir(workingDir1) - val proc = - new java.lang.ProcessBuilder() - .directory(workingDir1.toIO) - .command(commandArgs:_*) - .redirectOutput(ProcessBuilder.Redirect.PIPE) - .redirectError(ProcessBuilder.Redirect.PIPE) - .start() - - val stdout = proc.getInputStream - val stderr = proc.getErrorStream - val sources = Seq( - (stdout, Left(_: Bytes), ctx.log.outputStream), - (stderr, Right(_: Bytes),ctx.log.errorStream ) - ) - val chunks = mutable.Buffer.empty[Either[Bytes, Bytes]] - while( - // Process.isAlive doesn't exist on JDK 7 =/ - util.Try(proc.exitValue).isFailure || - stdout.available() > 0 || - stderr.available() > 0 - ){ - var readSomething = false - for ((subStream, wrapper, parentStream) <- sources){ - while (subStream.available() > 0){ - readSomething = true - val array = new Array[Byte](subStream.available()) - val actuallyRead = subStream.read(array) - chunks.append(wrapper(new ammonite.ops.Bytes(array))) - parentStream.write(array, 0, actuallyRead) - } - } - // if we did not read anything sleep briefly to avoid spinning - if(!readSomething) - Thread.sleep(2) - } - - if (proc.exitValue() != 0) throw new InteractiveShelloutException() - else ammonite.ops.CommandResult(proc.exitValue(), chunks) - } - - private def createManifest(mainClass: Option[String]) = { - val m = new java.util.jar.Manifest() - m.getMainAttributes.put(java.util.jar.Attributes.Name.MANIFEST_VERSION, "1.0") - m.getMainAttributes.putValue( "Created-By", "Scala mill" ) - mainClass.foreach( - m.getMainAttributes.put(java.util.jar.Attributes.Name.MAIN_CLASS, _) - ) - m - } - - def createJar(inputPaths: Agg[Path], mainClass: Option[String] = None) - (implicit ctx: Ctx.DestCtx): PathRef = { - val outputPath = ctx.dest - rm(outputPath) - if(inputPaths.nonEmpty) { - mkdir(outputPath/up) - - val jar = new JarOutputStream( - new FileOutputStream(outputPath.toIO), - createManifest(mainClass) - ) - - try{ - assert(inputPaths.forall(exists(_))) - for{ - p <- inputPaths - (file, mapping) <- - if (p.isFile) Iterator(p -> empty/p.last) - else ls.rec(p).filter(_.isFile).map(sub => sub -> sub.relativeTo(p)) - } { - val entry = new JarEntry(mapping.toString) - entry.setTime(file.mtime.toMillis) - jar.putNextEntry(entry) - jar.write(read.bytes(file)) - jar.closeEntry() - } - } finally { - jar.close() - } - - } - PathRef(outputPath) - } - - def createAssembly(inputPaths: Agg[Path], - mainClass: Option[String] = None, - prependShellScript: String = "") - (implicit ctx: Ctx.DestCtx): PathRef = { - val outputPath = ctx.dest - rm(outputPath) - - if(inputPaths.nonEmpty) { - mkdir(outputPath/up) - - val output = new FileOutputStream(outputPath.toIO) - - // Prepend shell script and make it executable - if (prependShellScript.nonEmpty) { - output.write((prependShellScript + "\n").getBytes) - val perms = java.nio.file.Files.getPosixFilePermissions(outputPath.toNIO) - perms.add(PosixFilePermission.GROUP_EXECUTE) - perms.add(PosixFilePermission.OWNER_EXECUTE) - perms.add(PosixFilePermission.OTHERS_EXECUTE) - java.nio.file.Files.setPosixFilePermissions(outputPath.toNIO, perms) - } - - val jar = new JarOutputStream( - output, - createManifest(mainClass) - ) - - val seen = mutable.Set("META-INF/MANIFEST.MF") - try{ - - - for{ - p <- inputPaths - if exists(p) - (file, mapping) <- - if (p.isFile) { - val jf = new JarFile(p.toIO) - import collection.JavaConverters._ - for(entry <- jf.entries().asScala if !entry.isDirectory) yield { - read.bytes(jf.getInputStream(entry)) -> entry.getName - } - } - else { - ls.rec(p).iterator - .filter(_.isFile) - .map(sub => read.bytes(sub) -> sub.relativeTo(p).toString) - } - if !seen(mapping) - } { - seen.add(mapping) - val entry = new JarEntry(mapping.toString) - jar.putNextEntry(entry) - jar.write(file) - jar.closeEntry() - } - } finally { - jar.close() - output.close() - } - - } - PathRef(outputPath) - } - -} diff --git a/core/src/main/scala/mill/modules/Util.scala b/core/src/main/scala/mill/modules/Util.scala deleted file mode 100644 index cd674bad..00000000 --- a/core/src/main/scala/mill/modules/Util.scala +++ /dev/null @@ -1,26 +0,0 @@ -package mill.modules - -import ammonite.ops.RelPath -import mill.eval.PathRef -import mill.util.Ctx - -object Util { - def download(url: String, dest: RelPath)(implicit ctx: Ctx.DestCtx) = { - ammonite.ops.mkdir(ctx.dest) - val out = ctx.dest / dest - - val website = new java.net.URI(url).toURL - val rbc = java.nio.channels.Channels.newChannel(website.openStream) - try{ - val fos = new java.io.FileOutputStream(out.toIO) - try{ - fos.getChannel.transferFrom(rbc, 0, java.lang.Long.MAX_VALUE) - PathRef(out) - } finally{ - fos.close() - } - } finally{ - rbc.close() - } - } -} diff --git a/core/src/main/scala/mill/package.scala b/core/src/main/scala/mill/package.scala deleted file mode 100644 index 93916c8b..00000000 --- a/core/src/main/scala/mill/package.scala +++ /dev/null @@ -1,12 +0,0 @@ -import mill.util.JsonFormatters - -package object mill extends JsonFormatters{ - val T = define.Target - type T[T] = define.Target[T] - val PathRef = mill.eval.PathRef - type PathRef = mill.eval.PathRef - type Module = define.Module - type Cross[T] = define.Cross[T] - type Agg[T] = util.Loose.Agg[T] - val Agg = util.Loose.Agg -} diff --git a/core/src/main/scala/mill/util/AggWrapper.scala b/core/src/main/scala/mill/util/AggWrapper.scala deleted file mode 100644 index c2994a9a..00000000 --- a/core/src/main/scala/mill/util/AggWrapper.scala +++ /dev/null @@ -1,116 +0,0 @@ -package mill.util - - - -import scala.collection.mutable -object Strict extends AggWrapper(true) -object Loose extends AggWrapper(false) -sealed class AggWrapper(strictUniqueness: Boolean){ - /** - * A collection with enforced uniqueness, fast contains and deterministic - * ordering. Raises an exception if a duplicate is found; call - * `toSeq.distinct` if you explicitly want to make it swallow duplicates - */ - trait Agg[V] extends TraversableOnce[V]{ - def contains(v: V): Boolean - def items: Iterator[V] - def indexed: IndexedSeq[V] - def flatMap[T](f: V => TraversableOnce[T]): Agg[T] - def map[T](f: V => T): Agg[T] - def filter(f: V => Boolean): Agg[V] - def withFilter(f: V => Boolean): Agg[V] - def collect[T](f: PartialFunction[V, T]): Agg[T] - def zipWithIndex: Agg[(V, Int)] - def reverse: Agg[V] - def zip[T](other: Agg[T]): Agg[(V, T)] - def ++[T >: V](other: TraversableOnce[T]): Agg[T] - } - - object Agg{ - def empty[V]: Agg[V] = new Agg.Mutable[V] - implicit def jsonFormat[T: upickle.default.ReadWriter]: upickle.default.ReadWriter[Agg[T]] = - upickle.default.ReadWriter[Agg[T]] ( - oset => upickle.default.writeJs(oset.toList), - {case json => Agg.from(upickle.default.readJs[Seq[T]](json))} - ) - def apply[V](items: V*) = from(items) - - implicit def from[V](items: TraversableOnce[V]): Agg[V] = { - val set = new Agg.Mutable[V]() - items.foreach(set.append) - set - } - - - class Mutable[V]() extends Agg[V]{ - - private[this] val set0 = mutable.LinkedHashSet.empty[V] - def contains(v: V) = set0.contains(v) - def append(v: V) = if (!contains(v)){ - set0.add(v) - - }else if (strictUniqueness){ - throw new Exception("Duplicated item inserted into OrderedSet: " + v) - } - def appendAll(vs: Seq[V]) = vs.foreach(append) - def items = set0.iterator - def indexed: IndexedSeq[V] = items.toIndexedSeq - def set: collection.Set[V] = set0 - - def map[T](f: V => T): Agg[T] = { - val output = new Agg.Mutable[T] - for(i <- items) output.append(f(i)) - output - } - def flatMap[T](f: V => TraversableOnce[T]): Agg[T] = { - val output = new Agg.Mutable[T] - for(i <- items) for(i0 <- f(i)) output.append(i0) - output - } - def filter(f: V => Boolean): Agg[V] = { - val output = new Agg.Mutable[V] - for(i <- items) if (f(i)) output.append(i) - output - } - def withFilter(f: V => Boolean): Agg[V] = filter(f) - - def collect[T](f: PartialFunction[V, T]) = this.filter(f.isDefinedAt).map(x => f(x)) - - def zipWithIndex = { - var i = 0 - this.map{ x => - i += 1 - (x, i-1) - } - } - - def reverse = Agg.from(indexed.reverseIterator) - - def zip[T](other: Agg[T]) = Agg.from(items.zip(other.items)) - def ++[T >: V](other: TraversableOnce[T]) = Agg.from(items ++ other) - - // Members declared in scala.collection.GenTraversableOnce - def isTraversableAgain: Boolean = items.isTraversableAgain - def toIterator: Iterator[V] = items.toIterator - def toStream: Stream[V] = items.toStream - - // Members declared in scala.collection.TraversableOnce - def copyToArray[B >: V](xs: Array[B], start: Int,len: Int): Unit = items.copyToArray(xs, start, len) - def exists(p: V => Boolean): Boolean = items.exists(p) - def find(p: V => Boolean): Option[V] = items.find(p) - def forall(p: V => Boolean): Boolean = items.forall(p) - def foreach[U](f: V => U): Unit = items.foreach(f) - def hasDefiniteSize: Boolean = items.hasDefiniteSize - def isEmpty: Boolean = items.isEmpty - def seq: scala.collection.TraversableOnce[V] = items - def toTraversable: Traversable[V] = items.toTraversable - - override def hashCode() = items.map(_.hashCode()).sum - override def equals(other: Any) = other match{ - case s: Agg[_] => items.sameElements(s.items) - case _ => super.equals(other) - } - override def toString = items.mkString("Agg(", ", ", ")") - } - } -} diff --git a/core/src/main/scala/mill/util/Ctx.scala b/core/src/main/scala/mill/util/Ctx.scala deleted file mode 100644 index 60e6bdbf..00000000 --- a/core/src/main/scala/mill/util/Ctx.scala +++ /dev/null @@ -1,60 +0,0 @@ -package mill.util - -import ammonite.ops.Path -import mill.define.Applicative.ImplicitStub -import mill.util.Ctx.{ArgCtx, BaseCtx, DestCtx, LoaderCtx, LogCtx} - -import scala.annotation.compileTimeOnly -import scala.language.implicitConversions - -object Ctx{ - @compileTimeOnly("Target.ctx() can only be used with a T{...} block") - @ImplicitStub - implicit def taskCtx: Ctx = ??? - - object DestCtx { - implicit def pathToCtx(path: Path): DestCtx = new DestCtx { def dest = path } - } - trait DestCtx{ - def dest: Path - } - trait BaseCtx{ - def base: Path - } - object BaseCtx { - implicit def pathToCtx(path: Path): BaseCtx = new BaseCtx { def base = path } - } - trait LogCtx{ - def log: Logger - } - object LogCtx{ - implicit def logToCtx(l: Logger): LogCtx = new LogCtx { def log = l } - } - trait ArgCtx{ - def args: IndexedSeq[_] - } - trait LoaderCtx{ - def load[T](x: Loader[T]): T - } - trait Loader[T]{ - def make(): T - } -} -class Ctx(val args: IndexedSeq[_], - val dest: Path, - val base: Path, - val log: Logger, - workerCtx0: Ctx.LoaderCtx) - extends DestCtx - with LogCtx - with ArgCtx - with LoaderCtx - with BaseCtx{ - - def load[T](x: Ctx.Loader[T]): T = workerCtx0.load(x) - def length = args.length - def apply[T](index: Int): T = { - if (index >= 0 && index < args.length) args(index).asInstanceOf[T] - else throw new IndexOutOfBoundsException(s"Index $index outside of range 0 - ${args.length}") - } -} diff --git a/core/src/main/scala/mill/util/EitherOps.scala b/core/src/main/scala/mill/util/EitherOps.scala deleted file mode 100644 index da2552c8..00000000 --- a/core/src/main/scala/mill/util/EitherOps.scala +++ /dev/null @@ -1,18 +0,0 @@ -package mill.util - -import scala.collection.generic.CanBuildFrom -import scala.collection.mutable -import scala.language.higherKinds - -object EitherOps { - - // implementation similar to scala.concurrent.Future#sequence - def sequence[A, B, M[X] <: TraversableOnce[X]](in: M[Either[A, B]])( - implicit cbf: CanBuildFrom[M[Either[A, B]], B, M[B]]): Either[A, M[B]] = { - in.foldLeft[Either[A, mutable.Builder[B, M[B]]]](Right(cbf(in))) { - case (acc, el) => - for (a <- acc; e <- el) yield a += e - } - .map(_.result()) - } -} diff --git a/core/src/main/scala/mill/util/JsonFormatters.scala b/core/src/main/scala/mill/util/JsonFormatters.scala deleted file mode 100644 index 00a40e7d..00000000 --- a/core/src/main/scala/mill/util/JsonFormatters.scala +++ /dev/null @@ -1,42 +0,0 @@ -package mill.util - -import ammonite.ops.{Bytes, Path} -import upickle.Js -import upickle.default.{ReadWriter => RW} -object JsonFormatters extends JsonFormatters -trait JsonFormatters { - implicit val pathReadWrite: RW[ammonite.ops.Path] = RW[ammonite.ops.Path]( - o => Js.Str(o.toString()), - {case Js.Str(json) => Path(json.toString)}, - ) - - implicit val bytesReadWrite: RW[Bytes] = RW[Bytes]( - o => Js.Str(javax.xml.bind.DatatypeConverter.printBase64Binary(o.array)), - {case Js.Str(json) => new Bytes(javax.xml.bind.DatatypeConverter.parseBase64Binary(json.toString))} - ) - - - implicit lazy val crFormat: RW[ammonite.ops.CommandResult] = upickle.default.macroRW - - implicit lazy val modFormat: RW[coursier.Module] = upickle.default.macroRW - implicit lazy val depFormat: RW[coursier.Dependency]= upickle.default.macroRW - implicit lazy val attrFormat: RW[coursier.Attributes] = upickle.default.macroRW - implicit val stackTraceRW = upickle.default.ReadWriter[StackTraceElement]( - ste => Js.Obj( - "declaringClass" -> Js.Str(ste.getClassName), - "methodName" -> Js.Str(ste.getMethodName), - "fileName" -> Js.Str(ste.getFileName), - "lineNumber" -> Js.Num(ste.getLineNumber) - ), - {case json: Js.Obj => - new StackTraceElement( - json("declaringClass").str.toString, - json("methodName").str.toString, - json("fileName").str.toString, - json("lineNumber").num.toInt - ) - } - ) - - -} diff --git a/core/src/main/scala/mill/util/Logger.scala b/core/src/main/scala/mill/util/Logger.scala deleted file mode 100644 index 17c66d27..00000000 --- a/core/src/main/scala/mill/util/Logger.scala +++ /dev/null @@ -1,138 +0,0 @@ -package mill.util - -import java.io._ - -import ammonite.ops.Path -import ammonite.util.Colors - - -/** - * The standard logging interface of the Mill build tool. - * - * Contains four primary logging methods, in order of increasing importance: - * - * - `ticker`: short-lived logging output where consecutive lines over-write - * each other; useful for information which is transient and disposable - * - * - `info`: miscellaneous logging output which isn't part of the main output - * a user is looking for, but useful to provide context on what Mill is doing - * - * - `error`: logging output which represents problems the user should care - * about - * - * Also contains the two forwarded stdout and stderr streams, for code executed - * by Mill to use directly. Typically these correspond to the stdout and stderr, - * but when `--show` is used both are forwarded to stderr and stdout is only - * used to display the final `--show` output for easy piping. - */ -trait Logger { - def colored: Boolean - val errorStream: PrintStream - val outputStream: PrintStream - def info(s: String): Unit - def error(s: String): Unit - def ticker(s: String): Unit - def close(): Unit = () -} - -object DummyLogger extends Logger { - def colored = false - object errorStream extends PrintStream(_ => ()) - object outputStream extends PrintStream(_ => ()) - def info(s: String) = () - def error(s: String) = () - def ticker(s: String) = () -} - -class CallbackStream(wrapped: OutputStream, f: () => Unit) extends OutputStream{ - override def write(b: Array[Byte]): Unit = { f(); wrapped.write(b) } - - override def write(b: Array[Byte], off: Int, len: Int): Unit = { - f() - wrapped.write(b, off, len) - } - - def write(b: Int) = {f(); wrapped.write(b)} -} -case class PrintLogger(colored: Boolean, - colors: ammonite.util.Colors, - outStream: PrintStream, - infoStream: PrintStream, - errStream: PrintStream) extends Logger { - - var lastLineTicker = false - def falseTicker[T](t: T) = { - lastLineTicker = false - t - } - override val errorStream = new PrintStream( - new CallbackStream(errStream, () => lastLineTicker = false) - ) - override val outputStream = new PrintStream( - new CallbackStream(outStream, () => lastLineTicker = false) - ) - - - def info(s: String) = { - lastLineTicker = false - infoStream.println(colors.info()(s)) - } - def error(s: String) = { - lastLineTicker = false - errStream.println(colors.error()(s)) - } - def ticker(s: String) = { - if (lastLineTicker){ - val p = new PrintWriter(infoStream) - val nav = new ammonite.terminal.AnsiNav(p) - nav.up(1) - nav.clearLine(2) - nav.left(9999) - p.flush() - }else{ - infoStream.println() - } - lastLineTicker = true - infoStream.println(colors.info()(s)) - } -} - -case class FileLogger(colored: Boolean, file: Path) extends Logger { - private[this] var outputStreamUsed: Boolean = false - - lazy val outputStream = { - outputStreamUsed = true - new PrintStream(new FileOutputStream(file.toIO.getAbsolutePath)) - } - - lazy val errorStream = { - outputStreamUsed = true - new PrintStream(new FileOutputStream(file.toIO.getAbsolutePath)) - } - - def info(s: String) = outputStream.println(s) - def error(s: String) = outputStream.println(s) - def ticker(s: String) = outputStream.println(s) - override def close() = { - if (outputStreamUsed) - outputStream.close() - } -} - -case class MultiLogger(colored: Boolean, streams: Logger*) extends Logger { - lazy val outputStream: PrintStream = - new PrintStream(b => streams.foreach(_.outputStream.write(b))) { - override def flush() = streams.foreach(_.outputStream.flush()) - override def close() = streams.foreach(_.outputStream.close()) - } - lazy val errorStream: PrintStream = - new PrintStream(b => streams.foreach(_.outputStream.write(b))) { - override def flush() = streams.foreach(_.outputStream.flush()) - override def close() = streams.foreach(_.outputStream.close()) - } - - def info(s: String) = streams.foreach(_.info(s)) - def error(s: String) = streams.foreach(_.error(s)) - def ticker(s: String) = streams.foreach(_.ticker(s)) - override def close() = streams.foreach(_.close()) -}
\ No newline at end of file diff --git a/core/src/main/scala/mill/util/MultiBiMap.scala b/core/src/main/scala/mill/util/MultiBiMap.scala deleted file mode 100644 index 2cb81944..00000000 --- a/core/src/main/scala/mill/util/MultiBiMap.scala +++ /dev/null @@ -1,55 +0,0 @@ -package mill.util - -import scala.collection.mutable -import Strict.Agg -/** - * A map from keys to collections of values: you can assign multiple values - * to any particular key. Also allows lookups in both directions: what values - * are assigned to a key or what key a value is assigned ti. - */ -trait MultiBiMap[K, V]{ - def containsValue(v: V): Boolean - def lookupKey(k: K): Agg[V] - def lookupValue(v: V): K - def lookupValueOpt(v: V): Option[K] - def add(k: K, v: V): Unit - def removeAll(k: K): Agg[V] - def addAll(k: K, vs: TraversableOnce[V]): Unit - def keys(): Iterator[K] - def items(): Iterator[(K, Agg[V])] - def values(): Iterator[Agg[V]] - def keyCount: Int -} - -object MultiBiMap{ - class Mutable[K, V]() extends MultiBiMap[K, V]{ - private[this] val valueToKey = mutable.LinkedHashMap.empty[V, K] - private[this] val keyToValues = mutable.LinkedHashMap.empty[K, Agg.Mutable[V]] - def containsValue(v: V) = valueToKey.contains(v) - def lookupKey(k: K) = keyToValues(k) - def lookupKeyOpt(k: K) = keyToValues.get(k) - def lookupValue(v: V) = valueToKey(v) - def lookupValueOpt(v: V) = valueToKey.get(v) - def add(k: K, v: V): Unit = { - valueToKey(v) = k - keyToValues.getOrElseUpdate(k, new Agg.Mutable[V]()).append(v) - } - def removeAll(k: K): Agg[V] = keyToValues.get(k) match { - case None => Agg() - case Some(vs) => - vs.foreach(valueToKey.remove) - - keyToValues.remove(k) - vs - } - def addAll(k: K, vs: TraversableOnce[V]): Unit = vs.foreach(this.add(k, _)) - - def keys() = keyToValues.keysIterator - - def values() = keyToValues.valuesIterator - - def items() = keyToValues.iterator - - def keyCount = keyToValues.size - } -} |