Relación One-to-Many en Spring Roo

En un pasado post hable un poco de los primeros pasos con Sprign Roo.

En este post hare un muy pequeño proyecto con Spring Roo pero me enfocare en ver como hacer entidades con relaciones de uno a muchos (maestro-esclavo).

Ok, pues empecemos.

Primero crearemos el proyecto indicándole el paquete raíz del mismo.

roo> project --topLevelPackage prueba.springroo.relonetomany --projectName relacion-onetomany
Created D:\Abaddon\Projects\JAbaddon\Code\SpringRoo\RelacionOneToMany\pom.xml
Created SRC_MAIN_JAVA
Created SRC_MAIN_RESOURCES
Created SRC_TEST_JAVA
Created SRC_TEST_RESOURCES
Created SRC_MAIN_WEBAPP
Created SRC_MAIN_RESOURCES\META-INF\spring
Created SRC_MAIN_RESOURCES\META-INF\spring\applicationContext.xml
Created SRC_MAIN_RESOURCES\META-INF\spring\log4j.properties

Ahora hay que definir el método de persistencia para el proyecto. Usaremos MySQL con Hibernate.

prueba.springroo.relonetomany roo> persistence setup --provider HIBERNATE --database MYSQL --databaseName rel_one_many
Created SRC_MAIN_RESOURCES\META-INF\persistence.xml
Created SRC_MAIN_RESOURCES\META-INF\spring\database.properties
please enter your database details in src/main/resources/database.properties
Managed SRC_MAIN_RESOURCES\META-INF\spring\applicationContext.xml
Managed ROOT\pom.xml
Managed SRC_MAIN_RESOURCES\META-INF\spring\database.properties

El nombre de base de datos que usamos fue "rel_one_many" así que hay que asegurarnos de tener una base de datos con ese nombre en nuestro MySQL.

En el comando "persistence setup" tambien se puede especificar el usuario y password que usaremos para conectarnos a la base de datos con "--userName" y "--password" respectivamente. Como aqui no lo especificamos asi sera necesario especificarlo en el archivo "src/main/resources/database.properties" para que podamos conectarnos a la base de datos sin problemas.

Lo siguiente sera configurar el logging a un nivel de DEBUG.

prueba.springroo.relonetomany roo> logging setup --level DEBUG
Managed SRC_MAIN_RESOURCES\META-INF\spring\log4j.properties

Ahora para propositos de este ejemplo usaremos usaremos las entidades Grupo y Alumno para representar una relación de uno a muchos donde el Grupo tiene uno o mas Alumnos.

Empecemos creando la entidad Grupo con las propiedades: nombre y fecha de registro.

prueba.springroo.relonetomany roo> entity --class prueba.springroo.relonetomany.dominio.Grupo --testAutomatically
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo.java
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoDataOnDemand.java
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoIntegrationTest.java
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_Entity.aj
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_ToString.aj
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_Configurable.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoIntegrationTest_Roo_Configurable.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoDataOnDemand_Roo_DataOnDemand.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoIntegrationTest_Roo_IntegrationTest.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoDataOnDemand_Roo_Configurable.aj
~.dominio.Grupo roo> field string --fieldName nombre --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo.java
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_ToString.aj
~.dominio.Grupo roo> field date --fieldName fechaRegistro --type java.util.Date --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo.java
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\GrupoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_ToString.aj

La siguiente entidad que crearemos sera Alumno, el cual tendrá las propiedades: nombre, apellido, fecha de nacimiento y numero de credencial.

~.dominio.Grupo roo> entity --class prueba.springroo.relonetomany.dominio.Alumno --testAutomatically
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno.java
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand.java
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoIntegrationTest.java
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_Entity.aj
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_ToString.aj
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_Configurable.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoIntegrationTest_Roo_Configurable.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_DataOnDemand.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoIntegrationTest_Roo_IntegrationTest.aj
Created SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_Configurable.aj
~.dominio.Alumno roo> field string --fieldName nombre --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno.java
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_ToString.aj
~.dominio.Alumno roo> field date --fieldName fechaNacimiento --type java.util.Date --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno.java
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_ToString.aj
~.dominio.Alumno roo> field number --fieldName numeroBoleta --type java.lang.Long --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno.java
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_ToString.aj
~.dominio.Alumno roo> field string --fieldName apellido --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno.java
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_ToString.aj

Ya teniendo las dos entidades ahora vamos a relacionarlas. Lo primero que haremos sera indicar que la entidad Grupo tendrá muchos Alumnos con el comando "field set":

