Ruby on Rails

Conceptos básicos

Fernando Blat & Fernando García & Álvaro Ortiz

The Cocktail

Ciclo de vida de una petición HTTP

• Framework de desarrollo web con filosofía MVC

Libro

No hay versión on-line, sólo de pago

Documentación

• Además del libro existen algunos lugares en los que se recogen documentos, tutoriales y demás ayuda:
  • API
  • wiki oficial
  • manuales
  • code snippets

Instalación

• La instalación de Rails es muy sencilla:
  • Instalar Ruby
  • Instalar los RubyGems es algo tan fácil como: gem install rails --include-dependencies
• Además requiere un servidor web y una base de datos

Estructura de directorios

$ rails demostracion

• app/: archivos del modelo, vista, controlador
• components/: componentes reusables
• config/: ficheros de configuración
• db/: estructura de base de datos y dumps de datos
• doc/: documentación del proyecto
• lib/: librerías externas

...

Estructura de directorios (ii)

...

• log/: logs de la aplicación
• public/: directorio con ficheros accesibles: htmls, javascripts, CSSs
• Rakefile: script de generación de la documentación y los tests
• script/: scripts de utilidad
• test/: baterías de pruebas
• vendor/: código de terceros

Estructura de directorios (iii)

• app/
  • controllers/
    • application.rb
  • helpers/
    • application_helper.rb
  • models/
  • views/
    • layouts/

Estructura de directorios (iv)

• scripts/
  • server: script de servidor web
  • console: consola irb con todo el entorno
  • generator: generador de código
  • destroy: elimina el código generador por generator

Entornos de ejecución

• Rails permite definir entornos de ejecución que se usarán durante los distintos estados de desarrollo de una aplicación
• Por defecto incorpora tres:
  • desarrollo: muchos logs, carga automática de cualquier cambio sin reiniciar el servidor
  • test: entorno que permita situaciones siempre reproducibles
  • ejecución: entorno con logs mínimos, de rendimiento optimizado

Configuración

• config/
  • environment.rb
  • environments/
    • development.rb
    • test.rb
    • production.rb
  • database.yml
  • routes.rb

Ciclo de vida de una petición HTTP

Active Record

• Proporciona una capa de relación de objetos (ORM)
• Se encarga de leerlos de la base de datos, mapearlos como objetos de nuestra aplicación y facilitarnos su acceso:
  • las tablas son clases
  • las filas son objetos
  • las columnas son atributos
• Facilitar la configuración utilizando convenciones de nombres

Convención vs. Configuración

• Cuando creamos una clase del modelo, ésta se va a mapear contra una tabla de la base de datos
• Se puede seguir una convención de nombres para evitar indicarlo explícitamente:
  • nombre de la clase: Order ↔ nombre de la tabla: orders
  • nombre de la clase: TaxAgency ↔ nombre de la tabla: tax_agencies
  • nombre de la clase: Person ↔ nombre de la tabla: people

Se puede forzar con una simple línea:

class Person < ActiveRecord::Base
  set_table_name "person"
end
	

Convención vs. Configuración (ii)

CREATE TABLE clients (
  id           int NOT NULL auto_increment,
  nif          varchar(10) NOT NULL default '',
  razon_social varchar(128) NOT NULL default'',
  alias        varchar(128) default '',
  nombre       varchar(128) default '',
  apellido     varchar(128) default '',
  PRIMARY KEY  (id),
  UNIQUE KEY nif (nif)
);
	

c = Client.new
c.nif = '12 456 567'
c.razon_social = 'Transportes Luis'
c.save
	

Convención vs. Configuración (iii)

class Client < ActiveRecord::Base
end
	

¿Y la definición de atributos?

Mapeo de atributos

• La definición de tipos se encuentra en un sólo lugar: la base de datos
• ActiveRecord mapea los atributos a partir de la definición de la base de datos: int a Fixnum; date a Date; char, varchar, string a String;...
• Lo que sí incluye la definición de la clase es la lógica de los datos: restricciones y relaciones con otras tablas

