Ruby on Rails - Guía rápida

¿Qué es Ruby?

Antes de montar en Rails, recapitulemos algunos puntos de Ruby, que es la base de Rails.

Ruby es la combinación exitosa de:

La elegancia conceptual de Smalltalk,
La facilidad de uso y aprendizaje de Python, y
El pragmatismo de Perl.

Ruby es ...

Un lenguaje de programación de alto nivel.
Interpretado como Perl, Python, Tcl / TK.
Orientado a objetos como Smalltalk, Eiffel, Ada, Java.

¿Por qué Ruby?

Ruby se originó en Japón y ahora está ganando popularidad también en Estados Unidos y Europa. Los siguientes factores contribuyen a su popularidad:

Fácil de aprender
Código abierto (licencia muy liberal)
Bibliotecas ricas
Muy fácil de extender
Verdaderamente orientado a objetos
Menos codificación con menos errores
Comunidad útil

Aunque tenemos muchas razones para usar Ruby, también hay algunos inconvenientes que es posible que deba considerar antes de implementar Ruby:

Performance Issues - Aunque compite con Perl y Python, sigue siendo un lenguaje interpretado y no podemos compararlo con lenguajes de programación de alto nivel como C o C ++.
Threading model- Ruby no usa hilos nativos. Los subprocesos de Ruby se simulan en la máquina virtual en lugar de ejecutarse como subprocesos del sistema operativo nativo.

Ejemplo de código Ruby

Aquí hay un código Ruby de muestra para imprimir "Hello Ruby"

# The Hello Class
class Hello
   
   def initialize( name )
      @name = name.capitalize
   end

   def salute
      puts "Hello #{@name}!"
   end
   
end

# Create a new object
h = Hello.new("Ruby")

# Output "Hello Ruby!"
h.salute

Output - Esto producirá el siguiente resultado -

Hello Ruby!

Ruby incrustado

Ruby proporciona un programa llamado ERB (Embedded Ruby), escrito por Seki Masatoshi . ERB le permite poner códigos Ruby dentro de un archivo HTML. ERB lee, palabra por palabra, y luego, en cierto punto, cuando encuentra un código Ruby incrustado en el documento, comienza a ejecutar el código Ruby.

Solo necesita saber dos cosas para preparar un documento ERB:

Si desea que se ejecute algún código Ruby, enciérrelo entre <% y %>.
Si desea que se imprima el resultado de la ejecución del código, como parte de la salida, incluya el código entre <%= y %>.

He aquí un ejemplo. Guarde el código en el archivo erbdemo.rb. Tenga en cuenta que un archivo Ruby tendrá una extensión.rb -

<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>

<html>

   <head>
      <title><%= page_title %></title>
   </head>
	
   <body>
      <p><%= salutation %></p>
      <p>This is an example of how ERB fills out a template.</p>
   </body>
	
</html>

Ahora, ejecute el programa usando la utilidad de línea de comandos erb.

tp> erb erbdemo.rb

Esto producirá el siguiente resultado:

<html>

   <head>
      <title>Demonstration of ERb</title>
   </head>
	
   <body>
      <p>Dear programmer,</p>
      <p>This is an example  of how ERb fills out a template.</p>
   </body>
	
</html>

¿Qué es Rails?

Un marco de aplicación web extremadamente productivo.
Escrito en Ruby por David Heinemeier Hansson.
Podría desarrollar una aplicación web al menos diez veces más rápido con Rails de lo que podría con un marco típico de Java.
Un marco Ruby de código abierto para desarrollar aplicaciones web respaldadas por bases de datos.
Configure su código con el esquema de la base de datos.
No se requiere fase de compilación.

Marco de pila completo

Incluye todo lo necesario para crear una aplicación web basada en bases de datos, utilizando el patrón Modelo-Vista-Controlador.
Ser un marco de pila completa significa que todas las capas están creadas para funcionar a la perfección con menos código.
Requiere menos líneas de código que otros marcos.

Convención sobre configuración

Rails evita los archivos de configuración en favor de las convenciones, la reflexión y las extensiones dinámicas de tiempo de ejecución.
¡Su código de aplicación y su base de datos en ejecución ya contienen todo lo que Rails necesita saber!

Fortalezas de los rieles

Rails está repleto de características que lo hacen más productivo, y muchas de las siguientes características se complementan entre sí.

Metaprogramación

Mientras que otros marcos utilizan una amplia generación de código desde cero, el marco Rail utiliza técnicas de metaprogramación para escribir programas. Ruby es uno de los mejores lenguajes para metaprogramación, y Rails usa bien esta capacidad. Rails también usa la generación de código, pero depende mucho más de la metaprogramación para el trabajo pesado.

Registro activo

Rails presenta el marco Active Record, que guarda objetos en la base de datos. La versión Rails del Active Record descubre las columnas en un esquema de base de datos y las adjunta automáticamente a los objetos de su dominio mediante la metaprogramación.

Convención sobre configuración

La mayoría de los marcos de desarrollo web para .NET o Java le obligan a escribir páginas de código de configuración. Si sigue las convenciones de nomenclatura sugeridas, Rails no necesita mucha configuración.

Andamio

A menudo, crea código temporal en las primeras etapas de desarrollo para ayudar a que una aplicación se ejecute rápidamente y ver cómo los componentes principales funcionan juntos. Rails crea automáticamente gran parte del andamio que necesitará.

Pruebas integradas

Rails crea pruebas automatizadas simples que luego puede ampliar. Rails también proporciona código de soporte llamado arneses y accesorios que facilitan la escritura y ejecución de casos de prueba. Ruby puede ejecutar todas sus pruebas automatizadas con la utilidad rake.

Tres ambientes

Rails le ofrece tres entornos predeterminados: desarrollo, pruebas y producción. Cada uno se comporta de forma ligeramente diferente, lo que facilita todo el ciclo de desarrollo de software. Por ejemplo, Rails crea una copia nueva de la base de datos de prueba para cada ejecución de prueba.

Para desarrollar una aplicación web usando Ruby on Rails Framework, necesita instalar el siguiente software:

Ruby
El marco de Rails
Un servidor web
Un sistema de base de datos

Suponemos que ya ha instalado un servidor web y un sistema de base de datos en su computadora. Puede utilizar el servidor web WEBrick, que viene con Ruby. Sin embargo, la mayoría de los sitios web utilizan servidores web Apache o lightTPD en producción.

Rails funciona con muchos sistemas de bases de datos, incluidos MySQL, PostgreSQL, SQLite, Oracle, DB2 y SQL Server. Consulte el manual de configuración del sistema de base de datos correspondiente para configurar su base de datos.

Veamos las instrucciones de instalación de Rails en Windows y Linux.

Instalación de rieles en Windows

Siga los pasos que se indican a continuación para instalar Ruby on Rails.

Paso 1: Verifique la versión de Ruby

Primero, verifique si ya tiene Ruby instalado. Abra el símbolo del sistema y escribaruby -v. Si Ruby responde y muestra un número de versión igual o superior a 2.2.2, escribagem --version. Si no recibe un error, omitaInstall Rubypaso. De lo contrario, instalaremos un Ruby nuevo.

Paso 2: instala Ruby

Si Ruby no está instalado, descargue un paquete de instalación desde rubyinstaller.org. Siga eldownloadenlace y ejecute el instalador resultante. Este es un archivo exerubyinstaller-2.2.2.x.exey se instalará con un solo clic. Es un paquete muy pequeño y también obtendrá RubyGems junto con este paquete. Por favor, checa elRelease Notes para más detalles.

Paso 3: instalar rieles

Install Rails - Con Rubygems cargado, puede instalar todos los Rails y sus dependencias usando el siguiente comando a través de la línea de comandos -

C:\> gem install rails

Note- El comando anterior puede tardar algún tiempo en instalar todas las dependencias. Asegúrese de estar conectado a Internet mientras instala las dependencias de gemas.

Paso 4: Verifique la versión de rieles

Use el siguiente comando para verificar la versión de los rieles.

C:\> rails -v

Output

Rails 4.2.4

¡Felicidades! Ahora estás en Rails sobre Windows.

Instalación de rieles en Linux

Estamos instalando Ruby On Rails en Linux usando rbenv. Es una herramienta ligera de gestión de versiones de Ruby. losrbenv proporciona un procedimiento de instalación sencillo para administrar varias versiones de Ruby y un entorno sólido para desarrollar aplicaciones Ruby on Rails.

Siga los pasos que se indican a continuación para instalar Ruby on Rails usando la herramienta rbenv.

Paso 1: instalar las dependencias de requisitos previos

Primero que nada, tenemos que instalar git - corey algunas dependencias de ruby que ayudan a instalar Ruby on Rails. Use el siguiente comando para instalar dependencias de Rails usandoyum.

tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-devel

Paso 2: Instale rbenv

Ahora instalaremos rbenv y configuraremos las variables de entorno adecuadas. Utilice el siguiente conjunto de comandos para obtener rbenv para el repositorio git.

tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
tp> exec $SHELL

tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELL

Paso 3: instala Ruby

Antes de instalar Ruby, determine qué versión de Ruby desea instalar. Instalaremos Ruby 2.2.3. Utilice el siguiente comando para instalar Ruby.

tp> rbenv install -v 2.2.3

Utilice el siguiente comando para configurar la versión actual de Ruby como predeterminada.

