Basic evaluator that creates classfiles and a jar now works

1 files changed, 35 insertions, 21 deletions

diff --git a/src/main/scala/hbt/Hbt.scala b/src/main/scala/hbt/Hbt.scala
index c6035e55..b321920b 100644
--- a/src/main/scala/hbt/Hbt.scala
+++ b/src/main/scala/hbt/Hbt.scala
@@ -1,25 +1,21 @@
 package hbt
 
-import java.io.FileOutputStream
-
-import collection.JavaConverters._
 import java.nio.{file => jnio}
-import java.util.jar.JarEntry
 
 import sourcecode.Enclosing
 
 import scala.collection.mutable
-class Args(val args: IndexedSeq[_]){
+class Args(val args: IndexedSeq[_], val dest: jnio.Path){
   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}")
   }
 }
-sealed trait Target[T]{
+trait Target[T]{
   val label: String
-  def evaluate(args: Args): T
   val inputs: Seq[Target[_]]
+  def evaluate(args: Args): T
 
   def map[V](f: T => V)(implicit path: Enclosing) = {
     Target.Mapped(this, f, path.value)
@@ -36,12 +32,12 @@ sealed trait Target[T]{
 
 object Target{
   def traverse[T](source: Seq[Target[T]])(implicit path: Enclosing) = {
-    Traverse(source, path.value)
+    Traverse[T](source, path.value)
   }
   case class Traverse[T](inputs: Seq[Target[T]], label: String) extends Target[Seq[T]]{
     def evaluate(args: Args) = {
       for (i <- 0 until args.length)
-      yield args(i)
+      yield args(i).asInstanceOf[T]
     }
 
   }
@@ -56,6 +52,8 @@ object Target{
     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 evaluate(args: Args) = path
     val inputs = Nil
@@ -72,17 +70,21 @@ object Target{
 object Hbt{
 
 
-  def evaluateTargetGraph[T](t: Target[T]): T = {
-    val targetSet = mutable.Set.empty[Target[_]]
-    def rec(t: Target[_]): Unit = {
-      if (targetSet.contains(t)) () // do nothing
+  def evaluateTargetGraph[T](t: Target[T])(implicit enclosing: Enclosing): T = {
+    val targetPaths = mutable.Map.empty[Target[_], List[String]]
+    def rec(t: Target[_], path: List[String]): Unit = {
+      if (targetPaths.contains(t)) () // do nothing
       else {
-        targetSet.add(t)
-        t.inputs.foreach(rec)
+        val currentPath =
+          if (!t.label.startsWith(enclosing.value)) path.reverse
+          else t.label.stripPrefix(enclosing.value).drop(1).split('.').toList
+
+        targetPaths(t) = currentPath
+        t.inputs.zipWithIndex.foreach{case (c, i) => rec(c, i.toString :: currentPath)}
       }
     }
-    rec(t)
-    val targets = targetSet.toIndexedSeq
+    rec(t, Nil)
+    val targets = targetPaths.keys.toIndexedSeq
     val targetIndices = targets.zipWithIndex.toMap
 
     val numberedEdges =
@@ -96,10 +98,22 @@ object Hbt{
     val results = mutable.Map.empty[Target[_], Any]
     for (cluster <- sortedClusters){
       val Seq(singletonIndex) = cluster
-      val singleton = targets(singletonIndex)
-      val inputResults = singleton.inputs.map(results)
-      results(singleton) = singleton.evaluate(new Args(inputResults.toIndexedSeq))
+      val target = targets(singletonIndex)
+      val inputResults = target.inputs.map(results)
+      val targetDestPath = jnio.Paths.get(targetPaths(target).mkString("/"))
+      import collection.JavaConverters._
+      if (jnio.Files.exists(targetDestPath)){
+        jnio.Files.walk(targetDestPath).iterator()
+          .asScala
+          .toArray
+          .reverseIterator
+          .map(jnio.Files.deleteIfExists)
+      }
+
+      results(target) = target.evaluate(
+        new Args(inputResults.toIndexedSeq, targetDestPath)
+      )
     }
     results(t).asInstanceOf[T]
   }
-}
\ No newline at end of file
+}