Estamos escribiendo un blog en Ruby on Rails. Escribiendo un blog en Ruby on Rails Primer proyecto en Ruby on Rails

Esta guía cubre la instalación y ejecución de Ruby on Rails.

Después de leerlo, aprenderás:

• Cómo instalar Rails, crear una nueva aplicación Rails y adjuntar su aplicación a una base de datos.
• La estructura general de una aplicación Rails.
• Principios básicos de MVC (Modelo, Controlador de Vista) y diseño basado en RESTful.
• Cómo generar rápidamente código inicial para una aplicación Rails.

Supuestos en este manual

Este tutorial está dirigido a principiantes que quieran iniciar una aplicación Rails desde cero. No se supone que haya trabajado con Rails antes.

Rails es un marco de desarrollo web escrito en el lenguaje de programación Ruby. Si no tiene experiencia con Ruby, puede resultarle difícil comenzar a aprender Rails. Existen varios buenos recursos en inglés dedicados a aprender Ruby, por ejemplo:

Tenga en cuenta que algunos de los recursos, aunque siguen siendo excelentes, aún cubren versiones anteriores de Ruby, como 1.6, y especialmente 1.8, y no incluyen parte de la sintaxis que verá en el desarrollo diario de Rails.

¿Qué son los rieles?

Rails es un marco de desarrollo web escrito en el lenguaje de programación Ruby. Está diseñado para facilitar la programación de aplicaciones web al hacer una serie de suposiciones sobre lo que cada desarrollador necesita para crear un nuevo proyecto. Le permite escribir menos código durante la programación en comparación con otros lenguajes y marcos. Los desarrolladores profesionales de Rails también notan que hace que el desarrollo de aplicaciones web sea más divertido =)

Rails es un software descarriado. Supone que existe una manera "mejor" de hacer algo, y está diseñado de tal manera que fomenta esa manera (y en algunos casos incluso desalienta) las alternativas. Si aprende "The Rails Way", podrá descubrir importantes mejoras en la productividad. Si persiste en incorporar viejos hábitos de otros lenguajes al desarrollo de Rails e intenta utilizar patrones aprendidos en otros lugares, tendrá una experiencia de desarrollo menos feliz.

La filosofía Rails incluye dos principios rectores importantes:

• No te repitas: DRY es un principio de desarrollo de software que establece que "Cada pieza de información debe tener una representación única, no redundante y autorizada en el sistema". No escriba la misma información una y otra vez, el código será más fácil de mantener y será más extensible y tendrá menos errores.
• Convención sobre configuración: Rails tiene opiniones sobre las mejores formas de hacer muchas cosas en una aplicación web y utiliza esas convenciones de forma predeterminada en lugar de obligarlo a modificar numerosos archivos de configuración.

Creando un nuevo proyecto de rieles

La mejor manera de utilizar esta guía es seguirla paso a paso. Todos los pasos son esenciales para ejecutar la aplicación de ejemplo y no se requieren códigos ni pasos adicionales.

Siguiendo este tutorial, creará un proyecto Rails llamado blog, un blog web muy simple. Antes de comenzar a crear una aplicación, debemos asegurarnos de que Rails esté instalado.

Los siguientes ejemplos usan $ para indicar una línea de entrada de terminal en sistemas operativos tipo UNIX, aunque puede configurarse de manera diferente. Si está utilizando Windows, la línea se verá similar a c:\source_code>

3.1. Instalación de rieles

Antes de instalar Rails, debe asegurarse de que las dependencias previas requeridas estén instaladas en su sistema. Estos incluyen Ruby y SQLite3.

Abra aplicaciones de línea de comando. En macOS, abra Terminal.app, en Windows, seleccione "Ejecutar" en el menú Inicio y escriba "cmd.exe". Cualquier comando que comience con el signo de dólar $ debe ejecutarse en la línea de comando. Asegúrate de tener instalada la versión actual de Ruby:

$ rubí -v rubí 2.5.0

Rails requiere la instalación de Ruby versión 2.5.0 o posterior. Si el número de versión es menor que este, deberá instalar una nueva copia de Ruby.

Para instalar rápidamente Ruby y Ruby on Rails en un sistema, los usuarios de Windows pueden usar Rails Installer. Se pueden ver métodos de instalación adicionales para la mayoría de los sistemas operativos en ruby-lang.org.

Si está trabajando en Windows, necesita instalar el kit de desarrollo Ruby Installer.

También necesitará una instalación de base de datos SQLite3.

Muchos sistemas operativos populares tipo UNIX vienen con una versión razonable de SQLite3. En Windows, si instaló Rails usando Rails Installer, ya tiene SQLite instalado. Otros usuarios pueden consultar el sitio web de SQLite3 para obtener instrucciones de instalación. Verifique que esté instalado correctamente y esté contenido en su RUTA:

$sqlite3 --versión

El programa debe informar su versión.

Para instalar Rails, use el comando de instalación de gemas proporcionado por RubyGems:

$ rieles de instalación de gemas

Para comprobar que todo está instalado correctamente, debes hacer lo siguiente:

$rieles --versión

Si dice algo como "Rails 6.0.0", puedes continuar.

3.2. Crear una aplicación de blog

Rails viene con una serie de scripts, llamados generadores, diseñados para hacer la vida del desarrollador más fácil generando todo lo necesario para comenzar con una tarea específica. Uno de ellos es el Nuevo Generador de Aplicaciones, que le brinda el marco de una aplicación Rails para que no tenga que escribirla usted mismo.

Para usar este generador, abre una terminal, ve a una carpeta donde tengas permiso para crear archivos y escribe:

