Guías de Make it Real
  • Introduction
  • Preparación
    • Conceptos básicos
    • El editor de texto
    • La línea de comandos
    • Git y Github
  • Git
    • Instalación y configuración
    • Conceptos y comandos esenciales
    • Ignorando archivos y carpetas
    • Trabajando con ramas
    • Repositorios remotos
    • Etiquetas
    • Reescribiendo la historia
    • Stashing
    • Github
  • HTML y CSS
    • Introducción a HTML
    • Introducción a CSS
    • Más elementos de HTML
    • Tablas
    • Formularios
    • El modelo de caja en CSS
    • Fondos (backgrounds)
    • Posicionamiento
    • Selectores CSS
    • Bordes, sombras y gradientes
    • Media Queries
    • Unidades en CSS
    • Flexbox
  • Bootstrap 3
    • Primeros pasos
    • Elementos básicos de HTML
    • Componentes
    • La grilla
    • Personalizando Bootstrap
    • Utilizando plantillas
  • Bootstrap 4
    • Primeros pasos
    • Elementos básicos de HTML
    • Componentes
    • La grilla
    • Clases utilitarias
    • Personalizando Bootstrap
  • Ruby
    • Primeros pasos
    • Tipos y operadores
    • Variables y entrada de usuario
    • Condicionales
    • Ciclos
    • Arreglos
    • Más cadenas de texto
    • Hashes
    • Métodos
    • Manipulación de archivos
    • Gemas
  • Programación Orientada a Objetos en Ruby
    • Clases y objetos
    • Métodos y atributos de clase
    • Herencia
    • Módulos
    • Excepciones
  • JavaScript I
    • Primeros pasos
    • Tipos y operadores
    • Variables
    • Condicionales
    • Ciclos
    • Arreglos
    • Más cadenas de texto
    • Funciones
    • Objetos literales
    • Manipulación de archivos
  • JavaScript en el navegador
    • Primeros pasos
    • Manipulando HTML
    • Escuchando eventos
    • Local Storage
    • History API
    • Canvas
    • Notificaciones Web
    • Audio y Video
    • Arrastrar y soltar
    • JSON
    • Realizando peticiones HTTP
  • jQuery
    • Primeros pasos
    • Manipulando HTML
    • Escuchando eventos
    • Plugins
    • Realizando peticiones con AJAX
  • JavaScript II
    • Prototipos
    • Librerías (Node.js)
    • ES6
    • Uso de this (call, apply, bind)
    • Programación funcional
    • Scope, hoisting, closures
    • Programación asincrónica
    • Testing
  • HTTP y Sinatra
    • Primeros pasos con Sinatra
    • El protocolo HTTP
    • Rutas
    • Formularios
    • Cookies y sesión
  • Bases de datos
    • Bases de datos relacionales
    • SQL
    • DDL
    • MongoDB
  • Ruby on Rails I
    • Primeros pasos
    • Arquitectura
    • Rutas
    • Layouts y rendering
    • ActiveRecord - Modelos
    • ActiveRecord - Migraciones
    • ActiveRecord - Validaciones
    • ActiveRecord - Asociaciones
    • ActiveRecord - Scopes
    • ActiveRecord - Callbacks
    • Recursos REST
    • Formularios
    • Autenticación con Devise
    • Sass y Bootstrap
    • Envío de correos
    • Carga de imágenes
    • Seeds
    • Heroku
  • Ruby on Rails II
    • Usando JavaScript (y jQuery) en Rails
    • Testing en Ruby
    • Testing en Rails
    • Creando una Web API
    • Web Sockets
  • Express.js
    • Primeros Pasos
    • El protocolo HTTP
    • Rutas
    • Vistas
    • Middlewares y manejo de errores
    • Formularios
    • Cookies y sesión
  • Express.js II
    • Mongoose
    • Web Sockets
    • Autenticación
    • Envío de correos
    • Cargar imágenes
    • Deployment
    • Testing
    • Creando una Web API
  • React
    • Primeros pasos
    • JSX
    • Componentes
    • Más sobre estado
    • Formularios
    • Peticiones HTTP con Axios
    • React Hooks
    • React Context
    • React Bootstrap
    • React Router
    • Carga de Imágenes
    • Testing
    • Estructura de carpetas
    • Componentes de clase
  • Redux
    • Primeros pasos
    • Action creators
    • Usando la librería react-redux
    • Middlewares
    • Operaciones asincrónicas con redux-thunk
    • Combinando funciones reductoras
    • Testing
    • Redux Tool Kit
  • Algoritmos
    • Describiendo un algoritmo
    • Complejidad (Big-O)
    • Estructuras de datos
    • Recursión
    • Ordenamiento
    • Búsqueda
    • Programación dinámica
  • Python
    • Primeros Pasos
    • Tipos y Variables
    • Funciones
    • Control de Flujo
    • Listas
    • Ciclos
    • Diccionarios, Tuplas y Sets
  • NumPy
    • Primeros Pasos
    • Arreglos
    • Arreglos Multidimensionales
    • Estadística con NumPy
    • Distribución Estadística
  • Pandas
    • Primeros Pasos
    • Inspección y Selección de Datos
    • Modificando Dataframes
    • La Función Lambda
    • Aggregates en Pandas
    • Múltiples Tablas
