ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/definitions/core/thread_group.rb

@@ -0,0 +1,22 @@
+##
+# Constant: ThreadGroup
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('ThreadGroup') do |klass|
+  klass.inherits(RubyLint.global_constant('Object'))
+
+  klass.define_method('__class_init__')
+
+  klass.define_instance_method('add') do |method|
+    method.define_argument('thread')
+  end
+
+  klass.define_instance_method('initialize')
+
+  klass.define_instance_method('list')
+
+  klass.define_instance_method('remove') do |method|
+    method.define_argument('thread')
+  end
+end

data/lib/ruby-lint/definitions/core/time.rb

@@ -0,0 +1,233 @@
+##
+# Constant: Time
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('Time') do |klass|
+  klass.inherits(RubyLint.global_constant('Object'))
+
+  klass.define_method('__class_init__')
+
+  klass.define_method('_load') do |method|
+    method.define_argument('data')
+  end
+
+  klass.define_method('at') do |method|
+    method.define_argument('sec')
+    method.define_optional_argument('usec')
+  end
+
+  klass.define_method('compose') do |method|
+    method.define_argument('offset')
+    method.define_argument('p1')
+    method.define_optional_argument('p2')
+    method.define_optional_argument('p3')
+    method.define_optional_argument('p4')
+    method.define_optional_argument('p5')
+    method.define_optional_argument('p6')
+    method.define_optional_argument('p7')
+    method.define_optional_argument('yday')
+    method.define_optional_argument('is_dst')
+    method.define_optional_argument('tz')
+  end
+
+  klass.define_method('duplicate') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_method('from_array') do |method|
+    method.define_argument('sec')
+    method.define_argument('min')
+    method.define_argument('hour')
+    method.define_argument('mday')
+    method.define_argument('month')
+    method.define_argument('year')
+    method.define_argument('nsec')
+    method.define_argument('is_dst')
+    method.define_argument('from_gmt')
+    method.define_argument('utc_offset')
+  end
+
+  klass.define_method('gm') do |method|
+    method.define_rest_argument('args')
+  end
+
+  klass.define_method('local') do |method|
+    method.define_rest_argument('args')
+  end
+
+  klass.define_method('mktime') do |method|
+    method.define_rest_argument('args')
+  end
+
+  klass.define_method('new') do |method|
+    method.define_optional_argument('year')
+    method.define_optional_argument('month')
+    method.define_optional_argument('day')
+    method.define_optional_argument('hour')
+    method.define_optional_argument('minute')
+    method.define_optional_argument('second')
+    method.define_optional_argument('utc_offset')
+  end
+
+  klass.define_method('now')
+
+  klass.define_method('specific') do |method|
+    method.define_argument('sec')
+    method.define_argument('nsec')
+    method.define_argument('from_gmt')
+    method.define_argument('offset')
+  end
+
+  klass.define_method('utc') do |method|
+    method.define_rest_argument('args')
+  end
+
+  klass.define_instance_method('+') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('-') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('<=>') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('_dump') do |method|
+    method.define_optional_argument('limit')
+  end
+
+  klass.define_instance_method('asctime')
+
+  klass.define_instance_method('ctime')
+
+  klass.define_instance_method('day')
+
+  klass.define_instance_method('dst?')
+
+  klass.define_instance_method('dup')
+
+  klass.define_instance_method('eql?') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('friday?')
+
+  klass.define_instance_method('getgm')
+
+  klass.define_instance_method('getlocal') do |method|
+    method.define_optional_argument('offset')
+  end
+
+  klass.define_instance_method('getutc')
+
+  klass.define_instance_method('gmt?')
+
+  klass.define_instance_method('gmt_offset')
+
+  klass.define_instance_method('gmtime')
+
+  klass.define_instance_method('gmtoff')
+
+  klass.define_instance_method('hash')
+
+  klass.define_instance_method('hour')
+
+  klass.define_instance_method('inspect')
+
+  klass.define_instance_method('isdst')
+
+  klass.define_instance_method('localtime') do |method|
+    method.define_optional_argument('offset')
+  end
+
+  klass.define_instance_method('mday')
+
+  klass.define_instance_method('min')
+
+  klass.define_instance_method('mon')
+
+  klass.define_instance_method('monday?')
+
+  klass.define_instance_method('month')
+
+  klass.define_instance_method('nsec')
+
+  klass.define_instance_method('rake_original_time_compare') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('round') do |method|
+    method.define_optional_argument('places')
+  end
+
+  klass.define_instance_method('saturday?')
+
+  klass.define_instance_method('sec')
+
+  klass.define_instance_method('seconds')
+
+  klass.define_instance_method('strftime') do |method|
+    method.define_argument('format')
+  end
+
+  klass.define_instance_method('subsec')
+
+  klass.define_instance_method('succ')
+
+  klass.define_instance_method('sunday?')
+
+  klass.define_instance_method('thursday?')
+
+  klass.define_instance_method('to_a')
+
+  klass.define_instance_method('to_date')
+
+  klass.define_instance_method('to_datetime')
+
+  klass.define_instance_method('to_f')
+
+  klass.define_instance_method('to_i')
+
+  klass.define_instance_method('to_r')
+
+  klass.define_instance_method('to_s')
+
+  klass.define_instance_method('to_time')
+
+  klass.define_instance_method('tuesday?')
+
+  klass.define_instance_method('tv_nsec')
+
+  klass.define_instance_method('tv_sec')
+
+  klass.define_instance_method('tv_usec')
+
+  klass.define_instance_method('usec')
+
+  klass.define_instance_method('utc')
+
+  klass.define_instance_method('utc?')
+
+  klass.define_instance_method('utc_offset')
+
+  klass.define_instance_method('wday')
+
+  klass.define_instance_method('wednesday?')
+
+  klass.define_instance_method('yday')
+
+  klass.define_instance_method('year')
+
+  klass.define_instance_method('zone')
+end
+
+##
+# Constant: Time::MonthValue
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('Time::MonthValue') do |klass|
+end

