REVERT TO CONSOLE » Groovy

The Thoughtworks Rover Problem – Groovy Edition

Jeff — Thu, 25 Mar 2010 18:43:46 +0000

I had some down time at work, and set about working on the Rover problem.

There are three problems, I chose the middle one to start with. I wrote it in groovy and used the very groovy clibuilder M. Laforge recommended in his comment. I mavenized it to make it easier to share.

You can find my solution here if you’re interested. It’s a good practice problem.

Developing Grails Apps in Eclipse

Jeff — Sat, 09 May 2009 21:11:53 +0000

This was a post I was planning on linking to; a colleague of mine was going to write a post about it, but he hasn’t yet and I’ve just spent an extra hour trying to get this to work and am frustrated- and so here is the post you’ve all been waiting for.

There are lots of holes in the existing documentation about setting up eclipse to work with grails.

First off, you will want to generate groovy class files to a directory, like bin-groovy. It’s not just for debugging, it’s also for running unit tests. Running unit tests from eclipse is a lot faster than running them from the command line, because eclipse will generate the class files needed as you develop. It’s really nice to have.

Here’s where the fun starts- let’s assume you want to use a plugin. It’s a reasonable assumption, since there are so many cool plugins available. The first thing you need to know is where plugins download and install to. These go to a plugin directory in your .grails directory, which is normally in your home folder. You’ll need the jars from these plugins in your eclipse classpath, so you’ll need to unzip them and add them as external jars. Then, you’ll also need the source from those plugins in your classpath. For this, I added an External Class Folder to my Java Build Path- the folder was located in .grails/projects//classes.

While you’ll want to uncheck the Disable Groovy Compiler Generating Class File checkbox, you’ll want to enable the Disable Check Package Matches Source Directory, otherwise you’ll have a compiler error from resources.groovy.

Finally, add bin-groovy as a class folder to your java build path libraries tab.

This entry was a big help.

Dirt Simple EXTJS Grid on Grails

Jeff — Mon, 25 Aug 2008 21:37:53 +0000

At my current contract, I’ve been using the popular EXTJS javascript library. In order to get up to speed faster, I’ve started a small project to assist my learning.

I thought about using a number of back ends to support my project, but decided on Grails after reading about the built-in JSON converters.

Getting started note: Since this is a dirt simple example, I copied extjs into the web-app/js directory. James Lorenzen looks like he has a better way, and there might be a plugin some day.

I started with a simple GORM object, Media, which looks like this:

class Media {

	static constraints = {
		releaseDate(nullable: true)
	}

	String title
	Date releaseDate
	Date dateCreated
	Date lastUpdated
}

Next I added some startup data by adding it to to Bootstrap.groovy class:

     	def m = new Media(releaseDate:null, title: 'Test')
     	m.save()

And added a controller:

import grails.converters.*

class MediaController {

    def view = {

    }

    def list = {
   	def listResult = [ total: Media.count(), items: Media.list(params)]
        render listResult as JSON
    }
}

And I now have a Grails back end that will deliver JSON to extjs! Off to the front end!

First I modified my layout, main.gsp, to add the extjs js and css files:


    
        <g:layoutTitle default="Grails" />

and added my view.gsp:


	
		
		Decorated

and lastly, my js file, taken nearly verbatim from an extjs example:

/*
 * Ext JS Library 2.0 Beta 1
 * Copyright(c) 2006-2007, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

Ext.onReady(function(){

    // create the Data Store
    var ds = new Ext.data.Store({
       autoLoad: true,
       proxy: new Ext.data.HttpProxy({
       url: 'http://localhost:8080/oscar/media/list'}),
       reader: new Ext.data.JsonReader({
       	results: 'total',
       	root:'items',
       	id:'id'
       },
       [
               {name: 'title'},
               {name: 'dateCreated'},
               {name: 'lastUpdated'},
               {name: 'releaseDate'}
          ]
       )
    });

    var cm = new Ext.grid.ColumnModel([
	    {header: "Title", width: 120, dataIndex: 'title'},
		{header: "Created Date", width: 180, dataIndex: 'dateCreated'},
		{header: "Last Updated", width: 115, dataIndex: 'lastUpdated'},
		{header: "releaseDate", width: 100, dataIndex: 'releaseDate'}
	]);
    cm.defaultSortable = true;

    // create the grid
    var grid = new Ext.grid.GridPanel({
        ds: ds,
        cm: cm,
        renderTo:'center-div',
        width:540,
        height:200
    });
});

My code is checked in here.

Groovy Environment Scripting

Jeff — Thu, 17 Jul 2008 20:30:08 +0000

Problem: You want to use groovy all the time, but ignorant (but paying) forces keep you writing verbose tedious Java code instead.

Solution: Use groovy instead of shell scripts! In large Java development projects, developing in a local environment comes with a maddening list of pulling levers, pushing buttons, and spinning wheels. Many of these can be automated with scripts, and those that can can be Groovy scripts.

I wrote this script to clean up after liferay portal kruft:

#!/usr/bin/env groovy

class Build{
    def ant = new AntBuilder()
    def localhostDir = "C:/dev/liferay/tomcat/work/Catalina/localhost"
    def portraitDir = localhostDir + "/portrait"
    def liferayDir = "C:/Documents and Settings/ujxh744/liferay"
    def luceneDir = liferayDir + "/lucene"
    def classpath = ant.path {
        dirset(dir: liferayDir){
            include(name: "*")
        }
        dirset(dir: localhostDir) {
            include(name: "*")
        }
   }

    void cleanUpLiferayShit() {
        ant.delete(dir: portraitDir)
        ant.delete(dir: luceneDir)
    }

    void echoDirectories(dirPath) {
        def pathList = dirPath.list()
        println "There are " + dirPath.size() + " remaining directories"
        dirPath.list().each{ arg ->
            println arg
        }
    }
}

def b = new Build()
b.cleanUpLiferayShit()
b.echoDirectories( b.getClasspath())

Reference Links:
Javaworld
Groovy Ant site

Grails Extended ManyToMany GORM Example

Jeff — Sat, 07 Jun 2008 02:51:47 +0000

This is a variation on this article. Having never been a big fan of writing XML, I’ll gladly opt for the XML-less version. The first example online I found has some formatting issues and just seems a little hard to follow.

My step by step example follows after the jump. Call it the “Grails extended many-to-many step-by-step guide using the grails console, for dummies”.

Let’s start with a very simple example:

A person has one or more characteristics. A characteristic can be applied to more than one person. A PersonCharacteristic relationship has an assignedValue.

Here’s what I did:


grails create-domain-class person

grails create-domain-class characteristic

grails create-domain-class personCharacteristic

First I fleshed out Person:

class Person {

	static hasMany = [characteristics:PersonCharacteristic]

	String firstName
	String lastName

	List characteristics() {
		return characteristics.collect{it.characteristic}
	}

	List addCharacteristic(Characteristic characteristic) {
		return addCharacteristic(characteristic, new Integer(1))
	}

	List addCharacteristic(Characteristic characteristic, Integer assignedValue) {
		PersonCharacteristic.link(this, characteristic, assignedValue)
		return characteristics()
	}

	List removeFromCharacteristics(Characteristic characteristic) {
		PersonCharacteristic.unlink(this, characteristic)
		return characteristics()
	}

}

and Characteristic is pretty similar

class Characteristic {

	static hasMany = [people:PersonCharacteristic,employers:EmployerCharacteristic]

	String name
	String description
	Integer systemWeight = new Integer(1)

	List people() {
		return people.collect{it.person}
	}

	List employers() {
		return employers.collect{it.employer}
	}

	List addToEmployers(Employer employer) {
		EmployerCharacteristic.link(employer, this)
		return employers()
	}

	List addToPeople(Person person) {
		PersonCharacteristic.link(person, this)
		return people()
	}

	List removeFromEmployers(Employer employer) {
		EmployerCharacteristic.unlink(employer, this)
		return employers()
	}

	List removeFromPeople(Person person) {
		PersonCharacteristic.unlink(person, this)
		return people()
	}
}

and finally, PersonCharacteristic

class PersonCharacteristic {

	def Person person
	def Characteristic characteristic
	def Integer assignedValue

	static PersonCharacteristic link(Person person, Characteristic characteristic) {

		return link(person, characteristic, new Integer(1))
	}

	static PersonCharacteristic link(Person person, Characteristic characteristic, Integer assignedValue ) {
		def pc = PersonCharacteristic.findByPersonAndCharacteristic(person, characteristic)
		if (!pc) {
			pc = new PersonCharacteristic(userWeight:1)
			pc.person = person
			pc.characteristic = characteristic
			pc.assignedValue = assignedValue
			person?.addToCharacteristics(pc)
			characteristic?.addToPeople(pc)
			pc.save()
		}
		return pc
	}

	static void unlink(Person person, Characteristic characteristic) {
		def pc = PersonCharacteristic.findByPersonAndCharacteristic(person, characteristic)
		if (pc) {
			person?.removeFromCharacteristics(pc)
			characteristic?.removeFromPeople(pc)
			pc.delete()
		}
	}
}

Note: if you want an explanation of this class look here and read the section The Many-to-Many map.

Now, with any luck we’ll be able to do this with the console…

(I would assume you know this but just in case… go to your project base dir and type…

grails console

Now here are some people and characteristics. This is the easy part.

def a = new Person(firstName: "Jeff", lastName: "Revert")
a.save()
def b = new Person(firstName: "Priyatam", lastName: "Console")
b.save()
def c = new Characteristic(name: "Stupid", description: "slow of mind")
c.save()
def d = new Characteristic(name: "Handsome", description: "a pleasing appearance")
d.save()

you should see this output if you’re following along correctly:

Result: Characteristic : 2

But why take my word for it? Test it!

def jeff = Person.findByFirstName('Jeff')
def priyatam = Person.findByFirstName('Priyatam')
def stupid = Characteristic.findByName('Stupid')
def handsome = Characteristic.findByName('Handsome')
if(jeff) {
    println "Found Jeff"
}
if(priyatam) {
    println "Found Priyatam"
}
if(stupid) {
    println "Found Stupid"
}
if(handsome) {
    println "Found Handsome"
}

You should see this output:

Found Jeff
Found Priyatam
Found Stupid
Found Handsome

Next we need to add our characteristics to our people.

def person = Person.findByFirstName('Jeff')
def characteristic = Characteristic.findByName('Stupid')
person.addCharacteristic(characteristic)

and the resulting output:

Result: [Characteristic : 1]

I should be set with my many to many relationship!

Not convinced? I know how you feel…

One problem with Grails default database config is that you can’t easily go there and check out the schema. Well, I don’t know how to anyway, and I’m guessing I’m not alone. In my real world job I always check out the database. It’s like a security blanket, only with a penchant for evil. Anyway, it’s not that HSQLDB can’t provide it, it’s that the config isn’t running an in-memory database capable of connecting to. So change the development datasource url to this:

url = "jdbc:hsqldb:hsql://localhost:9001/devDB"

Open a new shell, go to your grails install directory, and run this:

java -cp ./lib/hsqldb-1.8.0.5.jar org.hsqldb.Server -database.0 mem:devDB -dbname.0 devDB

This will run an in memory database server that you can connect to with your favorite database exploring app. Now fire up the grails console again, and let’s add this stuff again.
After adding the people and characteristics, and adding the PersonCharacteristic, check out the tables. I see PERSON, CHARACTERISTIC, and PERSON_CHARACTERISTIC.

select * from person_characteristic

and this shows I’ve got a PERSON_CHARACTERISTIC table with an ID, VERSION, CHARACTERISTIC_ID, PERSON_ID, and ASSIGNED_VALUE columns with values 1,0,1,1,1. So you get exactly what you’d expect. Not bad!

GORM Relationships in the Grails Console

Jeff — Fri, 30 May 2008 02:10:03 +0000

I’ve just started scratching the surface with Grails. A good starting point seems to be understanding GORM or Grails Object Relational Mapping, which is based on Hibernate3.

In looking at the Grails tutorials online, you might be inclined to start using Grails via scaffolding and generating controllers and views. And this is fine, but another perhaps smaller step alternative is to start with the Grails Console and mess around with the relationships you’re likely to form in the database.

I found that diving in with some of the tutorials, it isn’t always obvious why you’d dynamically scaffold versus performing a static scaffold, or you might not pick up on the power of groovy pages immediately. So I found working with the grails console and GORM to start with eliminated some of the mystery, and provided a solid foundation for further learning. In my previous post I discussed some of the subtle, perhaps unexpected, issues with persisting domain objects in the grails console. Here’s how I added relationships (after the jump).

Let’s start with person and characteristic domain objects:

grails create-domain-class person
grails create-domain-class characteristic

This will create domain class Person, which we will edit to look like:

class Person {
        static hasMany = [characteristics:Characteristic]
	static optionals = ['middleInitial']
        static constraints = {middleInitial(maxLength:1)}
	String firstName
	String lastName
	String middleInitial
}

and the Characteristic class:

class Characteristic {

	static belongsTo = Person
	static optionals = ['displayName']
	String name
	String displayName
	Integer systemLevel
}

Now fire up the grails console, you can persist the relationship as follows:

[/java]
def c = new Characteristic(name: “lazy”, displayName: “exudes laziness”, systemLevel: 1)
def p = new Person(firstName: “Jeff”, lastName: “Smith”, middleInitial: “S”,
characteristics:[c])
p.save()
[/java]

After executing, this should display:

Result: Person : 1

And how about some built-in querying?

Domain object plus .get(id) will retrieve by identifier:

def newGuy = Person.get(1)

if(newGuy) {
println newGuy.firstName
} else {
println "No new guy was found!"
}

You should see “Jeff” as the output.

Dynamic finders are where you really see some interesting things:

def f = Person.findByFirstName('Jeff')
if(f) {
  println f.lastName
  println f.characteristics.each{ println it.name }
} else {
  println "No Person with the first name of Jeff was found!"
}

Grails Startup Pain

Jeff — Tue, 27 May 2008 16:06:10 +0000

Grails is a composed of a stack I like, a combination of technologies I’ve enjoyed using over the last few years- Groovy, HSQLDB, Spring, Hibernate, etc. And the whole seems greater than the sum of its parts, so while I’m complaining about it today, I do so knowing that with future releases Grails could really deliver a great solution.

One thing that many new frameworks are striving to offer these days is a quick startup- you can push this button, pull this lever, and voila, you have a hello world and can build from there. Of course this sounds better than writing a domain class, a dao, a service class, then enter some BS in your web.xml, and wire your beans, and add a *-servlet.xml, configure log4j, etc etc etc. And it is. Except when it doesn’t work.

My initial attempt at creating a Grails project went like this:

grails create-app created my application.
import project imported my project into Eclipse. I ended up with 25 or so classes in my base directory.
grails run-app runs Jetty. I pull up a browser and can see my new site- everything appears to be going great.
grails create-domain-class Create a domain class. Edit the domain class file, add a few properties. Easy.
grails create-controller Creates a controller class. Remove the index() method and add def scaffold = domain class.
grails run-app start my server again. This time I see my controller, click on it.

NullPointerException

The crazy thing is, this is after following directions from the book written by the lead developer of the Grails project! Ouch!

Here’s another example:

The getting started with Grails documentation highlights using Bootstrap.groovy in grails-app/conf as a place to inject test data.

So for example, using a domain class Bookmark, in the Bootstrap.groovy file you could write:

new Bookmark(property1: "value1", property2: "value2").save()

and have the bookmark show up in the Grails scaffolding.

With this approach I ended up with a “NoMethodException” saying that save() was not a valid method for this domain class.

Nice.

Another approach mentioned using the groovy console to add data. I could create an object, such as the Bookmark, but again I could not save it. This time it seemed like after creating it, it could not find the object in the stack.

I will continue to post about this as I find out the source of my problems.

Update 5/28/08: After rereading the extensive “how to set up a Grails project in Eclipse” documentation, it became clear that without disabling the Groovy plugin auto-compilation feature, I wouldn’t have much success. In fact, after last night’s effort I’ve made some nice progress and am beginning to see some similarities between Grails and Seam, at least in terms of work-cycle.

I’m frustrated though, by the fact that grails shell is not working for me. I believe the issue is that I’m using cygwin. It may be time to just switch over the linux entirely.

Update: The “grails console” option appears to work.

Update 5/29/08: One thing I’ve noticed is that given a domain object like this:

class Person {
	static optionals = ['middleInitial']
	String firstName
	String lastName
	String middleInitial
}

In the grails console, you MUST specify the optional property middleInitial in order to successfully create an object. Unfortunately, there’s no warning or explanation in the console. It just doesn’t work without all properties being passed in the constructor.

So this will work:

def p = new Person(firstName: "test", lastName: "test", middleInitial: "m")
p.save()

But this will not:

def p = new Person(firstName: "test", lastName: "test")
p.save()

And neither will this:

def p = new Person()
p.firstName = "test"
p.lastName = "test"
p.save()

But this will:

def p = new Person()
p.firstName = "test"
p.lastName = "test"
p.middleInitial  = "m"
p.save()

Groovy CLIBuilder In Practice

Jeff — Mon, 06 Aug 2007 15:44:25 +0000

Ok, it doesn’t get much easier than this to build a CLI:

class ContentUpdaterMain {

static void main(args) {

def cli = new CliBuilder(usage: 'java -jar contentupdater.jar -su[dh] "update name"')
cli.h(longOpt: 'help', 'usage information')
cli.u(longOpt: 'update', 'update the provided table', args: 1)
cli.s(longOpt: 'stage', 'stage the provided table', args: 1)
cli.d(longOpt: 'debug', 'run the process with debugging enabled')
def opt = cli.parse(args)
if(!opt) return

if(opt.h) cli.usage()

if( opt.d ) {
//turn on debug
}

if(opt.u) {
//do updates
}

if( opt.s ) {
// run against staging db
}
}
}

This produces the following usage output:

usage: java -jar contentupdater.jar -su[dh] "update name"
-d,--debug run the process with debugging enabled
-h,--help usage information
-s,--stage stage the provided table
-u,--update update the provided table

And all that remains is to validate the input and invoke the processes!

Groovy Build Script Using AntBuilder Example

Jeff — Thu, 26 Jul 2007 19:46:51 +0000

As with most things in the life of a Java developer, doing simple things are simple, more complex things though are often much more complicated. For self-described slow learners such as myself, complex tasks become exponentially slower. So it has been with my adoption of the Groovy programming language. Even with the book, it’s still hard to find examples or adequate documentation for performing tasks the groovy way.

I have written a set of scripts to perform a data migration, but stalled when I went to write a groovy build script. Here’s what I ended up with:

import org.apache.log4j.Logger
import org.apache.tools.ant.listener.Log4jListener
import org.apache.tools.ant.Project

class build {

def ant = new AntBuilder()
static def SRC_DIR 		 = "Source/groovy"
static def DIST_DIR 	         = "dist"
static def CLASSES_DIR        = "bin"
static def LIB_DIR		  = "Source/lib"

def classpath = ant.path {
fileset(dir: "${LIB_DIR}"){
include(name: "*.jar")
}
pathelement(path: "${CLASSES_DIR}")
}

def groovyclasspath = ant.path {
fileset( file: "${LIB_DIR}/groovy-all-1.0.jar")
}

static void main(args) {
def build = new build()
build.run(args)
}

def all() {
ant.mkdir(dir: "${CLASSES_DIR}")
ant.javac(
destdir: "${CLASSES_DIR}",
srcdir: "${SRC_DIR}",
classpath: "${classpath}")
ant.groovyc(
destdir: "${CLASSES_DIR}",
srcdir: "${SRC_DIR}",
includes: "*.groovy",
classpathref: "${LIB_DIR}")
}

def void run(args) {
ant.getProject().addBuildListener(new Log4jListener())
ant.taskdef(
name: "groovyc",
classname: "org.codehaus.groovy.ant.Groovyc")
if ( args.size() > 0 ) {
invokeMethod(args[0], null )
} else {
all()
}

}

The problem with this is that the basic ant logging is gone. This is all I see when I run it with no arguments:

14:19:52,713 [INFO ]**(Log4jListener.java109) Task “groovyc” started.
14:19:52,729 [DEBUG]**(Log4jListener.java155) build.groovy omitted as build.class is up to date.
14:19:52,729 [INFO ]**(Log4jListener.java121) Task “groovyc” finished.

And, as many of you know, ant’s logging is one of the most important, if not only, way of troubleshooting ant script problems.

Here’s another attempt, but you can see I’m just using echo here:

def ant =new AntBuilder()

def srcDir          ="Source/groovy"
def libDir          ="Source/lib"
def classesDir      ="bin"

ant.sequential{
echo"Creating the output directories"
mkdir(dir:new File(classesDir))

echo"Defining the classpath"
path(id:"path"){
fileset(dir: libDir){
include(name:"**/*.jar")
}
pathelement(location: classesDir)
}

echo"Defining groovyc task"
taskdef(name:"groovyc", classname:"org.codehaus.groovy.ant.Groovyc", classpathref:"path")

echo"Compiling main classes"
groovyc(srcdir: srcDir, destdir: classesDir, classpathref:"path")

}

I know that with ant in the background, log4j logging must be there somewhere. I did some previous work using the ant api and was able to get basic logging going without too much trouble. This would be so much more useful if that were working.

Interesting groovy build script articles online: