Ruby On Rails

2015
Introduccin a Rails
Introduccin a Ruby on Rails

Comunidad Rails
LIBROSWEB | www.librosweb.es
Conversin a PDF por Roberto Ortiz|www.noia.mx
Contenido
Captulo 1. Antes de empezar ........................................................................................................ 3
Captulo 2. Qu es Rails? ............................................................................................................. 4
Captulo 3. Creando un nuevo proyecto ....................................................................................... 5
3.1. Instalando Rails .................................................................................................................. 5
3.2. Creando la aplicacin de Blog ........................................................................................ 6
Captulo 4. Hola, Rails! .................................................................................................................... 9
4.1. Iniciando el Servidor Web ................................................................................................ 9
4.2. Hola Mundo ........................................................................................................................ 11
4.3. Estableciendo la pgina principal ................................................................................ 12
Captulo 5. Creando un nuevo post ................................................................................................... 15
5.1. Primeros pasos ...................................................................................................................... 16
5.2. El primer formulario ........................................................................................................... 19
5.3. Creando artculos ................................................................................................................. 21
5.4. Creando el modelo Article .............................................................................................. 22
5.5. Migraciones ........................................................................................................................... 23
5.6. Guardando datos en el controlador .................................................................................... 24
5.7. Mostrando artculos ............................................................................................................. 26
5.8. Listando todos los artculos ................................................................................................. 27
5.9. Aadiendo enlaces ................................................................................................................ 29
5.10. Aadiendo validaciones ..................................................................................................... 30
5.11. Actualizando artculos ....................................................................................................... 34
5.12. Usando parciales para eliminar las duplicidades en las vistas ....................................... 37
5.13. Borrando artculos ............................................................................................................. 39
Captulo 6. Aadiendo otro modelo ............................................................................................. 43
6.1. Generando el modelo ...................................................................................................... 43
6.2. Asociando modelos ......................................................................................................... 45
6.3. Aadiendo una ruta para los comentarios ................................................................ 46
6.4. Generando un controlador............................................................................................. 46
Captulo 7. Refactorizacin ........................................................................................................... 53
7.1. Renderizando colecciones de parciales..................................................................... 53
7.2. Renderizando un formulario parcial ............................................................................ 55
Captulo 8. Borrando comentarios ............................................................................................... 57
8.1. Borrando los objetos asociados .................................................................................. 58

Captulo 9. Seguridad .................................................................................................................... 60
9.1. Autenticacin bsica ....................................................................................................... 60
9.2. Otros comentarios sobre la seguridad ....................................................................... 62
Captulo 10. Siguientes pasos ...................................................................................................... 63
Captulo 1. Antes de empezar

Esta gua est diseada para principiantes que quieren comenzar con Ruby on
Rails desde cero. No es necesario que tengas ninguna experiencia previa con
Rails. Sin embargo, para obtener el mximo de esta gua, tu ordenador s que
debe cumplir algunos requisitos tcnicos. En concreto, debes disponer de:
El lenguaje de programacin Ruby en su versin 1.9.3 o mayor.
El sistema de paquetes RubyGems. Si quieres aprender ms acerca de

RubyGems, puedes leer la gua en ingls:RubyGems User Guide.
La base de datos SQLite3.
Rails es un framework para aplicaciones web que corre sobre el lenguaje de

programacin Ruby. Si no tienes ninguna experiencia con Ruby, existen algunos
recursos gratis en la Internet para aprender Ruby, incluyendo:
Aprende a Programar con Ruby.
Mr. Neighborly's Humble Little Ruby Book.
Programming Ruby.
Why's (Poignant) Guide to Ruby.
Captulo 2. Qu es Rails?
Rails es un framework de desarrollo de aplicaciones web escrito en el lenguaje de
programacin Ruby. Est diseado para hacer que la programacin de
aplicaciones web sea ms fcil, haciendo supuestos sobre lo que cada
desarrollador necesita para comenzar. Te permite escribir menos cdigo
realizando ms que muchos otros lenguajes y frameworks. Adems, expertos
desarrolladores en Rails reportan que hace que el desarrollo de aplicaciones web
sea ms divertido.
Rails es un software dogmtico. ste asume que existe una forma "mejor" de
hacer las cosas, y est diseado para fomentar esa forma - y en algunos casos
para desalentar alternativas.
Si aprendes "El Modo Rails" probablemente descubrirs un tremendo incremento
en tu productividad. Si persistes trayendo viejos hbitos de otros lenguajes a tu
desarrollo en Rails, e intentas usar patrones aprendidos en otros lugares, podras
tener una experiencia menos agradable.
La filosofa de Rails se basa en estos dos principios:
DRY (del ingls, "Don't Repeat Yourself") - sugiere que escribir el mismo
cdigo una y otra vez es una mala prctica.
"Convencin sobre Configuracin" - significa que Rails hace algunas

suposiciones sobre lo que quieres hacer y cmo vas a hacerlo, en lugar de
requerir que especifiques cada pequea cosa a travs de un sin fin de
archivos de configuracin.
Captulo 3. Creando un nuevo proyecto

La mejor forma de usar esta gua es seguir cada paso tal y como se muestra. No
hemos ahorrado ninguna lnea de cdigo en las explicaciones, as que puedes
seguirla literalmente paso a paso. Ver el cdigo completo.
Al seguir esta gua, vas a crear un proyecto Rails llamado blog, que es un motor
de blogs muy sencillo. Antes de que puedas comenzar a crear la aplicacin,
asegrate de tener Rails instalado.
Los ejemplos que se muestran a continuacin usan el carcter $ para
representar a la consola de comandos de los sistemas operativos basados en
UNIX. Si ests usando Windows, la lnea de comandos se ver como c:\>.
TRUCO
3.1. Instalando Rails

Lo primero que debes hacer es abrir una consola de comandos. En Mac OS X eso
significa abrir la aplicacinTerminal.app. En Windows pincha sobre el men de
inicio y elige la opcin Ejecutar y teclea cmd.exe.
Las lneas que empiezan por $ son los comandos que debes ejecutar en la
consola. Lo primero es comprobar que tienes instalada alguna versin reciente de
Ruby:
$ ruby -v
ruby 2.0.0p353
Existen varias herramientas para instalar Ruby en tu sistema operativo. Los

usuarios de Windows pueden utilizar el instalador de Rails, mientras que los
usuarios de Mac OS X pueden usar Tokaido.
TRUCO
Adems, tu sistema debe contar con SQLite 3 instalado correctamente. Para

comprobar si es as, ejecuta el siguiente comando:
$ sqlite3 --version
Una vez comprobado que tienes tanto Ruby como SQLite 3, para instalar Rails,
usa el comando proporcionado por RubyGems gem install:
$ gem install rails
Para verificar que tu instalacin est correcta, deberas poder ejecutar lo siguiente:
$ rails --version
Si dice algo como "Rails 4.1.1", ests listo para continuar.
3.2. Creando la aplicacin de Blog

Rails viene con un nmero de generadores que estn diseados para hacer tu
ciclo de desarrollo ms fcil. Uno de esos es el generador de nuevas aplicaciones,
que crea la estructura base de una aplicacin Rails, por lo que no tienes que
escribirla por ti mismo.
Para usar este generador, abre la consola de comandos, navega hacia el
directorio en donde tienes permiso para crear archivos, y ejecuta:
$ rails new blog
Esto crear una aplicacin Rails llamada Blog en un directorio llamado blog e
instalar las dependencias (gemas) que estn mencionadas en el Gemfile usando
el comando bundle install.
Puedes ver todas las opciones que el generador de nuevas aplicaciones
provee, ejecutando rails new -h.
Despus de crear la aplicacin, entra a su directorio para continuar trabajando
directamente en la aplicacin:
TRUCO
$ cd blog
El comando rails new blog que acabamos de ejecutar, cre una carpeta en tu
directorio de trabajo llamado blog. El directorio blog tiene un nmero de archivos
autogenerados y carpetas que conforman la estructura de una aplicacin Rails.
La mayora del trabajo en este tutorial se llevar a cabo en la carpeta app/, as que
primero hagamos un repaso rpido al propsito de cada archivo y carpeta de
Rails:
Archivo/Carpeta
Propsito
app/
Contiene los controllers, models, views, helpers, mailers y assets

para tu aplicacin. Te centrars en esta carpeta por el resto de esta
gua.
config/
Configura las reglas de ejecucin de la aplicacin, rutas, base de

datos y ms. Este tema es cubierto en mayor detalle en Configuring
Rails Applications.
config.ru
Configuracin Rack para servidores basados en Rack usados para

