Ruby on Rails
Los rieles generan comandos.

Introducción

Parámetros

Observaciones

Generar rieles modelo

Para generar un modelo ActiveRecord que genere automáticamente las migraciones db correctas y los archivos de prueba para su modelo, ingrese este comando

rails generate model NAME column_name:column_type

'NOMBRE' es el nombre del modelo. 'campo' es el nombre de la columna en la tabla de base de datos y 'tipo' es el tipo de columna (por ejemplo, name:string o body:text ). Consulte la sección de Comentarios para obtener una lista de los tipos de columna admitidos.

Para configurar las claves foráneas, belongs_to:model_name .

Entonces, digamos que desea configurar un modelo de User que tenga un username , email y pertenezca a una School , escriba lo siguiente

rails generate model User username:string email:string school:belongs_to

rails g son taquigrafía para rails generate . Esto produciría el mismo resultado.

rails g model User username:string email:string school:belongs_to

Rails Generar Migración

Puede generar un archivo de migración de rieles desde el terminal usando el siguiente comando:

rails generate migration NAME [field[:type][:index] field[:type][:index]] [options]

Para obtener una lista de todas las opciones admitidas por el comando, puede ejecutar el comando sin ningún argumento, ya que los rails generate migration .

Por ejemplo, si desea agregar first_name y last_name campos a users la tabla, que puede hacer:

rails generate migration AddNamesToUsers last_name:string first_name:string

Rails creará el siguiente archivo de migración:

class AddNamesToUsers < ActiveRecord::Migration[5.0]
  def change
    add_column :users, :last_name, :string
    add_column :users, :first_name, :string
  end
end

Ahora, aplique las migraciones pendientes a la base de datos ejecutando lo siguiente en el terminal:

rake db:migrate

rails db:migrate

Nota: Para escribir menos, puede reemplazar generate con g .

Rieles Generan Andamios

NEGACIÓN DE RESPONSABILIDAD : No se recomienda el uso de andamios a menos que sea para aplicaciones / pruebas CRUD muy convencionales. Esto puede generar una gran cantidad de archivos (vistas / modelos / controladores) que no son necesarios en su aplicación web, causando así dolores de cabeza (mal :().

Para generar un andamio en pleno funcionamiento para un nuevo objeto, incluidos el modelo, el controlador, las vistas, los activos y las pruebas, use el comando rails g scaffold .

$ rails g scaffold Widget name:string price:decimal
    invoke  active_record
    create    db/migrate/20160722171221_create_widgets.rb
    create    app/models/widget.rb
    invoke    test_unit
    create      test/models/widget_test.rb
    create      test/fixtures/widgets.yml
    invoke  resource_route
     route    resources :widgets
    invoke  scaffold_controller
    create    app/controllers/widgets_controller.rb
    invoke    erb
    create      app/views/widgets
    create      app/views/widgets/index.html.erb
    create      app/views/widgets/edit.html.erb
    create      app/views/widgets/show.html.erb
    create      app/views/widgets/new.html.erb
    create      app/views/widgets/_form.html.erb
    invoke    test_unit
    create      test/controllers/widgets_controller_test.rb
    invoke    helper
    create      app/helpers/widgets_helper.rb
    invoke    jbuilder
    create      app/views/widgets/index.json.jbuilder
    create      app/views/widgets/show.json.jbuilder
    invoke  assets
    invoke    javascript
    create      app/assets/javascripts/widgets.js
    invoke    scss
    create      app/assets/stylesheets/widgets.scss

Luego puede ejecutar rake db:migrate para configurar la tabla de la base de datos.

Luego puede visitar http: // localhost: 3000 / widgets y verá un andamio CRUD completamente funcional.

Rails Generate Controller

Podemos crear un nuevo controlador con el comando rails g controller .

$ bin/rails generate controller controller_name

El generador del controlador espera parámetros en forma de generate controller ControllerName action1 action2 .

Lo siguiente crea un controlador de saludos con una acción de hola.

$ bin/rails generate controller Greetings hello

Verás la siguiente salida.

     create  app/controllers/greetings_controller.rb
      route  get "greetings/hello"
     invoke  erb
     create    app/views/greetings
     create    app/views/greetings/hello.html.erb
     invoke  test_unit
     create    test/controllers/greetings_controller_test.rb
     invoke  helper
     create    app/helpers/greetings_helper.rb
     invoke  assets
     invoke    coffee
     create      app/assets/javascripts/greetings.coffee
     invoke    scss
     create      app/assets/stylesheets/greetings.scss

Esto genera lo siguiente

También agregará rutas para cada acción en routes.rb