← Volver a la lista de posts

Introducción a Ruby on Rails

Ruby on Rails es un framework para crear aplicaciones Web, escrito en el lenguaje de programación Ruby, y diseñado para que el desarrollo de aplicaciones Web sea fácil y divertido.

Asumiendo que ya tienes Ruby instalado, crear un nuevo proyecto en Rails es tan fácil como ejecutar los siguientes comandos en la consola:

$ gem install rails
$ rails new mi_app
$ cd mi_app
$ rails server

El primer comando instala Rails. El segundo comando crea una carpeta con los archivos del proyecto. El tercer comando ingresa a la carpeta del proyecto. Y el último inicia el servidor. Eso es todo. Después de ejecutar esos comandos puedes ingresar a http://localhost:3000/ y ver la pantalla que por defecto crea Rails. ¡Felicitaciones, has creado tu primera aplicación Web! Aún no está publicada en Internet, pero al menos puedes accederla localmente desde tu computador.

Los 5 componentes más importantes del framework son los siguientes:

  • Enrutador.
  • Vistas.
  • ActiveRecord (la capa de acceso a datos).
  • Migraciones.
  • Aplicación de consola.

El enrutador

El objetivo de todos los frameworks de desarrollo Web, incluido Rails, es el de mapear (o relacionar) URL’s (p.e. http://localhost:3000/productos) al código que va a procesar esas peticiones.

Por ejemplo, supongamos que queremos crear una ruta para que cuando un usuario ingrese a http://localhost:3000/productos desde su navegador (p.e. Chrome, Firefox, Internet Explorer, etc.), vea la lista de productos que existen en ese momento en la base de datos. En Rails, las rutas se definen en el archivo config/routes.rb como se muestra en el siguiente ejemplo:

Rails.application.routes.draw do
  get 'products', to: 'products#index'
end

La segunda línea le dice a Rails que las peticiones que lleguen a /products van a ser procesadas por el método index de la clase ProductsController.

A los métodos que procesan las peticiones se les llaman acciones, y a las clases que contienen esos métodos se les llaman controladores. Los controladores se encuentran en la carpeta app/controllers).

Generalmente las acciones interactuan con la base de datos y renderizan una vista, pero para este ejemplo simplemente vamos a devolver <h1>Hola Mundo</h1>:

class ProductsController < ApplicationController
  def index
    render html: "<h1>Hola Mundo</h1>".html_safe
  end
end

Las vistas

Escribir todo el HTML directamente en las acciones sería bastante engorroso. Las vistas son archivos que se encuentran en la carpeta app/views y se usan para generar la respuesta que se va a devolver desde las acciones. Lo interesante es que en las vistas podemos meter (embeber es la palabra correcta) código Ruby como en el siguiente ejemplo que imprime <p>Hola Mundo</p> 3 veces:

<% 3.times do %>
  <p>Hola Mundo</p>
<% end %>

Fíjate que el código Ruby se debe embeber en las etiquetas <% y %>.

En los controladores, las acciones usan el método render para renderizar una vista como se muestra en el siguiente ejemplo:

class ProductsController < ApplicationController
  def index
    render 'products/index'
  end
end

En este caso se renderizaría la vista ubicada en app/views/products/index.html.erb. Fíjate que no fue necesario especificar la carpeta app/views/ ni la extensión .html.erb, Rails se encarga de eso automáticamente. Ahora, lo que confunde a muchos principiantes es que si hubiésemos omitido la línea render 'products/index' del código anterior (es decir, si el método index estuviera vacío), igual se renderizaría la misma vista. La razón es que Rails asume que, por defecto, quieres renderizar una vista y usa el nombre del controlador y de la acción para construir la ruta.

La regla es no llamar render explícitamente a menos de que necesites renderizar algo diferente a la vista que se renderiza por defecto (es decir, hubiese sido mejor dejar el método index vacío en el código anterior).

Ruby on Rails usa un concepto llamado convención sobre configuración para que la estructura de todos los proyectos sea similar y escribamos menos código. La desventaja es que, para los que están aprendiendo, muchas cosas en Rails parecen magia mientras entienden la convención y cómo sobrepasarla cuando es necesario.

Las acciones pueden pasar información a las vistas a través de variables de instancia (variables que empiezan con @) como en se muestra el siguiente ejemplo que mostraría <h1>Hola Mundo</h1> en el navegador:

class ProductsController < ApplicationController
  def index
    @greeting = "Hola Mundo"
  end