tp> rbenv global 2.2.3

Utilice el siguiente comando para verificar la versión de Ruby.

tp> ruby -v

Output

ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]

Ruby proporciona una palabra clave gempara instalar las dependencias compatibles; Nosotros los llamamosgems. Si no desea instalar la documentación de Ruby-gems, utilice el siguiente comando.

tp> echo "gem: --no-document" > ~/.gemrc

A partir de entonces, es mejor instalar la gema Bundler, ya que ayuda a administrar las dependencias de su aplicación. Utilice el siguiente comando para instalar la gema del paquete.

tp> gem install bundler

Paso 4: instalar rieles

Utilice el siguiente comando para instalar Rails versión 4.2.4.

tp> install rails -v 4.2.4

Utilice el siguiente comando para que Rails esté disponible.

tp> rbenv rehash

Utilice el siguiente comando para verificar la versión de los rieles.

tp> rails -v

Output

tp> Rails 4.2.4

El marco de Ruby on Rails requiere JavaScript Runtime Environment (Node.js) para administrar las características de Rails. A continuación, veremos cómo podemos usar Node.js para administrar Asset Pipeline, que es una función de Rails.

Paso 5: instalar JavaScript Runtime

Instalemos Node.js desde el repositorio de Yum. Tomaremos Node.js del repositorio de EPEL yum. Use el siguiente comando para agregar el paquete EPEL al repositorio de yum.

tp> sudo yum -y install epel-release

Utilice el siguiente comando para instalar el paquete Node.js.

tp> sudo yum install nodejs

¡Felicidades! Ahora estás en Rails sobre Linux.

Paso 6: instalar la base de datos

De forma predeterminada, Rails usa sqlite3, pero es posible que desee instalar MySQL, PostgreSQL u otro RDBMS. Esto es opcional; Si tiene la base de datos instalada, puede omitir este paso y no es obligatorio que tenga una base de datos instalada para iniciar el servidor de rails. Para este tutorial, usamos la base de datos PostgreSQL. Por lo tanto, utilice los siguientes comandos para instalar PostgreSQL.

tp> sudo yum install postgresql-server postgresql-contrib

Acepte el mensaje respondiendo con un y. Utilice el siguiente comando para crear un clúster de base de datos de PostgreSQl.

tp> sudo postgresql-setup initdb

Utilice el siguiente comando para iniciar y habilitar PostgreSQL.

tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresql

Mantener los rieles actualizados

Suponiendo que haya instalado Rails usando RubyGems, mantenerlo actualizado es relativamente fácil. Podemos usar el mismo comando en la plataforma Windows y Linux. Utilice el siguiente comando:

tp> gem update rails

Output

La siguiente captura de pantalla muestra un símbolo del sistema de Windows. La terminal de Linux también proporciona la misma salida.

Esto actualizará automáticamente su instalación de Rails. La próxima vez que reinicie su aplicación, recogerá esta última versión de Rails. Mientras usa este comando, asegúrese de estar conectado a Internet.

Verificación de instalación

Puede verificar si todo está configurado de acuerdo con sus requisitos o no. Utilice el siguiente comando para crear un proyecto de demostración.

tp> rails new demo

Output

Generará un proyecto ferroviario de demostración; lo discutiremos más tarde. Actualmente tenemos que comprobar si el entorno está configurado o no. A continuación, use el siguiente comando para ejecutar el servidor web WEBrick en su máquina.

tp> cd demo
tp> rails server

Generará código automático para iniciar el servidor.

Ahora abra su navegador y escriba lo siguiente:

http://localhost:3000

Debería mostrar un mensaje, como "Bienvenido a bordo" o "Felicitaciones".

Un marco es un programa, conjunto de programas y / o biblioteca de código que escribe la mayor parte de su aplicación por usted. Cuando usa un marco, su trabajo es escribir las partes de la aplicación que hacen que haga las cosas específicas que desea.

Cuando se propone escribir una aplicación Rails, dejando de lado la configuración y otras tareas domésticas, debe realizar tres tareas principales:

Describe and model your application's domain- El dominio es el universo de su aplicación. El dominio puede ser una tienda de música, una universidad, un servicio de citas, una libreta de direcciones o un inventario de hardware. Así que aquí tienes que averiguar qué contiene, qué entidades existen en este universo y cómo se relacionan los elementos entre sí. Esto es equivalente a modelar una estructura de base de datos para mantener las entidades y su relación.
Specify what can happen in this domain- El modelo de dominio es estático; tienes que hacerlo dinámico. Las direcciones se pueden agregar a una libreta de direcciones. Las partituras musicales se pueden comprar en las tiendas de música. Los usuarios pueden iniciar sesión en un servicio de citas. Los estudiantes pueden inscribirse en clases en una universidad. Debes identificar todos los posibles escenarios o acciones en las que pueden participar los elementos de tu dominio.
Choose and design the publicly available views of the domain- En este punto, puede empezar a pensar en términos de navegador web. Una vez que haya decidido que su dominio tiene estudiantes y que pueden registrarse en las clases, puede visualizar una página de bienvenida, una página de registro y una página de confirmación, etc. Cada una de estas páginas, o vistas, muestra al usuario cómo funcionan las cosas pararse en cierto punto.

Basándose en las tres tareas anteriores, Ruby on Rails se ocupa de un marco de modelo / vista / controlador (MVC).

Marco MVC de Ruby on Rails

los Model Vver CEl principio de control divide el trabajo de una aplicación en tres subsistemas separados pero estrechamente cooperativos.

Modelo (ActiveRecord)

Mantiene la relación entre los objetos y la base de datos y maneja la validación, asociación, transacciones y más.

Este subsistema está implementado en la biblioteca ActiveRecord, que proporciona una interfaz y enlace entre las tablas en una base de datos relacional y el código del programa Ruby que manipula los registros de la base de datos. Los nombres de los métodos Ruby se generan automáticamente a partir de los nombres de campo de las tablas de la base de datos.

Ver (ActionView)

Es una presentación de datos en un formato particular, provocada por la decisión de un controlador de presentar los datos. Son sistemas de plantillas basados en scripts como JSP, ASP, PHP y muy fáciles de integrar con la tecnología AJAX.

Este subsistema se implementa en la biblioteca ActionView, que es un sistema basado en Embedded Ruby (ERb) para definir plantillas de presentación para la presentación de datos. Cada conexión web a una aplicación Rails da como resultado la visualización de una vista.

Controlador (ActionController)

La facilidad dentro de la aplicación que dirige el tráfico, por un lado, consultando los modelos en busca de datos específicos y, por otro lado, organizando esos datos (buscarlos, clasificarlos, enviarlos por mensajes) en una forma que se ajuste a las necesidades de una vista determinada.

Este subsistema se implementa en ActionController, que es un intermediario de datos que se encuentra entre ActiveRecord (la interfaz de la base de datos) y ActionView (el motor de presentación).

Representación pictórica del marco MVC

A continuación se muestra una representación pictórica de Ruby on Rails Framework:

Representación de directorio de MVC Framework

Suponiendo una instalación estándar y predeterminada sobre Linux, puede encontrarlos así:

tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> ls

Verá subdirectorios que incluyen (pero no se limitan a) los siguientes:

actionpack-x.y.z
activerecord-x.y.z
rails-x.y.z

En una instalación de Windows, puede encontrarlos así:

tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dir

Verá subdirectorios que incluyen (pero no se limitan a) los siguientes:

ActionView y ActionController están agrupados en ActionPack.

ActiveRecord proporciona una variedad de técnicas de programación y atajos para manipular datos de una base de datos SQL. ActionController y ActionView proporcionan funciones para manipular y mostrar esos datos. Rails lo une todo.

Cuando utiliza el script auxiliar de Rails para crear su aplicación, crea la estructura de directorio completa para la aplicación. Rails sabe dónde encontrar las cosas que necesita dentro de esta estructura, por lo que no tiene que proporcionar ninguna entrada.

A continuación, se muestra una vista de nivel superior de un árbol de directorios creado por el script auxiliar en el momento de la creación de la aplicación. Excepto por cambios menores entre lanzamientos, cada proyecto de Rails tendrá la misma estructura, con las mismas convenciones de nomenclatura. Esta consistencia le da una gran ventaja; puede moverse rápidamente entre proyectos de Rails sin volver a aprender la organización del proyecto.

Para comprender esta estructura de directorio, usemos el demoaplicación creada en el capítulo Instalación. Se puede crear usando un simple comando auxiliar.rails demo.

Ahora, vaya al directorio raíz de la aplicación de demostración de la siguiente manera:

tp> cd demo
demo> dir

Encontrará una estructura de directorios en Windows de la siguiente manera:

Ahora expliquemos el propósito de cada directorio.

