path: root/railties/doc/guides/source/command_line.txt

A Guide to The Rails Command Line
=================================

Rails comes with every command line tool you'll need to

* Create a Rails application
* Generate models, controllers, database migrations, and unit tests
* Start a development server
* Mess with objects through an interactive shell
* Profile and benchmark your new creation
 
... and much, much more! (Buy now!)

This tutorial assumes you have basic Rails knowledge from reading the Getting Started with Rails Guide.

== Command Line Basics ==

There are a few commands that are absolutely critical to your everyday usage of Rails. In the order of how much you'll probably use them are:

* console
* server
* rake
* generate
* rails
 
Let's create a simple Rails application to step through each of these commands in context.

=== rails ===

The first thing we'll want to do is create a new Rails application by running the `rails` command after installing Rails.

NOTE: You know you need the rails gem installed by typing `gem install rails` first, right? Okay, okay, just making sure.

[source,shell]
------------------------------------------------------
$ rails commandsapp

     create  
     create  app/controllers
     create  app/helpers
     create  app/models
     ...
     ...
     create  log/production.log
     create  log/development.log
     create  log/test.log
------------------------------------------------------

Rails will set you up with what seems like a huge amount of stuff for such a tiny command! You've got the entire Rails directory structure now with all the code you need to run our simple application right out of the box.

NOTE: This output will seem very familiar when we get to the `generate` command. Creepy foreshadowing!

=== server ===

Let's try it! The `server` command launches a small web server written in Ruby named WEBrick which was also installed when you installed Rails. You'll use this any time you want to view your work through a web browser.

NOTE: WEBrick isn't your only option for serving Rails. We'll get to that in a later section. [XXX: which section]

Here we'll flex our `server` command, which without any prodding of any kind will run our new shiny Rails app:

[source,shell]
------------------------------------------------------
$ cd commandsapp
$ ./script/server
=> Booting WEBrick...
=> Rails 2.2.0 application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2008-11-04 10:11:38] INFO  WEBrick 1.3.1
[2008-11-04 10:11:38] INFO  ruby 1.8.5 (2006-12-04) [i486-linux]
[2008-11-04 10:11:38] INFO  WEBrick::HTTPServer#start: pid=18994 port=3000
------------------------------------------------------

WHOA. With just three commands we whipped up a Rails server listening on port 3000. Go! Go right now to your browser and go to http://localhost:3000. I'll wait.

See? Cool! It doesn't do much yet, but we'll change that.

=== generate ===

The `generate` command uses templates to create a whole lot of things. You can always find out what's available by running `generate` by itself. Let's do that:

[source,shell]
------------------------------------------------------
$ ./script/generate
Usage: ./script/generate generator [options] [args]

...
...

Installed Generators
  Builtin: controller, integration_test, mailer, migration, model, observer, performance_test, plugin, resource, scaffold, session_migration

...
...
------------------------------------------------------

NOTE: You can install more generators through generator gems, portions of plugins you'll undoubtedly install, and you can even create your own!

Using generators will save you a large amount of time by writing *boilerplate code* for you -- necessary for the darn thing to work, but not necessary for you to spend time writing. That's what we have computers for, right?

Let's make our own controller with the controller generator. But what command should we use? Let's ask the generator:

NOTE: All Rails console utilities have help text. For commands that require a lot of input to run correctly, you can try the command without any parameters (like `rails` or `./script/generate`). For others, you can try adding `--help` or `-h` to the end, as in `./script/server --help`.

[source,shell]
------------------------------------------------------
$ ./script/generate controller
Usage: ./script/generate controller ControllerName [options]

...
...

Example:
    `./script/generate controller CreditCard open debit credit close`

    Credit card controller with URLs like /credit_card/debit.
        Controller: app/controllers/credit_card_controller.rb
        Views:      app/views/credit_card/debit.html.erb [...]
        Helper:     app/helpers/credit_card_helper.rb
        Test:       test/functional/credit_card_controller_test.rb

Modules Example:
    `./script/generate controller 'admin/credit_card' suspend late_fee`

    Credit card admin controller with URLs /admin/credit_card/suspend.
        Controller: app/controllers/admin/credit_card_controller.rb
        Views:      app/views/admin/credit_card/debit.html.erb [...]
        Helper:     app/helpers/admin/credit_card_helper.rb
        Test:       test/functional/admin/credit_card_controller_test.rb
------------------------------------------------------

Ah, the controller generator is expecting parameters in the form of `generate controller ControllerName action1 action2`. Let's make a `Greetings` controller with an action of *hello*, which will say something nice to us.

