ruby-lint 0.0.1a

data/lib/rlint/analyze/definitions.rb

@@ -0,0 +1,244 @@
+module Rlint
+  module Analyze
+    ##
+    # {Rlint::Analyze::Definitions} is a callback class that is used for
+    # building a list of all the definitions (variables, methods, etc) of a
+    # block of Ruby code.
+    #
+    # The resulting instance of {Rlint::Definition} is stored in the `@storage`
+    # instance variable under the key `:scope`. This makes it possible for
+    # other callback classes to access this data easily.
+    #
+    class Definitions < Rlint::Callback
+      include Helper::Scoping
+
+      ##
+      # A short description of this class.
+      #
+      # @return [String]
+      #
+      DESCRIPTION = 'Builds a list of definitions, always enabled.'
+
+      ##
+      # Array containing the key names of the variables that should be exported
+      # out of a method definition.
+      #
+      # @return [Array]
+      #
+      EXPORT_VARIABLES = [:instance_variable, :class_variable, :constant]
+
+      ##
+      # Hash containing the scoping data to copy over when extending a class
+      # using a module.
+      #
+      # @return [Hash]
+      #
+      INCLUDE_SYMBOLS = {
+        'include' => {
+          :constant        => :constant,
+          :instance_method => :instance_method
+        },
+        'extend' => {
+          :constant        => :constant,
+          :instance_method => :method
+        }
+      }
+
+      ##
+      # Called when a value is assigned to a variable.
+      #
+      # @param [Rlint::Token::AssignmentToken] token
+      #
+      def on_assignment(token)
+        if token.type == :global_variable
+          variable_scope = @storage[:scope]
+        else
+          variable_scope = scope
+        end
+
+        # Assignment using a constant path. In this case each path segment
+        # should exist (with the exception of the last one) for the assignment
+        # to take place.
+        if token.name.is_a?(Array)
+          name_scope = scope
+
+          token.name[0..-2].each do |segment|
+            name_scope = name_scope.lookup(:constant, segment)
+          end
+
+          if name_scope
+            variable_scope = name_scope
+          else
+            return
+          end
+
+          name = token.name[-1]
+          type = :constant
+        else
+          name = token.name
+          type = token.type
+        end
+
+        variable_scope.add(
+          type,
+          name,
+          Definition.new(nil, :token => token, :reset => false)
+        )
+      end
+
+      ##
+      # Called when a new method is defined.
+      #
+      # @param [Rlint::Token::MethodDefinitionToken] token
+      #
+      def on_method_definition(token)
+        type      = :instance_method
+        new_scope = Definition.new(scope, :token => token)
+        target    = scope
+
+        token.parameters.each do |param|
+          new_scope.add(
+            param.type,
+            param.name,
+            Definition.new(nil, :token => param, :reset => false)
+          )
+        end
+
+        # The method is a class method.
+        if token.receiver
+          type = :method
+
+          if token.receiver.name != 'self' \
+          and token.receiver.name != @namespace[-1]
+            found  = target.lookup(token.receiver.type, token.receiver.name)
+            target = found if found
+          end
+        end
+
+        target.add(type, token.name, new_scope)
+
+        @scopes << new_scope
+      end
+
+      ##
+      # Called after a method definition has been processed.
+      #
+      # @see Rlint::Analyze::Definitions#on_method_definition
+      #
+      def after_method_definition(token)
+        # TODO: exporting these variables should only be done if the method is
+        # actually called.
+        last_scope = @scopes.pop
+
+        EXPORT_VARIABLES.each do |key|
+          scope.symbols[key] = scope.symbols[key].merge(
+            last_scope.symbols[key]
+          )
+        end
+      end
+
+      ##
+      # Called when a class definition is found.
+      #
+      # @param [Rlint::Token::ClassToken] token
+      #
+      def on_class(token)
+        name       = token.name.join('::')
+        @namespace << name
+        existing   = scope.lookup(:constant, name)
+
+        # If a class has already been defined the scope should not be
+        # overwritten.
+        if existing
+          existing.parent << scope
+          @scopes         << existing
+
+          return
+        end
+
+        parent    = scope.lookup(:constant, token.parent.join('::'))
+        new_scope = Definition.new([parent, scope], :token => token)
+
+        scope.add(:constant, name, new_scope)
+
+        @scopes << new_scope
+      end
+
+      ##
+      # Called after a class definition was found and processed.
+      #
+      # @see Rlint::Analyze::Definitions#on_class
+      #
+      def after_class(token)
+        @scopes.pop
+        @namespace.pop
+      end
+
+      ##
+      # Called when a module is defined.
+      #
+      # @param [Rlint::Token::Token] token
+      #
+      def on_module(token)
+        name       = token.name.join('::')
+        @namespace << name
+        existing   = scope.lookup(:constant, name)
+
+        # If a module has already been defined the scope should not be
+        # overwritten.
+        if existing
+          existing.parent << scope
+          @scopes         << existing
+
+          return
+        end
+
+        new_scope = Definition.new(scope, :token => token)
+
+        scope.add(:constant, name, new_scope)
+
+        @scopes << new_scope
+      end
+
+      ##
+      # Called after a module definition has been processed.
+      #
+      # @see Rlint::Analyze::Definitions#on_module
+      #
+      def after_module(token)
+        @scopes.pop
+        @namespace.pop
+      end
+
+      ##
+      # Called when a method call is found. This callback is used to extend
+      # classes using modules.
+      #
+      # @param [Rlint::Token::MethodToken] token
+      #
+      def on_method(token)
+        if INCLUDE_SYMBOLS.key?(token.name)
+          token.parameters.each do |param|
+            found = nil
+
+            # Extract the definition and scope to include.
+            if param.type == :constant_path
+              found = resolve_definition(param.name)
+            elsif param.type == :constant
+              found = scope.lookup(:constant, param.name)
+            end
+
+            next unless found
+
+            # Copy over all the constants and methods.
+            INCLUDE_SYMBOLS[token.name].each do |source, target|
+              found.symbols[source].each do |name, data|
+                scope.add(target, name, data)
+              end
+            end
+          end
+        end
+      end
+    end # Definitions
+  end # Analyze
+end # Rlint