$rails nuevo blog

Esto creará una aplicación Rails llamada Blog en el directorio del blog e instalará las gemas cuyas dependencias se mencionan en el Gemfile cuando se usa la instalación del paquete.

Cuando se utiliza el subsistema de Windows para Linux, existen algunas restricciones en los mensajes del sistema de archivos que significan que debe desactivar Spring y Listen Gems, lo que se puede hacer ejecutando Rails New Blog --skip-spring --skip-listen.

Puede ver todas las opciones posibles de línea de comando que acepta el creador de aplicaciones Rails ejecutando Rails new -h.

Una vez que hayas creado la aplicación del blog, ve a su carpeta:

El directorio del blog contiene varios archivos y carpetas generados automáticamente que definen la estructura de una aplicación Rails. La mayor parte del trabajo de este tutorial se realizará en la carpeta de la aplicación, pero por ahora repasemos las funciones de cada carpeta que Rails crea en una nueva aplicación de forma predeterminada:

Archivo/Carpeta	Objetivo
aplicación/	Contiene controladores, modelos, vistas, ayudantes, anuncios publicitarios, canales, trabajos y activos de su aplicación. A continuación veremos esta carpeta con más detalle.
papelera/	Contiene scripts de Rails que inician su aplicación y el directorio también puede contener otros scripts que utiliza para configurar, actualizar, implementar o ejecutar.
configuración/	Configuraciones de ruta, base de datos de su aplicación, etc. Esto se trata con más detalle en Configuración de aplicaciones Rails.
config.ru	Configuración de rack para los servidores basados ​​en rack utilizados para ejecutar la aplicación. Para obtener más información sobre Rack, visite el sitio web de Rack.
base de datos/	Contiene su esquema de base de datos actual, así como las migraciones de bases de datos.
Archivo de gemas Archivo de gemas.lock	Estos archivos le permiten especificar qué dependencias de gemas necesita su aplicación Rails. Estos archivos son utilizados por la gema Bundler. Para obtener más información sobre Bundler, visite el sitio web de Bundler.
biblioteca/	Módulos externos para su aplicación.
registro/	Archivos de registro de aplicaciones.
paquete.json	Este archivo le permite especificar qué dependencias npm son necesarias para su aplicación Rails. Este archivo es utilizado por Yarn. Para obtener más información sobre Yarn, visite el sitio web de Yarn.
público/	La única carpeta a la que se puede acceder desde el exterior tal como está. Contiene archivos estáticos y activos compilados.
Archivo de rastrillo	Este archivo busca y carga tareas que se pueden ejecutar en la línea de comando. Una tarea específica está disponible en todos los componentes de Rails. En lugar de cambiar el Rakefile, puede agregar sus propias tareas agregando archivos al directorio lib/tasks de la aplicación.
LÉAME.md	Esta es una guía introductoria a su aplicación. Debe editarse para decirles a los demás qué hace su aplicación, cómo configurarla, etc.
almacenamiento/	Archivos de almacenamiento activo para el servicio de disco. Esto se trata en la guía Descripción general de Active Storage.
prueba/	Pruebas unitarias, accesorios y otros aparatos de prueba. Esto se trata en la guía de aplicaciones de Testing Rails.
tmp/	Archivos temporales (como archivos caché y pid)
proveedor/	Lugar para código de terceros. En una aplicación Rails típica, incluye gemas externas.
.gitignore	Este archivo le dice a git qué archivos (explícitamente o por diseño) debe ignorar. Para obtener más información sobre cómo ignorar archivos, consulte GitHub: ignorar archivos.
.versión-ruby	Este archivo contiene la versión predeterminada de Ruby.

¡Hola Rails!

Primero, mostremos algo de texto en la pantalla. Para hacer esto, necesita un servidor en ejecución para su aplicación Rails.

4.1. Iniciando el servidor web

De hecho, ya tienes una aplicación Rails funcional. Sin duda, necesita ejecutar un servidor web en su máquina. Esto se puede hacer ejecutando el siguiente comando desde el directorio del blog:

Si está utilizando Windows, debe pasar los scripts de la carpeta bin directamente al intérprete de Ruby, es decir, al servidor Ruby bin\rails.

La compresión de activos de JavaScript requiere un tiempo de ejecución de JavaScript en su sistema y, si no tiene uno, se producirá un error de execjs durante la compresión de activos. Normalmente, macOS y Windows vienen con un tiempo de ejecución de JavaScript instalado. therubyrhino es el tiempo de ejecución recomendado para los usuarios de JRuby y se agrega al Gemfile si la aplicación se genera bajo JRuby. Puede aprender todo sobre los tiempos de ejecución compatibles en ExecJS.

Esto iniciará Puma, un servidor web distribuido con Rails de forma predeterminada. Para ver la aplicación en acción, abra una ventana del navegador y vaya a http://localhost:3000. Deberías ver la página de información predeterminada de Rails:

Para detener el servidor web, presione Ctrl+C en la terminal donde se está ejecutando. Para verificar que el servidor se ha detenido, debería ver el cursor de la línea de comando nuevamente. En la mayoría de los sistemas tipo UNIX, incluido macOS, será el signo de dólar $. En modo de desarrollo, Rails generalmente no requiere que se detenga el servidor; Todos los cambios que realice en los archivos son recogidos automáticamente por el servidor.

La página Bienvenido a bordo es una especie de prueba para una nueva aplicación Rails: muestra que sus programas están configurados lo suficientemente correctamente como para mostrar la página.

4.2. Saluda a Rails

