Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Migrated to Confluence 4.0


Grape (The Groovy Adaptable Packaging Engine or Groovy Advanced Packaging Engine) is the infrastructure enabling the grab() calls in Groovy, a set of classes leveraging Ivy to allow for a repository driven module system for Groovy. This allows a developer to write a script with an essentially arbitrary library requirement, and ship just the script. Grape will, at runtime, download as needed and link the named libraries and all dependencies forming a transitive closure when the script is run from existing repositories such as Ibiblio, Codehaus, and


The prototype is ready for inclusion into the trunk immediately, however the principal dependent library used (Apache Ivy) is a SVN snapshot.  We should at least wait for a Beta 2 release and preferably for an RC release of the library before merging into trunk.  That makes it a possible 1.6 candidate, and more likely a 1.7 candidate.

General Requirements

  • There must be a means to cause all calls to the Grape system to become no-ops and rely strictly on the JVM classpath.
  • Grape should support bringing in packages from Maven 2 repositories.
  • There should be some notion of 'endorsed modules' that are shortcutted in for easier use. For example: Scriptom, GroovyWS, SwingXBuilder. These can be hosted as regular Maven2 POMS or some other repository mechanism can be used.
  • There should be command line tools similar to RubyGems, to add, remove, enumerate, and update versions of Grapes stored in the local cache.
  • The implementation should not prevent movement into a container style module system such as integrating OSGi or Java 7 Super Packages. (this requirement should not be construed as an endorsement of either)


Module versioning model.

Grape follows the Ivy conventions for module version identificaiton, with naming change.

  • group - Which module group the module comes from. Translates directly to a Maven groupId or an Ivy Organization. Any group matching /groovy[x][\..*]^/ is reserved and may have special meaning to the groovy endorsed modules.
  • module - The name of the module to load. Translated directly to a Maven artifactId or an Ivy artifact.
  • version - The version of the module to use. Either a literal version '1.1-RC3' or an Ivy Range '[2.2.1,)' meaning 2.2.1 or any greater version).

Code Level Support


One or more groovy.lang.Grab annotations can be added at any place that annotations are accepted to tell the compiler that this code relies on the specific library. This will have the effect of adding the library to the classloader of the groovy compiler. This annotation is detected and evaluated before any other resolution of classes in the script, so imported classes can be properly resolved by a @Grab annotation.

Code Block
import com.jidesoft.swing.JideSplitButton
@Grab(group='com.jidesoft', module='jide-oss', version='[2.2.1,)')
public class TestClassAnnotation {
    public static String testMethod () {

An appropriate grab(...) call will be added to the static initializer of the class of the containing class (or script class in the case of an annotated script element).

TODO: How do we add a grab annotation to straight scripts? The current workaround is to annotate something in the script that can accept an annotation, like a method or parameter.

Method call

Typically a call to grab will occur early in the script or in class initialization. This is to insure that the libraries are made available to the ClassLoader before the groovy code relies on the code. A couple of typical calls may appear as follows:

Code Block
// random maven library
groovy.grape.Grape.grab(group:'com.jidesoft', module:'jide-oss', version:'[2.2.0,)')
groovy.grape.Grape.grab([group:'org.apache.ivy', module:'ivy', version:'2.0.0-beta1', conf:['default', 'optional']],
     [group:'org.apache.ant', module:'ant', version:'1.7.0'])

// endorsed Groovy Module
// FUTURE grab('Scriptom')

* grab(Object self, String module),- grab(Object self, Map attrs), and grab(Object self, Map attrs, Map... dependencies) will be added to the DGM so that references to the backing Grape classes will not be needed. These will be proxies to the main Grape class calls.

  • Multiple calls to grab in the same context with the same parameters should be idempotent. However, if the same code is called with a different ClassLoader context then resolution may be re-run.
  • grab is disabled by default. Starting calling Grape.initGrape() will enable grab. Any calls to grab before initGrape() is called will be ignored. Hence Grape managed classloading is opt in only.
  • If the args map passed into the grab call has an attribute noExceptions that evaluates true no exceptions will be thrown.
  • grab requires that a RootLoader or GroovyClassLoader be specified or be in the ClassLoader chain of the calling class. By default failure to have such a ClassLoader available will result in module resolution and an exception being thrown (if initGrape() has been called).
    • The ClassLoader passed in via the classLoader: argument and it's parent classloaders.
    • The ClassLoader of the object passed in as the referenceObject: argument, and it's parent classloaders.
    • The ClassLoader of the class issuing the call to grab
  • grab(String) is a shortcut for endorsed groovy modules and will be equivilant to grab(group:'groovy.endorsed', module:<the module>, version:<the version of groovy being run>)

    TODO: all discussion of grab(String} are purely hypothetical as it hasn't been prototyped or the needed infrastructure set up

grab(HashMap) Parameters

  • group: - <String> - Which module group the module comes from. Translates directly to a Maven groupId. Any group matching /groovy(|\..|x|x\..)/ is reserved and may have special meaning to the groovy endorsed modules.
  • module: - <String> - The name of the module to load. Translated directly to a Maven artifactId.
  • version: - <String> and possibly <Range> - The version of the module to use. Either a literal version '1.1-RC3' or an Ivy Range '[2.2.1,)' meaning 2.2.1 or any greater version).
  • conf: - <String>, default 'default' - The configuration or scope of the module to download. The default conf is default: which maps to the maven runtime and master scopes.
  • force:- <boolean>, defaults true - Used to indicate that this revision must be used in case of conflicts, independently of
  • conflicts manager
  • changing: - <boolean>, default false - Whether the artifact can change without it's version designation changing.
  • transitive: - <boolean>, default true - Whether to resolve other dependencies this module has or not.

There are two principal variants of grab, one with a single Map and one with an arguments Map and multiple dependencies map. A call to the single map grab is the same as calling grab with the same map passed in twice, so grab arguments and dependencies can be mixed in the same map, and grab can be called as a single method with named parameters.

There are synonyms for these parameters. Submitting more than one is a runtime exception.

