Merge pull request #16 from ysb33r/master

JRubyExec Task

Author: R. Tyler Croy

README.md

@@ -192,3 +192,52 @@ dependencies {
     gems group: 'com.lookout', name: 'custom-gem', version: '1.0.+'
 }
 ```
+
+## JRubyExec - Task for Executing a Ruby Script 
+
+In a similar vein to ```JavaExec``` and ```RhinoShellExec```, the ```JRubyExec``` allows for Ruby scripts to be executed
+in a Gradle script using JRuby.
+
+```groovy
+import com.lookout.jruby.JRubyExec
+
+dependencies {
+    jrubyExec 'rubygems:credit_card_validator:1.2.0'
+}
+
+task runMyScript( type: JRubyExec ) {
+    script 'scripts/runme.rb'
+    scriptArgs '-x', '-y'
+}
+```
+
+Common methods for ```JRubyExec``` for executing a script
+
+* ```script``` - ```Object``` (Usually File or String). Path to the script.
+* ```scriptArgs``` - ```List```.  List of arguments to pass to script.
+* ```workingDir``` - ```Object``` (Usually File or String).  Working directory for script.
+* ```environment``` - ```Map```.  Environment to be set. Do not set ```GEM_HOME``` or ```GEM_PATH``` with this method.
+* ```standardInput``` - ```InputStream```.  Set an input stream to be read by the script.
+* ```standardOutput``` - ```OutputStream```.  Capture the output of the script.
+* ```errorOutput``` - ```OutputStream```.  Capture the error output of the script.
+* ```ignoreExitValue``` - ```Boolean```.  Ignore the JVm exit value. Exit values are only effective if the exit value of the Ruby script is correctly communicated back to the JVM.
+* ```configuration``` - ```String```.  Configuration to copy gems from. (*) 
+* ```classpath``` - ```List```.  Additional Jars/Directories to place on classpath.
+* ```jrubyVersion``` - ```String```.  JRuby version to use if not the same as ```project.jruby.execVersion```. 
+
+(*) If ```jRubyVersion``` has not been set, ```jrubyExec``` will used as
+configuration. However, if ```jRubyVersion``` has been set, no gems will be used unless an explicit configuration has been provided
+
+Additional ```JRubyExec``` methods for controlling the JVM instance
+
+* ```jvmArgs``` - ```List```. See [jvmArgs](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:jvmArgs)
+* ```allJvmArgs``` - ```List```. See [allJvmArgs](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:allJvmArgs)
+* ```systemProperties``` - ```Map```. See [systemProperties](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:systemProperties)
+* ```bootstrapClassPath``` - ```FileCollection``` or ```List```. See [bootstrapClassPath](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:bootstrapClasspath)
+* ```minHeapSize``` - ```String```. See [minHeapSize](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html)
+* ```maxHeapSize``` - ```String```. See [maxHeapSize](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:maxHeapSize)
+* ```defaultCharacterEncoding``` - ```String```. See [defaultCharacterEncoding](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html)
+* ```enableAssertions``` - ```Boolean```. See [enableAssertions](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.JavaExec.html#org.gradle.api.tasks.JavaExec:enableAssertions)
+* ```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)

build.gradle

@@ -25,7 +25,11 @@ dependencies {
     compile gradleApi()
     compile localGroovy()
 
+
     testCompile 'junit:junit:4.+'
+    testCompile ("org.spockframework:spock-core:0.7-groovy-${gradle.gradleVersion.startsWith('1.')?'1.8':'2.0'}") {
+        exclude module : 'groovy-all'
+    }
 }
 
 test {
@@ -35,7 +39,12 @@ test {
     }
 
     systemProperties TESTROOT : new File(buildDir,'tmp/test/unittests').absolutePath
+    systemProperties TEST_SCRIPT_DIR : new File(projectDir,'src/test/resources/scripts').absolutePath
+    systemProperties 'logback.configurationFile' : new File(projectDir,'src/test/resources/logback-test.xml').absolutePath
 
+    if(gradle.startParameter.isOffline()) {
+        systemProperties 'TESTS_ARE_OFFLINE' : '1'
+    }
 }
 
 

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