~.dominio.Alumno roo> field set --fieldName alumnos --element prueba.springroo.relonetomany.dominio.Alumno --class prueba.springroo.relonetomany.dominio.Grupo --mappedBy grupo
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo.java
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_JavaBean.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Grupo_Roo_ToString.aj

Hay que notar aquí que en el momento en que escribimos el comando Spring Roo estaba bajo el contexto de la entidad Alumno (noten la cadena que hay antes del promt de "roo>" y que dice "~.dominio.Alumno"), por esa razón es necesario usar la opción "--class" para indicarle a que clase se le agregara el campo que se esta creando.

Otro punto en el que hay que poner atención es la opción "--mappedBy" la cual la nombramos como "grupo". Esto le dice a Spring Roo que la relación one-to-many estará mapeada por la propiedad "grupo" en los elementos que están del lado "many" de la relación (los contenidos).

Ahora en con la entidad Alumno hacemos la relación hacia el Grupo usando "field reference":

~.dominio.Grupo roo> field reference --fieldName grupo --class prueba.springroo.relonetomany.dominio.Alumno --type prueba.springroo.relonetomany.dominio.Grupo --notNull
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno.java
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_JavaBean.aj
Managed SRC_TEST_JAVA\prueba\springroo\relonetomany\dominio\AlumnoDataOnDemand_Roo_DataOnDemand.aj
Managed SRC_MAIN_JAVA\prueba\springroo\relonetomany\dominio\Alumno_Roo_ToString.aj

La opción "--type" indica el tipo de la referencia que estamos creando en la entidad.

Ok, las relaciones ya están configuradas. Ahora vamos a crear los controladores web con el comando "controller all" (para crear todos los controladores de cada una de las entidades) dentro del paquete "prueba.springroo.relonetomany.web"

~.dominio.Alumno roo> controller all --package prueba.springroo.relonetomany.web
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\web
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\web\GrupoController.java
Created SRC_MAIN_WEBAPP\WEB-INF\spring
Created SRC_MAIN_WEBAPP\WEB-INF\spring\webmvc-config.xml
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\web\GrupoController_Roo_Controller.aj
Created SRC_MAIN_WEBAPP\images
Created SRC_MAIN_WEBAPP\images\nl.png
Created SRC_MAIN_WEBAPP\images\update.png
Created SRC_MAIN_WEBAPP\images\es.png
Created SRC_MAIN_WEBAPP\images\delete.png
Created SRC_MAIN_WEBAPP\images\add.png
Created SRC_MAIN_WEBAPP\images\resultset_previous.png
Created SRC_MAIN_WEBAPP\images\resultset_next.png
Created SRC_MAIN_WEBAPP\images\favicon.ico
Created SRC_MAIN_WEBAPP\images\banner-graphic.png
Created SRC_MAIN_WEBAPP\images\resultset_last.png
Created SRC_MAIN_WEBAPP\images\gb.png
Created SRC_MAIN_WEBAPP\images\springsource-logo.png
Created SRC_MAIN_WEBAPP\images\it.png
Created SRC_MAIN_WEBAPP\images\show.png
Created SRC_MAIN_WEBAPP\images\sv.png
Created SRC_MAIN_WEBAPP\images\list.png
Created SRC_MAIN_WEBAPP\images\resultset_first.png
Created SRC_MAIN_WEBAPP\images\de.png
Created SRC_MAIN_WEBAPP\styles
Created SRC_MAIN_WEBAPP\styles\standard.css
Created SRC_MAIN_WEBAPP\styles\alt.css
Created SRC_MAIN_WEBAPP\WEB-INF\classes
Created SRC_MAIN_WEBAPP\WEB-INF\classes\standard.properties
Created SRC_MAIN_WEBAPP\WEB-INF\classes\alt.properties
Created SRC_MAIN_WEBAPP\WEB-INF\layouts
Created SRC_MAIN_WEBAPP\WEB-INF\layouts\default.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\layouts\layouts.xml
Created SRC_MAIN_WEBAPP\WEB-INF\views
Created SRC_MAIN_WEBAPP\WEB-INF\views\views.xml
Created SRC_MAIN_WEBAPP\WEB-INF\views\resourceNotFound.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\index.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\uncaughtException.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\dataAccessFailure.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\controller-index.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\tags
Created SRC_MAIN_WEBAPP\WEB-INF\tags\language.tagx
Created SRC_MAIN_WEBAPP\WEB-INF\tags\theme.tagx
Created SRC_MAIN_WEBAPP\WEB-INF\tags\pagination.tagx
Created SRC_MAIN_WEBAPP\WEB-INF\i18n
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\messages_sv.properties
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\messages.properties
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\messages_nl.properties
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\messages_it.properties
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\messages_es.properties
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\messages_de.properties
Created SRC_MAIN_WEBAPP\WEB-INF\i18n\application.properties
Managed SRC_MAIN_WEBAPP\WEB-INF\i18n\application.properties
Created SRC_MAIN_WEBAPP\WEB-INF\views\grupo
Created SRC_MAIN_WEBAPP\WEB-INF\views\grupo\list.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\grupo\show.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\grupo\create.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\menu.jspx
Managed SRC_MAIN_WEBAPP\WEB-INF\i18n\application.properties
Managed SRC_MAIN_WEBAPP\WEB-INF\views\menu.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\grupo\update.jspx
Managed SRC_MAIN_WEBAPP\WEB-INF\i18n\application.properties
Managed SRC_MAIN_WEBAPP\WEB-INF\views\menu.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\grupo\views.xml
Created SRC_MAIN_WEBAPP\WEB-INF\urlrewrite.xml
Created SRC_MAIN_WEBAPP\WEB-INF\web.xml
Managed SRC_MAIN_WEBAPP\WEB-INF\web.xml
Managed ROOT\pom.xml
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\web\AlumnoController.java
Managed SRC_MAIN_WEBAPP\WEB-INF\web.xml
Managed ROOT\pom.xml
Created SRC_MAIN_JAVA\prueba\springroo\relonetomany\web\AlumnoController_Roo_Controller.aj
Created SRC_MAIN_WEBAPP\WEB-INF\views\alumno
Created SRC_MAIN_WEBAPP\WEB-INF\views\alumno\list.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\alumno\show.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\alumno\create.jspx
Managed SRC_MAIN_WEBAPP\WEB-INF\i18n\application.properties
Managed SRC_MAIN_WEBAPP\WEB-INF\views\menu.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\alumno\update.jspx
Managed SRC_MAIN_WEBAPP\WEB-INF\i18n\application.properties
Managed SRC_MAIN_WEBAPP\WEB-INF\views\menu.jspx
Created SRC_MAIN_WEBAPP\WEB-INF\views\alumno\views.xml