data/lib/rlint/analyze/method_validation.rb

@@ -0,0 +1,104 @@
+module Rlint
+  module Analyze
+    ##
+    # {Rlint::Analyze::MethodValidation} is used to validate method calls.
+    # Errors are added for calling undefined methods, calling methods with
+    # invalid parameters and so on.
+    #
+    class MethodValidation < Rlint::Callback
+      include Helper::DefinitionResolver
+
+      ##
+      # A short description of this class.
+      #
+      # @return [String]
+      #
+      DESCRIPTION = 'Validates method calls and the specified parameters.'
+
+      ##
+      # Hash containing the various Ruby classes that are used to represent
+      # various types.
+      #
+      # @return [Hash]
+      #
+      TYPE_CLASSES = {
+        :string      => 'String',
+        :integer     => 'Fixnum', # Fixnum and Bignum share the same methods.
+        :float       => 'Float',
+        :symbol      => 'Symbol',
+        :array       => 'Array',
+        :hash        => 'Hash',
+        :brace_block => 'Proc',
+        :lambda      => 'Proc',
+        :regexp      => 'Regexp',
+        :range       => 'Range'
+      }
+
+      ##
+      # Called when a method call is found.
+      #
+      # @param [Rlint::Token::MethodToken] token
+      #
+      def on_method(token)
+        # Method called on a receiver (e.g. `String.new`).
+        if token.receiver
+          receiver_name  = token.receiver.name
+          receiver_scope = scope
+          receiver_type  = token.receiver.type
+          method_type    = :instance_method
+
+          if receiver_name.is_a?(Array)
+            return unless valid_constant_path?(token.receiver)
+
+            receiver_scope = resolve_definition(receiver_name)
+          end
+
+          # Method calls on variables such as `name.upcase`.
+          if token.receiver.is_a?(Token::VariableToken) \
+          and receiver_type != :constant \
+          and receiver_type != :constant_path
+            value = receiver_scope.lookup(receiver_type, receiver_name)
+
+            if !value.nil? and !value.token.value.nil?
+              value         = value.token.value
+              receiver_type = TYPE_CLASSES[value.type]
+            end
+
+            # Extract the class from a method call.
+            if value.respond_to?(:receiver)
+              while value.respond_to?(:receiver)
+                value = value.receiver
+              end
+
+              receiver_type = value.name
+            end
+
+          # Methods called directly on a type such as `'name'.upcase`.
+          elsif TYPE_CLASSES[receiver_type]
+            receiver_type = TYPE_CLASSES[receiver_type]
+
+          # Everything else.
+          else
+            method_type   = :method
+            receiver_type = receiver_name.is_a?(Array) \
+              ? receiver_name[-1] \
+              : receiver_name
+          end
+
+          # Retrieve the constant to check for the existence of the method.
+          found = receiver_scope.lookup(:constant, receiver_type)
+
+          if found and !definition_exists?(method_type, token, found)
+            if method_type == :instance_method
+              error = "undefined instance method #{token.name}"
+            else
+              error = "undefined class method #{token.name}"
+            end
+
+            error(error, token.line, token.column)
+          end
+        end
+      end
+    end # MethodValidation
+  end # Analyze
+end # Rlint