app- Organiza los componentes de su aplicación. Tiene subdirectorios que contienen la vista (vistas y ayudantes), el controlador (controladores) y la lógica empresarial de backend (modelos).
app/controllers- El subdirectorio de controladores es donde Rails busca las clases de controladores. Un controlador maneja una solicitud web del usuario.
app/helpers- El subdirectorio de ayudantes contiene las clases de ayuda que se utilizan para ayudar a las clases de modelo, vista y controlador. Esto ayuda a mantener el código del modelo, la vista y el controlador pequeño, enfocado y ordenado.
app/models- El subdirectorio de modelos contiene las clases que modelan y envuelven los datos almacenados en la base de datos de nuestra aplicación. En la mayoría de los marcos, esta parte de la aplicación puede volverse bastante desordenada, tediosa, detallada y propensa a errores. ¡Rails lo hace muy simple!
app/view - El subdirectorio de vistas contiene las plantillas de visualización para completar con datos de nuestra aplicación, convertir a HTML y volver al navegador del usuario.
app/view/layouts- Contiene los archivos de plantilla para diseños que se utilizarán con vistas. Esto modela el método común de encabezado / pie de página para envolver vistas. En sus vistas, defina un diseño usando el <tt> diseño: predeterminado </tt> y cree un archivo llamado default.html.erb. Dentro de default.html.erb, llame a <% yield%> para representar la vista usando este diseño.
components - Este directorio contiene componentes, pequeñas aplicaciones independientes que agrupan el modelo, la vista y el controlador.
config- Este directorio contiene la pequeña cantidad de código de configuración que necesitará su aplicación, incluida la configuración de su base de datos (en database.yml), la estructura de su entorno Rails (environment.rb) y el enrutamiento de las solicitudes web entrantes (routes.rb). También puede adaptar el comportamiento de los tres entornos Rails para pruebas, desarrollo e implementación con archivos que se encuentran en el directorio de entornos.
db- Por lo general, su aplicación Rails tendrá objetos modelo que acceden a tablas de bases de datos relacionales. Puede administrar la base de datos relacional con los scripts que cree y coloque en este directorio.
doc- Ruby tiene un marco, llamado RubyDoc, que puede generar automáticamente documentación para el código que crea. Puede ayudar a RubyDoc con comentarios en su código. Este directorio contiene todos los Rails generados por RubyDoc y la documentación de la aplicación.
lib - Colocará las bibliotecas aquí, a menos que pertenezcan explícitamente a otro lugar (como bibliotecas de proveedores).
log- Los registros de errores van aquí. Rails crea scripts que le ayudan a administrar varios registros de errores. Encontrará registros separados para el servidor (server.log) y cada entorno de Rails (development.log, test.log y production.log).
public - Al igual que el directorio público de un servidor web, este directorio tiene archivos web que no cambian, como archivos JavaScript (público / javascripts), gráficos (público / imágenes), hojas de estilo (público / hojas de estilo) y archivos HTML (público ).
script- Este directorio contiene scripts para iniciar y administrar las diversas herramientas que usará con Rails. Por ejemplo, existen scripts para generar código (generar) e iniciar el servidor web (servidor).
test- Las pruebas que escribes y las que crea Rails para ti, todo va aquí. Verá un subdirectorio para simulacros (simulacros), pruebas unitarias (unidad), accesorios (accesorios) y pruebas funcionales (funcionales).
tmp - Rails usa este directorio para almacenar archivos temporales para procesamiento intermedio.
vendor - Las bibliotecas proporcionadas por proveedores externos (como bibliotecas de seguridad o utilidades de bases de datos más allá de la distribución básica de Rails) van aquí.

Aparte de estos directorios, habrá dos archivos disponibles en el directorio de demostración.

README - Este archivo contiene un detalle básico sobre la aplicación Rail y una descripción de la estructura de directorios explicada anteriormente.
Rakefile- Este archivo es similar a Unix Makefile, que ayuda a construir, empaquetar y probar el código Rails. Esto será utilizado por la utilidad rake suministrada junto con la instalación de Ruby.

En este capítulo, crearemos un sistema de biblioteca en línea simple pero operativo para guardar y administrar los libros.

Esta aplicación tiene una arquitectura básica y se construirá usando dos modelos ActiveRecord para describir los tipos de datos que se almacenan:

Libros, que describe una lista real.
Asunto, que se utiliza para agrupar libros.

Flujo de trabajo para crear aplicaciones de rieles

Un flujo de trabajo recomendado para crear una aplicación Rails es el siguiente:

Utilice el comando rails para crear el esqueleto básico de la aplicación.
Cree una base de datos en el servidor PostgreSQL para almacenar sus datos.
Configure la aplicación para saber dónde se encuentra su base de datos y las credenciales de inicio de sesión para ella.
Cree registros activos de Rails (modelos), porque son los objetos comerciales con los que trabajará en sus controladores.
Genere migraciones que simplifiquen la creación y el mantenimiento de tablas y columnas de bases de datos.
Escriba el código del controlador para darle vida a su aplicación.
Cree vistas para presentar sus datos a través de la interfaz de usuario.

Entonces, comencemos con la creación de nuestra aplicación de biblioteca.

Creación de una aplicación web de rieles vacíos

Rails es tanto un marco de aplicación web en tiempo de ejecución como un conjunto de scripts auxiliares que automatizan muchas de las cosas que hace al desarrollar una aplicación web. En este paso, usaremos uno de esos guiones auxiliares para crear la estructura completa del directorio y el conjunto inicial de archivos para iniciar nuestra aplicación del Sistema de Bibliotecas.

Vaya al directorio de instalación de ruby para crear su aplicación.
Ejecute el siguiente comando para crear un esqueleto para la aplicación de biblioteca. Creará la estructura del directorio en el directorio actual.

tp> rails new library

Esto creará un subdirectorio para la aplicación de la biblioteca que contiene un árbol de directorios completo de carpetas y archivos para una aplicación Rails vacía. Verifique una estructura de directorio completa de la aplicación. Consulte la Estructura del directorio de Rails para obtener más detalles.

La mayor parte de nuestro trabajo de desarrollo consistirá en crear y editar archivos en el library/appsubdirectorios. Aquí hay un resumen rápido de cómo usarlos:

El subdirectorio de controladores es donde Rails busca las clases de controladores. Un controlador maneja una solicitud web del usuario.
El subdirectorio de vistas contiene las plantillas de visualización para completar con datos de nuestra aplicación, convertirlas a HTML y regresar al navegador del usuario.
El subdirectorio de modelos contiene las clases que modelan y envuelven los datos almacenados en la base de datos de nuestra aplicación. En la mayoría de los marcos, esta parte de la aplicación puede volverse bastante desordenada, tediosa, detallada y propensa a errores. Rails lo hace muy simple.
El subdirectorio de ayudantes contiene las clases de ayuda que se utilizan para ayudar a las clases de modelo, vista y controlador. Esto ayuda a mantener el código del modelo, la vista y el controlador pequeño, enfocado y ordenado.

Inicio del servidor web

La aplicación web Rails se puede ejecutar en prácticamente cualquier servidor web, pero la forma más conveniente de desarrollar una aplicación web Rails es utilizar el servidor web WEBrick integrado. Iniciemos este servidor web y luego naveguemos hasta nuestra aplicación de biblioteca vacía:

Este servidor se iniciará desde el directorio de la aplicación de la siguiente manera. Se ejecuta en el puerto número 3000.

tp> cd ruby\library 
tp\ruby\library\> Rails server

Genera el código automático para iniciar el servidor como se muestra a continuación:

Esto iniciará su servidor web WEBrick.

Ahora abra su navegador y busque http://127.0.0.1:3000. Si todo ha ido bien, debería ver un mensaje de saludo de WEBrick; de lo contrario, hay algún problema con su configuración. Si todo va bien, generará la salida de la siguiente manera.

¿Lo que sigue?

El siguiente capítulo explica cómo crear bases de datos para su aplicación y cuál es la configuración requerida para acceder a estas bases de datos creadas.

Además, veremos qué es Rails Migration y cómo se usa para mantener las tablas de la base de datos.

Antes de comenzar con este capítulo, asegúrese de que su servidor de base de datos esté funcionando. Ruby on Rails recomienda crear tres bases de datos: una base de datos para cada entorno de desarrollo, prueba y producción. Según la convención, sus nombres deberían ser:

library_development
library_production
library_test

Debe inicializar los tres y crear un usuario y una contraseña para ellos con privilegios completos de lectura y escritura. Estamos usando elroot ID de usuario de nuestra aplicación.

Configuración de base de datos para MySQL

En MySQL, estamos usando el rootID de usuario de nuestra aplicación. La sesión de la consola MySQL en la que haces esto se parece a:

mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Puede hacer lo mismo con dos bases de datos más library_production y library_test.

Configuración de database.yml

En este punto, debe informar a Rails sobre el nombre de usuario y la contraseña de las bases de datos. Haces esto en el archivodatabase.yml, disponible en el library\configsubdirectorio de la aplicación Rails que creó. Este archivo tiene secciones de configuración en vivo para bases de datos MySQL. En cada una de las secciones que usa, debe cambiar las líneas de nombre de usuario y contraseña para reflejar los permisos en las bases de datos que ha creado.

Cuando termines, debería verse algo así como:

development:
   adapter: mysql
   database: library_development
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: library_test
   username: root
   password: [password]
   host: localhost
   
production:
   adapter: mysql
   database: library_production
   username: root
   password: [password]
   host: localhost

Configuración de base de datos para PostgreSQL

De forma predeterminada, PostgreSQL no proporciona ningún usuario. Tenemos que crear nuevos usuarios. Utilice el siguiente comando para crear un usuario con el nombrerubyuser.

tp> sudo -u postgres createuser rubyuser -s

Si desea crear una contraseña para el nuevo usuario, utilice el siguiente comando.

