Say, you want to implement a quick and flexible automation enhancement to one of your eclipse RCP plugins – for example, because you are writing some sort of business application in which you always have to create a few standard structures manually in order to play with it and test it.

Here’s how you can do it the groovy way:

• create a new plugin project that depends on all plug-ins you want the automation script to be able to access.
• download groovy-all-x.y.z.jar from the Groovy homepage and put it into your plug-in’s runtime classpath.
• create an objectContribution like this:

      <objectContribution
            adaptable="false"
            id="myproject.groovyRunner"
            nameFilter="*.groovy"
            objectClass="org.eclipse.core.resources.IFile">
         <action
               class="myproject.automate.RunGroovyAction"
               enablesFor="1"
               id="myproject.groovyRunnerAction"
               label="Execute as Automation Script"
               menubarPath="additions">
         </action>
      </objectContribution>

• implement the action like this

package myproject.automate;

import java.io.PrintWriter;
import java.io.StringWriter;

import groovy.lang.GroovyClassLoader;

import org.codehaus.groovy.control.ErrorCollector;
import org.codehaus.groovy.control.MultipleCompilationErrorsException;
import org.codehaus.groovy.control.messages.Message;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;

import myproject.MyPlugin;

public class RunGroovyAction implements IObjectActionDelegate {

	/** store the parent shell */
	private Shell shell = null;

	/** store the selected file */
	private IFile file;

	@Override
	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
		shell = targetPart.getSite().getShell();
	}

	@Override
	public void selectionChanged(IAction action, ISelection selection) {
		file = (IFile) ((IStructuredSelection)selection).getFirstElement();
	}

	@Override
	public void run(IAction action) {
		Assert.isNotNull(shell);
		Assert.isNotNull(file);

		try {
			/* initialize the GroovyClassLoader with the Eclipse class loader */
			GroovyClassLoader loader = new GroovyClassLoader(getClass().getClassLoader());

			/* parse the groovy file */
			Class<?> parsed = loader.parseClass(file.getContents());

			/* cast it to runnable (or whatever you like to implement */
			Class<? extends Runnable> clazz = parsed.asSubclass(Runnable.class);

			/* instantiate and rum */
			Runnable r = clazz.newInstance();
			r.run();
		}
		catch(MultipleCompilationErrorsException e) {
			/* report compilation errors in an error dialog */

			StringWriter messages = new StringWriter();
			PrintWriter printWriter = new PrintWriter(messages);

			ErrorCollector ec = e.getErrorCollector();
			if(ec.hasErrors()) {
				for(Object o : ec.getErrors()) {
					((Message) o).write(printWriter);
					printWriter.append('\n');
				}
			}

			Status status = new Status(IStatus.ERROR, MyPlugin.PLUGIN_ID,
					messages.toString(), e);

			ErrorDialog.openError(shell, "Compilation errors", messages.toString(), status);
		} catch(Exception e) {
			/* report all other errors here */

			Status status = new Status(IStatus.ERROR, MyPlugin.PLUGIN_ID,
					"Execution error", e.getCause() == null ? e : e
							.getCause());

			ErrorDialog.openError(shell, "Error", "Execution error", status);
		}
	}
}

Now you can run your Eclipse application, create a .groovy class (implementing Runnable in the case above) in a file and run it from within your runtime workspace.

Happy scripting …