• Qué es un RSS?

RSS es una familia de formatos de fuentes web codificados en XML. Se utiliza para suministrar a suscriptores de información actualizada frecuentemente. El formato permite distribuir contenido sin necesidad de un navegador, utilizando un software diseñado para leer estos contenidos RSS (agregador).

• Qué es un GeoRSS?

GeoRSS es un conjunto de estándares para representar información geográfica mediante el uso de capas y está construido dentro de la familia de estándares RSS.

• Cómo convertir un RSS en GeoRSS?

Si usted no dispone de una aplicación para convertir sus RSS en GeoRSS puede utilizar Geonames para realizar dicha traducción de formato.
El “RSS to GeoRSS Converter” de Geonames busca posibles ubicaciones (sitios geogràficos) en el texto del  rss.  Si alguna ubicación geográfica relevante es encontrada, adiciona la latitud y longitud al RSS durante la codificación a GeoRSS.

• Que requiero para implementar el lector de GeoRSS utilizando Adobe Flex 3?

- Flex SDK

- Google Maps Flash API

• Donde puedo descargar el código fuente del ejemplo?

Puede descargar el código fuente desde esta ubicación.

• Que ejemplos de programación flex / actionscript  puedo encontrar en el código?

- Carga de datos en XML utilizando el objeto HTTPService

- Despliegue de datos utilizando componentes ComboBox, Datagrid e Image

- Formatear etiquetas de un ComboBox utilizando labelFunction.

- Despliegue de información HTML en el tooltip de la aplicación.

- Ejemplo básico de carga de Markers en Google Maps para Adobe Flex.

- Procesamiento de datos publicados en formatos XML, RSS y GeoRSS.

- Utilizar el servicio “Rss to GeoRSS” de Geonames con Flex y Actionscript.

• Puedo ver en línea el código fuente del ejemplo y la aplicación resultante?

A continuación puede ver tanto la aplicación como el código fuente relacionado.






Código fuente del archivo Rss.mxml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
	layout="vertical"
	applicationComplete="onComplete();" 
	creationComplete="loadSourcesService.send();">
<mx:Style>
	Application{
		background-color:#ffffff;
		paddingBottom:5; 
		paddingLeft:5;
		paddingRight:5; 
		paddingTop:5;
	}