tp> sudo -u postgres psql

postgres=# \password rubyuser

Utilice el siguiente comando para crear una base de datos library_development.

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

Utilice el siguiente comando para crear una base de datos library_production.

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

Utilice el siguiente comando para crear una base de datos library_test.

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

prensa Ctrl+D para terminar PosgreSQL.

Configuración de database.yml

En este punto, debe informar a Rails el nombre de usuario y la contraseña de las bases de datos. Haces esto en el archivodatabase.yml, disponible en el library\configsubdirectorio de la aplicación Rails que creó. Este archivo tiene secciones de configuración en vivo para bases de datos PostgreSQL. En cada una de las secciones, debe cambiar las líneas de nombre de usuario y contraseña para reflejar los permisos en las bases de datos que ha creado.

Cuando termines, debería verse como sigue:

default: &default
   adapter: postgresql
   encoding: unicode
  
development:
   adapter: postgresql
   encoding: unicode
   database: library_development
   username: rubyuser
   password: <Password for rubyuser>

test:
   adapter: postgresql
   encoding: unicode
   database: library_test
   username: rubyuser
   password: <Password for rubyuser>
 
production:
   adapter: postgresql
   encoding: unicode
   database: library_production
   username: rubyuser
   password: <Password for rubyuser>

¿Lo que sigue?

Los siguientes dos capítulos explican cómo modelar las tablas de su base de datos y cómo administrar aquellas que usan Rails Migrations.

Rails Active Record es la capa Object / Relational Mapping (ORM) proporcionada con Rails. Sigue de cerca el modelo ORM estándar, que es el siguiente:

las tablas se asignan a las clases,
las filas se asignan a objetos y
las columnas se asignan a los atributos del objeto.

Rails Active Records proporciona una interfaz y enlace entre las tablas en una base de datos relacional y el código del programa Ruby que manipula los registros de la base de datos. Los nombres de los métodos Ruby se generan automáticamente a partir de los nombres de campo de las tablas de la base de datos.

Cada objeto de registro activo tiene CRUD (Creatar Read, Update, y Delete) métodos para el acceso a la base de datos. Esta estrategia permite diseños simples y asignaciones directas entre tablas de base de datos y objetos de aplicación.

Traducir un modelo de dominio a SQL

Traducir un modelo de dominio a SQL es generalmente sencillo, siempre que recuerde que debe escribir SQL compatible con Rails. En términos prácticos, debes seguir ciertas reglas:

Cada entidad (como un libro) obtiene una tabla en la base de datos que lleva su nombre, pero en plural (libros).
Cada tabla de coincidencia de entidades tiene un campo llamado id , que contiene un número entero único para cada registro insertado en la tabla.
Dadas la entidad xy la entidad y, si la entidad y pertenece a la entidad x, la tabla y tiene un campo llamado x_id.
La mayor parte de los campos de cualquier tabla almacena los valores de las propiedades simples de esa entidad (cualquier cosa que sea un número o una cadena).

Creación de archivos de registro activos (modelos)

Para crear los archivos Active Record para nuestras entidades para la aplicación de la biblioteca, presentado en el capítulo anterior, emita el siguiente comando desde el nivel superior del directorio de la aplicación.

library\> ruby script/generate model Book
library\> ruby script/generate model Subject

Encima rails generate model book Los comandos generan el código automático de la siguiente manera:

Le está diciendo al generador que cree modelos llamados Libro y Asunto para almacenar instancias de libros y temas. Observe que está escribiendo Libro y Asunto en mayúsculas y usando la forma singular. Este es un paradigma de Rails que debe seguir cada vez que cree un modelo.

Cuando usa la herramienta de generación, Rails crea el archivo de modelo real que contiene todos los métodos exclusivos del modelo y las reglas de negocio que usted define, un archivo de prueba unitaria para realizar el desarrollo basado en pruebas, un archivo de datos de muestra (llamado accesorios) para usar con las pruebas unitarias y una migración de Rails que facilita la creación de tablas y columnas de bases de datos.

Además de crear muchos otros archivos y directorios, esto creará archivos llamados book.rb y subject.rb que contiene una definición de esqueleto en el app/models directorio.

Contenido disponible en book.rb -

class Book < ActiveRecord::Base
end

Contenido disponible en subject.rb -

class Subject < ActiveRecord::Base
end

Crear asociaciones entre modelos

Cuando tenga más de un modelo en su aplicación de rieles, deberá crear una conexión entre esos modelos. Puede hacerlo a través de asociaciones. Active Record admite tres tipos de asociaciones:

one-to-one- Existe una relación uno a uno cuando un elemento tiene exactamente uno de otro elemento. Por ejemplo, una persona tiene exactamente un cumpleaños o un perro tiene exactamente un dueño.
one-to-many- Existe una relación de uno a varios cuando un solo objeto puede ser miembro de muchos otros objetos. Por ejemplo, un tema puede tener muchos libros.
many-to-many - Existe una relación de muchos a muchos cuando el primer objeto está relacionado con uno o más de un segundo objeto, y el segundo objeto está relacionado con uno o varios del primer objeto.

Indique estas asociaciones agregando declaraciones a sus modelos: has_one, has_many, contains_to y has_and_belongs_to_many.

Ahora, debe decirle a Rails qué relaciones desea establecer dentro del sistema de datos de la biblioteca. Para hacerlo, modifique book.rb y subject.rb para que se vean así:

class Book < ActiveRecord::Base
   belongs_to :subject
end

Hemos utilizado un tema singular en el ejemplo anterior, porque un Libro puede pertenecer a un solo Asunto.

class Subject < ActiveRecord::Base
   has_many :books
end

Hemos utilizado libros en plural aquí, porque un tema puede tener varios libros.

Implementación de validaciones en modelos

La implementación de validaciones se realiza en un modelo Rails. Los datos que ingresa a la base de datos se definen en el modelo de Rails real, por lo que solo tiene sentido definir qué datos válidos implican en la misma ubicación.

Las validaciones son:

El valor del campo de título no debe ser NULL.
El valor del campo de precio debe ser numérico.

Abierto book.rb en el app\model subdirectorio y coloque las siguientes validaciones:

class Book < ActiveRecord::Base
   belongs_to :subject
   validates_presence_of :title
   validates_numericality_of :price, :message=>"Error Message"
end

validates_presence_of - protege los campos "NOT NULL" contra la falta de entrada del usuario.
validates_numericality_of - Evita que el usuario ingrese datos no numéricos.

Además de las validaciones mencionadas anteriormente, existen otras validaciones comunes. Consulte la Guía rápida de rieles .

¿Lo que sigue?

En el próximo capítulo, aprenderemos Rails Migration, que le permite usar Ruby para definir cambios en el esquema de su base de datos, haciendo posible usar un sistema de control de versiones para mantener las cosas sincronizadas con el código real.

Rails Migration le permite usar Ruby para definir cambios en el esquema de su base de datos, lo que hace posible usar un sistema de control de versiones para mantener las cosas sincronizadas con el código real.

Esto tiene muchos usos, que incluyen:

Teams of developers - Si una persona realiza un cambio de esquema, los otros desarrolladores solo necesitan actualizar y ejecutar "rake migrate".
Production servers - Ejecute "rake migrate" cuando lance una nueva versión para actualizar también la base de datos.
Multiple machines - Si desarrolla tanto en una computadora de escritorio como en una computadora portátil, o en más de una ubicación, las migraciones pueden ayudarlo a mantenerlos todos sincronizados.

¿Qué puede hacer la migración de rieles?

create_table (nombre, opciones)
drop_table(name)
renombrar_tabla (antiguo_nombre, nuevo_nombre)
add_column (nombre_tabla, nombre_columna, tipo, opciones)
renombrar_columna (nombre_tabla, nombre_columna, nuevo_nombre_columna)
change_column (nombre_tabla, nombre_columna, tipo, opciones)
remove_column (nombre_tabla, nombre_columna)
add_index (nombre_tabla, nombre_columna, tipo_índice)
remove_index (nombre_tabla, nombre_columna)

Migrations support all the basic data types - La siguiente es la lista de tipos de datos que admite la migración -

string - para tipos de datos pequeños como un título.
text - para piezas más extensas de datos textuales, como la descripción.
integer - para números enteros.
float - para decimales.
datetime and timestamp - almacena la fecha y la hora en una columna.
date and time - almacenar solo la fecha o solo la hora.
binary - para almacenar datos como imágenes, audio o películas.
Boolean - para almacenar valores verdaderos o falsos.

Valid column options are - La siguiente es la lista de opciones de columna válidas.

limit (: límite => "50")
default (: predeterminado => "bla")
null(: nulo => falso implica NO NULO )

NOTE - Las actividades realizadas por Rails Migration se pueden realizar utilizando cualquier interfaz gráfica de usuario o directamente en el indicador SQL, pero Rails Migration hace que todas esas actividades sean muy fáciles.

Consulte la API de Rails para obtener detalles sobre estos.

Crea las migraciones

Aquí está la sintaxis genérica para crear una migración:

application_dir> rails generate migration table_name

Esto creará el archivo db / migrate / 001_table_name.rb. Un archivo de migración contiene la sintaxis básica de Ruby que describe la estructura de datos de una tabla de base de datos.

NOTE - Antes de ejecutar el generador de migraciones, se recomienda limpiar las migraciones existentes generadas por los generadores de modelos.

