Got grouped evaluation working

2 files changed, 14 insertions, 15 deletions

diff --git a/src/main/scala/forge/Evaluator.scala b/src/main/scala/forge/Evaluator.scala
index ecbf4260..32a3c9d0 100644
--- a/src/main/scala/forge/Evaluator.scala
+++ b/src/main/scala/forge/Evaluator.scala
@@ -50,12 +50,13 @@ class Evaluator(workspacePath: jnio.Path,
     val targetDestPath = workspacePath.resolve(
       jnio.Paths.get(enclosingStr.stripSuffix(enclosingBase.label))
     )
+    val anyDirty = group.exists(_.dirty)
     deleteRec(targetDestPath)
 
     val inputsHash = inputResults.hashCode
-    (primeTerminal.dirty, resultCache.get(primeTerminal.defCtx.label)) match{
-      case (Some(dirtyCheck), Some((hash, terminalResults)))
-        if hash == inputsHash && !dirtyCheck() =>
+    resultCache.get(primeTerminal.defCtx.label) match{
+      case Some((hash, terminalResults))
+        if hash == inputsHash && !anyDirty =>
         for((terminal, res) <- terminals.items.zip(terminalResults)){
 
           newResults(terminal) = primeTerminal.formatter.reads(Json.parse(res)).get
@@ -64,14 +65,16 @@ class Evaluator(workspacePath: jnio.Path,
       case _ =>
         val terminalResults = mutable.Buffer.empty[String]
         for(target <- group.items){
-
           newEvaluated.append(target)
-          if (target.defCtx.anonId.isDefined && target.dirty.isEmpty) {
-            val res = target.evaluate(new Args(inputResults, targetDestPath))
+          val targetInputValues = target.inputs.toVector.map(x =>
+            newResults.getOrElse(x, results(x))
+          )
+          if (target.defCtx.anonId.isDefined) {
+            val res = target.evaluate(new Args(targetInputValues, targetDestPath))
             newResults(target) = res
           }else{
             val (res, serialized) = target.evaluateAndWrite(
-              new Args(inputResults, targetDestPath)
+              new Args(targetInputValues, targetDestPath)
             )
             if (!internalInputSet(target)){
               terminalResults.append(serialized)
@@ -117,7 +120,7 @@ object Evaluator{
       val targetGroup = grouping.lookupValue(target)
       for(upstream <- target.inputs){
         grouping.lookupValueOpt(upstream) match{
-          case None if upstream.dirty.isEmpty && upstream.defCtx.anonId.nonEmpty =>
+          case None if upstream.defCtx.anonId.nonEmpty =>
             grouping.add(targetGroup, upstream)
           case Some(upstreamGroup) if upstreamGroup == targetGroup =>
             val upstreamTargets = grouping.removeAll(upstreamGroup)
diff --git a/src/main/scala/forge/Target.scala b/src/main/scala/forge/Target.scala
index adf2cb99..6f434030 100644
--- a/src/main/scala/forge/Target.scala
+++ b/src/main/scala/forge/Target.scala
@@ -21,12 +21,8 @@ abstract class Target[T](implicit formatter: Format[T]) extends Target.Ops[T]{
   /**
     * Even if this target's inputs did not change, does it need to re-evaluate
     * anyway?
-    *
-    * - None means it never needs to re-evaluate unless its inputs do
-    * - Some(f) contains a function that returns whether or not it should re-evaluate,
-    *   e.g. if the files this target represents on disk changed
     */
-  val dirty: Option[() => Boolean] = Some(() => false)
+  def dirty: Boolean = false
 
 }
 
@@ -67,9 +63,9 @@ object Target{
     var lastCounter = counter
     def evaluate(args: Args) = {
       lastCounter = counter
-        counter + args.args.map(_.asInstanceOf[Int]).sum
+      counter + args.args.map(_.asInstanceOf[Int]).sum
     }
-    override val dirty = if (pure) None else Some(() => lastCounter != counter)
+    override def dirty = lastCounter != counter
   }
   def traverse[T: Format](source: Seq[Target[T]])(implicit defCtx: DefCtx) = {
     new Traverse[T](source, defCtx)