</mx:Style>	
<mx:Script>
	<![CDATA[
		import com.google.maps.controls.ZoomControlOptions;
		import mx.collections.ArrayCollection;
		import com.google.maps.overlays.MarkerOptions;
		import com.google.maps.overlays.Marker;
		import ejemplo.HTMLToolTip;
		import mx.managers.ToolTipManager;
		import flash.net.navigateToURL;
		import mx.controls.List;
		import mx.controls.Alert;
		import mx.events.ListEvent;
		import mx.rpc.events.FaultEvent;
		import mx.rpc.events.ResultEvent;
		import com.google.maps.MapType;
		import com.google.maps.LatLng;
		import com.google.maps.controls.PositionControl;
		import com.google.maps.controls.MapTypeControl;
		import com.google.maps.controls.ZoomControl;
		import com.google.maps.Map;
		import com.google.maps.MapEvent;
 
		public var map:Map;
 
	    //se invoca en el evento 'creationComplete' 
		private function onComplete() :void{
			//configuración del tooltip para despliegue de HTML
			ToolTipManager.toolTipClass = HTMLToolTip; 
		}
 
		//Manejo de la respuesta del HTTPService loadSourcesService
		private function loadSourcesService_result(evt:ResultEvent):void {
		    var resultObj:Object = evt.result;
		    sourcesCb.dataProvider = resultObj.xml.lista.item;
		}
 
		//Iniciar el Mapa
		private function startMap(event:Event):void {
			map = new Map();
			//Key de google Maps: http://code.google.com/intl/es-ES/apis/maps/documentation/flash/
			map.key = map.key = "ABQIAAAAzP_X84EVzii7yEPHkonPNRRMdub8RYo7ePgaMtJOPXtU0LG1eBQz8J6xJi_XxLQ80ti-WlGkph7kVw";
			map.addEventListener(MapEvent.MAP_READY, onMapReady);
 
			var zoomopts:ZoomControlOptions = new ZoomControlOptions();
			zoomopts.hasScrollTrack = false;
			var zoomCtrl:ZoomControl = new ZoomControl(zoomopts);
			map.addControl(zoomCtrl);
 
			// add MapType Controller
			var mapTypeCtrl:MapTypeControl = new MapTypeControl();
			map.addControl(mapTypeCtrl);
 
			// add Position Controller
			var posCtrl:PositionControl = new PositionControl();
			map.addControl(posCtrl);
			mapContainer.addChild(map);
		}
 
		private function resizeMap(event:Event):void {
			map.setSize(new Point(mapContainer.width, mapContainer.height));
		}
 
		private function onMapReady(event:MapEvent):void {
			//setCenter:  Parámetros: Coordenada Punto Central, Nivel de Zoom, Tipo de Mapa
			map.setCenter(new LatLng(4,-73),3, MapType.NORMAL_MAP_TYPE);
			//Habilita el Zoom Continuo
			map.enableContinuousZoom();
			//Habilita el Scroll del mapa utilizando el Mouse 
			map.enableScrollWheelZoom();
		}
 
		// Se invoca cuando el usuario cambia de opcion en el combo box
		// se obtiene el rss y se pasa al HTTPService 'loadRssService'
		private function getFuenteNombre ( event: ListEvent) : void{					
			if(sourcesCb.selectedItem){
				//configura la llamada al servicio geonames que recibe como parámetro
				//la url del rss que se va a georreferenciar
				//http://www.geonames.org/rss-to-georss-converter.html
				loadRssService.url= "http://ws.geonames.org/rssToGeoRSS?feedUrl="+sourcesCb.selectedItem.url;
				loadRssService.send();
				//elimina todos los markers del mapa
				map.clearOverlays();
				rssList.dataProvider = new ArrayCollection();
			}
		}
 
		//Esta funcion se llama cuando cambia el DataGrid, tiene como objetivo
		//establecer el contenido a desplegar en la descripcion, tomandolo del xml.
		private function getPage(event: ListEvent) : void{
			var selectedEq:Object = rssList.selectedItem;
			titulo.text = rssList.selectedItem.title;
			contenido.htmlText=rssList.selectedItem.description;
			//Alert.show(rssList.selectedItem["encoded"])
			mas.visible=true;
			var latlng:LatLng = new LatLng(Number(rssList.selectedItem.lat),Number(rssList.selectedItem.long));
			//lo hace solo cuando geonames devuelva la latitud y la longitud
			if(rssList.selectedItem.lat!=undefined||rssList.selectedItem.long!=undefined){
				var marker:Marker = generateMarker(selectedEq); 
				map.setCenter(latlng , 3);	
				map.addOverlay(marker);
			}
		}
 
		private function generateMarker(item:Object ):Marker{
			//crea un objeto de tipo LatLng
				var latlng:LatLng = new LatLng(Number(item.lat),Number(item.long));				
				//tooltip del Marker  
				var markerOptions : MarkerOptions= new MarkerOptions();
			    markerOptions.tooltip = item.title;
			    var marker : Marker = new Marker( latlng, markerOptions );
				return marker;
		}
 
		//Esta funcion se llama cuando se hace click en el enlace 
		//que me envia a la pagina de la fuente, coge el campo link del xml.
		private function getUrl() : void{
			//configura el request del LinkButton con el objeto link del xml 
			var u:URLRequest = new URLRequest(rssList.selectedItem.link);
        	navigateToURL(u,"_blank");
		}
 
		//Se llama cuando hay un resultado en HTTPService loadRssService
		protected function onServiceResult(event:ResultEvent):void {
			rssList.dataProvider = event.result.rss.channel.item;
			//configura la ubicacion de la imagen con el campo image.url
			imagen.source=event.result.rss.channel.image.url;
			titulo.text = "";
			contenido.htmlText='Seleccione una Noticia';
			mas.visible=false;
		}
 
 
 
		//Se llama cuando hay un fault HTTPService loadEQService y en HTTPService loadRssService
		private function load_fault(evt:FaultEvent):void {
			Alert.show('Ocurrió un Error en el Servidor', evt.fault.faultString);
		}
 
		private function  sourcesCbLabelFunction(item:Object):String{
			return item.nombre + " ("+item.pais+")";
		}
 
	]]>
</mx:Script>
	<mx:HTTPService id="loadSourcesService"
	            url="sources.xml"
	            resultFormat="object"
	            result="{loadSourcesService_result(event);}"
	            fault="load_fault(event);"
	            showBusyCursor="true" />
 
	<mx:HTTPService id="loadRssService"
	            resultFormat="object"
	            result="onServiceResult(event);"
	            fault="load_fault(event);"
	            showBusyCursor="true" />
 
	<mx:HDividedBox width="100%" height="100%">
		<mx:Panel id="panel1" width="50%" height="100%" title="Lector de GeoRSS">
			<mx:VBox id="box"  height="100%" width="100%">
				<mx:HBox width="100%">			
					<mx:ComboBox id="sourcesCb"  textAlign="left" width="100%"  
						labelFunction="sourcesCbLabelFunction"
						change="getFuenteNombre(event)" rowCount="10"
						prompt="Seleccione una opción..." />
				</mx:HBox>
				<mx:DataGrid id="rssList" width="100%" height="100%"  change="getPage(event)">
					<mx:columns>
						<mx:DataGridColumn dataField="title" headerText="Titular" 
							dataTipField="description" showDataTips="true" />
					</mx:columns>		
				</mx:DataGrid>
			</mx:VBox>
		</mx:Panel>
		<mx:Panel  width="50%" height="100%" title="Detalle de la Noticia">
			<mx:VDividedBox width="100%" height="100%">
				<mx:VBox width="100%" height="30%">
					<mx:HBox width="100%" >
						<mx:Image id="imagen" />
						<mx:LinkButton id="mas" visible="false" label="Ver mas..." click="{getUrl()}"/>	
					</mx:HBox>
					<mx:Text id="titulo" width="100%" fontWeight="bold"/>
					<mx:Text id="contenido" width="100%"/>
				</mx:VBox>
				<mx:VBox width="100%" height="70%">
					<mx:UIComponent id="mapContainer" 
			        initialize="startMap(event);" 
			        resize="resizeMap(event)" 
			        width="100%" height="100%"/>
				</mx:VBox>
			</mx:VDividedBox>	
		</mx:Panel>
	</mx:HDividedBox>