@@ -0,0 +1,67 @@
+package com.lookout.jruby
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.DuplicateFileCopyingException
+
+/** A collection of utilities to manipulate GEMs
+ *
+ * @author R Tyler Croy
+ * @author Schalk W. Cronjé
+ */
+class GemUtils {
+    static Boolean extractGem(Project p, File gem) {
+        def gemname = gemFullNameFromFile(gem.getName())
+        File extract_dir = new File("./vendor/gems/$gemname")
+
+        if (extract_dir.exists()) {
+            return
+        }
+
+        p.exec {
+            executable "gem"
+            args 'install', gem, '--install-dir=./vendor', '--no-ri', '--no-rdoc'
+        }
+    }
+
+    /** Extracts a gem to a folder
+     *
+     * @param project Project instance
+     * @param jRubyClasspath Where to find the jruby-complete jar (FileCollection, File or Configuration)
+     * @param gem Gem file to extract
+     * @param destDir Directory to extract to
+     * @param overwrite Allow overwrite of an existing gem folder
+     * @return
+     */
+    static void extractGem(Project project, def jRubyClasspath, File gem,File destDir,boolean overwrite) {
+        def gemname = gemFullNameFromFile(gem.name)
+        File extract_dir = new File(destDir,gemname)
+
+        if (extract_dir.exists()) {
+            if(overwrite) {
+                project.delete extract_dir
+            } else {
+                throw new DuplicateFileCopyingException("Gem ${gem.name} already exists")
+            }
+        }
+
+        if( jRubyClasspath instanceof Configuration) {
+            Set<File> cp = jRubyClasspath.files
+            jRubyClasspath = cp.find { it.name.startsWith('jruby-complete-') }
+        }
+
+        project.javaexec {
+            setEnvironment [:]
+            main 'org.jruby.Main'
+            classpath jRubyClasspath
+            args '-S', 'gem', 'install', gem, "--install-dir=${destDir.absolutePath}", '-N'
+        }
+    }
+
+    /** 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)
+     */
+    static String gemFullNameFromFile(String filename) {
+        return filename.replaceAll(~".gem", "")
+    }
+}

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

