sudo apt-get install wordnet

Then simply type:

wn hello -over

You should see output similar to this:

Overview of noun hello

The noun hello has 1 sense (first 1 from tagged texts)

1. (1) hello, hullo, hi, howdy, how-do-you-do — (an expression of greeting; “every morning they exchanged polite hellos”)

That’s all well and good, until I typed this:

wn smote -over

And came up empty. Indeed WordNet is useful but it is limited. There are 2 solutions that immediately came to mind.

1. Figure out how to get more definitions loaded into my instance of WordNet
2. Find a dictionary service that is much more comprehensive than WordNet, and write a client for it

After a couple of quick Google searches I decided on the latter. And, since I’ve been doing a fair amount of Grails work lately, I thought, why not try this in Groovy?

One of those Google searches brought me to http://services.aonaware.com/DictService/. After a few trials with the simple front-end on the page, I was satisfied. Then it was time to find a Groovy example, which I found quickly enough with Groovy WS.

If you look at the code snippet on that page, it is incredibly simple.

@Grab(group='org.codehaus.groovy.modules', module='groovyws', version='0.5.2')
import groovyx.net.ws.WSClient

proxy = new WSClient("http://www.w3schools.com/webservices/tempconvert.asmx?WSDL", this.class.classLoader)
proxy.initialize()

result = proxy.CelsiusToFahrenheit(0)
println "You are probably freezing at ${result} degrees Farhenheit"

I tried this example as is, but seemed to have problems with the annotation at the top. Being rather impatient, I found a Groovy WS Standalone jar here at:
http://snapshots.dist.codehaus.org/groovy/distributions/groovyws/groovyws-standalone-0.5-SNAPSHOT.jar

I dropped it into my $GROOVY_HOME/lib directory, and then removed the annotation from the code. The example worked perfectly.

So, using the WSDL from the service I mentioned earlier, I made a few modifications and named it Pablo.groovy. Why Pablo? Why not? When speed counts, who cares?!

import groovyx.net.ws.WSClient

proxy = new WSClient("http://services.aonaware.com/DictService/DictService.asmx?WSDL", this.class.classLoader)
proxy.initialize()

//Define is a name of the service method, see the service WSDL
result = proxy.Define(args[0])

if(result != null) {
	for(defin in result.definitions.definition) {
		println "${defin.wordDefinition}"
	}
}

I needed to analyze the WSDL to figure out how to interpret the results, but other than that, it was a pleasantly pain-free experience.

Now I type:

groovy Pablo.groovy smote

And I get a much more satisfying result, save the logging garbage at the top!