iniciar la aplicacin.
db/
Contiene el esquema actual de tu base de datos, as como las

migraciones de la base de datos.
doc/
Documentacin detallada de tu aplicacin.
GemfileGemfile.lock
Estos archivos te permiten especificar qu dependencias de gemas

son necesitadas para tu aplicacin Rails. Estos archivos son usados
por la gema Bundler, ver Sitio web de Bundler
lib/
Mdulos extendidos para tu aplicacin.
log/
Archivos de Log de tu aplicacin.
public/
La nica carpeta vista por el mundo tal como es. Contiene los
archivos estticos y assets compilados.
Archivo/Carpeta
Propsito
Rakefile
Este archivo localiza y carga tareas que pueden ser ejecutadas desde
la lnea de comandos. La lista de tareas son definidas a travs de los
componentes de Rails. En vez de cambiar el Rakefile, deberas
agregar tus propias tareas, aadiendo archivos al
directorio lib/tasks de tu aplicacin.
README.rdoc
Este es un breve manual de instrucciones para tu aplicacin.

Deberas editar este archivo para comunicar a otros lo que tu
aplicacin hace, cmo configurala y dems.
script/
Contiene el script de Rails que inicia tu aplicacin y contiene otros

scripts usados para deployar o correr tu aplicacin.
test/
Pruebas unitarias, fixtures y otras pruebas. stos son cubiertos

en Testing Rails Applications.
tmp/
Archivos temporales (como archivos de cach, PID y archivos de

sesiones).
vendor/
Lugar para cdigo de terceros. En una tpica aplicacin Rails, sta

incluye libreras y plugins.
Captulo 4. Hola, Rails!

Para comenzar, vamos a mostrar algo de texto en la pantalla rpidamente. Para
hacer sto, necesitas tener tu servidor de aplicacin Rails corriendo.
4.1. Iniciando el Servidor Web

En realidad ya tienes una aplicacin Rails funcional, Para verla, necesitas iniciar
un servidor web en tu mquina de desarrollo. Puedes hacerlo ejecutando:
$ rails server
TRUCO
Compilar CoffeeScript a JavaScript requiere de herramientas adicionales. Si
no dispones de ellas, vers un error de tipo execjs. Normalmente Mac OS X y

Windows ya incluyen estas utilidades. Rails agrega la
gematherubyracer al Gemfile en una lnea comentada para nuevas aplicaciones y
puedes descomentarla si la necesitas.
therubyrhino es el runtime de JavaScript recomendado para usuarios de JRuby y
es aadido por defecto al Gemfileen aplicaciones generadas bajo JRuby. Puedes

investigar acerca de todos los runtimes soportados en ExecJS.
Esto lanzar WEBrick, un servidor web incorporado en Ruby por defecto. Para ver
tu aplicacin en accin, abre tu navegador preferido y accede
a http://localhost:3000. Deberas ver la pgina de informacin por defecto de Rails.
Figura 4.1 Pgina de bienvenida de Rails

Para detener el servidor web, presiona Ctrl+C en la ventana de la lnea de
comandos donde se est ejecutando. En modo de desarrollo, Rails generalmente
no requiere reiniciar el servidor web; los cambios realizados sern tomados
automticamente por el servidor.
La pgina "Welcome Aboard" es la primera prueba para una nueva aplicacin
TRUCO
Rails: sta asegura que tienes el software configurado correctamente para servir
una pgina. Tambin puedes hacer click en el link About your application's
enviroment para ver un resumen del entorno de tu aplicacin.
4.2. Hola Mundo

Para conseguir que Rails diga "Hola", necesitas crear como mnimo
un controlador y una vista.
El propsito de un controlador es recibir las peticiones (requests) de la aplicacin.
El enrutamiento (routing) decide qu controlador recibe qu peticin.
A menudo, hay ms de una ruta para cada controlador, y diferentes rutas pueden
ser servidas por diferentes acciones (actions). El propsito de cada accin es
obtener informacin para pasarla despus a la vista.
El propsito de una vista es mostrar la informacin en un formato legible para los
humanos. Una distincin importante que hacer es que es el controlador, y no la
vista, donde la informacin es recolectada. La vista slo debera mostrar la
informacin. Por defecto, las plantillas de las vistas estn escritas en un lenguaje
llamado ERB (del ingls, Embedded Ruby), que se procesa automticamente para
cada peticin servida por Rails.
Para crear un nuevo controlador, necesitas ejecutar el generador de controladores
y decirle que quieres un controlador llamado por ejemplo welcome con una accin
llamada index. Para ello, ejecuta lo siguiente:
$ rails generate controller welcome index
Rails crear una serie de archivos y aadir una ruta por ti.
create
route
invoke
app/controllers/welcome_controller.rb
get "welcome/index"
erb
create
app/views/welcome
create
app/views/welcome/index.html.erb
invoke
create
test_unit
test/functional/welcome_controller_test.rb
invoke
helper
create
app/helpers/welcome_helper.rb
invoke
test_unit
create
invoke
invoke
create
invoke
create
test/unit/helpers/welcome_helper_test.rb
assets
coffee
app/assets/javascripts/welcome.js.coffee
scss
app/assets/stylesheets/welcome.css.scss
Los archivos ms importantes de stos son por supuesto el controlador, que se

encuentra enapp/controllers/welcome_controller.rb y la vista, que se encuentra
en app/views/welcome/index.html.erb.
Abre el archivo app/views/welcome/index.html.erb en tu editor de texto y edtalo
para que contenga slo est lnea de cdigo:
<h1>Hello, Rails!</h1>
4.3. Estableciendo la pgina principal

