Creación de un proyecto en Rails - moiseserg/rubyWebDev GitHub Wiki

Una introducción más completa: Getting Started with Rails

Para mostrar lo anterior supongamos que se desea generar un sistema para una empresa maquiladora, para dicha empresa es necesario tener datos de los empleados y las tareas que realizará cada empleado.

Lo primero que se debe hacer es crear el proyecto empresa, para ello se usará la instrucción

rails new empresa

Para lo que el sistema generará la siguiente salida:

create  
      create  README.md
      create  Rakefile
      create  config.ru
      create  .gitignore
      create  Gemfile
      ...
      remove  config/initializers/cors.rb
      remove  config/initializers/new_framework_defaults_5_1.rb
         run  bundle install
The dependency tzinfo-data (>= 0) will be unused by any of the platforms Bundler is installing for. Bundler is installing for ruby but the dependency is only for x86-mingw32, x86-mswin32, x64-mingw32, java. To add those platforms to the bundle, run `bundle lock --add-platform x86-mingw32 x86-mswin32 x64-mingw32 java`.
Fetching gem metadata from https://rubygems.org/.........
Fetching gem metadata from https://rubygems.org/.
Resolving dependencies.....
Using rake 12.3.0
Using concurrent-ruby 1.0.5
Fetching i18n 0.9.3
Installing i18n 0.9.3
...
Fetching uglifier 4.1.4
Installing uglifier 4.1.4
Fetching web-console 3.5.1
Installing web-console 3.5.1
Bundle complete! 16 Gemfile dependencies, 70 gems now installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.
         run  bundle exec spring binstub --all
* bin/rake: spring inserted
* bin/rails: spring inserted   

y de forma automática ejecutará la instrucción bundle install que instala las gemas (bibliotecas) que se cargan por default al proyecto.

Si cambia las bibliotecas para su proyecto debe ejecutar bundle install para hacer las instalaciones/modificaciones necesarias.

bundle install 

Se puede apreciar la estructura del proyecto usando un navegador de archivos, se tendrán las siguientes carpetas y archivos que se muestran en la figura:

Entre las carpetas que se instalan, se listan las de uso más común:

Para poder lanzar la aplicación se ejecuta el siguiente comando:

rails server

Aquí un ejemplo de la salida generada por el comando:

$ rails server
=> Booting Puma
=> Rails 5.1.4 application starting in development 
=> Run `rails server -h` for more startup options
Puma starting in single mode...
* Version 3.11.2 (ruby 2.5.0-p0), codename: Love Song
* Min threads: 5, max threads: 5
* Environment: development
* Listening on tcp://0.0.0.0:3000
Use Ctrl-C to stop
Started GET "/" for 127.0.0.1 at 2018-01-23 10:59:48 -0600
Processing by Rails::WelcomeController#index as HTML
  Rendering /home/emmanuel/.rbenv/versions/2.5.0/lib/ruby/gems/2.5.0/gems/railties-5.1.4/lib/rails/templates/rails/welcome/index.html.erb
  Rendered /home/emmanuel/.rbenv/versions/2.5.0/lib/ruby/gems/2.5.0/gems/railties-5.1.4/lib/rails/templates/rails/welcome/index.html.erb (13.1ms)
Completed 200 OK in 266ms (Views: 39.4ms)

La salida obtenida es la siguiente usando la url y puerto indicados por la orden rails server:

Para configurar el acceso a BD, abrir el archivo config/database.yml, si está configurado el proyecto usando SQLite, podrá ver algo como lo siguiente:

# SQLite version 3.x
#   gem install sqlite3
#
#   Ensure the SQLite 3 gem is defined in your Gemfile
#   gem 'sqlite3'
#
default: &default
  adapter: sqlite3
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  timeout: 5000

development:
  <<: *default
  database: db/development.sqlite3

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  <<: *default
  database: db/test.sqlite3

production:
  <<: *default
  database: db/production.sqlite3

Si la configuración es para usar con MySQL, el archivo será como el siguiente:

# MySQL. Versions 5.1.10 and up are supported.
#
# Install the MySQL driver
#   gem install mysql2
#
# Ensure the MySQL gem is defined in your Gemfile
#   gem 'mysql2'
#
# And be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.7/en/old-client.html
#
default: &default
  adapter: mysql2
  encoding: utf8
  pool: <%= ENV.fetch(  "RAILS_MAX_THREADS") { 5 } %>
  username: root
  password: password
  socket: /var/run/mysqld/mysqld.sock

development:
  <<: *default
  database: pizzeria_development

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  <<: *default
  database: pizzeria_test

# As with config/secrets.yml, you never want to store sensitive information,
# like your database password, in your source code. If your source code is
# ever seen by anyone, they now have access to your database.
#
# Instead, provide the password as a unix environment variable when you boot
# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
# for a full rundown on how to provide these environment variables in a
# production deployment.
#
# On Heroku and other platform providers, you may have a full connection URL
# available as an environment variable. For example:
#
#   DATABASE_URL="mysql2://myuser:mypass@localhost/somedatabase"
#
# You can use this database configuration with:
#
#   production:
#     url: <%= ENV['DATABASE_URL'] %>
#
production:
  <<: *default
  database: pizzeria_production
  username: pizzeria
  password: <%= ENV['PIZZERIA_DATABASE_PASSWORD'] %>

En caso de haber seleccionado SQLite o MySQL, las gemas también cambian. El archivo Gemfile de cada aplicación tiene la gema de acuerdo al gestor de BD que se haya seleccionado:

Cualquier cambio a las gemas requiere la actualización usando bundle install desde la raíz del proyecto.

Para crear la base de datos y probar la comunicación, deberá usar el comando rake db:create

$ rake db:create
Created database 'empresa_development'
Created database 'empresa_test'

• La interfaz de phpMyAdmin mostraría la base de datos creada, tal como lo indica el archivo config/database.yml

Después de ejecutar la orden explicada anteriormente:

$ rails generate scaffold Empleado nombre:string direccion:text edad:integer  

deberá poder ver los cambios en la tabla generada como empleados

Se puede crear un modelo usando scaffold, esto es un script que genera de manera automática los archivos de modelo, vista y controlador necesarios. En caso de haber instalado rspec genera los archivos para las pruebas CRUD de manera automática.

Si el modelo de empleado tiene los siguientes campos:

_{*no se usan acentos ya que los modelos se crean usando el alfabeto inglés.}

La línea que permite generar este modelo usando scaffold es la siguiente:

$ rails generate scaffold Empleado nombre:string direccion:text edad:integer  

La ejecución genera la siguiente salida:

$ rails generate scaffold Empleado nombre:string direccion:text edad:integer  
Running via Spring preloader in process 25418
      invoke  active_record
      create    db/migrate/20180123172257_create_empleados.rb
      create    app/models/empleado.rb
      invoke    test_unit
      create      test/models/empleado_test.rb
      create      test/fixtures/empleados.yml
      invoke  resource_route
       route    resources :empleados
      invoke  scaffold_controller
      create    app/controllers/empleados_controller.rb
      invoke    erb
      create      app/views/empleados
      create      app/views/empleados/index.html.erb
      create      app/views/empleados/edit.html.erb
      create      app/views/empleados/show.html.erb
      create      app/views/empleados/new.html.erb
      create      app/views/empleados/_form.html.erb
      invoke    test_unit
      create      test/controllers/empleados_controller_test.rb
      invoke    helper
      create      app/helpers/empleados_helper.rb
      invoke      test_unit
      invoke    jbuilder
      create      app/views/empleados/index.json.jbuilder
      create      app/views/empleados/show.json.jbuilder
      create      app/views/empleados/_empleado.json.jbuilder
      invoke  test_unit
      create    test/system/empleados_test.rb
      invoke  assets
      invoke    coffee
      create      app/assets/javascripts/empleados.coffee
      invoke    scss
      create      app/assets/stylesheets/empleados.scss
      invoke  scss
      create    app/assets/stylesheets/scaffolds.scss

Es importante verificar la estructura de archivos que ha sido cambiada:

Anteriormente, parte de los directorios y archivos era la siguiente:

$ tree
.
├── app
│   ├── assets
│   │   ├── javascripts
│   │   │   ├── application.js
│   │   │   ├── cable.js
│   │   │   └── channels
│   │   └── stylesheets
│   │       └── application.css
│   ├── controllers
│   │   ├── application_controller.rb
│   │   └── concerns
│   ├── helpers
│   │   └── application_helper.rb
│   ├── models
│   │   ├── application_record.rb
│   │   └── concerns
│   └── views
│       └── layouts
│           ├── application.html.erb
│           ├── mailer.html.erb
│           └── mailer.text.erb
├── db
│   └── seeds.rb
├── test
│   ├── application_system_test_case.rb
│   ├── controllers
│   ├── fixtures
│   │   └── files
│   ├── helpers
│   ├── integration
│   ├── mailers
│   ├── models
│   ├── system
│   └── test_helper.rb

Se muestran las partes donde se agregaron los archivos usando scaffold:

$ tree
.
├── app
│   ├── assets
│   │   ├── javascripts
│   │   │   ├── application.js
│   │   │   ├── cable.js
│   │   │   ├── channels
│   │   │   └── empleados.coffee
│   │   └── stylesheets
│   │       ├── application.css
│   │       ├── empleados.scss
│   │       └── scaffolds.scss
│   ├── controllers
│   │   ├── application_controller.rb
│   │   ├── concerns
│   │   └── empleados_controller.rb
│   ├── helpers
│   │   ├── application_helper.rb
│   │   └── empleados_helper.rb
│   ├── models
│   │   ├── application_record.rb
│   │   ├── concerns
│   │   └── empleado.rb
│   └── views
│       ├── empleados
│       │   ├── edit.html.erb
│       │   ├── _empleado.json.jbuilder
│       │   ├── _form.html.erb
│       │   ├── index.html.erb
│       │   ├── index.json.jbuilder
│       │   ├── new.html.erb
│       │   ├── show.html.erb
│       │   └── show.json.jbuilder
│       └── layouts
│           ├── application.html.erb
│           ├── mailer.html.erb
│           └── mailer.text.erb
├── db
│   ├── migrate
│   │   └── 20180123172257_create_empleados.rb
│   └── seeds.rb
├── test
│   ├── application_system_test_case.rb
│   ├── controllers
│   │   └── empleados_controller_test.rb
│   ├── fixtures
│   │   ├── empleados.yml
│   │   └── files
│   ├── helpers
│   ├── integration
│   ├── mailers
│   ├── models
│   │   └── empleado_test.rb
│   ├── system
│   │   └── empleados_test.rb
│   └── test_helper.rb

En la siguiente imagen se muestran algunos de los archivos generados.

Después de crearse los archivos, la base de datos debe ser actualizada para poder enseguida hacer conexiones para insertar, consultar ... información acerca del nuevo elemento creado, esto se hace usando:

$ rails db:migrate RAILS_ENV=development

La ejecución genera una salida como la siguiente:

$ rails db:migrate RAILS_ENV=development
== 20180123181704 CreateEmpleados: migrating ==================================
-- create_table(:empleados)
   -> 0.0662s
== 20180123181704 CreateEmpleados: migrated (0.0663s) =========================

El no hacer dicha instrucción genera un mensaje de error como el siguiente cuando se accede a empleados:

Puedes ingresar a la página indicada por rails server y se pueden usar las operaciones

• Crear
• Leer
• Actualizar
• Destruir

sobre la tabla empleados, la página generada es como la siguiente:

Se aprecia:

• http://localhost:3000/empleados la ruta con la que se entró a los elementos de la tabla empleados
• Al inicio (imagen de la izquierda) está vacía la lista de empleados.
• Enseguida, al hacer clic en New Empleado se pueden insertar los datos de un nuevo empleado según se especificaron los campos: nombre, dirección y edad.
• Muestra una ventana de tipo Read es decir muestra el dato insertado.
• Si se regresa a http://localhost:3000/empleados ya aparece el empleado insertado.

En la interfaz de phpMySQL puede verificarse:

• La estructura de los empleados.

• y el contenido (opción examinar).