ruby-lint 0.0.4 → 0.0.5

data/lib/ruby-lint/helper/constant_paths.rb

@@ -17,7 +17,7 @@ module RubyLint
       # @return [RubyLint::Definition::RubyObject|NilClass]
       #
       def resolve_constant_path(node)
-        current = definitions
+        current = current_scope
 
         constant_segments(node).each_with_index do |segment, index|
           found = current.lookup(:const, segment, index == 0)

data/lib/ruby-lint/inspector.rb

@@ -28,7 +28,7 @@ module RubyLint
     end
 
     ##
-    # Returns an Array containing all child constants and their childrne
+    # Returns an Array containing all child constants and their children
     # (recursively).
     #
     # The constants returned by this method are returned as String instances
@@ -92,7 +92,7 @@ module RubyLint
     def inspect_methods
       return [] unless constant.respond_to?(:methods)
 
-      methods = constant.methods(false).map do |name|
+      methods = get_methods.map do |name|
         method_information(:method, name)
       end
 
@@ -107,7 +107,7 @@ module RubyLint
     def inspect_instance_methods
       return [] unless constant.respond_to?(:instance_methods)
 
-      methods = constant.instance_methods(false).map do |name|
+      methods = get_methods(:instance_methods).map do |name|
         method_information(:instance_method, name)
       end
 
@@ -123,41 +123,19 @@ module RubyLint
       return constant.respond_to?(:superclass) ? constant.superclass : nil
     end
 
-    ##
-    # Formats the list of methods in a human readable format.
-    #
-    # @param [Array] methods
-    # @return [String]
-    #
-    def format_methods(methods)
-      output  = []
-      longest = 0
-
-      methods.each do |method|
-        longest = method.name.length if method.name.length > longest
-      end
-
-      methods.each do |method|
-        output << "%-#{longest}s: %s" % [
-          method.name,
-          method.parameters.inspect
-        ]
-      end
-
-      return output.join("\n")
-    end
+    private
 
     ##
-    # Formats a list of constants in a human readable format.
+    # Gets the methods of the current constant minus those defined in Object.
     #
-    # @param [Array] constants
-    # @return [String]
+    # @param [Symbol] getter
+    # @return [Array]
     #
-    def format_constants(constants)
-      return constants.join("\n")
-    end
+    def get_methods(getter = :methods)
+      diff = constant.send(getter) - Object.send(getter)
 
-    private
+      return diff | constant.send(getter, false)
+    end
 
     ##
     # @param [Class] source

data/lib/ruby-lint/iterator.rb

@@ -35,6 +35,21 @@ module RubyLint
   # integers it processes. After processing an integer it will display three
   # dashes.
   #
+  # ## Skipping Child Nodes
+  #
+  # The `on_*` callbacks can tell the Iterator class to not process any
+  # following child nodes by calling `skip_child_nodes!`:
+  #
+  #     def on_const(node)
+  #       # ...
+  #
+  #       skip_child_nodes!(node)
+  #     end
+  #
+  # Internally this uses `throw` and makes sure to only skip the child nodes of
+  # the specified node (`throw` calls bubble up regardless of `catch` calls,
+  # unlike when using `begin/rescue`).
+  #
   class Iterator
     ##
     # @param [Hash] options Hash containing custom options to set for the
@@ -58,11 +73,14 @@ module RubyLint
       return unless node.is_a?(AST::Node)
 
       before, after = callback_names(node)
+      skip_node     = catch :skip_child_nodes do
+        execute_callback(before, node)
+      end
 
-      execute_callback(before, node)
-
-      node.children.each do |child|
-        iterate(child) if child.is_a?(AST::Node)
+      if skip_node != node
+        node.children.each do |child|
+          iterate(child) if child.is_a?(AST::Node)
+        end
       end
 
       execute_callback(after, node)
@@ -70,6 +88,15 @@ module RubyLint
 
     protected
 
+    ##
+    # Instructs {#iterate} to not process any child nodes.
+    #
+    # @param [RubyLint::AST::Node] node
+    #
+    def skip_child_nodes!(node)
+      throw :skip_child_nodes, node
+    end
+
     ##
     # Executes the specified callback method if it exists.
     #

data/lib/ruby-lint/method_call/alias.rb

@@ -0,0 +1,46 @@
+module RubyLint
+  module MethodCall
+    ##
+    # The Alias class is used to evaluate the use of `alias` and
+    # `alias_method`.
+    #
+    class Alias < Base
+      ##
+      # @see Base#evaluate
+      #
+      def evaluate(arguments, context, block = nil)
+        if node.type == :alias and node.children[0].gvar?
+          alias_gvar(arguments, context)
+        else
+          alias_sym(arguments, context)
+        end
+      end
+
+      private
+
+      ##
+      # @see Base#evaluate
+      #
+      def alias_sym(arguments, context)
+        method_type = context.method_call_type
+        alias_name  = arguments[0].value.to_s
+        source_name = arguments[1].value.to_s
+        source      = context.lookup(method_type, source_name)
+
+        context.add(method_type, alias_name, source) if source
+      end
+
+      ##
+      # @see Base#evaluate
+      #
+      def alias_gvar(arguments, context)
+        alias_name  = node.children[0].name
+        source_name = node.children[1].name
+        source      = context.lookup(:gvar, source_name)
+
+        # Global variables should be added to the root scope.
+        vm.definitions.add(:gvar, alias_name, source) if source
+      end
+    end # Alias
+  end # MethodCall
+end # RubyLint

data/lib/ruby-lint/method_call/assign_member.rb

@@ -0,0 +1,55 @@
+module RubyLint
+  module MethodCall
+    ##
+    # The AssignMember class is used for evaluating object member assignments.
+    # This includes the following types of assignments:
+    #
+    # * Array index assignments
+    # * Hash key assignments
+    #
+    class AssignMember < Base
+      ##
+      # @see Base#evaluate
+      #
+      def evaluate(arguments, context, block = nil)
+        *members, values = arguments
+        member_values    = prepare_values(values)
+
+        members.each do |member|
+          member = create_member(member.value.to_s, member_values.shift)
+
+          context.add_definition(member)
+        end
+      end
+
+      private
+
+      ##
+      # @param [String] name
+      # @param [Mixed] value
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def create_member(name, value)
+        return Definition::RubyObject.new(
+          :name  => name,
+          :type  => :member,
+          :value => value
+        )
+      end
+
+      ##
+      # @param [Array] values
+      # @return [Array]
+      #
+      def prepare_values(values)
+        if values and values.array?
+          member_values = values.list(:member).map(&:value)
+        elsif values
+          member_values = [values]
+        end
+
+        return member_values
+      end
+    end # AssignMember
+  end # MethodCall
+end # RubyLint

data/lib/ruby-lint/method_call/attribute.rb