Para que Rails diga "Hola", debes crear al menos controlador Y vista(actuación).

La finalidad del responsable del tratamiento es recibir solicitudes específicas para la aplicación. Enrutamiento decide qué controlador recibirá qué solicitudes. A menudo hay más de una ruta para cada controlador y diferentes rutas pueden manejarse de manera diferente acción. El propósito de cada acción es recopilar información para proporcionarla a la vista.

El propósito de la vista es mostrar esta información en un formato legible por humanos. Una distinción importante a tener en cuenta es que el lugar donde se recopila la información es controlador, no una vista. La vista solo debe mostrar esta información. De forma predeterminada, las plantillas de vista están escritas en un lenguaje llamado eRuby (Embedded Ruby), que se convierte mediante un bucle de solicitud de Rails antes de enviarse al usuario.

Para crear un nuevo controlador, debe ejecutar el generador de "controladores" y decirle que desea un controlador llamado "Bienvenido" con una acción llamada "índice", como esta:

$ Rails genera el controlador Índice de bienvenida

Rails creará varios archivos y una ruta.

Crear ruta app/controllers/welcome_controller.rb obtener "bienvenido/index" invocar erb crear app/views/welcome crear app/views/welcome/index.html.erb invocar test_unit crear test/controllers/welcome_controller_test.rb invocar ayudante crear aplicación/ helpers/welcome_helper.rb invocar test_unit invocar activos invocar scss crear aplicación/assets/stylesheets/welcome.scss

Los más importantes son, por supuesto, el controlador, ubicado en app/controllers/welcome_controller.rb, y la vista, ubicada en app/views/welcome/index.html.erb.

Abra el archivo app/views/welcome/index.html.erb en un editor de texto. Elimine todo el código existente en el archivo y reemplácelo con la siguiente línea de código:

Si envía el formulario nuevamente, verá algo como lo siguiente:

"¡Primer artículo!", "texto"=>"Este es mi primer artículo.") permitido: falso>

Ahora esta acción muestra los parámetros del artículo que proviene del formulario. Sin embargo, sigue siendo inútil. Sí, ves los parámetros, pero en realidad no haces nada con ellos.

5.4. Crear un modelo de artículo

Los modelos en Rails usan un nombre singular y su tabla correspondiente en la base de datos usa un nombre plural. Rails proporciona un generador de modelos que la mayoría de los desarrolladores de Rails utilizan para crear nuevos modelos. Para crear un nuevo modelo, ejecute este comando en su terminal:

$ Rails genera modelo Título del artículo: texto de cadena: texto

Con este comando le decimos a Rails que queremos un modelo de Artículo con el atributo título tipo de cadena y atributo texto tipo de texto. Estos atributos se agregarán automáticamente a la tabla de artículos y se vincularán al modelo de artículo.

Rails responderá creando una serie de archivos. Ahora solo nos interesan app/models/article.rb y db/migrate/20140120191729_create_articles.rb (su nombre puede ser ligeramente diferente). Este último es responsable de crear la estructura de la base de datos, por lo que lo veremos a continuación.

Active Record es lo suficientemente inteligente como para asociar automáticamente los nombres de las columnas con los atributos del modelo, lo que significa que dentro de los modelos Rails no hay necesidad de declarar atributos, Active Record lo hará automáticamente.

5.5. Iniciar una migración

Como ya has visto, Rails genera el modelo creado el archivo. migración de base de datos en el directorio db/migrate. Migraciones es una clase de Ruby diseñada para facilitar la creación y modificación de tablas de bases de datos. Rails usa comandos rake para ejecutar migraciones y es posible deshacer una migración después de que se haya aplicado a su base de datos. El nombre del archivo de migración incluye una marca de tiempo para garantizar que se ejecuten en el orden en que fueron creados.

Si buscas en el archivo db/migrate/YYYYMMDDHHMMSS_create_articles.rb (recuerda, tu archivo tiene un nombre ligeramente diferente), esto es lo que encontrarás allí:

Clase CrearArtículos< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Esta migración crea un método de cambio que se llama cuando se ejecuta esta migración. Las acciones definidas en esta migración también son reversibles, lo que significa que Rails sabe cómo deshacer los cambios realizados por esta migración en caso de que decidas deshacerlos más adelante. Cuando ejecute esta migración, creará una tabla de artículos con una columna de cadena y una columna de texto. También creará dos campos de marca de tiempo para realizar un seguimiento de cuándo se creó y actualizó el artículo.

Ahora necesitamos usar el comando Rails para iniciar la migración:

$ carriles db:migrar

Rails ejecutará este comando de migración e informará que ha creado la tabla de artículos.

CreateArticles: migrar ================================================ === -- create_table(:articles) -> 0.0019s == CreateArticles: migrado (0.0020s) ============================ ===============

Dado que está ejecutando en el entorno de desarrollo de forma predeterminada, este comando se aplicará a la base de datos definida en la sección de desarrollo de su archivo config/database.yml. Si desea realizar migraciones en otro entorno, como producción, debe pasarlo explícitamente al llamar al comando: rails db:migrate RAILS_ENV=production.

5.6. Guardar datos en el controlador

Volviendo al ArticleController, necesitamos cambiar la acción de creación para usar el nuevo modelo de artículo para guardar datos en la base de datos. Abra app/controllers/articles_controller.rb y cambie la acción de creación para que se vea así:

Def crear @artículo = Artículo.nuevo(params[:artículo]) @artículo.save redirigir_to @artículo final

