Hey all,

For the past year or so I've been working on a static code analysis
tool/linter for Ruby (and written in Ruby) and it's finally starting to
shape up nicely. I've now reached this point where I'm happy with the
internals (at least for now) and just need to test the heck out of it
using real world code.

Of course I have quite a bit of code at my disposal myself but I'd
really appreciate it if other people could also give it a spin to see if
it works, what could be added/changed, etc. As such I'd like to request
those that are interested to give it a try.

To install it run the following Gem command:

    gem install ruby-lint -v 0.0.4

You can analyze a set of files by running the following:

    ruby-lint file1.rb file2.rb # and so on

The repository (and corresponding issue tracker) can be found at
https://github.com/YorickPeterse/ruby-lint.

There are two things I'm primarily interested in:

* Feature requests (there's only so much I can come up with myself)
* Bugs

In case of the latter I would also greatly appreciate it if people could
provide some sample code as this make it a lot easier for me to solve
the problem.

## Background Information

About a year ago I started working on this project out of frustration of
decent tools for the Ruby ecosystem that would help you with debugging
problems or even better, spotting them before they occur (whenever
possible). As a result "ruby-lint" was born.

The architecture is a bit crazy and has gone through quite a few changes
in the last few months. For example, initially I used a home grown
parser based on Ripper but recently replaced this with the "parser" Gem.
I intend to do a writeup on the architecture in the near future so if
you're interested in that stay tuned.

At the time of writing there's only one similar tool that I know of:
rubocop. Although rubocop and ruby-lint are similar they are also quite
different in many cases. Where rubocop focuses more on style related
issues (e.g. adding warnings when camelCase is used for methods)
ruby-lint focuses more on logic problems (e.g. calling a method without
the required amount of arguments). Both are competitors as well as
complementary tools.

Although ruby-lint does provide some basic style checking (e.g. it adds
warnings when you use "then" for an if statement) I intend to keep this
to a minimum, it mostly serves as an example to show that it's fairly
easy to write this kind of analysis code.

Thanks!

Yorick