Okay, week 1 is nearing an end.I accomplished alot of things.
First, I completed the meta-data storage code. I wrote some tests, which revealed some bugs that needed fixing, and they were. I am happy to say, that the metadata storage works!
Writing the test was difficult due to the fact I store the forms in the system using a static List in my container class. I wound up updating to JUnit 4 to get at the @BeforeClass annotation so that the only one set of forms gets loaded into the container class. This helped me greatly. Additionally, the @AfterClass annotation was handy for cleaning up from the tests.
Secondly, Writing the code for interrogating the model was a piece of cake, thanks to groovy. All code for interrogating the model has 50 lines! That includes a model class I wrote to hold the field types and field names. I'll show you, but before I do, I should note that return statements are optional, and the final statement will be returned.
package org.openmrs.module.groovyforms.util
import java.lang.reflect.Field
import org.openmrs.module.groovyforms.metadata.model.GroovyFormsDomainModel
/*
* Utility class containing methods for class interrogation.
*/
class GroovyFormsClassUtil {
/**
* Interrogates the class for all declared fields and
* stores the type and name in a container class
* @param the {@link Class#getCanonicalName() canonical name of the class}
* @see Class#getCanonicalName()
* @return a reference to a container class containing the type
*/
static def getModel(fields) {
def domainModel = new GroovyFormsDomainModel()
def names = domainModel.fieldNames.&add;
def types = domainModel.fieldTypes.&add;
def f = fields.each {Field field ->
names field.name
types field.type.canonicalName
}
domainModel
}
}
With groovy, it's so easy and concise (as you can see). Let's explain what's going on. First, I pass in the Field array I get from
Field.getDeclaredFields(). Now, groovy adds methods onto the standard JDK classes, one of those methods is a method named each() which takes a
closure. Now, back to the point, I pass a
Field into the closure. That closure is executed for each element (in this case, a Field). Then I add the name, and the type to a List stored in a container class, now that container class is also written in groovy!
package org.openmrs.module.groovyforms.metadata.model
/*
* Ths class holds information about the properties of the model.
*/
class GroovyFormsDomainModel {
/**
* The field names
*/
def fieldNames = []
/**
* The field types
*/
def fieldTypes = []
}
Now, the fields are Lists, not arrays. Anyways, I've gotten off on a tangent here, so let me get back on track.
What I accomplished:
Week 1:Code to generate the directory structure, serialization of metadata back/forth between XML and POJOs (Plain Old Java Objects), Wrote tests to ensure everything works in that regard. Additionally, I wrote the code to interrogate the domain model which I will generate the forms from.
Next WeekWrite up the templates for the view/controller and write code to do the generation of the view/controller. Write some tests to ensure everything generates correctly.
Unrelated to that, my stored-value card from google came today. It feels nice to be $500 richer! This is going to be the best summer, I'm already having fun doing this. It's amazing seeing the whole project evolve into something amazing.
by Robert O'Connor at
12:15 AM
under
blog
,
closures
,
developer
,
google
,
google summer of code
,
groovy
,
groovy forms module
,
gsoc
,
intern
,
java
,
open source
,
openmrs
,
soc