Ahora hay que probar todo el código para ver si todo esta bien. Recuerden crear la base de datos, configurar el usuario y password de la base de datos y sobre todo levantar la base de datos para que las pruebas se puedan conectar y ejecutar correctamente. Entonces, para ejecutar las pruebas usamos el comando:

~.web roo> perform tests

el cual nos debe indicar, entre otras cosas, un mensaje "BUILD SUCCESSFUL" y si no fue asi algo hicimos mal (asi que hay que volver a empezar desde el principio de este post).

Para ver todo esto corriendo ya en Tomcat simplemente hay que salirnos de la consola de Spring Roo y en el mismo folder del proyecto ejecutar el comando de maven:

$ mvn tomcat:run

Una vez que este corriendo Tomcat hay que ir a la direccion http://localhost:8080/relacion-onetomany/ y naveguen en la pequeña aplicación para que vean la funcionalidad de la relación one-to-many con Spring Roo.



Notaran que al crear Alumnos si no hay Grupos registrados no les muestra la propiedad para indicar el Grupo al que pertenece el Alumno, pero si crean Grupos y después crean Alumnos ya tienen la posibilidad de seleccionar a que grupo va a pertenecer el Alumno que estén creando.

Ruby Básico - Manejo de Cadenas

En el anterior post sobre Ruby Básico se hablo de una muy breve introducción a Ruby.

En este post profundizaré en el manejo de cadenas con Ruby.

Como se comento antes se puede crear una cadena en Ruby con comillas simples o comillas dobles. Por ejemplo si creamos un archivo llamado "cadenas00.rb" con el siguiente código:

cadena1 = "Esta es una cadena con comillas dobles"
cadena2 = 'Esta es una cadena con comillas simples'
puts cadena1
puts cadena2

y si lo corremos con Ruby:

$ ruby cadenas00.rb
Esta es una cadena con comillas dobles
Esta es una cadena con comillas simples

Sin embargo, también es posible crear cadenas que este delimitadas por un par de caracteres iguales (que no sean letras) que estén precedidos por el símbolo %. Por ejemplo, si creamos un archivo llamado "cadenas01.rb" con el siguiente código:

