Implement `DefCtx`, to bundle together `StaticContext` and `sourcecode.Enclosing`

4 files changed, 33 insertions, 26 deletions

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 = {