ruby-lint 0.0.3 → 0.0.4

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

@@ -0,0 +1,132 @@
+module RubyLint
+  module Analysis
+    ##
+    # Base analysis class that provides various helper methods commonly used
+    # across analysis classes.
+    #
+    # @!attribute [r] report
+    #  @return [RubyLint::Report]
+    #
+    # @!attribute [r] vm
+    #  @return [RubyLint::VirtualMachine]
+    #
+    class Base < Iterator
+      include Helper::ConstantPaths
+
+      attr_reader :report, :vm
+
+      ##
+      # Array containing the callback names for which a new scope should be
+      # created.
+      #
+      # @return [Array<Symbol>]
+      #
+      SCOPES = [:root, :block, :class, :def, :module, :sclass]
+
+      ##
+      # Called after a new instance of this class is created.
+      #
+      def after_initialize
+        unless vm.is_a?(VirtualMachine)
+          raise(
+            ArgumentError,
+            'Analysis classes require a valid RubyLint::VirtualMachine ' \
+              'instance to be set using `SomeAnalysisClass.new(:vm => ...)`'
+          )
+        end
+
+        @scopes = []
+      end
+
+      SCOPES.each do |type|
+        define_method("on_#{type}") do |node|
+          set_current_scope(node)
+        end
+
+        define_method("after_#{type}") do |node|
+          set_previous_scope
+        end
+      end
+
+      protected
+
+      ##
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def definitions
+        return vm.definitions
+      end
+
+      ##
+      # Returns the current scope.
+      #
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def current_scope
+        return @scopes[-1]
+      end
+
+      ##
+      # Sets the current scope to the definition associated with the given
+      # node.
+      #
+      # @param [RubyLint::Node] node
+      #
+      def set_current_scope(node)
+        unless vm.associations.key?(node)
+          raise ArgumentError, "No associations for node #{node}"
+        end
+
+        @scopes << vm.associations[node]
+      end
+
+      ##
+      # Sets the current scope back to the previous one.
+      #
+      def set_previous_scope
+        @scopes.pop
+      end
+
+      ##
+      # 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.
+      #
+      def error(message, node)
+        add_message(:error, message, node)
+      end
+
+      ##
+      # Adds a warning message to the report.
+      #
+      # @see RubyLint::Callback#error
+      #
+      def warning(message, node)
+        add_message(:warning, message, node)
+      end
+
+      ##
+      # Adds a regular informational message to the report.
+      #
+      # @see RubyLint::Callback#error
+      #
+      def info(message, node)
+        add_message(:info, message, node)
+      end
+
+      ##
+      # Adds a message of the given level.
+      #
+      # @param [Symbol] level
+      # @param [String] message
+      # @param [String] node
+      #
+      def add_message(level, message, node)
+        return unless report
+
+        report.add(level, message, node.line, node.column, node.file)
+      end
+    end # Base
+  end # Analysis
+end # RubyLint

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

@@ -0,0 +1,26 @@
+module RubyLint
+  module Analysis
+    ##
+    # The {RubyLint::Analysis::ConfusingVariables} class checks for local
+    # variable assignments where the variable name is the same as an existing
+    # method name. Often these kind of assignments can lead to unexpected
+    # behaviour.
+    #
+    class ConfusingVariables < Base
+      ##
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_lvasgn(node)
+        name   = node.name
+        method = current_scope.lookup(current_scope.method_call_type, name)
+
+        if method and method != current_scope
+          warning(
+            'variable assignment using the same name as an existing method',
+            node
+          )
+        end
+      end
+    end # ConfusingVariables
+  end # Analysis
+end # RubyLint

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

@@ -0,0 +1,36 @@
+module RubyLint
+  module Analysis
+    ##
+    # The {RubyLint::Analysis::UselessRuby} class checks for various useless
+    # Ruby features, the use of redundant tokens such as `then` for `if`
+    # statements and various other pedantics.
+    #
+    class Pedantics < Base
+      [:if, :unless, :until, :while].each do |type|
+        define_method("on_#{type}") do |node|
+          check_begin_token(node)
+        end
+      end
+
+      [:on_preexe, :on_postexe].each do |method|
+        define_method(method) do |node|
+          warning('BEGIN/END is useless', node)
+        end
+      end
+
+      private
+
+      ##
+      # Checks if a node's begin token matches "then" or "do" and if so adds a
+      # warning for it.
+      #
+      # @param [RubyLint::AST::Node] node
+      #
+      def check_begin_token(node)
+        if node.location.begin.is?('then') or node.location.begin.is?('do')
+          info('the use of then/do is not needed here', node)
+        end
+      end
+    end # Pedantics
+  end # Analysis
+end # RubyLint

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

