ruby-lint 0.0.2 → 0.0.3

data/Rakefile

@@ -1,4 +1,10 @@
+require File.expand_path('../lib/ruby-lint/extensions/string', __FILE__)
+require File.expand_path('../lib/ruby-lint/inspector', __FILE__)
+require File.expand_path('../lib/ruby-lint/definition_generator', __FILE__)
+
+require 'yaml'
 require 'rubygems/package_task'
+require 'digest/sha2'
 
 GEMSPEC = Gem::Specification.load('ruby-lint.gemspec')
 

data/bin/ruby-lint

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

data/doc/DCO.md

@@ -0,0 +1,26 @@
+# @title DCO
+# Developer's Certificate of Origin 1.0
+
+By making a contribution to this project, I certify that:
+
+1. The contribution was created in whole or in part by me and I
+   have the right to submit it under the open source license
+   indicated in the file LICENSE; or
+
+2. The contribution is based upon previous work that, to the best
+   of my knowledge, is covered under an appropriate open source
+   license and I have the right under that license to submit that
+   work with modifications, whether created in whole or in part
+   by me, under the same open source license (unless I am
+   permitted to submit under a different license), as indicated
+   in the file LICENSE; or
+
+3. The contribution was provided directly to me by some other
+   person who certified (1), (2) or (3) and I have not modified
+   it.
+
+4. I understand and agree that this project and the contribution
+   are public and that a record of the contribution (including all
+   personal information I submit with it, including my sign-off) is
+   maintained indefinitely and may be redistributed consistent with
+   this project or the open source license(s) involved.

data/doc/architecture.md

@@ -0,0 +1,63 @@
+# @title Architecture
+# Architecture
+
+The process of analysing Ruby source code is broken up into several separate
+steps. The basic flow of this process looks like the following:
+
+![ruby-lint flow](images/flow.png)
+
+Most third-party code will only deal with the last 3 steps.
+
+This chapter takes a brief look at the various parts that make up ruby-lint.
+Some of these parts are discussed more in depth in which case a link to these
+chapters can be found below.
+
+## The Parser
+
+The {RubyLint::Parser parser} converts raw Ruby source code into an AST. The
+AST is built up by nodes formatted as S expressions. A node for a simple String
+would look like the following:
+
+    (string "hello")
+
+Each node is an instance of {RubyLint::Node}. Each node can contain a number of
+child nodes. If one were to format the above S expression as an Array you'd get
+the following:
+
+    [:string, ["hello"]]
+
+For more information see the documentation of {RubyLint::Node} and the
+corresponding tests found in `spec/ruby-lint/parser/`.
+
+Currently the parser is based on Ripper, a library that comes with MRI 1.9 and
+newer. Because of this ruby-lint will be unable to support Rubinius and Jruby
+for the time being. In the future this parser will be replaced with something
+that runs on all the common Ruby implementations.
+
+## Definitions Builder
+
+The {RubyLint::DefinitionsBuilder definitions builder} iterates over the AST
+and evaluates it so that variables can be created, methods can be defined and
+so on. Once finished a single {RubyLint::Definition::RubyObject} definition is
+created that contains all the Ruby data of a block of Ruby code.
+
+One can see the definitions builder as a very basic virtual machine.
+
+## Analysis
+
+This is where the real work start. The analysis step consists out of various
+Ruby classes of which each performs its own type of analysis. For example,
+{RubyLint::Analyze::UndefinedMethods} checks for the use of undefined methods.
+
+## Reports
+
+Reports are used for storing a set of {RubyLint::Report::Entry} instances that
+contain information about a block of Ruby code that is being analyzed. Each
+entry contains some location information (line and column number for example)
+as well as a message (e.g. an error message).
+
+## Presenters
+
+Presenters are classes tasked with the job of presenting a report. Currently
+ruby-lint ships with a presenter that outputs a report in plain text as well as
+one that outputs a report in JSON.

data/doc/code_analysis.md

