DESARROLLO WEB CON RAILS

Prefacio



1. Introducción

1.1. Rails es sencillo

1.2. Encontrar la solución

1.3. Convenciones

1.4. Código fuente

1.5. Información importante sobre las versiones Rails





Parte I. Para comenzar



2. Arquitectura de las aplicaciones Rails

2.1. Modelos, vistas y controladores

2.2. Active Record: soporte del modelo Rails

Programación centrada en la base de datos

Mapeo de objetos relacionales

Active Record

2.3. Action pack: el visor y el controlador

Soporte de vista

¡Y el controlador!



3. Instalación de Rails

3.1. La lista de la compra

3.2. Instalación en Windows

3.3. Instalación en Mac OS X

3.4. Instalación en Linux

3.5. Selección de versión Rails

3.6. Entornos de desarrollo

La línea de comandos

Control de versión

Editores

El escritorio

3.7. Rails y las bases de datos

3.8. Mantener la actualización

3.9. Rails y los ISP



4. Recompensa inmediata

4.1. Crear una aplicación nueva

4.2. ¡Hola Rails!

Rails y las solicitudes URL

Nuestra primera acción

Dinamizando

Contenido dinámico

Añadir la hora

La historia hasta el momento

4.3. Vincular páginas

4.4. Lo que acabamos de hacer

Hora de jugar

Limpieza





Parte II. Crear una aplicación



5. La aplicación Depot

5.1. Diseño gradual

5.2. Lo que hace Depot

Casos de uso

Diagramas de flujo

Datos

5.3. Vamos a codificar



6. Tarea A: Mantenimiento del producto

6.1. Iteración A1: ejecutar

Crear una aplicación Rails

Creación de la base de datos

Configurar la aplicación

Probar la configuración

6.2. Crear el modelo de productos y la aplicación de mantenimiento

Ejecutar la aplicación de mantenimiento

6.3. Iteración A2: añadir una columna ausente

6.4. Iteración A3: ¡validación!

6.5. Iteración A4: hacer listas más atractivas

Lo que hemos hecho

Hora de jugar



7. Tarea B: Visualización del catálogo

7.1. Iteración B1: crear un listado de catálogo

7.2. Iteración B2: añadir un diseño de página

7.3. Iteración B3: utilizar un auxiliar para dar formato al precio

7.4. Iteración B4: vincular al carrito

Lo que acabamos de hacer

Hora de jugar



8. Tarea C: Creación del carrito

8.1. Sesiones

Colocar sesiones en la base de datos

Sesiones y buscadores

Carritos y sesiones

8.2. Iteración C1: crear el carrito

8.3. Iteración C2: crear un carrito más inteligente

La moraleja del cuento

8.4. Iteración C3: gestión de errores

¡El flash!

8.5. Iteración C4: terminar el carrito

Lo que hemos hecho

Hora de jugar



9. Tarea D: Añadir un poco de AJAX

9.1. Iteración D1: mover el carrito

Plantillas parciales

Cambiar el flujo

9.2. Iteración D2: crear un carrito AJAX

Resolución de problemas

El cliente nunca está satisfecho

9.3. Iteración D3: destacar los cambios

9.4. Iteración D4: ocultar un carrito vacío

Métodos auxiliares

9.5. Iteración D5: degradar si está deshabilitado Javascript

9.6. Lo que acabamos de hacer

Hora de jugar



10. Tarea E: ¡Cajero!

10.1. Iteración E1: capturar una petición

Relaciones entre modelos

Crear un formulario de captura de petición

Capturar los detalles de la petición

Última modificación AJAX

Lo que acabamos de hacer

Hora de jugar



11. Tarea F: Administración

11.1. Iteración F1: añadir usuarios

Administración de usuarios

11.2. Iteración F2: Inicio de sesión

11.3. Iteración F3: limitar el acceso

11.4. Iteración F4: añadir una barra lateral y más administración

Sale el último administrador

Cerrar la sesión

Lo que hemos hecho

Hora de jugar



12. Tarea G: El último cambio minúsculo

12.1. Generar el suministro de datos XML

Navegación por las tablas

Crear una interfaz REST

Respuesta adecuada

Otra forma de solicitar XML

Generar automáticamente el XML

Suministro Atom

¡Y también JSON!

12.2. Concluyendo

Hora de jugar



13. Tarea I: Internacionalización

13.1. Iteración I1: habilitar la traducción

13.2. Iteración I2: analizar estrategias del contenido

Lo que hemos hecho

Hora de jugar



14. Tarea T: Pruebas

14.1. Pruebas integradas

14.2. Pruebas de unidad de modelos

Una base de datos sólo para las pruebas

Una prueba de unidad real

Fixtures de prueba

Usar datos fixture