end

(Fíjate que no llamamos render explicitamente, así que la vista debe estar ubicada en app/views/products/index.html.erb). El contenido de esa vista es el siguiente:

<h1><%= @greeting %></h1>

Nota: En este caso usamos <%= porque queremos imprimir el valor de la variable @greeting en la pantalla.

ActiveRecord

ActiveRecord es la capa que nos permite acceder y manipular la información de la base de datos sin necesidad de escribir SQL (Structured Query Language).

El concepto más importante de ActiveRecord es el modelo. Un modelo es una clase de Ruby que extiende ActiveRecord::Base como se muestra en el siguiente ejemplo:

class Product < ActiveRecord::Base
end

Un modelo representa, generalmente, una tabla de la Base de Datos. Por convención, el nombre de la tabla es el mismo nombre del modelo pero sin capitalizar y en plural (products en este caso). Fíjate que en el modelo no definimos las columnas de la tabla explicitamente, ActiveRecord las toma de la tabla directamente (por convención).

Las acciones en los controladores usan los modelos para acceder a la información de la base de datos como se muestra en el siguiente ejemplo:

class ProductsController < ApplicationController
  def index
    @products = Product.all
  end
end

Y en la vista podemos mostrar los productos en una tabla HTML:

<table>
  <% @products.each do |product| %>
    <tr>
      <td><%= product.name %></td>
      <td><%= product.description %></td>
      <td><%= product.price %></td>
    </tr>
  <% end %>
</table>

Otra forma de interactuar con la base de datos, a través de los modelos, es con la consola de Rails que se accede con el comando rails console:

$ rails console
> Product.all
# muestra todos los productos

> p1 = Product.create(name: "Cerveza", description: "Yeah", price: 1500)
> p1.name
# imprime "Cerveza"

> p1.price = 1800 # subió de precio :(
> p1.save # guardemos el cambio en la base de datos

> p1.destroy # eliminemos el registro de la base de datos

Sin embargo, el verdadero poder de ActiveRecord está en las validaciones y las asociaciones, aunque, por espacio, ese será el tema de otro post.

Migraciones

Las migraciones nos permiten hacer cambios sobre la estructura de la base de datos de forma fácil y consistente, especialmente si multiples personas trabajan sobre el mismo proyecto, o el proyecto ya se encuentra en producción.

Las migraciones son archivos que se encuentran en la carpeta db/migrate y contienen instrucciones con cambios a la base de datos (creación de tablas, adición o modificación de columnas, etc.). Veamos un ejemplo de una migración:

class CreateProducts < ActiveRecord::Migration
  def change
    create_table :products do |t|
      t.string :name
      t.text :description

      t.timestamps null: false
    end
  end
end

Esta migración está creando la tabla productos con dos columnas: name y description.

Las migraciones se pueden crear manualmente, pero es mejor crearlas con el generador que viene integrado en la aplicación de consola de Rails (el tema de la siguiente sección):

$ rails generate migration AddPriceToProducts price:decimal

Que generaría la siguiente migración:

class AddPriceToProducts < ActiveRecord::Migration
  def change
    add_column :products, :price, :decimal
  end
end

Nota: Al generar una migración, solo estás creando un archivo con instrucciones para modificar la base de datos. Para ejecutar esos cambios en la base de datos debes correr el comando:

$ rake db:migrate

Para ver el estado de las migraciones en un proyecto, usa el comando:

$ rake db:migrate:status

Aplicación de Consola

Una de las razones por las que Rails es tan popular es que trae una poderosa aplicación de consola que nos permite, entre otras cosas, generar código a través de comandos.

Por ejemplo, podemos crear la estructura básica de una aplicación con los siguientes comandos:

$ rails new mi_app
$ cd mi_app
$ rails g model Product name description price:decimal
$ rails g controller Products
$ rake db:migrate

El tercer comando genera, entre otras cosas:

  • Un modelo llamado Product.
  • Una migración para crear la tabla products con tres columnas: name, description, y price.

El cuarto comando genera, entre otras cosas:

  • Un controlador llamado ProductsController.
  • Una carpeta products dentro de app/views.

El siguiente paso sería crear rutas y vistas que necesitemos para listar, crear, editar y eliminar productos. Existen comandos que nos generarían más código pero no te los recomendamos por ahora para que entiendas cómo funcionan todos los componentes de Rails.

Más recursos

comments powered by Disqus