Claves primarias e IDs

• Una convención del ActiveRecord es utilizar id como clave primaria
• Esto puede no interesarnos o convencernos
• Su argumento es que una clave así siempre va a funcionar, aunque tengamos otros atributos definidos como únicos y no nulos, además de las ventajas que tiene seguir una convención
• Si a pesar de todo no nos sirve podemos forzar a que se use otra clave primaria:

class Client < ActiveRecord::Base
  set_primary_key 'nif'
end
	

CRUD - Create, Read, Update, Delete

• Rails facilita el CRUD de diversas formas
• La más espectacular de ellas es el scaffolding

CRUD - Create

• Dos formas:
  • new y save
  • create

  c = Client.new
  c.nif = '12 456 567'
  c.razon_social = 'Transportes Luis'
  c.save
  
  c = Client.create ( :nombre => 'Fernando', 
  		:direccion => 'Plaza Castilla', .... , 
  		:cargo => 'programador' )
  	

CRUD - Read

• find y derivados: find_all y find_by_sql

client = Client.find(3)

clients = Client.find(:all, :conditions => 'ciudad = Madrid', 
		:order => 'nombre ASC', 
		:limit => 10)

client = Client.find(:first, :conditions => 'ciudad = Madrid', 
		:order => 'nombre DESC')