Probar el carrito

Soporte de pruebas de unidad

14.3. Pruebas funcionales de los controladores

Administrador

Índice: solamente para administradores

Fixtures dinámicos

Inicio de sesión

Utilidades prácticas de las pruebas funcionales

Métodos de petición HTTP

Afirmaciones

Variables

Métodos auxiliares de pruebas funcionales

Probando el contenido de la respuesta

Selectores

Selectores simples

Selectores encadenados

Pseudoclases

Afirmaciones de respuesta

Anidar afirmaciones de selección

Afirmaciones adicionales

14.4. Pruebas de integración de las aplicaciones

Pruebas de nivel aún superior

Soporte de pruebas de integración

Métodos prácticos de pruebas de integración

14.5. Pruebas de rendimiento

Perfil y evaluación

14.6. Utilizar objetos mock

Stubs frente a mock

Lo que hemos hecho





Parte III. Trabajar con la estructura de Rails



15. Rails en detalle

15.1. ¿Entonces, dónde está Rails?

15.2. Estructura del directorio

app/ y test/

doc/

lib/

Tareas Rake

log/

public/

script/

tmp/

vendor/

Utilizar Edge Rails

15.3. Configuración de Rails

Entornos de ejecución

Configurar las conexiones de la base de datos

Entornos

La ruta de carga

Parámetros de configuración

15.4. Convenciones de nomenclatura

Mayúsculas y minúsculas, subrayados y plurales

Agrupar controladores en módulos

15.5. Registro en Rails

15.6. Pistas de depuración

15.7. ¿Qué es lo siguiente?



16. Active Support

16.1. Ampliaciones disponibles generales

16.2. Enumeraciones y arrays

16.3. Hashes

16.4. Extensiones de cadena

Codificar nuestras normas para dar un estilo propio

16.5. Extensiones a los números

16.6. Extensiones de hora y fecha

16.7. Una extensión a los símbolos Ruby

16.8. with_options

16.9. Soporte Unicode

La aplicación de nombres Unicode



17. Migraciones

17.1. Crear y ejecutar migraciones

Ejecutar migraciones

17.2. Anatomía de una migración

Tipos de columnas

Renombrar columnas

Cambiar columnas

17.3. Administrar tablas

Opciones para crear tablas

Renombrar tablas

Problemas con rename_table

Definición de índices

Claves primarias

Tablas sin clave primaria

17.4. Migraciones de datos

Cargar datos con migraciones

Cargar datos desde los fixtures

Migrar datos con migraciones

17.5. Migraciones avanzadas

Utilizar SQL nativa

Extender las migraciones

Mensajes diseñados y referencias

17.6. Cuando las migraciones van mal

17.7. Manipulación del esquema fuera de las migraciones

17.8. Administrar las migraciones



18. Active Record parte I: Los fundamentos

18.1. Tablas y clases

18.2. Columnas y atributos

Acceder a las filas y atributos

Atributos booleanos

18.3. Claves primarias e id

Claves primarias compuestas

18.4. Conexión a la base de datos

Información del adaptador

Adaptador DB2

Adaptador Firebird

Adaptador Frontbase

Adaptador MySQL

Adaptador Openbase

Adaptador Oracle

Adaptador Postgres

Adaptador SQLite

Adaptador SQL Server

Adaptador Sybase

Conexiones y modelos

18.5. Crear, leer, actualizar y borrar

Crear filas nuevas

Leer las filas existentes

SQL y Active Record

Utilizar cláusulas like

find()

:conditions

:order

:limit

:offset

:joins

:select

:readonly

:from

:group

:lock

Encontrar solamente una fila

Codificar nuestro propio SQL

Obtener las estadísticas de la columna

Cuenta

Buscadores dinámicos

Alcances con nombre y anónimos

Volver a cargar los datos

Actualizar las filas existentes

save, save!, create y create!

Eliminar las filas

18.6. Agregación y datos estructurados

Almacenar datos estructurados

Composición de datos con adiciones

Los objetos compuestos son objetos de valor

18.7. Misceláneo

Identidad de objeto

Utilizar la conexión raw

El caso de la id ausente

Nombres de columnas mágicas

Actualizaciones parciales y bits sucios

Consulta en caché



19. Active Record parte II: Relaciones entre tablas

19.1. Creación de claves externas

19.2. Especificar las relaciones en los modelos

Relaciones una a una

Relaciones una a varias

Relaciones varias a varias

19.3. Declaraciones belongs_to y has_xxx

La declaración belongs_to

La declaración has_one

Opciones de has_one

La declaración has_many

Métodos añadidos por has_many()

La declaración has_and_belongs_to_many

Asociación de colección de devolución de llamadas

Utilizar modelos como tablas de unión

Eliminar duplicados

