Convert `Target#dirty` to `Target#externalHash`

2 files changed, 8 insertions, 8 deletions

diff --git a/src/main/scala/forge/Evaluator.scala b/src/main/scala/forge/Evaluator.scala
index 42bac78f..fae4447b 100644
--- a/src/main/scala/forge/Evaluator.scala
+++ b/src/main/scala/forge/Evaluator.scala
@@ -31,7 +31,8 @@ class Evaluator(workspacePath: Path,
   def evaluateGroupCached(group: OSet[Target[_]],
                           results: collection.Map[Target[_], Any]) = {
 
-    val (inputsHash, terminals) = partitionGroupInputOutput(group, results)
+    val (inputsHash0, terminals) = partitionGroupInputOutput(group, results)
+    val inputsHash = inputsHash0 + group.toIterator.map(_.externalHash).sum
     val primeLabel = labeling(terminals.items(0))
 
     val targetDestPath = workspacePath / primeLabel
@@ -40,7 +41,7 @@ class Evaluator(workspacePath: Path,
     val cached = for{
       json <- util.Try(Json.parse(read.getInputStream(metadataPath))).toOption
       (hash, terminalResults) <- Json.fromJson[(Int, Seq[JsValue])](json).asOpt
-      if hash == inputsHash && !group.exists(_.dirty)
+      if hash == inputsHash
     } yield (hash, terminalResults)
 
     cached match{
@@ -59,7 +60,7 @@ class Evaluator(workspacePath: Path,
 
         write.over(
           metadataPath,
-          Json.prettyPrint(Json.toJson((inputsHash, terminalResults))).getBytes(Codec.UTF8.charSet),
+          Json.prettyPrint(Json.toJson((inputsHash , terminalResults))).getBytes(Codec.UTF8.charSet),
         )
 
         (newResults, newEvaluated)
diff --git a/src/main/scala/forge/Target.scala b/src/main/scala/forge/Target.scala
index aa0371bc..81bc5b69 100644
--- a/src/main/scala/forge/Target.scala
+++ b/src/main/scala/forge/Target.scala
@@ -1,7 +1,7 @@
 package forge
 
 
-import ammonite.ops.mkdir
+import ammonite.ops.{ls, mkdir}
 import play.api.libs.json.{Format, JsValue, Json}
 abstract class Target[T](implicit formatter: Format[T]) extends Target.Ops[T]{
   /**
@@ -18,7 +18,7 @@ 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?
     */
-  def dirty: Boolean = false
+  def externalHash: Int = 0
 
 }
 
@@ -52,12 +52,10 @@ object Target{
   class Test(val inputs: Seq[Target[Int]],
              val pure: Boolean) extends Target[Int]{
     var counter = 0
-    var lastCounter = counter
     def evaluate(args: Args) = {
-      lastCounter = counter
       counter + args.args.map(_.asInstanceOf[Int]).sum
     }
-    override def dirty = lastCounter != counter
+    override def externalHash = counter
   }
   def traverse[T: Format](source: Seq[Target[T]]) = {
     new Traverse[T](source)
@@ -83,6 +81,7 @@ object Target{
   class Path(path: ammonite.ops.Path) extends Target[ammonite.ops.Path]{
     def evaluate(args: Args) = path
     val inputs = Nil
+    override def externalHash = ls.rec(path).map(x => (x.toString, x.mtime)).hashCode()
   }
   class Subprocess(val inputs: Seq[Target[_]],
                    command: Args => Seq[String]) extends Target[Subprocess.Result] {