ruby-lint 0.0.1a

data/.gitignore

@@ -0,0 +1,5 @@
+doc/build/*
+!doc/build/.gitkeep
+
+pkg
+Gemfile.lock

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p194

data/.yardopts

@@ -0,0 +1,10 @@
+./lib/rlint/**/*.rb ./lib/rlint.rb
+-m markdown
+-M redcarpet
+-o ./doc/build
+-r ./README.md
+--private
+--protected
+--asset ./doc/css/common.css:css/common.css
+-
+LICENSE

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012, Yorick Peterse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/MANIFEST

@@ -0,0 +1,79 @@
+.gitignore
+.rbenv-version
+.yardopts
+Gemfile
+LICENSE
+MANIFEST
+README.md
+Rakefile
+bin/rlint
+doc/.gitkeep
+doc/build/.gitkeep
+doc/css/.gitkeep
+doc/css/common.css
+lib/rlint.rb
+lib/rlint/analyze/coding_style.rb
+lib/rlint/analyze/definitions.rb
+lib/rlint/analyze/method_validation.rb
+lib/rlint/analyze/shadowing_variables.rb
+lib/rlint/analyze/undefined_variables.rb
+lib/rlint/analyze/unused_variables.rb
+lib/rlint/callback.rb
+lib/rlint/cli.rb
+lib/rlint/constant_importer.rb
+lib/rlint/definition.rb
+lib/rlint/formatter/text.rb
+lib/rlint/helper/definition_resolver.rb
+lib/rlint/helper/scoping.rb
+lib/rlint/iterator.rb
+lib/rlint/options.rb
+lib/rlint/parser.rb
+lib/rlint/parser_error.rb
+lib/rlint/report.rb
+lib/rlint/token/assignment_token.rb
+lib/rlint/token/begin_rescue_token.rb
+lib/rlint/token/block_token.rb
+lib/rlint/token/case_token.rb
+lib/rlint/token/class_token.rb
+lib/rlint/token/method_definition_token.rb
+lib/rlint/token/method_token.rb
+lib/rlint/token/parameters_token.rb
+lib/rlint/token/regexp_token.rb
+lib/rlint/token/statement_token.rb
+lib/rlint/token/token.rb
+lib/rlint/token/variable_token.rb
+lib/rlint/version.rb
+ruby-lint.gemspec
+spec/benchmarks/memory.rb
+spec/benchmarks/parse_parser.rb
+spec/helper.rb
+spec/rlint/analyze/coding_style.rb
+spec/rlint/analyze/definitions/classes.rb
+spec/rlint/analyze/definitions/methods.rb
+spec/rlint/analyze/definitions/modules.rb
+spec/rlint/analyze/definitions/variables.rb
+spec/rlint/analyze/method_validation.rb
+spec/rlint/analyze/shadowing_variables.rb
+spec/rlint/analyze/undefined_variables.rb
+spec/rlint/analyze/unused_variables.rb
+spec/rlint/callback.rb
+spec/rlint/constant_importer.rb
+spec/rlint/definition.rb
+spec/rlint/formatter/text.rb
+spec/rlint/iterator.rb
+spec/rlint/parser/arrays.rb
+spec/rlint/parser/classes.rb
+spec/rlint/parser/errors.rb
+spec/rlint/parser/hashes.rb
+spec/rlint/parser/methods.rb
+spec/rlint/parser/modules.rb
+spec/rlint/parser/objects.rb
+spec/rlint/parser/operators.rb
+spec/rlint/parser/procs.rb
+spec/rlint/parser/ranges.rb
+spec/rlint/parser/regexp.rb
+spec/rlint/parser/scalars.rb
+spec/rlint/parser/statements.rb
+spec/rlint/parser/variables.rb
+spec/rlint/report.rb
+task/test.rake

data/README.md

