ruby-lint 0.0.2 → 0.0.3

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

@@ -1,36 +1,31 @@
 module RubyLint
   module Analyze
     ##
-    # {RubyLint::Analyze::ShadowingVariables} is used to add warnings when block
-    # parameters shadow outer local variables.
+    # The ShadowingVariables class checks for the use of variables in a block
+    # that shadow outer variables. "Shadowing" means that a variable is used
+    # with the same name as a variable in the surrounding scope. A simple
+    # example:
     #
-    class ShadowingVariables < RubyLint::Callback
-      include Helper::DefinitionResolver
-
-      ##
-      # A short description of this class.
-      #
-      # @return [String]
-      #
-      DESCRIPTION = 'Checks for variables that shadow other variables.'
+    #     number = 10
+    #
+    #     [10, 20, 30].each do |number|
+    #       puts number # `number` is being shadowed
+    #     end
+    #
+    class ShadowingVariables < Iterator
+      include Helper::CurrentScope
 
       ##
-      # Called when a block is found. This callback is used to check if the
-      # parameters of the block shadow existing local variables defined in the
-      # outer scope.
+      # @param [RubyLint::Node] node
       #
-      # @param [RubyLint::Token::BlockToken] token The token of the block.
-      #
-      def on_block(token)
-        token.parameters.each do |param|
-          if scope.lookup(param.type, param.name)
-            warning(
-              "shadowing outer local variable #{param.name}",
-              param.line,
-              param.column
-            )
+      def on_block(node)
+        node.each_argument do |param|
+          if current_scope.has_definition?(param.type, param.name)
+            warning("shadowing outer local variable #{param.name}", param)
           end
         end
+
+        super
       end
     end # ShadowingVariables
   end # Analyze

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

@@ -0,0 +1,68 @@
+module RubyLint
+  module Analyze
+    ##
+    # The UndefinedMethods class checks for the use of undefined methods/local
+    # variables and adds errors whenever needed. Based on the receiver of a
+    # method call the corresponding error message differs to make it easier to
+    # understand what is going on.
+    #
+    # A simple example:
+    #
+    #     foobar        # => undefined method foobar
+    #     'test'.foobar # => undefined method foobar on an instance of String
+    #
+    class UndefinedMethods < Iterator
+      include Helper::Methods
+
+      ##
+      # @param [RubyLint::Node] node
+      #
+      def on_method(node)
+        # Don't add errors for non existing receivers as these are handled by
+        # classes such as UndefinedVariables.
+        return if invalid_receiver?(node)
+
+        valid = method_defined?(node)
+        error = "undefined method #{node.name}"
+
+        # Methods called on block variables should be ignored since these
+        # variables don't carry any class information with them.
+        if !valid and node.receiver
+          receiver = method_receiver(node.receiver)
+          valid    = receiver && receiver.ignore
+
+          if receiver.variable? and receiver.value
+            receiver = receiver.value
+          end
+
+          if receiver
+            error = receiver_error(node.name, receiver)
+          end
+        end
+
+        error(error, node) unless valid
+      end
+
+      private
+
+      ##
+      # Creates an error message for a method call on a receiver.
+      #
+      # @param [String] name
+      # @param [RubyLint::Definition::RubyObject] receiver
+      # @return [String]
+      #
+      def receiver_error(name, receiver)
+        error         = "undefined method #{name} on #{receiver.name}"
+        receiver_name = receiver.ruby_class || receiver.name
+
+        if receiver.instance?
+          error = "undefined method #{name} on an instance " \
+            "of #{receiver_name}"
+        end
+
+        return error
+      end
+    end # UndefinedMethods
+  end # Analyze
+end # RubyLint

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

@@ -1,98 +1,71 @@
 module RubyLint
   module Analyze
     ##
-    # {RubyLint::Analyze::UndefinedVariables} is used to add errors for the use of
-    # undefined variables.
+    # The UndefinedVariables class checks for the use of undefined variables
+    # (such as instance variables and constants). The order of definition and
+    # use of a variable does not matter.
     #
-    class UndefinedVariables < RubyLint::Callback
-      include Helper::DefinitionResolver
+    # This analysis class does *not* check for undefined local variables. Ruby
+    # treats these as method calls and as result they are handled by
+    # {RubyLint::Analyze::UndefinedMethods} instead.
+    #
+    class UndefinedVariables < Iterator
+      include Helper::CurrentScope
 
       ##