</mx:Application>

Código fuente del archivo ejemplo/HTMLToolTip.as:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package ejemplo
{
//Esta es la clase que maneja el tooltip para que muestre el contenido
//que esta en html y no como un string.
     import mx.containers.*;  
     import mx.controls.Text;  
     import mx.controls.ToolTip;  
     import mx.core.*;  
 
     public class HTMLToolTip extends ToolTip  
     {  
         public function HTMLToolTip()  
         {    super(); }  
 
         override protected function commitProperties():void{  
             super.commitProperties();  
             textField.htmlText = text;  
         }  
     } 
}

Archivo sources.xml:

<xml>
	<lista>
		<item>
			<nombre>El Tiempo - Mundo</nombre>
			<url>http://www.eltiempo.com/mundo/rss.xml</url>
			<pais>Colombia</pais>
		</item>
		<item>
			<nombre>El Tiempo - Colombia</nombre>
			<url>http://www.eltiempo.com/colombia/rss.xml</url>
			<pais>Colombia</pais>
		</item>
		<item>
			<nombre>El Espectador</nombre>
			<url>http://www.elespectador.com/rss.xml </url>
			<pais>Colombia</pais>
		</item>
		<item>
			<nombre>El Pais - America Latina</nombre>
			<url>http://www.elpais.com/rss/feed.html?feedId=17041</url>
			<pais>España</pais>
		</item>
		<item>
			<nombre>ABC - Portada</nombre>
			<url>http://www.abc.es/rss/feeds/abcPortada.xml</url>
			<pais>España</pais>
		</item>
		<item>
			<nombre>BBC Mundo</nombre>
			<url>http://www.bbc.co.uk/mundo/index.xml</url>
			<pais>Inglaterra</pais>
		</item>
		<item>
			<nombre>CNN - World</nombre>
			<url>http://rss.cnn.com/rss/edition_world.rss</url>
			<pais>Estados Unidos</pais>
		</item>
		<item>
			<nombre>Reuters - World News</nombre>
			<url>http://feeds.reuters.com/reuters/worldNews</url>
			<pais>Estados Unidos</pais>
		</item>
		<item>
			<nombre>BusinessWeek.com</nombre>
			<url>http://rss.businessweek.com/bw_rss/bwdaily</url>
			<pais>Estados Unidos</pais>
		</item>
		<item>
			<nombre>Google News</nombre>
			<url>http://news.google.com/news?output=rss</url>
			<pais>Alemania</pais>
		</item>
</lista>
</xml>

En el siguiente archivo Groovy Examples pueden encontrarse algunos ejemplos básicos de programación utilizando el lenguaje Groovy.
Entre otros pueden encontrarse los siguientes ejemplos:

• En el archivo _1_Hello hay una introduccion a la definicion de variables, rangos, listas y mapas y a la definicion de closures
• En el archivo _2_Estructuras_Logicas hay una descripcion de la forma en que trabajan las estructuras de control basicas y los loops particulares de groovy
• En el archivo _3_Metodos hay una explicacion del llamado a métodos y las sentencias try_catch_finally

Descargar Archivo Groovy Examples

Ejemplo de Loops con Groovy:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

 
public static void loops(){
 
//la variable it es el iterador
 
//al igual que todas los loop y closures, las sentencias del bucle se declaran entre corchetes
 
		// inicia en 0
 
		5.times {println "Times + $it "}
 
		1.upto(3) {println "Up + $it "}
 
		4.downto(1) {println "Down + $it "}
 
 
 
		def sum = 0
 
		1.upto(100) {sum += 1}
 
		println sum
 
 
 
		(1..6).each {println "Range $it"}
 
	}

Although several options exist for interface development in Java, even popular UI toolkits like Swing have been notoriously complex and difficult to use. Griffon, an agile framework that uses Groovy to simplify Swing, makes UI development dramatically faster and easier. In many respects, Griffon is for desktop development what Grails is for web development. While it’s based on Swing, its declarative style and approachable level of abstraction is instantly familiar to developers familiar with other technologies such as Flex or JavaFX.

A continuación algunas de las presentaciones disponibles en Slideshare:

• Opening Keynote by Søren Berg Glasius and Guillaume Laforge
• Practical Groovy DSL by Guillaume Laforge
• What’s New in Groovy 1.6? by Guillaume Laforge
• Industrial Strength Groovy by Paul King
• Groovy Finance: Grid Computing and Computational Finance
• The Grails Plugin System by Graeme Rocher

