From 5a7e3db2e39e8cd1d3cd56d186c055439ed6d160 Mon Sep 17 00:00:00 2001 From: Li Haoyi Date: Sat, 21 Oct 2017 20:29:25 -0700 Subject: Implement `DefCtx`, to bundle together `StaticContext` and `sourcecode.Enclosing` --- src/main/scala/hbt/Evaluator.scala | 7 ++++--- src/main/scala/hbt/StaticContext.scala | 10 +++++++++- src/main/scala/hbt/Target.scala | 32 +++++++++++++++----------------- src/main/scala/hbt/Util.scala | 10 +++++----- 4 files changed, 33 insertions(+), 26 deletions(-) (limited to 'src/main/scala/hbt') diff --git a/src/main/scala/hbt/Evaluator.scala b/src/main/scala/hbt/Evaluator.scala index 442ec633..2931662a 100644 --- a/src/main/scala/hbt/Evaluator.scala +++ b/src/main/scala/hbt/Evaluator.scala @@ -17,9 +17,10 @@ object Evaluator{ def rec(t: Target[_], path: List[String]): Unit = { if (targetPaths.contains(t)) () // do nothing else { - val currentPath = - if (!t.label.startsWith(enclosing.value)) path.reverse - else t.label.stripPrefix(enclosing.value).drop(1).split('.').toList + val currentPath = t.defCtx.staticEnclosing match{ + case None => path.reverse + case Some(s) => s.stripPrefix(enclosing.value).drop(1).split('.').toList + } targetPaths(t) = currentPath t.inputs.zipWithIndex.foreach{case (c, i) => rec(c, i.toString :: currentPath)} diff --git a/src/main/scala/hbt/StaticContext.scala b/src/main/scala/hbt/StaticContext.scala index 7eb4fa8d..60298a3f 100644 --- a/src/main/scala/hbt/StaticContext.scala +++ b/src/main/scala/hbt/StaticContext.scala @@ -6,7 +6,7 @@ import scala.reflect.macros._ case class StaticContext(value: Boolean) object StaticContext { - implicit def apply: StaticContext = macro applyImpl + implicit def default: StaticContext = macro applyImpl def rec(c: Context)(expr: c.Symbol): Boolean = { import c.universe._ // Classes and traits and such @@ -23,3 +23,11 @@ object StaticContext { c.Expr[StaticContext](q"hbt.StaticContext($staticContext)") } } +case class DefCtx(staticEnclosing: Option[String]) +object DefCtx{ + implicit def default(implicit enc: sourcecode.Enclosing, + sc: StaticContext) = { + if (sc.value) DefCtx(Some(enc.value)) + else DefCtx(None) + } +} \ No newline at end of file diff --git a/src/main/scala/hbt/Target.scala b/src/main/scala/hbt/Target.scala index fa2fbbe5..7b1c5166 100644 --- a/src/main/scala/hbt/Target.scala +++ b/src/main/scala/hbt/Target.scala @@ -1,33 +1,31 @@ package hbt -import java.io.InputStreamReader import java.nio.{file => jnio} -import sourcecode.Enclosing - trait Target[T]{ - val label: String + val defCtx: DefCtx + val inputs: Seq[Target[_]] def evaluate(args: Args): T - def map[V](f: T => V)(implicit path: Enclosing) = { - Target.Mapped(this, f, path.value) + def map[V](f: T => V)(implicit defCtx: DefCtx) = { + Target.Mapped(this, f, defCtx) } - def zip[V](other: Target[V])(implicit path: Enclosing) = { - Target.Zipped(this, other, path.value) + def zip[V](other: Target[V])(implicit defCtx: DefCtx) = { + Target.Zipped(this, other, defCtx) } def ~[V, R](other: Target[V]) - (implicit s: Implicits.Sequencer[T, V, R]): Target[R] = { + (implicit s: Implicits.Sequencer[T, V, R], defCtx: DefCtx): Target[R] = { this.zip(other).map(s.apply _ tupled) } } object Target{ - def traverse[T](source: Seq[Target[T]])(implicit path: Enclosing) = { - Traverse[T](source, path.value) + def traverse[T](source: Seq[Target[T]])(implicit defCtx: DefCtx) = { + Traverse[T](source, defCtx) } - case class Traverse[T](inputs: Seq[Target[T]], label: String) extends Target[Seq[T]]{ + case class Traverse[T](inputs: Seq[Target[T]], defCtx: DefCtx) extends Target[Seq[T]]{ def evaluate(args: Args) = { for (i <- 0 until args.length) yield args(i).asInstanceOf[T] @@ -35,25 +33,25 @@ object Target{ } case class Mapped[T, V](source: Target[T], f: T => V, - label: String) extends Target[V]{ + defCtx: DefCtx) extends Target[V]{ def evaluate(args: Args) = f(args(0)) val inputs = List(source) } case class Zipped[T, V](source1: Target[T], source2: Target[V], - label: String) extends Target[(T, V)]{ + defCtx: DefCtx) extends Target[(T, V)]{ def evaluate(args: Args) = (args(0), args(0)) val inputs = List(source1, source1) } - def path(path: jnio.Path)(implicit label: Enclosing) = Path(path, label.value) - case class Path(path: jnio.Path, label: String) extends Target[jnio.Path]{ + def path(path: jnio.Path)(implicit defCtx: DefCtx) = Path(path, defCtx) + case class Path(path: jnio.Path, defCtx: DefCtx) extends Target[jnio.Path]{ def evaluate(args: Args) = path val inputs = Nil } case class Subprocess(inputs: Seq[Target[_]], command: Args => Seq[String], - label: String) extends Target[Subprocess.Result] { + defCtx: DefCtx) extends Target[Subprocess.Result] { def evaluate(args: Args) = { jnio.Files.createDirectories(args.dest) diff --git a/src/main/scala/hbt/Util.scala b/src/main/scala/hbt/Util.scala index 7f8ccbcf..e1c6c4cf 100644 --- a/src/main/scala/hbt/Util.scala +++ b/src/main/scala/hbt/Util.scala @@ -10,22 +10,22 @@ import scala.collection.JavaConverters._ object Util{ def compileAll(sources: Target[Seq[jnio.Path]]) - (implicit path: Enclosing) = { + (implicit defCtx: DefCtx) = { Target.Subprocess( Seq(sources), args => Seq("javac") ++ args[Seq[jnio.Path]](0).map(_.toAbsolutePath.toString) ++ Seq("-d", args.dest.toAbsolutePath.toString), - path.value + defCtx ).map(_.dest) } - def list(root: Target[jnio.Path]): Target[Seq[jnio.Path]] = { + def list(root: Target[jnio.Path])(implicit defCtx: DefCtx): Target[Seq[jnio.Path]] = { root.map(jnio.Files.list(_).iterator().asScala.toArray[jnio.Path]) } - case class jarUp(roots: Target[jnio.Path]*)(implicit path: Enclosing) extends Target[jnio.Path]{ - val label = path.value + case class jarUp(roots: Target[jnio.Path]*)(implicit val defCtx: DefCtx) extends Target[jnio.Path]{ + val inputs = roots def evaluate(args: Args): jnio.Path = { -- cgit v1.2.3