@@ -0,0 +1,48 @@
+# README
+
+**Rlint is currently alpha quality, expect things to break and change without
+notice. Patches and bug reports are more than welcome.**
+
+Rlint (short name for Ruby Lint) is a linter and static code analysis tool for
+Ruby inspired by similar tools such as JSHint. It makes it possible for
+developers to detect errors such as undefined (or unused) variables and the
+use of non existing methods.
+
+## Requirements
+
+* Ruby 1.9 or newer
+* Ripper (comes bundled with Ruby 1.9)
+
+## Installation
+
+Rlint can be installed by running the following command:
+
+    $ gem install ruby-lint
+
+Please note that there already is an existing gem called "rlint". This Gem is
+**not** the same, it just happens to be a similar project (one that seems
+abandoned) that uses the same name.
+
+## Compatibility Issues
+
+Currently Rlint can only be executed using MRI 1.9.3, it does not run on MRI
+1.8.x due to the lack of Ripper. It also does not yet run without errors on
+MRI 2.0 as the addition of named variables changes the Ripper output, something
+Rlint doesn't properly handle at the moment.
+
+For the time being Rlint will stick to using Ripper which means it's also
+limited to MRI 1.9.x/2.0.x. I've been looking around for alternatives so that
+Rlint can be run on Jruby/Rubinius in the future but so far I haven't really
+found a worthy alternative. For now I'd rather focus on making Rlint work on
+one implementation instead of a number of different ones.
+
+Also keep in mind that while in theory Rlint should run on MRI 1.8.x I couldn't
+get the "ripper" gem to install properly, thus I'm unable to confirm this. Feel
+free to try it out but I won't bother with MRI 1.8.x myself if it requires more
+than a few minutes worth of work.
+
+## License
+
+All source code in this repository is licensed under the MIT license unless
+specified otherwise. A copy of this license can be found in the file "LICENSE"
+in the root directory of this repository.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems/package_task'
+
+GEMSPEC = Gem::Specification.load('ruby-lint.gemspec')
+
+Dir['./task/*.rake'].each do |task|
+  import(task)
+end
+
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+  pkg.need_tar = false
+  pkg.need_zip = false
+end
+
+task :default => :test

data/bin/rlint

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/rlint', __FILE__)
+require 'rlint/cli'
+
+Rlint::CLI.new.run

data/doc/css/common.css

@@ -0,0 +1,68 @@
+body
+{
+    font-size:   14px;
+    line-height: 1.6;
+    margin:      0 auto;
+    max-width:   960px;
+}
+
+p code
+{
+    background:    #f2f2f2;
+    padding-left:  3px;
+    padding-right: 3px;
+}
+
+pre.code
+{
+    font-size:   13px;
+    line-height: 1.4;
+}
+
+/**
+ * YARD uses generic table styles, using a special class means those tables
+ * don't get messed up.
+ */
+.table
+{
+    border:          1px solid #ccc;
+    border-right:    none;
+    border-collapse: separate;
+    border-spacing:  0;
+    text-align:      left;
+}
+
+.table.full
+{
+    width: 100%;
+}
+
+    .table .field_name
+    {
+        min-width: 160px;
+    }
+
+    .table thead tr th.no_sort:first-child
+    {
+        width: 25px;
+    }
+
+    .table thead tr th, .table tbody tr td
+    {
+        border-bottom:  1px solid #ccc;
+        border-right:   1px solid #ccc;
+        min-width:      20px;
+        padding:        8px 5px;
+        text-align:     left;
+        vertical-align: top;
+    }
+
+    .table tbody tr:last-child td
+    {
+        border-bottom: none;
+    }
+
+    .table tr:nth-child(odd) td
+    {
+        background: #f9f9f9;
+    }

data/lib/rlint/analyze/coding_style.rb