• Getting Started Guide
• User Guide
• Advanced usage guide
• Groovy and Grails talk: http://www.slideshare.net/desistartups/groovy-and-grails-talk
• Curso de Groovy: http://www.dosideas.com/cursos/course/view.php?id=9
• Introducción a Groovy: http://www.asert.com/pubs/Groovy/Groovy.pdf
• Creating “Hello World” Web Application Using the Grails Framework
• Grails : Hello world
• Getting Started with Grails :
• GRAILS QUICK REFERENCE
• http://www.slideshare.net/loffenauer/2007-09-10-fzi-training-groovy-grails-v-ws
• http://www.slideshare.net/desistartups/groovy-and-grails-talk
• http://www.slideshare.net/mjhugo/groovy-grails-devjam-jam-session-presentation

En esta sección del tutorial utilizaremos un plugin para la generación de RSS utilizando grails.  (Puede encontrar una lista de los plugins existentes en la siguiente ubicación: http://grails.org/plugin/home

El plugin que utilizaremos para la generación de rss se llama Feeds.  Para instalarlo ejecutamos el siguiente comando (tenga en cuenta estar ubicado en la carpeta de su proyecto)

> F:\dev\issuetracker>grails install-plugin feeds

Cuando aparezca en la consola el mensaje “Plugin feeds-1.4 installed” podemos seguir al siguiente paso del tutorial.

Vamos a crear un feed rss con los issues creados en el sistema. Primero procedemos a ubicar el archivo /issuetracker/grails-app/controllers/IssueController.groovy y adicionamos el siguiente método:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def feed = {
        render(feedType:"rss", feedVersion:"2.0") {
            title = "Mi feed de prueba "
            link = "http://localhost:8080/issuetracker/issue/feed"
            description = "Issues Grails news feed"
 
            Issue.list().each() { 
            	issue -> entry(issue.submitter) { 
            		link = "http://your.test.server/article/${issue.id}" 
            		issue.description // return the content 
            	} 
            } 
        } 
    }

Si digitamos la dirección http://localhost:8080/issuetracker/issue/feed podremos ver generado el siguiente feed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" version="2.0">
  <channel>
    <title>Mi feed de prueba</title>
    <link>http://localhost:8080/issuetracker/issue/feed</link>
    <description>Issues Grails news feed</description>
    <item>
      <title>User 1</title>
      <link>http://your.test.server/article/5</link>
      <content:encoded>My report from error</content:encoded>
      <guid>http://your.test.server/article/5</guid>
    </item>
    <item>
      <title>User 2</title>
      <link>http://your.test.server/article/6</link>
      <content:encoded>This component does not work in firefox</content:encoded>
      <guid>http://your.test.server/article/6</guid>
    </item>
  </channel>
</rss>

Si queremos incluir el enlace para la visualización del RSS en nuestra página de listado de Issues podemos adicionar el siguiente código al archivo /issuetracker/grails-app/views/issue/list.gsp

1
2
3

   <div >
	<a href="${createLinkTo(dir:'issue/feed', file:'')}">View RSS</a>
   </div>

En muchas ocasiones no es suficiente la funcionalidad que genera automáticamente el marco de trabajo Grails.  En la presente sección realizaremos algunas modificaciones a las pantallas generadas por la herramienta.

Vamos a la carpeta ‘grails-app/views‘, notese que hay una carpeta por cada tabla creada, en estas carpetas estará en código seudo-HTML para cada una de nuestras vistas en la aplicación.

El siguiente paso es modificar algunas de las vistas para ver su funcionamiento, para nuestro ejemplo vamos a modificar la vista que muestra la lista de “issues”, abrimos el archivo ‘grails-app/views/issue/list.gsp‘, pero, primero vamos a crear un nuevo tag dinamico para nuestra aplicación (ud puede ver mas de los tags en http://grails.org/Dynamic+Tag+Libraries).

Teniendo como base la carpeta de nuestro proyecto ejecutamos el comando:

> grails create-tag-lib Misc

Una vez ejecutado este comando se creara el archivo ‘grails-app/taglib/MiscTagLib.groovy ‘ y a este le vamos a añadir las siguientes líneas de código:

Descargamos la siguiente imagen: http://openclipart.org/people/hrum/hrum_cocktail.png y la copiamos en la carpeta issuetracker\web-app\images (es recomendable reducir el tamaño de la imagen para una mejor visualización).

Ahora modificamos   el archivo ‘grails-app/views/issue/list.gsp ‘ de la siguiente forma: (Nótense las líneas 27, y 39 a la 43.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
        <meta name="layout" content="main" />
        <title>Issue List</title>
    </head>
    <body>
        <div class="nav">
            <span class="menuButton"><a class="home" href="${resource(dir:'')}">Home</a></span>
            <span class="menuButton"><g:link class="create" action="create">New Issue</g:link></span>
        </div>
        <div class="body">
            <h1>Issue List</h1>
            <g:if test="${flash.message}">
            <div class="message">${flash.message}</div>
            </g:if>
            <div class="list">
                <table>
                    <thead>
                        <tr>
                   	        <g:sortableColumn property="id" title="Id" />
                   	        <th>Component</th>
                   	        <g:sortableColumn property="type" title="Type" />
                   	        <g:sortableColumn property="submitter" title="Submitter" />
                   	        <g:sortableColumn property="description" title="Description" />
                   	        <g:sortableColumn property="status" title="Status" />
                   	        <g:sortableColumn property="bounty" title="Bounty" />
                        </tr>
                    </thead>
                    <tbody>
                    <g:each in="${issueInstanceList}" status="i" var="issueInstance">
                        <tr class="${(i % 2) == 0 ? 'odd' : 'even'}">
                            <td><g:link action="show" id="${issueInstance.id}">${fieldValue(bean:issueInstance, field:'id')}</g:link></td>
                            <td>${fieldValue(bean:issueInstance, field:'component')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'type')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'submitter')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'description')}</td>
                            <td>${fieldValue(bean:issueInstance, field:'status')}</td>
                            <td>
                            	<g:repeat times="${issueInstance.bounty}">  
   									<img src="${createLinkTo(dir:'images', file:'hrum_cocktail.png')}" alt="${issueInstance.bounty} beers"/>  
   								</g:repeat>  
                            </td>
                        </tr>
                    </g:each>
                    </tbody>
                </table>
            </div>
            <div class="paginateButtons">
                <g:paginate total="${issueInstanceTotal}" />
            </div>
        </div>
    </body>