Esto es lo que sucede aquí: cada modelo de Rails se puede inicializar con los atributos apropiados, que se vincularán automáticamente a las columnas correspondientes de la base de datos. En la primera línea hacemos precisamente eso (recuerde que params[:article] contiene los atributos que nos interesan). @article.save es entonces responsable de guardar el modelo en la base de datos. Finalmente redirigimos al usuario a la acción mostrar, que definiremos más adelante.

Quizás se pregunte por qué la A en Article.new está en mayúscula cuando todos los demás enlaces de artículos de esta guía están en mayúscula. En este contexto, nos referimos a una clase llamada Artículo, que se define en app/models/article.rb. Los nombres de clases en Ruby deben comenzar con letra mayúscula.

Ahora que hay validaciones, llamar a @article.save en un artículo no válido devolverá false. Si abre app/controllers/articles_controller.rb nuevamente, verá que no estamos verificando el resultado de la llamada @article.save en la acción de creación. Si @article.save falla en esta situación, debemos mostrar el formulario al usuario nuevamente. Para hacer esto, reemplace las acciones nuevas y creadas en app/controllers/articles_controller.rb con estas:

Def nuevo @artículo = Artículo.nuevo fin def crear @artículo = Artículo.nuevo(artículo_params) si @artículo.save redirigir_to @artículo de lo contrario renderiza "nuevo" fin fin privado def artículo_params params.require(:artículo).permit(:título , :texto) fin

La nueva acción ahora crea una nueva variable de instancia llamada @article y verás por qué en un par de párrafos.

Tenga en cuenta que en la acción de creación usamos render en lugar de redirigir_to cuando guardar devuelve falso. El método de renderizado se utiliza para garantizar que el objeto @article se devuelva a la nueva plantilla cuando se renderice. Esta representación se realiza dentro de la misma solicitud que el envío del formulario, mientras que redirigir_to le dice al navegador que realice una solicitud diferente.

5.11. Actualizaciones de artículos

Hemos cubierto la parte "CR" de CRUD. Ahora centrémonos en la parte "U", la actualización de artículos.

El primer paso es agregar una acción de edición al ArticlesController, generalmente entre las acciones nueva y crear, como se muestra.

Def nuevo @artículo = Artículo.nuevo fin def editar @artículo = Artículo.find(params[:id]) fin def crear @artículo = Artículo.nuevo(artículo_params) si @artículo.save redirigir_to @artículo de lo contrario renderizar "nuevo" fin fin

La vista contendrá un formulario similar al que usamos al crear nuevos artículos. Cree un archivo llamado app/views/articles/edit.html.erb y agréguele lo siguiente:

Editando artículo

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

En este momento estamos apuntando el formulario a una acción de actualización, que aún no se ha definido, pero lo haremos pronto.

Pasar el objeto del artículo al método form_with configurará automáticamente la URL para enviar el formulario del artículo editado. Esta opción le dice a Rails que queremos que este formulario se envíe usando PATCH, un método HTTP que se espera que se use para actualizaciones recursos de acuerdo con el protocolo REST.

Luego necesitas crear una acción de actualización en app/controllers/articles_controller.rb. Agréguelo entre la acción de creación y el método privado:

Def crear @artículo = Artículo.nuevo(artículo_params) si @artículo.save redirigir_to @artículo más renderizar "nuevo" fin fin def actualizar @artículo = Artículo.find(params[:id]) si @artículo.update(artículo_params) redirigir_to @artículo más renderizar "editar" fin fin privado def artículo_params params.require(:artículo).permit(:título, :texto) fin

El nuevo método, actualizar, se utiliza cuando desea actualizar un registro que ya existe y requiere un hash que contiene los atributos que desea actualizar. Como antes, si hay un error al actualizar el artículo, queremos mostrar el formulario al usuario nuevamente.

Reutilizamos el métodoarticle_params que definimos anteriormente para la acción de creación.

No es necesario pasar todos los atributos para actualizar. Por ejemplo, si se llamó a @article.update(title: "Un nuevo título"), Rails actualizará solo el atributo del título, dejando todos los demás atributos intactos.

<% @articles.each do |article| %> <% end %>

Título	Texto
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

Y también agregaremos app/views/articles/show.html.erb a la plantilla para que el enlace "Editar" también esté en la página del artículo. Agregue lo siguiente al final de la plantilla:

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Y así es como se ve nuestra aplicación ahora:

5.12. Usar parciales para limpiar la repetición en las vistas

Nuestra página de edición es muy similar a la página nueva; de hecho, usan el mismo código para mostrar el formulario. Eliminemos esta duplicación usando una vista parcial. Por convención, los archivos parciales comienzan con un guión bajo.

Cree un nuevo archivo app/views/articles/_form.html.erb con el siguiente contenido:

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

Ahora actualicemos la vista app/views/articles/new.html.erb para usar este nuevo parcial reescribiéndolo por completo:

Nuevo articulo

<%= render "form" %> <%= link_to "Back", articles_path %>

Y lo mismo para la vista app/views/articles/edit.html.erb:

Editar artículo

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Eliminar artículos

Ahora estamos listos para cubrir la parte "D" de CRUD, eliminando de la base de datos. Siguiendo la convención REST, la ruta para eliminar artículos en la salida de rutas de rieles es la siguiente:

BORRAR /artículos/:id(.:formato) artículos#destruir

El método de eliminación de enrutamiento debe usarse para rutas que destruyen recursos. Si se dejara como una ruta de obtención normal, sería posible crear las siguientes URL maliciosas:

¡Mira este gato!