Crearemos dos migraciones correspondientes a nuestras tres tablas - books and subjects.

La migración de libros debe ser la siguiente:

tp> cd library
library> rails generate migration books

El comando anterior genera el siguiente código.

La migración de sujetos debe ser la siguiente:

tp> cd library
library> rails generate migration subjects

El comando anterior genera el siguiente código.

Tenga en cuenta que está utilizando minúsculas para el libro y el tema y la forma plural al crear migraciones. Este es un paradigma de Rails que debe seguir cada vez que cree una migración.

Editar el código

Vaya al subdirectorio db / migrate de su aplicación y edite cada archivo uno por uno usando cualquier editor de texto simple.

Modifique 001_books.rb de la siguiente manera:

La columna de ID se creará automáticamente, así que no lo hagas aquí también.

class Books < ActiveRecord::Migration
   
   def self.up
      create_table :books do |t|
         t.column :title, :string, :limit => 32, :null => false
         t.column :price, :float
         t.column :subject_id, :integer
         t.column :description, :text
         t.column :created_at, :timestamp
      end
   end

   def self.down
      drop_table :books
   end
end

El método self.up se utiliza al migrar a una nueva versión, self.downse utiliza para revertir cualquier cambio si es necesario. En este momento, se utilizará el script anterior para crearbooks mesa.

Modifique 002_subjects.rb de la siguiente manera:

class Subjects < ActiveRecord::Migration
   def self.up
      
      create_table :subjects do |t|
         t.column :name, :string
      end
	
      Subject.create :name => "Physics"
      Subject.create :name => "Mathematics"
      Subject.create :name => "Chemistry"
      Subject.create :name => "Psychology"
      Subject.create :name => "Geography"
   end

   def self.down
      drop_table :subjects
   end
end

El script anterior se utilizará para crear subjects tabla y creará cinco registros en la tabla de materias.

Ejecute la migración

Ahora que ha creado todos los archivos de migración necesarios. Es hora de ejecutarlos contra la base de datos. Para hacer esto, vaya a un símbolo del sistema y vaya al directorio de la biblioteca en el que se encuentra la aplicación, y luego escribarake migrate como sigue -

library> rake db:migrate

Esto creará una tabla "schema_info" si no existe, que rastrea la versión actual de la base de datos; cada nueva migración será una nueva versión, y cualquier nueva migración se ejecutará hasta que su base de datos tenga la versión actual.

Rakees un programa de construcción Ruby similar al programa make de Unix que Rails aprovecha para simplificar la ejecución de tareas complejas como actualizar la estructura de una base de datos, etc.

Ejecución de migraciones para bases de datos de prueba y producción

Si desea especificar qué entorno Rails usar para la migración, use la variable de shell RAILS_ENV.

Por ejemplo

library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrate

NOTE- En Windows, use "set RAILS_ENV = production" en lugar del comando de exportación .

¿Lo que sigue?

Ahora tenemos nuestra base de datos y las tablas necesarias disponibles. En los dos capítulos siguientes, exploraremos dos componentes importantes llamados Controller (ActionController) y View (ActionView).

Creación de controladores (controlador de acción).
Creación de vistas (vista de acciones).

El controlador Rails es el centro lógico de su aplicación. Coordina la interacción entre el usuario, las vistas y el modelo. El controlador también alberga una serie de importantes servicios auxiliares.

Es responsable de enrutar las solicitudes externas a las acciones internas. Maneja extremadamente bien las URL amigables para las personas.
Gestiona el almacenamiento en caché, lo que puede dar a las aplicaciones mejoras de rendimiento de órdenes de magnitud.
Gestiona módulos auxiliares, que amplían las capacidades de las plantillas de vista sin aumentar su código.
Gestiona sesiones, dando a los usuarios la impresión de una interacción continua con nuestras aplicaciones.

El proceso para crear un controlador es muy fácil y es similar al proceso que ya usamos para crear un modelo. Crearemos solo un controlador aquí -

library\> rails generate controller Book

Observe que está escribiendo Libro en mayúsculas y usando la forma singular. Este es un paradigma de Rails que debe seguir cada vez que cree un controlador.

Este comando realiza varias tareas, de las cuales las siguientes son relevantes aquí:

Crea un archivo llamado app/controllers/book_controller.rb

Si mira book_controller.rb, lo encontrará de la siguiente manera:

class BookController < ApplicationController
end

Las clases de controlador heredan de ApplicationController, que es el otro archivo en la carpeta de controladores:application.rb.

El ApplicationController contiene código que se puede ejecutar en todos sus controladores y hereda de Rails ActionController :: clase Base .

Todavía no necesita preocuparse con ApplicationController , así que definamos algunos códigos auxiliares de método enbook_controller.rb. Según sus necesidades, puede definir cualquier número de funciones en este archivo.

Modifique el archivo para que tenga el siguiente aspecto y guarde los cambios. Tenga en cuenta que depende de usted qué nombre desea dar a estos métodos, pero es mejor dar nombres relevantes.

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

Ahora implementemos todos los métodos uno por uno.

Implementando el método de lista

El método de lista le da una lista de todos los libros de la base de datos. Esta funcionalidad se logrará mediante las siguientes líneas de código. Edite las siguientes líneas en el archivo book_controller.rb.

def list
   @books = Book.all
end

La línea @books = Book.all del método list le dice a Rails que busque en la tabla de libros y almacene cada fila que encuentre en el objeto de instancia @books.

Implementación del método show

El método show muestra solo más detalles en un solo libro. Esta funcionalidad se logrará mediante las siguientes líneas de código.

def show
   @book = Book.find(params[:id])
end

La línea @book = Book.find (params [: id]) del método show le dice a Rails que busque solo el libro que tiene el id definido en params [: id].

El objeto params es un contenedor que le permite pasar valores entre llamadas a métodos. Por ejemplo, cuando estás en la página llamada por el método de lista, puedes hacer clic en un enlace para un libro específico, y pasa la identificación de ese libro a través del objeto params para que el programa pueda encontrar el libro específico.

Implementando el nuevo método

El nuevo método le permite a Rails saber que creará un nuevo objeto. Así que simplemente agregue el siguiente código en este método.

def new
   @book = Book.new
   @subjects = Subject.all
end

Se llamará al método anterior cuando muestre una página al usuario para que tome la entrada del usuario. Aquí, la segunda línea toma todos los sujetos de la base de datos y los coloca en una matriz llamada @subjects.

Implementando el método de creación

Una vez que tome la entrada del usuario usando el formulario HTML, es hora de crear un registro en la base de datos. Para lograr esto, edite el método de creación en book_controller.rb para que coincida con lo siguiente:

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

La primera línea crea una nueva variable de instancia llamada @book que contiene un objeto Book construido a partir de los datos enviados por el usuario. losbook_params El método se utiliza para recopilar todos los campos del objeto. :books. Los datos se pasaron del nuevo método para crear utilizando el objeto params.

La siguiente línea es una declaración condicional que redirige al usuario a la listmétodo si el objeto se guarda correctamente en la base de datos. Si no se guarda, el usuario vuelve al método nuevo. El método redirect_to es similar a realizar una metaactualización en una página web: lo reenvía automáticamente a su destino sin ninguna interacción del usuario.

Entonces @subjects = Subject.all es necesario en caso de que no guarde los datos correctamente y se convierta en un caso similar al de la nueva opción.

Implementación del método de edición

El método de edición parece casi idéntico al método show. Ambos métodos se utilizan para recuperar un solo objeto en función de su identificación y mostrarlo en una página. La única diferencia es que el método show no se puede editar.

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

Este método será llamado para mostrar datos en la pantalla para ser modificados por el usuario. La segunda línea toma todos los sujetos de la base de datos y los coloca en una matriz llamada @subjects.

Implementar el método de actualización

Este método se llamará después del método de edición, cuando el usuario modifica un dato y desea actualizar los cambios en la base de datos. El método de actualización es similar al método de creación y se utilizará para actualizar los libros existentes en la base de datos.

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

El método update_attributes es similar al método de guardar utilizado por create, pero en lugar de crear una nueva fila en la base de datos, sobrescribe los atributos de la fila existente.

Entonces @subjects = Subject.all se requiere toda la línea en caso de que no guarde los datos correctamente, entonces se vuelve similar a la opción de edición.

Implementación del método de eliminación

Si desea eliminar un registro de la base de datos, utilizará este método. Implemente este método de la siguiente manera.

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

La primera línea busca el clasificado según el parámetro pasado a través del objeto params y luego lo elimina usando el método de destrucción. La segunda línea redirige al usuario al método de lista mediante una llamada redirect_to.

Métodos adicionales para mostrar sujetos

Suponga que desea ofrecer a sus usuarios la posibilidad de explorar todos los libros basados en un tema determinado. Entonces, puede crear un método dentro de book_controller.rb para mostrar todos los temas. Suponga que el nombre del método esshow_subjects -

def show_subjects
   @subject = Subject.find(params[:id])
end

Finalmente tu book_controller.rb El archivo se verá de la siguiente manera:

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

Ahora guarde su archivo de controlador.

¿Lo que sigue?

Ha creado casi todos los métodos, que funcionarán en el backend. A continuación, definiremos rutas (URL) para acciones.

