Where can I find an actively developed lint tool for Ruby?

Question

Most of the code I write is in Ruby, and every once in a while, I make some typo which only gets caught after a while. This is irritating when I have my scripts running long

Answer 1

• 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)

Answer 2

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!

Answer 3

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.

Answer 4

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

Answer 5

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.

Answer 6

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