Break out reusable JVM specific stuff into its own file

3 files changed, 73 insertions, 55 deletions

diff --git a/core/src/main/scala/forge/define/Target.scala b/core/src/main/scala/forge/define/Target.scala
index 1d7a49f1..59229dab 100644
--- a/core/src/main/scala/forge/define/Target.scala
+++ b/core/src/main/scala/forge/define/Target.scala
@@ -68,8 +68,7 @@ object Target extends Applicative.Applyer[Target, Target]{
     def evaluate(args: Args) = f(args(0))
     val inputs = List(source)
   }
-  class Zipped[T, V](source1: Target[T],
-                                     source2: Target[V]) extends Target[(T, V)]{
+  class Zipped[T, V](source1: Target[T], source2: Target[V]) extends Target[(T, V)]{
     def evaluate(args: Args) = (args(0), args(1))
     val inputs = List(source1, source2)
   }
diff --git a/core/src/main/scala/forge/modules/Jvm.scala b/core/src/main/scala/forge/modules/Jvm.scala
new file mode 100644
index 00000000..79a2c989
--- /dev/null
+++ b/core/src/main/scala/forge/modules/Jvm.scala
@@ -0,0 +1,70 @@
+package forge.modules
+
+import java.io.FileOutputStream
+import java.util.jar.{JarEntry, JarOutputStream}
+
+import ammonite.ops._
+import forge.define.Target
+import forge.eval.PathRef
+import forge.util.Args
+
+
+object Jvm {
+
+  def subprocess(mainClass: String,
+                 classPath: Seq[Path]) = {
+    import ammonite.ops.ImplicitWd._
+    %("java", "-cp", classPath.mkString(":"), mainClass)
+  }
+
+  private def createManifest(mainClass: Option[String]) = {
+    val m = new java.util.jar.Manifest()
+    m.getMainAttributes.put(java.util.jar.Attributes.Name.MANIFEST_VERSION, "1.0")
+    m.getMainAttributes.putValue( "Created-By", "Scala Forge" )
+    mainClass.foreach(
+      m.getMainAttributes.put(java.util.jar.Attributes.Name.MAIN_CLASS, _)
+    )
+    m
+  }
+
+  def createJar(outputPath: Path, inputPaths: Seq[Path], mainClass: Option[String] = None): Option[Path] = {
+    rm(outputPath)
+    if(inputPaths.isEmpty) None
+    else {
+      mkdir(outputPath/up)
+
+      val jar = new JarOutputStream(
+        new FileOutputStream(outputPath.toIO),
+        createManifest(mainClass)
+      )
+
+      try{
+        assert(inputPaths.forall(exists(_)))
+        for{
+          p <- inputPaths
+          (file, mapping) <-
+          if (p.isFile) Iterator(p -> empty/p.last)
+          else ls.rec(p).filter(_.isFile).map(sub => sub -> sub.relativeTo(p))
+        } {
+          val entry = new JarEntry(mapping.toString)
+          entry.setTime(file.mtime.toMillis)
+          jar.putNextEntry(entry)
+          jar.write(read.bytes(file))
+          jar.closeEntry()
+        }
+      } finally {
+        jar.close()
+      }
+
+      Some(outputPath)
+    }
+  }
+  case class jarUp(roots: Target[PathRef]*) extends Target[PathRef]{
+
+    val inputs = roots
+    def evaluate(args: Args): PathRef = {
+      createJar(args.dest, args.args.map(_.asInstanceOf[PathRef].path))
+      PathRef(args.dest)
+    }
+  }
+}
diff --git a/core/src/test/scala/forge/JavaCompileJarTests.scala b/core/src/test/scala/forge/JavaCompileJarTests.scala
index 33383a95..6ce02149 100644
--- a/core/src/test/scala/forge/JavaCompileJarTests.scala
+++ b/core/src/test/scala/forge/JavaCompileJarTests.scala
@@ -1,13 +1,12 @@
 package forge
 
-import java.io.FileOutputStream
-import java.util.jar.{JarEntry, JarOutputStream}
 
 import ammonite.ops._
 import forge.define.Target
 import forge.discover.Discovered
 import forge.eval.{Evaluator, PathRef}
-import forge.util.{Args, OSet}
+import forge.modules.Jvm.jarUp
+import forge.util.OSet
 import utest._
 
 object JavaCompileJarTests extends TestSuite{
@@ -22,56 +21,6 @@ object JavaCompileJarTests extends TestSuite{
   }
 
 
-  private def createManifest(mainClass: Option[String]) = {
-    val m = new java.util.jar.Manifest()
-    m.getMainAttributes.put(java.util.jar.Attributes.Name.MANIFEST_VERSION, "1.0")
-    m.getMainAttributes.putValue( "Created-By", "Scala Forge" )
-    mainClass.foreach(
-      m.getMainAttributes.put(java.util.jar.Attributes.Name.MAIN_CLASS, _)
-    )
-    m
-  }
-
-  def createJar(outputPath: Path, inputPaths: Seq[Path], mainClass: Option[String] = None ): Option[Path] = {
-    rm(outputPath)
-    if(inputPaths.isEmpty) None
-    else {
-      mkdir(outputPath/up)
-
-      val jar = new JarOutputStream(
-        new FileOutputStream(outputPath.toIO),
-        createManifest(mainClass)
-      )
-
-      try{
-        assert(inputPaths.forall(exists(_)))
-        for{
-          p <- inputPaths
-          (file, mapping) <-
-            if (p.isFile) Iterator(p -> empty/p.last)
-            else ls.rec(p).filter(_.isFile).map(sub => sub -> sub.relativeTo(p))
-        } {
-          val entry = new JarEntry(mapping.toString)
-          entry.setTime(file.mtime.toMillis)
-          jar.putNextEntry(entry)
-          jar.write(read.bytes(file))
-          jar.closeEntry
-        }
-      } finally {
-        jar.close
-      }
-
-      Some(outputPath)
-    }
-  }
-  case class jarUp(roots: Target[PathRef]*) extends Target[PathRef]{
-
-    val inputs = roots
-    def evaluate(args: Args): PathRef = {
-      createJar(args.dest, args.args.map(_.asInstanceOf[PathRef].path))
-      PathRef(args.dest)
-    }
-  }
 
   val tests = Tests{
     'javac {