El módulo de enrutamiento proporciona reescritura de URL en Ruby nativo. Es una forma de redirigir las solicitudes entrantes a controladores y acciones. Reemplaza las reglas mod_rewrite. Lo mejor de todo es que Rails 'Routing funciona con cualquier servidor web. Las rutas se definen en app / config / routes.rb.

Piense en crear rutas como dibujar un mapa para sus solicitudes. El mapa les dice a dónde ir según un patrón predefinido:

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

Ejemplo

Consideremos que nuestra aplicación de administración de bibliotecas contiene un controlador llamado BookController. Tenemos que definir las rutas para aquellas acciones que se definen como métodos en la clase BookController.

Abra el archivo routes.rb en el directorio library / config / y edítelo con el siguiente contenido.

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

El archivo route.rb define las acciones disponibles en las aplicaciones y el tipo de acción, como obtener, publicar y parchear.

Use el siguiente comando para enumerar todas sus rutas definidas, que son útiles para rastrear problemas de enrutamiento en su aplicación o para brindarle una buena descripción general de las URL en una aplicación con la que está tratando de familiarizarse.

library> rake routes

¿Lo que sigue?

A continuación, crearemos el código para generar pantallas para mostrar datos y tomar entradas del usuario.

A Rails View es un programa ERb que comparte datos con controladores a través de variables de acceso mutuo.

Si busca en el directorio app / views de la aplicación de la biblioteca, verá un subdirectorio para cada uno de los controladores que hemos creado: book. Cada uno de estos subdirectorios se creó automáticamente cuando se creó el controlador con el mismo nombre con el script de generación.

Rails le permite saber que necesita crear el archivo de vista para cada método nuevo. Cada método que defina en el controlador debe tener un correspondienteerb archivo, con el mismo nombre que el método, para mostrar los datos que está recopilando el método.

Así que creemos archivos de vista para todos los métodos que hemos definido en book_controller.rb. Mientras ejecuta estas vistas, compruebe simultáneamente si estas acciones son aplicables en la base de datos o no.

Crear archivo de vista para el método de lista

Crea un archivo llamado list.html.erbusando su editor de texto favorito y guárdelo en la aplicación / vistas / libro. Después de crear y guardar el archivo, actualice su navegador web. Debería ver una página en blanco; si no lo hace, verifique la ortografía de su archivo y asegúrese de que sea exactamente el mismo que el método de su controlador.

Ahora, muestre el contenido real. Pongamos el siguiente código en list.html.erb.

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

El código a ejecutar es verificar si el arreglo @books tiene algún objeto. los.blank?El método devuelve verdadero si la matriz está vacía y falso si contiene algún objeto. Este objeto @books se creó en el controlador dentro del método de lista.

El código entre las etiquetas <% =%> es un link_tollamada al método. El primer parámetro de link_to es el texto que se mostrará entre las etiquetas <a>. El segundo parámetro es la acción que se llama cuando se hace clic en el enlace. En este caso, es el método show. El parámetro final es la identificación del libro que se pasa a través del objeto params.

Ahora, intente actualizar su navegador y debería aparecer la siguiente pantalla porque no tenemos ningún libro en nuestra biblioteca.

Crear archivo de vista para un nuevo método

Hasta ahora, no tenemos ningún libro en nuestra biblioteca. Tenemos que crear pocos libros en el sistema. Entonces, diseñemos una vista correspondiente a lanew método definido en book_controller.rb.

Cree un archivo llamado new.html.erb con su editor de texto favorito y guárdelo en app / views / book. Agregue el siguiente código al archivo new.html.erb.

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

aquí form_tagEl método interpreta el código Ruby en una etiqueta <form> HTML normal utilizando toda la información que se le proporciona. Esta etiqueta, por ejemplo, genera el siguiente HTML:

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

El siguiente método es text_fieldque genera un campo de texto <input>. Los parámetros para text_field son el objeto y el nombre del campo. En este caso, el objeto es libro y el nombre es título .

Método de rieles llamado collection_select, crea un menú de selección HTML construido a partir de una matriz, como @books. Hay cinco parámetros, que son los siguientes:

:book - El objeto que está manipulando. En este caso, es un objeto de libro.
:subject_id - El campo que se completa cuando se guarda el libro.
@books - La matriz con la que está trabajando.
:id- El valor que se almacena en la base de datos. En términos de HTML, este es el parámetro de valor de la etiqueta <option>.
:name- La salida que el usuario ve en el menú desplegable. Este es el valor entre las etiquetas <option>.

El siguiente usado es submit_tag, que genera un botón <input> que envía el formulario. Finalmente, está elend método que simplemente se traduce en </form>.

Vaya a su navegador y visite http://localhost:3000/book/new. Esto le dará la siguiente pantalla.

Ingrese algunos datos en este formulario y luego haga clic en el botón Crear. Aquí he agregado los siguientes detalles en los campos:

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

Cuando haces clic en el Create botón, llamará al create método, que no necesita ninguna vista porque este método utiliza list o newmétodos para ver los resultados. Por lo tanto, cuando hace clic en el botón Crear, los datos deben enviarse correctamente y redirigirlo a la página de la lista, en la que ahora tiene un solo elemento enumerado de la siguiente manera:

Si hace clic en el enlace, debería ver que falta otra plantilla, ya que aún no ha creado el archivo de plantilla para el método show.

Crear archivo de vista para el método show

Este método mostrará el detalle completo sobre cualquier libro disponible en la biblioteca. Cree un archivo show.html.erb en app / views / book y rellénelo con el siguiente código:

<h1><%= @book.title %></h1>

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

<%= link_to 'Back', {:action => 'list'} %>

Esta es la primera vez que aprovecha al máximo las asociaciones, que le permiten extraer fácilmente datos de objetos relacionados.

El formato utilizado es @variable.relatedObject.column. En este caso, puede extraer el valor del nombre del sujeto a través de la variable @book usando elbelongs_toasociaciones. Si hace clic en cualquier registro de la lista, se le mostrará la siguiente pantalla.

Crear archivo de vista para el método de edición

Cree un nuevo archivo llamado edit.html.erb y guárdelo en app / views / book. Rellénelo con el siguiente código:

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

<%= link_to 'Back', {:action => 'list' } %>

Este código es muy similar al new método excepto la acción que se actualizará en lugar de crear y definir una identificación.

En este escenario, usamos form_foretiqueta para la acción del formulario. Funcionará mejor queform_tag. Por qué, porque creará interacción con el modelo fácilmente. Por lo tanto, es mejor usar la etiqueta form_for siempre que necesite interacción entre el modelo y los campos del formulario.

En este punto, necesitamos algunas modificaciones en el list method'sver archivo. Vaya al elemento <li> </li> y modifíquelo para que tenga el siguiente aspecto:

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

Ahora, intente buscar libros con el http://localhost:3000/book/list. Le dará la lista de todos los libros junto con Editopción. Cuando haga clic en la opción Editar, tendrá la siguiente pantalla de la siguiente manera:

Ahora, edite esta información y luego haga clic en el botón Guardar cambios . Esto resultará en una llamada aupdatemétodo disponible en el archivo del controlador y actualizará todos los atributos cambiados. Note que elupdate El método no necesita ningún archivo de vista porque usa show o edit métodos para mostrar sus resultados.

Crear archivo de vista para el método de eliminación

Eliminar información de una base de datos usando Ruby on Rails es casi demasiado fácil. No es necesario que escriba ningún código de vista para el método de eliminación porque este método utilizalistmétodo para mostrar el resultado. Entonces, simplemente modifiquemos list.html.erb nuevamente y agreguemos un enlace de eliminación.

Vaya al elemento <li> </li> y modifíquelo para que tenga el siguiente aspecto:

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

los :confirmEl parámetro presenta un cuadro de confirmación de JavaScript que le pregunta si realmente desea realizar la acción. Si el usuario hace clic en Aceptar, la acción continúa y el elemento se elimina.

Ahora, intente buscar libros usando http://localhost:3000/book/list. Le dará una lista de todos los libros junto con Edit y Delete opciones de la siguiente manera:

Ahora, con la opción Eliminar, puede eliminar cualquier registro de la lista.

Crear archivo de vista para el método show_subjects

Cree un nuevo archivo, show_subjects.html.erb, en el directorio app / views / book y agréguele el siguiente código:

<h1><%= @subject.name -%></h1>

<ul>
   <% @subject.books.each do |c| %>
   <li><%= link_to c.title, :action => "show", :id => c.id -%></li>
   <% end %>
</ul>

Aprovecha las asociaciones al iterar a través de las listas de libros de un solo tema.

Ahora modifique la línea Asunto: de show.html.erb para que la lista de temas muestre un enlace.

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

Esto generará una lista de temas en la página de índice, para que los usuarios puedan acceder a ellos directamente.

Modificar list.html.erb para agregar lo siguiente al principio del archivo:

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

Ahora intente buscar libros usando http: // localhost: 3000 / book / list. Mostrará todos los temas con enlaces para que pueda navegar por todos los libros relacionados con ese tema.

¿Lo que sigue?

Espero que ahora se sienta cómodo con todas las operaciones de Rails.

El siguiente capítulo explica cómo usar Layoutspara poner sus datos de una mejor manera. Le mostraremos cómo utilizar CSS en sus aplicaciones Rails.