@@ -0,0 +1,90 @@
+# @title Code Analysis
+# Code Analysis
+
+Code analysis in ruby-lint is done using a set of classes that extend
+{RubyLint::Iterator}. This base class provides various methods for easily
+walking over an AST by using callback methods based on the node types. For
+example, the callback method `on_string` is used before a `(string)` node is
+processed. For more low level details see the API documentation of
+{RubyLint::Iterator}.
+
+For this guide we'll be creating an analysis class that checks for local
+variables written in camelCase. Whenever it finds these variables a warning
+will be added informing the developer that he/she should use snake\_case
+instead.
+
+At the most basic level this class looks like the following:
+
+    class CamelCaseVariables < RubyLint::Iterator
+
+    end
+
+By extending the base class your own class already comes with a method for
+walking the AST and calling callbacks as well as a few helper methods for
+adding errors and the likes.
+
+To use this class you'll have to create an instance of it and call
+{RubyLint::Iterator#iterate} and pass it an AST:
+
+    ast      = RubyLint::Parser.new('exampleNumber = 10').parse
+    iterator = CamelCaseVariables.new
+
+    iterator.iterate(ast)
+
+When running the above code you'll notice that nothing actually happens. This
+is because no callback methods have been added yet. There are two types of
+callback methods that can be added:
+
+* `on_X`
+* `after_X`
+
+Here X is the name of the node type. Methods that start with `on_` will be
+executed before any child nodes (of the current node) are processed.  Methods
+that start with `after_` will be executed after the node and its child nodes
+have been processed. Each callback method takes a single argument: an instance
+of {RubyLint::Node} containing information about the current node.
+
+In the above example we only need an `on_` callback:
+
+    class CamelCaseVariables < RubyLint::Iterator
+      def on_local_variable(node)
+        if node.name =~ /[a-z][A-Z]/
+          warning('use snake_case for local variables', node)
+        end
+      end
+    end
+
+If you now were to run the above it would technically work but still you won't
+see anything. This is because you also need to specify a {RubyLint::Report}
+instance to use for storing data such as warnings and error messages. This can
+be done as following:
+
+    report   = RubyLint::Report.new
+    iterator = CamelCaseVariables.new(:report => report)
+
+The last step is to actually display the report using a presenter. For this
+exercise we'll use {RubyLint::Presenter::Text}. Presenters are quite easy to
+use:
+
+    presenter = RubyLint::Presenter::Text.new
+
+    presenter.present(report)
+
+The full code of this exercise looks like the following:
+
+    class CamelCaseVariables < RubyLint::Iterator
+      def on_local_variable(node)
+        if node.name =~ /[a-z][A-Z]/
+          warning('use snake_case for local variables', node)
+        end
+      end
+    end
+
+    ast       = RubyLint::Parser.new('exampleNumber = 10').parse
+    report    = RubyLint::Report.new
+    iterator  = CamelCaseVariables.new(:report => report)
+    presenter = RubyLint::Presenter::Text.new
+
+    iterator.iterate(ast)
+
+    puts presenter.present(report)

data/doc/configuration.md

@@ -0,0 +1,86 @@
+# @title Configuration
+# Configuration
+
+The default configuration of ruby-lint should be suitable for most people.
+However, depending on your code base you may get an usual amount of false
+positives. In particular the class {RubyLint::Analyze::UndefinedMethods} can
+produce a lot of false positives.
+
+ruby-lint allows developers to customize the various parts of the tool such as
+what kind of messages to report and what types of analysis to run. This can be
+done in two different ways:
+
+1. Using CLI options
+2. Using a configuration file
+
+The first option is useful if you want to change something only once or if
+you're messing around with the various options. If you actually want your
+changes to stick around you'll want to use a configuration file instead.
+
+## File Locations
+
+When running the CLI ruby-lint will try to load one of the following two
+configuration files:
+
+* $PWD/ruby-lint.rb
+* $HOME/.ruby-lint.rb
+
+Here `$PWD` refers to the current working directory and `$HOME` to the user's
+home directory. If ruby-lint finds a configuration file in the current working
+directory the global one will *not* be loaded. This allows you to use project
+specific settings in combination with a global configuration file as a
+fallback.
+
+## Configuring ruby-lint
+
+The various configuration settings are set using plain old Ruby, there's no
+YAML nonsense that gets in your way.
+
+Configuration settings are stored in {RubyLint.configuration} (as an instance
+of {RubyLint::Configuration}). Although you can access this object directly in
+the form of `RubyLint.configuration.foo = :bar` it's recommended that you use
+{RubyLint.configure} instead since it provides a shorter and friendlier syntax.
+
+The boilerplate for configuring ruby-lint looks like the following:
+
+    RubyLint.configure do |config|
+
+    end
+
+To change the presenter to use you'd use the following:
+
+    RubyLint.configure do |config|
+      config.presenter = RubyLint::Presenter::JSON
+    end
+
+Changing the analysis classes is done as following:
+
+    RubyLint.configure do |config|
+      # Only use the two classes listed below.
+      config.analysis = [
+        RubyLint::Analysis::UndefinedVariables,
+        RubyLint::Analysis::ShadowingVariables
+      ]
+    end
+
+And changing the reporting levels:
+
+    RubyLint.configure do |config|
+      config.report_levels = [:error]
+    end
+
+Combined together this leads to the following configuration:
+
+    RubyLint.configure do |config|
+      config.presenter = RubyLint::Presenter::JSON
+
+      # Only use the two classes listed below.
+      config.analysis = [
+        RubyLint::Analysis::UndefinedVariables,
+        RubyLint::Analysis::ShadowingVariables
+      ]
+
+      config.report_levels = [:error]
+    end
+
+For more information see the documentation of {RubyLint::Configuration}.

data/doc/contributing.md

@@ -0,0 +1,16 @@
+# @title Contributing
+# Contributing
+
+Developers wishing to contribute to ruby-lint are required to follow a specific
+set of requirements. These requirements are described in the following article:
+<http://yorickpeterse.com/articles/contributing-to-my-code/>.
+
+These requirements are put in place to ensure a consistent code base, a
+streamlined development process and clear rules about what is and is not
+accepted. Although these requirements may seem a little bit daunting at first
+the whole process of making sure everything is set up correctly should take no
+more than a few minutes. In case you make a mistake or simply aren't sure about
+something I'll do my best to help you out.
+
+A copy of the DCO mentioned in the above article can be found in the file
+{file:DCO} A copy of the license can be found in the file {file:LICENSE}

data/doc/graphviz/flow.dot

@@ -0,0 +1,7 @@
+// Graphviz graph that shows the basic flow of the analysis process of
+// ruby-lint.
+
+digraph flow {
+    "Source" -> "Parser" -> "Definitions Builder" -> "Analysis";
+    "Analysis" -> "Report" -> "Presenter";
+}

data/lib/ruby-lint.rb

@@ -1,37 +1,37 @@
 require 'ripper'
+require 'ast/node'
 
-unless $:.include?(File.expand_path('../', __FILE__))
-  $:.unshift(File.expand_path('../', __FILE__))
-end
-
-require 'ruby-lint/version'
-require 'ruby-lint/parser'
-require 'ruby-lint/token/token'
-require 'ruby-lint/token/variable_token'
-require 'ruby-lint/token/statement_token'
-require 'ruby-lint/token/begin_rescue_token'
-require 'ruby-lint/token/method_definition_token'
-require 'ruby-lint/token/parameters_token'
-require 'ruby-lint/token/method_token'
-require 'ruby-lint/token/block_token'
-require 'ruby-lint/token/assignment_token'
-require 'ruby-lint/token/case_token'
-require 'ruby-lint/token/regexp_token'
-require 'ruby-lint/token/class_token'
-require 'ruby-lint/token/keyword_token'
-require 'ruby-lint/parser_error'
-require 'ruby-lint/iterator'
-require 'ruby-lint/callback'
-require 'ruby-lint/report'
-require 'ruby-lint/definition'
-require 'ruby-lint/constant_importer'
-require 'ruby-lint/formatter/text'
-require 'ruby-lint/helper/scoping'
-require 'ruby-lint/helper/definition_resolver'
-require 'ruby-lint/analyze/coding_style'
-require 'ruby-lint/analyze/definitions'
-require 'ruby-lint/analyze/unused_variables'
-require 'ruby-lint/analyze/undefined_variables'
-require 'ruby-lint/analyze/shadowing_variables'
-require 'ruby-lint/analyze/method_validation'
-require 'ruby-lint/options'
+require_relative 'ruby-lint/extensions/string'
+
+require_relative 'ruby-lint/variable_predicates'
+require_relative 'ruby-lint/node'
+require_relative 'ruby-lint/parser'
+require_relative 'ruby-lint/parser_error'
+require_relative 'ruby-lint/iterator'
+require_relative 'ruby-lint/definitions_builder'
+require_relative 'ruby-lint/constant_loader'
+
+require_relative 'ruby-lint/configuration'
+require_relative 'ruby-lint/version'
+require_relative 'ruby-lint/base'
+
+require_relative 'ruby-lint/definition/ruby_object'
+require_relative 'ruby-lint/definition/ruby_method'
+require_relative 'ruby-lint/definitions/core'
+
+require_relative 'ruby-lint/helper/conversion'
+require_relative 'ruby-lint/helper/current_scope'
+require_relative 'ruby-lint/helper/constant_paths'
+require_relative 'ruby-lint/helper/methods'
+
+require_relative 'ruby-lint/analyze/unused_variables'
+require_relative 'ruby-lint/analyze/shadowing_variables'
+require_relative 'ruby-lint/analyze/undefined_variables'
+require_relative 'ruby-lint/analyze/undefined_methods'
+require_relative 'ruby-lint/analyze/argument_amount'
+
+require_relative 'ruby-lint/report'
+require_relative 'ruby-lint/report/entry'
+
+require_relative 'ruby-lint/presenter/text'
+require_relative 'ruby-lint/presenter/json'

data/lib/ruby-lint/analyze/argument_amount.rb

@@ -0,0 +1,73 @@
+module RubyLint
+  module Analyze
+    ##
+    # The ArgumentAmount class is an analysis class that verifies the amount of
+    # arguments given with each method call and adds errors whenever an invalid
+    # amount was given.
+    #
+    class ArgumentAmount < Iterator
+      include Helper::Methods
+
+      ##
+      # @param [RubyLint::Node] node
+      #
+      def on_method(node)
+        return if invalid_receiver?(node) || !method_defined?(node)
+
+        definition    = lookup_method(node)
+        specified     = node.gather_arguments.length
+        minimum       = definition.length_of(:arguments)
+        optional      = definition.length_of(:optional_arguments)
+        maximum       = minimum + optional
+        rest          = !definition.rest_argument.nil?
+        expected_text = expected_text(minimum, maximum, optional)
+
+        unless correct_argument_amount(minimum, maximum, specified, rest)
+          error(
+            "wrong number of arguments (expected #{expected_text} but " \
+              "got #{specified})",
+            node
+          )
+        end
+      end
+
+      private
+
+      ##
+      # @param [Numeric] minimum
+      # @param [Numeric] maximum
+      # @param [Numeric] specified
+      # @param [TrueClass|FalseClass] rest
+      # @return [TrueClass|FalseClass]
+      #
+      def correct_argument_amount(minimum, maximum, specified, rest = false)
+        valid = false
+
+        if rest
+          valid = specified >= minimum
+        else
+          valid = specified >= minimum && specified <= maximum
+        end
+
+        return valid
+      end
+
+      ##
+      # Creates a string that indicates the amount of parameters that can be
+      # specified for a method.
+      #
+      # @param [Numeric] minimum
+      # @param [Numeric] maximum
+      # @param [Numeric] optional
+      # @return [String]
+      #
+      def expected_text(minimum, maximum, optional)
+        if optional > 0
+          return "#{minimum}..#{maximum}"
+        else
+          return minimum.to_s
+        end
+      end
+    end # ArgumentAmount
+  end # Analyze
+end # RubyLint