@@ -0,0 +1,102 @@
+module RubyLint
+  module MethodCall
+    ##
+    # The Attribute class is used for evaluating method calls to `attr`,
+    # `attr_reader` and similar methods.
+    #
+    class Attribute < Base
+      ##
+      # @see Base#evaluate
+      #
+      def evaluate(arguments, context, block = nil)
+        method = "evaluate_#{node.children[1]}"
+
+        send(method, arguments, context)
+      end
+
+      private
+
+      ##
+      # Evaluates a call to `attr`. The `attr` method can be used in two
+      # different ways (thank you Ruby for being consistent):
+      #
+      # 1. `attr [NAME], [TRUE|FALSE]`
+      # 2. `attr [NAME], [NAME], etc
+      #
+      # @see #evaluate
+      #
+      def evaluate_attr(arguments, context)
+        if arguments[1] and arguments[1].type == :true
+          names = [arguments[0].value.to_s, arguments[0].value.to_s + '=']
+        else
+          names = arguments.map { |arg| arg.value.to_s }
+        end
+
+        names.each do |name|
+          define_attribute(name, context)
+        end
+      end
+
+      ##
+      # Evaluates method calls to `attr_reader`.
+      #
+      # @see #evaluate
+      #
+      def evaluate_attr_reader(arguments, context)
+        arguments.each do |arg|
+          define_attribute(arg.value.to_s, context)
+        end
+      end
+
+      ##
+      # Evaluates method calls to `attr_writer`.
+      #
+      # @see #evaluate
+      #
+      def evaluate_attr_writer(arguments, context)
+        arguments.each do |arg|
+          define_attribute(arg.value.to_s, context, true)
+        end
+      end
+
+      ##
+      # Evaluates method calls to `attr_accessor`.
+      #
+      # @see #evaluate
+      #
+      def evaluate_attr_accessor(arguments, context)
+        arguments.each do |arg|
+          name = arg.value.to_s
+
+          define_attribute(name, context)
+          define_attribute(name, context, true)
+        end
+      end
+
+      ##
+      # @param [String] name
+      # @param [RubyLint::Definition::RubyObject] context
+      # @param [TrueClass|FalseClass] setter
+      #
+      def define_attribute(name, context, setter = false)
+        ivar_name = '@' + name
+
+        if setter
+          name = name + '='
+        end
+
+        context.define_instance_method(name)
+
+        unless context.has_definition?(:ivar, ivar_name)
+          ivar = Definition::RubyObject.new(
+            :type             => :ivar,
+            :name             => ivar_name,
+            :reference_amount => 1
+          )
+
+          context.add_definition(ivar)
+        end
+      end
+    end # Attribute
+  end # MethodCall
+end # RubyLint

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

@@ -0,0 +1,37 @@
+module RubyLint
+  module MethodCall
+    ##
+    # Base class for the various method call handlers, takes care of some of
+    # the common boilerplate code.
+    #
+    # @!attribute [r] node
+    #  @return [RubyLint::AST::Node]
+    #
+    # @!attribute [r] vm
+    #  @return [RubyLint::VirtualMachine]
+    #
+    class Base
+      attr_reader :node, :vm
+
+      ##
+      # @param [RubyLint::AST::Node] node
+      # @param [RubyLint::VirtualMachine] vm
+      #
+      def initialize(node, vm)
+        @node = node
+        @vm   = vm
+      end
+
+      ##
+      # @param [Array] arguments
+      # @param [RubyLint::Definition::RubyObject] context
+      # @param [RubyLint::Definition::RubyObject] block
+      #
+      #:nocov:
+      def evaluate(arguments, context, block = nil)
+        raise NotImplementedError, '#evaluate must be implemented'
+      end
+      #:nocov:
+    end # Base
+  end # MethodCall
+end # RubyLint

data/lib/ruby-lint/method_call/define_method.rb

@@ -0,0 +1,17 @@
+module RubyLint
+  module MethodCall
+    ##
+    # The DefineMethod class is used to process `define_method` calls.
+    # Currently this class is only used to set the instance type of the block
+    # to the correct value.
+    #
+    class DefineMethod < Base
+      ##
+      # @see Base#evaluate
+      #
+      def evaluate(arguments, context, block = nil)
+        block.instance! if block && block.block?
+      end
+    end # DefineMethod
+  end # MethodCall
+end # RubyLint

data/lib/ruby-lint/method_call/include.rb

@@ -0,0 +1,39 @@
+module RubyLint
+  module MethodCall
+    ##
+    # The Include class is used for evaluating the use of `include` and
+    # `extend` method calls.
+    #
+    class Include < Base
+      ##
+      # Hash containing the source and target definition types for both
+      # `include` and `extend` method calls.
+      #
+      COPY_TYPES = {
+        :include => {
+          :const           => :const,
+          :instance_method => :instance_method
+        },
+        :extend => {
+          :const           => :const,
+          :instance_method => :method
+        }
+      }
+
+      ##
+      # @see Base#evaluate
+      #
+      def evaluate(arguments, context, block = nil)
+        node_name = node.children[1]
+
+        arguments.each do |source|
+          COPY_TYPES[node_name].each do |from, to|
+            source.list(from).each do |definition|
+              context.add(to, definition.name, definition)
+            end
+          end
+        end
+      end
+    end # Include
+  end # MethodCall
+end # RubyLint