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.

1. 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.

1.1. rails

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

+ + + +

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

$ 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.

+ + + +

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

1.2. 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.

+ + + +

+ +	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:

$ 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.

1.3. 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:

$ ./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
+
+...
+...
+

+ + + +

+ +	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:

+ + + +

+ +	All Rails console utilities have help text. For commands that require a lot of input to run correctly, you can just 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`.

$ ./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.

$ ./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. All from one command!

+ +

Ruby on Rails

Sustainable productivity for web-application development

Chapters

A Guide to The Rails Command Line

1. Command Line Basics

1.1. rails

1.2. server

1.3. generate

2. Add a to_squawk method to String

2. Extending core classes

2.1. Working with init.rb

2.2. Creating the test

2.3. Organize your files

3. Add an acts_as_yaffle method to ActiveRecord

8. Odds and ends

8.1. Work with init.rb

8.2. Generate RDoc Documentation

8.1. Generate RDoc Documentation

8.3. Store models, views, helpers, and controllers in your plugins

8.2. Store models, views, helpers, and controllers in your plugins

8.4. Write custom Rake tasks in your plugin

8.3. Write custom Rake tasks in your plugin

8.5. Store plugins in alternate locations

8.4. Store plugins in alternate locations

8.6. Create your own Plugin Loaders and Plugin Locators

8.5. Create your own Plugin Loaders and Plugin Locators

8.7. Use Custom Plugin Generators

8.6. Use Custom Plugin Generators

9. Appendix

2. Before you Start Writing Tests

2. Introduction to Testing

2.1. The 3 Environments

2.3.1. What Are Fixtures?

2.3.2. YAML the Camel is a Mammal with Enamel

2.3.2. YAML

2.3.3. Comma Seperated

2.3.4. ERb'in It Up

2.3.3. ERb'in It Up

2.3.5. Fixtures in Action

2.3.4. Fixtures in Action

2.3.6. Hashes with Special Powers

2.3.5. Hashes with Special Powers

3.1.1. Rake Tasks for Preparing you Application for Testing ==

3.2. Running Tests

3.2. What to Include in Your Unit Tests

3.3. What to Include in Your Unit Tests

3.3. Assertions Available

3.4. Assertions Available

3.4. Rails Specific Assertions

3.5. Rails Specific Assertions

4.2. Available Request Types for Functional Tests

6. Testing Your Mailers

6. Rake Tasks for Running your Tests

7. Brief Note About Test::Unit

8. Setup and Teardown

9. Testing Routes

10. Testing Your Mailers

6.1. Keeping the Postman in Check

10.1. Keeping the Postman in Check

6.1.1. From All Sides

10.1.1. From All Sides

6.2. Unit Testing

10.2. Unit Testing

6.2.1. Revenge of the Fixtures

10.2.1. Revenge of the Fixtures

6.2.2. The Basic Test case

10.2.2. The Basic Test case

7. Rake Tasks for Testing

8. Other Testing Approaches

11. Other Testing Approaches

9. Changelog

12. Changelog

2. Add a `to_squawk` method to String

3. Add an `acts_as_yaffle` method to ActiveRecord