Usamos el método de eliminación para destruir recursos, y esta ruta está asociada con la acción de destrucción en app/controllers/articles_controller.rb, que aún no existe. El método de destrucción suele ser la última acción CRUD en un controlador y, al igual que otras acciones CRUD públicas, debe colocarse antes de cualquier método privado o protegido. Agregémoslo:

Def destruir @artículo = Artículo.find(params[:id]) @artículo.destroy redirigir_al final de la ruta_artículos

Todo el ArticlesController en el archivo app/controllers/articles_controller.rb ahora debería verse así:

Artículos de claseControlador< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

Puede llamar a destruir objetos de Active Record cuando desee eliminarlos de la base de datos. Tenga en cuenta que no necesitamos agregar una vista para esta acción ya que estamos redirigiendo a la acción de índice.

Listado de artículos

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Título	Texto
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Aquí usamos link_to de una manera diferente. Pasamos la ruta nombrada como segundo argumento y las opciones como otro argumento. El método: eliminar y datos: (confirmar: "¿Estás seguro?") Las opciones se utilizan como atributos html5, por lo que cuando se hace clic en un enlace, Rails primero mostrará al usuario un cuadro de diálogo de confirmación y luego enviará el enlace utilizando el método de eliminación. . Esto se hace utilizando el archivo JavaScript Rails-ujs, que se incluye automáticamente en el diseño de la aplicación (app/views/layouts/application.html.erb) cuando se genera la aplicación. Sin este archivo, no se mostrará el cuadro de diálogo de confirmación.

Felicitaciones, ahora puede crear, ver todos e individualmente, actualizar y eliminar artículos.

Agregar un segundo modelo

Es hora de agregar un segundo modelo a la aplicación. El segundo modelo procesará comentarios sobre artículos.

6.1. Generando el modelo

Tenemos la intención de utilizar el mismo generador que utilizamos anteriormente al crear el modelo de artículo. Esta vez crearemos un modelo de comentario que contiene un enlace al artículo. Ejecute el siguiente comando en una terminal:

$ Rails genera modelo Comentario comentarista:cuerpo de cadena:artículo de texto:referencias

Este comando genera cuatro archivos:

Primero, echemos un vistazo a app/models/comment.rb:

Comentario de clase< ApplicationRecord belongs_to:article end

Esto es muy similar al modelo de artículo que vimos anteriormente. La diferencia está en la línea pertenece_a:artículo, que establece conexión Registro activo. Aprenderá sobre las conexiones en la siguiente sección de la guía.

La palabra clave (:references) utilizada en el comando bash es un tipo de datos especial para modelos. Crea una nueva columna en su base de datos con el nombre del modelo representado con _id agregado, que puede contener valores numéricos. Para comprender mejor, analice el archivo db/schema.rb después de realizar la migración.

Además del modelo, Rails también realizó una migración para crear la tabla de base de datos correspondiente:

Clase CrearComentarios< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, null: false, foreign_key: true t.timestamps end end end

La línea t.references crea una columna numérica llamada Article_id, un índice y una restricción de clave externa que apunta a la columna id de la tabla de artículos. A continuación, iniciamos la migración:

$ carriles db:migrar

Rails es lo suficientemente inteligente como para realizar solo migraciones que aún no se han ejecutado en la base de datos actual; en nuestro caso verás:

CreateComments: migrando ================================================= == -- create_table(:comments) -> 0.0115s == CreateComments: migrado (0.0119s) ============================== =============

6.2. Conectando modelos

Las relaciones de Active Record le permiten declarar fácilmente relaciones entre dos modelos. En el caso de comentarios y artículos, podrá describir la relación de la siguiente manera:

• Cada comentario pertenece a un artículo.
• Un artículo puede tener muchos comentarios.

De hecho, es muy parecida a la sintaxis que usa Rails para declarar esta conexión. Ya has visto la línea de código en el modelo de comentarios (app/models/comment.rb) que hace que cada comentario pertenezca a un artículo:

Comentario de clase< ApplicationRecord belongs_to:article end

Debes editar app/models/article.rb para agregar el otro lado del enlace:

Artículo de clase< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Estos dos anuncios ponen automáticamente a disposición un gran número de posibilidades. Por ejemplo, si tiene una variable de instancia @article que contiene un artículo, puede obtener todos los comentarios que pertenecen a ese artículo en una matriz llamando a @article.comments.

6.3. Agregar una ruta para comentarios

Al igual que con el controlador de bienvenida, necesitamos agregar una ruta para que Rails sepa a qué dirección queremos ir para ver los comentarios. Abra el archivo config/routes.rb nuevamente y edítelo de la siguiente manera:

Recursos: los artículos hacen recursos: los comentarios terminan

Esto creará comentarios como recurso anidado en artículos. Esta es la otra cara de la captura de las relaciones jerárquicas que existen entre artículos y comentarios.

6.4. Generando un controlador

Teniendo el modelo, dirijamos nuestra atención a crear el controlador apropiado. Usaremos nuevamente el mismo generador que usamos antes:

$ Rails genera comentarios del controlador

Se crearán cuatro archivos y un directorio vacío:

Como cualquier otro blog, nuestros lectores crearán sus comentarios inmediatamente después de leer el artículo y, después de agregar un comentario, serán dirigidos nuevamente a la página de visualización del artículo y verán que su comentario ya se ha reflejado. En este sentido, nuestro CommentsController sirve como medio para crear comentarios y eliminar spam, si lo hubiera.

Primero, ampliaremos la plantilla de presentación de artículos (app/views/articles/show.html.erb) para permitir que se agregue un nuevo comentario:

Título: <%= @article.title %>

Texto: <%= @article.text %>

