ruby-lint 0.0.4 → 0.0.5

data/Rakefile

@@ -5,9 +5,15 @@ require File.expand_path('../lib/ruby-lint/definition_generator', __FILE__)
 require 'yaml'
 require 'bundler/gem_tasks'
 require 'digest/sha2'
+require 'coveralls/rake/task'
+require 'rake/clean'
+
+Coveralls::RakeTask.new
 
 GEMSPEC = Gem::Specification.load('ruby-lint.gemspec')
 
+CLEAN.include(['coverage', 'yardoc'])
+
 Dir['./task/*.rake'].each do |task|
   import(task)
 end

data/checksum/ruby-lint-0.0.4.gem.sha512

@@ -0,0 +1 @@
+40ff98f739ee8dfb2356010f56b2110fcfa022b5df2bffd978a8585c958beae913016535d3d9721144dda39bc719334e0a61a9159f206f8ce82476ea17882540

data/doc/changelog.md

@@ -5,6 +5,98 @@ This document contains a short summary of the various releases of ruby-lint.
 For a full list of commits included in each release see the corresponding Git
 tags (named after the versions).
 
+## 0.0.5 - 2013-09-01
+
+Originally slated for August 1st I decided to push this release back one month
+to buy myself some extra time to polish features, resolve more bugs and
+procrastinate more. Besides numerous bug fixes and extra polish this release
+contains two big new features that I'd like to highlight:
+
+* support for parsing basic YARD tags
+* loading of externally defined constants/files from the local file system
+
+### YARD Support
+
+[YARD][yard] provides a set of tags that can aid in documenting your code. For
+example, `@param` is a tag used to document the type, name and description of a
+method parameter. Since Ruby has no form of type hinting you're often left to
+wonder what kind of objects a method can work with.
+
+In version 0.0.5 support for two tags was added:
+
+* `@param`
+* `@return`
+
+When ruby-lint finds methods documented using these tags it will use them to
+pull in information about the parameter types and return values. This greatly
+increases the accuracy of ruby-lint, given your code is documented. Consider
+the following example:
+
+    def multiply(value, multiplier)
+      return value * value
+    end
+
+If ruby-lint were to process the above code it would have no idea what kind of
+object `value` and `multiplier` are and thus wouldn't be able to much with the
+above code. When documenting the above method with the mentioned YARD tags
+ruby-lint *is* capable of doing this:
+
+    ##
+    # @param [Fixnum] value
+    # @param [Fixnum] multiplier
+    # @return [Fixnum]
+    #
+    def multiply(value, multiplier)
+      return value * value
+    end
+
+By parsing the YARD tags ruby-lint can now know what the parameter types are
+and what type of data the method returns. This in turn allows ruby-lint to
+perform full analysis on the arguments instead of being forced to ignore them
+completely.
+
+### Loading External Files
+
+In previous versions ruby-lint had no way of loading external code that was not
+pre-defined using the built-in definitions (found in
+`lib/ruby-lint/definitions`). As a result a lot of false positives would be
+triggered when analysing complex projects (e.g. the typical Rails project).
+
+This has been addressed by introducing so called "file scanners" and "file
+loaders". In short, these scan for a set of constants used in a file and try to
+find the corresponding Ruby file that defines it (recursively). This greatly
+enhances the accuracy of analysis.
+
+Currently the algorithm for this is rather basic and can, especially in big
+projects, slow analysis down by quite a bit. This will be resolved in upcoming
+releases. Keep an eye on the following issues for more information:
+
+* <https://github.com/YorickPeterse/ruby-lint/issues/50>
+* <https://github.com/YorickPeterse/ruby-lint/issues/49>
+
+### Other Changes
+
+Besides the two features mentioned above various other changes have also been
+made, these are listed below.
+
+* Lots of bug fixes and cleanups, as you'd expect.
+* Constants (classes and modules) can now be referred by their name inside
+  themselves (e.g. "Foo" inside the class "Foo" refers to that class).
+* The text presenter now only shows filenames instead of the full file path,
+  reducing clutter.
+* Support for default global variables such as `$LOADED_FEATURES`
+* Support for methods such as `alias` and `alias_method`
+* Support for the `attr_*` family of methods
+* The test suite has been migrated from Bacon to RSpec
+* Support for keyword arguments.
+* Updated built-in Rails definitions to include more methods.
+* Debugging/benchmarking output for the analyze command.
+* The analysis class ConfusingVariables has been removed due to not being very
+  useful.
+* Various issues with method lookups inside blocks have been resolved.
+* Various internals have been cleaned up.
+* Improved error messages for calls to undefined methods.
+
 ## 0.0.4 - 2013-07-14
 
 Near total refactor of the entire project. New parser setup based on the