data/lib/ruby-lint/definitions/core/toplevel_binding.rb

@@ -0,0 +1,7 @@
+##
+# Constant: TOPLEVEL_BINDING
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('TOPLEVEL_BINDING') do |klass|
+end

data/lib/ruby-lint/definitions/core/true.rb

@@ -0,0 +1,7 @@
+##
+# Constant: TRUE
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('TRUE') do |klass|
+end

data/lib/ruby-lint/definitions/core/true_class.rb

@@ -0,0 +1,30 @@
+##
+# Constant: TrueClass
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('TrueClass') do |klass|
+  klass.inherits(RubyLint.global_constant('Object'))
+
+  klass.define_method('__class_init__')
+
+  klass.define_instance_method('&') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('^') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('__marshal__') do |method|
+    method.define_argument('ms')
+  end
+
+  klass.define_instance_method('inspect')
+
+  klass.define_instance_method('to_s')
+
+  klass.define_instance_method('|') do |method|
+    method.define_argument('other')
+  end
+end

data/lib/ruby-lint/definitions/core/type_error.rb

@@ -0,0 +1,8 @@
+##
+# Constant: TypeError
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('TypeError') do |klass|
+  klass.inherits(RubyLint.global_constant('StandardError'))
+end

data/lib/ruby-lint/definitions/core/unbound_method.rb

@@ -0,0 +1,51 @@
+##
+# Constant: UnboundMethod
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('UnboundMethod') do |klass|
+  klass.inherits(RubyLint.global_constant('Object'))
+
+  klass.define_method('__class_init__')
+
+  klass.define_instance_method('==') do |method|
+    method.define_argument('other')
+  end
+
+  klass.define_instance_method('arity')
+
+  klass.define_instance_method('bind') do |method|
+    method.define_argument('receiver')
+  end
+
+  klass.define_instance_method('call_on_instance') do |method|
+    method.define_argument('obj')
+    method.define_rest_argument('args')
+    method.define_block_argument('block')
+  end
+
+  klass.define_instance_method('defined_in')
+
+  klass.define_instance_method('executable')
+
+  klass.define_instance_method('hash')
+
+  klass.define_instance_method('initialize') do |method|
+    method.define_argument('mod')
+    method.define_argument('executable')
+    method.define_argument('pulled_from')
+    method.define_argument('name')
+  end
+
+  klass.define_instance_method('inspect')
+
+  klass.define_instance_method('name')
+
+  klass.define_instance_method('owner')
+
+  klass.define_instance_method('parameters')
+
+  klass.define_instance_method('source_location')
+
+  klass.define_instance_method('to_s')
+end