Añade un comentario:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Esto agregará un formulario a la página de visualización del artículo que crea un nuevo comentario cuando se llama a la acción de creación en CommentsController. Aquí la llamada form_with utiliza una matriz, que creará una ruta anidada como /articles/1/comments .

Escribamos crear en app/controllers/comments_controller.rb:

Comentarios de claseControlador< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

Es un poco más complicado de lo que viste en el artículo del controlador. Este es un efecto secundario del archivo adjunto que configuró. Cada solicitud de comentario realiza un seguimiento del artículo al que se adjunta el comentario, por lo que primero resolvemos el problema de recuperar el artículo llamando a buscar en el modelo Artículo.

Además, el código aprovecha algunos de los métodos disponibles para las conexiones. Usamos el método de creación en @article.comments para crear y guardar un comentario. Esto vincula automáticamente el comentario para que pertenezca a un artículo específico.

Una vez que hemos creado un nuevo comentario, llevamos al usuario de regreso al artículo original usando el asistente Article_path(@article). Como ya hemos visto, llama a la acción show en ArticlesController, que a su vez representa la plantilla show.html.erb. Aquí es donde queremos mostrar los comentarios, así que agreguemos lo siguiente a app/views/articles/show.html.erb.

Título: <%= @article.title %>

Texto: <%= @article.text %>

Comentarios

<% @article.comments.each do |comment| %>

Comentarista: <%= comment.commenter %>

Comentario: <%= comment.body %>

<% end %>

Añade un comentario:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Ahora puedes agregar artículos y comentarios a tu blog y mostrarlos en los lugares correctos.

Refactorización

Ahora que tenemos artículos y comentarios en funcionamiento, echemos un vistazo a la plantilla app/views/articles/show.html.erb. Se volvió largo e incómodo. Usemos parciales para aliviarlo.

7.1. Representación de colecciones de parciales

Primero, haremos un comentario parcial que muestre todos los comentarios de un artículo. Cree un archivo app/views/comments/_comment.html.erb y coloque lo siguiente en él:

Comentarista: <%= comment.commenter %>

Comentario: <%= comment.body %>

Luego puedes cambiar app/views/articles/show.html.erb así:

Título: <%= @article.title %>

Texto: <%= @article.text %>

Comentarios

<%= render @article.comments %>

Añade un comentario:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Esto ahora mostrará app/views/comments/_comment.html.erb parcial una vez para cada comentario en la colección @article.comments. Dado que el método render recorre en iteración la colección @article.comments, asigna cada comentario a una variable local denominada parcial, en este caso comentario, que está disponible para nosotros en el parcial para su visualización.

7.2. Representar un formulario en forma parcial

Movamos también la nueva sección de comentarios a nuestro parcial. Nuevamente, cree un archivo app/views/comments/_form.html.erb que contenga:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

Luego cambie app/views/articles/show.html.erb así:

Título: <%= @article.title %>

Texto: <%= @article.text %>

Comentarios

<%= render @article.comments %>

Añade un comentario:

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

El segundo renderizado simplemente define la plantilla parcial que queremos renderizar, comentarios/formulario. Rails es lo suficientemente inteligente como para poner un guión bajo en esta línea y comprender que deseaba representar el archivo _form.html.erb en el directorio app/views/comments.

El objeto @article está disponible en cualquier parcial representado en la vista, ya que lo definimos como una variable de instancia.

Eliminar comentarios

Otra característica importante del blog es la posibilidad de eliminar spam. Para hacer esto, necesita insertar algún enlace en la vista y una acción de destrucción en CommentsController.

Comentarista: <%= comment.commenter %>

Comentario: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

Al hacer clic en este nuevo enlace "Destruir comentario" se ejecutará DELETE /articles/:article_id/comments/:id en nuestro CommentsController que luego se usará para encontrar el comentario que queremos eliminar, así que agreguemos una acción de destrucción a nuestro controlador (app/ controladores/comentarios_controller.rb):

Comentarios de claseControlador< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

La acción de destrucción encontrará el artículo que estamos viendo, buscará el comentario en la colección @article.comments y luego lo eliminará de la base de datos y nos devolverá a ver el artículo.

8.1. Eliminar objetos relacionados

Si eliminas un artículo, también se deben eliminar los comentarios asociados a él, de lo contrario simplemente ocuparán espacio en la base de datos. Rails le permite utilizar la opción dependiente en un enlace para lograr esto. Modifique el modelo de artículo, app/models/article.rb, de la siguiente manera:

Artículo de clase< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Seguridad

9.1. Autenticación básica

Si publica su blog en línea, cualquiera puede agregar, editar y eliminar artículos o eliminar comentarios.

Rails proporciona un sistema de autenticación HTTP básico que funciona bien en esta situación.

En ArticlesController necesitamos una forma de bloquear el acceso a varias acciones si el usuario no está autenticado. Aquí podemos usar el método Rails http_basic_authenticate_with para permitir el acceso a las acciones requeridas si el método lo permite.

Para usar el sistema de autenticación, lo definiremos en la parte superior de nuestro ArticleController en app/controllers/articles_controller.rb. En nuestro caso, queremos que el usuario esté autenticado para cada acción excepto index y show, así que lo escribiremos así:

Artículos de claseControlador< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

También queremos permitir que solo los usuarios autenticados eliminen comentarios, por lo que en CommentsController (app/controllers/comments_controller.rb) escribiremos:

Comentarios de claseControlador< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

Ahora, si intenta crear un artículo nuevo, encontrará una llamada de autenticación básica HTTP:

También hay otros métodos de autenticación disponibles para aplicaciones Rails. Dos complementos populares para Rails son Devise y Authlogic, entre otros.