@@ -27,3 +119,5 @@ Various changes to the old parser.
 ## 0.0.1 - 2012-11-13
 
 First public release of ruby-lint.
+
+[yard]: http://yardoc.org/

data/lib/ruby-lint.rb

@@ -1,6 +1,9 @@
+gem 'parser', '>= 2.0.0.pre6'
+
 require 'parser'
 require 'parser/current'
 require 'yaml'
+require 'set'
 
 require_relative 'ruby-lint/extensions/string'
 
@@ -8,7 +11,12 @@ require_relative 'ruby-lint/variable_predicates'
 require_relative 'ruby-lint/ast/node'
 require_relative 'ruby-lint/ast/builder'
 require_relative 'ruby-lint/parser'
+require_relative 'ruby-lint/file_scanner'
 require_relative 'ruby-lint/nested_stack'
+require_relative 'ruby-lint/docstring/parser'
+require_relative 'ruby-lint/docstring/param_tag'
+require_relative 'ruby-lint/docstring/return_tag'
+require_relative 'ruby-lint/docstring/mapping'
 
 require_relative 'ruby-lint/helper/constant_paths'
 
@@ -21,14 +29,24 @@ require_relative 'ruby-lint/definition_builder/ruby_hash'
 require_relative 'ruby-lint/definition_builder/ruby_block'
 require_relative 'ruby-lint/definition_builder/primitive'
 
+require_relative 'ruby-lint/method_call/base'
+require_relative 'ruby-lint/method_call/assign_member'
+require_relative 'ruby-lint/method_call/include'
+require_relative 'ruby-lint/method_call/alias'
+require_relative 'ruby-lint/method_call/attribute'
+require_relative 'ruby-lint/method_call/define_method'
+
 require_relative 'ruby-lint/iterator'
+require_relative 'ruby-lint/global_scope'
 require_relative 'ruby-lint/virtual_machine'
 require_relative 'ruby-lint/constant_loader'
+require_relative 'ruby-lint/file_loader'
 
 require_relative 'ruby-lint/definition/ruby_object'
 require_relative 'ruby-lint/definition/ruby_method'
 require_relative 'ruby-lint/definition/constant_proxy'
 require_relative 'ruby-lint/definitions/core'
+require_relative 'ruby-lint/definitions/global_variables'
 
 require_relative 'ruby-lint/analysis/base'
 require_relative 'ruby-lint/analysis/unused_variables'
@@ -36,7 +54,6 @@ require_relative 'ruby-lint/analysis/shadowing_variables'
 require_relative 'ruby-lint/analysis/undefined_variables'
 require_relative 'ruby-lint/analysis/undefined_methods'
 require_relative 'ruby-lint/analysis/argument_amount'
-require_relative 'ruby-lint/analysis/confusing_variables'
 require_relative 'ruby-lint/analysis/pedantics'
 
 require_relative 'ruby-lint/report'

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

@@ -6,24 +6,28 @@ module RubyLint
     # amount was given.
     #
     class ArgumentAmount < Base
+      ##
+      # Hash that contains method names that should be used for analysis
+      # instead of the ones specified in the keys.
+      #
+      # @return [Hash]
+      #
+      MAP_METHODS = {
+        'new' => [:instance_method, 'initialize']
+      }
+
       ##
       # @param [RubyLint::Node] node
       #
       def on_send(node)
