Incubating support for executable Ruby-based JARs

Author: ysb33r

README.md

@@ -6,7 +6,7 @@ jruby-gradle-jar-plugin
 Plugin for creating JRuby-based java archives
 
 
-## Compatilibity
+## Compatibility
 
 This plugin requires Gradle 2.0 or better.
 
@@ -48,14 +48,8 @@ jar {
     // Can be called more than once for additional directories
     gemDir '/path/to/my/gemDir'
     
-    // Make the JAR executable and use the default main class
-    defaultMainClass()
-    
-    // Make the JAR executable by supplying your own main class
-    mainClass 'my.own.main.'
-    
-    // Equivalent to calling defaultGems() and defaultMainClass()
-    defaults 'gem, 'mainClass'
+    // Equivalent to calling defaultGems()
+    defaults 'gem'
         
   }
   
@@ -72,9 +66,36 @@ task myJar (type :Jar) {
 
 ```
 
+## Executable JARs
+
+Please note that executable JARs are still an incubating feature. At this point appropriate libs will be copied
+to the `META-INF/lib` directory, but a working `init.rb` is not available. It is still the responsibility of the
+the user to craft an appropriate `init.rb` and copy it to `META-INF` via the provided the [metaInf {}](http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.bundling.Jar.html) closure.
+ 
+ ```groovy
+ jar {
+   jruby {
+   
+     // Make the JAR executable and use the default main class
+     defaultMainClass()
+     
+     // Make the JAR executable by supplying your own main class
+     mainClass 'my.own.main.'
+     
+     // Equivalent to calling defaultMainClass()
+     defaults 'mainClass'
+     
+     // Adds dependencies from this configuration into `META-INF/lib`
+     // If none are specified, the plugin will default to 'jrubyJar','compile' & 'runtime'
+     configurations 'myConfig'    
+   }   
+ }
+```
+
 Using the default main class method `defaultMainClass()` will include class files from 
 [warbler-bootstrap](https://github.com/jruby-gradle/warbler-bootstrap) 
 
+
 ## Controlling the version of warbler-bootstrap
 
 By default the version is set to `1.+` meaning anything version 1.0 or beyond. If your project wants to lock

build.gradle

@@ -8,7 +8,7 @@ buildscript {
 }
 
 group = 'com.github.jruby-gradle'
-version = '0.1.0'
+version = '0.1.1'
 
 if (System.env.RELEASE != '1') {
     version = "${version}-SNAPSHOT"
@@ -28,12 +28,22 @@ configurations {
 dependencies {
     compile gradleApi()
     compile localGroovy()
-    compile 'com.github.jruby-gradle:jruby-gradle-plugin:0.1.2'
+    compile 'com.github.jruby-gradle:jruby-gradle-plugin:0.1.2+'
 
     testCompile ("org.spockframework:spock-core:0.7-groovy-${gradle.gradleVersion.startsWith('1.')?'1.8':'2.0'}") {
         exclude module : 'groovy-all'
     }
-    testWarbler group: 'com.github.jruby-gradle', name: 'warbler-bootstrap', version: '0.1.+'
+
+    // For the testWarbler tests I am locking the versions, instead of a open version, as it makes
+    // unit testing easier, This does not affect the final artifact.
+    // If you change values here, you need to update JRubyJarPluginSpec as well.
+    testWarbler 'com.github.jruby-gradle:warbler-bootstrap:0.1.0'
+    testWarbler ('org.jruby:jruby-complete:1.7.15') {
+        transitive = false
+    }
+    testWarbler ("org.spockframework:spock-core:0.7-groovy-2.0") {
+        transitive = false
+    }
 
 }
 

src/main/groovy/com/github/jrubygradle/jar/JRubyJarConfigurator.groovy

@@ -1,7 +1,11 @@
 package com.github.jrubygradle.jar
 
 import groovy.transform.PackageScope
+import org.gradle.api.Incubating
 import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.bundling.Jar
 import com.github.jrubygradle.GemUtils
 
@@ -25,10 +29,10 @@ class JRubyJarConfigurator {
     @PackageScope
     static void afterEvaluateAction( Project project ) {
         project.tasks.withType(Jar) { t ->
-            if(t.manifest.attributes.containsKey('Main-Class')) {
-                if(t.manifest.attributes.'Main-Class' == JRubyJarConfigurator.DEFAULT_MAIN_CLASS) {
+            if (t.manifest.attributes.containsKey('Main-Class')) {
+                if (t.manifest.attributes.'Main-Class' == JRubyJarConfigurator.DEFAULT_MAIN_CLASS) {
                     t.with {
-                        from({project.configurations.jrubyEmbeds.collect {project.zipTree(it)}}) {
+                        from({ project.configurations.jrubyEmbeds.collect { project.zipTree(it) } }) {
                             include '**'
                             exclude '**/WarMain.class'
                         }
@@ -57,11 +61,17 @@ class JRubyJarConfigurator {
      *
      * @param className Name of main class
      */
+    @Incubating
     void mainClass(final String className) {
+        maybeAddExtraManifest()
         archive.with {
             manifest {
                 attributes 'Main-Class': className
             }
+            metaInf {
+                from { this.getDependencies() }
+                into 'lib'
+            }
         }
     }
 
@@ -90,14 +100,73 @@ class JRubyJarConfigurator {
     /** Makes the executable by adding a default main class
      *
      */
+    @Incubating
     void defaultMainClass() {
         mainClass(DEFAULT_MAIN_CLASS)
     }
 
+    /** Adds a configuration to the list of dependencies that will be packed when creating an executable jar
+     * This method is ignored if {@code mainClass} is not set.
+     *
+     * @param name Name of configuration
+     */
+    @Incubating
+    void configuration(String name) {
+        this.configurations.add(archive.project.configurations.getByName(name))
+    }
+
+    /** Adds a configuration to the list of dependencies that will be packed when creating an executable jar
+     * This method is ignored if {@code mainClass} is not set.
+     *
+     * @param name Configuration
+     */
+    @Incubating
+    void configuration(Configuration config) {
+        this.configurations.add(config)
+    }
 
     private JRubyJarConfigurator(Jar a) {
         archive = a
     }
 
+    private Set<File> getDependencies() {
+        Set<File> tmp = []
+        if(configurations == null) {
+            archive.project.configurations.each { Configuration cfg ->
+                if( ['jrubyJar','compile','runtime'].contains(cfg.name) ) {
+                    tmp.addAll(cfg.files)
+                }
+            }
+        } else {
+            configurations.each {
+                tmp.addAll(it.files)
+            }
+        }
+        return tmp
+    }
+
+    private void maybeAddExtraManifest() {
+        if(extraManifest == null) {
+            extraManifest = new File(archive.project.buildDir,extraManifestName)
+            String taskName = "${archive.name}ExtraManifest"
+            Task task = archive.project.tasks.create(taskName)
+            task << {
+                String libs = task.inputs.files.collect { File f -> "lib/${f.name}" }.join(' ')
+                extraManifest.parentFile.mkdirs()
+                extraManifest.text = "Class-Path: ${libs}\n"
+            }
+            task.outputs.file(extraManifest)
+            task.inputs.files({this.getDependencies()})
+            archive.dependsOn task
+            archive.manifest.from({task.outputs.files.singleFile})
+        }
+    }
+
+    private String getExtraManifestName() {
+        "tmp/${archive.name}-extraManifest.mf"
+    }
+
     private Jar archive
+    private List<Configuration> configurations
+    private File extraManifest
 }

src/main/groovy/com/github/jrubygradle/jar/JRubyJarPlugin.groovy

@@ -15,6 +15,7 @@ class JRubyJarPlugin implements Plugin<Project> {
 
         project.apply plugin : 'com.github.jruby-gradle.base'
         project.configurations.maybeCreate('jrubyEmbeds')
+        project.configurations.maybeCreate('jrubyJar')
 
         // In order to update the testing cycle we need to tell unit tests where to
         // find GEMs. We are assuming that if someone includes this plugin, that they
@@ -58,6 +59,12 @@ class JRubyJarPlugin implements Plugin<Project> {
         project.afterEvaluate {
             WarblerBootstrap.addDependency(project)
             JRubyJarConfigurator.afterEvaluateAction(project)
+
+            project.dependencies {
+                jrubyJar group: 'org.jruby', name: 'jruby-complete', version: project.jruby.defaultVersion
+            }
+
+
         }
     }
 

src/test/groovy/com/github/jrubygradle/jar/JRubyJarPluginSpec.groovy

@@ -42,6 +42,15 @@ class JRubyJarPluginSpec extends Specification {
         jarTask = project.task('JarJar', type: Jar)
     }
 
+    def "Checking configurations exist"() {
+        given:
+            def cfg = project.configurations
+
+        expect:
+            cfg.getByName('jrubyEmbeds')
+            cfg.getByName('jrubyJar')
+    }
+
     def "Adding a fake file as if it is a gem layout"() {
         when: 'We configure the jar task with jruby data'
             new File(TESTROOT,'fake.txt').text = 'fake.content'
@@ -124,17 +133,20 @@ class JRubyJarPluginSpec extends Specification {
 
     def "Building a Jar"() {
         given: "A local repository"
+            final String jrubyTestVersion = '1.7.15'
             File expectedDir= new File(TESTROOT,'libs/')
             expectedDir.mkdirs()
             File expectedJar= new File(expectedDir,'test.jar')
             project.jruby.gemInstallDir = new File(TESTROOT,'fakeGemDir').absolutePath
+
             new File(project.jruby.gemInstallDir,'gems').mkdirs()
             new File(project.jruby.gemInstallDir,'gems/fake.txt').text = 'fake.content'
 
             project.with {
                 jruby {
                     defaultRepositories = false
                     warblerBootstrapVersion = '0.1.0'
+                    defaultVersion = jrubyTestVersion
                 }
                 repositories {
                     ivy {
@@ -144,6 +156,9 @@ class JRubyJarPluginSpec extends Specification {
                         }
                     }
                 }
+                dependencies {
+                    jrubyJar 'org.spockframework:spock-core:0.7-groovy-2.0'
+                }
             }
 
         when: "I set the default main class"
@@ -158,11 +173,21 @@ class JRubyJarPluginSpec extends Specification {
             project.evaluate()
 
         and: "I actually build the JAR"
+            project.tasks.getByName("${jarTask.name}ExtraManifest").execute()
+
             jarTask.copy()
+            def builtJar = fileNames(project.zipTree(expectedJar))
 
         then: "I expect to see the JarMain.class embedded in the JAR"
             expectedJar.exists()
-            fileNames(project.zipTree(expectedJar)).contains('com/lookout/jruby/JarMain.class')
-            !fileNames(project.zipTree(expectedJar)).contains('com/lookout/jruby/WarMain.class')
+            builtJar.contains('com/lookout/jruby/JarMain.class')
+            !builtJar.contains('com/lookout/jruby/WarMain.class')
+
+        and: "I expect to see jruby-complete packed in libs"
+            builtJar.contains("META-INF/lib/jruby-complete-${jrubyTestVersion}.jar".toString())
+
+        and: "I expect to see manifest to include it"
+            jarTask.manifest.effectiveManifest.attributes['Class-Path']?.contains("lib/jruby-complete-${jrubyTestVersion}.jar".toString())
+
     }
 }