From 38ca4a5005dbaee94e674c41bb7262d603eec73c Mon Sep 17 00:00:00 2001 From: Li Haoyi Date: Sat, 13 Jan 2018 15:07:04 -0800 Subject: rename OSet -> Agg --- core/src/main/scala/mill/define/Graph.scala | 14 ++--- core/src/main/scala/mill/discover/Discovered.scala | 6 +- core/src/main/scala/mill/eval/Evaluator.scala | 14 ++--- .../main/scala/mill/main/ReplApplyHandler.scala | 4 +- core/src/main/scala/mill/main/RunScript.scala | 4 +- core/src/main/scala/mill/modules/Jvm.scala | 14 ++--- core/src/main/scala/mill/package.scala | 4 +- core/src/main/scala/mill/util/MultiBiMap.scala | 18 +++--- core/src/main/scala/mill/util/OSet.scala | 66 +++++++++++----------- 9 files changed, 72 insertions(+), 72 deletions(-) (limited to 'core/src/main/scala') diff --git a/core/src/main/scala/mill/define/Graph.scala b/core/src/main/scala/mill/define/Graph.scala index 68fb65ed..f06dca11 100644 --- a/core/src/main/scala/mill/define/Graph.scala +++ b/core/src/main/scala/mill/define/Graph.scala @@ -2,17 +2,17 @@ package mill.define import mill.eval.Tarjans import mill.util.MultiBiMap -import mill.util.Strict.OSet +import mill.util.Strict.Agg object Graph { - class TopoSorted private[Graph](val values: OSet[Task[_]]) + 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 OSet.Mutable[Task[_]] + 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 @@ -27,8 +27,8 @@ object Graph { output } - def transitiveTargets(sourceTargets: OSet[Task[_]]): OSet[Task[_]] = { - val transitiveTargets = new OSet.Mutable[Task[_]] + 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 { @@ -44,7 +44,7 @@ object Graph { * 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: OSet[Task[_]]): TopoSorted = { + def topoSorted(transitiveTargets: Agg[Task[_]]): TopoSorted = { val indexed = transitiveTargets.indexed val targetIndices = indexed.zipWithIndex.toMap @@ -56,6 +56,6 @@ object Graph { val sortedClusters = Tarjans(numberedEdges) val nonTrivialClusters = sortedClusters.filter(_.length > 1) assert(nonTrivialClusters.isEmpty, nonTrivialClusters) - new TopoSorted(OSet.from(sortedClusters.flatten.map(indexed))) + new TopoSorted(Agg.from(sortedClusters.flatten.map(indexed))) } } diff --git a/core/src/main/scala/mill/discover/Discovered.scala b/core/src/main/scala/mill/discover/Discovered.scala index b7ec2140..98d4ebb9 100644 --- a/core/src/main/scala/mill/discover/Discovered.scala +++ b/core/src/main/scala/mill/discover/Discovered.scala @@ -5,7 +5,7 @@ import ammonite.main.Router import ammonite.main.Router.EntryPoint import mill.discover.Mirror.TargetPoint import mill.util.Ctx.Loader -import mill.util.Strict.OSet +import mill.util.Strict.Agg import scala.language.experimental.macros import scala.reflect.macros.blackbox.Context @@ -28,7 +28,7 @@ object Discovered { (mirror, segments, resolvedNode) => Seq(resolvedNode -> mirror) }.toMap - val targets = OSet.from( + val targets = Agg.from( Mirror.traverseNode(base, mirror){ (mirror, segmentsRev, resolvedNode) => for(target <- mirror.targets) yield target.asInstanceOf[TargetPoint[Any, Any]].run(resolvedNode) @@ -44,7 +44,7 @@ object Discovered { val targetsToSegments = segmentsToTargets.map(_.swap) } - def consistencyCheck[T](mapping: Discovered.Mapping[T]): OSet[Segments] = { + def consistencyCheck[T](mapping: Discovered.Mapping[T]): Agg[Segments] = { val mapping2 = Discovered.Mapping(mapping.mirror, mapping.base) for{ (t1, t2) <- mapping2.targets.zip(mapping.targets) diff --git a/core/src/main/scala/mill/eval/Evaluator.scala b/core/src/main/scala/mill/eval/Evaluator.scala index 2afaec6e..28d90fcf 100644 --- a/core/src/main/scala/mill/eval/Evaluator.scala +++ b/core/src/main/scala/mill/eval/Evaluator.scala @@ -9,7 +9,7 @@ import mill.discover.{Discovered, Mirror} import mill.define.Segment import mill.util import mill.util._ -import mill.util.Strict.OSet +import mill.util.Strict.Agg import scala.collection.mutable import scala.util.control.NonFatal @@ -35,7 +35,7 @@ class Evaluator[T](val workspacePath: Path, val workerCache = mutable.Map.empty[Ctx.Loader[_], Any] workerCache(Discovered.Mapping) = mapping - def evaluate(goals: OSet[Task[_]]): Evaluator.Results = { + def evaluate(goals: Agg[Task[_]]): Evaluator.Results = { mkdir(workspacePath) val transitive = Graph.transitiveTargets(goals) @@ -55,7 +55,7 @@ class Evaluator[T](val workspacePath: Path, case t if goals.contains(t) => Left(t) } - val evaluated = new OSet.Mutable[Task[_]] + val evaluated = new Agg.Mutable[Task[_]] val results = mutable.LinkedHashMap.empty[Task[_], Result[Any]] for (((terminal, group), i) <- sortedGroups.items().zipWithIndex){ @@ -84,7 +84,7 @@ class Evaluator[T](val workspacePath: Path, def evaluateGroupCached(terminal: Either[Task[_], Labelled[_]], - group: OSet[Task[_]], + group: Agg[Task[_]], results: collection.Map[Task[_], Result[Any]], counterMsg: String): (collection.Map[Task[_], Result[Any]], Seq[Task[_]]) = { @@ -168,7 +168,7 @@ class Evaluator[T](val workspacePath: Path, } - def evaluateGroup(group: OSet[Task[_]], + def evaluateGroup(group: Agg[Task[_]], results: collection.Map[Task[_], Result[Any]], groupBasePath: Option[Path], paths: Option[Evaluator.Paths], @@ -275,8 +275,8 @@ object Evaluator{ } case class Results(rawValues: Seq[Result[Any]], - evaluated: OSet[Task[_]], - transitive: OSet[Task[_]], + 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/main/ReplApplyHandler.scala b/core/src/main/scala/mill/main/ReplApplyHandler.scala index b83453ee..c239745a 100644 --- a/core/src/main/scala/mill/main/ReplApplyHandler.scala +++ b/core/src/main/scala/mill/main/ReplApplyHandler.scala @@ -5,7 +5,7 @@ import mill.define.Applicative.ApplyHandler import mill.define._ import mill.discover.{Discovered, Mirror} import mill.eval.{Evaluator, Result} -import mill.util.Strict.OSet +import mill.util.Strict.Agg import scala.collection.mutable object ReplApplyHandler{ @@ -34,7 +34,7 @@ class ReplApplyHandler(pprinter0: pprint.PPrinter, evaluator: Evaluator[_]) exte // 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(OSet(t)) + val res = evaluator.evaluate(Agg(t)) res.values match{ case Seq(head: V) => head case Nil => diff --git a/core/src/main/scala/mill/main/RunScript.scala b/core/src/main/scala/mill/main/RunScript.scala index 9f73fbc8..785db80e 100644 --- a/core/src/main/scala/mill/main/RunScript.scala +++ b/core/src/main/scala/mill/main/RunScript.scala @@ -12,7 +12,7 @@ import mill.define.Segment import mill.discover.Discovered import mill.eval.{Evaluator, Result} import mill.util.{EitherOps, Logger} -import mill.util.Strict.OSet +import mill.util.Strict.Agg import upickle.Js /** @@ -138,7 +138,7 @@ object RunScript{ def evaluate(evaluator: Evaluator[_], targets: Seq[Task[Any]]): (Seq[PathRef], Either[String, Seq[(Any, Option[upickle.Js.Value])]]) = { - val evaluated = evaluator.evaluate(OSet.from(targets)) + val evaluated = evaluator.evaluate(Agg.from(targets)) val watched = evaluated.results .iterator .collect { diff --git a/core/src/main/scala/mill/modules/Jvm.scala b/core/src/main/scala/mill/modules/Jvm.scala index 6e3fe45f..48f100b2 100644 --- a/core/src/main/scala/mill/modules/Jvm.scala +++ b/core/src/main/scala/mill/modules/Jvm.scala @@ -9,15 +9,15 @@ import ammonite.ops._ import mill.define.Task import mill.eval.PathRef import mill.util.Ctx -import mill.util.Loose.OSet +import mill.util.Loose.Agg import scala.annotation.tailrec import scala.collection.mutable object Jvm { - def gatherClassloaderJars(): OSet[Path] = { - val allJars = new OSet.Mutable[Path]() + def gatherClassloaderJars(): Agg[Path] = { + val allJars = new Agg.Mutable[Path]() var currentClassloader = Thread.currentThread().getContextClassLoader while(currentClassloader != null){ currentClassloader match{ @@ -30,14 +30,14 @@ object Jvm { } def interactiveSubprocess(mainClass: String, - classPath: OSet[Path], + classPath: Agg[Path], options: Seq[String] = Seq.empty): Unit = { import ammonite.ops.ImplicitWd._ %("java", "-cp", classPath.mkString(":"), mainClass, options) } def subprocess(mainClass: String, - classPath: OSet[Path], + classPath: Agg[Path], jvmOptions: Seq[String] = Seq.empty, options: Seq[String] = Seq.empty, workingDir: Path = null) @@ -101,7 +101,7 @@ object Jvm { m } - def createJar(inputPaths: OSet[Path], mainClass: Option[String] = None) + def createJar(inputPaths: Agg[Path], mainClass: Option[String] = None) (implicit ctx: Ctx.DestCtx): PathRef = { val outputPath = ctx.dest rm(outputPath) @@ -135,7 +135,7 @@ object Jvm { PathRef(outputPath) } - def createAssembly(inputPaths: OSet[Path], + def createAssembly(inputPaths: Agg[Path], mainClass: Option[String] = None, prependShellScript: String = "") (implicit ctx: Ctx.DestCtx): PathRef = { diff --git a/core/src/main/scala/mill/package.scala b/core/src/main/scala/mill/package.scala index 0b4f4873..78233cad 100644 --- a/core/src/main/scala/mill/package.scala +++ b/core/src/main/scala/mill/package.scala @@ -8,6 +8,6 @@ package object mill extends JsonFormatters{ type Module = define.Module val Module = define.Module type Cross[T] = define.Cross[T] - type OSet[T] = util.Loose.OSet[T] - val OSet = util.Loose.OSet + type Agg[T] = util.Loose.Agg[T] + val Agg = util.Loose.Agg } diff --git a/core/src/main/scala/mill/util/MultiBiMap.scala b/core/src/main/scala/mill/util/MultiBiMap.scala index abbaa752..2cb81944 100644 --- a/core/src/main/scala/mill/util/MultiBiMap.scala +++ b/core/src/main/scala/mill/util/MultiBiMap.scala @@ -1,7 +1,7 @@ package mill.util import scala.collection.mutable -import Strict.OSet +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 @@ -9,22 +9,22 @@ import Strict.OSet */ trait MultiBiMap[K, V]{ def containsValue(v: V): Boolean - def lookupKey(k: K): OSet[V] + 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): OSet[V] + def removeAll(k: K): Agg[V] def addAll(k: K, vs: TraversableOnce[V]): Unit def keys(): Iterator[K] - def items(): Iterator[(K, OSet[V])] - def values(): Iterator[OSet[V]] + 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, OSet.Mutable[V]] + 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) @@ -32,10 +32,10 @@ object MultiBiMap{ def lookupValueOpt(v: V) = valueToKey.get(v) def add(k: K, v: V): Unit = { valueToKey(v) = k - keyToValues.getOrElseUpdate(k, new OSet.Mutable[V]()).append(v) + keyToValues.getOrElseUpdate(k, new Agg.Mutable[V]()).append(v) } - def removeAll(k: K): OSet[V] = keyToValues.get(k) match { - case None => OSet() + def removeAll(k: K): Agg[V] = keyToValues.get(k) match { + case None => Agg() case Some(vs) => vs.foreach(valueToKey.remove) diff --git a/core/src/main/scala/mill/util/OSet.scala b/core/src/main/scala/mill/util/OSet.scala index a4fcc406..d0f41777 100644 --- a/core/src/main/scala/mill/util/OSet.scala +++ b/core/src/main/scala/mill/util/OSet.scala @@ -3,46 +3,46 @@ package mill.util import scala.collection.mutable -object Strict extends OSetWrapper(true) -object Loose extends OSetWrapper(false) -sealed class OSetWrapper(strictUniqueness: Boolean){ +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 OSet[V] extends TraversableOnce[V]{ + 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]): OSet[T] - def map[T](f: V => T): OSet[T] - def filter(f: V => Boolean): OSet[V] - def withFilter(f: V => Boolean): OSet[V] - def collect[T](f: PartialFunction[V, T]): OSet[T] - def zipWithIndex: OSet[(V, Int)] - def reverse: OSet[V] - def zip[T](other: OSet[T]): OSet[(V, T)] - def ++[T >: V](other: TraversableOnce[T]): OSet[T] + 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 OSet{ - def empty[V]: OSet[V] = new OSet.Mutable[V] - implicit def jsonFormat[T: upickle.default.ReadWriter]: upickle.default.ReadWriter[OSet[T]] = - upickle.default.ReadWriter[OSet[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 => OSet.from(upickle.default.readJs[Seq[T]](json))} + {case json => Agg.from(upickle.default.readJs[Seq[T]](json))} ) def apply[V](items: V*) = from(items) - def from[V](items: TraversableOnce[V]): OSet[V] = { - val set = new OSet.Mutable[V]() + def from[V](items: TraversableOnce[V]): Agg[V] = { + val set = new Agg.Mutable[V]() items.foreach(set.append) set } - class Mutable[V]() extends OSet[V]{ + class Mutable[V]() extends Agg[V]{ private[this] val set0 = mutable.LinkedHashSet.empty[V] def contains(v: V) = set0.contains(v) @@ -57,22 +57,22 @@ sealed class OSetWrapper(strictUniqueness: Boolean){ def indexed: IndexedSeq[V] = items.toIndexedSeq def set: collection.Set[V] = set0 - def map[T](f: V => T): OSet[T] = { - val output = new OSet.Mutable[T] + 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]): OSet[T] = { - val output = new OSet.Mutable[T] + 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): OSet[V] = { - val output = new OSet.Mutable[V] + 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): OSet[V] = filter(f) + def withFilter(f: V => Boolean): Agg[V] = filter(f) def collect[T](f: PartialFunction[V, T]) = this.filter(f.isDefinedAt).map(x => f(x)) @@ -84,10 +84,10 @@ sealed class OSetWrapper(strictUniqueness: Boolean){ } } - def reverse = OSet.from(indexed.reverseIterator) + def reverse = Agg.from(indexed.reverseIterator) - def zip[T](other: OSet[T]) = OSet.from(items.zip(other.items)) - def ++[T >: V](other: TraversableOnce[T]) = OSet.from(items ++ other) + 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 @@ -107,10 +107,10 @@ sealed class OSetWrapper(strictUniqueness: Boolean){ override def hashCode() = items.map(_.hashCode()).sum override def equals(other: Any) = other match{ - case s: OSet[_] => items.sameElements(s.items) + case s: Agg[_] => items.sameElements(s.items) case _ => super.equals(other) } - override def toString = items.mkString("OSet(", ", ", ")") + override def toString = items.mkString("Agg(", ", ", ")") } } } -- cgit v1.2.3