Merge pull request #4 from ysb33r/master

jruby-gradle-jar-plugin is walking upright

Author: R. Tyler Croy

README.md

@@ -4,3 +4,85 @@ jruby-gradle-jar-plugin
 [![Build Status](https://buildhive.cloudbees.com/job/jruby-gradle/job/jruby-gradle-jar-plugin/badge/icon)](https://buildhive.cloudbees.com/job/jruby-gradle/job/jruby-gradle-jar-plugin/) [![Gitter chat](https://badges.gitter.im/jruby-gradle/jruby-gradle-plugin.png)](https://gitter.im/jruby-gradle/jruby-gradle-plugin)
 
 Plugin for creating JRuby-based java archives
+
+
+## Compatilibity
+
+This plugin requires Gradle 2.0 or better.
+
+## Bootstrap
+
+To add the plugin to your project
+```groovy
+buildscript {
+  repositories {
+    jcenter()
+  }
+  
+    dependencies {
+      classpath group: 'com.github.jrubygradle', name: 'jruby-gradle-jar-plugin', version: '0.1.1'
+    }  
+}
+
+apply plugin: 'com.github.jrubygradle.jar'
+```
+
+## Implicit loaded plugins
+
+This loads the following plugins if they are not already loaded:
++ `com.github.jrubygradle.base`
+
+## Using the plugin
+
+This plugin does not add any new tasks or extensions, extends the `Jar` task type with a `jruby` closure. If the `java` plugin
+is loaded, then the `jar` task can also be configured.
+
+```groovy
+jar {
+  jruby {
+  
+    // Use the default GEM installation directory
+    defaultGems()
+
+    // Add this GEM installation directory to the 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'
+        
+  }
+  
+  // All other JAR methods and properties are still valid
+}
+
+task myJar (type :Jar) {
+  jruby {
+    // As above
+  }
+
+  // All other JAR methods and properties are still valid
+}
+
+```
+
+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'
+}
+```
+

build.gradle

@@ -18,22 +18,43 @@ sourceCompatibility = '1.7'
 repositories {
     jcenter()
     mavenLocal()
+    maven { url 'http://dl.bintray.com/rtyler/jruby' }
+}
+
+configurations {
+    testWarbler
 }
 
 dependencies {
     compile gradleApi()
     compile localGroovy()
+    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.lookout', name: 'warbler-bootstrap', version: '1.0.0'
+
+}
+
+ext {
+    testWarblerDir = new File(buildDir,'tmp/test/repo' )
 }
 
 test {
     testLogging {
         showStandardStreams = true
         exceptionFormat "full"
     }
+
+    doFirst {
+        copy {
+            from project.configurations.testWarbler.files
+            into testWarblerDir
+        }
+    }
+    systemProperties TESTROOT : new File(buildDir,'tmp/test/unittests').absolutePath
+    systemProperties WARBLER_LOCATION : testWarblerDir.absolutePath
 }
 
 task sourcesJar(type: Jar, dependsOn: classes) {

src/main/groovy/com/github/jrubygradle/JRubyJar.groovy

@@ -0,0 +1,103 @@
+package com.github.jrubygradle.jar
+
+import groovy.transform.PackageScope
+import org.gradle.api.Project
+import org.gradle.api.tasks.bundling.Jar
+import com.github.jrubygradle.GemUtils
+
+/** Helper class to add extra methods to {@code Jar} tasks in order to add JRuby specifics.
+ *
+ * @author Schalk W. Cronjé
+ */
+class JRubyJarConfigurator {
+
+    static final String DEFAULT_MAIN_CLASS = 'com.lookout.jruby.JarMain'
+
+    // This is used by JRubyJarPlugin to configure Jar classes
+    @PackageScope
+    static void configureArchive(Jar archive,Closure c) {
+        JRubyJarConfigurator configurator = new JRubyJarConfigurator(archive)
+        Closure configure = c.clone()
+        configure.delegate = configurator
+        configure()
+    }
+
+    @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'
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /** Adds a GEM installation directory
+     */
+    void gemDir(def properties=[:],File f) {
+        gemDir(properties,f.absolutePath)
+    }
+
+    /** Adds a GEM installation directory
+     * @param Properties that affect how the GEM is packaged in the JAR. Currently only {@code fullGem} is
+     * supported. If set the full GEM content will be packed, otherwise only a subset will be packed.
+     * @param dir Source folder. Will be handled by {@code project.files(dir)}
+    */
+    void gemDir(def properties=[:],Object dir) {
+        archive.with GemUtils.gemCopySpec(properties,archive.project,dir)
+    }
+
+    /** Makes the JAR executable by setting a custom main class
+     *
+     * @param className Name of main class
+     */
+    void mainClass(final String className) {
+        archive.with {
+            manifest {
+                attributes 'Main-Class': className
+            }
+        }
+    }
+
+    /** Sets the defaults
+     *
+     * @param defs A list of defaults. Currently {@code gems} and {@code mainClass} are the only recognised values.
+     * Unrecognised values are silently discarded
+     */
+    void defaults(final String... defs ) {
+        defs.each { String it ->
+            switch(it) {
+                case 'gems':
+                case 'mainClass':
+                    "default${it.capitalize()}"()
+            }
+        }
+    }
+
+    /** Loads the default GEM installation directory
+     *
+     */
+    void defaultGems() {
+        gemDir({archive.project.jruby.gemInstallDir})
+    }
+
+    /** Makes the executable by adding a default main class
+     *
+     */
+    void defaultMainClass() {
+        mainClass(DEFAULT_MAIN_CLASS)
+    }
+
+
+    private JRubyJarConfigurator(Jar a) {
+        archive = a
+    }
+
+    private Jar archive
+}

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

@@ -0,0 +1,65 @@
+package com.github.jrubygradle.jar
+
+import com.github.jrubygradle.internal.WarblerBootstrap
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.api.tasks.testing.Test
+
+/**
+ * @author Schalk W. Cronjé
+ */
+class JRubyJarPlugin implements Plugin<Project> {
+    void apply(Project project) {
+
+        project.apply plugin : 'com.github.jruby-gradle.base'
+        project.configurations.maybeCreate('jrubyEmbeds')
+
+        // 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
+        // will be writing tests that includes jruby and that they might need some
+        // GEMs as part of the tests.
+        def testConfiguration = { Task t ->
+            environment GEM_HOME : project.extensions.getByName('jruby').gemInstallDir
+            dependsOn 'jrubyPrepareGems'
+        }
+        try {
+            Task t = project.tasks.getByName('test')
+            if( t instanceof Test) {
+                project.configure(t,testConfiguration)
+            }
+        } catch(UnknownTaskException) {
+            project.tasks.whenTaskAdded { Task t ->
+                if(t.name == 'test' && t instanceof Test) {
+                    project.configure(t,testConfiguration)
+                }
+            }
+        }
+        try {
+            Task t = project.tasks.getByName('jar')
+            if( t instanceof Jar) {
+                t.dependsOn 'jrubyPrepareGems'
+            }
+        } catch(UnknownTaskException) {
+            project.tasks.whenTaskAdded { Task t ->
+                if (t.name == 'jar' && t instanceof Jar) {
+                    t.dependsOn 'jrubyPrepareGems'
+                }
+            }
+        }
+
+       if(!Jar.metaClass.respondsTo(Jar.class,'jruby',Closure)) {
+           Jar.metaClass.jruby = { Closure extraConfig ->
+               JRubyJarConfigurator.configureArchive(delegate,extraConfig)
+           }
+       }
+
+        project.afterEvaluate {
+            WarblerBootstrap.addDependency(project)
+            JRubyJarConfigurator.afterEvaluateAction(project)
+        }
+    }
+
+
+}

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

@@ -0,0 +1 @@
+implementation-class=com.github.jrubygradle.jar.JRubyJarPlugin