9.2. Otras reflexiones sobre la seguridad

La seguridad, especialmente en aplicaciones web, es un área amplia y detallada. La seguridad de su aplicación Rails se trata con más detalle en la guía Seguridad de las aplicaciones Rails. La forma más sencilla de trabajar con Rails es almacenar todos los datos externos en UTF-8. De lo contrario, las bibliotecas Ruby y Rails a menudo podrán convertir sus datos nativos a UTF-8, pero esto no siempre funciona de manera confiable, por lo que es mejor asegurarse de que todos los datos externos sean UTF-8.

Si comete un error en esta área, el síntoma más común es que aparezca en el navegador un diamante negro con un signo de interrogación en su interior. Otro síntoma común es la aparición de símbolos como "ü" en lugar de "ü". Rails toma una serie de medidas internas para mitigar casos comunes de problemas que pueden detectarse y corregirse automáticamente. Sin embargo, si hay datos externos que no están almacenados en UTF-8, esto puede provocar este tipo de problemas que Rails no puede detectar ni solucionar automáticamente.

Las dos fuentes de datos más comunes que no están en UTF-8 son:

• Su editor de texto: la mayoría de los editores de texto (como TextMate) guardan archivos como UTF-8 de forma predeterminada. Si su editor de texto no hace esto, puede causar que los caracteres especiales ingresados ​​en sus patrones (como é) aparezcan como un diamante con un signo de interrogación en el navegador. Esto también se aplica a sus archivos de traducción i18N. La mayoría de los editores que no utilizan UTF-8 de forma predeterminada (como algunas versiones de Dreamweaver) ofrecen una forma de cambiar el valor predeterminado a UTF-8. Haz esto.
• Su base de datos: Rails convierte de forma predeterminada los datos de su base de datos a UTF-8 en el borde. Sin embargo, si su base de datos no utiliza UTF-8 internamente, es posible que no pueda almacenar todos los caracteres que ingresará su usuario. Por ejemplo, si su base de datos utiliza Latin-1 internamente y su usuario ingresa caracteres rusos, hebreos o japoneses, los datos se perderán tan pronto como ingresen a la base de datos. Si es posible, utilice UTF-8 como almacenamiento interno en su base de datos.

Cree aplicaciones reales utilizando Ruby on Rails. Quizás haya probado Ruby on Rails pero lo encontró demasiado complicado y siente que necesita una introducción más completa. ¿Quizás tu jefe o cliente te ha lanzado al abismo con un proyecto de Ruby on Rails y necesitas aprender rápidamente sobre Rails? O tal vez haya decidido que desea agregar desarrollo web y Ruby on Rails a su currículum. Si es así, estás en el lugar correcto. Este curso le enseñará cómo crear aplicaciones web utilizando Ruby on Rails.

¿Por qué Ruby on Rails?

Ruby on Rails es una forma rápida y eficiente de desarrollar aplicaciones web. Simplifica las tareas repetitivas comunes que llevan mucho tiempo crear en otros idiomas. Es mucho más fácil completar un producto de alta calidad en Ruby on Rails que en otros idiomas.

Dado que el marco está maduro, hay un montón de proyectos/códigos de código abierto que puede usar que son extremadamente poderosos y realmente le brindan una ventaja en la creación de aplicaciones web sólidas.

Además, utiliza el lenguaje de programación Ruby. El código Ruby se lee como en inglés, lo que lo hace mucho más fácil de entender si recién estás comenzando a programar. Como lenguaje de tipado dinámico, Ruby no tiene todas las reglas rígidas que tienen otros lenguajes y se parece mucho a un lenguaje hablado. Le brinda la flexibilidad de resolver problemas de una manera más humana que otros lenguajes de programación.

¿Qué está cubierto?

Algunas de las características cubiertas en el curso incluyen...

Conceptos básicos de Git, "7 métodos" principales de Rails y cómo realizan "CRUD", enrutamiento de Rails, parámetros sólidos, devoluciones de llamadas personalizadas, validación personalizada, parciales,

Bootstrap 4, generadores Rails, autorización de usuario, autenticación de usuario, gestión de contenido, implementación, carga de bases de datos, envío/recepción de correo electrónico mediante la aplicación Rails, configuración de Sidekiq, configuración de Redis en Heroku y servidor privado, instalación de plantillas, mensajes de validación personalizados, adición de activos a Rails Pipeline, cargar imágenes en su propio servidor, cargarlas en AWS, agregar WYSIWYG: ¡lo que ve es lo que obtiene del editor y mucho más!

Por qué inscribirte en este curso es la mejor decisión que puedes tomar.

Estos cursos utilizan ejemplos no complejos para completar tareas complejas. El objetivo es lograr que comprenda exactamente lo que está haciendo y los motivos, no introducir código que no comprende. Ningún código está oculto porque es importante que comprenda qué hace cada línea.

Después de completar este curso, tendrás las habilidades necesarias para crear tus propias aplicaciones web usando Ruby on Rails.

Cuanto antes se registre en este curso, antes tendrá las habilidades y los conocimientos necesarios para mejorar su experiencia. ¡Los desarrolladores de Ruby on Rails tienen una gran demanda! ¿Por qué no empezar a utilizar Ruby on Rails hoy?

Ruby comenzó a desarrollarse el 23 de febrero de 1993 y fue lanzado en 1995. El nombre está inspirado en el lenguaje Perl, cuya sintaxis y semántica se han tomado prestadas de Ruby (perla - "perla", ruby ​​- "rubí"). El objetivo del desarrollo era crear un lenguaje de programación interpretado, “verdaderamente orientado a objetos”, fácil de desarrollar.

