JRuby/Gradle News

Gradle Feature Spotlight: Continuous Build

2015-09-10T15:24:41-07:00

Earlier this year the Gradle project released version 2.5 with a heap of new features and improvements. One of the most touted of those features is an incubating feature (read: beta) named Continuous Build which automatically re-executes tasks after a file change. Rubyists may recognize that this functionality is similar to what the guard gem provides.

What makes "continuous build" special is that it makes use of the existing build data present in your Gradle build. Using a task’s inputs the continuous build feature can automatically "watch" the appropriate files to re-execute your task, or your tasks dependent tasks, automatically as they change!

For users JRuby/Gradle this means that upgrading to Gradle 2.5 or later, and ensuring your build.gradle declares task inputs and continuous build will "just work!" Consider the following example for running RSpec tests:

build.gradle

buildscript {
    repositories { jcenter() }
    dependencies {
        classpath "com.github.jruby-gradle:jruby-gradle-plugin:1.0.3" (1)
    }
}
apply plugin: 'com.github.jruby-gradle.base' (2)

dependencies {
    jrubyExec 'rubygems:rspec:3.3.0' (3)
}

import com.github.jrubygradle.JRubyExec

task spec(type: JRubyExec) {
    group 'JRuby'
    description 'Execute the RSpecs in JRuby'
    script 'rspec'
    inputs.source fileTree('spec').include('**/*.rb'), fileTree('lib').include('**/*.rb') (4)
}

1	Specify our dependency on the JRuby/Gradle base plugin
2	Apply the plugin to our current project
3	Define our RSpec gem dependency
4	Set our task inputs to the `.rb` files in `spec/` and in `lib/`

Using the build.gradle above, I can auto-execute my tests whenever a Ruby file inside of the spec/ (my tests) or lib/ (my code under test) with the following command:

% ./gradlew -t spec

Here’s some example output from my example project:

example-project git:(master) % ./gradlew -t spec
Continuous build is an incubating feature.
:spec

Randomized with seed 37453
..............................................

Finished in 0.52 seconds (files took 3.82 seconds to load)
46 examples, 0 failures

Randomized with seed 37453


BUILD SUCCESSFUL

Total time: 8.77 secs

Waiting for changes to input files of tasks... (ctrl-d to exit)

At this point the Gradle process is patiently waiting until I write my most recent changes, then it kicks off the same task:

Change detected, executing build...

:spec

Randomized with seed 64935
..............................................

Finished in 0.502 seconds (files took 3.5 seconds to load)
46 examples, 0 failures

Randomized with seed 64935


BUILD SUCCESSFUL

Total time: 7.341 secs

Waiting for changes to input files of tasks... (ctrl-d to exit)

Pretty neat huh?

What makes this functionality exceptionally powerful for JRuby/Gradle users is that it respects the task inputs but also the task dependency graph. If my spec task declares a dependency on the compileJava task, whenever my Java source code changes, that will trigger a re-execution of compileJava and in turn spec!

So when you’re authoring tasks, even if you’re not this feature right now, be sure to declare task inputs. That build metadata can unlock lots of interesting functionality as Gradle continues to improve!

Continuous build is one of many examples of powerful Gradle functionality which can easily used in JRuby/Gradle, I hope you find it useful!

JRuby/Gradle at JRubyConf EU 2015

2015-09-10T15:24:41-07:00

A couple weeks ago, Schalk, Christian and I were fortunate enough to participate in the wonderful JRubyConf EU 2015 in Potsdam Germany. In the days that preceeded the conference we pulled together and finished up what would become the 1.0 release of the core plugins. Just in time for my presentation to introduce the JRuby/Gradle toolchain to the audience.

Below is a video recoded by Confreaks.tv of the talk titled JRuby/Gradle: Bringing Java Powertools to Ruby:

The other sessions are also worth checking out as there was a lot of great, in-depth, technical content presented at the single-track one-day conference.

On behalf of the JRuby/Gradle core team, I’d like to thank the conference organizers (especially Tobi) for hosting such a wonderful event and allowing us the opportunity to participate. Hopefully we’ll be back next year with more to talk about!

JRuby/Gradle 1.0 Announced

2015-09-10T15:24:41-07:00

Less than one year after the JRuby/Gradle project was founded, we are pleased to announce the release of 1.0 for the core plugins, which includes the base plugin, the jar plugin and an alpha version of the war plugin. This release marks the stability of the core task and configuration APIs for the lifetime of the 1.x branch of development.

Notable Features

This release includes a number of notable features which can help developers build high quality Ruby projects, based on JRuby.

Defaulted to the major milestone release: JRuby 9.0.0.0
Native Java dependency resolution via Gradle’s built-in support of Maven repositories and with Gem dependency resolution via a rubygems.org proxy.
Execution of local Ruby script via the JRubyExec task
Execution of scripts provided by a gem dependency, e.g. rspec via JRubyExec task
Support for distinct configurations to isolate dependencies, even JRuby versions, between JRubyExec tasks.
Similar support for different configurations between JRubyJar tasks

Project History

The JRuby/Gradle project was originally started to address the challenges faced when attempting to build complex Ruby applications based on JRuby. With such applications it is desirable to leverage the vast libraries available to JVM-based languages, as well as many of the user-friendly gems built by Ruby developers

After trying to make multiple tools, which weren’t designed to support non-Java projects, work with Ruby R. Tyler Croy started building a prototype with Gradle to package up a JRuby application as a jar. Shortly after publishing the prototype, Schalke W. Cronje discovered the fledgling project and with his Gradle development experience helped bring it from a weekend hack project to a well-tested, well-structured set of Gradle plugins. Eventually Christian Meier, whose link:https://github.com/torquebox/rubygems-servlets] code helped make the project originally possible, joined the team to help improve support in JRuby itself for the different embedded operating modes that the JRuby/Gradle toolchain makes use of.