-      # A short description of this class.
+      # Hash containing the various variable types to add errors for whenever
+      # they are used but not defined.
       #
-      # @return [String]
+      # @return [Hash]
       #
-      DESCRIPTION = 'Checks for the use of undefined variables.'
-
-      [
-        'instance_variable',
-        'class_variable',
-        'global_variable',
-        'constant'
-      ].each do |name|
-        readable = name.gsub('_', ' ')
+      VARIABLE_TYPES = {
+        :global_variable   => 'global variable',
+        :instance_variable => 'instance variable',
+        :class_variable    => 'class variable',
+        :constant          => 'constant'
+      }
 
-        define_method('on_' + name) do |token|
-          unless definition_exists?(token.type, token)
-            error(
-              "undefined #{readable} #{token.name}",
-              token.line,
-              token.column
-            )
+      VARIABLE_TYPES.each do |type, label|
+        define_method("on_#{type}") do |node|
+          if !current_scope.has_definition?(type, node.name) \
+          and !@in_constant_path
+            error("undefined #{label} #{node.name}", node)
           end
         end
       end
 
       ##
-      # Called when a variable assignment is found. Used to validate constant
-      # paths before assigning data to them.
+      # Validates each segment of a constant path in the correct scope.
       #
-      # @param [RubyLint::Token::AssignmentToken] token
+      # @param [RubyLint::Node] node
       #
-      def on_assignment(token)
-        on_constant_path(token) if token.name.is_a?(Array)
-      end
+      def on_constant_path(node)
+        definitions       = current_scope
+        @in_constant_path = true
 
-      ##
-      # Called when a constant path is found.
-      #
-      # @param [RubyLint::Token::VariableToken] token
-      #
-      def on_constant_path(token)
-        current  = scope
-        segments = []
+        # The first constant check should take data from parent scopes into
+        # account. The following segments should not.
+        method = :has_definition?
 
-        token.name.each do |segment|
-          segments << segment
-          found    = current.lookup(:constant, segment)
+        node.children.each do |segment|
+          name = segment.name
 
-          if found and found.token.line < token.line
-            current = found
-          else
-            error(
-              "undefined constant #{segments.join('::')}",
-              token.line,
-              token.column
-            )
+          unless definitions.send(method, :constant, name)
+            error("undefined constant #{name}", segment)
 
-            return
+            break
           end
+
+          definitions = definitions.lookup(:constant, name)
+          method      = :defines?
         end
       end
 
       ##
-      # Called when a method call is found.
-      #
-      # @param [RubyLint::Token::MethodToken] token
+      # @param [RubyLint::Node] node
       #
-      def on_method(token)
-        kernel_method = false
-        kernel        = scope.lookup(:constant, 'Kernel')
-
-        if kernel.lookup(:method, token.name) \
-        or kernel.lookup(:instance_method, token.name)
-          kernel_method = true
-        end
-
-        if !token.receiver \
-        and !kernel_method \
-        and !definition_exists?(:instance_method, token)
-          error(
-            "undefined local variable or method #{token.name}",
-            token.line,
-            token.column
-          )
-        end
+      def after_constant_path(node)
+        @in_constant_path = false
       end
     end # UndefinedVariables
   end # Analyze

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

@@ -1,102 +1,47 @@
 module RubyLint
   module Analyze
     ##
-    # {RubyLint::Analyze::UnusedVariables} is used to check for unused local,
-    # instance, class and global variables.
+    # The UnusedVariables class checks for variables that are defined but never
+    # used. Whenever it finds one of these variables it will add a
+    # corresponding warning message.
     #
-    class UnusedVariables < RubyLint::Callback
-      include Helper::DefinitionResolver
+    class UnusedVariables < Iterator
+      include Helper::CurrentScope
+      include Helper::ConstantPaths
 
       ##
-      # A short description of this class.
-      #
-      # @return [String]
-      #
-      DESCRIPTION = 'Checks for variables that are assigned but unused.'
-
-      ##
-      # Hash containing the human readable names for various variable types.
+      # Hash containing the various variable types for which to add warnings
+      # and human readable names for these types.
       #
       # @return [Hash]
       #