El lenguaje tiene una implementación de subprocesos múltiples independiente del sistema operativo, escritura dinámica fuerte, un recolector de basura y muchas otras características. La implementación multiplataforma del intérprete de idiomas es completamente gratuita.

Ruby on Rails (RoR) es un marco escrito en el lenguaje de programación Ruby. Implementa el patrón arquitectónico Model-View-Controller para aplicaciones web y también proporciona su integración con el servidor web y el servidor de base de datos. Es un software de código abierto y se distribuye bajo licencia MIT.

Para ayudarle a aprender estas tecnologías, hemos recopilado una selección de libros. Como siempre, si conoces algún libro que no esté incluido en este material, compártelo en los comentarios.

Este libro es para aquellos que quieran escribir Ruby como un profesional. Le enseña cómo diseñar hermosas API y trabajar con técnicas de programación funcional. El libro no es adecuado para principiantes, pero para aquellos que ya entienden Ruby, definitivamente será útil.

El propósito de este libro es enseñar a los lectores a utilizar el lenguaje Ruby de forma eficaz. El libro cubre Ruby 2.1. La publicación contiene alrededor de 400 ejemplos diferentes, acompañados de una exposición clara del problema y su solución con comentarios detallados.

El libro tiene un umbral de entrada bastante bajo. No es necesario conocer los conceptos básicos del desarrollo web para aprenderlo. El libro cubre Ruby on Rails, un marco popular para desarrollar aplicaciones web, desde cero. El autor Michael Hartl, además de Ruby on Rails, presenta al lector los conceptos básicos del propio lenguaje Ruby, el lenguaje de consulta SQL, CSS, HTML. El libro presta mucha atención al uso práctico de las capacidades del marco. También puedes leer un fragmento del libro.

Y este libro será útil para principiantes. Su complejidad aumenta progresivamente, y cada apartado posterior utiliza las habilidades adquiridas en los anteriores.

Con “Learning Ruby” aprenderás en la práctica todas las capacidades de este lenguaje de una manera fácil y divertida, que primero rápidamente cautivó los corazones de los programadores en California y luego en Rusia.

Después de leer este libro, aprenderá a escribir código elegante utilizando todas sus características únicas.

Este libro proporciona una visión detallada de la estructura interna del lenguaje Ruby. El lector no necesita conocer Ruby en sí, pero el conocimiento de C y, en particular, de los principios de programación orientada a objetos será una gran ventaja.

Este libro es excelente para comenzar con Ruby. Cubre todos los conceptos básicos necesarios, desde la instalación de idiomas hasta el manejo de archivos y la programación orientada a objetos. Cada tema cuenta con ejemplos claros.

Este libro habla de una de las características más interesantes de Ruby: los bloques. Son similares a cierres y lambdas y se utilizan tanto en estructuras de lenguaje simples como en bloques y técnicas complejas.

Este libro está dividido en varias secciones que varían en dificultad. Primero cubre la configuración y las características básicas de Ruby, y luego cubre la biblioteca estándar y temas avanzados.

Ruby es un lenguaje de programación potente y popular. Además de su popularidad, es la base de un marco conocido que le permite crear sitios web interesantes y dinámicos sobre diversos temas. Si nos fijamos en la calificación TIOBE, el idioma se encuentra entre los veinte idiomas más populares del mundo.

El lenguaje apareció en 1995 y se considera un lenguaje joven en comparación con C o C++, que aparecieron en 1972 y 1983, respectivamente. El lenguaje tiene una serie de ventajas y características específicas que se implementan exclusivamente en él, en comparación con otros lenguajes de programación populares.

plan de curso

Durante el curso en vídeo, aprenderá el lenguaje Ruby sin utilizar marcos adicionales. Cursos adicionales sobre Rubí puedes encontrarlo en .

Durante el curso aprenderemos a instalar y trabajar con el idioma, aprenderemos la sintaxis. Rubí(variables, bucles, declaraciones condicionales), así como cosas más complejas: programación orientada a objetos, trabajo con archivos, excepciones, métodos y tocaremos muchos otros temas.

Instalación de Ruby en Windows

Para instalar Ruby en Windows use instalador de rubíes, que se puede descargar desde el sitio web oficial mediante este enlace. Descargue la última versión e instálela como un programa normal. Una vez completada la instalación, verá una ventana similar:

En esta ventana, asegúrese de que la casilla de verificación esté marcada, luego se abrirá otra aplicación para su instalación. Rubí en el sistema.

En la ventana que se abre, ingrese 1 uno por uno y presione Enter, espere hasta que se complete la instalación, presione 2 y Enter, y al final ejecute el tercer comando presionando 3 y Enter.

Instalación de Ruby en Mac

En una Mac, Ruby se instala de forma predeterminada, por lo que no es necesario hacer nada adicional. Puede verificar la versión del idioma en la terminal usando el siguiente comando:

Si la versión está desactualizada, puede descargar una nueva. Primero, necesitas descargar el administrador de versiones de Ruby. Esto se hace a través de la terminal usando el comando:

Rizo -L https://get.rvm.io | bash -s estable

Después de instalar el administrador, debes reiniciar el terminal. Ejecute el siguiente comando:

Lista de RVM conocida

Después de reiniciar, puede instalar la versión que desee. En nuestro caso se instaló la versión 2.4.2:

Rvm instala rubí-2.4.2

Al final, puede verificar la versión nuevamente y, si aún es antigua, simplemente instale la nueva versión de forma predeterminada.