How to use the command "rails generate" (with examples)

The “rails generate” command is a powerful tool in Ruby on Rails for generating new code structures within an existing project. It provides a way to easily create models, controllers, migrations, and scaffolds in Rails applications, saving precious development time.

Use case 1: List all available generators

Code:

rails generate

Motivation: It is important to know what generators are available in a Rails project. Listing all available generators can help developers quickly understand the available options and use them accordingly.

Explanation: Running the “rails generate” command without any arguments will list all the available generators in the project. These generators are responsible for creating different components of a Rails application, such as models, controllers, migrations, and scaffolds.

Example output:

Running via Spring preloader in process 12345
Available generators:
  Model
  Controller
  Scaffold
  Migration
  ...

Use case 2: Generate a new model named Post with attributes title and body

Code:

rails generate model Post title:string body:text

Motivation: Models are essential components in Rails applications that represent database tables. Generating a new model with attributes saves time by automatically creating the necessary files and code for the model, including database migrations.

Explanation: This command generates a new model named “Post” with two attributes: “title” of type string and “body” of type text. The generator creates a migration file to create the “posts” table in the database and adds columns for the specified attributes.

Example output:

Running via Spring preloader in process 12345
      invoke  active_record
      create    db/migrate/20211010123456_create_posts.rb
      create    app/models/post.rb
      invoke    rspec
      create      spec/models/post_spec.rb

Use case 3: Generate a new controller named Posts with actions index, show, new and create

Code:

rails generate controller Posts index show new create

Motivation: Controllers handle the logic and actions of the application, and generating new controllers with necessary actions saves time and reduces manual coding effort.

Explanation: This command generates a new controller named “Posts” with four actions: “index”, “show”, “new”, and “create”. The generator creates the necessary controller file and associated view files for each action.

Example output:

Running via Spring preloader in process 12345
      create  app/controllers/posts_controller.rb
       route  get 'posts/index'
       route  get 'posts/show'
       route  get 'posts/new'
       route  post 'posts/create'
      invoke  erb
      create    app/views/posts
      create    app/views/posts/index.html.erb
      create    app/views/posts/show.html.erb
      create    app/views/posts/new.html.erb
      create    app/views/posts/_form.html.erb

Use case 4: Generate a new migration that adds a category attribute to an existing model called Post

Code:

rails generate migration AddCategoryToPost category:string

Motivation: Migrations are used to modify the database schema. Generating a new migration allows developers to easily add new columns or modify existing columns in their models without manually editing the database schema file.

Explanation: This command generates a new migration file that adds a “category” attribute of type string to the existing “Post” model. It automatically creates the necessary migration file with the appropriate code to add the column to the “posts” table.

Example output:

Running via Spring preloader in process 12345
      invoke  active_record
      create    db/migrate/20211010203040_add_category_to_post.rb

Use case 5: Generate a scaffold for a model named Post, predefining the attributes title and body

Code:

rails generate scaffold Post title:string body:text

Motivation: Scaffolding is a powerful feature in Rails that automatically generates a full set of MVC components for a model, including views and controllers. Generating a scaffold for a model eliminates the need to manually create the associated files and code.

Explanation: This command generates a scaffold for the “Post” model with two attributes: “title” of type string and “body” of type text. It creates the necessary model, controller, migration, and view files for the scaffold, providing a fully functional CRUD interface for the “Post” model.

Example output:

Running via Spring preloader in process 12345
      invoke  active_record
      create    db/migrate/20211010210345_create_posts.rb
      create    app/models/post.rb
      invoke    rspec
      create      spec/models/post_spec.rb
       route  resources :posts
      invoke  scaffold_controller
      create    app/controllers/posts_controller.rb
      invoke    rspec
      create      spec/controllers/posts_controller_spec.rb
      invoke    erb
      create      app/views/posts
      create      app/views/posts/index.html.erb
      create      app/views/posts/edit.html.erb
      create      app/views/posts/show.html.erb
      create      app/views/posts/new.html.erb
      create      app/views/posts/_form.html.erb
      invoke    rspec
      create      spec/views/posts
      create      spec/views/posts/index.html.erb_spec.rb
      create      spec/views/posts/edit.html.erb_spec.rb
      create      spec/views/posts/show.html.erb_spec.rb
      create      spec/views/posts/new.html.erb_spec.rb
      create      spec/views/posts/_form.html.erb_spec.rb
      invoke  assets
       route  get 'posts/index'
       route  get 'posts/new'
       route  get 'posts/show'
       route  get 'posts/edit'
       route  get 'posts/delete'

Conclusion:

The “rails generate” command is a versatile tool in Ruby on Rails that simplifies the creation of new code structures within existing projects. With the provided use cases, developers can now utilize this powerful command to generate models, controllers, migrations, and scaffolds efficiently. By automating the generation process, developers can focus on implementing the application’s business logic rather than spending time on repetitive and manual code generation tasks.