Jul 18, 2011 5:11:29 PM org.apache.cxf.endpoint.dynamic.DynamicClientFactory outputDebug
INFO: Created classes: com.aonaware.services.webservices.ArrayOfDefinition, com.aonaware.services.webservices.ArrayOfDictionary, com.aonaware.services.webservices.ArrayOfDictionaryWord, com.aonaware.services.webservices.ArrayOfStrategy, com.aonaware.services.webservices.Define, com.aonaware.services.webservices.DefineInDict, com.aonaware.services.webservices.DefineInDictResponse, com.aonaware.services.webservices.DefineResponse, com.aonaware.services.webservices.Definition, com.aonaware.services.webservices.Dictionary, com.aonaware.services.webservices.DictionaryInfo, com.aonaware.services.webservices.DictionaryInfoResponse, com.aonaware.services.webservices.DictionaryList, com.aonaware.services.webservices.DictionaryListExtended, com.aonaware.services.webservices.DictionaryListExtendedResponse, com.aonaware.services.webservices.DictionaryListResponse, com.aonaware.services.webservices.DictionaryWord, com.aonaware.services.webservices.Match, com.aonaware.services.webservices.MatchInDict, com.aonaware.services.webservices.MatchInDictResponse, com.aonaware.services.webservices.MatchResponse, com.aonaware.services.webservices.ObjectFactory, com.aonaware.services.webservices.ServerInfo, com.aonaware.services.webservices.ServerInfoResponse, com.aonaware.services.webservices.Strategy, com.aonaware.services.webservices.StrategyList, com.aonaware.services.webservices.StrategyListResponse, com.aonaware.services.webservices.WordDefinition
Jul 18, 2011 5:11:30 PM groovyx.net.ws.AbstractCXFWSClient getBindingOperationInfo
WARNING: Using SOAP version: 1.1
Smite \Smite\ (sm[imac]t), v. t. [imp. {Smote} (sm[=o]t), rarely
{Smit} (sm[i^]t); p. p. {Smitten} (sm[i^]t”t’n), rarely
{Smit}, or {Smote}; p. pr. & vb. n. {Smiting}
(sm[imac]t”[i^]ng).] [AS. sm[=i]tan to smite, to soil,
pollute; akin to OFries. sm[=i]ta to smite, LG. smiten, D.
smijten, G. schmeissen, OHG. sm[=i]zan to smear, stroke, OSw.
& dial. Sw. smita to smite, Dan. smide to throw, Goth.
bismeitan, to anoint, besmear; cf. Skr. m[=e]d to be fat. The
original sense seems to have been, to daub on, to smear. Cf.
{Smut}.]
1. To strike; to inflict a blow upon with the hand, or with
any instrument held in the hand, or with a missile thrown
by the hand; as, to smite with the fist, with a rod,
sword, spear, or stone.
[1913 Webster]

Now to smote the logging and be rid of it; simply adding these few lines will do:

import java.util.logging.Level
import java.util.logging.LogManager

LogManager.getLogManager().getLogger("").setLevel(Level.SEVERE)

Now the output is as tidy as I want it to be for now.

$ groovy Pablo.groovy smote
Smite \Smite\ (sm[imac]t), v. t. [imp. {Smote} (sm[=o]t), rarely
{Smit} (sm[i^]t); p. p. {Smitten} (sm[i^]t”t’n), rarely
{Smit}, or {Smote}; p. pr. & vb. n. {Smiting}
(sm[imac]t”[i^]ng).] [AS. sm[=i]tan to smite, to soil,
pollute; akin to OFries. sm[=i]ta to smite, LG. smiten, D.
smijten, G. schmeissen, OHG. sm[=i]zan to smear, stroke, OSw.
& dial. Sw. smita to smite, Dan. smide to throw, Goth.
bismeitan, to anoint, besmear; cf. Skr. m[=e]d to be fat. The
original sense seems to have been, to daub on, to smear. Cf.
{Smut}.]
1. To strike; to inflict a blow upon with the hand, or with
any instrument held in the hand, or with a missile thrown
by the hand; as, to smite with the fist, with a rod,
sword, spear, or stone.
[1913 Webster]

Whosoever shall smite thee on thy right cheek, turn
to him the other also. –Matt. v. 39.
[1913 Webster]

And David . . . took thence a stone, and slang it,
and smote the Philistine in his forehead. –1 Sam.
xvii. 49.
[1913 Webster]

2. To cause to strike; to use as an instrument in striking or
hurling.
[1913 Webster]

Prophesy, and smite thine hands together. –Ezek.
xxi. 14.
[1913 Webster]

Saul . . . smote the javelin into the wall. –1 Sam.
xix. 10.
[1913 Webster]

3. To destroy the life of by beating, or by weapons of any
kind; to slay by a blow; to kill; as, to smite one with
the sword, or with an arrow or other instrument.
[1913 Webster]

4. To put to rout in battle; to overthrow by war.
[1913 Webster]

5. To blast; to destroy the life or vigor of, as by a stroke
or by some visitation.
[1913 Webster]

The flax and the barly was smitten. –Ex. ix. 31.
[1913 Webster]

6. To afflict; to chasten; to punish.
[1913 Webster]

Let us not mistake God’s goodness, nor imagine,
because he smites us, that we are forsaken by him.
–Wake.
[1913 Webster]