@@ -0,0 +1,407 @@
+module Rlint
+  module Analyze
+    ##
+    # {Rlint::Analyze::CodingStyle} checks if a block of code matches a given
+    # set of coding standards. While none of the problems found by this class
+    # are considered harmful they are usually frowned upon as they do not
+    # follow the unofficial but generally accepted Ruby coding standards.
+    #
+    # ## Standards References
+    #
+    # The following was used to determine the standards this class should
+    # assume to be correct:
+    #
+    # * https://github.com/styleguide/ruby
+    # * https://github.com/bbatsov/ruby-style-guide
+    # * http://confluence.jetbrains.net/display/RUBYDEV/RubyMine+Inspections
+    # * My own opinion
+    #
+    # ## Checks
+    #
+    # This class checks for the following:
+    #
+    # * The length of method and variable names, should be less than the value
+    #   set in {Rlint::Analyze::CodingStyle::MAXIMUM\_NAME\_LENGTH}.
+    # * The use of class variables (it's relatively rare that you actually need
+    #   those).
+    # * The use of parenthesis around various statements: these are not needed
+    #   in Ruby.
+    # * The use of camelCase for method and variable names instead of
+    #   `snake_case`, the latter is what Ruby code should use.
+    # * Whether or not predicate methods are named correctly.
+    # * If a particular method name should be replaced by a different one (e.g.
+    #   "map" instead of "collect").
+    #
+    class CodingStyle < Rlint::Callback
+      ##
+      # A short description of this class.
+      #
+      # @return [String]
+      #
+      DESCRIPTION = 'Checks the coding style of a block of code.'
+
+      ##
+      # The maximum length for method and variable names.
+      #
+      # @return [Fixnum]
+      #
+      MAXIMUM_NAME_LENGTH = 30
+
+      ##
+      # Hash containing the names of method names and the names that should be
+      # used instead.
+      #
+      # @return [Hash]
+      #
+      RECOMMENDED_METHOD_NAMES = {
+        'collect'  => 'map',
+        'detect'   => 'find',
+        'find_all' => 'select',
+        'inject'   => 'reduce',
+        'length'   => 'size'
+      }
+
+      ##
+      # @see Rlint::Callback#initialize
+      #
+      def initialize(*args)
+        super
+
+        @in_method        = false
+        @predicate_method = false
+      end
+
+      ##
+      # Called when an instance variable is found.
+      #
+      # The following checks are run for instance variables:
+      #
+      # * Whether or not instance variables are `snake_cased` instead of
+      #   camelCased.
+      # * Whether or not the length of an instance variable is smaller than the
+      #   value defined in {Rlint::Analyze::CodingStyle::MAXIMUM\_NAME\_LENGTH}.
+      #
+      # @param [Rlint::Token::VariableToken] token The token containing details
+      #  about the variable.
+      #
+      def on_instance_variable(token)
+        validate_name(token)
+      end
+
+      ##
+      # Called when a class variable is found.
+      #
+      # This method will check for the same things as
+      # {Rlint::Analyze::CodingStyle#on_instance_variable} along with adding an
+      # info message about class variables being discouraged.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_instance_variable
+      #
+      def on_class_variable(token)
+        validate_name(token)
+
+        info(
+          'the use of class variables is discouraged',
+          token.line,
+          token.column
+        )
+      end
+
+      ##
+      # Called when a constant is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_instance_variable
+      #
+      def on_constant(token)
+        validate_name_length(token)
+      end
+
+      ##
+      # Called when a global variable is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_instance_variable
+      #
+      def on_global_variable(token)
+        validate_name(token)
+      end
+
+      ##
+      # Called when an instance variable is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_instance_variable
+      #
+      def on_local_variable(token)
+        validate_name(token)
+      end
+
+      ##
+      # Called when a value is assigned.
+      #
+      # This method checks for the name of the used variable (similar to
+      # instance variables) as well as adding a warning when an instance
+      # variable is assigned.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_instance_variable
+      # @see Rlint::Analyze::CodingStyle#on_class_variable
+      #
+      def on_assignment(token)
+        validate_name(token)
+
+        if token.type == :class_variable
+          info(
+            'the use of class variables is discouraged',
+            token.line,
+            token.column
+          )
+        end
+      end
+
+      ##
+      # Called when a return statement is found.
+      #
+      # @param [Rlint::Token::StatementToken] token The token of the return
+      #  statement.
+      #
+      def on_return(token)
+        if !token.value or token.value.empty? or !@in_method
+          return
+        end
+
+        token.value.each do |value|
+          # TODO: this probably won't work very well if there's a lambda inside
+          # a method that returns `true` or `false`.
+          if value.type == :keyword \
+          and (value.name == 'true' or value.name == 'false')
+            @predicate_method = true
+
+            break
+          end
+        end
+      end
+
+      ##
+      # Called when a method is defined. This method validates the name similar
+      # to instance variables as well as checking if the method definition
+      # modifies a core Ruby constant.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_instance_variable
+      #
+      def on_method_definition(token)
+        validate_name(token)
+
+        if token.receiver
+          validate_ruby_constant_modification(token.receiver)
+        end
+
+        @in_method = true
+      end
+
+      ##
+      # Called when a class is created. This callback adds a warning if a core
+      # Ruby constant is modified.
+      #
+      # @param [Rlint::Token::ClassToken] token Token class containing details
+      #  about the newly created class.
+      #
+      def on_class(token)
+        validate_ruby_constant_modification(token)
+      end
+
+      ##
+      # Called after a method token has been processed. This callback checks if
+      # a method is a predicate method and if so if the name is set correctly.
+      #
+      # @param [Rlint::Token::MethodDefinitionToken] token The token containing
+      #  details about the method definition.
+      # @todo This method currently only performs a very limited check for
+      #  predicate methods. Once a proper scoping system has been implemented
+      #  this method should be updated accordingly.
+      #
+      def after_method_definition(token)
+        if @predicate_method and token.name !~ /\?$/
+          info(
+            'predicate methods should end with a question mark',
+            token.line,
+            token.column
+          )
+        end
+
+        @in_method        = false
+        @predicate_method = false
+      end
+
+      ##
+      # Called when a method call is found.
+      #
+      # This method checks if the used method should be named differently
+      # instead (e.g. "map" instead of "collect").
+      #
+      # @param [Rlint::Token::MethodToken] token Token containing details about
+      #  the method.
+      #
+      def on_method(token)
+        if RECOMMENDED_METHOD_NAMES.key?(token.name)
+          recommended = RECOMMENDED_METHOD_NAMES[token.name]
+
+          info(
+            'it is recommended to use the method "%s" instead of "%s"' % [
+              recommended,
+              token.name
+            ],
+            token.line,
+            token.column
+          )
+        end
+      end
+
+      ##
+      # Called when an if statement is found.
+      #
+      # This method checks to see if there are any parenthesis around the
+      # statement and adds an info message if this is the case.
+      #
+      # @param [Rlint::Token::StatementToken] token The token containing
+      #  details about the if statement.
+      #
+      def on_if(token)
+        validate_parenthesis(token)
+      end
+
+      ##
+      # Called when an elsif statement is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_if
+      #
+      def on_elsif(token)
+        validate_parenthesis(token)
+      end
+
+      ##
+      # Called when a while statement is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_if
+      #
+      def on_while(token)
+        validate_parenthesis(token)
+      end
+
+      ##
+      # Called when a case statement is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_if
+      #
+      def on_case(token)
+        validate_parenthesis(token)
+      end
+
+      ##
+      # Called when a when statement is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_if
+      #
+      def on_when(token)
+        validate_parenthesis(token)
+      end
+
+      ##
+      # Called when an until statement is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_if
+      #
+      def on_until(token)
+        validate_parenthesis(token)
+      end
+
+      ##
+      # Called when an unless statement is found.
+      #
+      # @see Rlint::Analyze::CodingStyle#on_if
+      #
+      def on_unless(token)
+        validate_parenthesis(token)
+      end
+
+      private
+
+      ##
+      # Validates the name of the specified token. This method will check for
+      # the use of camelCase as well as checking for the length of the name.
+      #
+      # @param [Rlint::Token::Token] token The token to validate.
+      #
+      def validate_name(token)
+        if !token.respond_to?(:name) or !token.name
+          return
+        end
+
+        if token.name =~ /[a-z]+[A-Z]+/
+          info(
+            'the use of camelCase for names is discouraged',
+            token.line,
+            token.column
+          )
+        end
+
+        validate_name_length(token)
+      end
+
+      ##
+      # Checks if the name of the given token is too long or not. The maximum
+      # length of names is set in
+      # {Rlint::Analyze::CodingStyle::MAXIMUM\_NAME\_LENGTH}.
+      #
+      # @param [Rlint::Token::Token] token The token to validate.
+      #
+      def validate_name_length(token)
+        if !token.respond_to?(:name) or !token.name
+          return
+        end
+
+        if token.name.length > MAXIMUM_NAME_LENGTH
+          info(
+            "method and variable names should not be longer than " \
+              "#{MAXIMUM_NAME_LENGTH} characters",
+            token.line,
+            token.column
+          )
+        end
+      end
+
+      ##
+      # Checks if there are any parenthesis wrapped around a statement.
+      #
+      # @param [Rlint::Token::Token] token The token to validate.
+      #
+      def validate_parenthesis(token)
+        if token.code =~ /#{token.type}\s*\(/
+          info(
+            'the use of parenthesis for statements is discouraged',
+            token.line,
+            token.column
+          )
+        end
+      end
+
+      ##
+      # Adds a warning for modifying a core Ruby constant.
+      #
+      # @param [Rlint::Token::Token] token The token class to validate.
+      #
+      def validate_ruby_constant_modification(token)
+        if token.name.is_a?(Array)
+          name = token.name.join('::')
+        else
+          name = token.name
+        end
+
+        if Object.constants.include?(name.to_sym)
+          warning(
+            'modification of a core Ruby constant',
+            token.line,
+            token.column
+          )
+        end
+      end
+    end # CodingStyle
+  end # Analyze
+end # Rlint