Ahora que hemos hecho el controlador y la vista, necesitamos decirle a Rails
cundo queremos que se muestre Hello Rails. En nuestro caso, deseamos
mostrarlo al acceder a la portada de nuestro sitio, http://localhost:3000. Por el
momento, sin embargo, la pgina "Welcome Aboard" est ocupando ese lugar.
Para arreglarlo, borra el archivo index.html ubicado dentro de la carpeta public de
la aplicacin.
Necesitas hacer sto debido a que Rails servir preferentemente cualquier archivo
esttico en la carpeta public que coincida con una ruta de la aplicacin.
El archivo index.html es especial, ya que se sirve si llega una peticin a la ruta
raz de la aplicacin (enhttp://localhost:3000). Si haces otra peticin (por
ejemplo http://localhost:3000/welcome), se servira el archivo
esttico public/welcome.html, pero slo si existiera.
A continuacin, tienes que indicarle a Rails donde est ubicada tu pgina principal.
Para ello, abre el archivoconfig/routes en tu editor:
Blog::Application.routes.draw do
get "welcome/index"
# The priority is based upon order of creation:

# first created -> highest priority.
# ...
# You can have the root of your site routed with "root"
# just remember to delete public/index.html.
# root :to => "welcome#index"
ste es el archivo de enrutamiento de tu aplicacin, que mantiene entradas con un

DSL especial (domain-specific language) que le dicen a Rails cmo conectar
peticiones entrantes a controladores y acciones.
Este archivo contiene muchas rutas de ejemplo en lneas comentadas, y una de
ellas en realidad muestra como conectar la raz de tu sitio a
un controlador y accin especficos. Encuentra la lnea iniciando con root :to y
descomntala. Debera verse como lo siguiente:
root :to => "welcome#index"
El root :to => "welcome#index" le indica a Rails que debe asociar las peticiones
de la raz de la aplicacin a la accinindex del controlador welcome y get
"welcome/index" le indica a Rails que asocie peticiones
dehttp://localhost:3000/welcome/index a la accin index del controlador welcome.

Este fue creado al inicio cuando ejecutaste el generador del controlador (rails
generate controller welcome index).
Si accedes a la direccin http://localhost:3000 en tu navegador, vers el

mensaje Hello, Rails! que colocaste dentro de la
vista app/views/welcome/index.html.erb, indicando que esta nueva ruta est en
realidad pasando a la accinindex del controlador Welcome y est renderizando la

vista correctamente.
Captulo 5. Creando un nuevo post

Ahora que has visto cmo crear un controlador, una accin y una vista, vamos a crear algo
un poco ms complejo.
En la aplicacin de blog, ahora vas a crear un nuevo recurso (resource). Un recurso es el
trmino usado para una coleccin de objetos similares, como artculos, personas o
animales. Puedes crear, leer, actualizar y eliminar objetos para un recurso y estas
operaciones son referidas como operaciones CRUD (del ingls, Create, Read, Update,
Destroy).
Rails incluye un mtodo llamado resources que puedes utilizar para declarar un recurso
REST estndar. Este es el aspecto que debera tener el archivo config/routes.rb despus
de haber declarado el recurso article:
Blog::Application.routes.draw do
resources :articles
root 'welcome#index'
end
Si ejecutas el comando rake routes, vers que se han definido varias rutas para todas las
acciones estndar de las aplicaciones RESTful. Ms adelante se explicar el significado de
cada columna. Por ahora so fjate en que Rails ha inferido que la palabra en singular del
recurso articles es article, con lo que el resultado es el siguiente:
$ bin/rake routes
Prefix Verb
articles GET
POST
new_article GET
edit_article GET
article GET
URI Pattern
Controller#Action
/articles(.:format)
articles#index
/articles(.:format)
articles#create
/articles/new(.:format)
articles#new
/articles/:id/edit(.:format) articles#edit
/articles/:id(.:format)
articles#show
PATCH
articles#update
PUT
articles#update
DELETE /articles/:id(.:format)
root GET
articles#destroy
welcome#index
En las prximas secciones aadirs la funcionalidad de crear artculos en la aplicacin y

tambin podrs visualizarlos. Estas dos acciones son, respectivamente, las letras C y R del
conjunto de acciones CRUD. El formulario para crear los artculos tendr este aspecto:
Figura 5.1 Formulario para crear artculos en el blog

Por el momento ser un formulario muy simple. Pero tranquilo porque despus ya le
aplicaremos estilos para mejorarlo.
5.1. Primeros pasos

La primera cosa que necesitaremos para crear un nuevo artculo, es crear una seccin
especial para esto en nuestra aplicacin. Un buen lugar podra ser /posts/new. Si tratas de
navegar a esa direccin ahora - visitandohttp://localhost:3000/articles/new - Rails mostrar
el siguiente mensaje de error:
Figura 5.2 Error de enrutamiento en Rails (ninguna ruta est configurada para servir
/articles/new)
Este error se produce porque la ruta necesita tener asociado un controlador para poder
servir las peticiones. As que la solucin es tan sencilla como crear un controllador
llamado ArticlesController. Si no quieres crearlo a mano, ejecuta el siguiente comando:
$ bin/rails g controller articles
Si ahora abres el archivo app/controllers/articles_controller.rb que se acaba de

generar, vers el siguiente controlador vaco:
class ArticlesController < ApplicationController
end
Un controlador es simplemente una clase que hereda de ApplicationController. Dentro

de esta clase defines los mtodos que se convertirn en las acciones del controlador. Estas
acciones son las que se encargan de las operaciones CRUD sobre los artculos de la
aplicacin.
Ruby permite definir mtodos pblicos, privados y protegidos, pero las acciones de
los controladores solo pueden ser mtodos pblicos.
Si ahora refrescas la pgina http://localhost:3000/articles/new, vers de nuevo un error,
pero diferente al anterior:
NOTA
Figura 5.3 Error de Rails: no existe la accin new en ArticlesController

Este error significa que Rails no puede encontrar la accin new dentro del
controlador ArticlesController que acabas de generar. El motivo es que cuando se
genera un controlador automticamente, su contenido est vaco a menos que le indiques
qu acciones quieres incluir.
Para aadir una accin a mano en un controlador, lo nico que necesitas es crear un nuevo
mtodo en el controlador. Abre el archivo app/controllers/articles_controller.rb y
dentro de la clase ArticlesController define un nuevo mtodo de esta manera:
def new
end
Refresca de nuevo la pgina http://localhost:3000/articles/new y vers que a pesar de haber

aadido el mtodo new, sigues viendo un mensaje de error:
Figura 5.4 Error de rails: no existe la plantilla para articles/new

La causa de este error es que Rails espera que las acciones de los controladores tengan
asociadas unas vistas para mostrar su informacin. Cuando no existe la vista, Rails muestra
el siguiente mensaje de error.
Missing template articles/new, application/new with
{locale:[:en], formats:[:html], handlers:[:erb, :builder, :coffee]}.
Searched in: * "/path/to/blog/app/views"
Vaya rollo de texto, verdad? Repasemos rpidamente cada parte de ese texto.
La primera parte identifica la plantilla que est faltando. En este caso, es la
plantila articles/new. Rails primero buscar esta plantilla. Si no la encuentra, luego
tratar de cargar la plantilla llamada application/new. El motivo es que tu
controlador ArticlesController hereda del controlador base ApplicationController.
La siguiente parte del mensaje contiene un mapa (en ingls, hash). La clave :locale en
este mapa simplemente indica el idioma para el que se debe obtener la plantilla. Por
defecto, est configurado en ingls (cdigo en).
La siguiente clave, :formats especifica el formato de la plantilla que ser servido en la
respuesta. El formato por defecto es :html, por lo que Rails busca una plantilla HTML. La
ltima clave, :handlers, nos dice qu manejador de plantilla (en ingls, template handler)
se puede usar para renderizar la plantilla. :erb es el manejador ms usado para plantillas
HTML, :builder se usa para plantillas XML, y :coffee usa CoffeeScript para construir
plantillas JavaScript.
La ltima parte del mensaje de error indica los lugares en los que Rails ha buscado las
plantillas. En una aplicacin Rails como esta las plantillas se guardan en un nico
directorio. Pero en aplicaciones ms complejas, las plantillas podran encontrarse repartidas
en varias localizaciones.
La plantilla ms simple que funcionara en nuestro caso sera una localizada
en app/views/articles/new.html.erb. La extensin de este nombre de archivo es muy
importante: la primera extensin define el formato de la plantilla, y la segunda extensin
el manejador de plantilla que se usar.
Rails tratar de encontrar una plantilla llamada articles/new en el directorio app/views.
El formato para esta plantilla slo puede ser html y el manejador debera
ser erb, builder o coffee. Ya que quieres crear un nuevo formulario HTML, tendrs que
usar el lenguaje ERB. Por lo tanto el archivo debera llamarse articles/new.html.erb y
debe encontrarse dentro de la carpeta app/views de la aplicacin.
Ahora crea un nuevo archivo en app/views/articles/new.html.erb y escribe el siguiente
contenido en l:
<h1>New Post</h1>
Cuando recargues http://localhost:3000/posts/new, vers que la pgina tiene un ttulo. La

ruta, el controlador, la accin y la vista ahora estn funcionando todos de manera conjunta
y por eso ya no se muestra ningn error. Ahora es el momento de crear un formulario para
crear artculos.
5.2. El primer formulario

Para crear un formulario dentro de esta plantilla, se utiliza un constructor de
formularios (en ingls, "form builder"). El principal constructor de formularios de Rails
incluye un helper llamado form_for. Para hacer uso de este mtodo, aade el siguiente
cdigo a app/views/posts/new.html.erb:
<%= form_for :post do |f| %>
<p>
<%= f.label :title %><br>
<%= f.text_field :title %>
</p>
<p>
<%= f.label :text %><br>
<%= f.text_area :text %>

</p>
<p>
<%= f.submit %>
</p>
<% end %>
Si recargas la pgina, ahora vers el mismo formulario que en el ejemplo. Crear

formularios en Rails es as de sencillo!
Cuando llamas a form_for, le pasas un objeto identificador para este formulario, que en
este caso, es el smbolo:article. Esto le indica al mtodo form_for para quin es este
formulario.
Dentro del bloque para este mtodo, el objeto FormBuilder - representado por f - se usa
para construir dos ttulos y dos cajas de texto, una para el ttulo del artculo y otra para su
contenido. Finalmente, la llamada al mtodo submit en el objeto f crea un botn para
enviar el formulario.
Sin embargo, existe un problema con este formulario. Si ver el cdigo HTML generado en
la pgina, vers que el atributo action de el formulario apunta a /articles/new. sto es
un problema porque esta ruta va a la misma pgina donde te encuentras en este momento,
cuando en realidad la ruta slo debera usarse para mostrar el formulario que crea nuevos
artculos.
El formulario necesita una URL distinta para poder dirigirse hacia algn otro lugar.
Conseguirlo es bastante sencillo, ya que basta utilizar la opcin :url del mtodo form_for.
En Rails la accin que se usa normalmente para crear nuevos elementos se
llama create (en espaol, "crear"), por lo que el formulario debera apuntar hacia esa
accin.
Edita la lnea de form_for de la vista app/views/posts/new.html.erb para que se vea as:
<%= form_for :article, url: articles_path do |f| %>
En este ejemplo se pasa el helper articles_path a la opcin :url. Para comprender qu es

lo que hace Rails con este objeto, recuerda cmo era el resultado de ejecutar el
comando rake routes:
$ bin/rake routes
Prefix Verb
articles GET
POST
new_article GET
edit_article GET
article GET
URI Pattern
Controller#Action
/articles(.:format)
articles#index
/articles(.:format)
articles#create
/articles/new(.:format)
articles#new
/articles/:id/edit(.:format) articles#edit
articles#show
PATCH
articles#update
PUT
articles#update
root GET
articles#destroy
welcome#index
El helper articles_path le dice a Rails que apunte el formulario a la URI asociada con el
prefijo articles, por lo que el formulario enviar por defecto peticiones POST a esa ruta.
Como ves, esta ruta est asociada con la accin create del controlador
actual, ArticlesController.
Con el formulario y su ruta asociada definidas, ahora ya puedes rellenar el formulario y
pinchar en el botn de enviar para empezar el proceso de creacin de un nuevo artculo. No
obstante, cuando enves el formulario vers el siguiente mensaje de error que ya debera
resultarte familiar:
Figura 5.5 Error de Rails: no existe la accin create en ArticlesController

Para solucionarlo debemos crear la accin create en ArticlesController.
5.3. Creando artculos

Para hacer que el error "Unknown action" desaparezca, defini una accin create dentro de
la clase ArticlesControlleren app/controllers/articles_controller.rb, debajo de la
accin new:
class PostsController < ApplicationController
def new
end
def create
end
end
Si ahora reenvas el formulario, vers otro error comn: falta la plantilla. Por el momento
vamos a ignorar este error, ya que la accin create s que est al menos guardando el
nuevo artculo en la base de datos.
Cuando se enva un formulario, los campos del formulario se envan a Rails
como parmetros. Estos parmetros se pueden obtener dentro de las acciones del
controlador, ya que normalmente tu cdigo los necesita para completar sus tareas. Para ver
cmo son parmetros, cambiar la accin create a esto:
def create
render plain: params[:article].inspect
end
Al mtodo render se le pasa un hash muy simple con la clave text y el

valor params[:post].inspect. El mtodo paramses el objeto que representa a los
parmetros (o campos) que vienen desde el formulario. El mtodo params devuelve un
objeto ActiveSupport::HashWithIndifferentAccess, que te permite acceder a las claves
del hash usando tanto cadenas de texto como smbolos. En nuestro caso los nicos
parmetros que importan son los que vienen del formulario.
Si reenvias el formulario una vez ms, ya no obtendrs el error que indica que falta la
plantilla. En su lugar vers algo como lo siguiente:
{"title"=>"First article!", "text"=>"This is my first article."}
Ahora esta accin muestra los parmetros que se envan mediante el formulario que crea
nuevos artculo. En cualquier caso, de momento esto no nos sirve para nada. Aunque es
cierto que puedes ver el contenido de los parmetros, no estamos haciendo nada con ellos,
por lo que su valor se pierde.
5.4. Creando el modelo Article

Los modelos en Rails se escriben en singular y los nombres de sus tablas asociadas se
convierten automticamente en plural. Rails incluye un generador para crear modelos que
lo utilizan la mayora de programadores Rails para crear al menos el esqueleto del modelo.
Para crear el nuevo modelo Article ejecuta el siguiente comando en la consola:
$ bin/rails generate model Article title:string text:text
Con ese comando le decimos a Rails que queremos un modelo llamado Article, que
contenga un atributo title de tipo cadena de texto y un atributo text de tipo texto largo.
Esos atributos se aaden automticamente a la tabla articles en la base de datos y se
asocian al modelo Article.
El resultado de ejecutar este comando es que Rails ha creado varios archivos. Por el
momento slo nos
interesanapp/models/article.rb y db/migrate/20140120191729_create_articles.rb (
en tu caso el nombre de este archivo ser ligeramente diferente). Este ltimo se encarga de
crear la estructura de la base de datos, que es lo prximo que vamos a analizar.
El Active Record es lo suficientemente inteligente para asociar automticamente el
nombre de las columnas a los atributos del modelo, lo que significa que no tienes que
declarar los atributos dentro de los modelos de Rails, ya que Active Record lo har por t
automticamente.
TRUCO
5.5. Migraciones
Como hemos visto, el comando rails generate model crea un archivo de migracin de
base de datos en el directoriodb/migrate. Las migraciones son clases de Ruby que estn
diseadas para simplificar la creacin y modificacin de las tablas de la base de datos.
Rails usa comandos rake para ejecutar migraciones, y es posible deshacer una migracin
despus de que ha sido aplicada a la base de datos. Los archivos de migraciones incluyen
un sello de tiempo con la fecha y hora para que siempre sean procesadas en el mismo orden
que fueron creadas.
Si miras el contenido del
archivo db/migrate/20140120191729_create_articles.rb (recuerda que en tu caso el
nombre de este archivo ser ligeramente diferente), esto es lo que encontrars:
class CreateArticles < ActiveRecord::Migration
def change
create_table :articles do |t|
t.string :title
t.text :text
t.timestamps
end
end
end
La migracin de arriba crea un mtodo llamado change que se invoca cuando ejecutas la
migracin. La accin definida en este mtodo es reversible, lo cual significa que Rails sabe
cmo deshacer los cambios realizados en esta migracin en caso que necesites hacerlo ms
adelante.
Cuando ejecutas esta migracin se crea una tabla articles con una columna tipo string y
otra columna tipo text. Tambin crea dos campos de tipo timestamp para que Rails pueda
guarda la fecha y hora en la que los artculos se crean y se modifican.
Puedes encontrar ms informacin sobre las migraciones en el artculo Rails
Database Migrations
En este punto, puedes usar el comando rake para ejecutar la migracin:
NOTA
$ bin/rake db:migrate
Rails ejecutar este comando de migracin y te indicar que ha creado la tabla Articles.
== CreateArticles: migrating ==============================================
====
-- create_table(:articles)
-> 0.0019s
== CreateArticles: migrated (0.0020s) =====================================
====
Como por defecto siempre ests trabajando en el entorno de desarrollo, este comando
se aplica sobre la base de datos definida en la seccin development del
archivo config/database.yml. Si quieres ejecutar migraciones en otro entorno, por
ejemplo en produccin, debes indicarlo en forma explcita cuando invoques el
comando: rake db:migrate RAILS_ENV=production.
NOTA
5.6. Guardando datos en el controlador

En ArticlesController debemos cambiar ahora la clase create para que utilice el nuevo
modelo Article al guardar la informacin en la base de datos. Abre el
archivo app/controllers/articles_controller.rb y modifica la accin createpara que
tenga el siguiente contenido:
def create
@article = Article.new(params[:article])
@article.save
redirect_to @article
end
Lo que est sucediendo ahora es que cada modelo Rails se inicializa con sus respectivos
atributos, que se asocian automticamente con las columnas correspondientes de la base de
datos. La primera lnea del cdigo anterior hace exactamente eso (recuerda
que params[:article] contiene los atributos que nos interesan).
Despus, @article.save se encarga de guardar el modelo en la base de datos. Por ltimo,
redirigimos al usuario a la accin show, que definiremos ms adelante.
Como veremos despus, @article.save devuelve una variable booleana que indica
si el modelo fue guardado o no.
Si recargas de nuevo la pgina http://localhost:3000/articles/new sers casi capaz de crear
un nuevo artculo. Si lo pruebas, vers que se muestra este mensaje de error:
TRUCO
Figura 5.6 No se permiten esos atributos al crear un artculo

Rails incluye varias opciones para ayudarte a desarrollar aplicaciones seguras y ahora
mismo ests viendo en directo una de ellas. Esta opcin se llama strong_parameters y
obliga a decirle a Rails exactamente qu parametros estamos dispuestos a aceptar en
nuestros controladores.
Como en este caso slo nos interesan los atributos title y text, debes aadir el siguiente
mtodo article_params y cambiar el cdigo de la accin create:
def create
@article = Article.new(article_params)
@article.save
end
private
def article_params
params.require(:article).permit(:title, :text)
end
El mtodo permit es lo que nos permite aceptar tanto el title como el text en la accin.
Observa que def article_params es un mtodo privado. Esta estrategia impide que
un atacante pueda establecer los atributos del modelo manipulando el hash que se pasa al
modelo. Para ms informacin al respecto, consulta este artculo sobre los Strong
Parameters.
NOTA
5.7. Mostrando artculos

Si ahora vuelves a enviar el formulario, Rails mostrar un mensaje de error indicando que
no encuentra la accin show. Como esto no es muy til, vamos a crear la accin show antes
de continuar.
Como viste en la salida del comando rake routes, la ruta de la accin show tiene este
aspecto:
$ bin/rake routes
Prefix Verb
article GET
URI Pattern
Controller#Action
articles#show
...
La sintaxis :id de la ruta indica a Rails que esta ruta espera un parmetro llamado :id, que
en este caso ser el atributo id del artculo que se quiere ver. Como hicimos anteriormente,
es necesario aadir una nueva accin en el
archivo app/controllers/articles_controller.rb y tambin hay que crear su vista
correspondiente.
def show
@article = Article.find(params[:id])
end
Un par de cosas que debes tener en cuenta: usamos Article.find para encontrar el artculo
que nos interesa, pasndole el valor params[:id] para obtener el
parmetro :id directamente de la peticin. Tambin usamos una variable de instancia (con
el prefijo @) para guardar una referencia al objeto del artculo. Hacemos eso porque Rails
pasa automticamente todas las variables de instancia a la vista.
Ahora, crea un nuevo archivo app/view/articles/show.html.erb con el siguiente
contenido:
<p>
<strong>Title:</strong>
<%= @article.title %>
</p>
<p>
<strong>Text:</strong>
<%= @article.text %>
</p>
Con estos cambios, ya deberamos poder crear nuevos artculos. Para ello,
visita http://localhost:3000/posts/new y prubalo.
Figura 5.7 La accin que muestra los artculos del blog
5.8. Listando todos los artculos

Todava no tenemos una forma de listar todos los artculos disponibles, por lo que vamos a
hacerlo ahora mismo. La ruta que corresponde a esta accin segn el comando rake
routes es:
$ bin/rake routes
Prefix Verb
articles GET
URI Pattern
Controller#Action
/articles(.:format)
articles#index
...
Y la accin index correspondiente para esta ruta dentro de ActionController del

archivoapp/controllers/articles_controller.rb debera ser:
def index
@articles = Article.all
end
Y por ltimo, aade la vista para esta accin en la plantilla localizada

en app/views/articles/index.html.erb:
<h1>Listing articles</h1>
<table>
<tr>
<th>Title</th>
<th>Text</th>
</tr>
<% @articles.each do |article| %>

<tr>
<td><%= article.title %></td>
<td><%= article.text %></td>
</tr>
<% end %>
</table>
Visita ahora la pgina http://localhost:3000/articles y vers el listado de todos los artculos

que has creado.
5.9. Aadiendo enlaces

En estos momentos puedes crear, mostrar y listar artculos. Pero todas estas acciones son
independientes y no estn conectadas entre s. Por ello ahora vamos a aadir algunos
enlaces que nos permitan navegar entre las pginas.
Abre app/views/welcome/index.html.erb y modifcalo como se indica a continuacin:
<h1>Hello, Rails!</h1>
<%= link_to 'My Blog', controller: 'articles' %>
El mtodo link_to es uno de los helpers que incluye Rails para las vistas. Este mtodo
crea un enlace utilizando el texto y la ruta indicados, que en este caso ser la ruta articles.
Vamos a agregar enlaces a las otras vistas, empezando por aadir el enlace "New
Article" en la vistaapp/views/articles/index.html.erb justo por encima de la
etiqueta <table>:
<%= link_to 'New article', new_article_path %>
Este enlace te permite acceder directamente al formulario para crear nuevos artculos.
Aade tambin un enlace enapp/views/articles/new.html.erb, justo debajo del
formulario, para volver a la portada del sitio:
...
<% end %>
<%= link_to 'Back', articles_path %>
Finalmente, aade otro enlace a la plantilla app/views/articles/show.html.erb para

regresar a la accin index, de manera que la persona que est viendo un artculo pueda
volver fcilmente a la portada del sitio.
<p>
</p>
<p>
</p>
Si quieres crear un enlace a una accin dentro del mismo controlador, no es

necesario que especifiques la opcin :controller, ya que Rails utiliza por defecto el
controlador actual.
TRUCO En el entorno de desarrollo, que es el que se utiliza por defecto, Rails recarga la
aplicacin entera con cada peticin, por lo que no es necesario parar y reiniciar el servidor
web con cada cambio.
TRUCO
5.10. Aadiendo validaciones

Ahora mismo, el archivo app/models/article.rb del modelo es tan simple como:
class Article < ActiveRecord::Base
end
Aunque el archivo est vaco, fjate que la clase hereda de ActiveRecord::Base. El Active
Record aade de esta manera muchas funcionalidades a tus modelos de Rails. Entre otras,
incluye un CRUD bsico, validacin de datos, bsqueda de informacin y la posibilidad de
relacionar modelos entre s.
Rails incluye por ejemplo mtodos que te permiten validar la informacin que envas a los
modelos. Para definir esta validacin, abre el archivo app/models/article.rb y aade lo
siguiente:
validates :title, presence: true,
length: { minimum: 5 }
end
Estos cambios aseguran que que todos los artculos tengan un ttulo de al menos cinco
caracteres de longitud. Rails puede validar diferentes caractersticas de los modelos, como
si incluyen una determinada columna, si su valor es nico en la base de datos, su formato, y
si existen o no objetos relacionados. Las validaciones se explican con detalle en el
artculo Active Record Validations.
Ahora que ya has configurado la validacin, cuando invoques el mtood @article.save en

un artculo invlido, el resultado ser false. No obstante, si abres el
archivo app/controllers/articles_controller.rb, vers que no verificamos el
resultado de la llamada a @article.save dentro de la accin create. Si el
mtodo @article.save devuelvefalse, deberamos mostrar de nuevo el formulario al
usuario mostrndole los errores que contiene. Para ello, cambia las
acciones new y create en el archivo app/controllers/articles_controller.rb:
def new
@article = Article.new
end
def create
@article = Article.new(article_params)
if @article.save
else
render 'new'
end
end
private
def article_params
end
La accin newp ahora crea una variable de instancia llamada@article` y el motivo

por el que lo hace lo comprenders muy pronto.
Observa que en la accin create utilizamos render en vez de redirect_to cuando el
mtodo save devuelve false. Se utiliza el mtodo render para que el objeto @article se
pase cuando se renderiza la plantilla. Esta renderizacin se realiza en la misma peticin en
la que se envi el formulario, mientras que redirect_to le dice al navegador que realice
otra peticin.
Si recargas la pgina http://localhost:3000/articles/new y tratas de guardar un artculo sin
ttulo, Rails te mostrar el mismo formulario vaco, lo cual no es muy til. Lo que debemos
hacer es mostrar al usuario qu errores se han producido. Para ello, modifica el
archivo app/views/articles/new.html.erb para que compruebe si existen errores:
<% if @article.errors.any? %>
<div id="error_explanation">
<h2><%= pluralize(@article.errors.count, "error") %> prohibited
this article from being saved:</h2>
<ul>
<% @article.errors.full_messages.each do |msg| %>
<li><%= msg %></li>
<% end %>
</ul>
</div>
<% end %>
<p>
</p>
<p>
</p>
<p>
<%= f.submit %>
</p>
<% end %>
En este cdigo estn sucediendo varias cosas. Primero comprobamos si existen errores con
el mtodo@article.errors.any?. Si existen, mostramos una lista con todos los errores
obtenidos mediante@article.errors.full_messages.
El helper pluralize es uno de los helpers includos en Rails y que acepta como
argumentos un nmero y una cadena de texto. Si el nmero pasado es mayor que 1, la
cadena de texto se convierte automticamente en plural..
El motivo por el que aadimos @article = Article.new en el
controlador ArticlesController es porque si no, @articletendra un valor nil en la vista.
As que al ejecutar @article.errors.any? se mostrara un error.
Rails encierra automticamente con un <div class="field_with_errors"> a los campos
de formulario que contienen errores. As que slo tienes que definir los estilos CSS
correspondientes para hacer que los mensajes de error destaquen lo suficiente.
Ahora s vers un mensaje de error cuando trates de guardar un artculo sin ttulo en la
pginahttp://localhost:3000/articles/new.
Figura 5.8 Formulario con varios mensajes de error asociados
5.11. Actualizando artculos

Hasta ahora nos hemos ocupado de la parte CR del acrnimo CRUD. En esta seccin nos
ocuparemos de la parte U, es decir, de actualizar artculos. El primer paso consiste en
aadir la accin edit a ArticlesController.
def edit
end
La vista contendr un formulario similar al que hemos usado para crear nuevos artculos.
Para ello, crea el archivoapp/views/articles/edit.html.erb con el siguiente contenido:
<h1>Editing article</h1>
<%= form_for :article, url: article_path(@article), method: :patch do |f| %>

<ul>
<li><%= msg %></li>
<% end %>
</ul>
</div>
<% end %>
<p>
</p>
<p>
</p>
<p>
<%= f.submit %>
</p>
<% end %>
En esta ocasin el formulario apunta a la accin update, que todava no hemos creado. La
opcin :method => :patch le dice a Rails que queremos enviar este formulario mediante
el mtodo PATCH de HTTP que, segn el protocolo REST, es el que se debe utilizar al
actualizar recursos.
El primer parmetro de form_for puede ser un objeto, por ejemplo @article, que se utiliza
para rellenar los campos del formulario. Si pasas un smbolo (ejemplo :article) cuyo
nombre sea idntico al de una variable de instancia (@article) el funcionamiento es el
mismo. Esto es precisamente lo que est pasando en este ejemplo. Consulta
la documentacin de form_for para conocer ms detalles.
A continuacin, crea la accin update en el
archivo app/controllers/articles_controller.rb:
def update
if @article.update(article_params)
else
render 'edit'
end
end
private
def article_params
end
El nuevo mtodo update se usa al actualizar un registro que ya existe, y acepta como
argumento un hash que contiene los atributos que deseas actualizar. Como hicimos
anteriormente, si hay un error actualizando el artculo queremos volver a mostrar el
formulario al usuario. Para ello se reutiliza el mtodo article_params definido
anteriormente para la accin create.
No es necesario pasar todos los atributos a update. Por ejemplo, si
ejecutaras @article.update(title: 'A new title') Rails solo actualizara el
atributo title sin tocar los otros atributos.
Por ltimo, queremos mostrar un enlace a la accin edit en la lista de todos los artculos.
As que modifica la vistaapp/views/articles/index.html.erb para aadir un nuevo
enlace:
TRUCO
<table>
<tr>
<th>Title</th>
<th>Text</th>
<th colspan="2"></th>
</tr>

<tr>
<td><%= link_to 'Show', article_path(article) %></td>
<td><%= link_to 'Edit', edit_article_path(article) %></td>
</tr>
<% end %>

</table>
Aade tambin un enlace en la vista app/views/articles/show.html.erb, de manera que

haya un enlace Edit en la pgina de cada artculo. Aade lo siguiente al final de la plantilla:
...

| <%= link_to 'Edit', edit_article_path(@article) %>
Y este es el aspecto que tiene la aplicacin por el momento:
Figura 5.9 La accin index con un enlace a la accin edit
5.12. Usando parciales para eliminar las duplicidades en las

vistas
La pgina edit se parece mucho a la pgina new porque utilizan el mismo cdigo para
mostrar el formulario. As que vamos a eliminar estas duplicidades mediante los parciales.
Por convencin un parcial es un archivo de plantilla cuyo nombre empieza por un guin
bajo y cuyo contenido se reutiliza en varias plantillas diferentes.
Puedes aprender ms sobre los parciales en la gua Layouts and Rendering in Rails.
Crea un nuevo archivo llamado app/views/articles/_form.html.erb y que tenga el
siguiente contenido:
NOTA
<%= form_for @article do |f| %>

<ul>
<li><%= msg %></li>
<% end %>
</ul>
</div>
<% end %>
<p>
</p>
<p>
</p>
<p>
<%= f.submit %>
</p>
<% end %>
Todo este contenido, excepto la declaracin form_for, es idntico al contenido que ya

tenamos. Como @article es un recurso que incluye todas las rutas RESTful y Rails es
capaz de inferir qu URI y mtodo se debe utilizar, podemos simiplificar al mximo la
declaracin form_for. Consulta la gua Resource-oriented style para obtener ms

informacin sobre este uso de form_for.
Ahora actualiza completmanete la vista app/views/articles/new.html.erb para usar el
nuevo parcial:
<h1>New article</h1>
<%= render 'form' %>
Luego haz lo mismo para la vista app/views/articles/edit.html.erb:

<h1>Edit article</h1>
<%= render 'form' %>
5.13. Borrando artculos

Ahora ya estamos listos para completar la letra "D" del acrnimo CRUD: borrar artculos
de la base de datos. Siguiendo la convencin REST, la ruta para borrar artculos debera ser
la que indica el comando rake routes:
$ bin/rake routes
Prefix Verb
URI Pattern
Controller#Action
articles#destroy
...
El mtodo deletees el que se debe usar para eliminar recursos de la aplicacin. Si esta ruta
siguiera el formato GETtradicional, los usuarios maliciosos podran crear enlaces como el
siguiente:
<a href='http://example.com/articles/1/destroy'>Mira este precioso gatito!<

/a>
Para evitarlo se utiliza el mtodo DELETE de HTTP mediante la ruta que est asociada con la
accin destroy del archivoapp/controllers/articles_controller.rb. Como esta
accin no existe todava, crala con el siguiente contenido:
def destroy
@article.destroy
redirect_to articles_path
end
Puedes invocar el mtodo destroy en cualquier objeto Active Record para eliminarlo de la
base de datos. Como despus del borrado de informacin se redirige al usuario a la
accin index, no es necesario crear una vista para esta accin destroy.
Finalmente, agrega un enlace a la plantilla de la
accin index (app/views/articles/index.html.erb) para completar todo.
<h1>Listing Articles</h1>
<%= link_to 'New article', new_article_path %>
<table>
<tr>
<th>Title</th>
<th>Text</th>
<th colspan="3"></th>
</tr>

<tr>
<td><%= link_to 'Show', article_path(article) %></td>

<td><%= link_to 'Edit', edit_article_path(article) %></td>
<td><%= link_to 'Destroy', article_path(article),
method: :delete, data: { confirm: 'Are you sure?' } %></
td>
</tr>
<% end %>
</table>
En esta plantilla se utiliza link_to de una manera diferente. El nombre de la ruta se pasa
como segundo argumento y despus se indican las opciones mediante otro argumento. Las
opciones :method y :data-confirm se utilizan como atributos HTML5 para que cuando se
pinche sobre el enlace Rails muestre un mensaje de confirmacin al usuario antes de borrar
la informacin.
Este comportamiento es posible gracias al archivo JavaScript llamado jquery_ujs, que se
incluye automticamente en el layout de la aplicacin
(app/views/layouts/application.html.erb) que se cre al generar la aplicacin Rails.
Si no se incluye este archivo, el mensaje de confirmacin no se muestra.
Figura 5.10 Ventana JavaScript con un mensaje de confirmacin para borrar artculos
Felicidades! Ahora ya puedes crear, mostrar, listar, actualizar y borrar artculos.

Segn la filosofa de Rails, es preferible usar objetos que representan a recursos, en
vez de crear las rutas a mano. Para obtener ms informacin sobre el enrutamiento, consulta
el artculo Rails Routing from the Outside In.
NOTA
Captulo 6. Aadiendo otro modelo

A continuacin vamos a aadir un segundo modelo a la aplicacin. Este nuevo
modelo se encargar de gestionar los comentarios de los artculos.
6.1. Generando el modelo

Para generar el nuevo modelo usaremos el mismo generador que se explic
anteriormente para el modelo Article. Esta vez se crear un modelo
llamado Comment que gestionar los comentarios de los artculos. Para crearlo,
ejecuta el siguiente comando:
$ bin/rails generate model Comment commenter:string body:text article:refere
nces
Como resultado de este comando se generarn cuatro archivos:
File
Purpose
db/migrate/20140120201010_create_comments.rb
Archivo de migracin para crear la

tabla comments en la base de datos
(en tu caso el nombre del archivo
ser ligeramente diferente)
app/models/comment.rb
El modelo Comment
test/models/comment_test.rb
Los tests del modelo
test/fixtures/comments.yml
Comentarios de prueba para los

tests
Primero echa un vistazo al archivo app/models/comment.rb:

class Comment < ActiveRecord::Base
belongs_to :article
end
Su contenido es muy similar al del modelo Article generado anteriormente. La

nica diferencia es la lnea belongs_to :article, que configura una relacin
para Active Record. En la prxima senccin se explican estas relaciones entre
modelos.
Adems del modelo, Rails genera un archivo de migracin para crear la tabla
correspondiente en la base de datos:
class CreateComments < ActiveRecord::Migration
def change
create_table :comments do |t|
t.string :commenter
t.text :body
# this line adds an integer column called `article_id`.

t.references :article, index: true
t.timestamps
end
end
end
La lnea t.references crea una columna de tipo clave fornea para establecer la
relacin entre los dos modelos. Adems se crea un ndice para esta columna.
Como ya tenemos todo preparado, ejecuta el siguiente comando:
$ bin/rake db:migrate
Rails es lo bastante inteligente como para ejecutar solamente las migraciones que
todava no se han ejecutado en la base de datos que se est utilizando. As que el
resultado de ejecutar el comando ser:
== CreateComments: migrating ==============================================

===
-- create_table(:comments)
-> 0.0115s
== CreateComments: migrated (0.0119s) =====================================
===
6.2. Asociando modelos

Las asociaciones de Active Record permiten declarar las relaciones que existen
entre dos modelos. En el caso de los comentarios y los artculos, las relaciones se
podran escribir de esta manera:
Cada comentario pertenece (en ingls, "belongs to") a un artculo.
Un artculo puede tener muchos (en ingls, "have many") comentarios.
Si te fijas un poco, la sintaxis que utiliza Rails es prcticamente la misma que

como se describen las relaciones en ingls. Recuerda la lnea del
modelo Comment (archivo app/models/comment.rb) que establece la relacin
con Article:
class Comment < ActiveRecord::Base
belongs_to :article
end
Ahora edita el archivo app/models/article.rb para definir el otro extremo de la

relacin:
has_many :comments
end
Gracias a estas dos declaraciones (belongs_to y has_many), Rails puede hacer casi
todo el trabajo automticamente. Si por ejemplo tienes una variable de instancia
llamada @article que contiene un artculo, puedes obtener todos sus comentarios
mediante la isntruccin @article.comments.
Consulta el artculo Active Record Associations para obtener ms
informacin sobre las asociaciones.
NOTA
6.3. Aadiendo una ruta para los comentarios

En primer lugar debemos aadir una nueva ruta para que Rails sepa dnde
queremos navegar para ver los comentarios. Para ello, abre el
archivo config/routes.rb y haz que tenga el siguiente contenido:
resources :articles do
resources :comments
end
Esta configuracin crea la ruta comments dentro de la ruta articles que definimos
anteriormente. Esta es otra forma de establecer la relacin entre los dos modelos.
NOTA
Para obtener ms informacin sobre el enrutamiento, consulta la
gua Routing Guide.
6.4. Generando un controlador

El modelo ya est creado as que ahora podemos dedicarnos a su controlador
asociado. De nuevo utilizaremos el comando que genera controladores:
$ bin/rails generate controller Comments
Como resultado de este comando se generan seis archivos y un directorio vaco:
Archivo/Directorio
Propsito
app/controllers/comments_controller.rb
El controlador Comments
Archivo/Directorio
Propsito
app/views/comments/
Direcotrio donde guardar las vistas

del controlador
test/controllers/comments_controller_test.rb
El test funcional del controlador
app/helpers/comments_helper.rb
El helper para las vistas relacionadas

con los comentarios
test/helpers/comments_helper_test.rb
Test unitario para el helper
app/assets/javascripts/comment.js.coffee
Archivo CoffeeScript para las vistas

del controlador
app/assets/stylesheets/comment.css.scss
Hoja de estilos CSS para las vistas

del controlador
Como sucede en cualquier blog de Internet, los usuarios podrn aadir

comentarios en los artculos y despus de hacerlo, se les redirigir a la pgina de
ese mismo artculo para que puedan ver su comentario publicado. Por eso el
controlador CommentsController deber incluir un mtodo para crear comentarios y
para borrar todos los comentarios despam que lleguen.
As que en primer lugar vamos a modificar la plantilla que muestra los artculos
(archivoapp/views/articles/show.html.erb) para que deje crear nuevos
comentarios:
<p>
</p>
<p>
</p>
<h2>Add a comment:</h2>
<%= form_for([@article, @article.comments.build]) do |f| %>
<p>
<%= f.label :commenter %><br>
<%= f.text_field :commenter %>
</p>
<p>
<%= f.label :body %><br>
<%= f.text_area :body %>
</p>
<p>
<%= f.submit %>
</p>
<% end %>

| <%= link_to 'Edit', edit_article_path(@article) %>
Este cdigo aade un formulario en la pgina show de los artculos para poder
crear nuevos comentarios llamando a la accin create del
controlador CommentsController. En este caso el mtodo form_for utiliza un array

que crea rutas anidadas de tipo /articles/1/comments.
El siguiente paso consiste en crear la accin create en el
archivo app/controllers/comments_controller.rb:
class CommentsController < ApplicationController
def create
@article = Article.find(params[:article_id])
@comment = @article.comments.create(comment_params)
redirect_to article_path(@article)
end
private
def comment_params
params.require(:comment).permit(:commenter, :body)
end
end
Este controlador es un poco ms complejo del que creamos para los artculos.
Esta es una de las consecuencias de anidar relaciones. Cada peticin relacionada
con un comentario debe contener una referencia al artculo con el que est
relacionado. Por eso tenemos que buscar primero el modelo Article que est
relacionado con el comentario.
Adems, la accin utiliza algunos de los mtodos disponibles para las relaciones.
As por ejemplo se utiliza el mtodocreate sobre @article.comments para crear y
guardar un comentario. Esto hace que el comentario est automticamente
relacionado con este artculo especfico.
Despus de crear el nuevo comentario, se redirige al usuario de nuevo a la pgina
que meustra el artculo original mediante el helper article_path(@article). Como
acabamos de ver, este helper llama a la accin show del
controladorArticlesController, que a su vez renderiza la plantilla show.html.erb.
Como esta es la plantilla en la que se debe mostrar el nuevo comentario, aade lo

siguiente en el archivo app/views/articles/show.html.erb:
<p>
</p>
<p>
</p>
<h2>Comments</h2>
<% @article.comments.each do |comment| %>
<p>
<strong>Commenter:</strong>
<%= comment.commenter %>
</p>
<p>
<strong>Comment:</strong>
<%= comment.body %>
</p>
<% end %>
<p>
</p>
<p>
</p>
<p>
<%= f.submit %>
</p>
<% end %>
<%= link_to 'Edit Article', edit_article_path(@article) %> |

<%= link_to 'Back to Articles', articles_path %>
Ahora ya puedes aadir artculos y comentarios en el blog y cada contenido se

muestra en el lugar adecuado.
Figura 6.1 Artculo con comentarios
Captulo 7. Refactorizacin
La aplicacin ya permite crear artculos y comentarios, pero si echas un vistazo al
archivoapp/views/articles/show.html.erb vers que la plantilla es muy larga y su
cdigo es un poco catico. Para limpiar el cdigo podemos hacer uso de
los parciales.
7.1. Renderizando colecciones de parciales

En primer lugar vamos a crear un parcial para mostrar todos los comentarios de un
artculo. Crea el archivoapp/views/comments/_comment.html.erb y aade el
<p>
</p>
<p>
<%= comment.body %>
</p>
Then you can change app/views/articles/show.html.erb to look like the follow
ing:
Ahora puedes simplificar el archivo app/views/articles/show.html.erb de la

siguiente manera:
<p>
</p>
<p>
</p>
<h2>Comments</h2>
<%= render @article.comments %>
<p>
</p>
<p>
</p>
<p>
<%= f.submit %>
</p>
<% end %>

Ahora el parcial definido en app/views/comments/_comment.html.erb se utiliza para

renderizar cada comentario de la coleccin @article.comments. Como el mtodo
itera sobre @article.comments, asigna cada comentario a una variable local con el
mismo nombre que el parcial (en este caso, comment).
7.2. Renderizando un formulario parcial

El siguiente paso consiste en extraer de la plantilla la seccin para crear nuevos
comentarios. Crea el archivoapp/views/comments/_form.html.erb y aade el
<p>
</p>
<p>
</p>
<p>
<%= f.submit %>
</p>
<% end %>
Ahora ya puedes refactorizar la plantilla app/views/articles/show.html.erb de la

siguiente manera:
<p>
</p>
<p>
</p>
<h2>Comments</h2>
<%= render @article.comments %>
<%= render "comments/form" %>

El segundo render simplemente indica la plantilla parcial que se quiere renderizar.

Rails es capaz de interpretar la sintaxis comments/form de manera correcta, as que
se renderiza el parcial _form.html.erb del directorioapp/views/comments.
El objeto @article est disponible en cualquier parcial renderizado dentro de la
vista, ya que se ha definido como una variable de instancia.
Captulo 8. Borrando comentarios

Otra de las funcionalidades bsicas de cualquier blog es la posibilidad de borrar
los comentarios de spam. Para ello, vamos a aadir un enlace en la vista y una
accin llamada destroy en el controlador CommentsController.
En primer lugar, aade el enlace para borrar comentarios en la plantilla
del parcialapp/views/comments/_comment.html.erb:
<p>
</p>
<p>
<%= comment.body %>
</p>
<p>
<%= link_to 'Destroy Comment', [comment.article, comment],
method: :delete,
data: { confirm: 'Are you sure?' } %>
</p>
Al pinchar el enlace "Destroy Comment", se enva una peticin HTTP de

tipo DELETE a la URL/articles/:article_id/comments/:id que ser respondida
por CommentsController. As que vamos a crear la accindestroy en el controlador
(archivo app/controllers/comments_controller.rb):
def create
@comment = @article.comments.create(comment_params)
end
def destroy
@comment = @article.comments.find(params[:id])
@comment.destroy
end
private
def comment_params
params.require(:comment).permit(:commenter, :body)
end
end
La accin destroy busca el artculo que estamos leyendo, localiza el comentario

dentro de la coleccin@article.comments, lo borra de la base de datos y vuelve a
mostrar la pgina con el artculo original.
8.1. Borrando los objetos asociados

Si borras un artculo, todos sus comentarios tambin deran borrarse para que no
ocupen un espacio innecesario en la base de datos. Rails permite configurar este
comportamiento mediante la opcin dependent de la asociacin entre modelos.
Para ello, modifica el modelo Article cambiando el contenido del
archivo app/models/article.rb por lo siguiente:
has_many :comments, dependent: :destroy

end
Captulo 9. Seguridad
9.1. Autenticacin bsica
Si publicaras ahora tu aplicacin Rails, cualquier persona podra aadir, editar y
borrar artculos y comentarios. Obviamente Rails incluye algunas opciones de
seguridad para evitar esto. Una de ellas es la autenticacin basada en HTTP.
La clave consiste en proteger el acceso a varias de las acciones definidas en el
controlador ArticlesController. Si el usuario no est autenticado, no podr
acceder a esas acciones. Para ello utilizaremos el
mtodohttp_basic_authenticate_with de Rails.
La configuracin de la autenticacin en este caso consiste en indicar al principio
del controlador ArticlesControllerque quereos proteger todas las acciones
salvao index y show:
class ArticlesController < ApplicationController
http_basic_authenticate_with name: "dhh", password: "secret", except: [:in

dex, :show]
def index
@articles = Article.all
end
# ...
Otra restriccin adicional consiste en evitar que los usuarios puedan borrar
comentarios. Para ello, aade lo siguiente
en CommentsController (archivo app/controllers/comments_controller.rb):
http_basic_authenticate_with name: "dhh", password: "secret", only: :destr

oy
def create
...
end
# ...
Si ahora tratas de crear un nuevo artculo, vers la siguiente ventana en la que el

navegador te solicita un usuario y contrasea.
Figura 9.1 Ventana de usuario y contrasea para la autenticacin HTTP
Las aplicaciones Rails pueden utilizar obviamente otros mtodos de autenticacin

alternativos. Dos de las alternativas ms populares se llaman Devise y Authlogic.
9.2. Otros comentarios sobre la seguridad

La seguridad, sobre todo cuando habamos de aplicaciones web, es un tema muy
complejo. Por eso puedes consultar la gua Ruby on Rails Security Guide para
obtener ms informacin al respecto.
Captulo 10. Siguientes pasos

Despus de crear tu primera aplicacin Rails de prueba, ya deberas ser capaz de
empezar a jugar con ella para probar nuevas cosas por tu cuenta. En cualquier
caso, no ests solo en este proceso de aprendizaje. Como seguramente tarde o
temprano necesitars ayuda, puedes echar mano a estos recursos:
Las [Guas de Ruby on Rails en ingls](http://guides.rubyonrails.org/index.

html).
El Tutorial de Rails en ingls
La [lista de correo en ingls](http://groups.google.com/group/rubyonrails- talk).
El canal #rubyonrails de irc.freenode.net
Rails tambin incluye una completa ayuda que puedes consultar mediante la
utilidad rake de la lnea de comandos:
Ejecuta rake doc:guides para obtener una copia completa de las guas de
Rails en el directorio doc/guides de tu aplicacin. Despus slo tienes que
abrir el archivo doc/guides/index.html en tu navegador favorito.
Ejecuta rake doc:rails para obtener una copia completa de la documentacin

de la API de Rails en el directoriodoc/api de la aplicacin. Despus, abre el
archivo doc/api/index.html con tu navegador preferido.
Para poder generar las guas de Rails localmente mediante el

comando doc:guides, debes instalar primero la gema RedCloth. Adela al
archivo Gemfile y ejecuta bundle install para instalarla.
NOTA

Ruby On Rails

Cargado por

Copyright:

Formatos disponibles

Ruby On Rails

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ruby On Rails

Cargado por

Copyright:

Formatos disponibles

2015

Introduccin a Ruby on Rails

Conversin a PDF por Roberto Ortiz|www.noia.mx

8.1. Borrando los objetos asociados .................................................................................. 58

Captulo 1. Antes de empezar

El lenguaje de programacin Ruby en su versin 1.9.3 o mayor.

El sistema de paquetes RubyGems. Si quieres aprender ms acerca de

La base de datos SQLite3.

Rails es un framework para aplicaciones web que corre sobre el lenguaje de

Aprende a Programar con Ruby.

Mr. Neighborly's Humble Little Ruby Book.

Why's (Poignant) Guide to Ruby.

"Convencin sobre Configuracin" - significa que Rails hace algunas

Captulo 3. Creando un nuevo proyecto

3.1. Instalando Rails

Existen varias herramientas para instalar Ruby en tu sistema operativo. Los

Adems, tu sistema debe contar con SQLite 3 instalado correctamente. Para

Si dice algo como "Rails 4.1.1", ests listo para continuar.

3.2. Creando la aplicacin de Blog

Contiene los controllers, models, views, helpers, mailers y assets

Configura las reglas de ejecucin de la aplicacin, rutas, base de

Configuracin Rack para servidores basados en Rack usados para

Contiene el esquema actual de tu base de datos, as como las

Documentacin detallada de tu aplicacin.

Estos archivos te permiten especificar qu dependencias de gemas

Mdulos extendidos para tu aplicacin.

Archivos de Log de tu aplicacin.

Este es un breve manual de instrucciones para tu aplicacin.

Contiene el script de Rails que inicia tu aplicacin y contiene otros

Pruebas unitarias, fixtures y otras pruebas. stos son cubiertos

Archivos temporales (como archivos de cach, PID y archivos de

Lugar para cdigo de terceros. En una tpica aplicacin Rails, sta

Captulo 4. Hola, Rails!

4.1. Iniciando el Servidor Web

Compilar CoffeeScript a JavaScript requiere de herramientas adicionales. Si

no dispones de ellas, vers un error de tipo execjs. Normalmente Mac OS X y

es aadido por defecto al Gemfileen aplicaciones generadas bajo JRuby. Puedes

Figura 4.1 Pgina de bienvenida de Rails

4.2. Hola Mundo

Los archivos ms importantes de stos son por supuesto el controlador, que se

4.3. Estableciendo la pgina principal

# The priority is based upon order of creation:

ste es el archivo de enrutamiento de tu aplicacin, que mantiene entradas con un

dehttp://localhost:3000/welcome/index a la accin index del controlador welcome.

Si accedes a la direccin http://localhost:3000 en tu navegador, vers el

realidad pasando a la accinindex del controlador Welcome y est renderizando la

Captulo 5. Creando un nuevo post

En las prximas secciones aadirs la funcionalidad de crear artculos en la aplicacin y

Figura 5.1 Formulario para crear artculos en el blog

5.1. Primeros pasos

Si ahora abres el archivo app/controllers/articles_controller.rb que se acaba de

Un controlador es simplemente una clase que hereda de ApplicationController. Dentro

Figura 5.3 Error de Rails: no existe la accin new en ArticlesController

Refresca de nuevo la pgina http://localhost:3000/articles/new y vers que a pesar de haber

Figura 5.4 Error de rails: no existe la plantilla para articles/new

Cuando recargues http://localhost:3000/posts/new, vers que la pgina tiene un ttulo. La

5.2. El primer formulario

<%= f.text_area :text %>