data/lib/rlint/analyze/shadowing_variables.rb

@@ -0,0 +1,37 @@
+module Rlint
+  module Analyze
+    ##
+    # {Rlint::Analyze::ShadowingVariables} is used to add warnings when block
+    # parameters shadow outer local variables.
+    #
+    class ShadowingVariables < Rlint::Callback
+      include Helper::DefinitionResolver
+
+      ##
+      # A short description of this class.
+      #
+      # @return [String]
+      #
+      DESCRIPTION = 'Checks for variables that shadow other variables.'
+
+      ##
+      # 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 [Rlint::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
+            )
+          end
+        end
+      end
+    end # ShadowingVariables
+  end # Analyze
+end # Rlint

data/lib/rlint/analyze/undefined_variables.rb

@@ -0,0 +1,99 @@
+module Rlint
+  module Analyze
+    ##
+    # {Rlint::Analyze::UndefinedVariables} is used to add errors for the use of
+    # undefined variables.
+    #
+    class UndefinedVariables < Rlint::Callback
+      include Helper::DefinitionResolver
+
+      ##
+      # A short description of this class.
+      #
+      # @return [String]
+      #
+      DESCRIPTION = 'Checks for the use of undefined variables.'
+
+      [
+        'instance_variable',
+        'class_variable',
+        'global_variable',
+        'constant'
+      ].each do |name|
+        readable = name.gsub('_', ' ')
+
+        define_method('on_' + name) do |token|
+          unless definition_exists?(token.type, token)
+            error(
+              "undefined #{readable} #{token.name}",
+              token.line,
+              token.column
+            )
+          end
+        end
+      end
+
+      ##
+      # Called when a variable assignment is found. Used to validate constant
+      # paths before assigning data to them.
+      #
+      # @param [Rlint::Token::AssignmentToken] token
+      #
+      def on_assignment(token)
+        on_constant_path(token) if token.name.is_a?(Array)
+      end
+
+      ##
+      # Called when a constant path is found.
+      #
+      # @param [Rlint::Token::VariableToken] token
+      #
+      def on_constant_path(token)
+        current  = scope
+        segments = []
+
+        token.name.each do |segment|
+          segments << segment
+          found    = current.lookup(:constant, segment)
+
+          if found and found.token.line < token.line
+            current = found
+          else
+            error(
+              "undefined constant #{segments.join('::')}",
+              token.line,
+              token.column
+            )
+
+            return
+          end
+        end
+      end
+
+      ##
+      # Called when a method call is found.
+      #
+      # @param [Rlint::Token::MethodToken] token
+      #
+      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
+      end
+    end # UndefinedVariables
+  end # Analyze
+end # Rlint