Un diseño define el entorno de una página HTML. Es el lugar para definir una apariencia común de su resultado final. Los archivos de diseño residen en aplicaciones / vistas / diseños.

El proceso implica definir una plantilla de diseño y luego dejar que el controlador sepa que existe y que la use. Primero, creemos la plantilla.

Agregue un nuevo archivo llamado standard.html.erb a app / views / layouts. Deje que los controladores sepan qué plantilla usar por el nombre del archivo, por lo que se recomienda seguir el mismo esquema de nomenclatura.

Agregue el siguiente código al nuevo archivo standard.html.erb y guarde sus cambios:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

Todo lo que acaba de agregar eran elementos HTML estándar, excepto dos líneas. losstylesheet_link_tagEl método auxiliar genera una hoja de estilo <link>. En este caso, estamos vinculando la hoja de estilo style.css. losyield El comando le permite a Rails saber que debe poner el archivo html.erb para el método llamado aquí.

Ahora abierto book_controller.rb y agregue la siguiente línea justo debajo de la primera línea:

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

Indica al controlador que queremos usar un diseño disponible en el archivo standard.html.erb. Ahora intente buscar libros que producirán la siguiente pantalla.

Agregar hoja de estilo

Hasta ahora, no hemos creado ninguna hoja de estilo, por lo que Rails está usando la hoja de estilo predeterminada. Ahora creemos un nuevo archivo llamado style.css y guárdelo en / public / stylesheets. Agregue el siguiente código a este archivo.

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

Ahora actualice su navegador y vea la diferencia:

¿Lo que sigue?

El siguiente capítulo explica cómo desarrollar aplicaciones usando Rails Scaffolding para dar acceso al usuario para agregar, eliminar y modificar los registros en cualquier base de datos.

Mientras desarrolla aplicaciones Rails, especialmente aquellas que principalmente le brindan una interfaz simple para los datos en una base de datos, a menudo puede ser útil utilizar el método de andamio.

Los andamios proporcionan más emociones que una demostración barata. Aquí hay algunos beneficios:

Puede mostrar rápidamente el código a sus usuarios para recibir comentarios.
Estás motivado por un éxito más rápido.
Puede aprender cómo funciona Rails mirando el código generado.
Puede utilizar andamios como base para impulsar su desarrollo.

Ejemplo de andamio

Para entender el andamiaje, creemos una base de datos llamadacookbook y una mesa llamada recipes.

Creación de una aplicación web de rieles vacíos

Abra una ventana de comando y navegue hasta donde desea crear este cookbookAplicación web. Entonces, ejecute el siguiente comando para crear una estructura de directorio completa.

tp> rails new cookbook

Configurar la base de datos

Esta es la forma de crear una base de datos:

mysql> create database cookbook;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on cookbook.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Para indicarle a Rails cómo encontrar la base de datos, edite el archivo de configuración cookbook \ config \ database.yml y cambie el nombre de la base de datos a cookbook. Deje la contraseña en blanco. Cuando termines, debería verse como sigue:

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

Rails te permite ejecutar en modo de desarrollo, modo de prueba o modo de producción, utilizando diferentes bases de datos. Esta aplicación usa la misma base de datos para cada uno.

El código de andamio generado

Con la acción de andamio, Rails genera todo el código que necesita de forma dinámica. Al ejecutar scaffold como un script, podemos obtener todo el código escrito en el disco, donde podemos investigarlo y luego comenzar a adaptarlo a nuestros requisitos.

Así que ahora, comencemos una vez más a generar código de Scaffold manualmente usando el script auxiliar de scaffold -

cookbook> rails generate scaffold recipe

Genera archivos automáticos como se muestra a continuación:

El controlador

Veamos el código detrás del controlador. Este código es generado por elscaffoldgenerador. Si abre app / controllers / recipes_controller.rb, encontrará algo como sigue:

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

Cuando el usuario de una aplicación Rails selecciona una acción, por ejemplo, "Mostrar" - el controlador ejecutará cualquier código en la sección apropiada - "def show" - y luego, por defecto, mostrará una plantilla del mismo nombre - "show.html". erb ". Este comportamiento predeterminado se puede sobrescribir.

El controlador usa métodos ActiveRecord como find, find_all, new, save, update_attributes y destroy para mover datos hacia y desde las tablas de la base de datos. Tenga en cuenta que no tiene que escribir ninguna declaración SQL, rails se encargará de ello automáticamente.

Esta única línea de código dará vida a la tabla de la base de datos. Proporcionará una interfaz simple para sus datos y formas de:

Creando nuevas entradas
Editar entradas actuales
Ver entradas actuales
Destruyendo las entradas actuales

Al crear o editar una entrada, scaffold hará todo el trabajo duro, como la generación y el manejo de formularios, e incluso proporcionará una generación de formularios inteligente, que admite los siguientes tipos de entradas:

Cadenas de texto simples
Áreas de texto (o grandes bloques de texto)
Selectores de fecha
Selectores de fecha y hora

Puede utilizar Rails Migrations para crear y mantener tablas.

rake db:migrate RAILS_ENV=development

Ahora, vaya al directorio del libro de recetas y ejecute el servidor web con el siguiente comando:

cookbook> rails server

Ahora, abra un navegador y navegue hasta http://127.0.0.1:3000/recipe/new. Esto le proporcionará una pantalla para crear nuevas entradas en la tabla de recetas. A continuación se muestra una captura de pantalla:

Una vez que presione el Create para crear una nueva receta, su registro se agrega a la tabla de recetas y muestra el siguiente resultado:

Puede ver la opción de editar, mostrar y destruir los registros. Entonces, juega con estas opciones.

También puede enumerar todas las recetas disponibles en la tabla de recetas utilizando la URL http://127.0.0.1:3000/recipe/list.

Mejorando el modelo

Rails te ofrece una gran cantidad de manejo de errores de forma gratuita. Para comprender esto, agregue algunas reglas de validación al modelo de receta vacía:

Modifique la aplicación / modelos / receta.rb de la siguiente manera y luego pruebe su aplicación:

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

Estas entradas darán una verificación automática.

validates_length_of - el campo no está en blanco y no es demasiado largo.
validates_uniqueness_of- los valores duplicados quedan atrapados. En lugar del mensaje de error predeterminado de Rails, hemos proporcionado un mensaje personalizado aquí.

Forma alternativa de crear andamios

Cree una aplicación como se muestra arriba y The Generated Scaffold Code Como se muestra abajo

rails g scaffold Recipe tittle:string instructions:text

El código anterior genera los archivos automáticos con la base de datos utilizando sqlite3 con título y columna de instrucciones como se muestra debajo de una imagen.

necesitamos migrar la base de datos usando la siguiente sintaxis.

$ rake db:migrate RAILS_ENV=development

Finalmente, ejecute la aplicación utilizando la siguiente línea de comando:

rails server

Generará el resultado como se muestra arriba en las imágenes de salida.

Las vistas

Todas las vistas y todos los métodos del controlador correspondientes son creados por scaffold comando y están disponibles en el directorio app / views / recipes.

¿En qué se diferencian los andamios?

Si ha repasado los capítulos anteriores, debe haber visto que habíamos creado métodos para enumerar, mostrar, eliminar y crear datos, etc., pero el andamio hace ese trabajo automáticamente.

Ajax significa Asincrónico JavaScript y XML. Ajax no es una tecnología única; es un conjunto de varias tecnologías. Ajax incorpora lo siguiente:

XHTML para el marcado de páginas web
CSS para el estilo
Visualización e interacción dinámicas utilizando el DOM
Manipulación e intercambio de datos mediante XML
Recuperación de datos mediante XMLHttpRequest
JavaScript como el pegamento que une todo esto

Ajax le permite recuperar datos para una página web sin tener que actualizar el contenido de toda la página. En la arquitectura web básica, el usuario hace clic en un enlace o envía un formulario. El formulario se envía al servidor, que luego envía una respuesta. Luego, la respuesta se muestra para el usuario en una nueva página.

Cuando interactúa con una página web impulsada por Ajax, carga un motor Ajax en segundo plano. El motor está escrito en JavaScript y su responsabilidad es tanto comunicarse con el servidor web como mostrar los resultados al usuario. Cuando envía datos utilizando un formulario con tecnología Ajax, el servidor devuelve un fragmento HTML que contiene la respuesta del servidor y muestra solo los datos nuevos o modificados en lugar de actualizar toda la página.

Para obtener un detalle completo sobre AJAX, puede consultar nuestro Tutorial de AJAX

Cómo Rails implementa Ajax

Rails tiene un modelo simple y consistente de cómo implementa las operaciones Ajax. Una vez que el navegador ha renderizado y mostrado la página web inicial, diferentes acciones del usuario hacen que muestre una nueva página web (como cualquier aplicación web tradicional) o desencadenan una operación Ajax -

Some trigger fires - Este disparador podría ser el usuario que hace clic en un botón o enlace, el usuario que realiza cambios en los datos en un formulario o en un campo, o simplemente un disparador periódico (basado en un temporizador).
The web client calls the server- Un método de JavaScript, XMLHttpRequest , envía datos asociados con el desencadenador a un controlador de acciones en el servidor. Los datos pueden ser el ID de una casilla de verificación, el texto de un campo de entrada o un formulario completo.
The server does processing - El controlador de acciones del lado del servidor (acción del controlador Rails): hace algo con los datos y devuelve un fragmento HTML al cliente web.
The client receives the response - El JavaScript del lado del cliente, que Rails crea automáticamente, recibe el fragmento HTML y lo usa para actualizar una parte específica del HTML de la página actual, a menudo el contenido de una etiqueta <div>.