data/lib/ruby-lint/definitions/core/unmarshalable.rb

@@ -0,0 +1,13 @@
+##
+# Constant: Unmarshalable
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('Unmarshalable') do |klass|
+
+  klass.define_method('__module_init__')
+
+  klass.define_instance_method('__marshal__') do |method|
+    method.define_argument('ms')
+  end
+end

data/lib/ruby-lint/definitions/core/unsupported_library_error.rb

@@ -0,0 +1,8 @@
+##
+# Constant: UnsupportedLibraryError
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('UnsupportedLibraryError') do |klass|
+  klass.inherits(RubyLint.global_constant('StandardError'))
+end

data/lib/ruby-lint/definitions/core/weak_ref.rb

@@ -0,0 +1,42 @@
+##
+# Constant: WeakRef
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('WeakRef') do |klass|
+  klass.inherits(RubyLint.global_constant('BasicObject'))
+
+  klass.define_method('__class_init__')
+
+  klass.define_method('new')
+
+  klass.define_instance_method('__getobj__')
+
+  klass.define_instance_method('__object__')
+
+  klass.define_instance_method('__setobj__') do |method|
+    method.define_argument('obj')
+  end
+
+  klass.define_instance_method('method_missing') do |method|
+    method.define_argument('method')
+    method.define_rest_argument('args')
+    method.define_block_argument('block')
+  end
+
+  klass.define_instance_method('respond_to_missing?') do |method|
+    method.define_argument('method')
+    method.define_argument('include_private')
+  end
+
+  klass.define_instance_method('weakref_alive?')
+end
+
+##
+# Constant: WeakRef::RefError
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('WeakRef::RefError') do |klass|
+  klass.inherits(RubyLint.global_constant('RuntimeError'))
+end

data/lib/ruby-lint/definitions/core/zero_division_error.rb

@@ -0,0 +1,8 @@
+##
+# Constant: ZeroDivisionError
+# Created:  2013-04-01 18:33:55 +0200
+# Platform: rbx 2.0.0.rc1
+#
+RubyLint.global_scope.define_constant('ZeroDivisionError') do |klass|
+  klass.inherits(RubyLint.global_constant('StandardError'))
+end

data/lib/ruby-lint/definitions_builder.rb