7. To strike or affect with passion, as love or fear.
[1913 Webster]

The charms that smite the simple heart. –Pope.
[1913 Webster]

Smit with the love of sister arts we came. –Pope.
[1913 Webster]

{To smite off}, to cut off.

{To smite out}, to knock out, as a tooth. –Exod. xxi. 27.

{To smite with the tongue}, to reproach or upbraid; to
revile. [Obs.] –Jer. xviii. 18.
[1913 Webster]

Smite \Smite\ (sm[imac]t), v. t. [imp. {Smote} (sm[=o]t), rarely
{Smit} (sm[i^]t); p. p. {Smitten} (sm[i^]t”t’n), rarely
{Smit}, or {Smote}; p. pr. & vb. n. {Smiting}
(sm[imac]t”[i^]ng).] [AS. sm[=i]tan to smite, to soil,
pollute; akin to OFries. sm[=i]ta to smite, LG. smiten, D.
smijten, G. schmeissen, OHG. sm[=i]zan to smear, stroke, OSw.
& dial. Sw. smita to smite, Dan. smide to throw, Goth.
bismeitan, to anoint, besmear; cf. Skr. m[=e]d to be fat. The
original sense seems to have been, to daub on, to smear. Cf.
{Smut}.]
1. To strike; to inflict a blow upon with the hand, or with
any instrument held in the hand, or with a missile thrown
by the hand; as, to smite with the fist, with a rod,
sword, spear, or stone.
[1913 Webster]

Whosoever shall smite thee on thy right cheek, turn
to him the other also. –Matt. v. 39.
[1913 Webster]

And David . . . took thence a stone, and slang it,
and smote the Philistine in his forehead. –1 Sam.
xvii. 49.
[1913 Webster]

2. To cause to strike; to use as an instrument in striking or
hurling.
[1913 Webster]

Prophesy, and smite thine hands together. –Ezek.
xxi. 14.
[1913 Webster]

Saul . . . smote the javelin into the wall. –1 Sam.
xix. 10.
[1913 Webster]

3. To destroy the life of by beating, or by weapons of any
kind; to slay by a blow; to kill; as, to smite one with
the sword, or with an arrow or other instrument.
[1913 Webster]

4. To put to rout in battle; to overthrow by war.
[1913 Webster]

5. To blast; to destroy the life or vigor of, as by a stroke
or by some visitation.
[1913 Webster]

The flax and the barly was smitten. –Ex. ix. 31.
[1913 Webster]

6. To afflict; to chasten; to punish.
[1913 Webster]

Let us not mistake God’s goodness, nor imagine,
because he smites us, that we are forsaken by him.
–Wake.
[1913 Webster]

7. To strike or affect with passion, as love or fear.
[1913 Webster]

The charms that smite the simple heart. –Pope.
[1913 Webster]

Smit with the love of sister arts we came. –Pope.
[1913 Webster]

{To smite off}, to cut off.

{To smite out}, to knock out, as a tooth. –Exod. xxi. 27.

{To smite with the tongue}, to reproach or upbraid; to
revile. [Obs.] –Jer. xviii. 18.
[1913 Webster]

Smote \Smote\,
imp. (& rare p. p.) of {Smite}.
[1913 Webster]

smite
v 1: inflict a heavy blow on, with the hand, a tool, or a weapon
2: affect suddenly with deep feeling; “He was smitten with love
for this young girl”
3: cause pain or suffering in; “afflict with the plague”; “That
debasement of the verbal currency that afflicts terms used
in advertisement” [syn: {afflict}]
[also: {smote}, {smitten}, {smit}]

smote
See {smite}

The results are lengthy, but for right now, it’s all that I want. And nay, I shan’t complain!

It was quick and easy, and as long as I use it less than several thousand times per day, I am operating well within the terms of service.

Till next time!

Here is what I did, step by step, to get a chat bot going on my GAE site using gaelyk:

First I created a class to manage my chatting. It contains static references to GAE’s xmpp and datastore objects:

Next I created a simple form to manage invites, complete with backend to initiate the invitations. Keep in mind before you can send and receive messages you need to accept an invitation!:

Form:

Groovy:

Next, I enabled the inbound services on the appengine-web.xml, and the XmppServlet’s on the web.xml. This is described on the gaelyk tutorial.

Lastly, I created jabber.groovy in WEB-INF to handle incoming messages:

TODO:

• Uninvite, or block those previously invited
• Mask appid with a better chat name

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.

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.

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:

[sourcecode language='java']
#!/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())
[/sourcecode]

Reference Links:
Javaworld
Groovy Ant site

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!

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:

)
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!"
}

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()

I’ve started a little webapp project – just something simple at first, to get back into doing the type of work that I enjoy doing (as opposed to what I have to do to earn a living)…

The thing is, I keep running into Groovy bugs that appear to be closed but are still in the latest release, after debugging for an hour or two. In looking through the groovy website for a release candidate or some beta or alpha version, I didn’t see one. So rather than chalk up my efforts to a wasted attempt, I thought I’d post what I have here:

Here is what I put together for a simple spring config:

	

			classpath:org/reverttoconsole/mymediamanager/resource/mmm.properties
		
	

	

			
		


				org.reverttoconsole.mymediamanager.model
			
		



					${default.schema}
				

					${hibernate.dialect}
				

					org.hibernate.cache.EhCacheProvider
				
			
		
	

	

			
		
true
	

    

            ${driver.class}
        

        	${jdbc.url}
        

            ${mmm.user}
        

            ${mmm.password}
        
    

    

    

    

    		
    	
    

This is what I had in place for a model class:

package org.reverttoconsole.mymediamanager.model;

import javax.persistence.Entity
import javax.persistence.SequenceGenerator
import javax.persistence.GeneratedValue
import javax.persistence.Id
import javax.persistence.Column
import javax.persistence.Table
import javax.persistence.Basic

@Entity
@Table(name="MEDIA")
@SequenceGenerator(
	    name="SEQ_GEN",
	    sequenceName="media_seq", allocationSize=20)
class Media {

	@Id
	@GeneratedValue(generator = "media_seq")
	@Column(name="MEDIA_ID")
	def mediaId

	@Basic(optional=false)
	@Column(nullable=false)
	def type

	@Basic(optional=false)
	@Column(nullable=false)
	def fileName

	@Basic(optional=false)
	@Column(nullable=false)
	directory
}

And a dao:

package org.reverttoconsole.mymediamanager.dao;

import org.reverttoconsole.mymediamanager.model.Media
import org.springframework.orm.hibernate3.support.HibernateDaoSupport

class MediaDao extends HibernateDaoSupport {

	void addMedia(def media){
		hibernateTemplate.save(media)
	}
}

My simple integration test looked like this:

package org.reverttoconsole.mymediamanager.integration

import org.apache.log4j.xml.DOMConfigurator
import org.springframework.context.support.ClassPathXmlApplicationContext

import org.reverttoconsole.mymediamanager.dao.MediaDao

class SimpleTest extends GroovyTestCase {

	def context
	def mediaDao

	void setUp() {
		DOMConfigurator.configure("src/org/reverttoconsole/mymediamanager/resource/log4j.xml")
		context =
			new ClassPathXmlApplicationContext("./org/reverttoconsole/mymediamanager/resource/mmmDatabaseContext.xml")
	}

	void testSomething() {
                assert context
		mediaDao = (MediaDao)context.getBean("mediaDao")
// still working on this...
	}

}

And I added an ant script:

The specific error I keep seeing is:

\home\Jeff\work\mymediamanager\build.xml:61: groovy.lang.MissingMethodException: No signature of method: org.reverttoconsole.mymediamanager.integration.SimpleTest.main() is applicable for argument types: ([Ljava.lang.String;) values: {[]}

Although I also see various compilation errors sporadically, which I attribute to my eclipse setup.

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!