Swap over wholesale to ammonite.ops

6 files changed, 41 insertions, 64 deletions

diff --git a/src/main/scala/forge/Args.scala b/src/main/scala/forge/Args.scala
index c7cc455c..e73af6c1 100644
--- a/src/main/scala/forge/Args.scala
+++ b/src/main/scala/forge/Args.scala
@@ -1,8 +1,7 @@
 package forge
 
-import java.nio.{file => jnio}
 
-class Args(val args: IndexedSeq[_], val dest: jnio.Path){
+class Args(val args: IndexedSeq[_], val dest: ammonite.ops.Path){
   def length = args.length
   def apply[T](index: Int): T = {
     if (index >= 0 && index < args.length) args(index).asInstanceOf[T]
diff --git a/src/main/scala/forge/Evaluator.scala b/src/main/scala/forge/Evaluator.scala
index ed63f199..42bac78f 100644
--- a/src/main/scala/forge/Evaluator.scala
+++ b/src/main/scala/forge/Evaluator.scala
@@ -1,18 +1,16 @@
 package forge
 
-import java.nio.charset.Charset
-import java.nio.{file => jnio}
 
 import play.api.libs.json.{JsValue, Json}
 
 import scala.collection.mutable
 import scala.io.Codec
-
-class Evaluator(workspacePath: jnio.Path,
+import ammonite.ops._
+class Evaluator(workspacePath: Path,
                 labeling: Map[Target[_], Seq[String]]){
 
   def evaluate(targets: OSet[Target[_]]): Evaluator.Results = {
-    jnio.Files.createDirectories(workspacePath)
+    mkdir(workspacePath)
 
     val sortedGroups = Evaluator.groupAroundNamedTargets(
       Evaluator.topoSortedTransitiveTargets(targets),
@@ -34,14 +32,13 @@ class Evaluator(workspacePath: jnio.Path,
                           results: collection.Map[Target[_], Any]) = {
 
     val (inputsHash, terminals) = partitionGroupInputOutput(group, results)
-    val primeLabel = labeling(terminals.items(0)).mkString("/")
+    val primeLabel = labeling(terminals.items(0))
+
+    val targetDestPath = workspacePath / primeLabel
+    val metadataPath = targetDestPath / up / (targetDestPath.last + ".forge.json")
 
-    val targetDestPath = workspacePath.resolve(jnio.Paths.get(primeLabel))
-    val metadataPath = targetDestPath.resolveSibling(
-      targetDestPath.getFileName.toString + ".forge.json"
-    )
     val cached = for{
-      json <- util.Try(Json.parse(jnio.Files.newInputStream(metadataPath))).toOption
+      json <- util.Try(Json.parse(read.getInputStream(metadataPath))).toOption
       (hash, terminalResults) <- Json.fromJson[(Int, Seq[JsValue])](json).asOpt
       if hash == inputsHash && !group.exists(_.dirty)
     } yield (hash, terminalResults)
@@ -60,11 +57,9 @@ class Evaluator(workspacePath: jnio.Path,
         }
 
 
-        jnio.Files.write(
+        write.over(
           metadataPath,
           Json.prettyPrint(Json.toJson((inputsHash, terminalResults))).getBytes(Codec.UTF8.charSet),
-          jnio.StandardOpenOption.CREATE,
-          jnio.StandardOpenOption.TRUNCATE_EXISTING
         )
 
         (newResults, newEvaluated)
@@ -85,9 +80,9 @@ class Evaluator(workspacePath: jnio.Path,
   def evaluateGroup(group: OSet[Target[_]],
                     results: collection.Map[Target[_], Any],
                     terminals: OSet[Target[_]],
-                    targetDestPath: jnio.Path) = {
+                    targetDestPath: Path) = {
 
-    deleteRec(targetDestPath)
+    rm(targetDestPath)
     val terminalResults = mutable.Buffer.empty[JsValue]
     val newEvaluated = mutable.Buffer.empty[Target[_]]
     val newResults = mutable.Map.empty[Target[_], Any]
@@ -112,16 +107,6 @@ class Evaluator(workspacePath: jnio.Path,
     (newResults, newEvaluated, terminalResults)
   }
 
-  def deleteRec(path: jnio.Path) = {
-    if (jnio.Files.exists(path)){
-      import collection.JavaConverters._
-      jnio.Files.walk(path).iterator()
-        .asScala
-        .toArray
-        .reverseIterator
-        .map(jnio.Files.deleteIfExists)
-    }
-  }
 }
 
 
diff --git a/src/main/scala/forge/Target.scala b/src/main/scala/forge/Target.scala
index 144fc0e9..aa0371bc 100644
--- a/src/main/scala/forge/Target.scala
+++ b/src/main/scala/forge/Target.scala
@@ -1,7 +1,7 @@
 package forge
 
-import java.nio.{file => jnio}
 
+import ammonite.ops.mkdir
 import play.api.libs.json.{Format, JsValue, Json}
 abstract class Target[T](implicit formatter: Format[T]) extends Target.Ops[T]{
   /**
@@ -79,8 +79,8 @@ object Target{
     val inputs = List(source1, source1)
   }
 
-  def path(path: jnio.Path) = new Path(path)
-  class Path(path: jnio.Path) extends Target[jnio.Path]{
+  def path(path: ammonite.ops.Path) = new Path(path)
+  class Path(path: ammonite.ops.Path) extends Target[ammonite.ops.Path]{
     def evaluate(args: Args) = path
     val inputs = Nil
   }
@@ -88,7 +88,7 @@ object Target{
                    command: Args => Seq[String]) extends Target[Subprocess.Result] {
 
     def evaluate(args: Args) = {
-      jnio.Files.createDirectories(args.dest)
+      mkdir(args.dest)
       import ammonite.ops._
       implicit val path = ammonite.ops.Path(args.dest, pwd)
       val output = %%(command(args))
@@ -97,6 +97,6 @@ object Target{
     }
   }
   object Subprocess{
-    case class Result(result: ammonite.ops.CommandResult, dest: jnio.Path)
+    case class Result(result: ammonite.ops.CommandResult, dest: ammonite.ops.Path)
   }
 }
diff --git a/src/main/scala/forge/package.scala b/src/main/scala/forge/package.scala
index fe7e1965..bcbdc70f 100644
--- a/src/main/scala/forge/package.scala
+++ b/src/main/scala/forge/package.scala
@@ -1,21 +1,15 @@
 import play.api.libs.json._
-import java.nio.{file => jnio}
 
-import ammonite.ops.Bytes
+import ammonite.ops.{Bytes, Path}
 
 package object forge {
 
-//  implicit object jsValueFormat extends Format[JsValue]{
-//    def reads(json: JsValue) = JsSuccess(json)
-//    def writes(o: jnio.Path) = JsString(o.toAbsolutePath.toString)
-//  }
-
-  implicit object pathFormat extends Format[jnio.Path]{
+  implicit object pathFormat extends Format[ammonite.ops.Path]{
     def reads(json: JsValue) = json match{
-      case JsString(v) => JsSuccess(jnio.Paths.get(v))
+      case JsString(v) => JsSuccess(Path(v))
       case _ => JsError("Paths must be a String")
     }
-    def writes(o: jnio.Path) = JsString(o.toAbsolutePath.toString)
+    def writes(o: Path) = JsString(o.toString)
   }
 
   implicit object bytesFormat extends Format[Bytes]{
@@ -46,6 +40,6 @@ package object forge {
     }
   }
 
-  implicit val crFormat = Json.format[ammonite.ops.CommandResult]
-  implicit val tsFormat = Json.format[Target.Subprocess.Result]
+  implicit val crFormat: Format[ammonite.ops.CommandResult] = Json.format
+  implicit val tsFormat: Format[Target.Subprocess.Result] = Json.format
 }
diff --git a/src/test/scala/forge/EvaluationTests.scala b/src/test/scala/forge/EvaluationTests.scala
index b9318c43..2fde2ce0 100644
--- a/src/test/scala/forge/EvaluationTests.scala
+++ b/src/test/scala/forge/EvaluationTests.scala
@@ -1,6 +1,5 @@
 package forge
 
-import java.nio.{file => jnio}
 
 import utest._
 import utest.framework.TestPath
@@ -13,7 +12,7 @@ object EvaluationTests extends TestSuite{
     'evaluateSingle - {
 
       class Checker[T: Discovered](base: T)(implicit tp: TestPath) {
-        val workspace = jnio.Paths.get("target/workspace", tp.value.mkString("/"))
+        val workspace = ammonite.ops.pwd / 'target / 'workspace / tp.value
         ammonite.ops.rm(ammonite.ops.Path(workspace, ammonite.ops.pwd))
         // Make sure data is persisted even if we re-create the evaluator each time
         def evaluator = new Evaluator(
diff --git a/src/test/scala/forge/Main.scala b/src/test/scala/forge/Main.scala
index b65099ec..e4e38b23 100644
--- a/src/test/scala/forge/Main.scala
+++ b/src/test/scala/forge/Main.scala
@@ -1,53 +1,53 @@
 package forge
 import java.io.FileOutputStream
-import java.nio.{file => jnio}
 import java.util.jar.JarEntry
 import collection.JavaConverters._
+import ammonite.ops._
 object Main{
 
   def main(args: Array[String]): Unit = {
 
-    val sourceRoot = Target.path(jnio.Paths.get("src/test/resources/example/src"))
-    val resourceRoot = Target.path(jnio.Paths.get("src/test/resources/example/resources"))
+    val sourceRoot = Target.path(pwd / 'src / 'test / 'resources / 'example / 'src)
+    val resourceRoot = Target.path(pwd / 'src / 'test / 'resources / 'example / 'resources)
     val allSources = list(sourceRoot)
     val classFiles = compileAll(allSources)
     val jar = jarUp(resourceRoot, classFiles)
 
 //    val evaluator = new Evaluator(
-//      jnio.Paths.get("target/workspace"),
+//      Paths.get("target/workspace"),
 //      DefCtx("forge.Main ", None)
 //    )
 //    evaluator.evaluate(OSet(jar))
   }
-  def compileAll(sources: Target[Seq[jnio.Path]])  = {
+  def compileAll(sources: Target[Seq[Path]])  = {
     new Target.Subprocess(
       Seq(sources),
       args =>
         Seq("javac") ++
-          args[Seq[jnio.Path]](0).map(_.toAbsolutePath.toString) ++
-          Seq("-d", args.dest.toAbsolutePath.toString)
+        args[Seq[Path]](0).map(_.toString) ++
+        Seq("-d", args.dest.toString)
     ).map(_.dest)
   }
 
-  def list(root: Target[jnio.Path]): Target[Seq[jnio.Path]] = {
-    root.map(jnio.Files.list(_).iterator().asScala.toArray[jnio.Path])
+  def list(root: Target[Path]): Target[Seq[Path]] = {
+    root.map(ls.rec)
   }
-  case class jarUp(roots: Target[jnio.Path]*) extends Target[jnio.Path]{
+  case class jarUp(roots: Target[Path]*) extends Target[Path]{
 
     val inputs = roots
-    def evaluate(args: Args): jnio.Path = {
+    def evaluate(args: Args): Path = {
 
-      val output = new java.util.jar.JarOutputStream(new FileOutputStream(args.dest.toFile))
+      val output = new java.util.jar.JarOutputStream(new FileOutputStream(args.dest.toIO))
       for{
         root0 <- args.args
-        root = root0.asInstanceOf[jnio.Path]
+        root = root0.asInstanceOf[Path]
 
-        path <- jnio.Files.walk(root).iterator().asScala
-        if jnio.Files.isRegularFile(path)
+        path <- ls.rec(root)
+        if path.isFile
       }{
-        val relative = root.relativize(path)
+        val relative = path.relativeTo(root)
         output.putNextEntry(new JarEntry(relative.toString))
-        output.write(jnio.Files.readAllBytes(path))
+        output.write(read.bytes(path))
       }
       output.close()
       args.dest