El blog de pico.dev

last, como obtener los últimos inicios de sesión

2012-01-27T21:57:00.000+01:00

El comando last es una pequeña utilidad que nos permite conocer cuando se inició la sesión y cuando finalizó, con que usuario y desde que dirección IP se realizaron los últimos inicios de sesión a un sistema. Quizá esta información no sea de utilidad en alguna situación o para detectar intrusiones a un sistema. Su uso es muy simple:

$ last -F -10

Este comando nos permite conocer los ultimos 10 inicios de sesión en el sistema. Si queremos conocer los inicio de sesión realizados por un determinado usuario lo haríamos con:

$ last -F -10 root

Este comando tiene unos cuantos parámetros más que pueden consultarse en la página man del comando.

Errores de precisión, redondeo y representación con float y double

2012-01-21T17:02:00.001+01:00

Los tipos de datos float y double aunque muy usados y útiles tienen defectos, como que no son capaces de representar el resultado de ciertas operaciones ariméticas entre números reales con total precisión, en algunos casos solo son capaces de representar aproximaciones a ellos y que las operaciones las realizan en base dos. Al igual que nosotros no podemos repsentar 1/3 con números en base diez con total exactitud (solo una aproximación 0,333333333... con treses hasta el infinito) a las computadoras les pasa otro tanto de lo mismo, aunque estas guardan los números en base dos. Por tanto usarlos para hacer ciertas operaciones aritméticas, y siendo acumuladas varias de ellas, puede dar lugar a errores de redondeo y precisión en el resultado final. Por estos motivos usar estos tipos de datos no son los más adecuados para trabajar en una aplicación que calcule precios. Veámoslo con un ejemplo.

Supongamos que tenemos una cantidad de dinero tal que 100,05 a la que aplicamos un 10% de descuento y posteriormente un 5% en concepto de impuestos. Las líneas de código que calculan esto son:

import java.text.NumberFormat;

double amount = 100.05;
double discount = amount * 0.10;
double total = amount - discount;
double tax = total * 0.05;
double taxedTotal = tax + total;

NumberFormat money = NumberFormat.getCurrencyInstance();
System.out.println("Subtotal: "+ money.format(amount));
System.out.println("Discount: " + money.format(discount));
System.out.println("Total: " + money.format(total));
System.out.println("Tax: " + money.format(tax));
System.out.println("Tax+Total: " + money.format(taxedTotal));

Y el resultado es:

Subtotal: 100,05 €
Discount: 10,00 €
Total: 90,04 €
Tax: 4,50 €
Tax+Total: 94,55 €

Si nos fijamos en la suma de total más impuestos hay una diferencia de 0.01 y si presentamos un desglose de precios como este a un usuario puede que este piense que hay algún error en el cálculo, le genere desconfianza y no haga la compra en el peor de los casos. Viendo los valores sin los redondeos que hace NumberFormat tenemos:

Subtotal: 100.05
Discount: 10.005
Total: 90.045
Tax: 4.50225
Tax+Total: 94.54725

Los redondeos que hace NumberFormat es HALF_EVEN por defecto, de modo que cuando un decimal está equidistante a las dos partes se redondea a la parte par por lo que con una precisión de dos decimales:

Discount: 10.005 se redondea a 10.00
Total: 90.045 se redondea a 90.04
Tax: 4.50225 se redondea a 4.50
Tax+Total: 94.54725 se redondea a 94.55

En este caso se trata de un problema de redondeo pero ahora supongamos que tenemos una cantidad de 0,70 céntimos a la que no aplicamos un descuento pero si el procentaje de impuestos del 5%. Tendríamos:

import java.text.NumberFormat;
double amount = 0.70;
double tax = amount * 0.05;
double taxedTotal = tax + amount;

NumberFormat money = NumberFormat.getCurrencyInstance();
System.out.println("Subtotal: "+ money.format(amount));
System.out.println("Tax: " + money.format(tax));
System.out.println("Tax+Total: " + money.format(taxedTotal));

Subtotal: 0,70 €
Tax: 0,03 €
Tax+Total: 0,74 €

Nos encontramos otra vez con la diferencia de 0.01. Vemos los valores sin redondear por NumberFormat:

Subtotal: 0.7
Tax: 0.034999999999999996
Tax+Total: 0.735

Aquí se ve que el resultado de ciertas operaciones aritméticas entre datos double (o float) son almacenadas por una computadora con errores de precisión, 0.70 * 0.05 (debería ser 0.035).

Para evitar estos errores debemos utilizar la clase BigDecimal que pemite almacenar números con una precisión en la práctica infinita en base 10, realizar los cálculos como los humanos esperan, en base diez, y hacer los redondeos de precisión. Aplicando una precisión de dos decimales a los números y usando BigDecimal tenemos:

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;

RoundingMode RM = RoundingMode.HALF_EVEN;
BigDecimal amount = new BigDecimal("100.05"); 
BigDecimal discountPercent = new BigDecimal("0.10");
BigDecimal discount = amount.multiply(discountPercent).setScale(2, RM); 
BigDecimal total = amount.subtract(discount).setScale(2, RM);
BigDecimal taxPercent = new BigDecimal("0.05");
BigDecimal tax = total.multiply(taxPercent).setScale(2, RM);
BigDecimal taxedTotal = total.add(tax).setScale(2, RM);
NumberFormat money = NumberFormat.getCurrencyInstance(); 
System.out.println("Subtotal : " + money.format(amount));
System.out.println("Discount : " + money.format(discount));
System.out.println("Total : " + money.format(total)); 
System.out.println("Tax : " + money.format(tax)); 
System.out.println("Tax+Total: " + money.format(taxedTotal));

Ahora los precios si están correctos:

Subtotal : 100,05 €
Discount : 10,00 €
Total : 90,05 €
Tax : 4,50 €
Tax+Total: 94,55 €

Para el otro caso en el que teníamos un error de precisión:

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;

RoundingMode RM = RoundingMode.HALF_EVEN;
BigDecimal amount = new BigDecimal("0.70");
BigDecimal taxPercent = new BigDecimal("0.05");
BigDecimal tax = amount.multiply(taxPercent).setScale(2, RM);
BigDecimal taxedTotal = tax.add(amount).setScale(2, RM); 

NumberFormat money = NumberFormat.getCurrencyInstance(); 
System.out.println("Subtotal: "+ money.format(amount)); 
System.out.println("Tax: " + money.format(tax)); 
System.out.println("Tax+Total: " + money.format(taxedTotal));

Subtotal: 0,70 €
Tax: 0,04 €
Tax+Total: 0,74 €

Referencia:
http://www.javamexico.org/blogs/luxspes/por_que_usar_bigdecimal_y_no_double_para_calculos_aritmeticos_financieros
http://speleotrove.com/decimal/decifaq1.html#tzeros
http://www.mkyong.com/java/how-do-calculate-monetary-values-in-java-double-vs-bigdecimal/
http://blogs.oracle.com/CoreJavaTechTips/entry/the_need_for_bigdecimal
http://stackoverflow.com/questions/7539/please-explain-the-use-of-java-math-mathcontext/7561#7561
http://en.wikipedia.org/wiki/Floating_point

Calendario Arch Linux 2012

2012-01-01T15:19:00.001+01:00

Empieza un nuevo año y una de las cosas que primero hacemos es ver y obtener un calendario para poner encima de nuestra mesa. Hace unos días vi un calendario tematizado con Ubuntu. En un rato que he sacado he tenido tiempo de crear uno basado en Arch Linux y traducido al español. Así que aquí lo tenéis listo y esperando para imprimir, construirlo y ponerlo encima de vuestra mesa. En el paquete tenéis la versión SVG, PNG y PDF (200 KiB) lo podéis obtener mediante este enlace.

Si le cogeís gusto a ~~la papiroflexia~~ los modelos de papel tal vez os interese obtener este Cheat Cube tambén para nuestra distribución. Ahora Tux y el cheat cube van a tener un nuevo compañero :). En cuanto pueda imprimirlo le saco unas fotos.

¡Que empecéis bien el año!

Referencia:
Calendarios de ubuntu para imprimir del 2012
http://spreadubuntu.org/es/node/751

Feliz navidad y próspero 2012

2011-12-23T18:56:00.000+01:00

Ha pasado un año completo para El blog de pico.dev y en febrero del 2012 este blog cumplirá el segundo aniversario. A punto de finalizar el 2011 llega el momento de hacer balance de lo que ha dado de si este año. En este 2011 he publicado 43 entradas, unas pocas menos que una media de una a la semana que me he fijado como objetivo desde hace un tiempo. Aunque aún el año no ha acabado este blog ha tenido cerca de 34.271 visitas, 25.251 visitantes y 55.280 páginas vistas, dicho así parecen muchas pero son «solo» cerca de unas 90-150 visitas diarias. Aún así son considerablemente más que el año 2010 (12.970 visitas, 9.758 visitantes y 20.946 páginas vistas) lo que es casi triplicar el tráfico del año anterior, el hecho de ir acumulando contenido en el blog se nota a medida que pasa el tiempo aunque muy lentamente. Seguro que otros blogs que publican cientos de entradas al cabo del año y tienen a varios usuarios publicando en él tienen bastantes más visitas, aunque mi objetivo no es publicar un gran número de entradas del estilo «Como instalar/actualizar el programa X por cada versión menor (X.X.1) en Ubuntu (u otra distribución)» o «Publicada la versión menor X.X.1 del programa X» que creo que aportan más bien poco sino escribir entradas que compartan alguna información más útil.

En cuanto a la temática de las entradas he escrito más sobre programación que lo que hice en el 2010 y eso creo que va a seguir siendo así aunque no dejaré de escribir de vez en cuando alguna más orientada a (Arch) Linux y software libre.

Si habéis llegado o suscrito recientemente a mi blog (y si aún no lo habéis hecho estáis invitados) os pongo aquí la hemeroteca de las entradas que he escrito durante este año:

Programación:
Unir Apache HTTPD y Tomcat mediante un reverse proxy
Enviar correos electrónicos mediante Java Mail
Implementación de un Comparator genérico en Java con ayuda de Groovy
Servidor web ligero Cherokee, instalación e integración con PHP en Arch Linux
Elegir herramientas para un proyecto Java
Instalar Symfony y Cherokee en Arch Linux
Hola mundo con Symfony 2 y Cherokee
Internacionalización a lenguajes con diferentes formas plurales en Java
Seleccionar el lenguaje (locale) según el dominio en Apache Tapestry
Comparar cadenas en Java ignorando acentos
Integración continua con Jenkins
Configuración de entorno en Java con ayuda de Groovy
Ejemplo sencillo con JavaCC de un analizador léxico y sintáctico
Formatear precios con símbolo de moneda en Java
Internacionalización (i18n) de campos con Hibernate
Convenciones para los literales en archivos .properties en Java

Tapestry:
Componente cache para Tapestry 5
Componente lista para Tapestry 5 (paginable y anidable)
Usar Apache Tapestry 5 con Groovy (u otros lenguajes de la JVM)
Motivos para elegir el framework Apache Tapestry
Peticiones Ajax en Tapestry
Peticiones Ajax en Tapestry (II)
Componente AjaxSpinner para Tapestry 5

(Arch) Linux:
Instalar Plymouth como arranque gráfico en Arch Linux
Poner en color pacman y yaourt
Obtener información del sistema en Linux (con inxi, lspci y hwinfo)
Añadir marcas de agua a imágenes con ImageMagick
Motivos para elegir la distribución Arch Linux
Personalizar GNOME (iconos, temas, extensiones, opciones)
Arte usando texto ASCII con FIGlet

Vídeo promocional sobre Arch Linux
El impuesto Windows
Como sería si Microsoft, Apple y Linux...

Otros:
Un día en la Euskal Encounter 19

Dicho lo cual solo me queda daros las gracias por ser parte de las visitas de este blog y desearos...

Referencia:
http://laventanamuerta.net/haz-llegar-la-navidad-a-tu-escritorio-con-los-fondos-navidenos-de-tux/
http://www.klowner.com/wallpaper/
http://www.youtube.com/watch?v=WdyplU0RVk8

Arte usando texto ASCII con FIGlet

2011-12-17T20:08:00.000+01:00

Seguramente hayas visto en algunos sitios una figura o texto formado por caracteres ASCII, probablemente no hayan sido creadas a mano con la inspiración de un artista, hay herramientas incluso usables desde la web que permiten generarlas. FIGlet es una de ellas que permite crear una figura ASCII a partir de un texto. Su instalción en Arch Linux es tan simple como instalar el paquete figlet con:

$ yaourt -S figlet

En la propia página de figlet podemos encontrar enlaces a varios conjuntos de fuentes a aplicar al texto que queramos generar. También podemos ver algunos ejemplos.

FIGlet tiene más opciones pero la más habitual tal vez sea indicar la fuente a usar y el mensaje del que queremos su representación en arte ASCII.

$ figlet -w 200 "El blog de pico.dev"
 _____ _   _     _                   _              _               _            
