Tutorial de introduccin a Ruby on Rails

Ruby on Rails es un entorno de desarrollo web de cdigo abierto que est optimizado para
satisfaccin de los programadores y de la productividad. Te permite escribir un buen cdigo
favoreciendo la convencin antes que la configuracin.
En este tutorial introductorio aprenderemos qu es Ruby, qu es Rails y cmo crear una aplicacin
de ejemplo.
Qu es Ruby on Rails?
Ruby on Rails es un entorno de desarrollo web, de cdigo abierto (open source, software libre), que
nos permite construir aplicaciones web flexibles y robustas rpidamente.
Las dos piezas principales de este entorno son dos: por un lado Ruby, y por otro, Rails.
Qu es Ruby?
Ruby es un lenguaje de programacin enfocado a la simplicidad y a la productividad, con una
sintaxis elegante y natural, que le hace muy fcil de entender. Es un lenguaje de script (no
compilado), totalmente orientado a objetos.
El lenguaje Ruby fu creado por Yukihiro matz Matsumoto en 1995 cogiendo lo que ms le
gustaba de otros lenguajes como Perl, Smalltalk, Eiffel, Ada y Lisp.
Mientras que otros lenguajes tienen tipos primitivos (como nmeros, booleanos, ...) que no son
objetos, aqu todo es un objeto y por tanto se le pueden asociar propiedades y mtodos, as como
redefinir o extender su comportamiento.
Veamos algunos ejemplos:
Ejemplo 1
5.times { print "Me encanta Ruby!" }
En este primer ejemplo vemos cmo el nmero 5 tiene un mtodo "times" con el que tenemos un
bucle, al que le pasamos el bloque entre llaves para que sea ejecutado 5 veces.
Ejemplo 2
(1..100).each do |i| print i end
En este segundo ejemplo, vemos cmo los rangos de nmeros (1..100) tienen un mtodo "each" con
el que podemos tambin hacer un bucle, cogiendo cada valor en cada vuelta en el parmetro i.
Ejemplo 3
class umeric de! mas(") sel!.#(") end de! par$ ((sel!%&)'&) ((
sel! end de! impar$ !par$ end end n ( 5.mas ) * n ahora +ale 11
n.par$ * de+ol+er, !alse n.impar$ * de+ol+er, true
Aqu vemos la posibilidad de redefinir el lenguaje. Aunque la manera normal de sumar dos nmeros
es mediante el operador "+", hemos aadido un mtodo "mas" a la clase Numeric de donde
descienden todos los nmeros para poder sumarlos con esta otra sintaxis. Como vemos, en realidad
el operador "+" es azucar sintctico para el mtodo ".+" de la clase Numeric.
Pero ms importante que redefinirlo, sin duda es poder extenderlo: vemos en el anterior ejemplo
cmo podemos ampliar la clase Numeric con mtodos que nos indiquen si el nmero es par o impar.
Ruby es un lenguaje completo, maduro y estable con muchsimas ms caractersticas como manejo
de excepciones, recolector de basura, interaccin con libreras externas, multithreading
independientemente del sistema operativo, y es altamente portable (funciona en GNU/Linux, UNIX,
Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista, DOS, BeOS, OS/2).
Para profundizar en el lenguaje Ruby, visita la web oficial de Ruby y echa un vistazo a la
presentacin que hizo Sergio Gil en la Conferencia Rails 2006, titulada Ruby Mola (y por qu).
Qu es Rails?
Rails es un framework [?] creado para el desarrollo de aplicaciones web. Para entendernos, es una
serie de utilidades, de herramientas para crear aplicaciones web ms rpidamente que hacindolo
desde cero. Usando un framework evitamos reinventar la rueda, nos ahorramos muchsimo trabajo y
podemos concentrarnos en lo que verdaderamente importa: la lgica de la aplicacin, no en escribir
una y otra vez los mismos formularios y scripts de proceso para crear, leer, modificar y eliminar
datos en nuestra base de datos.
Frameworks para desarrollo web hay muchos: Cake para PHP, Django para Python, Spring para
Java, y muchos otros. Rails es un framework que usa el lenguaje Ruby, y por eso se conoce al
conjunto como Ruby on Rails. Pero tambin existen otros frameworks para Ruby que no son Rails,
como puede ser el microframework Camping.
Rails fu desarrollado por el dans David Heinemeier, como una herramienta para facilitarle el
trabajo al programar la aplicacin web Basecamp para la empresa 37 Signals. En julio de 2004
liber el cdigo como software libre, y en febrero de 2005 comenz a aceptar colaboraciones para
mejorar Rails, formndose un amplio equipo de programadores, el core team.



David Heinemeier y el Rails Core Team
Entre las caractersticas de Ruby on Rails podemos destacar que est basado en el patrn de diseo
MVC (Modelo-Vista-Controlador [?]) con el que se separa la lgica de la presentacin, que nos
permite dejar de pensar siempre en SQL para pasar a pensar en objetos, que dispone de utilidades
para generar rpidamente interfaces de administracin, es independiente de la base de datos,
podemos realizar tests continuos para garantizar que nuestra aplicacin funciona como esperamos,
se puede extender mediante el uso de plugins, se integra muy fcilmente con libreras de efectos
como script.aculo.us... y todo ello escribiendo muy pocas lneas de cdigo, muy claras y fciles de
entender.
Vamos a ver todo esto mediante una serie de ejemplos prcticos, para no perdernos demasiado en la
teora.
Crear nuestra aplicacin
El primer paso para crear una nueva aplicacin Rails es crear la estructura base. Para ello abriremos
un terminal de comandos y escribiremos:
$ rails blog
Esto generar un directorio llamado "blog", que es el nombre de nuestra aplicacin, y dentro un
montn de subdirectorios y ficheros que forman la base de nuestra aplicacin. Entra en este nuevo
directorio y veamos los principales elementos:
$ cd blog $ ls app con!i- doc lo- Ra.e!ile script tmp components
db lib public R/01M/ test +endor
Dentro de app encontrars los ficheros correspondientes a los modelos, vistas, controladores y
helpers, que forman la parte principal de nuestra aplicacin (de ah el nombre de "app", que viene
de "application"). En config estn los ficheros de configuracin que definen el acceso a base de
datos y otros, en log encontraremos los ficheros de registro de servidor (logs), la carpeta public
contendr elementos estticos como imgenes, hojas de estilo y javascript...
Fjate que tambin existe una carpeta script. Contiene unas cuantas herramientas de Rails que nos
ayudarn en nuestro desarrollo. Vamos a probar la primera:
$ script/server
A continuacin, abre tu navegador web y dirgete a la direccin http://localhost:3000. Lo que vers
es la pgina de bienvenida de Ruby on Rails dentro de tu nueva aplicacin, y esto es porque Rails
viene con su propio servidor web de serie, llamado WEBrick. Si vuelves al terminal podrs
observar cmo WEBrick ha ido respondiendo a las peticiones del navegador web sirviendo los
ficheros solicitados.
La pgina de bienvenida a nuestra aplicacin Rails
WEBrick en funcionamiento
Mantn este terminal abierto con el servidor web en funcionamiento, y abre un nuevo terminal para
poder seguir usando las herramientas de Rails.
Nuestra aplicacin acceder a una base de datos, por lo que antes de continuar debemos crearla.
Emplearemos MySQL... crea una base de datos llamada "blog_development" con un usuario
"blogusr" y clave "blogpwd" usando tu herramienta favorita (phpMyAdmin, CocoaMySql...).
Nosotros lo haremos directamente desde lnea de comandos:
$ mysql -uroot -p (...) create database blo-2de+elopment de!ault
character set ut!3 collate ut!32unicode2ci4 -rant all on
blo-2de+elopment.' to 5blo-usr565localhost5 identi!ied by
5blo-p7d5 4
Una vez exista esta base de datos, abriremos el fichero config/database.yml y apuntaremos los
datos en el apartado development:
# coni!"database#yml
de+elopment8 adapter8 mys9l database8 blo-2de+elopment username8
blo-usr pass7ord8 blo-p7d soc.et8 %+ar%run%mys9ld%mys9ld.soc.
Fjate que en este fichero tenemos tres secciones principales, que corresponden a los tres entornos
que se manejan en una aplicacin Rails: development (desarrollo), test (pruebas) y production
(produccin). Cada entorno tendr su propia base de datos independiente, de manera que podamos
desarrollar tranquilos sin cambiar nada de la base de datos de produccin, y podamos testear en una
base de datos que se regenerar cada vez que lancemos la batera de tests. Pero por ahora usaremos
slo la base de desarrollo.
Crear art$culos
Queremos crear un blog, as que lo primero que necesitamos es poder escribir nuestros artculos.
Para nosotros, un artculo tendr un ttulo y un texto principal, as que comenzaremos con esto. Lo
primero que necesitamos es generar el modelo Articulo, para lo que usaremos el script de
generacin de modelos:
$ script/generate model Articulo e"ists app%models% e"ists
test%unit% e"ists test%!i"tures% create app%models%articulo.rb
create test%unit%articulo2test.rb create
test%!i"tures%articulos.yml create db%mi-rate create
db%mi-rate%0012create2articulos.rb
Vemos que al lanzarlo, el script comprueba que existan los subdirectorios necesarios, y crea varios
ficheros: en orden, articulo.rb contendr la lgica del modelo; los archivos dentro de test nos
facilitan el testeo de esta lgica, y el fichero creado dentro de db/migrate nos facilita especificar la
estructura de la tabla que almacenar los artculos en la base de datos. Vamos a abrir y rellenar este
fichero:
# db"mi!rate"%%1&create&articulos#rb
class :reate0rticulos ; 0cti+eRecord88Mi-ration de! sel!.up
create2table 8articulos do |t| t.column 8titulo< 8strin-
t.column 8cuerpo< 8te"t end end de! sel!.do7n
drop2table 8articulos end end
Vemos que en este fichero define dos mtodos, uno llamado self.up que realizar los cambios
necesarios, y otro llamado self.down que deshace estos mismos cambios en caso de que
quisiramos echarnos atrs.
Las acciones que realizamos dentro de self.up son muy sencillas de leer: si lo leemos en ingls casi
nos sale la frase "crea una tabla articulos y haz una columna ttulo que es una cadena y una
columna cuerpo que es un texto". Por otro lado, self.down dice simplemente "tira la tabla
articulos".
Adems de las columnas que definamos aqu, Rails incluir automticamente para cada tabla una
columna "id" para el identificador nico de cada fila de la tabla.
Nos podemos fijar tambin en que nosotros pedimos definir el modelo Articulo (en singular), y
Rails siguiendo sus convenciones, supone que nos pondremos de acuerdo en llamar a la tabla
"articulos", como el plural del modelo. Rails es lo suficientemente listo como para saber hacer el
plural incluso en casos irregulares como Person -> people. Tambin podemos definir nuestras
propias reglas de pluralizacin para definir las reglas gramaticales de otros idiomas y hacer que por
ejemplo pluralice correctamente un modelo Camion como camiones, en lugar de "camions".
Para aplicar esta definicin del modelo Articulo en la base de datos, ejecutaremos:
$ rake db:migrate (in %home%=aime%blo-) (( :reate0rticulos8
mi-ratin- ((((((((((((((((((((((((((((((((((((((((((((((((( >>
create2table(8articulos) >? 0.0@@0s (( :reate0rticulos8 mi-rated
(0.0@@As) ((((((((((((((((((((((((((((((((((((((((
Al ejecutar esta orden, Rails leer el fichero config/database.yml para saber cmo acceder a la base
de datos, y aplicar las rdenes definidas en la migracin para crear las tablas en MySQL. Si en el
fichero de configuracin hubiramos especificado otro tipo de base de datos (PostgreSQL, Oracle,
Sqlite, SQL Server...) en lugar de MySQL, Rails habra sabido cmo crear las tablas; l se ocupa de
la sintaxis SQL de cada tipo de base de datos y nosotros podemos definirlo a un nivel ms alto de
abstraccin.
Ya tenemos nuestro modelo Articulo creado y la tabla que almacenar sus datos; ahora necesitamos
un controlador para administrar los artculos, que nos permita crearlos, modificarlos, borrarlos...
Para ello ejecutaremos:
$ script/generate controller Admin e"ists app%controllers% e"ists
app%helpers% create app%+ie7s%admin e"ists test%!unctional% create
app%controllers%admin2controller.rb create
test%!unctional%admin2controller2test.rb create
app%helpers%admin2helper.rb
Acabamos de generar nuestro primer controlador, al que hemos bautizado como "admin". Por ahora
est vaco, no hace nada, como podemos comprobar visitando http://localhost:3000/admin: nos
indicar que ninguna accin ha respondido al mtodo index.
Para comenzar rpidamente, vamos a hacer uso de una caracterstica de Rails llamada scaffold, que
se traduce por "andamio", y es precisamente eso: al igual que al construir edificios uno se apoya en
andamios al comienzo de la construccin, y posteriormente termina quitndolos cuando la
construccin est avanzada y ya no los necesitamos. Un scaffold nos genera listados, formularios y
lgica de proceso para las operaciones ms comunes en una interfaz de administracin: crear,
visualizar, modificar y eliminar.
Edita el fichero app/controllers/admin_controller.rb y ponlo como en el siguiente ejemplo:
# app"controllers"admin&controller#rb
class 0dmin:ontroller ; 0pplication:ontroller sca!!old 8articulo
end
A continuacin, reinicia WEBrick (para la mayora de los cambios no es necesario reiniciarlo, pero
como hemos modificado el fichero de configuracin de base de datos, lo necesitaremos hacer), y
dirgete de nuevo a http://localhost:3000/admin... prueba el interfaz y crea unos cuantos artculos de
prueba, modfcalos, elimina, etc... Si creas ms de 10 podrs ver cmo aparecen automticamente
los enlaces de paginacin. Todo esto te lo acabas de ahorrar, no necesitas programarlo ya que el
scaffold de Rails lo ha generado por t.
Scaffold de administracin de artculos
Despus de trastear un rato con este interfaz de administracin, caemos en la cuenta de que nos
gustara que el modelo Articulo tuviera ms campos. Nos gustara poder almacenar la fecha y hora
en que se cre el artculo, as como la fecha y hora de la ltima modificacin. Para ello, lo que
necesitamos es una nueva migracin donde definamos los cambios en la base de datos:
$ script/generate migration fechas_en_articulos e"ists db%mi-rate
create db%mi-rate%00&2!echas2en2articulos.rb
Editamos el archivo generado y lo dejamos as:
# db"mi!rate"%%2&ec'as&en&articulos#rb
class Bechas/n0rticulos ; 0cti+eRecord88Mi-ration de! sel!.up
add2column 8articulos< 8created2at< 8datetime
add2column 8articulos< 8updated2at< 8datetime end de! sel!.do7n
remo+e2column 8articulos< 8created2at
remo+e2column 8articulos< 8updated2at end end
Este cdigo se lee fcilmente: aadir a la tabla "articulos" dos columnas "created_at" y "updated_at"
de tipo fecha y hora; y si nos echamos atrs, eliminar esas columnas. Por qu le hemos puesto
nombres en ingls a estos campos de fecha? Pues para aprovecharnos de que si lo hacemos as,
Rails se encargar automticamente de rellenar estos campos de fecha sin que tengamos que
programarlo, cada vez que se cree o actualice un artculo.
Para aplicar estos cambios ejecutaremos:
$ rake db:migrate (in %home%=aime%blo-) (( Bechas/n0rticulos8
mi-ratin- ((((((((((((((((((((((((((((((((((((((((((((((( >>
add2column(8articulos< 8created2at< 8datetime) >? 0.0C5As >>
add2column(8articulos< 8updated2at< 8datetime) >? 0.00))s ((
Bechas/n0rticulos8 mi-rated (0.05&&s)
((((((((((((((((((((((((((((((((((((((
Si ahora volvemos al interfaz de administracin, veremos que estos dos nuevos campos se han
incorporado a los listados y formularios, y funcionan como esperbamos. Evidentemente, los
artculos creados con anterioridad no tendrn almacenadas las fechas puesto que estos campos no
existan cuando los creamos.
Los scaffolds dinmicos son de mucha utilidad para arrancar rpidamente e ir viendo cmo queda la
aplicacin mientras vamos pensando qu campos necesitamos, pero llega un momento en que es
mejor disponer de los cdigos en ficheros de manera que los podamos modificar a nuestro antojo
para personalizar el aspecto (por ejemplo traducir las frases en ingls!). Para ello ejecutamos:
$ script/generate scaffold Articulo Admin e"ists app%controllers%
e"ists app%helpers% e"ists app%+ie7s%admin e"ists
app%+ie7s%layouts% e"ists test%!unctional% dependency model e"ists
app%models% e"ists test%unit% e"ists test%!i"tures% identical
app%models%articulo.rb identical test%unit%articulo2test.rb
identical test%!i"tures%articulos.yml create
app%+ie7s%admin%2!orm.rhtml create app%+ie7s%admin%list.rhtml
create app%+ie7s%admin%sho7.rhtml create app%+ie7s%admin%ne7.rhtml
create app%+ie7s%admin%edit.rhtml o+er7rite
app%controllers%admin2controller.rb$ DEna9dF y !orce
app%controllers%admin2controller.rb o+er7rite
test%!unctional%admin2controller2test.rb$ DEna9dF y !orce
test%!unctional%admin2controller2test.rb identical
app%helpers%admin2helper.rb create app%+ie7s%layouts%admin.rhtml
create public%stylesheets%sca!!old.css
Vemos que el script nos solicita nuestro permiso para sobreescribir un par de ficheros existentes,
que se crearon al generar el controlador. Contestaremos afirmativamente en ambos casos con "y".
Examinemos rpidamente los cdigos que nos ha generado este scaffold. Abre de nuevo el fichero
app/controllers/admin_controller.rb:
# app"controllers"admin&controller#rb
class 0dmin:ontroller ; 0pplication:ontroller de! inde" list
render 8action (? 5list5 end * G/Hs should be sa!e (see
http8%%777.7A.or-%&001%ta-%doc%7henHoIseGet.html) +eri!y 8method
(? 8post< 8only (? D 8destroy< 8create< 8update F< 8redirect2to (?
{ 8action (? 8list } de! list 6articulo2pa-es< 6articulos (
pa-inate 8articulos< 8per2pa-e (? 10 end de! sho7 6articulo (
0rticulo.!ind(paramsD8idF) end de! ne7 6articulo ( 0rticulo.ne7
end de! create 6articulo ( 0rticulo.ne7(paramsD8articuloF) i!
6articulo.sa+e !lashD8noticeF ( 50rticulo 7as success!ully
created.5 redirect2to 8action (? 5list5 else render 8action (?
5ne75 end end de! edit 6articulo ( 0rticulo.!ind(paramsD8idF) end
de! update 6articulo ( 0rticulo.!ind(paramsD8idF) i!
6articulo.update2attributes(paramsD8articuloF) !lashD8noticeF (
50rticulo 7as success!ully updated.5 redirect2to 8action (?
5sho75< 8id (? 6articulo else render 8action (? 5edit5 end end de!
destroy 0rticulo.!ind(paramsD8idF).destroy redirect2to 8action (?
5list5 end end
Vindolo en orden, vemos que define todos los mtodos que necesitamos para administrar los
artculos. No intentes comprender ahora toda la sintaxis empleada, qudate con la idea general:
index corresponde a la portada principal, que hace lo mismo que list y pinta ("render") lo
mismo que esa accin.
list genera un listado paginado con los artculos.
show busca el artculo cuyo id se haya indicado por parmetro y lo almacena en la variable
@articulo.
new prepara un nuevo Articulo, vaco.
create crea un nuevo Articulo con los parmetros que le hayan pasado y lo salva en la base.
Si tiene xito, prepara un mensaje de "OK" y redirige al listado; si no, redirige de vuelta a la
accin "new".
update busca el artculo por el id indicado, y se intenta actualizar con los parmetros
pasados. Si tiene xito, redirige a "show", y si no, de vuelta a "edit".
destroy busca el artculo por id, lo elimina y redirige al listado.
A cada accin del controlador le corresponde una vista. Encontrars los ficheros correspondientes
en app/views/admin. Si los abres, vers que son simples ficheros HTML, con partes de cdigo Ruby
embebido, usando las etiquetas <% y %>, similar a otros lenguajes de script para web.
list.rhtml muestra el listado de artculos.
show.rhtml muestra una ficha de artculo.
new.rhtml muestra la pgina para crear un artculo.
edit.rhtml muestra la pgina para editar un artculo.
_form.rhtml contiene el formulario de artculo, compartido por las acciones new y edit.
Esto es lo que se conoce como "partial", ya que contiene un cdigo parcial, que se inserta
dentro de otro para completarse.
Podemos modificar todos estos ficheros a nuestro antojo. Por ejemplo, prueba a cambiar list.rhtml
por lo siguiente para tener un listado algo ms sencillo:
# app"(ie)s"admin"list#r'tml
;h1?Jos artKculos de mi blo-;%h1? ;L !or articulo in
6articulos.re+erse L? ;h&?;L( lin.2to articulo.titulo< 8action
(? 8sho7< 8id (? articulo L?;%h&? ;p?;L(
simple2!ormat(h(articulo.cuerpo)) L?;%p? ;p?;L( lin.2to 5Morrar5<
{ 8action (? 5destroy5< 8id (? articulo }< 8con!irm (? 5NOe-uro$5<
8method (? 8post L?;%p? ;hr %? ;L end L? ;L( lin.2to 50nterior5< {
8pa-e (? 6articulo2pa-es.current.pre+ious } i!
6articulo2pa-es.current.pre+ious L? ;L( lin.2to 5Oi-uiente5<
{ 8pa-e (? 6articulo2pa-es.current.ne"t } i!
6articulo2pa-es.current.ne"t L? ;br %? ;L( lin.2to
5ue+o5< 8action (? 5ne75 L?
*arte p+blica del blo!
Ya tenemos un interfaz web que nos permite administrar los artculos. Esta zona ser privada
(posteriormente podramos ponerle proteccin por usuario y contrasea); necesitamos una parte
pblica que muestre los artculos.
Vamos a crear para ello un nuevo controlador, que tendr por el momento slo 2 acciones:
"index" (la pgina principal que mostrar los artculos) y "detalles" (la pgina que mostrar todos
los detalles de un artculo):
$ script/generate controller Blog index detalles e"ists
app%controllers% e"ists app%helpers% create app%+ie7s%blo- e"ists
test%!unctional% create app%controllers%blo-2controller.rb create
test%!unctional%blo-2controller2test.rb create
app%helpers%blo-2helper.rb create app%+ie7s%blo-%inde".rhtml
create app%+ie7s%blo-%detalles.rhtml
Ahora abriremos el controlador, app/controllers/blog_controller.rb, y definiremos las dos
acciones:
# app"controllers"blo!&controller#rb
class Mlo-:ontroller ; 0pplication:ontroller de! inde" 6articulos
( 0rticulo.!ind(8all< 8order (? 5id 1/O:5) end de! detalles
6articulo ( 0rticulo.!ind(paramsD8idF) end end
Como vemos, las acciones son muy sencillas: en index, creamos el objeto @articulos que
contendr todos (:all) los artculos, ordenados a la inversa (:order => 'id DESC') para mostrar los
ltimos arriba. La accin "detalles" crear el objeto @articulo buscndolo por el id pasado como
parmetro.
Ahora necesitamos crear las vistas, que cogern estos objetos que hemos preparado en el
controlador y mostrarn su informacin por pantalla. Comencemos por la vista correspondiente a la
accin "index", editando el fichero app/views/blog/index.rhtml. Como vers es un simple bucle
que recorre @articulos, y para cada uno muestra su ttulo, cuerpo y una lnea de separacin al final.
El ttulo se muestra en forma de enlace a la accin "detalles", con el id del artculo en curso dentro
del bucle. El cuerpo se muestra usando tres "helpers" de texto: "h" se encarga de asegurar que el
html mostrado es seguro (para evitar buena parte de ataques); "truncate" se encarga de recortar el
texto en caso de que sea ms largo que la longitud especificada, y "simple_format" se encarga de
dar un formato muy simple a un texto para mostrarlo como HTML, por ejemplo convirtiendo los
saltos de lnea en prrafos.
# app"(ie)s"blo!"inde,#r'tml
;L !or articulo in 6articulos L? ;h1?;L( lin.2to
articulo.titulo< 8action (? 8detalles< 8id (? articulo L?;%h1? ;L(
simple2!ormat(truncate(h(articulo.cuerpo)<&00)) L? ;hr %? ;L end
L?
El listado de artculos
A continuacin, edita app/views/blog/detalles.rhtml para crear la ficha de artculo. El cdigo en
esta ocasin muestra el ttulo del artculo sin ser enlace, el cuerpo sin cortar, y adems abajo la
fecha en el formato dia-mes-ao [hora:minuto].
;h1?;L( 6articulo.titulo L?;%h1? ;L(
simple2!ormat(h(6articulo.cuerpo)) L? ;p?;em?;L(
6articulo.created2at.str!time("Ld>Lm>LE DLP8LMF") L?;%em?;%p?
Detalle de artculo
Comentarios
Para finalizar el blog, necesitamos poder recoger y mostrar los comentarios que los visitantes
quieran dejar en cada artculo. Es hora de crear un nuevo modelo: Comentario. Un comentario
tendr un texto, el nombre del usuario, la fecha de creacin, y el id del artculo al que est asociado.
$ script/generate model omentario e"ists app%models% e"ists
test%unit% e"ists test%!i"tures% create app%models%comentario.rb
create test%unit%comentario2test.rb create
test%!i"tures%comentarios.yml e"ists db%mi-rate create
db%mi-rate%00A2create2comentarios.rb
Editamos el fichero de migracin:
# db"mi!rate"%%3&create&comentarios#rb
class :reate:omentarios ; 0cti+eRecord88Mi-ration de! sel!.up
create2table 8comentarios do |t| t.column 8te"to< 8te"t
t.column 8nombre< 8strin- t.column 8created2at< 8datetime t.column
8articulo2id< 8inte-er end end de! sel!.do7n
drop2table 8comentarios end end
Ejecutamos la migracin para crear la nueva tabla de comentarios...
$ rake db:migrate (in %home%=aime%blo-) (( :reate:omentarios8
mi-ratin- ((((((((((((((((((((((((((((((((((((((((((((((( >>
create2table(8comentarios) >? 0.101Qs (( :reate:omentarios8
mi-rated (0.101@s) ((((((((((((((((((((((((((((((((((((((
Hemos creado la nueva tabla de comentarios, que incluye un campo para relacionarlos con el
artculo que le corresponda. Ahora hemos de indicar qu tipo de relacin queremos entre artculos y
comentarios, editando los modelos. Queremos que un artculo pueda tener varios comentarios, y que
un comentario pertenezca a un nico artculo, as que esto se traduce en lo siguiente:
# app"models"articulo#rb
class 0rticulo ; 0cti+eRecord88Mase has2many 8comentarios end
# app"models"comentario#rb
class :omentario ; 0cti+eRecord88Mase belon-s2to 8articulo end
A continuacin necesitamos un formulario para permitir a los usuarios crear comentarios para un
artculo. Editaremos la vista de detalle de artculo:
# app"(ie)s"blo!"detalles#r'tml
;h1?;L( 6articulo.titulo L?;%h1? ;L(
simple2!ormat(h(6articulo.cuerpo)) L? ;p?;em?;L(
6articulo.created2at.str!time("Ld>Lm>LE DLP8LMF") L?;%em?;%p?
;h&?:omentarios;%h&? ;L !or comentario in 6articulo.comentarios L?
;L( simple2!ormat(h(comentario.te"to)) L? ;p?;em?;L(
comentario.nombre L?;%em?< ;L( comentario.created2at.str!time("Ld>
Lm>LE DLP8LMF") L?;%p? ;L end L? ;hA?0Rade tu comentario a este
artKculo!;%hA? ;L !orm2ta- 8action (? 5comenta5< 8id (? 6articulo
do L? ;p?;label !or("comentario2nombre"?ombre;%label?;br%? ;L(
te"t2!ield 5comentario5< 5nombre5 L?;%p? ;p?;label
!or("comentario2te"to"?Mensa=e;%label?;br%? ;L( te"t2area
5comentario5< 5te"to5< {8ro7s (? 5< 8cols (? 30} L?;%p? ;L(
submit2ta- 5/n+iar comentario5 L? ;L end L?
En primer lugar, hemos creado una seccin que muestra los comentarios del artculo. Fjate en que
encontrar los comentarios de un artculo es tan sencillo como usar @articulo.comentarios, y
realizar un bucle sobre ellos.
En segundo lugar, mostramos el formulario de creacin de comentarios. La accin del formulario
apunta a la accin "comenta", con el id del artculo actual. Dentro del formulario incluimos un rea
de texto para el nombre del usuario y un rea de texto para el mensaje.
Slo nos falta definir la accin "comenta". Editaremos el controlador del blog y la aadimos al
final:
# app"controllers"blo!&controller#rb
class Mlo-:ontroller ; 0pplication:ontroller de! inde" 6articulos
( 0rticulo.!ind(8all< 8order (? 5id 1/O:5) end de! detalles
6articulo ( 0rticulo.!ind(paramsD8idF) end de! comenta
0rticulo.!ind(paramsD8idF).comentarios.create(paramsD8comentarioF)
redirect2to 8action (? 8detalles< 8id (? paramsD8idF end end
La nueva accin "comenta" busca el artculo con el id indicado por parmetro, y en sus comentarios
crea uno con los parmetros del comentario (nombre y texto).
-uiciente por 'oy###
Nuestro blog est listo! Puedes probar a crear artculos desde "/admin" y a verlos en la parte pblica
"/blog", dejando comentarios y viendo cmo aparecen para cada uno.
Si quieres puedes descargar el cdigo del blog que hemos creado para tenerlo de referencia.
En siguientes entregas del tutorial de introduccin aprenderemos a usar tests y validaciones, usar
layouts, AJAX, RSS y varios plugins.
Hasta la prxima!