Elicia/Scaffolding en RoR.rest

ANEXO2:SCAFFOLDING EN RUBY ON RAILS

Hola, que tal amigos de Devcodela,! Les habla Elicia Cordova. Y en este video aprenderemos a crear nuestra primera aplicación utilizando scaffold al mismo tiempo explicaremos el patrón de diseño MVC en Ruby on Rails.

Creando Gemset para nuestro proyecto

En primer lugar definiremos un gemset para el proyecto que estamos trabajando. Este comando especificará la version del interprete de Ruby que queremos usar, seguido del nombre del gemset creado.

$rvm use 2.0.0@MicroBlog --create --default

Ahora sobre este gemset creamos nuestra primera aplicacion.

Creando nuestra primera aplicación en Rails

Para crear una nueva aplicación en Rails, se ejecuta el comando: rails new seguido del nombre de nuestra aplicación microblog que queremos crear.

Esta es la forma que debemos seguir para crear cualquier aplicacion de Rails. Este comando nos crearà automaticamente un esqueleto con todas las carpetas y archivos propios de nuestra aplicación Rails.

>>>
$ rails new microblog
      create
      create  README.rdoc
      create  Rakefile
      create  config.ru
      create  .gitignore
      create  Gemfile
      create  app
      create  app/assets/javascripts/application.js
      create  app/assets/stylesheets/application.css
      create  app/controllers/application_controller.rb
      .
      .
      .
      create  test/test_helper.rb
      create  tmp/cache
      create  tmp/cache/assets
      create  vendor/assets/javascripts
      create  vendor/assets/javascripts/.keep
      create  vendor/assets/stylesheets
      create  vendor/assets/stylesheets/.keep
         run  bundle install
      .
      .
      .
      Your bundle is complete! Use `bundle show [gemname]` to see where a bundled
      gem is installed.

Se crean muchos archivos y directorios de Ruby, no obstante Bundler empezarà a correr automáticamente instalando gemas que vienen configuradas por defecto.

Estructura del directorio creado de una aplicación Rails:

app/:	Dentro de esta carpeta se encuentrará todo el código del núcleo de nuestra aplicación, incluyendo modelos, vistas y controladores.
app/assets:	Aqui se encuentra todos los recursos estáticas de nuestra aplicación tales como las hojas de estilo encascada(css), archivos javascript y las imágenes.
app/models:	Lo explicare mas adelante
app/views:	Lo explicare mas adelante
app/controllers:	Lo explicare mas adelante
config/:	Se encuentran archivos de configuración de la aplicación para desarrollo, producción y testing, el archivo de ruteo
Gemfile:	Aqui se especificarán todas las gemas que tu aplicación requiere.

Y otros archivos que por el momento no son de utilidad explicar para el objetivo de este video.

Bundler

Después de crear una nueva aplicación web en Rails, el siguiente paso es usar Bundler para instalar e incluir las gemas necesarias propias para la aplicación. Lo que haremos serà cambiar el archivo GemFile donde mostrarà las gemas que vienen por defecto y agregaremos gemas específicas para nuestra aplicación, finalmente correremos el Bundler.

Abriremos el archivo Gemfile.rb con nuestro editor de texto favorito.

>>>
$ subl Gemfile

El siguiente Gemfile es lo que viene por defecto.

>>>
source 'https://rubygems.org'
# Use sqlite3 as the database for Active Record
gem 'sqlite3'
# Use SCSS for stylesheets
gem 'sass-rails', '~> 4.0.1'
# Use Uglifier as compressor for JavaScript assets
gem 'uglifier', '>= 1.3.0'
# Use CoffeeScript for .js.coffee assets and views
gem 'coffee-rails', '~> 4.0.0'
# See https://github.com/sstephenson/execjs#readme for more supported runtimes
# gem 'therubyracer', platforms: :ruby
# Use jquery as the JavaScript library
gem 'jquery-rails'
# Turbolinks makes following links in your web application faster.
# Read more: https://github.com/rails/turbolinks
gem 'turbolinks'
# Build JSON APIs with ease. Read more: https://github.com/rails/jbuilder
gem 'jbuilder', '~> 1.0.1'
group :doc do
  # bundle exec rake doc:rails generates the API under doc/api.
  gem 'sdoc', require: false