| ____| | | |__ | | ___   __ _    __| | ___   _ __ (_) ___ ___   __| | _____   __
|  _| | | | '_ \| |/ _ \ / _` |  / _` |/ _ \ | '_ \| |/ __/ _ \ / _` |/ _ \ \ / /
| |___| | | |_) | | (_) | (_| | | (_| |  __/ | |_) | | (_| (_) | (_| |  __/\ V / 
|_____|_| |_.__/|_|\___/ \__, |  \__,_|\___| | .__/|_|\___\___(_)__,_|\___| \_/  
                         |___/               |_| 

$ figlet -f letters.flf -w 200 "El blog de pico.dev"

EEEEEEE lll  bb      lll                      dd                 iii                        dd                
EE      lll  bb      lll  oooo   gggggg       dd   eee   pp pp         cccc  oooo           dd   eee  vv   vv 
EEEEE   lll  bbbbbb  lll oo  oo gg   gg   dddddd ee   e  ppp  pp iii cc     oo  oo      dddddd ee   e  vv vv  
EE      lll  bb   bb lll oo  oo ggggggg  dd   dd eeeee   pppppp  iii cc     oo  oo ... dd   dd eeeee    vvv   
EEEEEEE lll  bbbbbb  lll  oooo       gg   dddddd  eeeee  pp      iii  ccccc  oooo  ...  dddddd  eeeee    v    
                                 ggggg                   pp

Los textos ASCII generados por FIGlet nos pueden ser de utilidad en los sitios en los que solo podamos usar caracteres de texto como en correos electrónicos que no lleven formato html o en los archivos de log de una aplicación.

Referencia:
http://www.figlet.org/
http://patorjk.com/software/taag/
http://www.network-science.de/ascii/

Como sería si Microsoft, Apple y Linux...

2011-12-09T19:41:00.001+01:00

¿Como sería si Microsoft, Apple y Linux se decicasen a la industria automovilística y vendiesen motores y coches conociendo sus políticas y formas de comercializar su software y productos?

set small_troll_mode=on

Empecemos por Microsoft

Algunos modelos de sus motores son conocidos y recordados por provocar fallos en el coche que son instalados [1], algunos no más molestos como que las ruedas se desinchan de vez en cuando o el aire acondicionado no funciona a veces si a la vez tienes puesta la radio y algunos graves como que el motor se apaga de repente o deja de frenar cuando lo necesitas que provocan pequeños accidentes y pequeñas perdidas de memoria en el conductor a los que se les queda la cara de un tono azulado después de los hechos por el susto.

Aproximádamente cada segundo martes del mes [2] tienes que llevar el coche al taller para hacer una revisión de algunas partes del coche por fallos de seguridad detectados en diversas partes del mismo, no sabes muy bien que van a revisar pero oye si lo dice Microsoft por algo será. Otros problemas de seguridad conocidos y explotados por los ladrones para acceder al interior no son resueltos pasados meses e incluso años siempre a criterio de Microsoft, ellos saben lo que es importante y bueno para sus usuarios.

Los coches vienen con un montón de extras inútiles [3] que no quieres como una alerón hortera, una luces de neon en los bajos o un sistema de alarma que deja de funcionar a los 30 días si no pagas la licencia. Todo ello hace que el coche nuevo y recien salido de fábrica circule a una velocidad máxima de 80 km/h cuando debería alcanzar los 120 km/h y a veces sin ningún motivo aparente se reduzca a 50 km/h pasados unos meses.

No puedes abrir el capó del coche para para ver como es el motor, y por tanto no puedes cambiarle de aceite, la batería o algunas piezas para conseguir una mayor potencia, fiabilidad, seguridad o menor consumo de combustible.

Las administraciones públicas que tienen enormes flotas de automóviles comprados a Microsoft [4] se gastan cada año millones de euros en renovar licencias para usarlos, ya que el coche en realidad no lo compran solo les da un licencia de uso. Pueden comprar coches con motor Linux que algunos no tienen costes de licencias pero los funcionarios están acostumbrados a los coches con motor Windows, es el que usan como particulares.

Por lo visto debe de haber una forma de duplicar un motor rápidamente, las personas lo utilizan para instalarle a sus coches la última versión del motor Windows que siempre dicen trae nuevas prestaciones. Saben que esto no es legal por la licencia de uso del motor y les llaman piratas, pero a la vez Microsoft lo consiente, sabe que cuando vayan a sus trabajos sus empresas tendrán que pagar ya que no estarán acostuambrados a ningún otro tipo de motor. Sino puede obligarles a comprar la licencia como particulares al menos los convierte en adictos a sus motores, piensan que es mejor que usen uno de ellos pirateado que uno de la competencia [5], y así están los funcionarios de muchas las administraciones públicas.

En alguna ocasión el navegador GPS de Microsoft venía ya instalado en el coche junto con el motor. Sin embargo, la Unión Europera a partir de una denuncia del fabricante de navegadores Opera [6] dictaminó que esto era un abuso de posición dominante ya que impedía al resto de fabricantes de GPS colocar sus navegadores y dificultaba la libre competencia. Microsoft argumentaba que el navegador GPS era parte inseparable de su motor y que sin él en no funcionaba. Finalmente, Microsoft se vió obligada a darle al usuario la posibilidad de seleccionar su navegador GPS en una Ballot Screen [7], ya estaba escarmentada de anteriores multas por valor de 500 millones de euros por anteriores litigios [8].

Pasados 5 años, con suerte, tienes que comprar otro coche porque el que que tienes ya no puede cargar con los trastos que llevas en él, no sabes por qué ya que los utilizas para hacer lo mismo que hace 5 años solo son un poco más modernos, te han comentado que puede ser debido a la obsolescencia programada. Tal vez solo quieres la carrocería que ya tienes el motor de tu anterior coche que es antiguo pero que todavía puede funcionar en el nuevo o tal vez te plantes instalar un motor basado en Linux ya que conoces alguna distribución que te lo dá sin ningún coste, ya estas cansado de los defectos de los motores Windows, el comercial sorprendido te dirá que eso no es posible que a ellos los fabricantes de coches no les venden solo carrocerias, ya les dan el motor de Windows preinstalado y así es como lo venden, a esto algunas personas lo conocen como el impuesto Windows.

El turno de Apple

Al contrario que Microsoft, Apple no solo fabrica motores sino también la carrocería y tampoco podras adquirirlos por separado. La producción se ha deslocalizado a China ya que allí hay mano de obra más barata, abundante y los trabajadores de esas plantas tiene menos derechos laborales que los trabajadores occidentales. Sin embargo, cuando sale algún caso de que algún empleado de esas fábricas llega a suicidarse [1] por las condiciones en que se encuentra, en Apple, dicen que van a cancelar relaciones contractuales si los contratistas no ponen remedio en un intento de que el asunto no afecte a su marca [1].

Apple no fabrica coches de bajo coste, según ellos no saben hacerlo sin que sean una basura [2], (¡tragaros eso fabricantes de utilitarios PC!), asunto arreglado ya tienen una razón para vender sus coches esos precios, a pesar de utilizar las mismas piezas, son sensiblemente mas caros que los coches PC. A quien no le importa pagar el precio de un coche Mac no le importa sacar de nuevo y a menudo la tarjeta de crédito para pagar el precio que tienen sus accesorios y para pagar los añadidos de la nueva App Store, motivo por el cual esta tiene más éxito que el mismo concepto en otras marcas.

Cada cierto tiempo sacan nuevas actualizaciones para sus motores con un precio de tan solo X con 99, tipica regla comercial para fijar precios y hacer pensar a los clientes que estan pagando menos en un intento por confundirles y demostrando que no les importa contar mentiras piadosas, parece que funciona.

Tampoco puedes abrir el capo para ver como es el motor ni modificarlo ni puedes saber si te han puesto un sistema de segimiento y rastreo CarrierIQ con el que puedan conocer en que sitios has estado o analizar y recopilar información tuya sin tu consentimiento ni saber con que fines [3]. Cuando los alarmados conductores Mac se informan de la existencia de dichos dispositivos instalados en sus vehículos les comentan que en el próximo modelo dejarán de utilizarlos, prometen hacer borrón, cuenta nueva y asunto arreglado, aquí no ha pasado nada ¡estos no son los androides que andáis buscando!. Algunas personas tachadas de poco menos que locos ya advertían de que estas funciones malévolas en motores privativos podían estar presentes [4].

Dicen que sus productos son respetuosos con el medio ambiente, solo utilizan piezas que lo sean, son eléctricos e híbridos nada de utilizar la obsoleta y contaminante tecnología de combustión. Sus motores son lo último y son productos deseados, su maquinaria de marketing se encarga de hacer que asi sea. Tienen una carrocería cuidada pero solo en dos colores, negro y blanco, este último les costó sacarlo al mercado varios meses más tarde que el primero parece ser que por un problema en los focos [5].

Apple es distinta, en los lanzamientos de sus productos algunos clientes pueden pasarse una noche esperando en la puerta del concesionario a que abran al día siguiente para gastarse su dinero y comprar lo último de la marca [6]. Para que no decaiga el ánimo los empleados del concesionario los reciben con aplausos y vitores cuando entran.

Ahora Linux

Los motores Linux son libres y podrás utilizarlos con cualquier propópsito. Su licencia te da el derecho a obtener sus planos, y si tienes los conocimientos puedes estudiarlos, modificarlos y redistribuir tu mejoras con tus vecinos para ayudarles, estas son las 4 libertades básicas [1]. Algunas personas han logrado proporcionar la mayor potencia, fiabilidad, seguridad o menor consumo de combustible que no se puede hacer con motores Windows o Max OS X. Con los accesorios en su mayoría tambien libres pasa otro tanto de lo mismo.

Han demostrado su fiabilidad y ser muy versátiles y se pueden instalar además de coches, en otro tipo de vehículos como motos, camiones, barcos y aviones e incluso en micromotos como Kutxashares. Pueden utilizar no solo válvulas x86 sino también de las marcas ARM, MIPS, OpenRisc, PowerPC y otras menos conocidas [2].

No existen concesionarios Linux y no lo encontrarás en el resto de concesionarios PC, se piden por internet y en la mayoria de los casos su coste es nulo, a pesar de ello la mayoría de personas PAsan DE FOllones y se quedan con lo que les dán preinstalado aceptando sus defectos. Su negocio no se basa principalmente en vender licencias sino servicios, como RedHat, IBM y Canonical. Dado que cualquier persona puede proponer mejoras construyen comunidades, el avance conseguido por esas comunidades luego es aplicado a sus productos comerciales y el avance en los productos comerciales acaba llegando también a las comunidades de modo que todo el mundo se vea beneficiado. Alrededor de los motores Linux y sus accesorios se crean talleres mecánicos y puestos de trabajo localizados [3] con el objetivo de prestar esos servicios en su ámbito local.

El reciente concepto de App Store y Market para Apple y Microsoft es algo que ya tenian los distribuidores Linux desde hace ya mucho tiempo.

Estos motores tampoco están exentos de fallos y a veces a sus coches también se les desinchan las ruedas pero por lo general una vez conocidos son resueltos más rápidamente que en los coches Microsoft y Apple. Algunos fabricantes de accesorios mecánicos no dan soporte para estos motores y a veces no funcionan correctamente aunque los más comunes ya no suelen presentar problemas, no es como en los años 90 pero la leyenda urbana sigue extendida.

Algunas versiones de los distribuidores requieren que los usuarios monten las piezas ellos mismos como en Arch Linux y Gentoo, otros distribuidores lo ponen tan fácil o más que no tienen nada que envidiar a los coches Microsoft, es el caso de Ubuntu, Linux Mint y Fedora. Tener esta amplia variedad de modelos de motores Linux hace que a alguna gente le cueste decidirse por uno, tratan de buscar «el mejor», pero se equivocan, en Linux no hay «el mejor» quizá sí el mas adecuado para cada tipo de conductor. Para los que tienen el primer motor Linux posiblemente las opciones más adecuadas serían Ubuntu, Linux Mint, Fedora o openSUSE. Para los usuarios que ya llevan un tiempo usándolos quizá les parezca más adecuada para sus necesidades Arch Linux aunque hay muchos otros modelos [4].

Pasado el tiempo si tratas bien el coche y no lo metes por cualquier carrtera no notarás una degradación de prestaciones y funcionará a los mismos 120 km/h del primer día.

set small_troll_mode=off

Por suerte ni Microsoft, ni Apple, ni Linux se dedican a la fabricación de motores ni coches pero piensa si lo hicieran si aceptarías que instalasen en tu coche un dispositivo de seguimiento sin que te informasen de ello o si no te parecería ridículo que hubiese gente esperando una noche en la puerta de un concesionario para comprar un nuevo modelo de Renault o si tu coche recien comprado te viene con un motón de accesorios que no quieres o si... tal vez tampoco los coches y los ordenadores no sean lo mismo pero... ¿si algunas de estas cosas no las aceptarías en tu coche u otros ámbitos por que las aceptas en tu ordenador? Tú decides.

Artículos relacionados:
El impuesto Windows
De Windows a Arch Linux
Guía instalación Arch Linux (Parte I, instalación base)

Referencia:
Microsoft
[1] Buscar: Windows Millenium y Windows Vista
[2] Buscar: windows martes de parches
[3] Buscar: windows programas preinstaldos
[4] Buscar: windows administracion pública
[5] Buscar: Las versiones pirateadas de Windows frenan el avance de Linux
[6] Buscar: windows explorer denuncia opera
[7] Buscar: windows ballot screen
[8] Buscar: microsoft multa union europea

Apple
[1] Buscar: apple foxconn suicidios
[2] Buscar: apple ordenadores basura 500
[3] Buscar: apple carrieriq
[4] Buscar: richard stallman
[5] Buscar: apple iphone blanco retrasado
[6] Buscar: apple colas tiendas

Linux
[1] Buscar: libertades software libre
[2] Buscar: linux arquitecturas soportadas

[3] Buscar: empresas software libre euskadi
[4] Buscar: linux distribuciones

Convenciones para los literales en archivos .properties en Java

2011-12-02T20:11:00.001+01:00

La internacionalización (i18n) y la localización (i10n) en las aplicaciones Java ya sean de escritorio o aplicaciones web se suelen hacer a través de archivos .properties obtenidos a partir de la clase ResourceBundle que contienen los literales para cada uno de los idiomas que soporta la aplicación, a cada literal se le asocia una clave que será el medio por el cual se identificará a la hora de recuperarlos.

Un extracto de un archivo típico suele tener el siguiente aspecto:

...
#Combos
comboDepartamentos=Todos los departamentos
comboAreas=Todas las áreas
comboRepositorios=Todos los repositorios
comboAplicaciones=Todas las aplicaciones
comboModulos=Todos los módulos
comboProgramas=Todos los programas
...
#Mantenimiento de Repositorios
mr.aceptar=Aceptar
mr.buscar=Buscar
mr.cancelar=Cancelar
mr.confirmarEliminar=Los repositorios seleccionados pueden tener información relacionada que será eliminada en cascada. ¿Desea eliminar los repositorios seleccionados y la información relacionada?
mr.registroEliminado=El registro ha sido eliminado por otro usuario.
mr.validacion.nombreExiste=Existe otro repositorio con el mismo nombre.
...
#Mantenimiento de Aplicaciones
ma.aceptar=Aceptar
ma.buscar=Buscar
ma.cancelar=Cancelar
...
#Mantenimiento de Módulos
mm.aceptar=Aceptar
mm.buscar=Buscar
mm.confirmarEliminar=Los módulos seleccionados pueden tener información relacionada que será eliminada en cascada. ¿Desea eliminar los módulos seleccionados y la información relacionada?
...

Como se puede observar las claves de los literales de cada pantalla están identificados por un prefijo (mr, ma, mm) con el objetivo de agrupar los de cada pantalla, algunos no tienen prefijo como los de la sección #Combos. A los literales muy largos como mr.confirmarEliminar y mm.confirmarEliminar se les asigna una clave más corta que el propio literal y que tendremos que asignar para identificarlo.

Estas convenciones tienen algunos problemas. Uno de ellos es que hay literales que son muy comunes en la aplicación y estarán varias veces repetidos como Aceptar, Buscar, Cancelar lo que implica que los traductores tendrán que tarducirlo varias veces y a los programadores mantener mayor número de literales, además de ralentizar el trabajo ¿tiene sentido pedir a los traductores traducir el mismo literal varias veces? No. Los literales largos como mr.confirmarEliminar y mm.confirmarEliminar tienen el problema de que sus claves son poco representativas de su literal siendo vistos en el archivo de código fuente donde se use, lo que hace que leerlo sea poco significativo y representativo de los textos que luego se muestran.

Para solventar estos problemas y después de varios años de experiencia trabajando con archivos de literales en Java prefiero seguir otras convenciones. Según estas los archivos tendrían el siguiente aspecto:

...
Aceptar=Aceptar
Buscar=Buscar
Cancelar=Cancelar
...
El_registro_ha_sido_eliminado_por_=El registro ha sido eliminado por otro usuario.
Existe_otro_repositorio_con_=Existe otro repositorio con el mismo nombre.
Los_repositorios_seleccionados_pueden_tener_información_relacionada_=Los repositorios seleccionados pueden tener información relacionada que será eliminada en cascada. ¿Desea eliminar los repositorios seleccionados y la información relacionada?
...
Los_módulos_seleccionados_pueden_tener_información_relacionada_=Los módulos seleccionados pueden tener información relacionada que será eliminada en cascada. ¿Desea eliminar los módulos seleccionados y la información relacionada?
...
#Combos
Todas_las_aplicaciones=Todas las aplicaciones
Todas_las_areas=Todas las áreas
Todos_los_departamentos=Todos los departamentos
Todos_los_modulos=Todos los módulos
Todos_los_programas=Todos los programas
Todos_los_repositorios=Todos los repositorios
...

Como se puede ver para los literales cortos la clave será el propio literal en nuestro idioma nativo sin ñ o tildes, con esto al leer el archivo de código fuente sabremos cual es el texto exacto que se mostrará y no tendremos que estar inventándonos constantemente identificadores para los literales. Los literales cortos pero formados por varias palabras tendrán un «_» para representar el espacio. Las claves de los literales largos son el literal acortado con suficientes palabras para que no se repitan, les añado un «_» al final para saber que se ha acortado, el objetivo de acortarlo es que con unas cuantas palabras ya podemos hacernos una idea del texto que se muestra. Además los literales están ordenados alfabéticamente por la clave para encontrarlos más fácilmente. No digo que estas reglas no puedan tener excepciones para algunos casos pero siguiéndolas para la mayoría evitaremos que según vaya pasando el tiempo estos archivos se conviertan en un problema de mantenimiento, cuando en una aplicación tenemos 2000 o más literales, créeme, puede llegar a serlo.

Apache Tapestry 5.3 publicado (Notas de publicación)

2011-11-23T18:01:00.001+01:00

La versión 5.3 de del framework Apache Tapestry para el desarrollo de aplicaciones web dinámicas en Java ha sido publicada y así ha sido anunciada en la lista de correo. Continúa con la línea de las series 5.x e incorpora muchas novedades, mejoras y correcciones de errores, casi 350 peticiones han sido resueltas. Varias de estas nuevas características se suman a algunos Motivos para elegir el framework Apache Tapestry. Las lista de novedades es la siguiente:

Documentación
La ya buena documentación que existía ha sido mejorada y ampliada con nuevas secciones. Así tenemos un tutotial con el que los usuarios que estén empezando les resulte más fácil la tarea, incluye las herramientas a utilizar, las dependencias, como emepezar una aplicación rápidamente utilizando el archetype de maven y un par de ejemplos sencillos para empezar a hacer algo asi como usar Tapestry con Hibernate. También se ha añadido una sección de recetas sobre como hacer cosas habituales en muchas aplicaciones. También se ha añadido una sección de preguntas frecuentes y unas páginas de consulta para características de uso habitual (Application Module Class Cheat Sheet, Component Cheat Sheet).

Alertas
Tapestry ahora tiene un mecanismo central para manejar las alertas de usuario. Esto incluye el servicio AlertManager y el componente Alerts. Simplmente añade el componente Alerts a tu layout estandar y Tapestry se encarga del resto. Las alertas se pueden añadir tanto en las peticiones tradicionales como en las peticiones Ajax y pueden ser transitorias (se muestran durante unos segundos), normales o fijas (se mantienen entre peticiones hasta que el usuario las elimina expresamente haciendo clic). Las alertas pueden ser de tres severidades: info, advertencia (warn) y error. La apariencia puede ser personalizada sobreescribiendo las reglas CSS de Tapestry.

Salida de comentarios
Ahora es posible que Tapestry emita comentarios de salida. Esto son comentarios (como ) que ayudan a depurar las etiquetas de salida en la parte del cliente. Esto se habilita para todas las peticiones que usen el símbolo de configuración «tapestry.component-render-tracing-enabled» y pueden ser añadidas a cualquier petición añadiendo el parámetro «t:component-trace=true» a la URL. Esto aumenta significativamente el tamaño de las etiquetas de salida pero puede ser muy útil con layouts compejos para determinar que componente es el responsable de cada porción de la página.

Contribuciones de servicio adaptables
Al hacer contribuciones a un servicio ahora no se está limitado a contribuir un valor que sea asignable al tipo asociado con la configuración. Objetos de cualquier tipo pueden ser contribuidos y el servicio TypeCoercer será usado para transformar el valor al tipo de la configuración (Ver documentación TypeCoercer).

Mejoras en la depuración de componentes
Dada la forma en como Tapestry instrumentaba las páginas y componentes usar un depurador ha sido dificultoso con las clases de páginas y componentes, cualquier campo mutable muestra su valor por defecto en el depurador independientemente de que haya sido escrito en el campo o leído de él. En el modo desarrollo de Tapestry 5.3 los valores ocultos leen de y escriben a esos campos en los propios campos (esto también ha sido corregido en la rama de mantenimiento 5.2.5). Este ocultamiento no ocurre en el modo producción para evitar potenciales pérdidas de memorias.

Recarga deshabilitada en producción
Desde ahora no se buscan cambios en los archivos de clases, plantillas o catálogos de mensajes en el modo producción. Es asumido que las aplicaciones Tapestry son empaquetadas en archivos WAR en producción y que cambiar el archivo WAR causa que el contenedor de servlet redespliegue la aplicación entera. Este cambio mejora el rendimiento y reduce el consumo de memoria en las aplicaciones.

JavaDoc Tapestry
Tapestry ahora incluye una nueva librería , tapestry-javadoc, que reemplaza el antiguo componente de informes basado en Maven. Simplemente poniendo una anotación @tapestrydoc en el JavaDoc de los componentes Tapestry generará la documentación completa como parte del JavaDoc... no mas cambios entre el JavaDoc y el informe del componente generado por Maven y no mas dependencia en Maven para la documentación de los componentes. Los estilos del JavaDoc han sido adaptados a los colores del proyecto.

Template skinning
Tapestry añade la posibilidad de personalizar y/o tematizar («skin and/or theme») las páginas o componentes. Es una extensión de como Tapestry gestiona las páginas por locale pero añade ejes definidos por aplicación además de reglas para encontrar recursos. Ver ComponentResourceSelector y ComponentRequestSelectorAnalyzer.

También hay un nuevo componente Dynamic el cual usa una plantilla externa (no una plantilla de Tapestry) que puede ser seleccionada en tiempo de ejecución.

Mediante esta funcionalidad ahora la plantilla que se aplica para una página o componentes no solo vendrá determinado por el locale de la aplicación sino que podremos introducir más variables en la elección. Una de ellas podría ser el tipo de cliente, como por ejemplo un dispositivo móvil del que hace la petición u otros criterios para asi mostrar contenido más adaptado o personalizado.

En el siguiente enlace de puede ver una demostración de como aplicar la funcionalidad Template Skinning.

Evento de formulario cancelado
Los componentes de formulario ahora reconocen cuando el formulario de la parte cliente fue cancelado. Un nuevo evento «cancelled» es disparado al principio del proceso de envío lo cual permite a la página saltar todas las actualizaciones y validaciones en el servidor cuando sea lo deseado.

Restricciones implicitas en OrderedConfiguration
Al usar OrderedConfiguration.add() sin restricciones Tapestry ahora implicitamente ordenará el elmento añadido después del elemento añadido anteriormente dentro del mismo método. En versiones anteriores esos elementos eran añadidos sin restricciones. Esto hace más fácil contribuir un grupo de elementos relacionados con un orden implicito.

Nuevas validaciones de las clases de componente
Tapestry incluye nuevas validaciones de clases de componente para ayudar a reducir algunos errores comunes. Ahora comprueba que los componentes referenciados por un manejador de eventos concuerde con un componente definido en la plantilla... esto identifica rápidamente errores tipográficos en los nombres de métodos. Esto es, si la firma de un manejador de evento es «onFormularioRegistroSubmit()» se comprueba que exista en la plantilla un componente de id «FormularioRegistro». Esta comprobación puede ser deshabilitada con un símbolo de configuración de tal modo que aplicaciones 5.2 existentes que tengan este tipo de errores todavía puedan funcionar (esto es, tendrá manejadores de eventos muertos que nunca serán invocados).

Carpeta de aplicación
Tapestry ahora puede ser configurado para ejecutarse dentro de una carpeta, lo cual puede ser útil cuando se ejecuta dentro de una aplicación web que contiene otros servlets y filtros como una forma de prevenir conflictos. En vez de ejecutarse en la raiz del contexto de la aplicación.

Mejorado el arquetipo de inicio rápido
El arquetipo de Maven ha sido actualizado y ahora muestra varias nuevas funcionalidades de uso común. Además añade soporte para Gradle (Referencia). La forma de usarlo desde la linea de comandos es:

$MAVEN_HOME/bin/mvn archetype:generate -DarchetypeCatalog=http://tapestry.apache.org/

Páginas blancas
La nueva anotación @WhitelistAccessOnly marca una página como accesible solo por una lista blanca de clientes. Las reglas para la lista son extensibles. La regla por defecto de la lista blanca es que sea accedida desde 127.0.0.1. Usa esta anotación en páginas que pueden exponer datos sensibles como paneles informativos incorporados.

Catálogo de página
Las aplicacicones Tapestry incluyen una página PageCatalog la cual lista todas las páginas cargadas de la aplicación con detalles acerca de su tiempo de construcción y número de componentes. La página requiere acceso en la lista blanca (ver en comentario anterior). Muestra alguna información que solo está disponible en el modo desarrollo. PageCatalog puede ser usada para cargar todas la páginas de la aplicación lo cual es útil para localizar problemas en las páginas... y es especialmente útil al aumentar de una versión anterior de Tapestry.

Otra página de la que podemos obtener información acerca de los servicios de la aplicación es ServiceStatus donde podremos ver el estado de los mismos.

Logging en la parte ciente JavaScript
La consola en la parte cliente Blackbird ha sido eliminada. En su lugar están los mensajes de la consola flotante combinada con el logging a la consola de Firebug o WebKit. Tapestry no captura más las excepciones de JavaScript de inicialización de modo que pueden ser informadas apropiadamente en la consola nativa. Estos cambios deberían hacer la depuración de JavaScript en el lado cliente mucho más fácil.

El informe de error es una de las cosas buenas de Tapestry. Con esta nueva versión esta característica se ha extendido a las peticiones Ajax con lo que cuando se produzca una excepción en el servidor se nos mostrará un informe en una ventana emergente con un contenido similar a las excepciones de las peticiones normales. En este screencast se puede ver en funcionamiento.

Otra lista de novedades no mencionadas en la notas de lanzamiento oficial:

Nuevos componentes
Se han añadido unos cuantos nuevos componentes al los ya presentes en el core. Estos son:

KaptchaImage / KaptchaField: Permite evitar el spam en los formularios.
Tree: componente ábol que pemite mostrar información jerárquica con nodos expandibles, contraibles y seleccionables. Es personalizable y basado en Ajax.
Checklist: componente de selección multiple consistente en diferentes checkbox.

Nueva capa de abstracción JavaScript
En estos momentos Tapestry está atado a Prototype y Scriptaculous por compatibilidad con anteriores versiones (aunque se puede utilizar perfectamente junto con otros frameworks javascript como jQuery). En un futuro la nueva capa capa de abstracción permitirá usar cualquier librería JavaScript. La transición se completará en la versión 5.4.

Soporte Ajax mejorado
La clase MiltiZoneUpdate ha sido marcada como obsoleta en favor del servicio AjaxResponseRenderer. Esta nueva clase permite actualizar una zona con el contenido de Block, Component u otro objeto capaz de ser convertido a RenderCommand. Permite además importar una librería JavaScript como parte de la respuesta Ajax y añadir una llamada a una función en el lado del cliente, útil y a veces necesario para procesar la petición Ajax correctamente.

Integración con JSR 330 (Dependency Injection for Java)
Empezando desde Tapestry 5.3 es posible usar las anotaciones que define la especificación JSR-330 en la capa de servicios de tal modo que no dependan de Tapestry.

Integración JPA2
Integración nativa con JPA2 proporcionando compatibilidad hacia atrás en futuras versiones y posibilidad de usar múltiples unidades de persistencia en la misma aplicación. Permite configurar JPA sin necesidad de XML.

Herramienta construcción, Gradle
Tapestry ha pasado de utilizar Maven a usar Gradle como herramienta de contrucción y compilación para el propio proyecto. Gradle aporta nuevas funcionalidades, simplifica otras y evita algunos de los aspectos menos deseables de Maven.

Actualización Jumpstart
Actualizada la aplicación de referencia Jumpstart a la versión 5.3 con numerosos ejemplos que muestran funcionalidades, y con la posibilidad de ver el código fuente de esos ejemplos.

Otras

Incorporación de Underscore.js que añade programación funcional a JavaScript (en modo no conflicto).
Coercion de String-a-Enum sin necesidad de hacer una contribución en el contenedor IOC.
Compresión JavaScript y CSS a través de de la librería YUICompressor library.
Más rápido y más eficiente en uso de memoria.

Cambios disruptivos

Tapestry depende ahora del Servlet API versión 2.5 con lo que la versión mínima para ejecutarlo ahora será Tomcat 6.0+.
Actualizado Prototype a la versión 1.7.
Las plantillas sin son tratadas como si tuvieran el doctype de HTML5 () pudiendose usar entidades como © o   sin ver errores de parseo de anteriores versiones.

Algunas interfaces y APIS en Tapstry 5.3 serán eliminadas en Tapestry 5.4 o posteriores. Estas incluyen:

Entorno RenderSupport (reemplazada con el entorno JavaScriptSupport).
El objeto MultiZoneUpdate, reemplazada con AjaxResponseRenderer.
El servicio ClassFactory y la interfaz ClassFab (reemplazada con el servicio PlasticProxyFactory y la interfaz PlasticClass).
La funcionalidad "suppress redirects", que permitía a los eventos de los componentes responder directamente con HTML, como en Tapestry 4.

Salvo que se usen características marcadas como obsoletas en Tapestry 5.2 en la nueva versión la actualización no requerirá más que actualizar a las nuevas dependencias.

Y una lista larga de corrección de errores y mejoras. La lista completa está en las notas de publicación de tapestry 5.3 oficiales y aquí una lista de novedades en inglés.

Referencia:
http://tapestry.apache.org/index.html
http://tapestry.apache.org/download.html
Documentación sobre Apache Tapestry
Motivos para elegir el framework Apache Tapestry

Personalizar GNOME (iconos, temas, extensiones, opciones)

2011-11-18T20:24:00.001+01:00

Una vez que tenemos instalado nuestro sistema una de las primeras cosa que solemos hacer es personalizarlo cambiando el fondo de pantalla, instalando un pack de iconos o cambiando el tema de las ventanas. Aunque GNOME con su versión 3.0 o 3.2 ha perdido algunas funcionalidades y algunas posibilidadesd de configuración la herramienta gnome-tweak-tool permite configurar las opciones más habituales que querrán la mayoría de los usuarios. Para instalarla en arch linux:

# pacman -S gnome-tweak-tool

Una vez instalada veremos su icono en el menu Aplicaciones > Accesorios > Configuración avanzada.

En la pestaña Escritorio podemos configurar algunos comportamientos como mostrar la visibilidad de los iconos Computadora, Papelera, Carpeta Home.

En Extensiones de GNOME-Shell podemos instalar nuevas extensiones que descarguemos aunque es mejor opción hacerlo con el gestor de paquetes de nuestra distribución. Hay una lista de extensiones disponibles para Arch linux que pueden instalarse individualmente y que modifican el comportamiento por defecto del shell de gnome.

En GNOME-Shell podemos personalizar la información que se muestra en el reloj, las acciones a realizar al cerrar la tapa del portátil y los botones que queremos en las ventanas.

En Tema podemos configurar los temas del puntero del ratón, iconos, tema de los componentes GTK+ y de las ventanas. Uno de los temas de iconos más conocidos es el tema faenza disponible en Arch linux en el repositorio AUR con el nombre de paquete faenza-icon-theme. Aunque temas de iconos hay muchos.

En Tipografías se pueden cambiar las fuentes y tamaños de la fuente usada en el sistema, de los documentos, en el título de la ventana y alguna otra opción.

En la opción Ventanas se pueden modificar algunos comportamientos al hacer clic en las ventanas.

La falta de configuración de la versión 3 de gnome es una de las críticas que se le ha hecho pero a medida que vaya evolucionando en versiones lo hará al mismo tiempo en funcionalidades y opciones de configuración, es cuestión de tiempo.

Yo no soy de tener una personalización extrema del escritorio prácticamente tengo con la configuración por defecto exceptuando el tema de iconos faenza.

Internacionalización (i18n) de campos con Hibernate

2011-11-11T20:52:00.001+01:00

Si estamos desarrollando un sitio web que soporta varios idiomas necesitaremos internacionalizar (i18n) los literales que aparecen en él. Esto incluye también tenerlo en cuenta y solucionarlo en los nombres, descripciones y textos que guardamos en la base de datos de las entidades de dominio y que puedan aparecer en en el html generado.

La primera solución que se nos ocurre para las entidades de dominio es crear un campo por cada idioma y concepto a internacionalizar. Sin embargo, esto tiene el problema de que en la base de datos el número de campos crecerá rápidamente y si tenemos muchos elementos a internacionalizar y muchos idiomas el número de campos puede ser un problema por el tamaño de fila, y aunque los limites en posgres y los límites de mysql son elevados y más que suficientes para la mayoría de los casos, con la solución anterior podemos llegar a ellos o estar peligrosamente cerca.

Diagrama entidad relación de base de datos
Primera solución (variación número columnas)

Para evitarnos problemas las buenas prácticas de diseño de las bases de datos dicen que las tablas han de estar normalizadas y siguiengo la solución anterior tendríamos variaciones en el número de columnas con lo que inclumpliríamos la primera forma normal (1FN). ¿Pero porque inclumplir esta forma normal puede ser un problema? Porque en el momento que tengamos que soportar un nuevo idioma deberemos modificar el esquema de la base de datos añadiendo un campo por cada concepto de las entidades que haya que internacionalizar. Y hacer esto en una base de datos que está en producción puede ser una fuente de problemas y un peligro. Además, en tablas con muchos registros (de unos cuantos miles o cientos de miles) añadir una columna puede ser muy lento pudiendo llegar a horas o más tiempo cosa que dependiendo del proyecto no es viable al poder tener que realizar paradas largas por mantenimiento.

La solución que voy a explicar a continuación es crear una tabla Diccionario la cual relacionaremos con las tablas de los datos de dominio (Producto) y una tabla Traduccion que relacionaremos con la tabla Diccionario y que contendrá las traducciones para cada idioma. La tabla Traduccion contendrá tres campos la clave primaria del diccionario, el idioma de la traduccion y el literal de la traducción propiamente dicho con lo que ya no tendremos variaciones en el número columnas. En la tabla Traduccion la clave primaria estará formada por la clave del diccionario y el campo locale. El esquema que tendríamos sería el siguiente:

Diagrama entidad relación de base de datos.
Producto-Diccionario 1:1
Diccionario-Traduccion 1:N

A primera vista la tabla Diccionario no tiene mucho sentido pero nos permitirá crear en Hibernate una clase donde podremos incluir algunos métodos de utilidad de forma que podamos acceder a las traducciones más cómodamente. Para modelar este esquema con hibernate necesitaremos las siguientes entidades de dominio, la entidad Producto, Diccionario, Traduccion y TraduccionPK (necesaria en Hibernate al tener Traduccion una clave compuesta por dos campos o columnas).

// Producto.java (Código resumido)
...

@Entity
@Table(name = "Producto")
public class Producto implements Serializable {
 ...

 @OneToOne(cascade = CascadeType.ALL)
 @JoinColumn(name = "nombre_id", nullable = true)
 private Diccionario nombre;

 @OneToOne(cascade = CascadeType.ALL)
 @JoinColumn(name = "descripcion_id", nullable = true)
 private Diccionario descripcion;

 ...
}

// Diccionario.java
package com.blogspot.elblogdepicodev.domain;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.MapKeyColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.apache.commons.lang3.StringUtils;

import com.blogspot.elblogdepicodev.misc.AppThreadLocal;

@Entity
@Table(name = "diccionario")
public class Diccionario implements Serializable {

 private static final long serialVersionUID = -1210174827995726573L;
 
 private static final int LONGITUD_TEXTO_ABREVIADO = 10;
 
 @Id
 @GeneratedValue
 private Long id;

 @OneToMany(cascade = CascadeType.ALL)
 @JoinColumn(name = "diccionario_id")
 @MapKeyColumn(name = "locale")
 private Map<String, Traduccion> traducciones;
 
 public Diccionario() {
 }
 
 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }

 public Map<String, Traduccion> getTraducciones() {
  if (traducciones == null) {
   traducciones = new HashMap<String, Traduccion>();
  }
  return traducciones;
 }

 public void setTraducciones(Map<String, Traduccion> textos) {
  this.traducciones = textos;
 }

 //
 public String getTexto() {
  return getTexto(getLocale());
 }

 public void setTexto(String texto) {
  setTexto(getLocale(), texto);
 }
 
 public String getTexto(Locale locale) {
  Traduccion t = getTraducciones().get(locale.toString());
  if (t == null) {
   return null;
  }
  return t.getTexto();
 }

 public void setTexto(Locale locale, String texto) {
  Traduccion t = getTraducciones().get(locale);
  if (t == null) {
   t = new Traduccion(this, getLocale().toString());
  }
  t.setTexto(texto);
 }

 //
 public boolean equals(Diccionario d) {
  if (d == null) {
   return false;
  }
  return getId().equals(d.getId());
 }

 @Override
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public String toString() {
  Map m = new HashMap();
  m.put("id", getId());
  m.put("texto", StringUtils.abbreviate(getTexto(), LONGITUD_TEXTO_ABREVIADO));
  return m.toString();
 }
    
 private Locale getLocale() {
  return AppThreadLocal.getPreferencias().getLocale();
 }
}

// Traduccion.java
package com.blogspot.elblogdepicodev.domain;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

import org.apache.commons.lang3.StringUtils;

import com.blogspot.elblogdepicodev.misc.Utilidades;

@Entity
@Table(name = "traduccion")
public class Traduccion implements Serializable {

 private static final long serialVersionUID = -1210174827995726573L;
 
 private static final int LONGITUD_TEXTO_ABREVIADO = 10;

 @Id
 private TraduccionPK id;

 @Column(length = 65536)
 private String texto;

 public Traduccion() {  
 }
 
 public Traduccion(Diccionario diccionario, String locale) {
  this.id = new TraduccionPK(diccionario, locale);
 }
 
 public TraduccionPK getId() {
  return id;
 }

 public void setId(TraduccionPK id) {
  this.id = id;
 }

 public String getTexto() {
  return texto;
 }

 public void setTexto(String texto) {
  this.texto = texto;
 }
 
 //
 public Locale getLocale() {
  return Utilidades.getLocale(id.getLocale());
 }

 //
 public boolean equals(Traduccion t) {
  if (t == null) {
   return false;
  }
  return getId().equals(t.getId());
 }

 @Override
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public String toString() {
  Map m = new HashMap();
  m.put("id", getId());
  m.put("locale", getId().getLocale());
  m.put("texto", StringUtils.abbreviate(getTexto(), LONGITUD_TEXTO_ABREVIADO));
  return m.toString();
 }
}

// TraduccionPK.java
package com.blogspot.elblogdepicodev.domain;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

import javax.persistence.Basic;
import javax.persistence.Embeddable;
import javax.persistence.ManyToOne;

@Embeddable
public class TraduccionPK implements Serializable {
 
 private static final long serialVersionUID = 4445136951104395835L;

 @ManyToOne
 private Diccionario diccionario;

 @Basic
 private String locale;

 public TraduccionPK() {  
 }
 
 public TraduccionPK(Diccionario diccionario, String locale) {
  this.diccionario = diccionario;
  this.locale = locale;
 }
 
 public Diccionario getDiccionario() {
  return diccionario;
 }

 public void setDiccionario(Diccionario diccionario) {
  this.diccionario = diccionario;
 }

 public String getLocale() {
  return locale;
 }

 public void setLocale(String locale) {
  this.locale = locale;
 }

 //
 public boolean equals(TraduccionPK t) {
  if (t == null) {
   return false;
  }
  return diccionario.equals(t.getDiccionario()) && getLocale().equals(t.getLocale());
 }

 @Override
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public String toString() {
  Map m = new HashMap();
  m.put("dicionario", getDiccionario().toString());
  m.put("locale", getLocale());
  return m.toString();
 }
}

// Utilidades.java
public class Utilidades {
 ...

 public static Locale getLocale(String locale) {
  String[] s = locale.split("_");
  switch (s.length) {
  case 1: {
   return new Locale(s[0]);
  }
  case 2: {
   return new Locale(s[0], s[1]);
  }
  case 3: {
   return new Locale(s[0], s[1], s[2]);
  }
  default: {
   throw new IllegalArgumentException();
  }
  } 
 }

 ...
}

Esta solución carga las traducciones para todos los idiomas de un diccionario cuando posiblemente solo necesitemos la traducción de un idioma en concreto, tal vez si no quisiésemos que se carguen todos los textos de las traducciones podríamos sacar el campo texto a otra tabla y relacionarla con la Traduccion con un id con lo que los campos de tablas nos quedarían: Traduccion (diccionario_id, locale, texto_id), Texto (id, texto). Aunque con esta última solución necesitamos lanzar una sql más por cada texto que queramos acceder.

Referencia:
http://www.hibernate.org/
http://www.postgresql.org/about/
http://dev.mysql.com/doc/refman/5.0/en/column-count-limit.html
http://es.wikipedia.org/wiki/Normalizaci%C3%B3n_de_bases_de_datos
http://support.microsoft.com/kb/283878/es

Formatear precios con símbolo de moneda en Java

2011-11-04T20:36:00.000+01:00

Si estamos desarrollando una aplicación que muestre precios y trabaje con diferentes monedas o tengamos que mostrar el precio junto con la moneda de ese precio necesitaremos un NumberFormat configurado para que nos muestre además del precio el símbolo de la moneda. Esto nos será de mucha utilidad en aplicaciones de comercio electrónico, por ejemplo, ya que evitaremos hacer concatenaciones de cadenas String y el código será más legible y fácil de mantener.

Locale locale = ...;
String simbolo = ...;

DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(locale);
dfs.setCurrencySymbol(simbolo);
String pattern = (Constantes.DIVISAS_SIMBOLO_FINAL.indexOf(simbolo) != -1) ? "#,##0.## ¤" : "¤ #,##0.##";
DecimalFormat df = new DecimalFormat(pattern, dfs);

El truco está en hacer uso de un DecimalFormatSymbols y un «¤» en el patrón de formateo. Otra cosa que también tendremos que tener en cuenta si para la moneda que vamos a mostrar el precio el símbolo se pone antes o después de él según la convención de esa moneda. Una vez tenemos el formateador de precio con el símbolo lo usamos de la siguiente forma:

float importe = 13.19;
df.format(importe);

Y obtendremos «13,19 €».

La lógica de obtener el DecimalFormat estaría muy bien tenerlo en una clase de utilidad que lo construya para poder usarlo de diferentes sitios evitando duplicar código.

¡Hola Planeta Código!

2011-10-28T20:06:00.000+02:00

Últimamente las entradas que estoy escribiendo en el blog están más orientadas a la programación entorno a la plataforma Java que a GNU/Linux aunque siempre relacionadas con el software libre o código abierto. Por ello he incluido mi blog en el agregador de Planeta Código más orientado a temas de programación.

Al igual que cuando incluí mi blog en Planeta Linux el objetivo es llegar a más lectores y si es posible recibir más visitas y comentarios en el blog. Para los que no conozcan mi blog podeís visitarlo en http://elblogdepicodev.blogspot.com. La temática del mismo es el software libre, linux, la programación y cualquier cosa que tenga que ver con la tecnología o la informática.

Algunas de las últimas entradas que he escrito en él son:

Motivos para elegir el framework Apache Tapestry
Peticiones Ajax en Tapestry (II)
Peticiones Ajax en Tapestry
Seleccionar el lenguaje (locale) según el dominio en Apache Tapestry
Usar Apache Tapestry 5 con Groovy (u otros lenguajes de la JVM)
Componente AjaxSpinner para Tapestry 5

Ejemplo sencillo con JavaCC de un analizador léxico y sintáctico
Configuración de entorno en Java con ayuda de Groovy
Comparar cadenas en Java ignorando acentos
Integración continua con Jenkins
Internacionalización a lenguajes con diferentes formas plurales en Java
Hola mundo con Symfony 2 y Cherokee
Elegir herramientas para un proyecto Java

Espero que a alguno os resulten interesantes, si es así estáis invitados a suscribiros al feed de mi blog.

Peticiones Ajax en Tapestry (II)

2011-10-21T19:59:00.000+02:00

Como comentaba en la entrada Peticiones Ajax en Tapestry para hacerlas no es necesaria ni una sola linea de javascript. En la entrada Peticiones Ajax en Tapestry expliqué como hacer una petición Ajax que actualizaba un fragmento de una página y como hacer un petición Ajax que devolviese datos en Json para ser procesados en el cliente.

Pero el soporte para las peticiones Ajax de Tapestry no se queda en esos dos casos. Otro escenario habitual en las páginas es la necesidad de actualizar más de una región de una misma página con una única petición. Para ello Tapestry proporciona la clase MultiZoneUpdate (en la versión 5.3 será desaconsejado su uso en favor del uso de AjaxResponseRenderer) que será el objeto que deberemos devolver en el método del evento que atiende la petición. Este objeto contendrá las referencias de las zonas que queremos actualzar en la página y los nuevos contenidos a mostrar en ellas, Tapestry se encargará en el cliente de actualizarlas automaticamente por nosotros sin que tengamos que hacer nada más.

Veámoslo con un ejemplo.

<t:zone t:id="usuarioZone" update="show">
    <t:if test="service.usuario">
        <span>${service.usuario.login} (<a t:id="cerrarSesion" t:type="actionlink">Cerrar sesion</a>)</span>
        <p:else><span>Invitado (<a t:type="pagelink" page="index">Iniciar sesión/Registrarse</a>)</span></p:else>
 </t:if>
</t:zone>
...
<t:zone t:id="formularioZone" update="show">
 <t:if test="!service.usuario">
  <t:form t:id="usuarioRegistradoForm" zone="datosZone">
   <t:html5textfield type="email" value="urForm.usuario" validate="required" placeholder="Usuario"/>
   <t:html5textfield type="password" value="urForm.contrasena" validate="required" placeholder="Contraseña"/><br/>    
   <t:submit t:id="usuarioRegistradoSubmit" value="Iniciar sesión" class="btn"/>
  </t:form>
 </t:if>

 <t:if test="service.usuario">
  <t:form t:id="cerrarSesionUsuarioRegistradoForm">
   ${service.usuario.login}<br/>
   <t:submit t:id="cerrarSesionUsuarioRegistradoSubmit" value="Cambiar de usuario" class="btn"/>
  </t:form>
 </t:if>
</t:zone>

Object onSubmitFromUsuarioRegistradoForm() throws IOException {
// Registrar al usuario (service.getUsuario() devolverá el objeto que representa al usuario)
...
 if (!service.getRequestGlobals().getRequest().isXHR()) {
  return null;
 }

 MultiZoneUpdate mzu = new MultiZoneUpdate("formularioZone", formularioZone.getBody()).add("usuarioZone", sesionZone.getBody());;

 return mzu;
}

En el ejemplo hay definidas dos zonas (usuarioZone, formularioZone) que son los componentes definidos con <t:zone>. Las zonas representan fragmentos de página cuyo contenido puede ser actualizado por una petición Ajax. Cuando se envía el formuario formularioZone se llama al método onSubmitFromUsuarioRegistradoForm en el cual comprobamos si la petición es una petición Ajax (service.getRequestGlobals().getRequest().isXHR()) si no lo es se actualizará toda la página pero todo seguirá funcionando, si lo es se devuelve un objeto MultiZoneUpdate y se actualizarán las zonas formularioZone y usuarioZone con el contenido de los propios componentes formularioZone y sesionZone aunque podríamos actualizarlas con el contenidos de otros componentes. Los eventos lanzados por Tapestry siguen por defecto una convención que es on[Evento]From[Componente] aunque podrímos darle el nombre que queramos si utilizamos anotaciones.

En Tapestry pasar de una aplicación no Ajax a una Ajax es muy sencillo basta insertar las zonas y en los métodos de los eventos devolver las zonas y contenidos con las que las queremos actualizar. Otro punto importante a destacar y que contribuye a facilitar la adición del soporte Ajax es que el contenido con el que se actualizan las zonas no lo tenemos que saparar en archivos individuales ni supondrá una reestructuración drástica en los archivos del proyecto como tendríamos que hacer en otros frameworks. También a destacar es que esta funcionalidad de actualizar dos fragmentos o zonas de una página no está presente en otros frameworks de por sí donde normalmente cada petición Ajax actualiza un único fragmento. El soporte en Tapestry para trabajar con Ajax es ¡sencillo y excelente!, de lo mejor que hay.

Nota: A partir de la versión 5.3 la clase MultiZoneUpdate ha sido marcada como obsoleta y la nueva clase y método a utilizar es ajaxResponseRenderer.addRender.

Referencia:
Peticiones Ajax en Tapestry
Documentación sobre Apache Tapesty

Ejemplo sencillo con JavaCC de un analizador léxico y sintáctico

2011-10-15T12:34:00.002+02:00

Hay ocasiones en que necesitamos procesar una determinada expresión, por ejemplo para hacer una búsqueda por una serie de criterios obtenidos de la misma. La forma habitual es hacerlo creando un algoritmo específico más o menos complejo según lo sea la expresión con varios splits, expresiones regulares, condiciones, bucles, etc..., que normalmente resulta en código ofuscado difícil de desarrollar, mantener, entender lo que hace y poco flexible ante cambios. Esta es la primera opción que se nos ocurre pero no es la mejor forma de hacerlo como veremos en esta entrada.

Cuando nos enfrentamos a un problema de procesar una expresión debemos tener en cuenta primeramente dos cosas: cual es su léxico (las palabras que lo forman) y su sintaxis (las reglas que definen el orden del léxico). Más tarde por otra parte para procesar la expresión necesitaremos de acciones léxicas y sintácticas que es código que se ejecutará para realizar las tareas que necesitemos al procesar la expresión.

Para facilitar la tarea existen los compiladores como resultado de la invención de los primeros lenguajes y aunque parecen algo complejo de hacer no lo son tanto como desarrollar un algoritmo específico. JavaCC es una herramienta que nos permite definir el léxico de una expresión o lenguaje, la sintaxis del mismo y las acciones léxicas y sintácticas generando posteriormente con la definción de estas cosas una serie de archivos .java con el código fuente de un analizador léxico, sintáctico y otra serie de archivos .java de utilidad para los mismos.

Supongamos que tenemos una aplicación en la que el usuario tiene una caja de búsqueda en la que puede introducir una serie de palabras separadas por espacios, en la que también puede agrupar varias palabas rodeándolas con " y también puede introducir fechas en varios formatos y con distintos separadores para el día, mes y año pudiendo especificar día, mes y año, solo mes y año, solo el mes o solo el año, por ejemplo dd.MMM.yyyy, dd/MMMM/yyyy, MMMM-dd-yyyy, MMM.yyyy, MMM, yyyy, ... Para complicarlo aún más los meses pueden estar en diferentes idiomas. Un ejemplo de expresión podría ser: «"real madrid" enero.2012 febrero.2012 fútbol» en la que intenta buscar elementos relacionados con el real madrid y fútbol y en los meses de enero o febrero de 2012.

Veamos el código fuente de nuestro pequeño compilador cuya misión sera interpretar la expresión de la mejor de las formas y devolver un objeto org.hibernate.criterion.Criterion con el que podremos hacer una búsqueda en Hibernate según los criterios de la expresión. El compilador está dividido en varias partes:

PARSER_BEGIN y PARSE_END: define el nombre de nuestro analizador e incluye métodos de utilidad (en perfecto código Java) que será incluidos en el analizador sintático sin modificar y que podremos usar desde las acciones sintácticas. Los métodos importantes de esta primera parte son los constructores (JavaCC inserta unos pero como vemos podemos definir más), el método main, buildCriterionTermino y buildCriterionFecha que construirán un Criterion cuando el analizador sintáctico detecte un término o fecha respectivamente, la misión principal de nuestro compilador. Estos métodos no tienen mayor complicación son puro código Java. (en azul).

SKIP y TOKEN: esta parte es la que define el analizador léxico con las palabras de nuestra expresión o lenguaje. Ahí están la forma de las fechas, los términos, el día, mes y año, los separadores. Básicamente son una forma de expresiones regulares para definir cada uno de ellos (en morado).

procesarQuery, procesar, termino, fecha: Son propiamente los métodos del analizador sintáctico y van a definir la sintáxis de nuestro lenguaje. procesar contiene una de las partes más importantes ya que es el punto de partida, va cogiendo los tokens proporcionados por el analizador léxico (que genera JavaCC) y determina si es una fecha, término o algo desconocido. Según lo detectado se ejecuta el bloque de código posterior que va entre {} y que constituye una acción sintáctica. Como se ve la acción sintáctica es perfecto código Java y puede usar las variables definidas en el bloque procesar como ct, ft y r. Después de procesar todos los términos de la expresión se ejecuta otra acción sintáctica que agrupa todos los Criterion recogidos en ct, cf en uno solo y que será lo que devuelve el analizador (en verde).

En la acción sintáctica de termino tenemos que tener en cuenta que el término puede ser un mes (enero, ...) por lo que se intenta procesar como una fecha con buildCriterionFecha y si devuelve algo es que se trataba de un mes sino se procesará como un termino con buildCriterionTermino.

¿Por qué se trata un elemento DESCONOCIDO? Porque sino el analizador sintáctico daría un excepción al no saber lo que es, teminaría y no devolvería nada. De esta forma conseguimos que si una expresión que no se entiende se ignore y se devuelvan al menos el resto de expresiones en el Criterion. Este será el caso de un término fecha mal expresado como «01.enero/2012» donde mezcla diferentes separadores en la misma fecha. Tal como están definidos los tokens, el analizador léxico no sabría que es.

Y eso es lo principal de nuestro compilador. No es tan complicado hacer uno como podría parecer a priori, sin duda mucho más fácil que hacer un algoritmo específico para ello incluso para una expresión tan simple como la tratada, ahora imagínate una que pueda ser como «(<expr> or (<expr>and (<expr>or <expr>) or <expr>))».

Esta es una de esas herramientas muy útilies y con la cual sabiendo usarla o al menos tener conocimiento de ella nos puede ahorrar mucho tiempo y conseguir hacer las cosas mejor. Además y dado que lo que genera como resultado son una serie de archivos .java podremos utilizarlos en cualquier entorno, como en alguna administración pública cuyo nombre no citaré aquí y en la que no esta permitido usar librerías no homologadas por ellos, dado que se trata de código fuente y que no tiene dependencias sobre otras librerías no tendremos ningún problema en usar JavaCC en casos como este.

Para compilar el compilador podemos hacerlo con ant con la siguiente tarea (también podemos utilizar los propios comandos de JavaCC):

<javacc target="src/main/java/com/blogspot/elblogdepicodev/jj/Buscador.jj"
 outputdirectory="src/main/java/com/blogspot/elblogdepicodev/jj/buscador"
    javacchome="/home/[user]/javacc-5.0"/>

Los archivos generados serían:

Buscador.java
BuscadorConstants.java
BuscadorTokenManager.java
ParseException.java
SimpleCharStream.java
Token.java
TokenMgrError.java

// Buscador.jj
options {
 STATIC = false;
}

PARSER_BEGIN(Buscador)
package com.blogspot.elblogdepicodev.jj.buscador;

import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;

import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.hibernate.type.IntegerType;
import org.hibernate.type.Type;

public class Buscador {
 private static final String[] FORMATOS_FECHAS = new String[] { 
  "d/MMM/yyyy", "d/MMMM/yyyy", "MMM/d/yyyy", "MMMM/d/yyyy", "MMM/yyyy", "MMMM/yyyy",
  "d.MMM.yyyy", "d.MMMM.yyyy", "MMM.d.yyyy", "MMMM.d.yyyy", "MMM.yyyy", "MMMM.yyyy",
  "d-MMM-yyyy", "d-MMMM-yyyy", "MMM-d-yyyy", "MMMM-d-yyyy", "MMM-yyyy", "MMMM-yyyy",
  "MMM", "MMMM", "yyyy" 
 };

 private Locale locale;

 public Buscador(Locale locale) {
  this(new StringReader(""), locale);
 }
 
    public Buscador(InputStream is, String encoding, Locale locale) {
  this(is, encoding);
                this.locale = locale;
 }
 
 public Buscador(Reader r, Locale locale) {
  this(r);
        this.locale = locale;
 }

    public static void main(String[] args) throws ParseException, TokenMgrError {
     StringBuffer sb = new StringBuffer();
     for(int i = 0; i < args.length; ++i) {
   if (i > 0) {
    sb.append(" ");
      }
   sb.append(args[i]);
     }

     Buscador parser = new Buscador(new Locale("es"));
     Criterion criterion = parser.procesarQuery(sb.toString());
     System.out.println(criterion);
 }
 
 // Utilidades
 private Criterion or(List<Criterion> criterions) {
  Criterion lhs = null;
  for (Criterion criterion : criterions) {
   if (lhs == null) {
    lhs = criterion;
   } else {
    lhs = Restrictions.or(lhs, criterion);
   }
  }
  return lhs;
 }

 private Criterion and(List<criterion> criterions) {
  Criterion lhs = null;
  for (Criterion criterion : criterions) {
   if (lhs == null) {
    lhs = criterion;
   } else {
    lhs = Restrictions.and(lhs, criterion);
   }
  }
  return lhs;
 }
 
 private Criterion buildCriterionTermino(String term) {
  List<Criterion> coincidencias = new ArrayList<Criterion>();
  
  String t = "%" + term + "%";

  coincidencias.add(Restrictions.ilike("nombre", t));
  coincidencias.add(Restrictions.ilike("ciudad", t));
  coincidencias.add(Restrictions.ilike("direccion", t));

  Criterion criterio = or(coincidencias);
  
  return criterio; 
 }
 
 private Criterion buildCriterionFecha(String term) {
  Criterion criterio = null;
  
  for (int i = 0; i < FORMATOS_FECHAS.length; ++i) {
   String formatoFecha = FORMATOS_FECHAS[i];
   SimpleDateFormat sdf = new SimpleDateFormat(formatoFecha, locale);

   // Fecha
   try {
    Date fecha = sdf.parse(term);

    Calendar calendario = Calendar.getInstance(locale);
    calendario.setTime(fecha);

    switch (i) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 6:
    case 7:
    case 8:
    case 9:
    case 12:
    case 13:
    case 14:
    case 15:
     // Día, mes, año
     criterio = Restrictions.sqlRestriction("(day({alias}.fecha) = ? and month({alias}.fecha) = ? and year({alias}.fecha) = ?)", new Object[] {
       calendario.get(Calendar.DAY_OF_MONTH), calendario.get(Calendar.MONTH) + 1, calendario.get(Calendar.YEAR) }, new Type[] { IntegerType.INSTANCE,
       IntegerType.INSTANCE, IntegerType.INSTANCE });
     break;
    case 4:
    case 5:
    case 10:
    case 11:
    case 16:
    case 17:
     // Mes, año
     criterio = Restrictions.sqlRestriction("(month({alias}.fecha) = ? and year({alias}.fecha) = ?)", new Object[] {
       calendario.get(Calendar.MONTH) + 1, calendario.get(Calendar.YEAR) }, new Type[] { IntegerType.INSTANCE, IntegerType.INSTANCE });
     break;
    case 18:
    case 19:
     // Mes
     criterio = Restrictions.sqlRestriction("month({alias}.fecha) = ?", calendario.get(Calendar.MONTH) + 1, IntegerType.INSTANCE);
     break;
    case 20:
     // Año
     criterio = Restrictions.sqlRestriction("year({alias}.fecha) = ?", calendario.get(Calendar.YEAR), IntegerType.INSTANCE);
     break;
    default:
     assert (false);
     break;
    }
   } catch (java.text.ParseException e) {
   }
   
   if (criterio != null) {
    break;
   }
  }

  return criterio;
 }
 
 private class CriterionInfo {
  public boolean isFecha;
  public Criterion criterio; 
 }
}
PARSER_END(Buscador)

SKIP : { " " | "\t" | "\n" | "\r" | "\r\n" }

TOKEN : { < #NO_SKIP : ~[" ", "\t", "\r", "\n"] > }
TOKEN : { < #SEP1 : "/" > }
TOKEN : { < #SEP2 : "." > }
TOKEN : { < #SEP3 : "-" > }
TOKEN : { < #SEP : (<sep1> | <sep2> | <sep3>) > }
TOKEN : { < #LETRA : ~[" ", "\t", "\r", "\n", "/", ".", "-"] > }
TOKEN : { < #NUM : ["0"-"9"] > }
TOKEN : { < #MES : (<letra>)+ > }
TOKEN : { < #DIA : (<num> | <num><num>) > }
TOKEN : { < #ANO : (<num><num><num><num>) > }

TOKEN : { < FECHA : (
 <dia><sep1><mes><sep1><ano> | <mes><sep1><dia><sep1><ano> | <mes><sep1><ano> | 
 <dia><sep2><mes><sep2><ano> | <mes><sep2><dia><sep2><ano> | <mes><sep2><ano> |
 <dia><sep3><mes><sep3><ano> | <mes><sep3><dia><sep3><ano> | <mes><sep3><ano> |
 <num><num><num><num>) > }
TOKEN : { < TERMINO : ("\""(~["\""])+"\"" | (<letra>)+) > }
TOKEN : { < DESCONOCIDO : (<no_skip>)+ > }

Criterion procesarQuery(String query) :
{
 Criterion criterio = null;

 ReInit(new StringReader(query));
}
{
 criterio = procesar()
 {
  return criterio;
 }
}

Criterion procesar() :
{
 List<Criterion> ct = new ArrayList<Criterion<();
 List<Criterion> cf = new ArrayList<Criterion<();

 Criterion criterio = null;
 CriterionInfo criterioInfo = null;
 Token t = null;
}
{
 (
  criterio = fecha()
  {
   if (criterio != null) {
    cf.add(criterio);
   }
   //System.out.println(criterio);
  }
 |
  criterioInfo = termino() 
  {
   criterio = criterioInfo.criterio;
   if (criterio != null) {
    if (criterioInfo.isFecha) {
     cf.add(criterio);
    } else {
     ct.add(criterio);
    }
   }
   //System.out.println(criterio);
  }
 |
  t = <desconocido>
  {
   //System.out.println(t.image);
  }
 )*
 <eof>
 {
  List<Criterion> r = new ArrayList<Criterion>();
  if (!ct.isEmpty()) {
   r.addAll(ct);
  }
  if (!cf.isEmpty()) {
   r.add(or(cf));
  }
  return (r.isEmpty())?null:and(r);
 } 
}

CriterionInfo termino() :
{
 Token t = null;
}
{
 t = <termino>
 { 
  //System.out.println(t.image);
  String term = t.image;
  CriterionInfo ci = new CriterionInfo();
   
  // Comprobar si se trata de un mes
  ci.criterio = buildCriterionFecha(term);
  
  if (ci.criterio != null) {
   ci.isFecha = true;
  } else {
   ci.isFecha = false;

   if (term.startsWith("\"") && term.endsWith("\"")) {
    term = term.substring(1, term.length() - 1);
   }
   ci.criterio = buildCriterionTermino(term);
  } 
  return ci;
 }
}

Criterion fecha() :
{
 Token t = null;
}
{
 t = <fecha>
 { 
  String term = t.image;
  return buildCriterionFecha(term);
 }
}

Referencia:
http://javacc.java.net/
http://www.lpsi.eui.upm.es/webcomp/jgperez/java/IntrodJavaCC.pdf

Configuración de entorno en Java con ayuda de Groovy

2011-10-07T17:46:00.000+02:00

Una necesidad habitual en prácticamente todas las aplicaciones y proyectos es tener una forma de poder configurar una aplicación en función del entorno en el que se vaya a ejecutar. Cosas habituales que cambian dependiendo del entorno son la configuración de logging, conexión a la base de datos, tal vez la configuración de hibernate si lo usamos, parámetros, etc... Habitualmente necesitaremos un entorno con su configuración para la máquina en la que desarrolla cada programador del proyecto que será el entorno de desarrollo, también es habitual tener un entorno de pruebas independiente del entorno de cada desarrollador y el entorno de producción que es donde se ejecuta la aplicación.

La configuración del multientorno la podemos la podemos hacer de diferentes formas, mediante archivos de propiedades, con xml u otras formas. Aqui vamos a ver como hacerlo con la ayuda de groovy de una forma sencilla sin tener que pelearnos con procesar la forma del archivo, que con xml puede llegar a ser laborioso y con archivos .properties un tanto limitado en cuanto a posibilidades.

Veámos primero lo que sería el archivo de configuración:

[
    entorno: 'desarrollo',
    
	//
	valores: [
		'valor1', 
		'valor2', 
		'valor3'
	] as String[],

	// Redefinición para configuración para entornos
    entornos: [
        desarrollo: [
		    log4j:      '/cfg/log4j-desarrollo.properties',
    		hibernate:  '/cfg/hibernate-desarrollo.cfg.xml',
		    quartz:     '/cfg/quartz-desarrollo.properties',
		],
        pruebas: [
			log4j:      '/cfg/log4j-pruebas.properties',
			hibernate:  '/cfg/hibernate-pruebas.cfg.xml',
			quartz:     '/cfg/quartz-pruebas.properties',
		],
        produccion: [
			log4j:      '/cfg/log4j-produccion.properties',
			hibernate:  '/cfg/hibernate-produccion.cfg.xml',
			quartz:     '/cfg/quartz-produccion.properties',

			valor: [
				'valor-produccion1', 
				'valor-produccion2', 
				'valor-produccion3'
			] as String[],
		]
    ]
]

El archivo de configuración es código groovy que define un mapa con una serie de propiedades y valores. La propiedad entorno indica el entorno que será usado en tiempo de ejecución por la aplicación. La propiedad entornos tiene las propiedades específicas de cada entorno. Las propiedad «valores» está definda de forma global independiente de entorno y es común para los entornos de desarrollo y pruebas pero que se redefine para el entorno de producción.

La clase Entorno nos permitirá procesar el archivo de configuración groovy y la clase Utilidades tiene unos métodos de utilidad para facilitar la tarea.

// Entorno.java
package com.blogspot.elblogdepicodev.misc;

import java.io.InputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Entorno {

	private static Logger logger = LoggerFactory.getLogger(Entorno.class);
	
	public enum Ent {
		DESARROLLO, PRUEBAS, PRODUCCION
	}
	
	public static final String PROP_LOG4J = "log4j";
	public static final String PROP_HIBERNATE = "hibernate";
	public static final String PROP_QUARTZ = "quartz";

	private static Object conf;
	private static Ent entorno;
	private static Object configuracion;
	
	public static void initialize(Object conf) throws Exception {
		initialize(conf, null);
	}
	
	public static void initialize(Object conf, Ent ent) throws Exception {
		Entorno.conf = conf;
		Entorno.entorno = (ent != null)?ent:Ent.valueOf(((String) getPropiedadGlobal("entorno")).toUpperCase());
		Entorno.configuracion = getPropiedadGlobal("entornos." + Entorno.entorno.toString().toLowerCase());
		
		logger.debug("Entorno inicializado (" + ent + ")");
	}
	
	public static Object getPropiedad(String propiedad) {
		try {
			String p = propiedad.replaceAll("\\.", "?.");
			// Ver si es una propiedad del entorno
			Object o = getPropiedadEntorno(p);
			if (o == null) {
				// No es una propiedad del entorno, ver si es una propiedad global
				o = getPropiedadGlobal(p);
			}
			return o;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	public static String getString(String propiedad) {
		return (String) getPropiedad(propiedad);
	}
	
	public static InputStream getResourceAsStream(String propiedad) {
		return (InputStream) Entorno.class.getResourceAsStream(getString(propiedad));
	}
	
	public static Ent getEntorno() {
		return entorno;
	}
	
	public static boolean isEntorno(Ent e) {
		return entorno.equals(e);
	}
	
	public static boolean isDesarrollo() {
		return isEntorno(Ent.DESARROLLO);
	}
	
	public static boolean isPruebas() {
		return isEntorno(Ent.PRUEBAS);		
	}
	
	public static boolean isProduccion() {
		return isEntorno(Ent.PRODUCCION);
	}	
	
	public static Object getPropiedadGlobal(String propiedad) throws Exception {
		return Utilidades.groovy("conf." + propiedad, Utilidades.map("conf", conf));
	}
	
	public static Object getPropiedadEntorno(String propiedad) throws Exception {
		return Utilidades.groovy("configuracion." + propiedad, Utilidades.map("configuracion", configuracion));
	}
}

// Utilidades.java
package com.blogspot.elblogdepicodev.misc;

import groovy.text.SimpleTemplateEngine;
import groovy.text.TemplateEngine;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.reflect.Type;
import java.text.MessageFormat;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;

import javax.script.Bindings;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.blogspot.elblogdepicodev.misc.Entorno.Ent;

public class Utilidades {

	private static Logger logger = LoggerFactory.getLogger(Utilidades.class);

	private static ScriptEngine engine;

	static {
		ScriptEngineManager manager = new ScriptEngineManager();
		engine = manager.getEngineByName(Constantes.GROOVY_ENGINE_NAME);
	}

	public static void initializeEntorno() throws Exception {
		initializeEntorno(null);
	}

	public static void initializeEntorno(Ent ent) throws Exception {
		StringBuffer sb = new StringBuffer();

		InputStream is = Utilidades.class.getResourceAsStream("/cfg/Configuracion.groovy");
		Reader r = new InputStreamReader(is);

		char[] b = new char[4096];
		int i = r.read(b);
		while (i != -1) {
			sb.append(b, 0, i);
			i = r.read(b);
		}
		Object configuracion = Utilidades.groovy(sb.toString(), Collections.EMPTY_MAP);
		Entorno.initialize(configuracion, ent);
	}

	public static Object groovy(String script, Map bindings) throws ScriptException {
		Bindings b = engine.createBindings();
		if (bindings != null) {
			b.putAll(bindings);
		}
		return engine.eval(script, b);
	}
}

Los métodos importantes de esta clase son el initializeEntorno de clase Utilidades que se encarga de leer el archivo de configuración, evaluarlo como una expresión groovy y pasárselo al método initialize de la clase Entorno. La llamada a initializeEntorno la haremos cuando se arranque la aplicación posiblemente en un ContextLitener si se trata de una aplicación web. Una vez tengamos en entorno inicializado podremos llamar a getPropiedad de Entorno para obtener el valor de una propiedad, este método primeramente buscará entre la propiedades específicas entorno en ejecución y si no existe en él buscará entre las propiedades globales, devolverá lo primero en lo que encuentre algo.

Con estas dos clases tenemos una solución sencilla pero a la vez muy potente de configuración de entornos. Dado que las propiedades las estamos de definiendo con groovy las propiedades devueltas no será solo datos String que luego tendremos que parsear en nuestra aplicación sino que con la ayuda de groovy las propiedades devueltas podrán ser objetos, Double, Long, Date, listas, mapas, etc .... Y esta no es la unica forma de definir el archivo de configuración podríamos hacer que fuese un objeto en vez de un mapa de propiedades y podríamos definir métodos con alguna lógica y llamarlos al obtener una propiedad. ¡Las posibilidades son muchas para estas pocas líneas de código!

Peticiones Ajax en Tapestry

2011-09-30T18:59:00.002+02:00

Tapestry posee un excelente soporte para trabajar con Ajax incluso llegando al punto de no ser necesario escribir ni una sola línea de javascript para hacer este tipo de peticiones. Aquellos componentes de Tapestry que poseen el parámetro zone (como por ejemplo ActionLink, EventLink o Form, ...) permiten actualizar un fragmento de la página (o varios a la vez) mediante una petición Ajax. Además de utilizar un componte que posea un parámetro zone hay que definir las zonas, mediante el componente Zone, que pueden ser actualizadas.

En el ejemplo Ajax ActionLink de la aplicación demostración Jumpstart puede verse un ejemplo en funcionamiento de actualización de un fragmento de la página, tambien puede verse el código fuente de los elementos implicados.

Una de las cosas que hay que destacar es lo sencillo que es pasar de una aplicación no-ajax a una ajax si esto se ajusta a lo que necesitamos, para ello basta usar los parametros zone de los componentes y definir las zonas en la propia página, hay que notar que no es necesario separar ese contenido de la zonas en otro archivo para devolverlo únicamete cuando se haga la petición ajax todo está en un único archivo y Tapestry se encarga de devolver únicamente el contenido de la zona cuando esta vaya a a ser actualizada en una petición Ajax.

El actualizar fragmentos de una página con el contenido html generado por una zona cubre la mayoría de los casos en los que es necesario trabajar con Ajax, sin embargo, en alguna ocasión podenos necesitar trabajar a más bajo nivel haciendo nosotros mismos la petición Ajax y devolviendo datos en formato json en el servidor que luego procesaremos en el cliente para tratarlos, en el siguiente ejemplo se ve como es. El componente hace una petición ajax sobre el evento onGetColores del mismo al cabo de 5 segundos de cargarse la página en la que es incluido. En el cliente hace un alert para cada uno de los elementos devueltos en el evento.

//Colores.java
package com.blogspot.elblogdepicodev.tapestry.components;

import org.apache.tapestry5.ComponentResources;
import org.apache.tapestry5.MarkupWriter;
import org.apache.tapestry5.annotations.Environmental;
import org.apache.tapestry5.annotations.Import;
import org.apache.tapestry5.ioc.annotations.Inject;
import org.apache.tapestry5.json.JSONArray;
import org.apache.tapestry5.services.javascript.JavaScriptSupport;

@Import(library = { "Colores.js" })
public class Colores {

    @Environmental
    private JavaScriptSupport javaScriptSupport;
    
    @Inject
    private ComponentResources componentResources;

    Object onGetColores() {
 return new JSONArray("Rojo", "Verde", "Azul", "Negro");
    }

    protected void afterRender(MarkupWriter writer) {
 String link = componentResources.createEventLink("getColores").toAbsoluteURI();
        
 JSONObject spec = new JSONObject();
 spec.put("link", link);

        javaScriptSupport.addInitializerCall("colores", spec);
    }
}

// Colores.js
function Colores(spec) {
 this.link = spec.link;

 var sthis = this;
 setTimeout(function() { sthis.getColores(); }, 5000);
}
Colores.prototype.getColores = function() {
 $j.ajax({
  url: this.link,
  success: function(data) {
                    $j.each(data, function(index, color) { 
                        alert(color); 
                    });
                }
 });
}

Tapestry.Initializer.colores = function(spec) {
 new Colores(spec);
}

El javascript del ejemplo utiliza la librería jQuery para hacer la petición Ajax y la referencia a ella con la etiqueta script habría que incluirlo en la página, $j es una variable con una referencia a ella.

Todo realmente sencillo, en la mayoría de los casos no será necesario que trabajemos a bajo nivel con las peticiones Ajax. Otra cosa más que hace que trabajar con Tapestry sea muy agradable.

Referencia:
Documentación sobre Apache Tapestry
Peticiones Ajax en Tapestry (II)
http://tapestry.apache.org/ajax-and-zones.html
http://tapestry.apache.org/javascript.html
http://jumpstart.doublenegative.com.au/home.html
http://jumpstart.doublenegative.com.au/jumpstart/

Comparar cadenas en Java ignorando tildes

2011-09-23T19:32:00.001+02:00

A veces es necesario comparar cadenas de texto (String) para realizar ordenaciones de elementos. Pero en esta tarea aparentemente sencilla probablemente necesitemos ignorar mayúsculas y minúsculas y las palabras con tildes en el caso del Español y si necesitamos la misma funcionalidad de ordenación en otros idiomas aún se puede complicar más ya que pueden utilizar más caracteres que pueden presentar problemas (ã, ä, å, â, æ, mapa de caracteres). Una solución que se suele aplicar habitualmente es hacer un reemplazo de esos caracteres (á, ã, ä, å, â, ...) para igualar diferentes caracteres de las cadenas (a). Pero para ello hay que conocer todos esos caracteres para cada idioma lo que puede ser un problema. Para facilitar la tarea de ordenar cadenas Java dispone de la clase Collator teniendo en cuenta ciertas reglas del idioma en concreto.

List paises = ...;
Locale locale = ...;

Collator c = Collator.getInstance(locale);
c.setStrength(Collator.PRIMARY);

Collections.sort(paises, new CollatorComparator(c));

Con una clase propia, CollatorComparator, que implementa la interfaz Comparator podemos hacer la ordenación de una lista de cadenas:

import java.util.Comparator;
import java.text.Collator;

public class CollatorComparator implements Comparator {
 
 private Collator collator;

 public CollatorComparator(Collator collator) {
  this.collator = collator;
 }

 public int compare(Object o1, Object o2) {
  return collator.compare(o1, o2);
 }

 public boolean equals(Object obj) {
  return false;
 }
}

Algo importante es la «fuerza» del comprador, que permite ajustar cuales son los caracteres que se consideran diferentes en la comparación. Disponemos de las siguientes posibilidades:

PRYMARY: Considera como distintos los distintos caracteres («a» vs «b»)
SECONDARY: Considera como distintos diferentes formas acentuadas («a» vs «á»)
TERTIARY: Considera como diferentes mayúsculas y minúsculas («a» vs «A»)
IDENTICAL: Solo se consideran idénticos («a» vs «a»)

Referencia:
java.util.Comparator
java.text.Collator
java.text.RuleBasedCollator

Componente AjaxSpinner para Tapestry 5

2011-09-09T21:09:00.000+02:00

Hoy en día las aplicaciones web que hace peticiones de forma asíncrona con AJAX son la mayoría ya que es una técnica que permite obtener únicamente los datos que se necesitan sin tener que hacer una cargar entera de la página web en el navegador. Esta técnica hace que las peticiones al devolver únicamente los datos necesarios (y no toda la página) y los recursos para procesar la petición sean menos, también hace que el resultado de las peticiones sean más pequeños con lo que el tiempo de carga también se reduce al generar menos tŕafico de red, asi mismo el usuario nota un aumento de tiempo de respuesta. También hace que en ciertos casos las aplicaciones sean más fáciles de desarrollar por no tener que tratar en el servidor en cada petición el estado concreto de cada cliente.

Por la naturaleza de las peticiones, asíncronas y ejecutandose en segundo plano, es recomendable mostrar al usuario algún tipo de notificación que informe a este de que hay una petición AJAX en curso de tal forma que pueda saber que se está haciendo algo y que se ha completado.

En el siguiente ejemplo voy a desarrollar un componente para Apache Tapestry 5 que implemente esta funcionalidad de tal forma que siempre que se esté realizando una petición AJAX se muestre un pequeño tooltip del mismo estilo del que existe en gmail o google reader pero con los puntos suspentivos finales animados (de «.» a «..» a «...» a «....» y otra vez al inicio de «.»). En la vesión 5.2 de Tapestry aún se usa prototype y las peticiones AJAX que inicia Tapestry las realiza con esta librería. Por suerte siempre que Prototype inicia una petición o alguna finaliza lanza dos eventos informando de ello. Por lo que nuestra tarea será registrar un par de funciones propias para estos dos eventos con la lógica que queremos implementar.

El código Java del componente es el siguiente, lo importante está en el método afterRender donde se genera el código javascript de inicialización que crea la instancia del objeto javascript AjaxSpinner cuando se carga la página:

package com.blogspot.elblogdepicodev.tapestry.components;

import org.apache.tapestry5.ComponentResources;
import org.apache.tapestry5.MarkupWriter;
import org.apache.tapestry5.annotations.Environmental;
import org.apache.tapestry5.annotations.Import;
import org.apache.tapestry5.ioc.annotations.Inject;
import org.apache.tapestry5.services.javascript.JavaScriptSupport;

@Import(stylesheet = { "AjaxSpinner.css" }, library = { "AjaxSpinner.js" })
public class AjaxSpinner {

    @Environmental
    private JavaScriptSupport javaScriptSupport;
    
    @Inject
    private ComponentResources componentResources;

    protected void afterRender(MarkupWriter writer) {
        String id = componentResources.getId();

        JSONObject spec = new JSONObject();
        spec.put("id", id);
        
        javaScriptSupport.addInitializerCall("ajaxSpinner", spec);
    }
}

La plantilla del componente se encarga de generar el html con las capas que van a contener los tooltips, uno para indicar que se está realizando una petición, otro para indicar que aún está en funcionamiento si la petición tarda un rato y otro para indicar que la petición está tardando más de lo normal. Se mostrará una capa u otra dependiendo del tiempo que lleve realizandose. El código de la plantilla AjaxSpinner.tml del componente es:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<t:container xmlns:p="tapestry:parameter" xmlns:t="http://tapestry.apache.org/schema/tapestry_5_1_0.xsd" xmlns="http://www.w3.org/1999/xhtml">
<div class="ajax-spinner" id="${componentResources.id}1" t:type="@Any">
    Cargando...
</div>
<div class="ajax-spinner" id="${componentResources.id}2" t:type="@Any">
    Aún en funcionamiento. Cargando...
</div>
<div class="ajax-spinner ajax-spinner-tardando" id="${componentResources.id}X" t:type="@Any">
    Está tardando demasiado...
</div>
</t:container>

El código javascript (AjaxSpinner.js) para el componente es:

function AjaxSpinner(spec) {
	this.id = spec.id;
	this.t1 = null;
	this.t2 = null;
	this.tX = null;
	this.peZ = null;
	
	this.d1 = $j('#' + this.id + '1');
	this.d2 = $j('#' + this.id + '2');
	this.dX = $j('#' + this.id + 'X');
	
	this.d1.css('margin-left', -1 * (this.d1.width() / 2));
	this.d2.css('margin-left', -1 * (this.d2.width() / 2));
	this.dX.css('margin-left', -1 * (this.dX.width() / 2));
	
	var sthis = this;
	
	Ajax.Responders.register({
		onCreate: function() {
			sthis.clear();
			sthis.t1 = setTimeout(function() { sthis.timeout1(); }, 500);
			sthis.t2 = setTimeout(function() { sthis.timeout2(); }, 15000);
			sthis.tX = setTimeout(function() { sthis.timeoutX(); }, 45000);
			sthis.peZ = new PeriodicalExecuter(function(pe) { sthis.timeoutZ(); }, 1);
		},
		onComplete: function() {
			if (Ajax.activeRequestCount == 0) {
				sthis.clear();
			}
		}
	});
}

AjaxSpinner.prototype.timeout1 = function() {
	this.d1.show();
	this.d2.hide();
	this.dX.hide();
}

AjaxSpinner.prototype.timeout2 = function() {
	this.d1.hide();
	this.d2.show();
	this.dX.hide();
}

AjaxSpinner.prototype.timeoutX = function() {
	this.d1.hide();
	this.d2.hide();
	this.dX.show();
}

AjaxSpinner.prototype.timeoutZ = function() {
	var e = $j('div[id^=' + this.id + ']:visible');
	var t = e.html().trim();
	if (t.endsWith('....')) {
		t = t.substring(0, t.length - 3);
	} else {
		t += '.';
	}
	e.html(t);
}

AjaxSpinner.prototype.clear = function () {
	if(this.t1) clearTimeout(this.t1);
	if(this.t2) clearTimeout(this.t2);
	if(this.tX) clearTimeout(this.tX);
	if(this.peZ) this.peZ.stop();
	this.d1.hide();
	this.d2.hide();
	this.dX.hide();
}

Tapestry.Initializer.ajaxSpinner = function(spec) {
	new AjaxSpinner(spec);
}

Y los estilos CSS (AjaxSpinner.css) para dar a los tooltips el mismo aspecto que los de gmail y google reader:

div.ajax-spinner {
	display: none;
	position: fixed;
	padding: 5px;
	top: 0px;
	left: 50%;
	text-align: center;
	background-color: #fff1a8;
	border-bottom-left-radius: 5px;
	border-bottom-right-radius: 5px;
	z-index: 9999;
	vertical-align: middle;
}

div.ajax-spinner-tardando {
	background-color: #f8baba;
}

Una vez desarrollado el componente lo único que tendríamos que hacer es hacer uso del componente en la plantilla de la página donde queramos usarlo, por ejemplo:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:t="http://tapestry.apache.org/schema/tapestry_5_1_0.xsd" xmlns:p="tapestry:parameter">
<head>
    <title>${titulo}</title>

    <link rel="stylesheet" type="text/css" href="http://fonts.googleapis.com/css?family=Ubuntu:regular,italic,bold,bolditalic"></link>
    <link t:type="any" rel="shortcut icon" href="context:/images/favicon.ico"></link>
    <meta name="description" content="${message:descripcion-app}"/>
    <meta name="keywords" content="${message:keywords-app}"/>
    
    <t:extension-point id="head">
    </t:extension-point>
</head>
<body>
    <t:ajaxspinner t:id="principal"/>

    <div class="body">
        <t:extension-point id="cabecera">
        </t:extension-point>
        
        <t:extension-point id="menu">
        </t:extension-point>
        
        <t:extension-point id="cuerpo">
        </t:extension-point>

        <t:extension-point id="pie">
        </t:extension-point>
    </div>
</body>

El resultado cuando se hace un petición AJAX que tarda bastante tiempo es:

Tal vez te preguntes... ¿solo hace falta poner <t:ajaxspinner t:id="principal"/> para usarlo? ¿y el archivo .js con el código javascript no hay que meterlo en el head de la plantilla? ¿y la instanciación del AjaxSpinner en javascript? ¿y el CSS tampoco hay que meterlo en el head? No, no hace falta saber que el componente hace uso de un archivo de javscript ni la hora de estilos que necesita ni saber como se inicializa de eso ya tiene conocimiento tapestry por la definición del componente (mediante la anotación Import) y se encarga de incluir todo y de hacerlo eficientemente agregando el contenido de los archivos en uno solo. También el propio componente se encarga de generar el código javascript que necesita para inicalizarse.

Esta es una de las grandes características de los componentes tapestry ya que como véis lo único que hace falta es usarlo y pasarle los parametros necesarios (aunque en esta caso no tiene ninguno), no hace falta saber como funciona internamente, los estilos y que javascript necesita. Los componentes de tapestry permite abstraernos enormemente de sus detalles y eso es bueno, muy bueno ¿no crees?.

Referencia:
Documentación sobre Apache Tapestry

Integración continua con Jenkins

2011-09-02T20:16:00.001+02:00

Jenkins es una herramienta de integración continua (CI) que permite realizar tareas periódicas y automáticamente como generar el archivo del proyecto o ejecutar los casos de prueba. Usar una herramienta de integración contínua tiene varios beneficios como detectar problemas de forma temprana haciendo que sean más fáciles de resolver y automatizar procesos repetitivos que nos liberan de tiempo. Todo ello en un entorno independiente de los de desarrollo.

Su instalación y uso es muy sencillo basta con descargar u archivo .war y arrancarlo con:

java -jar jenkins.war

O desplegarlo en un contenedor de aplicaciones como Tomcat ya que es una aplicación web java. Su configuración se puede hacer completamente desde la interfaz de usuario que proporciona. Algunas otras características de Jenkins son:

- Puede proporcionar el conjunto de cambios realizados en un commit al repositorio de control de versiones como CVS/Subversion.
- Proporciona enlaces permanentes para porder utilizarlos en otras herramientas.
- Tiene nitificiones por RSS, correo electrónico y mensajería instantánea.
- Informes de las pruebas JUnit y TestNG.
- Puede distribuir las compilaciones y pruebas entre varias máquinas.
- Y una de sus mejores características, el soporte para plugins que le añaden funcionalidades. Y hay un montón de ellos para diversas tareas.

Jenkins no necesita una base de datos para funcionar lo que simplifica su configuración pero necesita guardar datos y lo hace por defecto en el directorio ~/.jenkins. Para actualizar a una nueva versión de jenkins basta con reeemplazar el archivo jenkins.war por el nuevo. Para hacer una copia de seguridad de los datos o copiarlos a otra máquina basta con copiar el directorio ~/.jenkins.

Nada más arrancar Jenkins y acceder con el navegador a la dirección http://localhost:8080/jenkins veremos la siguiente página:

Vamos a ver como configurar una tarea para sea ejecutada por jenkins cada cierto tiempo y vamos a ver como instalar un plugin, en concreto el plugin de git.

Para crear una tarea que haga el trabajo que queramos pulsaremos el enlace «Crear nueva Tarea», le daremos un nombre a la tarea y seleccionaremos la opción «Crear un proyecto de estilo libre». Al configurar la tarea veremos un montón de opciones pero por suerte de cada una de ellas tiene una «?» con la que podremos obtener ayuda. Algunas importantes son la configuración para que jenkins obtenga el código fuente de la aplicación. El apartado de disparadores de las ejecuciones por una expresión cron o por consulta de repositorio de control de versiones. El apartado de Ejecutar para lanzar la tarea que deseemos. Y las acciones que queramos que haga jenkins despues de ejecutar la tarea como enviar correos electrónicos o ejecutar otros proyectos. En la captura de pantalla he configurado una tarea (o proyecto) para que se ejecute cada minuto lanzando el comando date del sistema (en este caso de un sistema Linux).

Una vez que la tarea (o proyecto) se lanza en la opción Salida de consola podemos ver la salida de la tarea lanzada, muy util si queremos ver que ha sucedido en ella.

Para instalar el plugin de git basta ir al apartado «Administrar Jenkins > Administrar Plugins > Todos los plugins» marcar el de git, pulsar el botón instalar al final de la página y reiniciar jenkins.

En la pantalla de Panel de control podemos obtener en laces a fuentes RSS de los proyectos fallidos, de los más recientes o de todos los trabajos para recibir notificaciones por esta vía.

Usar una herramienta continua como jenkins además de las ventajas que ya de por si aporta con la integración continua es motivador para el equipo de desarrollo ya que en cierta forma le obliga a conseguir que la última ejecución de las tareas sea en todo momento correcto. Es una de esas herramientas imprescindibles a usar en cualquier proyecto.

Referencia:
http://en.wikipedia.org/wiki/Continuous_integration
http://jenkins-ci.org/
https://wiki.jenkins-ci.org/display/JENKINS/Meet+Jenkins
https://wiki.jenkins-ci.org/display/JENKINS/Use+Jenkins
https://wiki.jenkins-ci.org/display/JENKINS/Extend+Jenkins
https://wiki.jenkins-ci.org/display/JENKINS/Containers

Motivos para elegir el framework Apache Tapestry

2011-08-19T19:21:00.000+02:00

En el mundo del desarrollo web en el entorno Java hay muchos frameworks disponibles en los que elegir (JSP/Servlets, Struts, Grails, Wicket, Play, Seam, ... Tapestry y varios más), a veces la elección del framework más adecuado para el desarrollo del proyecto que tenemos por delante no suele ser una decisión sencilla y no solo intervienen decisiones técnicas sino también los conocimientos y predisposición de aprender que tenga el equipo que vaya a desarrollarlo. Lo que está claro es que si el proyecto es más o menos complejo o va a necesitar mantenimiento nadie se plantea desarrollarlo directamente con JSP y Servlets.

En la siguiente entrada voy a tratar de explicar algunas características y dar algunos motivos y razones por los que deberías tener en cuenta el framework Apache Tapestry.

Componentes
La característica estrella para mi de este framework es la alta productividad y la reutilización de código que se puede conseguir con los componentes que se desarrollan en el framework ya que una vez desarrollados pueden ser usados tantas veces como se quiera a lo largo de todo el proyecto sin tener que conocer los detalles de como y que necesitan para funcionar salvo por los parámetros que recibe. Esta abstracción incluye los estilos y el javascript y Tapestry se encargará de agregar e incluir únicamente los necesarios en la página según la definición de los mismos.

Prácticamente en todos los proyectos hay necesidad de desarrollar una serie de funcionalidades o componentes comunes que son usados repetidas veces en el mismo o en diferentes proyectos. ¿Cuantas veces en un mismo proyecto has tenido que implementar la misma funcionalidad en páginas diferentes? ¿y cuantas veces te has tenido que pelear con sus parámetros que hay que recoger de la request en forma cruda (String) necesitando convertir su tipo correcto o transformarlo a las entidades de dominio? ¿y si tienes que hacer la misma funcionalidad en varios sitios de la misma aplicación, copias y pegas? ¿y si tienes que cambiar algo común lo tienes que hacer en todos los sitios? ¿cuanto código duplicado tienes? Está claro que tener código duplicado desperdigado en nuestra aplicación a la larga será un gran problema en el mantenimiento, pues bien, en con este framework el componente será solo uno y si tienes que hacer un cambio solo necesitarás modificarlo en un sitio. Solo tienes que pensar en cual es la funcionalidad que quieres reutilizar (en la misma o diferentes páginas) y meterla en un componente. El desarrollo orientado a componentes predispone para reutilizar código.

En frameworks como Struts y Grails se trabaja en términos de URL y parámetros en Tapestry en términos de componentes y objetos. Tapestry se encarga de convertir los parmámetros de la URL al tipo adecuado y de dejarlo en una propiedad del componente de ese tipo. Tapestry puede transformar un String a un tipo de objeto en concreto (por ejemplo una clase de dominio) y viceversa, esto es necesario ya que todo lo que se envía al navegador del usuario ha de ser un String ¿quien realiza esa transformación del objeto a String? ¿y de String al objeto cuando se vuelvan a enviar los datos al servidor? Todo esto lo hace a través de una clase que implementa la interfaz Translator o ValueEncoder.

También, cuando pasamos un parámetro a un componente es capaz de hacer las conversiones necesarias para transformar el tipo del parámetro que pasamos al tipo de parámetro del componente. En el gráfico de la documentación de conversiones se pueden ver las que hace se hacer por defecto aunque podríamos implementar una nueva si tuviesemos necesidad.

Además los componentes pueden ser empaquetados en una librería (un archivo .jar) y ser reutilizados en varios proyectos cosa que hará que el tiempo de desarrollo de los siguientes proyectos se reduzca bastante si las necesidades son parecidas. También a medida que vayamos tienendo una librería de componentes seremos más productivos en el mismo proyecto si es de larga duración o tiene mucho mantenimiento.

Pero tampoco hay que desarrollar los componentes desde cero, Tapestry ya proporciona una amplia colección de ellos listos para usar directamente o agregándolos en los nuevos que creemos y hay varias librerías de ellos desarrolladas en otros proyectos. Hay componentes para tratar campos de formularios, que permiten evaluar una condición, para recorrer una colección de elementos, para crear enlaces, para mostrar errores... también hay otros tan complejos como un grid para mostrar datos en una tabla paginada, para editar un bean o para cargar contenido en las páginas a través de AJAX y algunos otros para otras tareas.

En el componente grid que proporciona unicamente tendrás que implementar el método que será el que recupere los objetos de la base de datos ya que del resto se encargará el componente llamando a nuestro método de búsqueda con los parámetros necesarios para realizarla, como la página a mostrar. Pero hacer un nuevo componente no es nada complejo, cada componente está formado de un controlador (que es una simple clase Java POJO) y normalmente una platilla que es XHTML válido.

Otra características importante es que los componentes pueden lanzar eventos que pueden ser procesados por aquellos que los contienen, pudiendo de esta forma realizar diferentes acciones y comportamientos dependiendo del componente en el que está contenido. Esto añade más posibilidades de reutilización de los componentes.

Si desarrollamos muchos proyectos pequeños y que no tienen mucho mantenimiento podemos reutilizar los componentes que desarrollamos en un proyecto en otro, si desarrollamos uno, dos o pocos proyectos pero que tienen un gran mantenimiento podemos reutilizarlos igualmente en las funcionalidades comunes. En ambos casos de tipos de proyectos nos beneficiaremos enormemente de los componentes.

Modular y contenedor IOC integrado
Práctiamente cada funcionalidad de Tapestry puede ser modificada o extendida a través de su contenedor de inversión de control, solo hace falta hacer la contribución adecuada en el contenedor. Además, esas contribuciones no se hace en un XML sino que se hace a través de código Java con las ventajas que ello conlleva como la asistencia del compilador y la refactorización del IDE. El contenedor IOC implementa usa y pone a nuestra disposición varios de los patrones más usados como Chain of Command, Strategy Builder, Chain Builder, Shadow Builder, Pipelines, etc... Finalmente no impone un determinado framework de persistencia, de testing, de seguridad u otra cosa por lo que tendremos libertad de elegir la que más adecuado nos parezca en cada ámbito a resolver. En un mundo tan cambiante como la tecnología cuando surja esa otra nueva y brillante forma de hacer las cosas no nos veremos encadenados a una en concreto porque Tapestry nos lo exija y eso tarde o temprano pasará. ¿Quizá dentro de poco pase con hibernate y activejdbc? ¿Te gustaría estar encadenado a un framework que te imponga un modelo o framework de persistencia en concreto?

Hay plugins para las herramentas más habituales como Hibernate, String, Quartz, JFreeChart, Lucene, ... y si no existe siempre se puede hacer una integración definiendo un nuevo servicio. Como he dicho prácticamente cualquier apartado puede ser extendido o adaptado a nuestras necesidades. ¿Necesitas un validador o un objeto que convieta de un tipo a otro? No hay problema, implementa en un objeto la interfaz adecuada, configuralo en la aplicación y él se encarga de usarlo cuando sea necesario.

Tapestry no es un framework «full stack» pero eso... ¿es un defecto o una ventaja? Dependiendo del tipo de proyecto, nuestras preferencias o necesidades puede ser una cosa u otra.

Exception reporting
Otra buena característica de Tapestry es que cuando algo va mal no solo nos da la traza de la excepción que se ha producido en la consola del servidor sino que nos muestra una página con toda la información de la aplicación y de la petición realizada y que ha fallado, con lo que descubrir la causa de la excepción nos será más sencillo. ¿Te has exasperado alguna vez porque la línea que se indica en un error no se corresponde con la realidad? En el informe verás la linea exacta que ha producido la excepción y un extracto del código fuente de los componentes y los usos de unos a otros hasta llegar a la excepción, además en la traza el informe te marcará en otro color las clases que se han usado de tu aplicación. Por supuesto está pagina puede ser personalizada en un entorno de producción. En Tapestry 5.3 se ha incorporado un informe incluso para las peticiones AJAX y el autor del framework ha publicado un screencast en el que se pueden ver los informes de errores en acción.

Productividad
En caso de hacer modificaciones en las clases de los componentes, páginas y servicios o a las plantillas de los mismos los cambios se hacen efectivos inmediatamente sin tener que realizar un redespliegue de la aplicación aunque en algunos casos no nos quede más remedio que hacerlo. Aún en ese caso la aplicación tarda poco en arrancar comparado con otros frameworks. Si desarrollamos en Java podemos aprovecharnos del soporte de refactor que ofrecen los IDE. La productividad se consigue reutilizando componentes ya desarrollados y probados.

Rendimiento y escalabilidad
En las últimas versiones se han incorporado características para aumentar el rendimiento y su escalabilidad como la eliminación del pool de páginas, ahora solo hay una instancia para todas las peticiones de la aplicación, la eliminación de espacios en blanco innecesarios lo que reduce el tamaño del contenido a devolver, la compresión del contenido devuelto para reducirlo aún más y la agregación de javascripts y hojas de estilo para reducir el número de peticiones a realizar al servidor. Con estas características se consigue que la página carge más rápido en el cliente y disminuya la carga de trabajo en el servidor al realizarse menos peticiones.

Soporte localización
En otros frameworks es habitual que solo exista un bundle con las traducciones de toda la aplicación. Tapestry permite una granularidad mayor, los componentes pueden tener su propio bundle de propeties con las traducciones específicas de ese componente, además los componentes y páginas pueden tener una plantilla diferente según el locale (y a partir de la versión 5.3 podriamos tener una plantilla diferente si el cliente es un dispositivo movil u otras características que decidamos) e incluso las imágenes con textos son recursos que podrían localizarse eligiendo la adecuada según el lenguaje de la aplicación.

Validaciones
La validación de los datos de entrada de un usuario de la aplicación es una de las cosas importantes que como desarrolladores tenemos que tratar. La validaciones son muy simples de aplicar ya que se hace de forma declarativa dejando a Tapestry todo el trabajo de comprobarlas en el servidor. Además es capaz de presentar los errores al usuario en caso de que alguna haya producido algún error. Soporta la especificación JSR-303.

Políglota
¿Te gustan otros lenguajes que han aparecido recientemente y que se pueden ejecutar sobre la Java VM como Groovy o Scala? Pues con él puedes desarrollar tus componentes, páginas y servicios con el lenguaje que prefieras ya sea Java, Groovy, Scala o cualquier otro que se pueda ejecutar sobre la máquina virtual. Puedes ver un ejemplo en otra entrada que he escrito Usar Apache Tapestry 5 con Groovy (u otros lenguajes de la JVM).

Otras características
Tapestry implementa el patrón «redirect after post» que resuelve algunos problemas inherentes a las aplicaciones web o los botones atrás y adelante de los navegadores. En un artículo de theserverside, Redirect After Post, tienes una explicación más detallada de este patrón.

Además de las anteriores, y en mi opinión personal, otra es que con él realmente disfruto programando y quedo satisfecho de como queda el trabajo que realizo. ¿Se podría decir algo mejor de un framework de forma resumida?

Por supuesto no es perfecto y estas son solo unas pocas de sus características pero creo que en los aspectos importantes como la reutilización de código en base a los componentes, su modularidad, adaptabilidad y gran rendimiento, productividad y su desarrollo sencillo una vez aprendidos sus conceptos básicos considero que gana por mucha diferencia respecto a otros frameworks. Una de sus deficiencias respecto a otros frameworks (o no) como Grails y otros parecidos en otros lenguajes (PHP, Ruby) es que no proporciona un entorno tan integrado («full stack») como la posibilidad de ejecutar los teses con grails test-app o de ejecutar la aplicación grails run-app, pero esto también tiene la ventaja de que no se nos impone uno y podemos usar el que queramos y tenemos mayor control sobre lo que hacemos.

La versión actual de Tapestry es la 5.2.6 estando al versión 5.3 en estos momentos en proceso de entrar en estado beta. Los cambios que incorporará 5.3 pueden consultarse en las notas de publicación de la versión.

Si tienes curiosidad de ver algo de código de una aplicación puedes ver estas entradas: Hola Mundo con Tapestry 5, Componentes lista paginada con Tapestry y si quieres ver una aplicación funcionando puedes acceder a este Hola Mundo con Tapestry 5 que se está ejecutando en el Google App Engine. También en la aplicación JumpStart tienes un montón de ejemplos interesantes con el código fuente sobre diversas características de él, seguro te sorprende lo simple y «limpio» que es el código para las cosas que se hacen en esos ejemplos.

En la entrada Documentación sobre Tapestry puedes ver la documentación disponible que he ido recopilando por la red.

Espero que estos motivos os animen a echarle un vistazo, con que sólo uno lo hiciera ya me sentiría recompensado por haber escrito la entrada. Si es así pueden estar atentos a las entradas que escriba en mi blog ya que pretendo seguir escribiendo sobre Tapestry en él :).

Referencia:
http://mail-archives.apache.org/mod_mbox/tapestry-users/201201.mbox/%3C4F210FCA.3020801@ictjob.be%3E

Seleccionar el lenguaje (locale) según el dominio en Apache Tapestry

2011-08-11T22:54:00.005+02:00

Apache Tapestry por defecto determina el lenguaje (locale) de la aplicación por los headers que envía el navegador del usuario con sus preferencias. Si tenemos un sitio internacional con varios dominios y soportando varios lenguajes para cada país o dominio quizá nos interese más determinar el idioma del usuario por el dominio al que accede. Una de las cosas excelentes de Tapestry es que es extremadamente modular y extensible y cualquier cosa que es definida como un servicio puede ser adaptada a nuestras necesidades a través del contenedor de dependencias (IOC).

Para conseguir lo que queremos el servicio que debemos redefinir es org.apache.tapestry5.services.LocalizationSetter que es el responsable de establecer el locale según las preferencias enviadas por el usuario en la petición. Por tanto debemos desarrollar una clase con la lógica que necesitamos y que implemente esa interfaz. Pero no hace falta que la desarrollemos desde cero, podemos partir de la que usa Tapestry internamente org.apache.tapestry5.internal.services.LocalizationSetterImpl (el software libre/código abierto es genial ¿verdad?).

La parte interesante e importante que debemos redefinir es la siguiente:

	/* AppLocalizationSetter.java */
	...
	private final Request request;
                private final PersistentLocale persistentLocale;
        	private final ThreadLocale threadLocale;

                private Map&lt;String, String&gt; defaultLocales;
                ...
                public AppLocalizationSetter(Request request, PersistentLocale persistentLocale, ThreadLocale threadLocale, @Symbol(SymbolConstants.SUPPORTED_LOCALES) String localeNames, ...) {
                        ...
                        this.defaultLocales = new HashMap&lt;String, String&gt;();
                }
	...
	public boolean setLocaleFromLocaleName(String localeName) {
		boolean supported = isSupportedLocaleName(localeName);
		
		Locale supportedLocale = findClosestSupportedLocale(localeName);
		if (!localeName.trim().equals("")) {
			persistentLocale.set(supportedLocale);		
		}

		threadLocale.setLocale(supportedLocale);

		return supported;
        }
        ...
	private Locale findClosestSupportedLocale(String desiredLocale) {
		String localeName = desiredLocale;

		while (true) {
			if (isSupportedLocaleName(localeName))
				return toLocale(localeName);

			localeName = stripTerm(localeName);

			if (localeName.length() == 0)
				break;
		}
               return getDefaultLocale(desiredLocale);
	}

	private String getDomainLocale() {
		String dominio = request.getServerName();
		if (defaultLocales.get(dominio) != null) {
			return defaultLocales.get(dominio);
		}
		// Buscar el idioma según el dominio
                // ¿en una constante?
                // ¿quizá en base de datos?
		String locale = ...;
		defaultLocales.put(dominio, locale);
                return locale;
	}

	private Locale getDefaultLocale(String desiredLocale) {
                String domainLocale = getDomainLocale();
        
                if (domainLocale.equals(desiredLocale)) {
                        // El locale del dominio no está soportado
            	        return supportedLocales.get(0);
                }
        
                Locale defaultLocale = findClosestSupportedLocale(domainLocale);
        
                return defaultLocale;
	}
	...

	/* AppModule.java */
	...
	public static void bind(ServiceBinder binder) {
		binder.bind(LocalizationSetter.class, AppLocalizationSetter.class).withId("AppLocalizationSetter");
	}
	
	public static void contributeServiceOverride(MappedConfiguration configuration, @Local LocalizationSetter override) {
		configuration.add(LocalizationSetter.class, override);
	}
	...

Lo importante a modificar es la forma de encontrar un locale soportado dado un localeName e implementar el método getDomainLocale() que tendrá nuestra lógica, obteniendo el Locale a partir de dominio por el que se ha accedido a la aplicación («request.getServerName()»). La forma de hacer la correspondencia entre el dominio y Locale la podemos hacer de la mejor forma que se nos ocurra de forma simple con un mapa con los dominios como claves y los locales como valor o accediendo a una base de datos que tenga la correspondencia.

Tapestry codifica en las URLs el idioma del usuario para hacerlo persistente, esto se hace con persistentLocale.set(locale). Si el locale que se intenta establecer está soportado por la aplicación se hacer persistente para posteriores peticiones y se hace efectivo para la petición actual. Si el locale que se intenta establecer no está directamente soportado se busca uno más general soportado, esto es lo que hace el método findClosestSupportedLocale. Por ejemplo, si se intenta usar el locale «en_US» y nuestra aplicación no lo soporta pero si soporta «en» se usa este último. Finalmente, si no encuentra ninguno devuelve el del dominio con la lógica que hemos definido y si tampoco es uno de los soportados de entre los de la lista del símbolo SymbolConstants.SUPPORTED_LOCALES finalmente se usa el del defecto de la aplicación (el primero de esa lista).

Deberemos hacer las contribuciones de nuestra aplicación en AppModule.java que sobreescriben el sevicio usado por defecto en Tapestry por el sevicio con nuestra lógica.

Tapestry tiene un gran diseño y es muy flexible y adaptable, este es un ejemplo, redefiinimos el comportamiento con una nueva lógica que está localizada en una clase y puede ser fácilmente redefinida por otra en el momento que tengamos necesidad sin tener que cambiar nada de código en el resto de la aplicación salvo en el AppModule.

Referencia:
Documentación sobre Apache Tapestry

Internacionalización a lenguajes con diferentes formas plurales en Java

2011-08-05T19:39:00.000+02:00

Si desarrollamos una aplicación para diferentes lenguajes y por tanto necesitamos internacionalizarla es probable que tengamos que tener en cuenta el número de diferentes formas plurales que tengan esos lenguajes. El español tiene dos formas plurales o tipos de número (singular/1, plural/1+) pero otros lenguajes tienen más de dos formas plurales (nular/0, dual/2, trial/3, paucal/grupo reducido). Java da soporte a esta funcionalidad a través de la clase ChioceFormat aunque nos requerirá un poco más de trabajo formatear cada mensaje.

A través de la clase ChoiceFormat elegimos la cadena con la forma plural correcta, posteriormente tal vez debamos hacer sustituciones en el mensaje con un MessageFormat.

En el javadoc de ChoiceFormat viene explicado como construir un patrón para posteriormente con la cantidad de elementos seleccionar la forma plural correcta.

Estos dos pasos quedarían así:

import java.text.ChoiceFormat;
import java.text.MessageFormat;

public class Test {
    public static void main(String[] args) {
	// Construir el ChoiceFormat
        ChoiceFormat cf = new ChoiceFormat("0#Hay {0} elementos.|1#Hay {0} elemento.|1<Hay {0} elementos.");
        String m = null;
        double n = 0;

        // Obtener la forma plural
        n = -3;
        m = cf.format(n)

        // Formatear
        System.out.println(MessageFormat.format(m, n));

        n = 0.5;
        m = cf.format(n)
        System.out.println(MessageFormat.format(m, n));
        
        n = 1;
        m = cf.format(n)
        System.out.println(MessageFormat.format(m, n));

        n = 2.5;
        m = cf.format(n)
        System.out.println(MessageFormat.format(m, n));

        n = 3;
        m = cf.format(n)
        System.out.println(MessageFormat.format(m, n));
    }
}

El resultado de este programa es:

Hay -3 elementos.
Hay 0,5 elementos.
Hay 1 elemento.
Hay 2,5 elementos.
Hay 3 elementos.

Si el String que se le pasa al ChoiceFormat viniese de un archivo .properties con los mensajes de cada idioma podríamos soportar varias formas plurales cambiando los límites en el mensaje localizado. En español tendríamos un literal en un properties tal que:

elementos=0#Hay cero elementos.|1#Hay un elemento.|1<Hay algo más de un elemento.

Pero en otro idioma podríamos tener esto según las diferentes formas plurales de ese idioma:

elementos=0#Hay menos de un elemento.|1#Hay un elemento.|1<Hay algo más de un elemento.|2#Hay dos elementos||2#Hay algo más de dos elementos.|3#Hay tres o más elementos.

Hay menos de un elemento.
Hay menos de un elemento.
Hay un elemento.
Hay algo más de dos elementos.
Hay tres o más elementos.

Referencia:
http://download.oracle.com/javase/7/docs/api/java/text/ChoiceFormat.html
http://download.oracle.com/javase/7/docs/api/java/text/MessageFormat.html

Un día en la Euskal Encounter 19

2011-07-24T11:46:00.007+02:00

En estos días se está celebrando, del 22 al 25 de julio, la Euskal Encounter, uno de los enventos informáticos más importantes de Euskadi, del estado de España y según algunos uno de los mejores de parte de Europa. Así desde hace ya 19 ediciones, con en estos días exactamente 4096 puestos para los asistentes que disponen de una conexión de 20 Gb por segundo ofrecida por la mano de Euskaltel y HP.

A pesar de que se organiza en Barakaldo, al alcance de metro de ciudad en la que vivo y escasos minutos, hasta este año no había asistido a ninguna. Tenía muchas ganas de ir y vivir en primera persona lo que ahí acontecía al menos por un día, este año no lo quería dejar pasar y así ha sido. Como repaso de lo que ha dado el día (y parte de la noche) os escribo esta entrada.

El asistir me pedía tener todo preparado para que no me faltara nada, cámara de fotos, camiseta con el logo de Arch Linux para hacer promoción ;), disco duro con el mayor espacio posible por si en algún momento descargaba algo (aunque con la entrada de un día no da para disponer de conexión por suerte encontré un sitio libre) más que nada quería probar que daban de sí esos 20 Gb para todos a cada usuario, descargando con torrent se alzanzaban picos de 1 MiB/s, y también instalé el juego Battle for Wesnoth para probarlo por si tenía algún momento desocupado.

He llegado a las 10:15 momentos poco después de que se abriera el plazo para conseguir la acreditación por un día. Nada más llegar mucha gente todavía descansando, se veía muchas pantallas sin encender y muchos sitios libres, a partir de la 13:00 ya se empezaba a notar más movimiento aunque aquí el horario es muy variable según cada persona. Mucho PC, alguno con Ubuntu y también bastante Mac los cuales son fácilmente reconocibles por su logotipo de manzana. Pensaba que iba a ver más portátiles pero muchos eran ordenadores con sus buenas pantallas de 21 y 27 pulgadas con lo que debe costar cargarlos a las espaldas y algunos mods muy bien hechos. Lo primero era hacer una ronda por todo el recinto. Había principalmente gente joven de 17 a 30 años pero también había gente ya entrada en la cuerentena y cincuentena. Y sí, también se veían chicas aunque en bastante menor proporción.

Están las zonas del gamegune, donde los pros de los juegos compiten, la zona de stands donde se puede ver una exposición con objetos de películas míticas con la máscara de Darth Vader y una maqueta de la estrella de la muerte de La guerra de las galaxias, el condensador de fluzo de regreso al futuro, las garras de Pesadilla en elm street, la ropa del Scream, la espada de conan, los trajes de dune, un pedrusco de criptonita, un billete de gotham y objetos de otras películas como Terminator. Un lugar de culto para aquellos que les gustan estas películas. Hay una zona con consolas XBOX con diferentes juegos, no podía dejar pasar la oportunidad de jugar un derby entre el Athletic y la Ral Sociedad ahora que a primero hora de la mañana no había nadie ni tampoco campeonatos, lamentablemente mi poca práctica desde hace mucho tiempo en juegos me hizo perderlo, decargué mi furia repartiendo golpes con un Street Figther :). Por supuesto después de tantas horas y días delante de una pantalla no podía faltar la zona dormitorio, era como una zona de setas formada por tiendas de campaña, se veían cosas menos elaboradas como colchonetas y mantas pero seguramente para descansar unas horas suficiente. La zona de stands estaba representada por algunas compañías de hardware y modding, la tienda de la Free Software Foundation donde se podían adquirir camisetas, un retromuseo donde se podían ver varios objetos ya obsoletos y consolas antiguas funcionando con juegos y la zona ExpoSyFy donde estaban los objetos comentados de películas. También había un par de escenarios y varias pantallas gigantes.

Gamegune

Stands, zona talleres y conferencias

Zona dormitorio

ExpoSyFy

Retromuseo

Amstrad PC

Microprocesadores y tarjetas gráficas

Discos duros y sistemas operativos Linux

Tampoco falta la zona donde den la manduca donde están los comedores, cafetería y un puesto de telepizza.

La organización ha preparado para los asistentes numerosas actividades, competiciones, concursos, stands, conferencias, escena, talleres y juegos para todos los gustos e intereses que sin duda mantienen a los asistentes ocupados en todo momento. El número de fotos y vídeos que he sacado son muchos (pero menos de los que pensaba), demasiado para incluirlo todo en una entrada aún así os pongo una muestra representativa, casi completa, para que las imágenes sean ellas mismas las que os cuenten las cosas como habéis ido observando.

Competiciones en las que los profesionales se dedican a competir entre ellos en diferentes juegos como Gran Turismo 5, FIFA 211, Super Street Fighter IV Arcade, Moto GP, Counter Strike 1.6, Starcraft 2 y otros cuantos y en diferentes plataformas como XBOX 360, PS3 y PC. Los primeros clasificados obtienen incluso premios en metálico o regalos, algunos individualmente o en equipo vienen en gran medida a competir en el gamegune.

En el apartado de escena hay diferentes modalidades de creación artística desde gráficos 2D, 3D, intros, animación 3D y música. Aquí tenéis una pequeña muestra de la proyección de los trabajos realizados de Fast 3D, Wild Compo y Animación 3D.

Entre tanto fan del hardware no podrían faltar aquellos que personalizan sus equipos de manera extrema y presentan sus trabajos en los concursos de modding. También en el apartado hard pueden asistir al taller de Arduino para introducirse en esta plataforma de hardware abierta.

Los concursos son muchos Air Guitar, Futbol 3, disfraces, carrera de sacos, Libdub, Fast crimping, de disfraces, Frikitest y el ya clásico lanzamiento de CD y DVD además de algunos otros. También hay concursos dirigidos al software libre Hack it para resolver una serie de problemas, AI Contest en el que programar la inteligencia artificial de una moto del clásico juego de las motos de luz de Tron, Foss Coding en el que se plantea un problema y se ha de resolver con herramientas de software libre. La euskal cuenta con la presencia por parte de la Free Software Foundation donde se pueden adquirir camisetas.

Los mainframes no son cosa del pasado, siguen ahí y por lo visto son de mucha utilidad para tratar gran cantidad de información. Hasta ahora no había visto ninguno en persona ya que suelen estar escondidos en algún recóndito sótano. Aquí los que hacen la euskal posible.

Después de pasar muchas horas delante del ordenador a lo largo de los cuatro días hay varios talleres a los que asistir desde relacionados con juegos, hacking, mainframes, gadgets y programación de videojuegos.

El asistir a la Euskal ha sido toda una experiencia, un montón de gente con los mismos intereses y un montón de cosas por ver y hacer además de muy divertido sobre todo para los jugones aunque también se organizan cosas para programadores, artistas, .... El año que viene no se si asistiré o lo haré los cuatro días, me parece demasiado para mí pero un día puede volver a estar bien.

Seguramente haya habido muchos detalles que me he perdido pero me ha gustado mucho lo que he visto, para finalizar un vídeo que gusta bastante por aquí y por el cual puedes escuchar un Patxiiiiiiiiiiiiiiiiiiiiiiii! en cualquier momento, http://goo.gl/uy324.

Ya puedo decir que estuve allí. ¡Hasta el año que viene si se da la oportunidad!

Vídeo promocional sobre Arch Linux

2011-07-17T20:20:00.005+02:00

Después de los motivos de por qué elegir Arch Linux he hecho un pequeño vídeo que resume algunos aspectos de está fantástica distribución, para aquellos que prefieran ver en vez de leer y también para poder hacerlo llegar no solo a los que visitan mi blog sino también para aquellos que visitan youtube.

Rolling Release, KISS, número de paquetes disponibles, aplicaciones de usuario, aplicaciones para desarrollo, personalización, rapidez y ligereza, adaptación a las preferencias del usuario y su gran comunidad son algunas características que destaco de esta distribución. El vídeo es muy simple porque es mi primer vídeo, no tengo muchas capacidades gráficas, ni una gran creatividad y tampoco PiTiVI permite muchas opciones (esperemos que según vayan saliendo nuevas versiones le añadan funcionalidades y corrijan errores ya que no ha juntado bien las diapositivas) pero espero que contenga los aspectos importantes de Arch Linux, si creeís que falta o tenéis alguna aportación solo tenéis que sugerírmelo y haré lo que pueda por añadirlo. El vídeo no es definitivo y a medida que se me ocurra o me comentéis alguna modificación la iré añadiendo.

El vídeo está completamente hecho con software libre. PiTiVi, Inkscape, GIMP y por supuesto Arch Linux.

Espero que a alguien le aníme a pasarse a esta distribución, si es el caso puedes visitar las guía de instalación de Arch Linux que he escrito. Está dividida en dos partes: Instalación base y Entorno gráfico y programas.

Sin más, espero que os guste :).

Mientras estaba subiendo mi video me he encontrado con otros que me han parecido interesantes en este caso promocionando Linux (Linux, la libertad de elegir y Nosotros somos Linux ¿y tú?).

Usar Apache Tapestry 5 con Groovy (u otros lenguajes de la JVM)

2011-07-08T13:25:00.011+02:00

Una de las caracteristicas de la que presume Apache Tapestry 5 es ser poliglota. Esto significa que podemos desarrollar nuestra aplicacción no solo con el lenguaje de programación Java sino con cualquier otro que se ejecute sobre la máquina virtual, como Groovy, Scala o una mezcla de ellos, aprovechando algunas características de estos lenguajes que todavía no posee Java, como las closures y una API ampliada que hace uso de ellas y que ayuda a reducir el código de la aplicación además de hacerlo más legible. Personalmente me gusta mucho Tapestry pero también me gustan algunas características de Groovy como lenguaje, ahora juntando las dos cosas ambas se me hacen aún más interesantes y con muchas más posibilidades.

Para probar esta característica he actualizado la aplicación (ahora con Tapestry 5.2) que utilicé en una entrada anterior, Hola mundo con Tapestry 5 en el Google App Engine, en la que se puede ver la aplicación funcionando en el Google App Engine programada en Java junto con la misma versión con las páginas y componentes programada en Groovy.

Sin embargo, a decir verdad, esto no creo que sea una característica de Apache Tapestry de por si sino más bien de la máquina virtual Java ya que intuyo que la misma técnica se podría aplicar a otros frameworks. La magia consiste en la forma de compilar las clases del projecto, en vez de utilizar la tarea de Ant javac para compilar hay que utilizar groovyc.

<target name="compile">	
        <path id="compile.lib.path">
            <fileset dir="lib" includes="*.jar"/>
        </path>
        <path id="groovy.lib.path">
            <fileset dir="lib" includes="groovy-all-1.8.0.jar"/>
        </path>
		<taskdef name="groovyc" classname="org.codehaus.groovy.ant.Groovyc" classpathref="groovy.lib.path"/>

		<mkdir dir="build/classes"/>
		<!-- Compilar las clases (solo java) --> 
<!--
		<javac srcdir="src"		
			destdir="build/classes"
			source="1.5"
			classpathref="compile.lib.path"
			includeAntRuntime="false"/>
-->
		<!-- Compilar las clases java y groovy -->
		<groovyc srcdir="src" 
			destdir="build/classes"
			classpathref="compile.lib.path">
			<javac
				source="1.5"
				debug="on"/>
		</groovyc>
    </target>

En este ejemplo del componente Reloj las diferencias con Java no son muchas pero se puede ver que es código Groovy, ya que no utiliza ; para los finales de sentencia y se pueden acceder a las propiedades sin el método get. (como en el caso componentResources.id)

package com.blogspot.elblogdepicodev.tapestry.helloWorld.components

import org.apache.tapestry5.Asset
import org.apache.tapestry5.ComponentResources
import org.apache.tapestry5.MarkupWriter
import org.apache.tapestry5.annotations.Environmental
import org.apache.tapestry5.annotations.Path
import org.apache.tapestry5.annotations.SupportsInformalParameters
import org.apache.tapestry5.ioc.annotations.Inject
import org.apache.tapestry5.services.javascript.JavaScriptSupport

@SupportsInformalParameters
public class RelojGroovy {

    @Inject
    @Path("classpath:com/blogspot/elblogdepicodev/tapestry/helloWorld/components/Reloj.js")
    private Asset script

    @Environmental
    private JavaScriptSupport javaScriptSupport
    
    @Inject
    private ComponentResources componentResources

    protected void setupRender() {
        javaScriptSupport.importJavaScriptLibrary(script)
    }

    protected boolean beginRender(MarkupWriter writer) {
        def id = componentResources.id
        
        writer.element("span", "id", id)
        componentResources.renderInformalParameters(writer)
		return false
    }

    protected boolean afterRender(MarkupWriter writer) {
        def id = componentResources.id

        writer.end()
        javaScriptSupport.addScript("var %s = new Reloj('%s')", id, id)       
		return true
    }
}

Una vez compiladas las clases para la máquina virtual ya no hay diferencia entre las clases compiladas con Java y las clases compiladas con Groovy y por este motivo podemos hacer uso en Tapestry otros lenguajes además de Java. Además de compilar con groovyc lo único especial que deberemos hacer es incluir en la aplicación la librería groovy-all-1.8.0.jar para que las clases groovy funcionen correctamente.

Referencia:
Documentación sobre Apache Tapestry
Hola mundo con Tapestry 5 en el Google App Engine
Codigo fuente ejemplo Hola Mundo con Apache Tapestry 5 en Google App Engine