Merge pull request #27 from ysb33r/master

Added project.jrubyexec support

Author: R. Tyler Croy

.gitignore

@@ -2,3 +2,5 @@ build/
 *.sw*
 .ruby-*
 .gradle/
+*.iml
+.idea

README.md

@@ -241,3 +241,27 @@ Additional ```JRubyExec``` methods for controlling the JVM instance
 * ```debug``` - ```Boolean```. See [debug](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:debug)
 * ```copyTo``` - ```JavaForkOptions```. See [copyTo](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html)
 * ```executable``` - ```Object``` (Usually ```File``` or ```String```). See [executable](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:executable)
+
+## jrubyexec extension
+
+Similar to ```javaexec``` and ```exec``` it is possible to add the execution of a jruby script within another task
+
+```groovy
+task needSomeRubyLove {
+  jrubyexec {
+    script 'scripts/runme.rb'
+    scriptArgs '-x', '-y'  
+  }
+}
+```
+
+The behaviour of ```project.jrubyexec``` is slightly different to that of ```JRubyExec```.
+
+* The version of ```jruby-complete``` is strictly tied to to ```jruby.defaultVersion```. Therefore trying to set ```jrubyVersion```
+in the ```jrubyexec``` closure will cause a failure
+* GEMs and additional JARs are only taken from the ```jrubyExec``` configuration. 
+* It is not possible to supply a ```configuration``` parameter to the ```jrubyexec``` closure.
+* GEMs will be installed to ```jruby.gemInstallDir```. Existing gems will not be overwritten.
+
+As with ```JRubyExec```, ```args```, ```setArgs``` and ```main``` are illegal within the ```jrubyexec``` closure.
+All other methods should work.

src/integTest/groovy/com/lookout/jruby/JRubyExecExtensionIntegrationSpec.groovy

@@ -0,0 +1,94 @@
+package com.lookout.jruby
+
+import org.gradle.testfixtures.ProjectBuilder
+import spock.lang.Ignore
+import spock.lang.IgnoreIf
+import spock.lang.Specification
+
+import static org.gradle.api.logging.LogLevel.LIFECYCLE
+
+/**
+ * @author Schalk W. Cronjé
+ */
+class JRubyExecExtensionIntegrationSpec extends Specification {
+    static final boolean TESTS_ARE_OFFLINE = System.getProperty('TESTS_ARE_OFFLINE') != null
+    static final File TEST_SCRIPT_DIR = new File( System.getProperty('TESTS_SCRIPT_DIR') ?: 'src/integTest/resources/scripts')
+    static final File TESTROOT = new File(System.getProperty('TESTROOT') ?: 'build/tmp/test/integration-tests')
+
+    def project
+
+    void setup() {
+        project = ProjectBuilder.builder().build()
+        project.with {
+            buildDir = TESTROOT
+            logging.level = LIFECYCLE
+            apply plugin: 'com.lookout.jruby'
+            evaluate()
+        }
+    }
+
+
+    @IgnoreIf({TESTS_ARE_OFFLINE})
+    def "Run a script with minimum parameters"() {
+        given:
+            def output = new ByteArrayOutputStream()
+
+        when:
+            project.jrubyexec {
+                script        "${TEST_SCRIPT_DIR}/helloWorld.rb"
+                standardOutput output
+            }
+
+        then:
+            output.toString() == "Hello, World\n"
+    }
+
+    @IgnoreIf({TESTS_ARE_OFFLINE})
+    def "Run a script containing a conditional"() {
+        given:
+            def output = new ByteArrayOutputStream()
+
+        when: "we have an 'if' clause"
+            project.jrubyexec {
+                script        "${TEST_SCRIPT_DIR}/helloName.rb"
+                if(input == 0) {
+                    scriptArgs 'Stan'
+                } else {
+                    scriptArgs 'man'
+                }
+                standardOutput output
+            }
+
+        then: "only the appropriate parameters should be passed"
+            output.toString() == expected
+
+        where:
+            input | expected
+            0     | "Hello, Stan\n"
+            1     | "Hello, man\n"
+
+    }
+
+    @IgnoreIf({TESTS_ARE_OFFLINE})
+    def "Running a script that requires a gem, a separate jRuby and a separate configuration"() {
+        given:
+            def output = new ByteArrayOutputStream()
+            project.with {
+                dependencies {
+                    jrubyExec 'rubygems:credit_card_validator:1.1.0'
+                }
+                jrubyexec {
+                    script        "${TEST_SCRIPT_DIR}/requiresGem.rb"
+                    standardOutput output
+                    jrubyArgs '-T1'
+                }
+            }
+
+        when:
+            project.evaluate()
+
+        then:
+            output.toString() == "Not valid\n"
+    }
+
+}

