Windows developers are used to having powerful IDEs to help them build their applications. I used to live and die by the line-by-line breakpointer, and I was surprised by the lack of any similar debugging tools for Rails. However, after working with Rails for a month, I learned an important lesson: you just don't need them.
Rails developers typically do test-driven development, so they're writing their unit tests before they write their business rules. For example, if I were to write a keyword search method, I'd write a unit test first:
# Should find 2 because I have "red" in the test data in 2 records assert_equal(2, Document.find_by_keywords("red")
# should find 0 because that term isn't in any of the records assert_equal(2, Document.find_by_keywords("blue")
# should find 2 because the word "ninja" is found on one document # and 'pirate' is found in another. assert_equal(2, Document.find_by_keywords("ninja pirate")
If you notice, the test that I wrote gives me a clear indicator of what I need to code. It also gives me a chance to throw all sorts of stuff at my code to see how it will react later.
Unit testing can be difficult to grasp if you've never done it before. The hardest part is learning to write the tests first. If you can master that, you'll notice your need for debugging tools diminish quickly.
Still not convinced? Read on. There are a few built-in tools that you have at your disposal.
The Rails Console is an interactive command shell where you can access your models in real time. It's very handy during development because you can use it to try some code out before you build it into your application.
The console is invoked from the command line by running
ruby scriptconsole
from your Rails application's directory. The console will start and notify you that it's running in Development mode, which means it's using your development database.
When it's done loading, you are presented with a simple prompt ( >> ) and you can begin working with your code.
I've got a simple Rails application that has Projects and Tasks. I can use the Console to manipulate my data.
I can create and save records:
>> project = Project.create(:name=>"Web Site")
=> #<Project:0x47be220 @new_record=false,
@new_record_before_save=true, @errors=#<ActiveRecord::Errors:0x47bd924
@errors={}, @base=#<Project:0x47be220 ...>>,
@attributes={"name"=>"Web Site", "id"=>1,
"description"=>nil}>
>> task = Task.create(:name=>"Design Logo",
:project => project)I can associate records:
>> project.tasks << Tasks.create(:name =>"Choose colors")
I can even retrieve records:
>> Project.find(1)
The console is great for trying out code, inspecting models, and testing code. It's not a replacement for proper unit tests but it is a really nice tool.
The breakpointer is a script you can use to connect to a running Rails application. It works very much like a breakpoint debugger in a traditional editor, although it's a little more limiting and a lot more flexible.
In your code, you add the keyword:
breakpoint
When that breakpoint is triggered, your application will appear to freeze up. Once it's frozen, you can start the breakpointer script to connect to your application and interactively debug everything, including the session. It basically attaches the Rails console command to your active application.
Invoke the breakpointer script by entering:
ruby scriptreakpointer
Once connected, you execute commands just like you would with the Rails Console, but you can also look at values in the request and session, just as if you were writing code in a controller.
>>session[:user_id] =>1 >>current_user.username => "hoganbp"
The breakpointer is something you won't use very often once you are comfortable writing integration, functional, or unit tests, but when you need it, it's extremely valuable.