Integrando Gorm en Griffon

Con los últimos anuncios de Graeme Rocher sobre la integración de Gorm en cualquier script Groovy:(ver https://gist.github.com/graemerocher/c25ec929d9bcd1adcbea):

Lo que pedía el cuerpo era hacer un intento para incluir Gorm en un ejemplo sencillo de Griffon.
El código completo esta en el siguiente repo (https://github.com/ivanarrizabalaga/BookGorm), y las partes relevantes son:

BuildConfig.groovy:

    repositories {

        griffonHome()

        mavenLocal()

        mavenCentral()

        mavenRepo "http://snapshots.repository.codehaus.org"

        mavenRepo "http://repository.codehaus.org"

        mavenRepo "http://download.java.net/maven/2/"

        mavenRepo "http://repository.jboss.com/maven2/"

        mavenRepo "http://repo.spring.io/milestone"

        mavenRepo "http://repo.spring.io/release"        

    }

    dependencies {

        runtime "org.grails:grails-datastore-gorm-hibernate4:3.0.0.RELEASE"

        runtime "org.grails:grails-spring:2.3.6"

        runtime "com.h2database:h2:1.3.164"        

        compile "org.springframework:spring-expression:3.2.4.RELEASE"        

    }

Initialize.groovy:

//TODO Should be a Spring bean

new HibernateDatastoreSpringInitializer("bookgorm").

configureForDataSource(new DriverManagerDataSource(

Driver.name, 

"jdbc:h2:prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE", 'sa', ''

)

)

src/main/bookgorm/Book.groovy:

package bookgorm

import grails.persistence.Entity













@Entity

class Book{

  String title

  String author

  static constraints = {

        title blank:false

        author blank:false

  }

}

BookController.groovy:

    void loadData(){

        List books=Book.list()

        edt{

            model.books.addAll(books)

        }

        

    }



    def addBook= {evt=null->

        Book b=new Book(title:view.titleField.text,author:view.authorField.text)

        b.save()

        edt{

            model.books.add(b)

            view.titleField.text=""

            view.authorField.text=""

        }

    }



    def clearAll= {evt=null->

        Book.executeUpdate("delete Book")    

        edt{

            model.books.clear()

        }

    }    

Mola, no?
¡A cuidarse!

Convirtiendo Groovy objects en Maps

En groovy convertir las propiedades de un objecto en un Map es una labor practicamente inmediata:


Nota: Si el objecto no es un objeto simple sino que esta compuesto de otros objetos complejos estos campos serán mapeados igualmente pero tal cual son, sin transformarse en Maps.

Groovy: Imprimiendo las properties de un objeto

A veces, en especial mientras ejecutas tests, necesitas sacar la información de tus objetos de dominio.

Empiezas con un println sencillo y al rato tu código apesta porque tienes println infumables que además habrá que revisar el día que cambias la definición de tus clases.

Así que para ahorrarme estos disgustos he acabado haciendo una clase muy sencilla que directamente te permite sacar la información de cualquier dominio (o listas de dominios) de forma genérica.

El código mezclando groovy con la api de reflection de java queda como sigue:


Si vas por partes verás que es muy sencillo, el único detalle más complicado tiene que ver con los campos heredados ya que hay que escalar en la jerarquía para poder listarlos.

Ale, espero que le sirve a alguien!
Iván.

Groovy regexp: Capturing inside curly brackets

Right to the snippet, :D

Griffon: Números y campos de texto

Cuando en vez un input normal se quiere garantizar que la entrada cumple un formato o tipo de valor específico hace falta irse a su hermano 'raro' el JFormattedTextField.

Para conseguir que funcione bien en Griffon lo primero es entender correctamente como funciona en Java, así que tal vez debas echar un ojo a este enlace:

http://docs.oracle.com/javase/tutorial/uiswing/components/formattedtextfield.html

Aunque siendo realista, es posible que no te apetezca leer tanto así que te pongo un ejemplo básico y listo, :D.

En este ejemplo vamos a ver como se hace el binding de valores de un formattedTextField:

   

Model:


View:


A partir de ahi cualquier necesidad diferente pasará casi siempre por jugar con el NumberFormat para crear la máscara adecuada y demás historias.

Ale, que la fuerza te acompañe!

Griffon: Varias versiones en Ubuntu

Es posible que quieras mantener varias versiones de Griffon disponibles en tu Ubuntu y te habrás preguntado como se puede hacer eso. 

La opción más 'pro' sería basarse en el uso de 'update-alternatives' pero como buscamos algo realmente sencillo vamos a tirar de enlaces simbolicos.

Al tema:

Descomprimir el tar/zip en la carpeta /usr/share

Irse a la carpeta de comunes:

cd /usr/share

Asegurarse que la carpeta y sus archivos tienen el mismo user/group que el resto de 'ejecutables':

sudo chown -R root:root griffon-1.2.0

Actualizar/Crear (si es la primera vez) el enlace simbolico a la version que queramos:

ln -sfn griffon-1.2.0 griffon

Actualizar/Crear 3 enlaces simbólicos a los scripts principales de Griffon desde el bin para que este accesible en el path:

 /usr/bin/griffon -> /usr/share/griffon/bin/griffon 
 /usr/bin/griffon-debug -> /usr/share/griffon/bin/griffon-debug
 /usr/bin/griffonsh -> /usr/share/griffon/bin/griffonsh

Para comprobar que esta todo correcto podemos hacer desde cualquier carpeta:

 griffon -version 
------------------------------------------------------------
 Griffon 1.2.0
------------------------------------------------------------

y debería salir la versión a la que estemos apuntando.

Como última nota recordar que siempre que hay un 'ejecutable' en el path podemos recordar de donde sale haciendo:

 which griffon
 -->/usr/bin/griffon

Groovy: String.containsAny

A veces es necesario comprobar que una cadena no contiene ninguno de los términos "prohibidos" de una lista.

En este caso lo fácil es hacer un pequeña función con un bucle y a correr, pero como esto es Groovy y somos más guays queremos hacer que la clase String tenga un método que nos resuelva la papeleta para no ir llenando nuestro código con funciones de este estilo o en el menos malo de los casos creando una clase helper con un método estático o alguna cosa así.

Así que al lio:



El truco aqui esta en usar la inyección de métodos del metaClass por un lado y sobre todo sacar provecho de la función inject que está disponible para listas.

Esta función lo que hace es ejecutar un closure sobre cada elemento de la lista arrastrando el valor de la ejecución en cada elemento hacia el siguiente.

Mola verdad? :D

Groovy: Añadir elementos a una lista (cuidadin!!)

Aunque parezca mentira ("me pongo colorada..."), no en serio, aunque no te lo creas añadir un elemento a una lista de groovy puede resultar peligroso.

Las siguientes instrucciones no hacen lo mismo siempre:

output+=item
output.add(item)

Si el elemento es una lista la primera operacion implica añadir los elementos de la lista y la segunda inserta en la lista destino un objeto de tipo lista.

Si no te lo crees chequea esto:

Ale, a seguir grooveando con cuidado!

Groovy: Mover seleccion de elementos arriba y abajo

A veces a partir de una lista de elementos se pide poder "subir" o "bajar" una subselección de tu lista.

Es una operación que se puede hacer de muchas formas, pero en groovy se puede jugar un poco con el lenguaje para que sea más chulo el código y sobretodo para poder usar lo mismo en ambas direcciones.

Ale, ahi va...

Groovy: Dynamic access to nested properties via GString

In groovy you can easily access properties by using GString which a really cool feature.


However this trick doesnt work when nested '.' are inside de expression.

In this case you can do the following:

That's all!

Groovy, spring, transactional y un pequeño apunte

Spring hace aveces magia negra, lo cual está muy bien salvo cuando no funciona y tienes que pararte a mirar que coño de hechizos está usando, :D.

El caso es que si tienes problemas con la gestión de transacciones delegadas a las anotaciones de Spring es probable que quieras hacer un test unitario para ver si las conexiones se cierran o no.

Como configurar el test de groovy para que ejecute la política de transacciones que quieras?

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = ["classpath:/beans/misBeans1.xml","classpath:/beans/misBeans2.xml"])
@TransactionConfiguration(transactionManager="transactionManager", defaultRollback=false)
class SpringConnectionsTest{

 static final Logger log=Logger.getLogger(SpringConnectionsTest.class)

 @Autowired
 ApplicationContext context;

@Before
void setTup(){
....
}

@Test
void testSomething(){
...
}

• Así que basicamente se trata de quitar la herencia al GroovyTestCase que tendría por defecto al ser un test de groovy.
• Indicar los ficheros de beans que se quieren cargar.
• Inyectar el bean (en el ejemplo cogemos el contexto podría ser cualquier bean) con @Autowired.

Como podemos ver que métodos se registran para el control de transacciones?

log4j.logger.org.springframework.transaction=DEBUG

Cómo podemos ver cuándo se pilla una conexion nueva o se reutiliza una?

log4j.logger.org.springframework.jdbc.datasource.DataSourceUtils=DEBUG

Mi método no lo engancha, ¿qué pasa?

Podrían ser 1000 cosas, pero recuerda que el transactionManager solo funciona con métodos públicos.