You could give Diamondback Ruby a try. It does a static typecheck of Ruby code, and will thus blame you for using an undefined variable.

While DRuby is an ongoing research project, it already works quite well for small, self-contained Ruby scripts. Currently, it is unable to analyze much of the Ruby standard library “out-of-the-box”. Currently they are working toward typing Ruby on Rails (see their most recent papers).

• ruby -c myfile.rb will check for correct Ruby syntax.
• Reek checks Ruby code for common code smells.
• Roodi checks Ruby code for common object-oriented design issues.
• Flog can warn you about unusually complex code.

[Plug] If your project is in a public Github repository, Caliper can run the latter three tools and others on your code every time you commit. (Disclaimer: I work on Caliper)

RubyMine (http://www.jetbrains.com/ruby) does the trick:

alt text http://img707.imageshack.us/img707/5688/31911448.png

None of the below will do all the analysis that RubyMine does.

• NetBeans Ruby pack
• Aptana RadRails
• gVIM (with syntastic plugin by scrooloose)

Each of these has the capacity to identify syntax errors such as wrong number of parentheses, too many defs, ends, braces, etc. But none will identify invalid method calls the way RubyMine does.

Here s why: it s difficult.

Since Ruby is extremely dynamic (and methods like c could easily be generated on the fly), any editor that tries to identify non-existent variables/methods would need to have a large part of the entire evironment loaded and multiple program flow paths constantly tested in order to get accurate validity results. This is much more difficult than in Java where almost all programming is static (at least it was when I dropped that hat).

This ability to easily generate methods on the fly is one of the reasons the community holds testing to such high esteem. I really do reccomend you try testing as well.

Have a look at RuboCop. It is a Ruby code style checker based on the Ruby Style Guide. It s maintained pretty actively and supports all major Ruby implementations. It works well with Ruby 1.9 and 2.0 and has great Emacs integration.

Yes. Test::Unit

Ok, I know you already know this and that in some sense this is a non-helpful answer, but you do bring up the negative consequence of duck typing, that there kind of is (at this time) no way around just writing more tests than something like Java might need.

So, for the record, see Test::Unit in the Ruby Standard Library or one of the other test frameworks.

Having unit tests that you can run and rerun is the best way to catch errors, and you do need more of them (tests, not errors :-) in dynamic languages like Ruby...

nitpick might be what you re lookng for.

With this code:

class MyString < String
  def awesome
    self.gsub("e", "3").gsub("l", "1").uppercase
  end
end

puts MyString.new("leet").awesome

... it outputs:

$ nitpick misspelling.rb 
*** Nitpick had trouble loading "misspelling.rb":
    NoMethodError undefined method `uppercase  for "133t":MyString
Nothing to report boss! He s clean!

Have not used it yet, but sounds promising (will update when I ve tested this).

https://github.com/michaeledgar/laser

Static analysis and style linter for Ruby code.

Pelusa is nice, but is working in rubinius only. This shouln t be a proplem for people familar with RVM though.

avdi@lazarus:~$ irb
>> a = 20
=> 20
>> b = 30
=> 30
>> puts c
NameError: undefined local variable or method `c  for main:Object
        from (irb):3
>>

There ya go, the tool is called "IRB". Do I get the bounty?

I m only half joking. I wrote this second answer to hopefully drive home the point that in Ruby, if you want to know that something is defined or not, you have to run the code.