  • group:, groupId:, organisation:, organization:, org:
  • module:, artifactId:, artifact:
  • version:, revision:, rev:
  • conf:, scope:, {{configuration:}}

    Grape may want support simple ranges ('2.2.1'..'*') or '2.2.1'..<'3.0.0' meaning any version greater than 2.2.1 but no 3.x version. But there are implementation problems, trying either of these ranges creates a runtime error having to do with enumerating the list.

Arguments Map arguments
  • classLoader: - <GroovyClassLaoder> or <RootClassLoader> - The ClassLoader to add resolved Jars to
  • refObject: - <Object> - The closest parent ClassLoader for the object's class will betreated as though it were passed in as classLoader:
  • validate: - <boolean>, default false - Should poms or ivy files be validated (true), or should we trust the cache (false).
  • noExceptions: - <boolean>, default false - If ClassLoader resolution or repository querying fails, should we throw an exception (false) or fail silently (true).

Tool level support


GroovyStarter has been enhanced with an additonal --grab option. All three main arguments are required (group, module, version). Resolved jars will be added to the RootLoader. These modules will be resolved prior to the main class call.

LoaderConfiguration conf files

LoaderConfiguration has been enhanced with an additional 'grab' line option, where the option is followed by all three arguments (group, module, version). Resolved jars will be added as though they were specifically mentioned by a 'load' line option. These lines are similarly subject to property replacement as 'load' lines are.

<groovyc> support

The GroovyC ant task has been enhanced with <grab> child elements. The attributes group, module, and version specify the module to grab.

TODO: currently this doesn't work when fork='true'

File Level View

The downloaded modules will be stored according to Ivy's standard mechanism with a cache root of ~/.groovy/grape

Command Line Tools

Code Block
grape install <groupId> <artifactId> [<version>]

This installs the specified groovy module or maven artifact. If a version is specified that specific version will be installed, otherwise the most recent version will be used (as if '*' we passed in).

Code Block
grape list

Lists locally installed modules (with their full maven name in the case of groovy modules) and versions.

Code Block
grape resolve (<groupId> <artifactId> <version>)+

This returns the file locations of the jars representing the artifcats for the specified module(s) and the respective transitive dependencies.


The motivation for introducing Grape into groovy is to resolve the library and module proliferation problem we are encountering. As a general purpose language Grape is suitable for a lot of wildly variable tasks. Providing groovy ways to do those things can crate 'bloat' because a large number of classes that are


Credit for coming up with the name Grape goes to Jörg Staudemeyer and grab Andres Almiray.

Use of Maven Repositories

Maven is big, there are tons of Java libraries that are already deployed in a well-known infrastructure. Because almost all(question) of these are straight Java they are all usable in Groovy out of the box.

Use of Ivy

  • Ivy is licensed under the ASL2, which is the same license as Groovy
  • Ivy is focused strictly on Repository Management. Maven has a strong Repository Management portion, but also has other aspects not germane to the needs of the Grape system, namely build management and project management. If the goal is to provide a means to drop unneeded code we shouldn't bring in unneeded code.
  • Ivy provides for an extensible repository resolution system. If we decide to roll our own Groovy Repository we have the infrastructure to do it, we can also support other non-maven repository systems if needed.

Backward Compatibility

GroovyStarter does do some existing library management, namely loading every singe jar in ~/.groovy/lib into the RootLoader. With Grape installed such behavior can continue, and is merely duplicate effort with no adverse implications. In the 2.0 timeframe we may want to look into deprecating or removing the auto-include of the ~/groovy/lib directory.

Reference Implementaion

A 0.1.0 protptype is available. This shows the grab(...) method, the @Grab annotation, and command line tools. Examples are available in subversion in src/examples, except for the annotation, where the best examples are in the test class.

This version may conflict with Gant, only one of the Ivy files should exist under $GROOVY_HOME/libs. If the beta-1 jar is left in place then Grape may not work.

Future Directions

We may want to increase the kind of repositories that Grape can handle from simple Ivy and Maven repositories to other areas such as OSGi Repository Bundles , JNLP (WebStart) files and JSR-277 JAM files.