-      HUMAN_READABLE = {
+      VARIABLE_TYPES = {
         :local_variable    => 'local variable',
+        :global_variable   => 'global variable',
         :instance_variable => 'instance variable',
         :class_variable    => 'class variable',
-        :global_variable   => 'global variable'
+        :constant          => 'constant'
       }
 
-      ##
-      # Array containing the variable callback methods to define.
-      #
-      # @return [Array]
-      #
-      UNUSED_VARIABLES = [
-        :on_local_variable,
-        :on_instance_variable,
-        :on_class_variable,
-        :on_global_variable
-      ]
+      VARIABLE_TYPES.each do |type, label|
+        define_method("on_#{type}") do |node|
+          variable = current_scope.lookup(node.type, node.name)
 
-      UNUSED_VARIABLES.each do |name|
-        define_method(name) do |token|
-          unused_variables.delete(token.name)
+          if variable and !variable.used?
+            warning("unused #{label} #{node.name}", node)
+          end
         end
       end
 
       ##
-      # @see RubyLint::Callback#initialize
-      #
-      def initialize(*args)
-        super
-
-        @unused_variables = [{}]
-      end
-
-      ##
-      # Called when a new scope is found.
-      #
-      def on_new_scope
-        @unused_variables << {}
-      end
-
-      ##
-      # Called after a new scope has ended.
+      # @param [RubyLint::Node] node
       #
-      def after_new_scope
-        # Add the warnings for all the unused variables.
-        unused_variables.each do |name, token|
-          readable = HUMAN_READABLE[token.type]
-
-          warning(
-            "assigned but unused #{readable} #{token.name}",
-            token.line,
-            token.column
-          )
+      def on_constant_path(node)
+        iterate_constant_path(node) do |name, segment, definition|
+          if definition and !definition.used?
+            warning("unused constant #{name}", segment)
+          end
         end
-
-        @unused_variables.pop
-      end
-
-      ##
-      # Called when a variable is assigned.
-      #
-      # @param [RubyLint::Token::AssignmentToken] token
-      #
-      def on_assignment(token)
-        unused_variables[token.name] = token
-      end
-
-      private
-
-      ##
-      # Returns the Hash to use for storing unused variables for the current
-      # scope.
-      #
-      # @return [Hash]
-      #
-      def unused_variables
-        return @unused_variables[-1]
       end
     end # UnusedVariables
   end # Analyze

data/lib/ruby-lint/base.rb

@@ -0,0 +1,85 @@
+module RubyLint
+  ##
+  # @return [RubyLint::GlobalScope]
+  #
+  def self.global_scope
+    return @global_scope ||= Definition::RubyObject.new(
+      :name => 'global',
+      :type => :global
+    )
+  end
+
+  ##
+  # Looks up the given constant in the global scope. If it does not exist this
+  # method will try to load it from one of the existing definitions.
+  #
+  # @param [String] name
+  # @return [RubyLint::Definition::RubyObject]
+  #
+  def self.global_constant(name)
+    found = global_scope.lookup(:constant, name)
+
+    if !found and !constant_loader.loaded?(name)
+      constant_loader.load(name)
+
+      found = global_scope.lookup(:constant, name)
+    end
+
+    return found
+  end
+
+  ##
+  # Provides a simple DSL for configuring ruby-lint.
+  #
+  # @yieldparam [RubyLint::Configuration]
+  #
+  def self.configure
+    yield configuration
+  end
+
+  ##
+  # @return [RubyLint::Configuration]
+  #
+  def self.configuration
+    return @configuration ||= Configuration.new
+  end
+
+  ##
+  # @param [RubyLint::Configuration] config
+  #
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  ##
+  # @return [RubyLint::ConstantLoader]
+  #
+  def self.constant_loader
+    return @constant_loader ||= ConstantLoader.new
+  end
+
+  ##
+  # Returns an Array of locations from which to load configuration files.
+  #
+  # @return [Array]
+  #
+  def self.configuration_files
+    return [
+      File.join(Dir.pwd, 'ruby-lint.rb'),
+      File.expand_path('~/.ruby-lint.rb', __FILE__)
+    ]
+  end
+
+  ##
+  # Tries to load a configuration file from one of the locations in
+  # {RubyLint.configuration_files}.
+  #
+  def self.load_configuration
+    configuration_files.each do |path|
+      if File.file?(path)
+        require(path)
+        break
+      end
+    end
+  end
+end # RubyLint