puts %!Esta es una cadena!
puts %{Esta es otra cadena}
puts %[Esta también es una cadena]
puts %-Esta sera una cadena?-
puts %!Esta es una cadena como el primer ejemplo pero usando el caracter \! con secuencia de escape!

tenemos como salida:

$ ruby cadenas01.rb
Esta es una cadena
Esta es otra cadena
Esta también es una cadena
Esta sera una cadena?
Esta es una cadena como el primer ejemplo pero usando el caracter ! con secuencia de escape

Este estilo para crear cadenas en Ruby es muy útil para cuando se crean cadenas con mucho texto.

Uno de los muchos usos que les damos a las cadenas en nuestros programas es para imprimir valores de variables. Ruby nos permite hacer sustitucion de expresiones dentro de una cadena simplemente encerrando nuestra expresión entre #{ y } dentro de la cadena misma. Por ejemplo, si creamos un archivo llamado "cadenas02.rb" con el siguiente código:

x = 2
y = "expresión"
z = 2.3

puts "El valor de x es #{x}"
puts "El valor de y es #{y}"
puts "El valor de z es #{z}"

# Sera lo mismo que lo siguiente?

puts "El valor de x es " + x
puts "El valor de y es " + y
puts "El valor de z es " + z

tenemos como salida:

$ ruby cadenas02.rb
El valor de x es 2
El valor de y es expresión
El valor de z es 2.3
cadenas02.rb:11:in `+': can't convert Fixnum into String (TypeError)
     from cadenas02.rb:11:in `
'

Notaran que Ruby con el uso de #{} hace automáticamente la transformación adecuada de las variables para poder meterlas a las cadenas.

Como ya había comentado Ruby es un lenguaje orientado a objetos puro de tal forma que una cadena entre comillas es un objeto y se pueden llamar métodos de la clase String. Por ejemplo, si creamos un archivo llamado "cadenas03.rb" con el siguiente código:

cadena1 = "MAYUSCULAS".downcase
cadena2 = String.new("minusculas").upcase

puts "#{cadena1}"
puts "#{cadena2}"

tenemos como salida:

$ ruby cadenas03.rb
mayusculas
MINUSCULAS

Los metodos de la clase String downcase y upcase regresan una copia de la cadena en minúsculas y mayúsculas respectivamente. El método new crea una nueva instancia de la cadena que se le pasa como argumento.

El siguiente código (que sera guardado en un archivo llamado "cadenas04.rb") muestra el uso de algunos de los métodos de la clase String.

str1 = String.new("Mensaje 1")
str2 = String.new("Mensaje 2")
str3 = String.new("MeNSajE 2")
str4 = String.new("    Cadena con espacios    ")

puts "Las cadenas son iguales? #{str1 == str2}"
puts "Las cadenas son diferentes? #{str1 != str2}"
puts "Que pasa si multiplico la cadena? #{str1 * 2}"
puts "Comparacion de cadenas case-sensitive #{str2.eql?(str3)}"
puts "Comparacion de cadenas case-insensitive #{str2.casecmp(str3)}"
puts "Mi cadena esta vacia? #{str2.empty?}"
puts "Donde esta el '2' en mi cadena? #{str2.index("2")}"
puts "Si le quito los espacios a la derecha? [#{str4.rstrip}]"
puts "Si le quito los espacios a la izquierda? [#{str4.lstrip}]"
puts "Si le quito los espacios? [#{str4.strip}]"
puts "Mi cadena a la inversa! #{str2.reverse}"
puts "Substring! [#{str4.slice(4..22)}]"
puts "Substring! [#{str4.slice(4..-5)}]"

entonces al correr el código se tiene como salida:

$ ruby cadenas04.rb
Las cadenas son iguales? false
Las cadenas son diferentes? true
Que pasa si multiplico la cadena? Mensaje 1Mensaje 1
Comparacion de cadenas case-sensitive false
Comparacion de cadenas case-insensitive 0
Mi cadena esta vacia? false
Donde esta el '2' en mi cadena? 8
Si le quito los espacios a la derecha? [    Cadena con espacios]
Si le quito los espacios a la izquierda? [Cadena con espacios    ]
Si le quito los espacios? [Cadena con espacios]
Mi cadena a la inversa! 2 ejasneM
Substring! [Cadena con espacios]
Substring! [Cadena con espacios]

¿Notan como el uso del un numero negativo en el método slice de la clase String cuenta los indices de cada carácter en la cadena de derecha a izquierda?.

Como mencione, el código anterior solo muestra algunos de los métodos de String así que si se requiere de hacer algo con una cadena primero hay que verificar si existe algún método ya en la clase String que lo haga.