Estos pasos son la forma más sencilla de usar Ajax en una aplicación Rails, pero con un poco de trabajo adicional, puede hacer que el servidor devuelva cualquier tipo de datos en respuesta a una solicitud de Ajax, y puede crear JavaScript personalizado en el navegador para realizar más interacciones involucradas.

Ejemplo de AJAX

Este ejemplo funciona basado en scaffold, el concepto Destroy funciona basado en ajax.

En este ejemplo, proporcionaremos, enumeraremos, mostraremos y crearemos operaciones en la mesa de ponis. Si no entendió la tecnología de andamios, le sugerimos que lea primero los capítulos anteriores y luego continúe con AJAX on Rails.

Crear una aplicación

Comencemos con la creación de una aplicación Se hará de la siguiente manera -

rails new ponies

El comando anterior crea una aplicación, ahora necesitamos llamar al directorio de la aplicación usando el comando cd. Entrará en el directorio de una aplicación, luego debemos llamar a un comando de scaffold. Se hará de la siguiente manera:

rails generate scaffold Pony name:string profession:string

El comando anterior genera el andamio con la columna de nombre y profesión. Necesitamos migrar la base de datos de la siguiente manera

rake db:migrate

Ahora ejecute la aplicación Rails de la siguiente manera

rails s

Ahora abra el navegador web y llame a una URL como http: // localhost: 3000 / ponies / new, el resultado será el siguiente

Creando un Ajax

Ahora abra app / views / ponies / index.html.erb con los editores de texto adecuados. Actualice su línea de destrucción con: remote => true,: class => 'delete_pony'. Finalmente, se ve así.

Cree un archivo, destroy.js.erb, colóquelo junto a sus otros archivos .erb (en app / views / ponies). Debería verse así:

Ahora ingrese el código como se muestra a continuación en destroy.js.erb

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

Ahora abra el archivo de su controlador que se encuentra en app / controllers / ponies_controller.rb y agregue el siguiente código en el método de destrucción como se muestra a continuación:

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

Finalmente, la página del controlador es como se muestra en la imagen.

Ahora ejecute una aplicación, Salida llamada desde http: // localhost: 3000 / ponies / new, se verá como la siguiente imagen

Presione el botón crear pony, generará el resultado de la siguiente manera

Ahora haga clic en el botón Atrás, se mostrará toda la información creada por pony como se muestra en la imagen

Hasta ahora, estamos trabajando en scaffold, ahora haga clic en el botón Destruir, llamará a una ventana emergente como se muestra a continuación, la ventana emergente funciona en base a Ajax.

Si hace clic en el botón Aceptar, eliminará el registro de pony. Aquí he hecho clic en el botón Aceptar. El resultado final será el siguiente:

Es posible que tenga un requisito en el que desee que los visitantes de su sitio carguen un archivo en su servidor. Rails hace que sea muy fácil manejar este requisito. Ahora procederemos con un proyecto de Rails simple y pequeño.

Como de costumbre, comencemos con una nueva aplicación Rails llamada testfile. Creemos la estructura básica de la aplicación usando un comando simple de rieles.

tp> rails new testfile

Antes de comenzar el desarrollo de la aplicación, debemos instalar los archivos gem como se muestra a continuación:

gem install carrierwave
gem install bootstrap-sass

Abra su archivo de gemas y agregue las siguientes dos gemas en la parte inferior como se muestra en la siguiente imagen:

Después de agregar gemas en el archivo de gemas, debemos ejecutar el siguiente comando en la consola:

bundle install

Creando el modelo

Necesitamos crear un modelo con dos cadenas como nombre y archivo adjunto como se muestra a continuación:

rails g model Resume name:string attachment:string

Necesitamos crear la migración de la base de datos como se muestra a continuación:

rake db:migrate

Necesitamos generar el controlador como se muestra a continuación:

rails g controller Resumes index new create destroy

¡Excelente! Ahora tenemos la estructura básica configurada. Ahora necesitamos crear un cargador. Un Uploader vino de carrierwave gem y le dice a carrierwave cómo manejar los archivos. En resumen, contenía todas las funcionalidades de procesamiento de archivos. Ejecute el comando para crear un cargador como se muestra a continuación

rails g uploader attachment

Ahora abra el modelo de currículum y llame al cargador como se muestra a continuación. El modelo de currículum se ha colocado en app / models / resume.rb -

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

Antes de trabajar en el controlador, necesitamos modificar nuestro config / routes.db como se muestra a continuación:

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

Vamos a editar el controlador como se muestra a continuación.

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

Agreguemos la implementación de bootstrap en el archivo css. El archivo css podría estar en app / assets / stylesheets / resumes.css.scss

@import "bootstrap";

Ahora abra app / views / layouts / application.html.erb y agregue códigos como se muestra a continuación:

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

Ahora necesitamos configurar vistas de índice como se muestra a continuación:

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

Ahora, editemos new.html.erb y agreguemos nuestro código de formulario.

<% if [email protected]? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

Ahora inicie el servidor y visite http: // localhost: 3000. Producirá una pantalla similar a la siguiente:

Una última cosa que debemos hacer es filtrar la lista de tipos de archivos permitidos. Para eso, necesitamos agregar un código simple como se muestra a continuación en app / uploaders / attach_uploader.rb

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

Ahora inicie el servidor y visite http: // localhost: 3000. Ahora ingrese un formato incorrecto; generará un mensaje incorrecto como se muestra a continuación -

Para un detalle completo sobre File objeto, debe pasar por el Ruby Reference Manual.

Action Maileres el componente Rails que permite a las aplicaciones enviar y recibir correos electrónicos. En este capítulo, veremos cómo enviar un correo electrónico usando Rails. Comencemos a crear unemails proyecto usando el siguiente comando.

tp> rails new mailtest

Esto creará el marco necesario para continuar. Ahora, comenzaremos con la configuración de ActionMailer.

Action Mailer - Configuración

Los siguientes son los pasos que debe seguir para completar su configuración antes de continuar con el trabajo real:

Vaya a la carpeta de configuración de su proyecto de correo electrónico y abra el archivo environment.rb y agregue la siguiente línea en la parte inferior de este archivo.

config.action_mailer.delivery_method = :smtp

Le dice a ActionMailer que desea utilizar el servidor SMTP. También puede configurarlo para que sea: sendmail si está utilizando un sistema operativo basado en Unix, como Mac OS X o Linux.

Agregue también las siguientes líneas de código al final de su environment.rb.

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

Reemplace cada valor de hash con la configuración adecuada para su servidor de Protocolo simple de transferencia de correo (SMTP). Puede obtener esta información de su proveedor de servicios de Internet si ya no lo sabe. No es necesario cambiar el número de puerto 25 y el tipo de autenticación si está utilizando un servidor SMTP estándar.

También puede cambiar el formato de mensaje de correo electrónico predeterminado. Si prefiere enviar correos electrónicos en HTML en lugar de en formato de texto sin formato, agregue la siguiente línea a config / environment.rb también:

ActionMailer::Base.default_content_type = "text/html"

ActionMailer :: Base.default_content_type podría establecerse en "text / plain", "text / html" y "text / enriched". El valor predeterminado es "texto / sin formato".

El siguiente paso será crear un mailer

Generar un Mailer

Utilice el siguiente comando para generar un correo de la siguiente manera:

tp> cd emails
emails> rails generate mailer Usermailer

Esto creará un archivo user_mailer.rb en el directorio app \ mailer. Verifique el contenido de este archivo de la siguiente manera:

class Emailer < ActionMailer::Base
end

Creemos un método de la siguiente manera:

class UserMailer < ApplicationMailer
   default from: '[email protected]'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

default Hash- Este es un hash de valores predeterminados para cualquier correo electrónico que envíe desde este correo. En este caso, estamos configurando el encabezado: from a un valor para todos los mensajes de esta clase. Esto se puede anular por correo electrónico
mail - El mensaje de correo electrónico real, estamos pasando los encabezados de asunto: a y:.

Cree un archivo llamado welcome_email.html.erb en app / views / user_mailer /. Esta será la plantilla utilizada para el correo electrónico, formateada en HTML -

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

A continuación, crearemos una parte de texto para esta aplicación de la siguiente manera:

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

Llamando al Mailer

Primero, creemos un andamio de usuario simple

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

Action Mailer está muy bien integrado con Active Job para que pueda enviar correos electrónicos fuera del ciclo de solicitud-respuesta, de modo que el usuario no tenga que esperar.

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

Ahora, pruebe su aplicación usando http://127.0.0.1:3000/users/new. Muestra la siguiente pantalla y al usar esta pantalla, podrá enviar su mensaje a cualquier persona.

Esto enviará su mensaje y mostrará el mensaje de texto "Mensaje enviado con éxito" y la salida de la siguiente manera:

sent mail to [email protected] (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: [email protected]
To: [email protected]
Message-Id: <[email protected]>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

Para obtener más información sobre cómo enviar correos electrónicos mediante Rails, consulte ActionMailer .

↰ Previous page Next page ↱