Javascript: Haciendo herencia a través del prototype

Como en js no hay clases reales cuando se quiere obtener un funcionamiento de delegación similar hay que acudir a patrones más o menos liosos para ello.

La forma más efectiva de hacerlo (en términos de memoría) es haciendo uso de los prototypes de las funciones tal y como sigue:

	//Super class
	var Car = function(loc){
	this.loc=loc;
	};
	Car.prototype.move=function(){
	this.loc++;
	};
	//Sub class
	var Van = function (loc){
	Car.call(this.loc);
	}
	Van.prototype=Object.create(Car.prototype);
	Van.prototype.constructor=Van;
	Van.prototype.grab=function(){
	//whatever
	}
	var zed = new Car(3);
	zed.move();
	var amy=new Van(9);
	amy.move();
	amy.grab();

view raw javascript-subclassing-pattern hosted with ❤ by GitHub

PD: Sacado del curso de Udacity-Object Oriented Javascript (https://www.udacity.com/course/ud015), si puedes hazlo.

MYSQL: Updating column with a random codified value

	update `datamart`.`mytable`
	set
	mycolumn = case (FLOOR(1 + RAND() * 5))
	when 1 then 'SOME'
	when 2 then 'RANDOM'
	when 3 then 'STUFF'
	when 4 then 'RIGHT'
	when 5 then 'HERE'
	end;

view raw mysql-update-case-random hosted with ❤ by GitHub

Grails, reusing domains with a binary plugin

How should I do in order to reuse my domains?
Use your own domain's plugin, this is how.

Just create your plugin:

grails create-plugin book-remote
...{work as usual with your domains}...

Change your groupId/version and set binary as default type of packaging:

BookRemoteGrailsPlugin.groovy:

String groupId = 'com.nortia.book'
String version = '0.1'
String packaging = 'binary'

Install into local maven repo (or wherever you want to):

grails  maven install --binary

Then, you have include your plugin as a dependency for your grails app:

BuildConfig.groovy:

    dependencies {
    //Since it is  binary plugin is goes here instead of in the 'plugins' section
compile 'com.nortia.book:book-remote:0.1'
    }

That's it! :D
PD: There is no need for the plugin to be 'binary' unless you're planning to use those domains in another groovy (no grails) project (which was my case).

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

	@Grab("org.grails:grails-datastore-gorm-hibernate4:3.0.0.RELEASE")
	@Grab("org.grails:grails-spring:2.3.6")
	@Grab("com.h2database:h2:1.3.164")
	import grails.orm.bootstrap.*
	import grails.persistence.*
	import org.springframework.jdbc.datasource.DriverManagerDataSource
	import org.h2.Driver
	init = new HibernateDatastoreSpringInitializer(Person)
	def dataSource = new DriverManagerDataSource(Driver.name, "jdbc:h2:prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE", 'sa', '')
	init.configureForDataSource(dataSource)
	println "Total people = " + Person.count()
	@Entity
	class Person {
	String name
	static constraints = {
	name blank:false
	}
	}

view raw RunHibernateGorm.groovy hosted with ❤ by GitHub

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!

Mi 'chuleta' de Git

Llevo meses usando una especie de servilleta vieja donde apunto los comandos básicos de Git que siempre se me olvidan.

Hoy tenía que recoger la habitación y aunque no descarto que la hoja en cuestión acabe teniendo valor histórico creo que es momento de volcarlo a un mini-post que me sirva como 'cheatsheet' personal.

Hay 1000 recursos por ahi fuera mucho más estructurados y más completos, esto es simplemente mi versión ultrasimplificada

Los comandos hacen referencia a un hipotético escenario donde se trabaja sobre 3 entornos (desarrollo, staging, produccion), desplegando la aplicación sobre Heroku.

	//////////////////////
	//DEVELOPMENT
	//////////////////////
	//Checkout development branch and check
	git checkout develop
	git branch
	//Code for a while
	emacs....
	//Commit changes
	git commit -a -m "Life is wonderful"
	//Push changes
	git push origin develop
	//////////////////////
	//STAGING
	//////////////////////
	//Merge changes
	git checkout staging
	git merge develop
	//Everything is ok, commit to staging
	git push origin staging
	//Deploy to Heroku staging
	git push staging-heroku staging:master
	//////////////////////
	//PRODUCTION
	//////////////////////
	//Merge changes
	git checkout master
	git merge staging
	git push production-heroku master:master
	//////////////////////
	//OTROS
	//////////////////////
	//Work with branches locally
	git checkout --track origin/develop
	//Update local repo (non existing branch) with remote branch
	git branch -f --track develop origin/develop

view raw git-cheatsheet hosted with ❤ by GitHub

Convirtiendo Groovy objects en Maps

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

	//Couple of VO classes
	class ParamsContainerA{
	int num1
	String text1
	boolean bool1
	}
	class ParamsContainerB{
	int num2
	String text2
	boolean bool2
	}
	//Couple of instances
	ParamsContainerA anObjA=new ParamsContainerA(num1:12,text1:"holaA",bool1:true)
	ParamsContainerB anObjB=new ParamsContainerB(num2:24,text2:"adiosB",bool2:false)
	//Turned into Maps (filtering out the class property if desired)
	Map mA=anObjA.properties.findAll{it.key!="class"}
	Map mB=anObjB.properties.findAll{it.key!="class"}
	Map result=mA+mB
	println mA
	println mB
	println result

view raw groovy-into-map hosted with ❤ by GitHub

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.

SQL Corralated Update

O como hacer un update en una tabla según una condicion que involucre a una segunda tabla. Por ejemplo si tenemos:

tablaPadre (id, tablaHija_id)
tablaHija(id,tablaPadre_id)

Y resulta q por un error de carga o algo similar la columna tablaPadre_id no esta bien cargada, podemos actualizar esa tablaHija según los datos de la tablaPadre usando la siguiente query:

UPDATE tablaHija th
SET tablaPadre_id = (
   SELECT t.id
   FROM tablaPadre tp
   WHERE tp.tablaHija_id = th.id)
WHERE EXISTS (
   SELECT 1
   FROM tablaPadre tp
   WHERE tp.tablaHija_id = th.id);

De esta forma los valores de la columna de la tablaPadre se usarán para dar valor a la columna vacia de la tablaHija.

Ale, chao!

Replace en fichero tocho con 'sed'

Si alguna vez te has visto obligado a hacer un 'Replace All' en un fichero de texto grande (> 500MB) sabras que la experiencia es casi religiosa.

El editor de turno se queda colgado al abrir y al reemplazar y no queda dios ni semidios del que no te hayas acordado.

La solucion pasa por usar el comando sed de linux:

sed -i.bak 's/datamart_desa/datamart/' fich.sql

En este ejemplo se reemplaza la cadena "datamart_desa" por "datamart" en el fichero 'fich.sql' generando (por si acaso) un backup con el nombre 'fich.sql.bak'.

En un ejemplo concreto con un fichero de 870MB tarda unos 10sec., ¡una maravilla oiga!

De nada, :D

Windows: Kill / ps equivalentes

Como se puede listar las tareas/procesos de windows desde línea de comandos?

tasklist

Como se puede matar un proceso a partir de su id?

Taskkill /PID 756 /F

De nada! :D.

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:

	package arrizabalaga.mocks
	import java.lang.reflect.Field
	import java.lang.reflect.Modifier
	import arrizabalaga.DogSample
	class TestHelper {
	/**
	* Map with properties that must NOT be printed
	*/
	static Map _BLACK_PROPERTIES=[
	(DogSample.class):["nickName"]]
	/**
	* Prints filtered properties from a list of objects
	* @param obj List with data
	* @return String formatted
	*/
	public static String printList(List obj,int max=null){
	StringBuffer strResult= new StringBuffer()
	List subList=max!=null?obj.take(max):obj
	subList.each { strResult<< printAll(it) }
	return strResult.toString()
	}
	/**
	* Prints properties from the given object
	* @param obj Object to be printed
	* @return
	*/
	public static String printAll(def obj){
	String resul="---[${obj?.class}: ${obj?.hasProperty('id')?obj.id:''}]---\n".toString()
	Map props=prepareFields(obj)
	props.each{k,v->
	resul+= "\t$k:$v\n".toString()
	}
	resul+="------"
	return resul
	}
	/**
	* Gets list of fields that must be printed for an specific class
	* @param fields Initial list of fields (is used in recursion)
	* @param type The class to filter its fields
	* @param blacklistProperties List of strings with the names of properties that must be removed
	* @return
	*/
	private static List<Field> getFilteredFields(List<Field> fields, Class<?> type,List<String> blacklistProperties) {
	for (Field field: type.getDeclaredFields()) {
	if(!field.synthetic &&
	!(field.name in blacklistProperties) &&
	!(Modifier.isStatic(((Field)field).modifiers))) {
	fields.add(field);
	}
	}
	if (type.getSuperclass() != null) {
	fields = getFilteredFields(fields, type.getSuperclass(),blacklistProperties);
	}
	return fields;
	}
	/**
	* Given an object it returns a map made of fieldName|value pairs
	* @param obj Object to be trace
	* @return Map with pairs of fieldName|value
	*/
	private static prepareFields(def obj) {
	if(!obj) {
	return [:]
	}
	List blacklistProperties=_BLACK_PROPERTIES.get(obj.class)?:[]
	List<Field> fields=getFilteredFields(new LinkedList<Field>(),obj.class,blacklistProperties)
	return fields.collectEntries { v ->
	[ (v.name):obj[v.name] ]
	}
	}
	}

view raw groovy+print_filtered_properties hosted with ❤ by GitHub

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

	import java.util.regex.Matcher
	import java.util.regex.Pattern
	//Tring to capture whats inside the curly brackets
	String input="xxx{var23.ID}yyy{something here.some more}--{}"
	//The group is everything but a '}'
	def pattern = ~/\{([^\}]*)\}/
	def result=pattern.matcher(input)
	result.each{it->
	println it
	}
	//Output:
	//[{var23.ID}, var23.ID]
	//[{something here.some more}, something here.some more]
	//[{}, ]

view raw groovy+regexp+curlybrackerts hosted with ❤ by GitHub