Powered by GitBook
On this page
  • El enrutador
  • Los controladores
  • Las vistas
  • Pasando información del controlador a la vista
  • ActiveRecord
  • La aplicación de consola
  1. Ruby on Rails I

Arquitectura

PreviousPrimeros pasosNextRutas

Last updated 2 years ago

Ruby on Rails usa un concepto llamado para que la estructura de todos los proyectos sea similar y escribamos menos código.

La desventaja de la es que muchas cosas en Rails parecen magia para los principiantes.

Los componentes más importantes de Ruby on Rails son:

  • El enrutador (el archivo config/routes.rb).

  • Los controladores (en app/controllers).

  • Las vistas (en app/views).

  • ActiveRecord (la capa de acceso a la base de datos).

  • La aplicación de consola.

El enrutador

El enrutador es el componente que decide qué controlador y método va a procesar una petición HTTP.

El enrutador se configura en el archivo config/routes.rb.

Hay varias formas de definir las rutas. Veamos la más genérica:

get '/products', to: 'products#index'

En este ejemplo estamos diciendo que cuando alguien haga una petición a GET /products el método index del controlador ProductsController (ubicado en app/controllers/products_controller.rb) es el que se va a encargar de procesar la petición.

Otra forma equivalente es utilizar el operador => (hashrocket) de la siguiente forma:

get '/products' => 'products#index'

No importa cuál forma utilices, lo importante es ser consistente en cada proyecto.

Por último, es posible omitir el controlador y el método **siempre y cuando la ruta tenga la forma **/<controlador>/<método>. Por ejemplo, la siguiente línea utilizará el método index del controlador ProductsController.

get '/products/index'

Los controladores

Los controladores son clases de Ruby que extienden ApplicationController y tienen métodos que son los que se van a encargar de procesar las peticiones HTTP.

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

En este ejemplo estamos renderizando el HTML <h1>Hola Mundo</h1>.

El método html_safe es necesario para decirle a Rails que no escape el código HTML.

Las vistas

Al igual que en Sinatra podemos utilizar vistas para no tener que escribir todo el código HTML en el código Ruby.

Por convención Rails renderiza una vista por defecto que se debe encontrar en una ubicación específica y se debe llamar de una forma específica:

  • El nombre del archivo debe ser igual al método seguido de .html.erb (generalmente).

  • Se debe ubicar en la carpeta app/views dentro de una carpeta que se llame igual al controlador.

Por ejemplo, el método index del siguiente controlador va a intentar renderizar la vista app/views/products/index.html.erb:

class ProductsController < ApplicationController
  def index
  end
end

Pasando información del controlador a la vista

Al igual que con Sinatra cualquier variable de instancia va a ser visible en la vista. Por ejemplo, si en el controlador tenemos lo siguiente:

class ProductsController < ApplicationController
  def index
    @name = "Pedro"
  end
end

Podemos utilizar esa información en la vista (que debe estar ubicada en app/views/products/index.html.erb) de la siguiente forma:

<h1>Hola <%= @name %></h1>

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)](SQL (Structured Query Language)).

La aplicación de consola

Una de las razones por las que Ruby on 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 llamados generadores.

En las siguientes secciones veremos estos componentes en más detalle.

convención sobre configuración
convención sobre configuración