-        receiver, name, args = *node
+        receiver, name, *args = *node
 
-        name  = name.to_s
-        scope = current_scope
-
-        if receiver and vm.associations.key?(receiver)
-          scope = vm.associations[receiver]
-        end
-
-        method = scope.lookup(scope.method_call_type, name)
+        scope  = scope_for_receiver(receiver)
+        method = determine_method(scope, name.to_s)
 
         return unless method
 
-        given    = args ? args.children.length : 0
+        given    = args ? args.length : 0
         min, max = argument_range(method)
 
         unless correct_argument_amount(min, max, given)
@@ -38,6 +42,35 @@ module RubyLint
 
       private
 
+      ##
+      # @param [RubyLint::AST::Node] receiver
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def scope_for_receiver(receiver)
+        scope = current_scope
+
+        if receiver and vm.associations.key?(receiver)
+          scope = vm.associations[receiver]
+        end
+
+        return scope
+      end
+
+      ##
+      # @param [RubyLint::Definition::RubyObject] scope
+      # @param [String] name
+      # @return [RubyLint::Definition::RubyMethod]
+      #
+      def determine_method(scope, name)
+        method = scope.lookup(scope.method_call_type, name)
+
+        if method and MAP_METHODS[method.name]
+          method = scope.lookup(*MAP_METHODS[method.name])
+        end
+
+        return method
+      end
+
       ##
       # @param [Numeric] min
       # @param [Numeric] max

data/lib/ruby-lint/analysis/base.rb

@@ -51,19 +51,19 @@ module RubyLint
       protected
 
       ##
+      # Returns the current scope.
+      #
       # @return [RubyLint::Definition::RubyObject]
       #
-      def definitions
-        return vm.definitions
+      def current_scope
+        return @scopes[-1]
       end
 
       ##
-      # Returns the current scope.
-      #
       # @return [RubyLint::Definition::RubyObject]
       #
-      def current_scope
-        return @scopes[-1]
+      def previous_scope
+        return @scopes[-2]
       end
 
       ##
@@ -90,29 +90,28 @@ module RubyLint
       ##
       # Adds an error message to the report.
       #
-      # @param [String] message The message to add.
-      # @param [RubyLint::Node] node The node for which to add the message.
+      # @see #add_message
       #
-      def error(message, node)
-        add_message(:error, message, node)
+      def error(*args)
+        add_message(:error, *args)
       end
 
       ##
       # Adds a warning message to the report.
       #
-      # @see RubyLint::Callback#error
+      # @see #add_message
       #
-      def warning(message, node)
-        add_message(:warning, message, node)
+      def warning(*args)
+        add_message(:warning, *args)
       end
 
       ##
       # Adds a regular informational message to the report.
       #
-      # @see RubyLint::Callback#error
+      # @see #add_message
       #
-      def info(message, node)
-        add_message(:info, message, node)
+      def info(*args)
+        add_message(:info, *args)
       end
 
       ##
@@ -125,7 +124,14 @@ module RubyLint
       def add_message(level, message, node)
         return unless report
 
-        report.add(level, message, node.line, node.column, node.file)
+        report.add(
+          :level    => level,
+          :message  => message,
+          :line     => node.line,
+          :column   => node.column,
+          :file     => node.file,
+          :node     => node
+        )
       end
     end # Base
   end # Analysis

data/lib/ruby-lint/analysis/pedantics.rb

@@ -8,7 +8,9 @@ module RubyLint
     class Pedantics < Base
       [:if, :unless, :until, :while].each do |type|
         define_method("on_#{type}") do |node|
-          check_begin_token(node)
+          if node.location.respond_to?(:begin) and node.location.begin
+            check_begin_token(node)
+          end
         end
       end
 

data/lib/ruby-lint/analysis/undefined_methods.rb

@@ -21,12 +21,6 @@ module RubyLint
         name  = name.to_s
         scope = current_scope
 