@@ -0,0 +1,215 @@
+package com.lookout.jruby
+
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.TaskInstantiationException
+import org.gradle.internal.FileUtils
+import org.gradle.process.JavaExecSpec
+import org.gradle.util.CollectionUtils
+
+/** Runs a ruby script using JRuby
+ *
+ * @author Schalk W. Cronjé
+ */
+class JRubyExec extends JavaExec {
+
+    static final String JRUBYEXEC_CONFIG = 'jrubyExec'
+
+    static void updateJRubyDependencies(Project proj) {
+        proj.dependencies {
+            jrubyExec "org.jruby:jruby-complete:${proj.jruby.execVersion}"
+        }
+
+        proj.tasks.withType(JRubyExec) { t ->
+            if(t.jrubyConfigurationName != proj.configurations.jrubyExec) {
+                proj.dependencies.add(t.jrubyConfigurationName,"org.jruby:jruby-complete:${t.jrubyVersion}")
+            }
+        }
+    }
+
+    /** Script to execute.
+     *
+     */
+    @InputFile
+    File script
+
+    /** Configuration to copy gems from. If {@code jRubyVersion} has not been set, {@code jRubyExec} will used as
+     * configuration. However, if {@code jRubyVersion} has been set, not gems will be used unless an explicit
+     * configuration has been provided
+     *
+     */
+    @Optional
+    @Input
+    String configuration
+
+    @Input
+    String jrubyVersion
+
+    JRubyExec() {
+        super()
+        super.setMain 'org.jruby.Main'
+
+        try {
+            project.configurations.getByName(JRUBYEXEC_CONFIG)
+        } catch(UnknownConfigurationException ) {
+            throw new TaskInstantiationException('Cannot instantiate a JRubyExec instance before jruby plugin has been loaded')
+        }
+
+        jrubyVersion = project.jruby.execVersion
+        jrubyConfigurationName = JRUBYEXEC_CONFIG
+    }
+
+    /** Sets the scriptname
+     *
+     * @param fName Path to script
+     */
+    void setScript(Object fName) {
+        switch (fName) {
+            case File:
+                script=fName
+                break
+            case String:
+                script=new File(fName)
+                break
+            default:
+                script=new File(fName.toString())
+        }
+    }
+
+    /** Returns a list of script arguments
+     */
+    List<String> scriptArgs() {CollectionUtils.stringize(this.scriptArgs)}
+
+    /** Set arguments for script
+     *
+     * @param args
+     */
+    void scriptArgs(Object... args) {
+        this.scriptArgs.addAll(args as List)
+    }
+
+    /** Returns a list of jruby arguments
+     */
+    List<String> jrubyArgs()  {CollectionUtils.stringize(this.jrubyArgs)}
+
+    /** Set arguments for jruby
+     *
+     * @param args
+     */
+    void jrubyArgs(Object... args) {
+        this.jrubyArgs.addAll(args as List)
+    }
+
+    /** Setting the {@code jruby-complete} version allows for tasks to be run using different versions of JRuby.
+     * This is useful for comparing the results of different version or running with a gem that is only
+     * compatible with a specific version or when running a script with a different version that what will
+     * be packaged.
+     *
+     * @param version String in the form '1.7.13'
+     */
+    void setJrubyVersion(final String version) {
+        if(version == project.jruby.execVersion) {
+            jrubyConfigurationName = JRUBYEXEC_CONFIG
+        } else {
+            final String cfgName= 'jrubyExec$$' + name
+            project.configurations.maybeCreate(cfgName)
+            jrubyConfigurationName = cfgName
+        }
+        jrubyVersion = version
+    }
+
+    @Override
+    void exec() {
+        if(configuration == null && jrubyConfigurationName == JRUBYEXEC_CONFIG) {
+            configuration = JRUBYEXEC_CONFIG
+        }
+
+        def jrubyCompletePath = project.configurations.getByName(jrubyConfigurationName)
+        File gemDir = tmpGemDir()
+        environment 'GEM_HOME' : gemDir
+
+        if(configuration != null) {
+            project.configurations.getByName(jrubyConfigurationName)
+            project.with {
+                mkdir gemDir
+                configurations.getByName(configuration).files.findAll { File f ->
+                    f.name.endsWith('.gem')
+                }.each { File f ->
+                    GemUtils.extractGem(project,jrubyCompletePath,f,gemDir,true)
+                }
+            }
+        }
+
+        super.classpath project.configurations.getByName(jrubyConfigurationName).files
+        super.setArgs(getArgs())
+        super.exec()
+    }
+
+    /** getArgs gets overridden in order to add JRuby options, script name and script argumens in the correct order
+     */
+    @Override
+    List<String> getArgs() {
+        def cmdArgs = []
+        cmdArgs.addAll(jrubyArgs)
+        cmdArgs.add(script.absolutePath)
+        cmdArgs.addAll(scriptArgs)
+        cmdArgs as List<String>
+    }
+
+    @Override
+    JavaExec setMain(final String mainClassName) {
+        if(mainClassName == 'org.jruby.Main') {
+            super.setMain(mainClassName)
+        } else {
+            throw notAllowed("Setting main class for jruby to ${mainClassName} is not a valid operation")
+        }
+    }
+
+    @Override
+    JavaExec setArgs(Iterable<?> applicationArgs) {
+        throw notAllowed('Use jvmArgs / scriptArgs instead')
+    }
+
+    @Override
+    JavaExec args(Object... args) {
+        throw notAllowed('Use jvmArgs / scriptArgs instead')
+    }
+
+    @Override
+    JavaExecSpec args(Iterable<?> args) {
+        throw notAllowed('Use jvmArgs / scriptArgs instead')
+    }
+
+    /** Returns the {@code Configuration} object this task is tied to
+     */
+    String getJrubyConfigurationName() {
+        return this.jrubyConfigurationName
+    }
+
+    private static UnsupportedOperationException notAllowed(final String msg) {
+        return new UnsupportedOperationException (msg)
+    }
+
+    private File tmpGemDir() {
+        String ext = FileUtils.toSafeFileName(jrubyConfigurationName)
+        if(configuration) {
+            ext= "${ext}-${FileUtils.toSafeFileName(configuration)}"
+        }
+        new File( project.buildDir, "tmp/${ext}").absoluteFile
+    }
+
+    private String jrubyConfigurationName
+    private List<Object>  jrubyArgs = []
+    private List<Object>  scriptArgs = []
+
+}
+
+
+