Ruby Básico (IRb, Comentarios, Enteros y Cadenas)

Dicen que "Ruby es el mejor amigo del programador" y la verdad no entendía porque hasta que empece a usar un poco Ruby primero para aprender y luego para hacer pequeños programas que utilizo como herramientas en mi labor diaria.

Estos pequeños programas van desde analizadores de logs hasta programas que me ayudar a generar paquetes de instalación de una forma personalizada.

Ruby es un lenguaje orientado a objetos y fue creado en 1993 por Yukihiro Matsumoto. Es muy popular en estos tiempos y existe muchas librerías de apoyo que van desde acceder a base de datos hasta manejar XML.

Ruby viene con una consola interactiva llamada IRb (Interactive Ruby) que sirve de mucho para poder experimentar con el lenguaje. Para correr la consola interactiva simplemente hay que teclear el comando "irb".

irb(main):006:0* mensaje = "Hola Mundo!"
=> "Hola Mundo!"
irb(main):007:0> puts mensaje
Hola Mundo!
=> nil
irb(main):008:0> print mensaje
Hola Mundo!=> nil
irb(main):009:0>

Los identificadores en Ruby son aquellos nombres que les damos a las variables, nombres de métodos, clases, constantes, etc. Estos nombres si hacen distinción entre mayúsculas y minúsculas y pueden ser creados usando caracteres alfanuméricos y el guion bajo '_'.

Como todo lenguaje Ruby tiene palabras reservadas que no pueden ser usadas al nombrar nuestras variables, métodos, clases, etc., no listare las palabras reservadas aquí pero las pueden encontrar en cualquier sitio en internet.

Hay dos tipos de comentarios en Ruby: para comentar una sola linea y para comentar muchas lineas.

# Este es un comentario de una sola linea

=begin
Este es un comentario
para muchas
lineas
=end

Hay 5 tipos de variables en Ruby: globales, de instancia, locales, de clase y constantes. En este post hablare de las globales y constantes, en futuros posts donde les hable de como usar Ruby con clases y objetos ya hablaremos de los otros tipos de variables.

Las variables globales en Ruby se declaran colocando el símbolo $ al inicio del nombre de la variable

$variable_global = 3.1416

Y las constantes simplemente se declaran usando puras mayúsculas en el nombre, y cualquier intento de modificar una constante resulta en un error.

PI = 3.1416
RUTA_DESTION=/tmp/

irb(main):010:0> CONSTANTE = 3.1416
=> 3.1416
irb(main):011:0> CONSTANTE = 2
(irb):11: warning: already initialized constant CONSTANTE
=> 2
irb(main):012:0>

Los enteros en Ruby se pueden escribir con un signo al inicio y también se les puede indicar el tipo de base que se desee para el numero: 0b para binarios, 0x para hexadecimal y 0 para octal.

irb(main):012:0> numero1 = 12354
=> 12354
irb(main):013:0> numero2 = 1
=> 1
irb(main):014:0> numero1 + numero2
=> 12355
irb(main):015:0> numero3 = 0b0010
=> 2
irb(main):016:0> numero2 + numero3
=> 3
irb(main):017:0> numero4 = 0x0F
=> 15
irb(main):018:0> numero3 + numero4
=> 17
irb(main):019:0> numero5 = 1_000_000
=> 1000000
irb(main):020:0>

Como notaran el guion bajo '_' es ignorado al declaran enteros.

Ruby maneja dos clases para los enteros: Fixnum y Bignum. La diferencia entre estas clases es que Fixnum esta hecho para manejar enteros en el rango de -2³⁰ to 2^30-1 or -2⁶² to 2^62-1 (depende de la computadora donde este corriendo Ruby) y el Bignum se usa para cuando los rangos son mayores a los anteriores.

Para los números flotantes Ruby usa la clase: Float. Los números flotantes puede ser declarados usando notación científica.

irb(main):022:0* flotante = 1.2345
=> 1.2345
irb(main):023:0> flotante2 = 1.34e4
=> 13400.0
irb(main):024:0>

La clase de Ruby String es la que maneja las cadenas. Las cadenas puede ser declaradas usando comillas simples o comillas dobles.

irb(main):026:0* cadena = 'Esta es una cadena'
=> "Esta es una cadena"
irb(main):027:0> cadena2 = "Esta es otra cadena pero con comillas dobles"
=> "Esta es otra cadena pero con comillas dobles"
irb(main):028:0>