[source,shell]
------------------------------------------------------
$ ./script/generate controller Greeting hello
     exists  app/controllers/
     exists  app/helpers/
     create  app/views/greeting
     exists  test/functional/
     create  app/controllers/greetings_controller.rb
     create  test/functional/greetings_controller_test.rb
     create  app/helpers/greetings_helper.rb
     create  app/views/greetings/hello.html.erb
------------------------------------------------------

Look there! Now what all did this generate? It looks like it made sure a bunch of directories were in our application, and created a controller file, a functional test file, a helper for the view, and a view file.

Let's check out the controller and modify it a little (in `app/controllers/greeting_controller.rb`):

[source,ruby]
------------------------------------------------------
class GreetingController < ApplicationController
  def hello
    @message = "Hello, how are you today? I am exuberant!"
  end

end
------------------------------------------------------

Then the view, to display our nice message (in `app/views/greeting/hello.html.erb`):

[source,html]
------------------------------------------------------
<h1>A Greeting for You!</h1>
<p><%= @message %></p>
------------------------------------------------------

Deal. Go check it out in your browser. Fire up your server. Remember? `./script/server` at the root of your Rails application should do it.

[source,shell]
------------------------------------------------------
$ ./script/server
=> Booting WEBrick...
------------------------------------------------------

The URL will be `http://localhost:3000/greetings/hello`. I'll wait for you to be suitably impressed.

NOTE: With a normal, plain-old Rails application, your URLs will generally follow the pattern of http://(host)/(controller)/(action), and a URL like http://(host)/(controller) will hit the *index* action of that controller.

"What about data, though?", you ask over a cup of coffee. Rails comes with a generator for data models too. Can you guess its generator name?

[source,shell]
------------------------------------------------------
$ ./script/generate model
Usage: ./script/generate model ModelName [field:type, field:type]

...

Examples:
    `./script/generate model account`

        creates an Account model, test, fixture, and migration:
            Model:      app/models/account.rb
            Test:       test/unit/account_test.rb
            Fixtures:   test/fixtures/accounts.yml
            Migration:  db/migrate/XXX_add_accounts.rb

    `./script/generate model post title:string body:text published:boolean`

        creates a Post model with a string title, text body, and published flag.
------------------------------------------------------

Let's set up a simple model called "HighScore" that will keep track of our highest score on video games we play. Then we'll wire up our controller and view to modify and list our scores.

[source,shell]
------------------------------------------------------
$ ./script/generate model HighScore id:integer game:string score:integer
      exists  app/models/
      exists  test/unit/
      exists  test/fixtures/
      create  app/models/high_score.rb
      create  test/unit/high_score_test.rb
      create  test/fixtures/high_scores.yml
      create  db/migrate
      create  db/migrate/20081126032945_create_high_scores.rb
------------------------------------------------------

Taking it from the top, we have the *models* directory, where all of your data models live. *test/unit*, where all the unit tests live (gasp! -- unit tests!), fixtures for those tests, a test, the *migrate* directory, where the database-modifying migrations live, and a migration to create the `high_scores` table with the right fields.

The migration requires that we *migrate*, that is, run some Ruby code (living in that `20081126032945_create_high_scores.rb`) to modify the schema of our database. Which database? The sqlite3 database that Rails will create for you when we run the `rake db:migrate` command. We'll talk more about Rake in-depth in a little while.

[source,shell]
------------------------------------------------------
$ rake db:migrate
(in /home/commandsapp)
==  CreateHighScores: migrating ===============================================
-- create_table(:high_scores)
   -> 0.0070s
==  CreateHighScores: migrated (0.0077s) ======================================
------------------------------------------------------

NOTE: Let's talk about unit tests. Unit tests are code that tests and makes assertions about code. In unit testing, we take a little part of code, say a method of a model, and test its inputs and outputs. Unit tests are your friend. The sooner you make peace with the fact that your quality of life will drastically increase when you unit test your code, the better. Seriously. We'll make one in a moment.

Yo! Let's shove a small table into our greeting controller and view, listing our sweet scores.

[source,ruby]
------------------------------------------------------
class GreetingController < ApplicationController
  def hello
    if request.post?
      score = HighScore.new(params[:high_score])
      if score.save
        flash[:notice] = "New score posted!"
      end
    end
    
    @scores = HighScore.find(:all)
  end

end
------------------------------------------------------

XXX: Go with scaffolding instead, modifying greeting controller for high scores seems dumb.