src/integTest/resources/scripts/helloName.rb

@@ -0,0 +1 @@
+puts "Hello, " + ARGV[0]

src/main/groovy/com/lookout/jruby/GemUtils.groovy

@@ -10,6 +10,8 @@ import org.gradle.api.file.DuplicateFileCopyingException
  * @author Schalk W. Cronjé
  */
 class GemUtils {
+    enum OverwriteAction { FAIL, SKIP, OVERWRITE }
+
     static Boolean extractGem(Project p, File gem) {
         String gemName = gemFullNameFromFile(gem.getName())
         String installDir = p.jruby.gemInstallDir
@@ -38,15 +40,20 @@ class GemUtils {
                             def jRubyClasspath,
                             File gem,
                             File destDir,
-                            boolean overwrite) {
+                            GemUtils.OverwriteAction overwrite) {
         String gemName = gemFullNameFromFile(gem.name)
         File extractDir = new File(destDir, gemName)
 
         if (extractDir.exists()) {
-            if(overwrite) {
-                project.delete extractDir
-            } else {
-                throw new DuplicateFileCopyingException("Gem ${gem.name} already exists")
+
+            switch (overwrite) {
+                case GemUtils.OverwriteAction.SKIP:
+                    return
+                case GemUtils.OverwriteAction.OVERWRITE:
+                    project.delete extractDir
+                    break
+                case GemUtils.OverwriteAction.FAIL:
+                    throw new DuplicateFileCopyingException("Gem ${gem.name} already exists")
             }
         }
 
@@ -63,6 +70,15 @@ class GemUtils {
         }
     }
 
+    static void extractGems(Project project,def jRubyClasspath, Configuration gemConfig,File destDir,GemUtils.OverwriteAction action ) {
+        gemConfig.files.findAll { File f ->
+            f.name.endsWith('.gem')
+        }.each { File f ->
+            GemUtils.extractGem(project,jRubyClasspath,f,destDir,action)
+        }
+
+    }
+
     /** Take the given .gem filename (e.g. rake-10.3.2.gem) and just return the
      * gem "full name" (e.g. rake-10.3.2)
      */

src/main/groovy/com/lookout/jruby/JRubyExec.groovy

@@ -1,6 +1,6 @@
 package com.lookout.jruby
 
-
+import com.lookout.jruby.internal.JRubyExecUtils
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.file.FileCollection
@@ -143,12 +143,12 @@ class JRubyExec extends JavaExec {
                 configurations.getByName(configuration).files.findAll { File f ->
                     f.name.endsWith('.gem')
                 }.each { File f ->
-                    GemUtils.extractGem(project,jrubyCompletePath,f,gemDir,true)
+                    GemUtils.extractGem(project,jrubyCompletePath,f,gemDir,GemUtils.OverwriteAction.OVERWRITE)
                 }
             }
         }
 
-        super.classpath project.configurations.getByName(jrubyConfigurationName).files
+        super.classpath JRubyExecUtils.classpathFromConfiguration(project.configurations.getByName(jrubyConfigurationName))
         super.setArgs(getArgs())
         super.exec()
     }
@@ -200,8 +200,8 @@ class JRubyExec extends JavaExec {
 
     private File tmpGemDir() {
         String ext = FileUtils.toSafeFileName(jrubyConfigurationName)
-        if(configuration) {
-            ext= "${ext}-${FileUtils.toSafeFileName(configuration)}"
+        if(configuration && configuration!=jrubyConfigurationName) {
+            ext= ext + "-${FileUtils.toSafeFileName(configuration)}"
         }
         new File( project.buildDir, "tmp/${ext}").absoluteFile
     }

src/main/groovy/com/lookout/jruby/JRubyPlugin.groovy

@@ -1,5 +1,6 @@
 package com.lookout.jruby
 
+import com.lookout.jruby.internal.JRubyExecDelegate
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.tasks.Copy
@@ -33,6 +34,7 @@ class JRubyPlugin implements Plugin<Project> {
             gems
         }
         project.configurations.create(JRubyExec.JRUBYEXEC_CONFIG)
+        JRubyExecDelegate.addToProject(project)
 
         // In order for jrubyWar to work we'll need to pull in the warbler
         // bootstrap code from this artifact