Ampliar las asociaciones

Compartir ampliaciones de asociación

19.4. Unir varias tablas

Herencias de una sola tabla

Asociaciones polimórficas

19.5. Uniones autoreferenciadas

19.6. Acts as

Acts as list

Acts as tree

19.7. Cuando se guardan las cosas

Grabación y colecciones

19.8. Carga previa de las filas hijo

19.9. Contadores



20. Active Record parte III: Ciclo de vida del objeto

20.1. Validación

Auxiliares de validación

validates_acceptance_of

validates_associated

validates_confirmation_of

validates_each

validates_exclusion_of

validates_format_of

validates_inclusion_of

validates_length_of

validates_numericality_of

validates_presence_of

validates_size_of

validates_uniqueness_of

Validación condicional

Mensajes de error de validación

20.2. Devolución de llamadas

Registros de marcas temporales

Objetos de devolución de llamadas

Observadores

Instanciar los observadores

20.3. Atributos avanzados

Fachada de columnas

Memorización sencilla

20.4. Transacciones

Transacciones integradas

Transacciones de varias bases de datos

Bloqueo optimista



21. Action Controller: Asignación de ruta y las URL

21.1. Los fundamentos

21.2. Solicitudes de ruta

Jugando con las rutas

Definir las rutas con map.connect

Generación de URL

El método url_for

url_for

Rutas con nombre

Nombres de controladores

URL con ruta

21.3. Ruta basada en los recursos

REST: transferencias de estado representacionales

REST y Rails

Añadir nuestras acciones

Recursos anidados

Anidación de ruta superficial

Seleccionar una representación de datos

21.4. Pruebas de ruta



22. Action Controller y Rails

22.1. Métodos de acción

Entorno del controlador

Respuestas al usuario

Presentar las plantillas

Enviar archivos y otros datos

send_data

send_file

Redirección

redirect_to

redirect_to

redirect_to

22.2. Cookies y sesiones

Detección de la cookie

Sesiones Rails

Almacenamiento de la sesión

Comparar las opciones de almacenamiento de sesión

Caducidad de sesión y limpieza

22.3. Flash. Comunicación entre las acciones

22.4. Filtros y verificación

Filtros anteriores y posteriores

Filtros posteriores y respuestas fiables

Filtros durante

Herencias de filtro

Verificación

Aplicación

Pruebas

Acciones

22.5. Memoria caché, primera parte

Qué guardar en el caché

Expirar páginas

Expirar páginas de forma explícita

Seleccionar una estrategia de almacenamiento en caché

Expirar páginas implícitamente

Expiración basada en el tiempo de las páginas en caché

Siendo buenos con la memoria caché del cliente

Expiración de encabezamientos

Soporte de LastModified y ETag

22.6. El problema de las solicitudes GET

Arreglar el problema GET



23. Action View

23.1. Plantillas

Dónde van las plantillas

El entorno de la plantilla

Qué hay dentro de una plantilla

Plantillas constructoras

Plantillas ERb

Escapar valores sustituidos

23.2. Utilizar auxiliares

23.3. Métodos auxiliares para dar formato, vincular y paginar

Auxiliares de formato

Vincular a otras páginas y recursos

Auxiliares de paginado

23.4. Funcionamiento de los formularios

23.5. Formularios que envuelven objetos de modelo

Auxiliares de campos y form_for

Campos de texto

Áreas de texto

Botones de opción

Casillas de verificación

Listas de selección

Listas de selección agrupadas

Campos de fecha y hora

Etiquetas

Auxiliares de campo si utilizar form_for

Varios modelos en un formulario

Control de errores y objetos de modelo

23.6. Constructores de formularios diseñados

23.7. Trabajar con archivos que no son modelos

Antiguo estilo de form_tag

23.8. Cargar archivos en las aplicaciones Rails

23.9. Diseños y componentes

Diseños

Localizar archivos de diseño

Pasar datos a los diseños

Plantillas parciales de página

Parciales y colecciones

Plantillas compartidas

Plantillas con diseños

Parciales y controladores

23.10. Memoria caché, parte dos

Expirar fragmentos de la memoria caché

Opciones de almacenamiento de caché

23.11. Añadir sistemas de plantilla nuevos

Crear plantillas dinámicas



24. La Web, v2.0

24.1. Prototype

El ejemplo de búsqueda

Utilizar auxiliares Prototype

Opciones comunes

Sincronización

Actualizar la página

Filtros JavaScript

Desviación de llamadas

link_to_remote

periodically_call_remote

link_to_function

remote_function

observe_field

observe_form

form_remote_tag y remote_form_for

submit_to_remote

Degradación y estructura del servidor

Degradar a distintas URL

Degradar a la misma URL

24.2. Script.aculo.us