</html>

Ahora nuestro listado de Issues se verá de la siguiente forma:

Grails soporta los conceptos de “Pruebas Unitarias” y “Pruebas de Integración“.
Las “pruebas unitarias” se orientan a pruebas pequeñas de ejecución rápida que no soportan carga de Componentes.  Las “pruebas de integración” se encargan de evalular el ambiente en el que se ejecuta el aplicativo.

Para nuestro ejemplo vamos a modificar el archivo “ProjectTests.groovy“  (Este archivo se encuentra dentro de la carpeta   “\issuetracker\test\unit\” .  Grails crea automáticamente Archivos de pruebas para las entidades del dominio creadas previamente) :

import grails.test.*
 
class ProjectTests extends GrailsUnitTestCase {
    protected void setUp() {
        super.setUp()
    }
 
    protected void tearDown() {
        super.tearDown()
    }
 
    //Test sin errores
    void testSomething() {
    	Project hs = new Project(name:"hello world")
        assertEquals "hello world", hs.name
    }
 
    //Test con errores
    void testSomethingFails() {
    	Project hs = new Project(name:"hello world")
        assertEquals "hello world failed", hs.name
    }
}

En este ejemplo vemos dos pruebas testsomething y testsomethingfails.

Para ejecutar el conjunto de pruebas unitarias del proyecto ejecutamos el comando:

>> F:\dev\issuetracker>grails test-app

Para nuestro ejemplo la consola debería mostrar un mensaje similar al siguiente:

Starting unit tests ...
Running tests of type 'unit'
-------------------------------------------------------
Running 4 unit tests...
Running test ComponentTests...PASSED
Running test IssueTests...PASSED
Running test ProjectTests...
                    testSomethingFails...FAILED
Tests Completed in 312ms ...
-------------------------------------------------------
Tests passed: 3
Tests failed: 1
-------------------------------------------------------

Adicionalmente grails genera un reporte en la siguiente ruta: F:\dev\issuetracker\test\reports\html\index.html. A continuación un pantallazo del reporte:

Pruebas Funcionales de Proyectos Grails

Además de pruebas unitarias , Grails también soporta pruebas funcionales utilizando Canoo WebTest. (Canoo WebTest es una herramienta de software libre destinada para la automatización de pruebas de aplicaciones web.)

Para instalar el plugin de pruebas funcionales ejecutamos el siguiente comando:

F:\dev\issuetracker>grails install-plugin webtest

(Nota: Durante la instalación del plugin el instalador pedirá también la instalación de WebTest)

Para crear una prueba funcional de nuestra clase de dominio Project, ejecutamos el siguiente comando:

F:\dev\issuetracker>grails create-webtest Project

Grails creará el siguiente archivo: “/issuetracker/webtest/tests/ProjectTest.groovy“  con el siguiente contenido:

class ProjectTest extends grails.util.WebTest {
 
    // Unlike unit tests, functional tests are sometimes sequence dependent.
    // Methods starting with 'test' will be run automatically in alphabetical order.
	// If you require a specific sequence, prefix the method name (following 'test') with a sequence
	// e.g. test001ProjectListNewDelete
 
    def testProjectListNewDelete() {
            invoke      'project'
            verifyText  'Home'
 
            verifyListSize 0
 
            clickLink   'New Project'
            verifyText  'Create Project'
            clickButton 'Create'
            verifyText  'Show Project', description:'Detail page'
            clickLink   'List', description:'Back to list view'
 
            verifyListSize 1
 
            group(description:'edit the one element') {
                showFirstElementDetails()
                clickButton 'Edit'
                verifyText  'Edit Project'
                clickButton 'Update'
                verifyText  'Show Project'
                clickLink   'List', description:'Back to list view'
            }
 
            verifyListSize 1
 
            group(description:'delete the only element') {
                showFirstElementDetails()
                clickButton 'Delete'
                verifyXPath xpath:  "//div[@class='message']",
                            text:   /.*Project.*deleted.*/,
                            regex:  true
            }
 
            verifyListSize 0
    }
 
    String ROW_COUNT_XPATH = "count(//div[@class='list']//tbody/tr)"
 