clients = Client.find_by_sql("select * from clients 
		where num_telefono like '91%'")
	

CRUD - Update

• update y update_all

client = Client.update(4, :nombre => 'Fernando A.', 
		:num_fax => '14343343')

clients = Client.update_all("descuento = 1.1*descuento", 
		"ciudad = 'madrid'")
	

CRUD - Delete

• Dos formas:
  • delete y delete_all
  • destroy y destroy_all
• los delete llaman directamente a la base de datos mientras que los destroy lo hacen a través del ActiveRecord, asegurándose que se cumple la lógica de la aplicación

Client.delete(4)

Client.delete_all("ciudad = 'madrid'")
	

Relaciones

• El ActiveRecord soporta la definición de relaciones entre los modelos
• Se definen tres tipos:
  • uno-a-uno
  • uno-a-muchos
  • muchos-a-muchos
• Es necesario definir claves ajenas

CREATE TABLE `proposals` (
  `id` int NOT NULL auto_increment,
  `client_id` int NOT NULL default '0',
  ...
	

Relaciones: uno-a-uno

• Se definen con belongs_to y has_one
• belongs_to: define una relación de parentesco
• has_one: define una relación de inclusión con una única instancia

class Contract < ActiveRecord::Base
  belongs_to :proposal
end

class Proposal < ActiveRecord::Base
  has_one :contract
end

p = Proposal.new
p.contract = Contract.new...
		

Relaciones: uno-a-muchos

• Se definen con belongs_to y has_many
• belongs_to: define una relación de parentesco
• has_many: define una relación de inclusión con múltiples instancias

class Client < ActiveRecord::Base
  has_many :proposals
end

class Proposal < ActiveRecord::Base
  belongs_to :client
end

c = Client.find(3)
c.proposals.each { |proposal| print proposal.estado 
	 		if proposal.estado == 'Aceptada' }
		

Relaciones: muchos-a-muchos

• Se definen con has_and_belongs_to_many

class Client < ActiveRecord::Base
  has_and_belongs_to_many :proposals
end

class Proposal < ActiveRecord::Base
  has_and_belongs_to_many :clients
end
		

Relaciones: muchos-a-muchos (ii)

• Esta relación se mapea en una tabla nueva, que ha de estar creada concatenando los nombres de las dos tablas en orden alfabético
• La tabla contiene referencias a los identificadores

CREATE TABLE clients_proposals (
  client_id int NOT NULL auto_increment,
  proposal_id int NOT NULL auto_increment,
  PRIMARY KEY  (client_id, proposal_id)
)
		

Validación de datos

• ActiveRecord incorpora una serie de validadores de los datos del modelo.
• Se valida desde el formato, hasta que el valor sea numérico, que esté (o no esté) en un rango de valores determinado,....
• Se indican en la definición de los modelos

class Client < ActiveRecord::Base
  has_many :proposals

  validates_length_of :codigo_postal, :is => 5
  validates_presence_of :nif, :razon_social
end
		

Validación de datos (ii)

• validates_acceptance_of: comprueba que un checkbox está marcado
• validates_associated: comprueba que haya una relación entre objetos
• validates_confirmation_of: comprueba que dos campos tienen el mismo contenido
• validates_each: comprueba uno o más atributos utilizando un bloque
• validates_exclusion_of: comprueba que el atributo no está entre esos valores

Validación de datos (iii)

• validates_inclusion_of: comprueba que el atributo está entre esos valores
• validates_format_of: comprueba que el formato es el indicado
• validates_length_of: comprueba que la longitud del campo sea la correcta
• validates_numericality_of: comprueba que el valor sea de tipo numérico
• validates_presence_of: comprueba que el valor no sea nulo
• validates_uniqueness_of: comprueba que el valor sea único

Validación de datos (iv)

class Client < ActiveRecord::Base

  validates_format_of :longitud , :with => /^\d+(cm|px|em)/

  validates_inclusion_of  :estado,
                          :in => %w{Aceptada Recibida}

end
		

Ciclo de vida de una petición HTTP

• Framework de desarrollo web con filosofía MVC

Action Controller

• El ActionController, junto con el ActionView, forman el ActionPack
• Funciones:
  • dirigir las peticiones
  • renderizar plantillas
  • gestión de sesiones
  • manejar la interacción del usuario con la aplicación, actuando como puente

Métodos del controlador

• El ActionController coordina modelo y vista, encargándose de la lógica del proceso
• Cada modelo tiene sus métodos definidos en el controlador. Dichos métodos son acciones que el usuario puede realizar contra la web

http://tuapp.com/clients/list

app/controllers/clients_controller.rb

  def list
    @clients = Client.find(:all)
  end
	

Métodos del controlador (ii)

• A cada método se le asigna una vista, normalmente una plantilla en RHTML, que genera la respuesta para el usuario
• Si no se indica nada, la vista asociada será la que se llame igual que el controlador

app/views/clients/list.rhtml

...
<% @clients.each do |client| %>

  <td><%= client.name %></td>

<% end %>
...
	

Métodos del controlador (iii)

• El ActionController asocia cada método a una vista
• Podemos forzar que renderice otra vista diferente, o incluso que renderiza en una cadena:
  • render(:action => :index): renderiza la plantilla index.rhtml
  • render(:file => path): renderiza la plantilla indicada en el path
  • cadena = render_to_string(:action => 'list'): renderiza la plantilla indicada en la cadena

  def create
    @client = Client.new(params[:client])
    if @client.save
      redirect_to :action => 'list'
    else
      render :action => 'new'
    end
	

Métodos del controlador (iv)

• También podemos hacer que cuando termine una acción nos redirija a otra acción:
  • redirect_to(:action => 'list'): redirige a la acción list

  def create
    @client = Client.new(params[:client])
    if @client.save
      redirect_to :action => 'list'
    else
      render :action => 'new'
    end
	

Ejemplo de creación

método new » vista new » método create

  def new
    @client = Client.new
  end
	

Ejemplo de creación (ii)

método new » vista new » método create

<form action="/clients/create" method="post">

  <p><label for="client_nif">Nif</label><br/>
  <input id="client_nif" name="client[nif]" size="30" 
  type="text" value="" /></p>

  <p><label for="client_razon_social">Razón social</label><br/>
  <input id="client_razon_social" name="client[razon_social]"
   size="30" type="text" value="" /></p>

  <input name="commit" type="submit" value="Create" />
</form>
	

Ejemplo de creación (iii)

método new » vista new » método create

  def create
    @client = Client.new(params[:client])
    if @client.save
      flash[:notice] = 'Client was successfully created.'
      redirect_to :action => 'list'
    else
      render :action => 'new'
    end
  end
	

Paso de parámetros

• params es un objeto de tipo Hash que se utiliza para pasar parámetros entre vista y controlador.

Después de la llamada a Client.new

params = { 'client' => {:nombre => 'Luis', 
			:telefono => '914562123', 
			:nif => '12345323N' }, 
	'action' => 'create' , 
	'controller' => 'clients' }		


params[:client]
params[:action]
params[:controller]
	

Las URIs en Rails

• Rails utiliza un sistema llamado routing para saber quién ha de resolver cada petición
• En la uri suele incluirse información que ayuda a discernir esto: nombre del controlador, método del controlador, identificador, ...
• Esto consigue que las direcciones en Rails sean fácilmente reconocibles
• El mecanismo es muy flexible: routes.rb

Redirigiendo rutas en Rails

routes.rb

  map.connect ':username/contacto', :controller => 'users', 
	:action =>'contact'

  map.connect 'users/:action/:id', :username=>'ap', 
	:controller => 'users'

  map.connect 'ver/*nicetitles', :username=>'ap', 
	:controller => 'pageposts', 
	:action => 'route'

  map.connect 'programa/:year/:month/:day/:id', 
	:username => 'ap', 
	:controller => 'programmeposts', 
	:action => 'post'
	

Rutas con nombre

routes.rb

  map.programa 'programa/:year/:month/:day/:id', 
	:username => 'ap', 
	:controller => 'programmeposts', 
	:action => 'post'

  programa_url(:year => '2005', :month => '12', 
	:day => '20', :id => '5')
		
	» http://tu.url.com/programa/2005/12/20/5

	

El objeto Flash

• flash es una variable de tipo Hash que se comparte entre controladores y vistas
• Permite transmitir mensajes de un sitio a otro
• Ideal para darle retroalimentación al usuario

  def create
    @client = Client.new(params[:client])
    if @client.save
      flash[:notice] = 'Client was successfully created.'
      redirect_to :action => 'list'
    else
      render :action => 'new'
    end
  end
	

Filtros

• Los filtros permiten definir acciones que se han de llevar a cabo antes o después de ejecutar la llamada al controlador

class ClientsController < ApplicationController

  before_filter :authorize, :only => [ :admin_views, :create, 
					:update, :delete ]

  def authorize
    if not session[:user_id]
      flash[:notice] = "Por favor, identifícate"
      redirect_to :controller => 'user', :action => 'login'
    end
  end
	

Sesiones

• Al igual que el objeto flash, hay una variable de tipo Hash llamada session que permite almacenar información de sesión

def login
  user = User.find(:first, 
		:conditions => "name = '#{params[:name]}' 
			and password = '#{params[:password]}'")
  if user
    session[:user_id] = user.id
    redirect_to :action => 'index'
  else
    reset_session
    flash[:note] = 'Nombre de usuario o contraseña inválidos'
  end

end
	

Ciclo de vida de una petición HTTP

• Framework de desarrollo web con filosofía MVC

ActionView

• El ActionView se encarga de renderizar las plantillas que devolverá Rails como respuesta al usuario
• Por defecto Rails las busca en app/views/controlador/
• Rails soporta dos lenguajes de plantillas:
  • RXML: ficheros .rxml que producen como resultado XML
  • RHTML: ficheros .rhtml que producen como resultado (X)HTML

RHTML básico

• RHTML soporta dos tipos de etiquetas para incrustrar código dinámico:
  • <%= %>: la ejecución de la plantilla produce un contenido
  • <% %>: no se genera ningún código

app/views/clients/view.rhtml

...
<% @clients.each do |client| %>

  <td><%= client.name %></td>

<% end %>
...
  

Helpers

• Además del uso de las etiquetas <% %> y <%= %>, ActionView define una serie de ayudas para generar código mucho más compacto.
• Hay ayudas para generar formularios, formatear datos, crear enlaces, enlazar imágenes,...

Helpers de formateo

<%= human_size 34567 %> » 35 kb

<%= time_ago_in_words Time.local(2004,10,13) %> » 470 days

<%= number_with_precision 65.0/3, 3 %> 	» 21.667

<%= truncate program.name, 20 %> 	» La cocina de Arg... 
	

Helpers de HTML

<%= link_to 'Eliminar', :action => 'delete' %>

<%= link_to 'Eliminar', 
	{:action => 'delete', :controller => 'clients'}, 
	{:class => 'enlace-home', :confirm => '¿Estás seguro?'} 
%>

<%= image_tag "images/home.png", :class => "img-small", 
		:size => "320x240" %>

<%= image_tag "home", :class => "img-small", 
		:size => "320x240" %>

<%= mail_to "soporte@tecnicos.com", "Servicio Técnico", 
		:subject => 'Avería' %>
	

Paginadores

• ActionView y ActiveRecord definen un objeto Pagination: a nivel de vista muestra los enlaces necesarios, mientras que a nivel de objeto se encarga de recuperarlos de la base de datos

def list
  @client_pages, @clients = paginate :clients, :per_page => 10
end
		

<%= pagination_links @client_pages %>
		

El resultado

Helpers de formularios

<%= start_form_tag :action => 'create' %>

  <p><label for="client_nif">Nif</label><br/>
  <%= text_field 'client', 'nif'  %></p>

  <p><label for="client_razon_social">Razón social</label><br/>
  <%= text_field 'client', 'razon_social'  %></p>

  <%= submit_tag "Create" %>

<%= end_form_tag %>
	

Helpers de formularios (ii)

<form action="/clients/create" method="post">

  <p><label for="client_nif">Nif</label><br/>
  <input id="client_nif" name="client[nif]" size="30" 
	type="text" value="" /></p>

  <p><label for="client_razon_social">Razón social</label><br/>
  <input id="client_razon_social" name="client[razon_social]"
	 size="30" type="text" value="" /></p>

  <input name="commit" type="submit" value="Create" />
</form>
		

Helpers de formularios (iii)

params = { 'client' => {:nif => '12345323N', 
			:razon_social => 'Pinturas Esponja' }, 
	 'action' => 'create'}
	

Helpers de formularios (iv)

• text_field :variable, :attribute, options
• hidden_field :variable, :attribute, options
• password_field :variable, :attribute, options
• text_area :variable, :attribute, options
• check_box :variable, :attribute, options, on_value, off_value
• select :variable, :attribute, choices, options html_options

Helpers de formularios (v)

<p><label for="proposal_estado">Estado</label><br/>
<%= 
 select :proposal, :estado, %w{Aceptada Recibida Preparación} 
%></p>
	

Layouts

• Cada plantilla de la vista va incrustada en su layout correspondiente
• Directorio: app/views/layouts
• Jerarquía ascendente: Rails busca una plantilla con el nombre de la vista, y si no la encuentra busca una con el nombre application.rhtml
• Una llamada para incrustar el contenido: <%= content_for_layout %>

Layouts (ii)

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 
 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html lang="es">
<head>
  <title>Maitre</title>
</head>

<body>
  <div class="message">
    <%= flash['note'] %>
  </div>

  <%= @content_for_layout %>

</body>
		

Active Support

• Librería genérica de apoyo
• Incorpora funciones que facilitan el cálculo de tiempo, de pluralización, de conversión entre fechas, etcétera
• Muchas de estas funciones las gasta Rails internamente, pero otras están pensadas para el programador

Ejemplo

now = Time.now
puts now 		» Sun Jan 29 11:02:54 CET 2006
puts 20.minutes.ago 	» Sun Jan 29 10:43:29 CET 2006
puts 3.days.ago 	» Thu Jan 26 11:03:45 CET 2006
puts now.at_midnight 	» Sun Jan 29 00:00:00 CET 2006
puts now.next_week 	» Mon Jan 30 00:00:00 CET 2006
puts now.tomorrow 	» Mon Jan 30 11:02:54 CET 2006
puts now.tomorrow.tomorrow » Tue Jan 31 11:02:54 CET 2006