Autocompletado

Opciones auto_complete_field

Elementos arrastrar y soltar y ordenables

Edición local

Efectos visuales

24.3. Plantillas RJS

Editar los datos

Añadir datos

Mostrar/ocultar los datos

Seleccionar elementos

Interacción JavaScript directa

Auxiliares Script.aculo.us

24.4. Conclusión



25. Action Mailer

25.1. Envío de correos electrónicos

Configuración del correo electrónico

Enviar correos

Plantillas de correo

Generar correos electrónicos

Enviar correos en formato HTML

Enviar varios tipos de contenido

Diseños de gestor de correos

Enviar correos adjuntos

25.2. Recibir correos electrónicos

25.3. Pruebas de correo electrónico

Correos de pruebas de unidad

Pruebas funcionales de correo electrónico



26. Active Resources

26.1. Alternativas a Active Resource

XML

JSON

SOAP

XML-RPC

26.2. Vamos a ver el código

26.3. Relaciones y colecciones

26.4. Trabajar con todos los elementos





Parte IV. Seguridad e implementación de su aplicación



27. Seguridad en la aplicación Rails

27.1. Inyección SQL

Protección frente a la inyección SQL

Extraer consultas en métodos de modelo

27.2. Crear registros directamente desde los parámetros del formulario

27.3. No confiar en los parámetros id

27.4. No exponer los métodos de controlador

27.5. Cross-site scripting (CSS/XSS)

Un ataque común

Proteger la aplicación de XSS

27.6. Evitar los ataques de fijación de sesiones

27.7. Cargas de archivos

27.8. No almacenar información sensible sin encriptar

27.9. Utilizar SSL para transmitir la información sensible

27.10. No guardar en caché las páginas autenticadas

27.11. Confirmar que funciona



28. Implementación y producción

28.1. Comenzar pronto

28.2. Cómo funciona un servidor de producción

FastCGI, delegación de solicitudesy Phusion PassengerTM

28.3. Instalación de Passenger

28.4. Implementación sin preocupaciones con Capistrano

Preparación del servidor de implementación

Poniendo bajo control una aplicación

Implementar la aplicación

Enjuagar, lavar y repetir

28.5. Verificación en una aplicación implementada

Examinar los archivos de registro

Usar la consola para mirar la aplicación en activo

28.6. Tareas de la aplicación de producción

Relaciones con los archivos de registro

Limpiar sesiones

Limitar los errores de la aplicación

28.7. Concluyendo la implementación





Parte V. Apéndices



Apéndice A. Introducción a Ruby

A.1. Ruby es un lenguaje orientado a objetos

A.2. Nombres Ruby

A.3. Métodos

A.4. Clases

Privado y protegido

A.5. Módulos

A.6. Array y hash

Los hash y las listas de parámetros

A.7. Estructuras de control

A.8. Expresiones regulares

A.9. Bloques e iteradores

A.10. Excepciones

A.11. Objetos Marshal

A.12. Ruby interactivo

A.13. Estilos de Ruby

A.14. Documentación



Apéndice B. Parámetros de configuración

B.1. Configuración de nivel superior

B.2. Configuración Active Record

Configuración variada de Active Record

B.3. Configuración de Action Controller

B.4. Configuración Action View

B.5. Configuración de Action Mailer

B.6. Configuración de las pruebas



Apéndice C. Código fuente

C.1. Aplicación Depot completa

Configuración y migraciones de la base de datos

Controladores

Modelos

Diseño y vistas

Vistas admin

Vistas de producto

Vistas de la tienda

Vistas de usuario

Quién ha comprado

Auxiliar

Internacionalización

Pruebas de unidad y funcional

Datos de prueba

Pruebas de unidad

Pruebas funcionales

Pruebas de integración

Pruebas de rendimiento

Archivos CSS



Apéndice D. Recursos

D.1. Recursos en la red



Índice alfabético

Ruby on Rails es una estructura Web MVC (Model-View-Controller) completa que le ayudará a crear aplicaciones Web de alta calidad, dedicando mucho menos tiempo del que imagina. Concéntrese en la aplicación, y Rails se ocupará de los detalles. Incluso puede escribir aplicaciones que admiten JavaScript sin tener que redactar una sola línea de código.



Este libro comienza con un recorrido paso a paso por la creación de una aplicación real, para luego profundizar en el análisis de las características integradas de Rails. Por último, ofrece un enfoque en los recursos de Rails y descubre los métodos más prácticos que utilizan actualmente los desarrolladores. Este manual le enseña, entre otros aspectos, a aprender cómo Rails elimina configuraciones tediosas y tareas de administración local, cómo incorporar a sus aplicaciones Ajax, REST, servicios Web y control de correo electrónico, etc.