Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

lectures/04-rails-mvc translated.

  • Loading branch information...
commit 3f9749199f3c65cdbb61fdc430b4973fa9053896 1 parent f2e4e0e
Sebastian Rajo authored
View
85 lectures/04-rails-mvc/4.1-rails-basics.md
@@ -1,11 +1,11 @@
-Rails Basics
+Rails Básico
============
-Rails can generate a working rails application in a single command.
+Rails puede generar una aplicación funcional con solamente una línea de comando.
$ rails new hello-world
-An application can then be run.
+Para ejecutar la aplicación:
$ cd hello-world
hello-world$ rails s
@@ -18,16 +18,16 @@ An application can then be run.
[2011-12-07 16:29:35] INFO ruby 1.9.2 (2011-07-09) [x86_64-darwin11.2.0]
[2011-12-07 16:29:35] INFO WEBrick::HTTPServer#start: pid=20070 port=3000
-Navigate to [localhost:3000](http://localhost:3000) to see your rails application.
+Introduzca [localhost:3000](http://localhost:3000) en el navegador para ver su aplicación.
-You can also open a rails console with `rails c`.
+También puede abrir la consola de Rails con `rails c`.
-That's too easy. Let's build a bare bones Rails application that can serve static pages, first.
+Eso es demasiado fácil. Vamos a construir el esqueleto de una aplicación Rails que muestre páginas estáticas.
Bundler
-------
-Create a *Gemfile* with the following contents.
+Cree una *Gemfile* con el siguiente contenido:
``` ruby
source "http://rubygems.org"
@@ -35,7 +35,7 @@ source "http://rubygems.org"
gem "rails", "3.1"
```
-Install gems.
+Instale la gema.
$ bundle install
Your bundle is complete! Use `bundle show [gemname]` to see where a bundled gem is installed.
@@ -43,48 +43,48 @@ Install gems.
$ rails --version
Rails 3.1.0
-Boot
-----
+Buteo
+-----
-In *config/boot.rb* we just need to setup bundler to load our gems.
+En *config/boot.rb* vamos a configurar bundler para que cargue nuestras gemas.
``` ruby
-# require rubygems that knows how to load gems
+# requiere de rubygems, el cuál sabe cómo cargar las gemas
require 'rubygems'
-# require bundler, which in turn will load all the gems
+# requiere de bundler, el que a su vez, cargará todas las gemas
require 'bundler/setup'
```
-Application
+Aplicación
-----------
-An application is declared in *config/application.rb*.
+La aplicación es declarada en *config/application.rb*.
``` ruby
-# load libraries required on boot
+# carga las librerías necesarias en el buteo
require File.expand_path('../boot', __FILE__)
-# the action controller that serves requests
+# el controlador de acciones que maneja los requests
require "action_controller/railtie"
-# libraries required for the application to run
-# include :default and current environment libraries
+# librerías necesarias para ejecutar la aplicación
+# incluye :default y las actuales librerías de entorno
Bundler.require :default, Rails.env
-# application itself
+# la aplicación en sí misma
module HelloWorld
class Application < Rails::Application
- # Configure the default encoding used in templates for Ruby 1.9.
+ # Configure el encoding por defecto utilizado en los templates para Ruby 1.9.
config.encoding = "utf-8"
end
end
```
-Environment
------------
+Entorno
+-------
-Initialize the application with all its environment options in *config/environment.rb*.
+Inicializa la aplicación con todas sus opciones de entorno en *config/environment.rb*.
``` ruby
require File.expand_path('../application', __FILE__)
@@ -95,9 +95,9 @@ HelloWorld::Application.initialize!
Config.ru
---------
-Rails uses Rack as the basis for its HTTP handling.
+Rails utiliza Rack como manejador básico de HTTP.
-Config.ru is a convention by which we indicate how to run a Rack-based application. This is also called to *rack-up* an application.
+Config.ru es una convención en la cual indicamos cómo ejecutar una aplicación basada en Rack. Esto también es llamado realizarle un *rack-up* a la aplicación.
``` ruby
require ::File.expand_path('../config/environment', __FILE__)
@@ -105,12 +105,12 @@ require ::File.expand_path('../config/environment', __FILE__)
run HelloWorld::Application
```
-A call to `File.expand_path('../config/environment', __FILE__)` evaluates to an absolute path to `config/environment`. This enables running Rails applications from any location.
+La llamada `File.expand_path('../config/environment', __FILE__)` define la dirección absoluta de `config/environment`. Esto permite ejecutar la aplicación desde cualquier ubicación.
Script/rails
------------
-Script/rails is automatically run when you type `rails`. It loads `config/application.rb` and `config/boot.rb`.
+Script/rails es automáticamente ejecutado cuando tipeas `rails`. Esto carga `config/application.rb` y `config/boot.rb`.
``` ruby
#!/usr/bin/env ruby
@@ -121,29 +121,29 @@ require File.expand_path('../../config/boot', __FILE__)
require 'rails/commands'
```
-Cryptographic Token
+Token criptográfico
-------------------
-A secret token is required to encrypt session data. Add *config/initializers/secret_token.rb*.
+Un token secreto es necesario para cifrar la información de la sesión. Agregue *config/initializers/secret_token.rb*.
``` ruby
-HelloWorld::Application.config.secret_token = "why did the chicken cross the road?"
+HelloWorld::Application.config.secret_token = "¿porqué el pollo cruzó la carretera?"
```
-Static HTML Page
-----------------
+Página HTML estática
+--------------------
-Add *public/index.html* with some basic HTML content.
+Agregue un archivo *public/index.html* con algún contenido HTML básico.
-Run the Application
--------------------
+Ejecutando la aplicación
+------------------------
$ rails s
-Navigate to http://localhost:3000 to display the contents of index.html.
+Escriba en el navegador http://localhost:3000 para desplegar el contenido de index.html.
-Load Sequence
--------------
+Secuencia de ejecución
+----------------------
$ rails s
@@ -164,8 +164,7 @@ Load Sequence
[2011-12-07 17:24:35] INFO ruby 1.9.2 (2011-07-09) [x86_64-darwin11.2.0]
[2011-12-07 17:24:35] INFO WEBrick::HTTPServer#start: pid=20322 port=3000
-Next
-====
-
-Lets look at a [Rails MVC application](4.2-rails-mvc-scaffold.md).
+A continuación
+==============
+Demos una mirada a [Aplicación Rails MVC](4.2-rails-mvc-scaffold.md).
View
74 lectures/04-rails-mvc/4.2-rails-mvc-scaffold.md
@@ -1,26 +1,23 @@
-Live Rails MVC Application and Scaffold
-=======================================
+Aplicación Rails MVC y Scaffold
+===============================
-Rails can generate a working rails application in a single command.
+Rails puede generar una aplicación funcional con sólo una linea de comando.
$ rails new rails-basics
-Model View Controller
----------------------
+Modelo Vista Controlador
+------------------------
-An HTTP request is sent to a *controller* via a route defined in `config/routes.rb`. A controller is a class that inherits
-from `ApplicationController`, which inherits from `ActionController::Base`. It will typically render a corresponding *view*,
-which is a template in ERB, HAML or other format that gets converted to HTML. These templates often use a specific *layout*.
-The view is often populated with data from a *model* that is usually retrieved from a database.
+Una solicitud HTTP es enviada al *controlador* por medio de la ruta definida en `config/routes.rb`. Un controlador es una clase que hereda de `ApplicationController`, la cual a su vez hereda de `ActionController::Base`. Generalmente será mostrada por la correspondiente *vista*, la cual es un template en ERB, HAML u otro formato que se pueda convertir a HTML. Esos template a menudo utilizan un *layout* específico. La vista comúnmente se completa con la información obtenida del *modelo*, la cual se obtiene de una base de datos.
-An Integration Test
--------------------
+Pruebas de integración
+----------------------
-Create a new test fixture.
+Cree una nueva prueba.
rails generate integration_test index
-This creates a test in `test/integration/index_test.rb`. We can add some meat to it, checking that we can render the index.html page with a proper title.
+Esto crea una prueba en `test/integration/index_test.rb`. Le podemos agregar algo de contenido, comprobando que podemos mostrar la página index.html con su correspondiente título.
``` ruby
require 'test_helper'
@@ -31,30 +28,30 @@ class IndexTest < ActionDispatch::IntegrationTest
test "fetches the index.html page" do
get "/"
assert_response :success
- assert_select "title", "Ruby on Rails: Welcome aboard"
+ assert_select "title", "Ruby on Rails: Bienvenido a bordo!"
end
end
```
-Asserts come from [ActionDispatch::Assertions](http://apidock.com/rails/ActionDispatch/Assertions).
+Los asserts [ActionDispatch::Assertions](http://apidock.com/rails/ActionDispatch/Assertions).
-Run tests with `rake test`.
+Ejecute las pruebas con `rake test`.
-Switch from SQL-Lite to PostgreSQL
-----------------------------------
+Cambie de SQL-Lite a PostgreSQL
+-------------------------------
-Heroku doesn't support SQLLite. Lets switch to PostgreSQL.
+Heroku no soporta SQLLite. Vamos a realizar el cambio a PostgreSQL.
-Change `sqlite` to `pg` in `Gemfile` and run `bundle install`.
+Cambie `sqlite` a `pg` en la `Gemfile` y ejecute `bundle install`.
-Create a login role.
+Cree un rol de acceso.
$ psql template1
create role rails with createdb login password 'password';
-Edit `config/database.yml`.
+Edite `config/database.yml`.
``` yaml
common: &common
@@ -77,67 +74,66 @@ production:
database: rails_production
```
-Create the databases.
+Cree una base de datos.
rake db:create:all
Assets
------
-In Rails assets are precompiled.
+En Rails los assets estan precompilados.
RAILS_ENV=production
rake assets:precompile
git add public/assets
git commit -m "vendor compiled assets"
-Deploy to Heroku
+Deploy a Heroku
----------------
-Heroku provides hosting for Rails applications and GIT-based workflow for deployment. Create an account on [heroku.com](http://www.heroku.com/).
+Heroku provee de hosting para aplicaciones creadas con Rails y soporte para el deploy en proyectos manejados con GIT. Cree una cuenta en [heroku.com](http://www.heroku.com/).
gem install heroku
heroku keys:add
-Create an application.
+Cree una aplicación.
$ heroku create dblock-rails-mvc --stack cedar
Creating dblock-rails-mvc... done, stack is cedar
http://dblock-rails-mvc.herokuapp.com | git@heroku.com:dblock-rails-mvc.git
-Setup a *heroku* remote. This is a GIT-based destination to which we can *push* code. You can see your remotes with `git remote -v`.
+Configure un *heroku* remoto. Esto es un destino GIT al cual le enviaremos el código mediante el comando *push*. Puedes ver todos los destinos remotos con `git remote -v`.
$ git remote add heroku git@heroku.com:dblock-rails-mvc.git
-Push the application to Heroku.
+Envíe la aplicación a Heroku.
$ git push heroku master
-Open a browser, `heroku open`.
+Abra el navegador con `heroku open`.
Scaffold Domain Model
---------------------
rails generate scaffold Thing name:string description:string
-This creates a model, controller, views, a database migration script, updates the schema and writes basic tests.
+Esto crea el modelo, el controlador, la vista, un script de migración de la base de datos, actualiza el esquema y crea las pruebas básicas.
Rakefile
--------
-Tasks are written in Ruby and run with [Rake](https://github.com/jimweirich/rake). Rake needs a `Rakefile`, which imports the application's code. You can run `rake -T` to see available tasks.
+Las tareas son escritas en Ruby y se ejecutan con [Rake](https://github.com/jimweirich/rake). Rake necesita un archivo `Rakefile`, el cual importa el código de la aplicación. Puedes ejecutar `rake -T` para ver las tareas disponibles.
$ rake -T
rake about # List versions of all Rails frameworks and the environment
...
-Exercise
---------
-
-Create a Rake task in `lib/tasks` that loads the `database.yaml` file and displays the database configuration for the current environment. When running this task, check whether the `database` value is set - you may need to set `YAML::ENGINE.yamler = 'syck'`.
+Ejercicio
+---------
-Next
-====
+Cree una tarea de Rake en `lib/tasks` que cargue el archivo `database.yaml` y muestre la configuración de la base de datos para el entorno actual. Cuando ejecute esta tarea compruebe que el valor `database` está definido; quizás necesite definir `YAML::ENGINE.yamler = 'syck'`.
-Lets rebuild a [Rails MVC application from scratch](4.3-rails-mvc-dev.md).
+A continuación
+==============
+Vamos a reconstruir una [aplicación Rails MVC desde cero](4.3-rails-mvc-dev.md).
View
169 lectures/04-rails-mvc/4.3-rails-mvc-dev.md
@@ -1,21 +1,21 @@
-Live Rails MVC Application from Scratch
-=======================================
+Aplicación Rails MVC desde Cero
+================================
-Start with the skeleton built in [a previous lesson](7-rails-basics.md), call the application module *RailsMVC*.
+Comience con el esqueleto construido en la [lección previa](7-rails-basics.md); nombre al módulo de la aplicación *RailsMVC*.
-* *Gemfile*: gems, including Rails
-* *config.ru*: rack-based startup script
-* *script/rails*: rails-based startup script
-* *config/environment.rb*: application initialization
-* *config/boot.rb*: application boot
-* *config/application.rb*: application
-* *config/initializers/secret_token.rb*: base cryptographic blob
-* *public/index.html*: hello world
+* *Gemfile*: gemas, incluyendo a Rails
+* *config.ru*: script de arranque de tipo Rack
+* *script/rails*: script de arranque de tipo Rails
+* *config/environment.rb*: inicialización de la aplicación
+* *config/boot.rb*: buteo de la aplicación
+* *config/application.rb*: aplicación
+* *config/initializers/secret_token.rb*: blob criptográfico base
+* *public/index.html*: hola mundo
-Routes
-------
+Rutas
+-----
-A route connects an HTTP request with a controller. Routes are declared in *config/routes.rb*.
+Una ruta conecta una solicitud con el controlador. Las rutas son declaradas en *config/routes.rb*.
``` ruby
RailsMVC::Application.routes.draw do
@@ -23,12 +23,12 @@ RailsMVC::Application.routes.draw do
end
```
-Default *RESTful* routing connects standard HTTP verbs (*GET*, *PUT*, *POST* and *DELETE*) with standard resource actions (`:index`, `:show`, `:new`, `:edit`, `:update` and `:destroy`).
+El ruteo por defecto es *RESTful* y utiliza los clásicos (*GET*, *PUT*, *POST* and *DELETE*) con las conocidas acciones de recursos (`:index`, `:show`, `:new`, `:edit`, `:update` y `:destroy`).
Rakefile
--------
-Tasks, such as database migrations, are written in [Rake](https://github.com/jimweirich/rake). Rake needs a *Rakefile*, which imports the application's code. Therefore, you have access to all domain models in Rake tasks.
+Las tareas, tal como la migración de la base de datos, son escritas en [Rake](https://github.com/jimweirich/rake). Rake necesita el archivo *Rakefile*, el cual importa el código de la aplicación. Además tienes acceso a todos los modelos del dominio en las tareas de Rake.
``` ruby
require File.expand_path('../config/application', __FILE__)
@@ -38,28 +38,28 @@ require 'rake'
RailsMVC::Application.load_tasks
```
-You can run `rake -T` to see available tasks.
+Puedes ejecutar `rake -T` para ver todas las tareas disponibles.
$ rake -T
rake about # List versions of all Rails frameworks and the environment
...
-Application Folder
-------------------
+La carpeta de la aplicación
+---------------------------
-Application code is located in *app*, by convention.
+Por convención el código de la aplicación está ubicado en *app*.
Asset Pipeline
--------------
-The *asset pipeline* enables authoring JavaScript, CSS and other static artifacts in many ways and compile or package them for the application. For example, in Rails 3.1 the asset pipeline enabled developers to write CoffeeScript instead of raw JavaScript out of the box.
+El *asset pipeline* autoriza a los JavaScript, los CSS y otros objetos estáticos y los compila o empaqueta para la aplicación. Por ejemplo, en Rails 3.1 el asset pipeline habilita a los desarrolladores a escribir con CoffeeScript en lugar de JavaScript.
-Enable the application pipeline in *config/application.rb*.
+Habilite el pipeline de la aplicación en *config/application.rb*.
# Enable the asset pipeline
config.assets.enabled = true
-Dynamic HTML in Rails is rendered with *templates*. Templates can be authored in multiple languages and execute Ruby code. Rails uses *ERB* by default. Another popular templating language is *HAML*. Add `haml-rails` to Gemfile and an application layout *app/views/layouts/application.html.haml*. A layout is a top-level template that defines the page structure, includes stylesheets and javascripts.
+El HTML dinámico en Rails es mostrado con *templates*. Los templates pueden ser creados en muchos lenguajes y ejecutar código de Ruby. Rails utiliza *ERB* por defecto. Otro creador de templates popular es *HAML*. Agregue `haml-rails` a la Gemfile y un layout *app/views/layouts/application.html.haml*. Un layout es un template en una capa superior que define la estructura de la página, incluyendo la hoja de estilo y los javascripts.
``` haml
!!!
@@ -74,18 +74,17 @@ Dynamic HTML in Rails is rendered with *templates*. Templates can be authored in
= yield
```
-The `stylesheet_link_tag` and `javascript_include_tag` methods are declared in [ActionView::Helpers::AssetTagHelper](http://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html), which is the tip of the *asset pipeline*. While you can hardcode links in your templates, these functions work with the asset pipeline's concepts and let you add global settings, such as *asset host* for assets hosted externally on a CDN. It's pretty common for Rails applications to generate assets at build time and deploy these to a web server.
+Los métodos `stylesheet_link_tag` y `javascript_include_tag` son declarados en [ActionView::Helpers::AssetTagHelper](http://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html), la cual es la punta del *asset pipeline*. A pesar de poder definir manualmente los vínculos en tu template, esas funciones trabajan con el concepto de asset pipeline y te permiten agregar configuraciones globales, tal como *asset host* para assets ubicados externamente en un CDN. Es bastante común para las aplicaciones en Rails generar assets en tiempo de desarrollo y luego realizar su deploy a un servidor web.
-The asset pipeline has the concept of a *manifest file* which include *directives* to let rails know which files to include. Create
-*app/assets/javascripts/application.js* - one of these *manifest files* with the following *directives*.
+Los asset pipeline tienen el concepto de *archivo manifiesto* el cual incluye las *directivas* para dejarle saber a Rails qué archivos incluir. Cree *app/assets/javascripts/application.js* - uno de esos *archivos manifiesto* con las siguientes *directivas*.
//= require jquery
//= require jquery_ujs
//= require_tree .
-Rails now ships with jQuery. Add `jquery-rails` to your Gemfile.
+Rails ahora utiliza jQuery. Agregue `jquery-rails` a su Gemfile.
-Add a stylesheet to *app/assets/stylesheets/application.css.scss*. The stylesheet is authored in SCSS, which is an extension of CSS that allows you to use variables, nested rules, mixins, inline imports, etc.
+Agregue una hoja de estilo *app/assets/stylesheets/application.css.scss*. La hoja de estilo es creada con SCSS la cual es una extensión de CSS, que utiliza variables, reglas anidadas, mixins, importaciones en línea, etc.
``` css
#error_explanation {
@@ -101,12 +100,12 @@ Add a stylesheet to *app/assets/stylesheets/application.css.scss*. The styleshee
}
```
-Database Configuration
-----------------------
+Configuración de la base de datos
+---------------------------------
-Since we're using PostgreSQL we need `pg` in Gemfile.
+Ya que estamos usando PostgreSQL, vamos a necesitar `pg` en la Gemfile.
-Rails configuration files are authored in *YAML*, which executes Ruby code. You could, for example, reference an environment variable with `ENV['VARIABLE']`. Add *config/database.yml* for the database configuration. You can reuse blocks of configuration with `<<:`.
+Los archivos de configuración de Rails son creados con *YAML*, el cual ejecuta código Ruby. Puede, por ejemplo, referenciar a variables de entorno con `ENV['VARIABLE']`. Agregue *config/database.yml* para la configuración de la base de datos. Puedes reutilizar bloques de configuración con `<<:`.
``` yaml
common: &common
@@ -129,20 +128,20 @@ production:
database: rails_production
```
-If you run `rake -T` you'll notice that there are no database tasks. That's because we're only using the *action_controller* part of Rails. Change `require "action_controller/railtie"` in *config/application.rb* to include `rails/all`.
+Si ejecutas `rake -T` serás notificado de que no existen tareas para la base de datos. Estos es porque estás utilizando solamente el *action_controller* de Rails. Modifique `require "action_controller/railtie"` en *config/application.rb* incluyendo `rails/all`.
``` ruby
require 'rails/all'
```
-Re-run `rake -T` and make sure that database tasks are now displayed.
+Ejecute nuevamente `rake -T` y asegúrese que las tareas de la base de datos ahora son mostradas.
-Database Migrations
--------------------
+Migración de base de datos
+--------------------------
-A database-backed application needs a schema. We could create *db/schema.rb* and populate it with a schema, but the Rails way is to use *database migrations*. Migrations support creating a new database and upgrading an existing one with built-in database versioning.
+Una aplicación con una base de datos de respaldo necesita de un esqueleto. Podríamos crearlo en *db/schema.rb* y completarlo con el esqueleto, pero la forma en que lo realiza Rails es utilizando *migración de base de datos*. La migración soporta la creación de una nueva base de datos y la actualización de una ya existente mediante la utilización de un sistema de versiones de bases de datos integrado.
-Create *db/migrate/1_create_things.rb*.
+Cree *db/migrate/1_create_things.rb*.
``` ruby
class CreateThings < ActiveRecord::Migration
@@ -155,14 +154,14 @@ class CreateThings < ActiveRecord::Migration
end
```
-We forgot the description. Let's create another migration to add this.
+Olvidamos la descripción. Vamos a crear otra migración para agregársela.
$ rails generate migration add_description_to_things description:string
invoke active_record
create db/migrate/20111207001110_add_description_to_things.rb
-This should generate the following time-stamped migration file:
+Esto debería generar el siguiente archivo de migración:
``` ruby
class AddDescriptionToThings < ActiveRecord::Migration
@@ -171,23 +170,22 @@ class AddDescriptionToThings < ActiveRecord::Migration
end
end
```
+Las migraciones se ejecutan en el orden en que fueron creadas, como lo determina el número al inicio de sus nombres de archivo.
-Migrations run incrementally in the order they were created, as determined by the number in the front of their filename.
-
-Local Database
---------------
+Base de datos local
+-------------------
-Create a database and migrate it from empty to version 1.
+Cree una base de datos y mígrela con una versión vacía 1.
rake db:create
rake db:migrate
-Data Model
-----------
+Modelo de datos
+---------------
-In Rails, *ActiveRecord* abstracts database access.
+En Rails, el *ActiveRecord* abstrae el acceso a la base de datos.
-Create *app/models/thing.rb*.
+Cree *app/models/thing.rb*.
``` ruby
class Thing < ActiveRecord::Base
@@ -196,29 +194,29 @@ class Thing < ActiveRecord::Base
end
```
-The validators are a way to ensure presence and uniqueness of fields. The fields are automagically generated by querying the schema on application startup.
+Las validaciones son una manera de asegurarse la presencia y la unicidad de los campos. Los campos son generados automáticamente por medio de las consultas al esqueleto al inicio de la aplicación.
-Application Controller
-----------------------
+El Controlador de la aplicación
+-------------------------------
-All controllers inherit from `ActionController::Base`. It's a good idea to create an `ApplicationController` in *app/controllers/application_controller.rb* that can implement common logic, such as authentication, in the future.
+Todos los controladores heredan de `ActionController::Base`. Es una buena idea crear un `ApplicationController` en *app/controllers/application_controller.rb* que pueda implementar una lógica común, tal como la autenticación.
``` ruby
class ApplicationController < ActionController::Base
end
```
-Things Controller
------------------
+El controlador del objeto Thing
+-------------------------------
-Add *app/controllers/things_controller.rb*.
+Agregue *app/controllers/things_controller.rb*.
``` ruby
class ThingsController < ApplicationController
end
```
-Retrieving all things for the index page.
+Obteniendo todos los objetos thing para la página index.
``` ruby
def index
@@ -226,7 +224,7 @@ def index
end
```
-Retrieve an existing thing by parameter when showing or editing a thing. The `params` hash has entries that can be accessed both by string and by symbol.
+Obtén un objeto thing existente por medio de un parámetro cuando lo editas o lo muestras. Los hash de `parámetros` poseen entradas a las que pueden accederse por medio de string y símbolos.
``` ruby
def show
@@ -234,7 +232,7 @@ def show
end
```
-Create a new thing when clicking on new.
+Cree un nuevo objeto thing cuando realice un clic en new.
``` ruby
def new
@@ -242,13 +240,13 @@ def new
end
```
-Persist a new or update an existing thing when submitting a thing from a new or edit page.
+Guarde o actualice un objeto thing cuando realice el envío desde la página de creación o edición.
``` ruby
def create
@thing = Thing.new(params[:thing])
if @thing.save
- redirect_to @thing, notice: 'Thing was successfully created.'
+ redirect_to @thing, notice: 'El objeto Thing ha sido creado con éxito.'
else
render action: "new"
end
@@ -257,14 +255,14 @@ end
def update
@thing = Thing.find(params[:id])
if @thing.update_attributes(params[:thing])
- redirect_to @thing, notice: 'Thing was successfully updated.'
+ redirect_to @thing, notice: 'El objeto Thing ha sido actualizado con éxito.'
else
render action: "edit"
end
end
```
-Destroy a thing.
+Borre un objeto thing.
``` ruby
def destroy
@@ -274,7 +272,7 @@ def destroy
end
```
-Errors are stored automatically via the model being saved, the controller's job is to re-render the view corresponding to the failed action. Create a partial *views/shared/_error_msg.html.haml* that will display errors.
+Los errores se guardan automáticamente al ser guardado el modelo, el trabajo del controlador es el de refrescar la vista con la correspondiente acción de fallo. Cree *views/shared/_error_msg.html.haml* la cual mostrará el error.
``` haml
- if model.errors.any?
@@ -285,12 +283,12 @@ Errors are stored automatically via the model being saved, the controller's job
%li= msg
```
-The `:index`, `:show`, `:new`, `:edit`, `:update` and `:destroy` methods are called *actions*. These are the default for *RESTful* routing.
+Los métodos `:index`, `:show`, `:new`, `:edit`, `:update` y `:destroy` son llamados *acciones*. Son los métodos por defecto para el ruteo *RESTful*.
-Things View
------------
+La vista de los objetos Thing
+-----------------------------
-Add *app/views/things/index.html.haml*.
+Agregue *app/views/things/index.html.haml*.
``` haml
%h1 Things
@@ -305,12 +303,12 @@ Add *app/views/things/index.html.haml*.
%tr
%td= thing.name
%td= link_to 'Edit', edit_thing_path(thing)
- %td= link_to 'Destroy', thing, :confirm => "Are you sure?", :method => :delete
+ %td= link_to 'Destroy', thing, :confirm => "¿Está seguro?", :method => :delete
= link_to "New Thing", new_thing_path
```
-Rather than hardcoding an entire form, let's use a gem called [simple_form](https://github.com/plataformatec/simple_form) and make an edit form partial, *app/views/things/_form.html.haml*.
+En lugar de codificar a mano un formulario, vamos a usar la gema llama [simple_form](https://github.com/plataformatec/simple_form) y realizar una edición de formulario, *app/views/things/_form.html.haml*.
``` haml
= simple_form_for @thing do |f|
@@ -319,7 +317,7 @@ Rather than hardcoding an entire form, let's use a gem called [simple_form](http
= f.button :submit
```
-The form can be used for the new thing in *app/views/things/new.html.haml*.
+El formulario puede usarse para los nuevo objeto thing en *app/views/things/new.html.haml*.
``` haml
%h1 New Thing
@@ -329,7 +327,7 @@ The form can be used for the new thing in *app/views/things/new.html.haml*.
= link_to 'Back', things_path
```
-It can also be used to edit a thing in *app/views/things/edit.html.haml*.
+También puede utilizarse para editar un objeto thing en *app/views/things/edit.html.haml*.
``` haml
%h1= @thing.name
@@ -339,7 +337,7 @@ It can also be used to edit a thing in *app/views/things/edit.html.haml*.
= link_to 'Back', things_path
```
-Finally, we should display a thing in *app/views/things/show.html.haml*.
+Finalmente, debemos mostrar el objeto thing en *app/views/things/show.html.haml*.
``` haml
%ul
@@ -350,10 +348,10 @@ Finally, we should display a thing in *app/views/things/show.html.haml*.
= link_to 'Back', things_path
```
-Things Routes
--------------
+El ruteo de los objetos Thing
+-----------------------------
-Edit *config/routes.rb*.
+Edite *config/routes.rb*.
``` ruby
RailsMVC::Application.routes.draw do
@@ -361,19 +359,18 @@ RailsMVC::Application.routes.draw do
end
```
-Review `rake routes`.
+Revise `rake routes`.
Links
-----
-* [Rails Testing](http://guides.rubyonrails.org/testing.html)
-
-Exercise
---------
+* [Rails Testing (Inglés)](http://guides.rubyonrails.org/testing.html)
-* Add a set of unit tests for the Thing model that ensure that a Thing can be created, retrieved by id, updated and destroyed (CRUD).
-* Add a set of functional tests for your things_controller that ensures Thing's CRUD.
-* Add a set of functional view tests for the things view that ensure the view displays a list of things for the `:index` action, forms for `:edit`, contents of a thing on `:show`, etc.
-* Bonus point for an integration test that runs a complete scenario of creating, showing, editing updating and destroying a Thing object end-to-end.
-* Bonus point for a route test.
+Ejercicios
+----------
+* Agregue un conjunto de pruebas unitarias al model del objeto Thing que asegure que el objeto es creado, recupérelo por su id, actualícelo y destrúyalo (CRUD):
+* Agregue un conjunto de pruebas funcionales para su things_controller que compruebe que el objeto Thing es CRUD.
+* Agregue un conjunto de pruebas funcionales para la vista que asegure que muestra una lista de objetos thing por medio de la acción `:index`, formularios para editarlos con `:edit`, el contendido con `:show`, etc.
+* Puntos adicionales por pruebas de integración que ejecute un escenario completo de creación, muestreo, edición, actualización y destrucción de objetos Thing.
+* Puntos adicionales por pruebas de ruta.
View
18 lectures/04-rails-mvc/README.md
@@ -1,15 +1,15 @@
-Lecture 4: Rails MVC
+Lectura 4: Rails MVC
====================
-Objective
----------
+Objetivo
+--------
-Build a basic Rails application with Rails tools, then from scratch. Exercise the fundamentals of test-driven development.
+Construir una aplicación simple con las herramientas de Rails desde cero. Ejercitar el manejo fundamental del desarrollo de pruebas.
-Class Materials
----------------
+Materiales de Clase
+-------------------
-* [Introduction to Rails](4.1-rails-basics.md)
-* [Live Rails MVC Application and Scaffold](4.2-rails-mvc-scaffold.md)
-* [Live Rails MVC Application from Scratch](4.3-rails-mvc-dev.md)
+* [Introducción a Rails](4.1-rails-basics.md)
+* [Aplicación Rails MVC y el Scaffold](4.2-rails-mvc-scaffold.md)
+* [Aplicación Rails MVC desde cero](4.3-rails-mvc-dev.md)
Please sign in to comment.
Something went wrong with that request. Please try again.