@@ -0,0 +1,692 @@
+module RubyLint
+  ##
+  # {RubyLint::DefinitionsBuilder} is a iterator class responsible for building
+  # a list of definitions. This approach means that individual iterator classes
+  # don't have to bother with this process and can instead focus on analyzing
+  # code.
+  #
+  class DefinitionsBuilder < Iterator
+    ##
+    # Array of variable types that should be exported to the outer scope of a
+    # method definition.
+    #
+    # @return [Array]
+    #
+    EXPORT_VARIABLES = [:instance_variable, :class_variable, :constant]
+
+    ##
+    # Hash containing the definition types to copy when including/extending a
+    # module.
+    #
+    # @return [Hash]
+    #
+    INCLUDE_CALLS = {
+      'include' => {
+        :constant        => :constant,
+        :instance_method => :instance_method
+      },
+      'extend' => {
+        :constant        => :constant,
+        :instance_method => :method
+      }
+    }
+
+    # Define the methods used for incrementing the amount of references to a
+    # variable.
+    [
+      :local_variable,
+      :global_variable,
+      :instance_variable,
+      :class_variable,
+      :constant,
+      :constant_path
+    ].each do |type|
+      define_method("on_#{type}") do |node|
+        if node.constant_path?
+          variable = resolve_definitions(node.children)
+        else
+          variable = definitions.lookup(node.type, node.name)
+        end
+
+        increment_reference_amount(variable) if variable
+
+        enable_reference_counting
+      end
+    end
+
+    ##
+    # Called at the root node of a Ruby script.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_root(node)
+      @options[:node_definitions] = {}
+      @options[:definitions]      = initial_definitions
+
+      enable_reference_counting
+      associate_node_definition(node, definitions)
+    end
+
+    ##
+    # Creates a new module definition and updates the scope accordingly. If the
+    # module already exists the existing set of definitions is used instead of
+    # creating a new one.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_module(node)
+      scope   = definitions
+      mod_def = Definition::RubyObject.new_from_node(
+        node,
+        :value   => nil,
+        :parents => [scope]
+      )
+
+      increment_reference_amount(mod_def)
+
+      if scope.has_definition?(:constant, mod_def.name)
+        existing = scope.lookup(:constant, mod_def.name)
+
+        if existing
+          @definitions << update_parent_definitions(existing, scope)
+
+          increment_reference_amount(existing)
+          associate_node_definition(node, existing)
+
+          return
+        end
+      end
+
+      define_module(node, mod_def)
+    end
+
+    ##
+    # Changes the scope back to the outer scope of a module definition.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def after_module(node)
+      @definitions.pop
+    end
+
+    ##
+    # Creates a new class definition and updates the scope accordingly.
+    #
+    # @see RubyLint::DefinitionsBuilder#on_module
+    #
+    def on_class(node)
+      scope  = definitions
+      parent = RubyLint.global_constant('Object')
+
+      # Resolve the definition of the parent class.
+      if node.children[1]
+        if node.children[1].constant_path?
+          parent = resolve_definitions(node.children[1].children)
+        else
+          parent = resolve_definitions([node.children[1]])
+        end
+      end
+
+      class_def = Definition::RubyObject.new_from_node(
+        node,
+        :value   => nil,
+        :parents => [parent, scope]
+      )
+
+      increment_reference_amount(class_def)
+
+      # Use an existing definition list if it exists.
+      if scope.has_definition?(:constant, class_def.name)
+        existing = scope.lookup(:constant, class_def.name)
+
+        if existing
+          @definitions << update_parent_definitions(existing, scope)
+
+          increment_reference_amount(existing)
+          associate_node_definition(node, existing)
+
+          return
+        end
+      end
+
+      define_module(node, class_def)
+    end
+
+    ##
+    # Changes the scope back to the outer scope of the class definition.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def after_class(node)
+      @definitions.pop
+    end
+
+    ##
+    # Called when an sclass block is found. These blocks look like the
+    # following:
+    #
+    #     class << self
+    #       # ...
+    #     end
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_sclass(node)
+      use   = node.children[0]
+      found = definitions.lookup(use.type, use.name) || definitions
+
+      associate_node_definition(node, found)
+
+      @definitions << found
+      @call_types  << :method
+    end
+
+    ##
+    # Called after an sclass block has been processed.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def after_sclass(node)
+      @definitions.pop
+      @call_types.pop
+    end
+
+    ##
+    # Creates a new method definition. This definition is either added in the
+    # current scope or in the scope of the receiver in case one is specified.
+    # Any method arguments are automatically added as definitions to the inner
+    # scope.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_method_definition(node)
+      scope  = definitions
+      method = Definition::RubyMethod.new_from_node(
+        node,
+        :parents       => [scope],
+        :method_type   => call_type,
+        :instance_type => :instance
+      )
+
+      if method.receiver
+        existing = scope.lookup(method.receiver.type, method.receiver.name)
+
+        if existing
+          scope = method.receiver = existing
+        else
+          return
+        end
+      end
+
+      scope.add(method.method_type, method.name, method)
+
+      associate_node_definition(node, method)
+
+      @definitions << method
+    end
+
+    ##
+    # Resets the scope to the outer scope and exports various variables into
+    # this scope.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def after_method_definition(node)
+      method = @definitions.pop
+
+      # TODO: variables should only be exported when the method is actually
+      # called.
+      EXPORT_VARIABLES.each do |type|
+        method.definitions[type].each do |name, defs|
+          definitions.add(type, name, defs)
+        end
+      end
+    end
+
+    ##
+    # Creates definitions for variable assignments. When assigning a value to a
+    # constant path and a particular segment does not exist the entire
+    # assignment is skipped.
+    #
+    # @param [RubyLint::Node|Array] node
+    #
+    def on_assign(node)
+      variable, value = *node
+      assign_method   = "on_#{variable.type}_assign"
+
+      # Deal with multiple variable assignments such as the following:
+      # first = second = third = 10
+      value = resolve_assignment_value(value)
+
+      if respond_to?(assign_method)
+        send(assign_method, variable, value)
+      else
+        assign_variable(definitions_for(variable), variable, value)
+      end
+
+      # Don't count references for the variable that's being assigned.
+      disable_reference_counting
+    end
+
+    ##
+    # @see RubyLint::DefinitionsBuilder#on_assign
+    #
+    def after_assign(node)
+      enable_reference_counting
+    end
+
+    ##
+    # Processes conditional variable assignments.
+    #
+    # @see RubyLint::DefinitionsBuilder#on_assign
+    #
+    def on_op_assign(node)
+      type = node.children[0].type
+      name = node.children[0].children[0]
+
+      on_assign(node.children) unless definitions.lookup(type, name)
+    end
+
+    ##
+    # Handles the assignments of constant paths.
+    #
+    # @param [RubyLint::Node] variable
+    # @param [RubyLint::Node] value
+    #
+    def on_constant_path_assign(variable, value)
+      scope = resolve_definitions(variable.children[0..-2])
+      last  = variable.children[-1]
+
+      assign_variable(scope, last, value, last.type) if scope
+    end
+
+    ##
+    # Handles the assignments of Array indexes, Hash keys and object members.
+    #
+    # @param [RubyLint::Node] variable
+    # @param [RubyLint::Node] values
+    #
+    def on_aref_assign(variable, values)
+      target  = variable.children[0]
+      members = variable.gather_arguments(:argument)
+      scope   = definitions.lookup(target.type, target.name)
+
+      return unless scope
+
+      members.each_with_index do |member, index|
+        member = resolve_variable(member) if member.variable?
+
+        next unless member
+
+        assign_variable(scope, member, values[index], :member)
+      end
+    end
+
+    ##
+    # Called when a value is assigned to an object member.
+    #
+    # @param [RubyLint::Node] variable
+    # @param [RubyLint::Node] value
+    #
+    def on_field_assign(variable, value)
+      object, member = *variable
+      object_def     = definitions.lookup(object.type, object.name)
+
+      if object_def
+        assign_variable(object_def, member, value, :member)
+      end
+    end
+
+    ##
+    # Processes the local variables created by `for` loops.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_for(node)
+      scope = definitions
+
+      # The values are set to `nil` as the only reliable way of retrieving
+      # these is actual code evaluation.
+      node.children[0].each do |variable|
+        assign_variable(scope, variable, nil)
+      end
+    end
+
+    ##
+    # Creates a new scope for the block's body.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_block(node)
+      scope = definitions
+      block = Definition::RubyObject.new_from_node(
+        node,
+        :name           => 'block',
+        :parents        => [scope],
+        :update_parents => [:local_variable]
+      )
+
+      node.each_argument do |arg|
+        variable = Definition::RubyObject.new_from_node(arg, :ignore => true)
+
+        block.add(arg.type, arg.name, variable)
+      end
+
+      # Ensure that local variables in the current scope are available inside
+      # the block.
+      scope.list(:local_variable).each do |variable|
+        block.add(variable.type, variable.name, variable)
+      end
+
+      associate_node_definition(node, block)
+
+      @definitions << block
+    end
+
+    ##
+    # @param [RubyLint::Node] node
+    #
+    def after_block(node)
+      @definitions.pop
+    end
+
+    ##
+    # Includes/extends a module when the `include` or `extend` method is
+    # called.
+    #
+    # @param [RubyLint::Node] node
+    #
+    def on_method(node)
+      return unless INCLUDE_CALLS.key?(node.children[0])
+
+      method_call = Definition::RubyMethod.new_from_node(node)
+      copy_types  = INCLUDE_CALLS[method_call.name]
+      scope       = definitions
+
+      method_call.arguments.each do |param|
+        if param.receiver
+          source = resolve_definitions(param.receiver_path)
+        else
+          source = scope.lookup(param.type, param.name)
+        end
+
+        if source.variable?
+          source = source.value
+        end
+
+        next unless source.is_a?(Definition::RubyObject)
+
+        copy_types.each do |from, to|
+          source.definitions[from].each do |name, definition|
+            scope.add(to, name, definition)
+          end
+        end
+      end
+    end
+
+    private
+
+    ##
+    # Assigns a value to the specified variable.
+    #
+    # @param [RubyLint::Definition::RubyObject] definition The definition
+    #  list to add the variable to.
+    # @param [RubyLint::Node] variable The variable to create.
+    # @param [RubyLint::NOde] value The value of the variable.
+    # @param [NilClass|Symbol] type The type of variable to add, set to the
+    #  type of `variable` by default.
+    #
+    def assign_variable(definition, variable, value, type = variable.type)
+      # Resolve variable values.
+      if value and (value.variable? or value.constant?)
+        found_value = resolve_variable(value)
+        value       = found_value if found_value
+      end
+
+      if value and value.method?
+        value = resolve_return_value(value)
+      end
+
+      var_def = create_variable_definition(variable, value)
+
+      # Certain types (the core Ruby types in particular) should be turned into
+      # instances when used for assigning a variable.
+      if create_instance?(var_def)
+        val_def = RubyLint.global_constant(var_def.value.ruby_class)
+
+        var_def.value.instance!
+
+        var_def.value.parents << val_def.instance if val_def
+      end
+
+      if value and value.collection?
+        assign_collection_members(var_def, value)
+      end
+
+      definition.add(type, var_def.name, var_def)
+    end
+
+    ##
+    # Assigns the indexes of the array to a definitions list.
+    #
+    # @param [RubyLint::Definition::RubyObject] definitions
+    # @param [Array] values
+    #
+    def assign_array_indexes(definitions, values)
+      values.each_with_index do |value, index|
+        assign_variable(
+          definitions,
+          Node.new(:integer, [index.to_s]),
+          value,
+          :member
+        )
+      end
+    end
+
+    ##
+    # Assigns the key/value pairs of a hash to a definition list.
+    #
+    # @param [RubyLint::Definition::RubyObject] definitions
+    # @param [Array] values
+    #
+    def assign_hash_pairs(definitions, values)
+      values.each do |pair|
+        assign_variable(definitions, pair, pair.value, :member)
+      end
+    end
+
+    ##
+    # Determines what method should be used for processing a collection's
+    # member values.
+    #
+    # @param [RubyLint::Definition::RubyObject] variable
+    # @param [RubyLint::Node] value
+    #
+    def assign_collection_members(variable, value)
+      if value.array?
+        assign_array_indexes(variable, value.value)
+      elsif value.hash?
+        assign_hash_pairs(variable, value.value)
+      end
+    end
+
+    ##
+    # Adds a definition for the `self` keyword.
+    #
+    # @param [RubyLint::Definition::RubyObject] definition The definition
+    #  list to add the keyword to.
+    #
+    def add_self(definition)
+      definition.add(:keyword, 'self', definition)
+    end
+
+    ##
+    # Increments the reference amount of the specified definition.
+    #
+    # @param [RubyLint::Definition::RubyObject] definition
+    #
+    def increment_reference_amount(definition)
+      definition.reference_amount += 1 if @enable_reference_counting
+    end
+
+    ##
+    # Enables reference counting of variables.
+    #
+    def enable_reference_counting
+      @enable_reference_counting = true
+    end
+
+    ##
+    # Disables reference counting of variables.
+    #
+    def disable_reference_counting
+      @enable_reference_counting = false
+    end
+
+    ##
+    # Creates a new {RubyLint::Definition::RubyObject} instance for a variable
+    # with an optional value.
+    #
+    # @param [RubyLint::Definition::RubyObject|RubyLint::Node] variable
+    # @param [RubyLint::Definition::RubyObject|RubyLint::Node] value
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def create_variable_definition(variable, value = nil)
+      if variable.is_a?(Node)
+        definition = Definition::RubyObject.new_from_node(
+          variable,
+          :value => value
+        )
+      else
+        definition       = variable
+        definition.value = value
+      end
+
+      return definition
+    end
+
+    ##
+    # Returns a boolean that indicates if the definition should be an instance
+    # of a Ruby value.
+    #
+    # @param [RubyLint::Definition::RubyObject] definition
+    # @return [TrueClass|FalseClass]
+    #
+    def create_instance?(definition)
+      val = definition.value
+
+      return val && val.ruby_class
+    end
+
+    ##
+    # Resolves variables that point to other variables down to the original
+    # one.
+    #
+    # @param [RubyLint::Definition::RubyOject] variable
+    # @return [RubyLint::Definition::RubyObject|NilClass]
+    #
+    def resolve_variable(variable)
+      resolved = variable
+
+      if variable.variable? or variable.constant?
+        resolved = definitions.lookup(variable.type, variable.name)
+
+        if resolved and !resolved.constant?
+          resolved = resolved.value
+        elsif !resolved
+          resolved = nil
+        end
+      end
+
+      return resolved
+    end
+
+    ##
+    # Resolves the return value of a method call.
+    #
+    # @param [RubyLint::Node] node
+    # @return [RubyLint::Definition::RubyObject|NilClass]
+    #
+    def resolve_return_value(node)
+      source = definitions
+
+      if node.receiver
+        if node.receiver.method?
+          source = resolve_return_value(node.receiver)
+        else
+          source = source.lookup(node.receiver.type, node.receiver.name)
+        end
+      end
+
+      return source ? source.call(node.name) : nil
+    end
+
+    ##
+    # Extracts the end value used in multiple variable assignments in the form
+    # of `first = second = third = 10`.
+    #
+    # @param [RubyLint::Node|Array] node
+    # @return [RubyLint::Node]
+    #
+    def resolve_assignment_value(node)
+      if node.respond_to?(:type) and node.type == :assign
+        node = resolve_assignment_value(node.value)
+      end
+
+      return node
+    end
+
+    ##
+    # @param [RubyLint::Node] node
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def definitions_for(node)
+      return node.global_variable? ? @options[:definitions] : definitions
+    end
+
+    ##
+    # Updates the parent definitions of a given definition object.
+    #
+    # @param [RubyLint::Definition::RubyObject] existing
+    # @param [RubyLint::Definition::RubyObject] parent
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def update_parent_definitions(existing, parent)
+      existing.parents << parent unless existing.parents.include?(parent)
+
+      return existing
+    end
+
+    ##
+    # Creates the required definitions for a new class or module.
+    #
+    # @param [RubyLint::Node] node
+    # @param [RubyLint::Definition::RubyObject] constant
+    #
+    def define_module(node, constant)
+      add_self(constant)
+
+      definitions.add(:constant, constant.name, constant)
+
+      associate_node_definition(node, constant)
+
+      @definitions << constant
+    end
+
+    ##
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def initial_definitions
+      definitions = Definition::RubyObject.new(
+        :name          => 'root',
+        :type          => :root,
+        :parents       => [RubyLint.global_constant('Kernel')],
+        :instance_type => :instance
+      )
+
+      definitions.merge(RubyLint.global_scope)
+
+      return definitions
+    end
+  end # DefinitionsBuilder
+end # RubyLint