@@ -0,0 +1,47 @@
+module RubyLint
+  module Analysis
+    ##
+    # 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:
+    #
+    #     number = 10
+    #
+    #     [10, 20, 30].each do |number|
+    #       puts number # `number` is being shadowed
+    #     end
+    #
+    class ShadowingVariables < Base
+      ##
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_block(node)
+        @outer_scope = current_scope
+        @in_block    = true
+
+        super
+      end
+
+      ##
+      # @param [RubyLint::AST::Node] node
+      #
+      def after_block(node)
+        @in_block    = false
+        @outer_scope = nil
+
+        super
+      end
+
+      ##
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_arg(node)
+        if @in_block \
+        and @outer_scope.has_definition?(:lvar, node.name)
+          warning("shadowing outer local variable #{node.name}", node)
+        end
+      end
+    end # ShadowingVariables
+  end # Analysis
+end # RubyLint

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

@@ -0,0 +1,91 @@
+module RubyLint
+  module Analysis
+    ##
+    # 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 < Base
+      ##
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_send(node)
+        receiver, name, _  = *node
+
+        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]
+
+          # TODO: this should be handled in a more generic and especially in a
+          # more nicer way.
+          return if scope.parents.empty?
+        end
+
+        exists = scope.has_definition?(scope.method_call_type, name)
+
+        unless exists
+          message = error_for(name, receiver, scope)
+
+          error(message, node)
+        end
+      end
+
+      private
+
+      ##
+      # Determines what error message to use for a method call.
+      #
+      # @param [String] name The name of the method.
+      # @param [RubyLint::AST::Node] receiver The receiver node, if any.
+      # @param [RubyLint::Definition::RubyObject] scope The scope the method
+      #  was called on.
+      # @return [String]
+      #
+      def error_for(name, receiver, scope)
+        return receiver ? receiver_error(name, scope) : method_error(name)
+      end
+
+      ##
+      # @param [String] name
+      # @return [String]
+      #
+      def method_error(name)
+        return "undefined method #{name}"
+      end
+
+      ##
+      # Returns a String containing the error message to use when calling an
+      # undefined method on a receiver.
+      #
+      # @param [String] name
+      # @param [RubyLint::Definition::RubyObject] scope
+      # @return [String]
+      #
+      def receiver_error(name, scope)
+        klass = scope.ruby_class ? scope.ruby_class : scope.name
+
+        if scope.instance?
+          error = "undefined method #{name} on an instance of #{klass}"
+        else
+          error = "undefined method #{name} on #{scope.name}"
+        end
+
+        return error
+      end
+    end # UndefinedMethods
+  end # Analysis
+end # RubyLint

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

@@ -0,0 +1,46 @@
+module RubyLint
+  module Analysis
+    ##
+    # 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.
+    #
+    # This analysis class does *not* check for undefined local variables. Ruby
+    # treats these as method calls and as result they are handled by
+    # {RubyLint::Analysis::UndefinedMethods} instead.
+    #
+    class UndefinedVariables < Base
+      ##
+      # Hash containing the various variable types to add errors for whenever
+      # they are used but not defined.
+      #
+      # @return [Hash]
+      #
+      VARIABLE_TYPES = {
+        :gvar  => 'global variable',
+        :ivar  => 'instance variable',
+        :cvar  => 'class variable'
+      }
+
+      VARIABLE_TYPES.each do |type, label|
+        define_method("on_#{type}") do |node|
+          unless current_scope.has_definition?(type, node.name)
+            error("undefined #{label} #{node.name}", node)
+          end
+        end
+      end
+
+      ##
+      # Handles regular constants as well as constant paths.
+      #
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_const(node)
+        variable = resolve_constant_path(node)
+        name     = constant_segments(node).join('::')
+
+        error("undefined constant #{name}", node) unless variable
+      end
+    end # UndefinedVariables
+  end # Analysis
+end # RubyLint

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

@@ -0,0 +1,49 @@
+module RubyLint
+  module Analysis
+    ##
+    # 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 < Base
+      ##
+      # Hash containing the various variable types for which to add warnings
+      # and human readable names for these types.
+      #
+      # @return [Hash]
+      #
+      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)
+
+          if variable and !variable.used?
+            warning("unused #{label} #{name}", node)
+          end
+        end
+      end
+
+      ##
+      # Handles regular constants as well as constant paths.
+      #
+      # @param [RubyLint::AST::Node] node
+      #
+      def on_casgn(node)
+        variable = resolve_constant_path(node)
+        name     = constant_segments(node).join('::')
+
+        if variable and !variable.used?
+          warning("unused constant #{name}", node)
+        end
+      end
+    end # UnusedVariables
+  end # Analysis
+end # RubyLint

data/lib/ruby-lint/ast/builder.rb

@@ -0,0 +1,17 @@
+module RubyLint
+  module AST
+    ##
+    # Custom AST builder class used to provide some extra additions/changes to
+    # the AST such as the use of a custom node class.
+    #
+    class Builder < ::Parser::Builders::Default
+      ##
+      # @see Parser::Builders::Default#n
+      # @return [RubyLint::AST::Node]
+      #
+      def n(type, children, location)
+        return Node.new(type, children, :location => location)
+      end
+    end # Builder
+  end # AST
+end # RubyLint