end
# Use ActiveModel has_secure_password
# gem 'bcrypt-ruby', '~> 3.1.2'
# Use unicorn as the app server
# gem 'unicorn'
# Use Capistrano for deployment
# gem 'capistrano', group: :development
# Use debugger
# gem 'debugger', group: [:development, :test]

Se muestran algunas de las gemas que comunmente se necesitan. Por ahora no necesitamos alguna otra gema, mas de las que viene por defecto.

Vamos a refactorizar este código.. Primero eliminaremos las lineas que vienen comentadas con el simbolo(#).

A continuación especificamos la versión de Ruby que espera la aplicación, seguido del gemset RVM. Si no estamos utilizando un gemset de Ruby, no debemos incluir la linea comentada, de lo contrario, lo descomentamos, pues es muy convenientemente utilizar la combinación versión de Ruby seguido del gemset.

Quedando al final todo el archivo así:

>>>
source 'https://rubygems.org'
ruby '2.0.0'
#ruby-gemset=Miproyecto
gem 'rails', '4.0.2'
group :development do               ---> Obliga a bundler a instalar la versión 1.3.8 de la gema sqlite3. Con esto            gem 'sqlite3', '1.3.8'                  especificamos  que lo estamos incluyendo en un entorno de desarrollo y evita                                                conlfictos con la BDx que serà utilizada en Heroku
end
gem 'sass-rails', '4.0.1'
gem 'uglifier', '2.1.1'
gem 'coffee-rails', '4.0.1'
gem 'jquery-rails', '3.0.4'
gem 'turbolinks', '1.1.1'
gem 'jbuilder', '1.0.2'
group :doc do
  gem 'sdoc', '0.3.20', require: false
end

A menos que no se especifique un número de versión de la gema, Bundler instalará automáticamente la última versión de la gema. Por desgracia, las actualizaciones de la gema a menudo causan la rotura lo que se hace potencialmente confuso, por lo que vamos a incluir los números de versión de manera explícita.

Una vez que hayamos resumido todo el Gemfile, instalaremos las gemas usando:

>>>
$ bundle update
$ bundle install

El comando bundle install tomará varios minutos. Pero cuando esté, nuestra aplicación estará lista para funcionar.

Rails Server

Gracias a que hemos corrido rails new y bundle install ya tenemos lista nuestra aplicacioǹ para correr. Rails viene con un comando o script que correrà el servidor web local, visible solo desde su equipo de desarrollo.

>>>
$ rails server
=> Booting WEBrick
-=> Rails application starting on http://0.0.0.0:3000
-=> Call with -d to detach
-=> Ctrl-C to shutdown server

Si tu sistema se queja de la falta de javascript en tiempo de ejecución visite la página execjs en GitHub para obtener una lista de posibilidades. Yo les recomiendo instalar Node.js. Esto nos dice que nuestra aplicacion está corriendo en el puerto 3000 en la direccion 0.0.0.0. o tambien la direccion 127.0.0.1 el cual tambien se le conoce como localhost.

Para ver mas informacion acerca de nuetsra primera aplicacion , Click en el link "About your application's enrovonment" .

Claro , nosotros no necesitamos la pag por defecto de Rails, pero es bueno ver que esto trabaje por ahora. Nosotros posteriormente eliminaremos la página por defecto y la reemplazaremos por una página de inicio personalizada. De esta manera ya tenemos creada nuestra primera aplicación en Rails.

Modelo Vista Controlador en acción

Ahora, aprenderemos a obtener una visión general de alto nivel de cómo Rails trabaja por dentro las aplicaciones. Ustedes puede haber notado que la estructura de la aplicación Rails:

![](http://ruby.railstutorial.org/images/figures/directory_structure_rails_4_0.png)

Tiene un directorio de la aplicación llamada app/ con tres subdirectorios: modelos , vistas y controladores. Esto es un indicio de que Rails sigue el patrón arquitectónico model-vista-controlador (MVC), que impone una separación de la "lógica del dominio" (también llamada " lógica de negocio " ) y la "lógica de presentación" que está asociada con la interfaz gráfica de usuario (GUI). En el caso de las aplicaciones web, la "lógica de dominio" por lo general se compone de modelos de datos para cosas como los usuarios, artículos y productos, y la interfaz gráfica de usuario es sólo una página web en un navegador web.

El Modelo Vista Controlador permite separar nuestro código en tres partes:

El Modelo: Está formado por clases, cada clase es un modelo, y cada modelo representa una tabla en la base de datos. Por tanto el Modelo es el encargado de trabajar con la lógica de la base de datos. Nosotros podríamos tener un Modelo Persona y una tabla personas, desde la clase Persona trabajaremos con todo lo relacionado a la tabla personas.
La Vista: Es la representación final de una petición, dentro de una vista hay más que nada código html, seguramente también habrá código Ruby, pero será mínimo, como imprimir una variable por pantalla o mostrar un listado de un arreglo. Pero más que nada la Vista se encargará de la presentación, lo que ve el visitante y no de la lógica de la petición.
El Controlador: Este, en cambio, sí se encargará de la lógica de la petición. A su vez hará de puente entre el Modelo y la Vista. Cada controlador será una clase con métodos, y por cada método habrá una vista que representará la versión procesada de ese método.

Al interactuar con una aplicación Rails, un navegador envía una solicitud, la cual es recibida por un servidor web y se transmite a un controlador de Rails. En algunos casos, el controlador hará que una vista que es una plantilla convertida a HTML, se envíe de vuelta al navegador. Además, el controlador interactúa con un modelo , que es un objeto Ruby que representa un elemento del sitio (por ejemplo, un usuario) y está a cargo de la comunicación con la base de datos. Después de invocar el modelo, entonces el controlador representa la vista y devuelve la página web completa en el navegador como HTML.

![](http://ruby.railstutorial.org/images/figures/mvc_schematic.png)

Crearemos un pequeño scaffold para explicar el funcionamiento del MVC.

El primer paso será crear el modelo de datos. En nuestro caso será post.

Modelando una demo de Post

Un post para nuestra aplicación demo tendrán un único identificador entero llamado id, titulo (string) y contenido (string) visible publicamente.

![](http://ruby.railstutorial.org/images/figures/demo_user_model.png)

Como veremos mas adelante el nombre posts, corresponde a una tabla en una base de datos y los atributos id, titulo, contenido son columnas de esa tabla.

El recurso Post

En esta sesion implementaremos el modelo de datos del post, junto con una interfaz web para el modelo.

Vamos a pensar en un recurso post, el cual nos permitirá pensar en los post como objetos que se pueden leer, actualizar y eliminar a través del protocolo http. Nuestro recurso post será creado por un programa generador de código llamdo scaffold el cual viene como estándar con cada proyecto de Rails.

Entonces,

$ rails generate scaffold Post titulo: string contenido:string

Los argumnetos que se pasan al comando scaffold son el nombre del recurso (Post) junto con parámetros opcionales para los atributos del módulo de datos.

Al incluir titulo y contenido hemos organizado el modelo de Post de la imagen anterior. No hay necesidad d incluir el parámetro id, pues éste es creado automáticamnete por Rails para el uso de la clave principal o primary key de la Base de Datos.

Para continuar debemos migrar la Base de Datos con RAKE.

$bundle exec rake db:migrate

Si usas RVM hacer:

$rake db:migrate

Esto simplemente actualiza la Base de Datos con un nuevo modelo de post. Tener en cuenta

Ahora, entramos a localhost:3000

>>>
URL     Action  Purpose
/posts  index   page to list all posts
/posts/1        show    page to show posts with id 1
/posts/new      new     page to make a new post
/posts/1/edit   edit    page to edit post with id 1

Partimos de la pàgina para mostrar todos los usuarios de nuestra app. en un principaio no hay usuarios.