Question

I’m working on the Rails guide now and am confused about the controller and scaffold. In the guide I saw two commands:

$ rails generate controller home index
$ rails generate scaffold Post name:string title:string content:text

I know the first line means it creates a home controller with an action index. However, I don’t quite understand what the practical meaning is here. Does it simply mean it will render a page with an address “home/index”?

For the second line, what I understand is it creates an app called Post with three parameters name, title, and content. I don’t know if it is correct and am wondering what scaffold actually means. The guide’s explanation is a bit ambiguous to me.

Thanks.

Answer 1

So, first, you should just run them. They’ll list the files they create and you can look at them.

The first one creates a controller named home (a piece of code for responding to web requests) with one action named index. An action is the combination of ant HTTP verb and a URL (in this case GET /home/index) that corresponds to a method in the controller. The generator also creates a dummy view for rendering that action, and some empty test and helper files. You can see that in what it prints:

  create  app/controllers/home_controller.rb
   route  get "home/index"
  invoke  erb
  create    app/views/home
  create    app/views/home/index.html.erb
  invoke  test_unit
  create    test/functional/home_controller_test.rb
  invoke  helper
  create    app/helpers/home_helper.rb
  invoke    test_unit
  create      test/unit/helpers/home_helper_test.rb
  invoke  assets
  invoke    coffee
  create      app/assets/javascripts/home.js.coffee
  invoke    scss
  create      app/assets/stylesheets/home.css.scss

Particularly useful is the controller:

class HomeController < ApplicationController
  def index
  end
end

You haven’t given Rails any information about what you want that action to do (you just said, “create a controller called ‘home’ with some action called ‘index'”), so it’s up to you to fill out that method. And you can see the URL info by invoking rake routes:

home_index GET /home/index(.:format) home#index

In other words, when you send a GET request to /home/index it calls HomeController#index. Since that method is empty and doesn’t tell Rails what to render, it will default to rendering the view at app/views/home/index.html.erb, which the generator also created and expects you to do something interesting with.

The second generator does a lot more. It creates a resource, which means a model that you store in the database and also a controller with simple CRUD actions and dummy views to manipulate that model. So in addition to the controller/view stuff above, it also creates an upgrade script to create the right table in the DB and a Ruby class that will serve as the model. Look particularly at the first two “create” items here, and load them up in your editor:

  invoke  active_record
  create    db/migrate/20130111151206_create_posts.rb
  create    app/models/post.rb
  invoke    test_unit
  create      test/unit/post_test.rb
  create      test/fixtures/posts.yml
  invoke  resource_route
   route    resources :posts
  invoke  scaffold_controller
  create    app/controllers/posts_controller.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    test_unit
  create      test/functional/posts_controller_test.rb
  invoke    helper
  create      app/helpers/posts_helper.rb
  invoke      test_unit
  create        test/unit/helpers/posts_helper_test.rb
  invoke  assets
  invoke    coffee
  create      app/assets/javascripts/posts.js.coffee
  invoke    scss
  create      app/assets/stylesheets/posts.css.scss
  invoke  scss
  create    app/assets/stylesheets/scaffolds.css.scss

You can see all the actions you can actually do, again by running rake routes:

     posts GET    /posts(.:format)          posts#index
           POST   /posts(.:format)          posts#create
  new_post GET    /posts/new(.:format)      posts#new
 edit_post GET    /posts/:id/edit(.:format) posts#edit
      post GET    /posts/:id(.:format)      posts#show
           PUT    /posts/:id(.:format)      posts#update
           DELETE /posts/:id(.:format)      posts#destroy

Finally, check out the controller code at app/controllers/PostsController.rb to see what these actions actually do (they’re a bit more interesting).