-        # Abort if the receiver doesn't exist since it will be handled by other
-        # analysis classes.
-        if receiver and !vm.associations.key?(receiver)
-          return
-        end
-
         if receiver and vm.associations.key?(receiver)
           scope = vm.associations[receiver]
 
@@ -35,9 +29,7 @@ module RubyLint
           return if scope.parents.empty?
         end
 
-        exists = scope.has_definition?(scope.method_call_type, name)
-
-        unless exists
+        unless has_definition?(scope, name)
           message = error_for(name, receiver, scope)
 
           error(message, node)
@@ -46,6 +38,24 @@ module RubyLint
 
       private
 
+      ##
+      # @param [RubyLint::Definition::RubyObject] scope
+      # @param [String] name
+      #
+      def has_definition?(scope, name)
+        exists = scope.has_definition?(scope.method_call_type, name)
+
+        # Due to the way `parser` wraps block nodes (`(block (send) ...)`
+        # opposed to `(send ... (block))`) we'll try to find the method in the
+        # previous scope if we can't find it in the current block scope.
+        if !exists and scope.block?
+          prev   = previous_scope
+          exists = prev.has_definition?(prev.method_call_type, name)
+        end
+
+        return exists
+      end
+
       ##
       # Determines what error message to use for a method call.
       #
@@ -76,7 +86,7 @@ module RubyLint
       # @return [String]
       #
       def receiver_error(name, scope)
-        klass = scope.ruby_class ? scope.ruby_class : scope.name
+        klass = class_names_for_object(scope)
 
         if scope.instance?
           error = "undefined method #{name} on an instance of #{klass}"
@@ -86,6 +96,34 @@ module RubyLint
 
         return error
       end
+
+      private
+
+      ##
+      # @param [RubyLint::Definition::RubyObject] object
+      # @return [String]
+      #
+      def class_names_for_object(object)
+        if object.parents.empty?
+          klass = object.ruby_class ? object.ruby_class : object.name
+        else
+          klass = name_for_parents(object.parents)
+        end
+
+        return klass
+      end
+
+      ##
+      # @param [Array] parents
+      # @return [String]
+      #
+      def name_for_parents(parents)
+        return parents[0].name if parents.length == 1
+
+        segments = parents[0..-2].map(&:name)
+
+        return segments.join(', ') + " or #{parents[-1].name}"
+      end
     end # UndefinedMethods
   end # Analysis
 end # RubyLint

data/lib/ruby-lint/analysis/unused_variables.rb

@@ -15,22 +15,34 @@ module RubyLint
       VARIABLE_TYPES = {
         :lvasgn => 'local variable',
         :gvasgn => 'global variable',
-        :ivasgn => 'instance variable',
         :cvasgn => 'class variable'
       }
 
       VARIABLE_TYPES.each do |type, label|
         define_method("on_#{type}") do |node|
           type     = VirtualMachine::ASSIGNMENT_TYPES[node.type]
-          name     = node.name
-          variable = current_scope.lookup(type, name)
+          variable = current_scope.lookup(type, node.name)
 
-          if variable and !variable.used?
-            warning("unused #{label} #{name}", node)
+          if add_warning?(variable)
+            warning("unused #{label} #{variable.name}", node)
           end
         end
       end
 
+      ##
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_ivasgn(node)
+        name        = node.name
+        variable    = current_scope.lookup(:ivar, name)
+        method_type = current_scope.method_call_type
+        getter      = current_scope.lookup(method_type, name[1..-1])
+
+        if variable and !variable.used? and !getter
+          warning("unused instance variable #{name}", node)
+        end
+      end
+
       ##
       # Handles regular constants as well as constant paths.
       #
@@ -44,6 +56,16 @@ module RubyLint
           warning("unused constant #{name}", node)
         end
       end
+
+      private
+
+      ##
+      # @param [RubyLint::Definition::RubyObject] variable
+      # @return [TrueClass|FalseClass]
+      #
+      def add_warning?(variable)
+        return variable && !variable.used? && variable.name[0] != '_'
+      end
     end # UnusedVariables
   end # Analysis
 end # RubyLint