    def verifyListSize(int size) {
        ant.group(description:"verify Project list view with $size row(s)") {
            verifyText  'Project List'
            verifyXPath xpath:      ROW_COUNT_XPATH,
                        text:       size,
                        description:"$size row(s) of data expected"
        }
    }
 
    def showFirstElementDetails() {
        clickLink   '1', description:'go to detail view'
    }
}

Para ejecutar la prueba escribimos el comando:

> F:\dev\issuetracker>grails run-webtest

Se generará un reporte como el siguiente:

Puede encontrar un listado de completo para pruebas de canoo en la siguiente ubicación: http://webtest.canoo.com/webtest/manual/manualOverview.html

Adicionalmente puede utilizar la herramienta WebTestRecorder.

Enlaces Relacionados:

• Grails Unit Testing
• Testing Controllers
• Testing Services
• Testing Domain Classes
• Grails Functional Testing
• Mastering Grails: Testing your Grails application

A continuación se describirá el proceso para configurar el entorno de Eclipse con las opciones para edición de Código Groovy y soporte para aplicaciones Grails.  (Eclipse es un entorno de desarrollo múltiplataforma de código abierto. Más información en esta dirección: http://es.wikipedia.org/wiki/Eclipse_(software) ) .

Primero abrir eclipse y seleccionar en el menú la opción  help → software updates.   Esta opción abrirá una nueva pantalla. En esta seleccionamos la opción  Avaliable Software:

Seleccionamos el botón Add Site y en la url añadimos http://dist.codehaus.org/groovy/distributions/updateDev/ y damos clic en OK.

Ahora agregamos el siguiente sitio, repitiendo el paso anterior http://dist.codehaus.org/groovy/distributions/update/

Y seleccionamos los plugins a instalar de la siguiente forma (Tener en cuenta exactamente las versiones seleccionadas para el “Groovy Feature” y el “Grails Eclipse Feature” :

Seleccionamos la opción “Install” y aceptamos los términos de la licencia. Luego de terminada la descarga automática de los plugins seleccionados debemos proceder a reiniciar Eclipse.

Configuración de Variables de Entorno de Eclipse

Ahora vamos a añadir la variable de entorno GRAILS_HOME en eclipse. Vamos a Windows → Preferences, buscamos Java → Build Path → Classpath Variables:

Damos clic en la opción New,

Name: GRAILS_HOME
Path: (La ruta donde esta instalado grails, ej: C:\grails)

Ahora importemos un proyecto grails a eclipse.
Vamos a File → Import, ahí escogemos General → Existing Projects into Workspace, y le damos Next:

Ahora buscamos el directorio donde esta nuestro proyecto grails y hacemos clic en finish:

Ahora vamos a modificar las propiedades del configuración del proyecto Eclipse. Hacemos Click derecho sobre el proyecto → properties y seleccionamos la opción “groovy project properties” (Modificamos los valores de las variables según como muestra la imagen)

Para ejecutar la aplicación podemos utilizar la combinación de teclas  CTRL+F11, o la opción  Run → Run en el menú. Seleccionamos la primera opción, para nuestro ejemplo issuetracker y la opción  OK.

Cuando en la consola de eclipse aparezca   Server running. Browse to http://localhost:8080/issuetracker, podremos iniciar la aplicación  en el explorador.

Configuración para Depuración (Debug) de Grails en Eclipse

Para que el depurador de Eclipse funcione con Grails, debemos verificar en las propiedades del proyecto  que la opción Disable Groovy Compiler Generating Files esté habilitada  y en Groovy compiler output location este la ruta “web-app/WEB-INF/classes”.

Para nuestro ejemplo, vamos a hacer un debug para la clase “ComponentController.groovy”

Abrimos la clase “ComponentController.groovy” y ponemos un break point en cualquier linea, para nuestro ejemplo en la linea 9, Hacemos clic en el botón debug, o F11, saldrá una pantalla similar a esta:

Habilitamos la casilla “Don’t tell me again” y OK.
Ahora vemos la aplicación en el navegador, y hacemos clic en el vinculo ComponentController ,y el debug es activado en eclipse.

Damos clic derecho en el proyecto en la pantalla debug y vamos a Edit Source Lookup, damos click en el botón add, seleccionamos la opción Workspace Folder,

Buscamos la ruta web-app/ WEB-INF/classes, habilitamos la opción Search subfolders y la opción OK.  Adicionalmente, seleccionamos de nuevo la opción  add, y agregamos la ruta grails-app, también habilitamos la opción Search subfolders y OK.

En este momento ya tenemos habilitado  entorno de eclipse para depuración de aplicaciones Groovy / Grails.

Para nuestro ejemplo vamos a crear los siguientes modelos de dominio: Project, Component, and Issue.
La clase “Project” que representa el proyecto de software para el cual vamos a registrar incidencias (Bugs).
Un Project puede tener uno o más Componentes (Ejm: gui, documentación, etc)
Un Componente solo está asociado a un proyecto y puede tener cero o más Issues asociados.
Un objeto Issue está asociado a un Componente.

Con el siguiente comando creamos la entidad Project:

>  D:\dev\issuetracker>grails create-domain-class  Project

Si el comando se ejecuta satisfactoriamente debería obtenerse una respuesta similar a la
siguiente:

>  Welcome to Grails 1.1.1 – http://grails.org/
>  Licensed under Apache Standard License 2.0
>  Grails home is set to: C:\dev\grails-1.1.1
>  Base Directory: D:\dev\issuetracker
>  Running script C:\dev\grails-1.1.1\scripts\CreateDomainClass.groovy
>  Environment set to development
>  Created DomainClass for Project
>  Created Tests for Project

grails automáticamente crea el archivo    %PROJECT_HOME%\grails-app\domain\Project.groovy     con la siguiente estructura

1
2
3
4

class Project {
 
static constraints = {}
}

Qué es una Clase de Dominio?

Una clase de dominio es un artefacto persistente para el cual todas sus propiedades  son persistidas
en la base de datos (Más información en  GORM http://www.grails.org/GORM (Grails Object Relational Mapping) )

Para nuestro ejemplo editamos el archivo Project.groovy de la siguiente forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Project {
  // relaciones
  static hasMany = [components: Component]
 
// campos
String name
 
String toString() {
return name
}
 
// restricciones
static constraints = {
name()
components()
}
}

Como se puede ver en la clase Project, por lo general una clase de dominio de GORM se compone de relaciones con otras entidades,
campos (Columnas en la base de datos), y restricciones.

Para nuestro sistema de ejemplo debemos crear también las clases de dominio Issue y Component:

>  D:\dev\issuetracker>grails create-domain-class  Component
>  D:\dev\issuetracker>grails create-domain-class  Issue

y las editamos de la siguiente forma:

Component.groovy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Component {
// relationships
static belongsTo = Project
static hasMany = [issues: Issue]
 
// fields
Project project
String name
 
// override for nice display
String toString() {
return “${project} - ${name}”
}
 
// constraints
static def constraints = {
//’empty’ constraints
//garantizan el orden como apareceran los campos en la forma
name()
project()
issues()
}
}

Issue.groovy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Issue {
// relationships
static belongsTo = Component
 
// fields
Component component
String type
String submitter
String description
String status = “New”
Integer bounty
Date dateCreated
Date lastUpdated
 
// constraints
static constraints = {
component()
//restringe una lista de valores
type(inList: ["Defect", "Feature"])
submitter()
 
description(size: 0..5000)
status(inList: ["New", "Accepted", "Closed", "Won't Fix"])
bounty(range:0..12)
}
}

En los siguientes enlaces puede encontrarse información mucho más detallada sobre el funcionamiento de GORM:
Mapeo de Entidades: http://www.grails.org/GORM+-+Mapping+DSL
Relaciones: http://www.grails.org/GORM+-+Defining+relationships
Colecciones: http://www.grails.org/GORM+-+Collection+Types
Operaciones de Crud: http://www.grails.org/GORM+-+CRUD

Creación de Datos de Prueba

Muchas veces se requieren datos de ejemplo para realizar pruebas al sistema.
Grails nos permite la creación inicial de datos de la siguiente forma:

Ubicar el archivo    %PROJECT_HOME%\grails-app\conf\BootStrap.groovy   y modificarlo de la siguiente forma:

class BootStrap {

def init = { servletContext ->
// Create some test data
new Project(name:”Widget para Facebook”).save()
new Project(name:”Simple Issue Tracker”).save()
new Project(name:”Extensión para Openlayers”).save()
}
def destroy = {
}
}

En este ejemplo creamos tres objetos Project como datos de prueba.

Creación de Controladores y Vistas

Dado que ya disponemos de nuestras clases de dominio, podemos ejecutar los siguientes comandos que se
encargarán de generar los controladores y vistas para nuestras entidades:

>D:\dev\issuetracker>grails generate-all Project
>D:\dev\issuetracker>grails generate-all Component
>D:\dev\issuetracker>grails generate-all Issue

El comando generate-all genera el código necesario para habilitar el CRUD de las entidades Project, Component e Issue.

Para ejecutar la aplicación podemos utilizar el comando:

> D:\dev\issuetracker>grails run-app

Una vez  se ha inicializado el servidor, puede ingresar a la aplicación a través del siguiente url:  http://localhost:8080/issuetracker

En la pantalla de inicio podrá ver lo siguiente:

Si selecciona la opción ProjectController podrá ver el listado de los proyectos:

A continuación la pantalla donde se muestra el detalle de un Component:

Si desea crear un nuevo Issue, grails ha generado para usted la siguiente pantalla:

Nótese que con muy poco esfuerzo hemos logrado crear una aplicación completa de CRUD para administrar nuestras entidades Project, Component e Issue.  En las siguientes partes del tutorial se incluirán  funcionalidades adicionales y personalización de la visualización.

Puede descargar el código completo de la parte 2 desde esta ubicación

Introducción:

Grails es un marco de trabajo para el desarrollo de aplicaciones web que se basa en las ideas de
“Codificación a través de Convenciones” (coding by convention) y DRY (don’t repeat yourself) utilizando el lenguaje de programación Groovy.

Grails se ejecuta sobre una máquina virtual de Java, teniendo acceso completo a la plataforma y librerías Java.

Con Grails pueden crearse fácilmente aplicaciones web gracias a:

• Ofrece un Entorno completo para el desarrollo y publicación de aplicaciones: Todas las dependencias y configuración requeridas para ejecutar las aplicaciones web son proporcionadas por Grails.  Usted debe solamente preocuparse por el código particular de su aplicación.
• Incluye un servidor Jetty embebido.
• El modo de desarrollo automáticamente recarga los cambios realizados al código de la aplicación sin tener que reiniciar el servidor web.
• Ofrece mapeo de persistencia automàtico para las clases del Dominio del problema, así como también manejo automàtico de las relaciones entre las entidades.
• Ofrece scaffolding para el acceso a datos, ofreciendo posibilidades para el desarrollo rápido de operaciones CRUD (Create, Read, Update, Delete).
• Soporte de tecnologías para la implementación de vistas de datos utilizando “dynamic tag libraries” y “Groovy Server Pages (GSP)”
• Extensibilidad a través de la utilización de plugins.

Grails puede usarse como un entorno de desarrollo autónomo que esconde todos los detalles de configuración así como también permite integrar lógica de negocio escrita en Java.  Entre los objetivos de Grails está el hacer el desarrollo web lo más simple y atractivo posible de tal forma que un amplio segmento de desarrolladores puedan utilizarlo.

Tutorial “Escribir un Manejador de Incidencias Utilizando Grails”

El tutorial a desarrollar a continuación se basa en el artículo “Writing a Simple Issue Tracker in Grails” Part 1 y   Part 2

Cómo Obtener el Framework Grails?

Usted puede descargar la última versión del framework desde la siguiente ubicación: http://www.grails.org/Download

Instalación

Una vez ha obtenido y descomprimido el framework debe adicionar a su sistema operativo la variable de entorno GRAILS_HOME.

Si utiliza windows puede configurar las variables de entorno de la siguiente forma:

> set GRAILS_HOME=C:\download\grails
> echo %GRAILS_HOME%
C:\download\grails
> set PATH=%GRAILS_HOME%\bin;%PATH%

(Información adicional:  Administrar variables de entorno en Windows XP )

O si utiliza sistemas basados en linux puede utilizar los siguientes comandos:

> set GRAILS_HOME=~/download/grails
> export GRAILS_HOME
> echo ${GRAILS_HOME}
~/download/grails
> cd ${GRAILS_HOME}
> chmod a+x bin/grails
> set PATH=${GRAILS_HOME}/bin:${PATH}
> export PATH

(No olvide configurar también la variable JAVA_HOME apuntando a la carpeta donde reside su instalación
particular de Java (JDK http://java.sun.com/javase/downloads/index.jsp).
Configuración de Java en Windows
Configuración de Java en Unix)

para comprobar su instalación de grails puede digitar el siguiente comando

> grails

debe aparecer como respuesta un mensaje similar al siguiente:

> C:\Documents and Settings\user>grails
> Welcome to Grails 1.1.1 – http://grails.org/
> Licensed under Apache Standard License 2.0
> Grails home is set to: C:\dev\grails-1.1.1
> No script name specified. Use ‘grails help’ for more info or ‘grails interactive’ to enter interactive mode

Creando el proyecto Con Grails

Para crear nuestro  proyecto Grails debe utilizar el siguiente comando

> D:\dev>grails  create-app issuetracker

este comando creará una carpeta con la siguiente estructura de directorios:
(Para nuestro ejemplo la carpeta %PROJECT_HOME% es representada por la carpeta D:\dev\issuetracker)

Configuración de la Base de Datos

Para nuestro ejemplo utilizaremos el motor de bases de datos relacionales PostgreSql. (Debemos crear
una instancia y usuario en la base de datos. Para este caso creamos la base de datos “issues” con
su usuario relacionado “issuetracker” con clave “issuetracker”)

Primero necesitamos descargar el driver Jdbc disponible en la siguiente ubicación: http://jdbc.postgresql.org/download.html
(Para nuestro ejemplo descargamos el jar postgresql-8.3-604.jdbc4.jar )
El jar obtenido debe ser copiado en la carpeta %PROJECT_HOME%/lib

Configuración del Datasource

Una de las grandes ventajas de Grails es la facilidad para el manejo de la configuración del proyecto.

Por ejemplo el comando ejecutado “create-app”  entre otros archivos crea uno llamado  DataSource.groovy (En la carpeta %PROJECT_HOME%grails-app/conf/ ).
Este archivo nos permite especificar diferentes ambientes (Development, TestData y Production)
para el manejo de la fuente de datos del proyecto.  Como opción por omisión utiliza el manejador de datos
HSQLDB.

Para modificar la configuración del entorno “Development” utilizando postgresql debemos modificar el archivo DataSource.groovy de la siguiente forma:

development {
dataSource {
driverClassName = "org.postgresql.Driver"
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
url = "jdbc:postgresql://localhost:5432/issues"
dialect = org.hibernate.dialect.PostgreSQLDialect
username = "issuetracker"
password = "issuetracker"
}
}

(Más información en http://hartsock.blogspot.com/2008/07/postgresql-and-grails.html )