Merge pull request #8 from ysb33r/oneJar

One jar with shadow

Author: R. Tyler Croy

CHANGELOG.md

@@ -0,0 +1,10 @@
+= Changelog
+
+== Roadmap (0.1.1)
+
+* [Issue #2](https://github.com/jruby-gradle/jruby-gradle-jar-plugin/issues/2) - Executable JARs for Ruby GEMs.
+
+== Version 0.1.0
+
+* Initial release
+* [Issue #1](https://github.com/jruby-gradle/jruby-gradle-jar-plugin/issues/1) - Extension to build JARs containing GEMs.

README.md

@@ -31,6 +31,7 @@ apply plugin: 'com.github.jrubygradle.jar'
 
 This loads the following plugins if they are not already loaded:
 + `com.github.jrubygradle.base`
++ `java`
 
 ## Using the plugin
 
@@ -63,47 +64,71 @@ task myJar (type :Jar) {
 
   // All other JAR methods and properties are still valid
 }
+```
+
+## Controlling the Ruby entry point script
+
+If nothing is specified, then the bootstrap will look for a Ruby script `META-INF/init.rb`. 
+It is also possible to set the entry script. This must be specified relative to the root of the created JAR.
 
+```groovy
+jrubyJavaBootstrap {
+    jruby {
+        initScript = 'bin/asciidoctor'
+    }
+}
 ```
 
+It is the user's responsibility to ensure that entry point script is created and added to the JAR, be it `META-INF/init.rb`
+or another specified script.
+
+
 ## 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 {
+**Please note that executable JARs are still an incubating feature**.
+
+Executable JARs are indirectly supported via the [Gradle Shadow Jar plugin](http://plugins.gradle.org/plugin/com.github.johnrengelman.shadow).
+
+
+### Adding Shadow JAR
+```groovy
+buildscript {
+  repositories {
+    jcenter()
+  }
+  
+    dependencies {
+      classpath 'com.github.jengelman.gradle.plugins:shadow:1.1.1'
+      classpath group: 'com.github.jrubygradle:jruby-gradle-jar-plugin:0.1.1'
+    }  
+}
+
+apply plugin: 'com.github.jrubygradle.jar'
+apply plugin: 'com.github.johnrengelman.shadow'
+
+```
+
+### Configuring Shadow JAR
+
+Configuration is exactly the same as for a normal JAR class.
+
+```groovy
+shadowJar {
    jruby {
    
-     // Make the JAR executable and use the default main class
+     // Use the default bootstrap class
      defaultMainClass()
      
      // Make the JAR executable by supplying your own main class
-     mainClass 'my.own.main.'
+     mainClass 'my.own.main'
      
      // Equivalent to calling defaultMainClass()
-     defaults 'mainClass'
+     defaults 'gems', '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
-down the specific version, then it can be set via
-
-```groovy
-jruby {
-  warblerBootstrapversion = '1.0.0'
-}
-```
-
+See [Shadow JAR README](https://github.com/johnrengelman/shadow/blob/master/README.md) for configuration specifics.
+In a similar fashion to the `jar` task, the `shadowJar` task will make use of the `jrubyJavaBootstrap` task to
+create and compile a basic bootstrap class.

build.gradle

@@ -36,6 +36,8 @@ dependencies {
         exclude module : 'groovy-all'
     }
 
+    testRuntime 'com.github.jengelman.gradle.plugins:shadow: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.

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

@@ -0,0 +1,66 @@
+package com.github.jrubygradle.jar
+
+import groovy.transform.TupleConstructor
+import org.gradle.api.GradleException
+import org.gradle.api.Task
+
+/**
+ * @author Schalk W. Cronjé.
+ *
+ * @since 0.1.1
+ */
+@TupleConstructor
+class BootstrapClassExtension {
+
+    static final String BOOTSTRAP_TEMPLATE_PATH = 'META-INF/gradle-plugins/bootstrap.java.template'
+
+    /** The task this extension instance is attached to.
+     *
+     * @since 0.1.1
+     *
+     */
+    Task task
+
+    /** The location of the Ruby initialisation/bootstrap script.
+     * The default bootstrap class will look for a file in this relative location.
+     * It is the user's responsibility that this script is added to the Jar.
+     *
+     * @since 0.1.1
+     */
+    String initScript = 'META-INF/init.rb'
+
+    /** This is the JRuby language compatibility mode.
+     * @since 0.1.1
+     */
+    String compatMode = '1.9'
+
+    Object source
+
+    Object getSource() {
+        if(null == source) {
+            setSourceFromResource()
+        }
+        this.source
+    }
+
+    void setSourceFromResource() {
+        Enumeration<URL> enumResources
+        enumResources = this.class.classLoader.getResources( BOOTSTRAP_TEMPLATE_PATH)
+        if(!enumResources.hasMoreElements()) {
+            throw new GradleException ("Cannot find ${BOOTSTRAP_TEMPLATE_PATH} in classpath")
+        } else {
+            URI uri = enumResources.nextElement().toURI()
+            String location = uri.getSchemeSpecificPart().replace('!/'+BOOTSTRAP_TEMPLATE_PATH,'')
+            if(uri.scheme.startsWith('jar')) {
+                location=location.replace('jar:file:','')
+                source= task.project.zipTree(location)
+            } else if(uri.scheme.startsWith('file')) {
+                source= location.replace('file:','')
+            } else {
+                throw new GradleException("Cannot extract ${uri}")
+            }
+        }
+
+   }
+
+}

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

@@ -3,9 +3,6 @@ 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
 
@@ -15,7 +12,8 @@ import com.github.jrubygradle.GemUtils
  */
 class JRubyJarConfigurator {
 
-    static final String DEFAULT_MAIN_CLASS = 'com.lookout.jruby.JarMain'
+    static final String DEFAULT_BOOTSTRAP_CLASS = 'com.github.jrubygradle.jar.bootstrap.JarMain'
+    static final String SHADOW_JAR_TASK_CLASS = 'com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar'
 
     // This is used by JRubyJarPlugin to configure Jar classes
     @PackageScope
@@ -29,15 +27,8 @@ 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) {
-                    t.with {
-                        from({ project.configurations.jrubyEmbeds.collect { project.zipTree(it) } }) {
-                            include '**'
-                            exclude '**/WarMain.class'
-                        }
-                    }
-                }
+            if(t.class.superclass.name == SHADOW_JAR_TASK_CLASS && t.name=='shadowJar') {
+                t.configurations.add(project.configurations.getByName('jrubyJar'))
             }
         }
     }
@@ -63,15 +54,10 @@ class JRubyJarConfigurator {
      */
     @Incubating
     void mainClass(final String className) {
-        maybeAddExtraManifest()
         archive.with {
             manifest {
                 attributes 'Main-Class': className
             }
-            metaInf {
-                from { this.getDependencies() }
-                into 'lib'
-            }
         }
     }
 
@@ -102,74 +88,20 @@ class JRubyJarConfigurator {
      */
     @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.configuration(archive.project.configurations.getByName(name))
+        mainClass(DEFAULT_BOOTSTRAP_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 Configuration
-     */
-    @Incubating
-    void configuration(Configuration config) {
-        if(this.configurations==null) {
-            this.configurations = []
-        }
-        this.configurations.add(config)
+    boolean isShadowJar() {
+        shadowJar
     }
 
     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})
+        if (a.class.name == SHADOW_JAR_TASK_CLASS || a.class.superclass.name == SHADOW_JAR_TASK_CLASS) {
+            shadowJar = true
         }
     }
 
-    private String getExtraManifestName() {
-        "tmp/${archive.name}-extraManifest.mf"
-    }
-
     private Jar archive
-    private List<Configuration> configurations
-    private File extraManifest
+    private boolean shadowJar = false
 }