ruby-lint 0.0.3 → 0.0.4

data/lib/ruby-lint/generated_constant.rb

@@ -0,0 +1,33 @@
+module RubyLint
+  ##
+  # {RubyLint::GeneratedConstant} contains information about a constant (and
+  # its data) that was pre-generated using {RubyLint::DefinitionGenerator}.
+  #
+  # @!attribute [r] methods
+  #  @return [Hash]
+  #
+  # @!attribute [r] name
+  #  @return [String]
+  #
+  # @!attribute [r] constant
+  #  @return [Class]
+  #
+  # @!attribute [r] superclass
+  #  @return [String]
+  #
+  class GeneratedConstant
+    attr_reader :methods, :name, :constant, :superclass
+
+    ##
+    # @param [Hash] attributes
+    #
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+
+      @methods    ||= []
+      @superclass ||= 'Object'
+    end
+  end # GeneratedConstant
+end # RubyLint

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

@@ -6,35 +6,44 @@ module RubyLint
     #
     module ConstantPaths
       ##
-      # Iterates over each segment of the constant path and yields the supplied
-      # block.
+      # Looks up a definition for a given constant path. If no constant could
+      # be found `nil` is returned.
       #
-      # @example
-      #  path = s(:constant_path, s(:constant, 'A'), s(:constant, 'B')
+      # The first constant segment in the path can inherit constants from the
+      # outer scope, any following constants will be limited to the scope of
+      # the constant itself.
       #
-      #  iterate_constant_path(path) do |name, segment, definition|
-      #    puts name
-      #  end
+      # @param [RubyLint::AST::Node] node
+      # @return [RubyLint::Definition::RubyObject|NilClass]
       #
-      # @param [RubyLint::Node] node The constant path to iterate over.
+      def resolve_constant_path(node)
+        current = definitions
+
+        constant_segments(node).each_with_index do |segment, index|
+          found = current.lookup(:const, segment, index == 0)
+
+          found ? current = found : return
+        end
+
+        return current
+      end
+
+      ##
+      # Returns an Array containing the segments of a constant path.
       #
-      # @yieldparam [String] name The name of the current segment.
-      # @yieldparam [RubyLint::Node] node The raw AST node of the current
-      #  segment.
-      # @yieldparam [RubyLint::Definition::RubyObject] definition The
-      #  definition object of the current segment.
+      # @param [RubyLint::AST::Node] node
+      # @return [Array<String>]
       #
-      def iterate_constant_path(node)
-        definitions = current_scope
+      def constant_segments(node)
+        segments = []
 
-        node.children.each do |segment|
-          name       = segment.children[0]
-          definition = definitions.lookup(:constant, name)
+        if node.children[0]
+          segments.concat(constant_segments(node.children[0]))
+        end
 
-          yield name, segment, definition
+        segments << node.children[1].to_s
 
-          definition ? definitions = definition : break
-        end
+        return segments
       end
     end # ConstantPaths
   end # Helper

data/lib/ruby-lint/inspector.rb

@@ -52,7 +52,16 @@ module RubyLint
       source.constants.each do |name|
         next unless source.const_defined?(name)
 
-        constant  = source.const_get(name)
+        # FIXME: When using autoload/Rails in some cases this will trigger a
+        # load error. I have no idea why.
+        begin
+          constant = source.const_get(name)
+        rescue LoadError => error
+          warn error.message
+
+          next
+        end
+
         name      = name.to_s
         full_name = include_source ? "#{source_name}::#{name}" : name
 
@@ -105,6 +114,15 @@ module RubyLint
       return methods.sort_by(&:name)
     end
 
+    ##
+    # Returns the superclass of the current constant or `nil` if there is none.
+    #
+    # @return [Mixed]
+    #
+    def inspect_superclass
+      return constant.respond_to?(:superclass) ? constant.superclass : nil
+    end
+
     ##
     # Formats the list of methods in a human readable format.
     #
@@ -147,7 +165,7 @@ module RubyLint
     # @return [TrueClass|FalseClass]
     #
     def process_child_constants?(source, constant)
-      return constant.respond_to?(:constants) \
+      return constant.respond_to?(:consts) \
         && constant != source \
         && !constant.constants.empty?
     end

data/lib/ruby-lint/iterator.rb

@@ -16,17 +16,17 @@ module RubyLint
   #
   # These event names are used to call the corresponding callback methods if
   # they exist. Each callback method takes a single argument: the node (an
-  # instance of {RubyLint::Node}) that belongs to the event.
+  # instance of {RubyLint::AST::Node}) that belongs to the event.
   #
   # Creating iterator classes is done by extending this particular class and
   # adding the needed methods to it:
   #
   #     class MyIterator < RubyLint::Iterator
-  #       def on_integer(node)
+  #       def on_int(node)
   #         puts node.children[0]
   #       end
   #
-  #       def after_integer(node)
+  #       def after_int(node)
   #         puts '---'
   #       end
   #     end
@@ -35,43 +35,17 @@ module RubyLint
   # integers it processes. After processing an integer it will display three
   # dashes.
   #
-  # Each instance of a class that subclasses {RubyLint::Iterator} also has
-  # access to the instance variable `@options`. This instance variable is used
-  # to store certain information, such as the list of definitions for a block
-  # of Ruby code. The following two keys are set by default:
-  #
-  # * `:definitions`: a set of Ruby definitions such as classes and methods.
-  # * `:report`: an instance of {RubyLint::Report} that can be used for adding
-  #   information about the analyzed code.
-  # * `:node_definitions`: a Hash that associates {RubyLint::Node} instances
-  #   with the corresponding scope.
-  #
-  # To make it easier to add data to a report sub classes can use the following
-  # three methods:
-  #
-  # * error
-  # * info
-  # * warning
-  #
-  # These methods take away some of the boilerplate that would otherwise be
-  # required to check for a report and add data to it if it's set.
-  #
   class Iterator
-    ##
-    # Hash containing the options that were set for the iterator.
-    #
-    # @return [Hash]
-    #
-    attr_reader :options
-
     ##
     # @param [Hash] options Hash containing custom options to set for the
     #  iterator.
     #
     def initialize(options = {})
-      @options     = default_options.merge(options)
-      @definitions = []
-      @call_types  = []
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+
+      after_initialize if respond_to?(:after_initialize)
     end
 
     ##
@@ -81,18 +55,14 @@ module RubyLint
     #  iterate over.
     #
     def iterate(node)
-      return unless node.is_a?(Node)
+      return unless node.is_a?(AST::Node)
 
       before, after = callback_names(node)
 
       execute_callback(before, node)
 
       node.children.each do |child|
-        if child.is_a?(Array)
-          child.each { |c| iterate(c) }
-        else
-          iterate(child)
-        end
+        iterate(child) if child.is_a?(AST::Node)
       end
 
       execute_callback(after, node)
@@ -100,107 +70,6 @@ module RubyLint
 
     protected
 
-    ##
-    # 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)
-      if has_report?
-        @options[:report].add(
-          level,
-          message,
-          node.line,
-          node.column,
-          node.file
-        )
-      end
-    end
-
-    ##
-    # Returns `true` if the current iterator has a report instance set.
-    #
-    # @return [TrueClass|FalseClass]
-    #
-    def has_report?
-      return @options[:report].is_a?(Report)
-    end
-
-    ##
-    # Returns a definition list to use for the last segment in the constant
-    # path. If one of the segments is invalid `nil` is returned instead.
-    #
-    # @param [Array] path An array of nodes or definitions that make up the
-    #  constant path.
-    # @return [RubyLint::Definition::RubyObject|NilClass]
-    #
-    def resolve_definitions(path)
-      current = definitions
-
-      path.each do |segment|
-        if segment.is_a?(Definition::RubyObject)
-          name = segment.name
-        else
-          name = segment.children[0]
-        end
-
-        found = current.lookup(segment.type, name)
-        found ? current = found : return
-      end
-
-      return current
-    end
-
-    ##
-    # Returns the call type to use for method calls.
-    #
-    # @return [Symbol]
-    #
-    def call_type
-      return @call_types.empty? ? :instance_method : @call_types[-1]
-    end
-
-    ##
-    # Returns the current definition list to use.
-    #
-    # @return [RubyLint::Definition::RubyObject]
-    #
-    def definitions
-      return @definitions.empty? ? @options[:definitions] : @definitions[-1]
-    end
-
-    protected
-
     ##
     # Executes the specified callback method if it exists.
     #
@@ -218,36 +87,7 @@ module RubyLint
     # @return [Array]
     #
     def callback_names(node)
-      return [:"on_#{node.type}", :"after_#{node.type}"]
-    end
-
-    ##
-    # Associates a definitions object with a node of the AST.
-    #
-    # @param [RubyLint::Node] node
-    # @param [RubyLint::Definition::RubyObject] definitions
-    #
-    def associate_node_definition(node, definitions)
-      @options[:node_definitions][node] = definitions
-    end
-
-    ##
-    # Retrieves the definitions list associated to an AST node.
-    #
-    # @param [RubyLint::Node] node
-    # @return [RubyLint::Definition::RubyObject|NilClass]
-    #
-    def associated_definition(node)
-      return @options[:node_definitions][node]
-    end
-
-    ##
-    # Returns a Hash containing the default configuration options.
-    #
-    # @return [Hash]
-    #
-    def default_options
-      return {:node_definitions => {}}
+      return ["on_#{node.type}", "after_#{node.type}"]
     end
   end # Iterator
 end # RubyLint

data/lib/ruby-lint/nested_stack.rb

@@ -0,0 +1,46 @@
+module RubyLint
+  ##
+  # {RubyLint::NestedStack} is a basic implementation of a nested stack. It's
+  # primarily used by {RubyLint::VirtualMachine} for storing variables and
+  # values during assignments.
+  #
+  class NestedStack
+    def initialize
+      @values = []
+    end
+
+    ##
+    # Adds a new stack to push values to.
+    #
+    def add_stack
+      @values << []
+    end
+
+    ##
+    # Returns `true` if the stack is empty.
+    #
+    # @return [TrueClass|FalseClass]
+    #
+    def empty?
+      return @values.empty?
+    end
+
+    ##
+    # Pushes a value to the current (= last) stack.
+    #
+    # @param [Mixed] value
+    #
+    def push(value)
+      @values.last << value
+    end
+
+    ##
+    # Pops the last stack from the collection and returns it.
+    #
+    # @return [Array]
+    #
+    def pop
+      return @values.pop
+    end
+  end # NestedStack
+end # RubyLint

data/lib/ruby-lint/parser.rb

@@ -1,826 +1,44 @@
 module RubyLint
   ##
-  # {RubyLint::Parser} parses Ruby code and returns a clean and usable AST
-  # instead of the rather raw AST returned by Ripper itself. Each node in the
-  # AST is an instance of {RubyLint::Node}.
+  # {RubyLint::Parser} provides a small wrapper around the Parser Gem and
+  # allows for the use of a custom AST builder.
   #
-  # ## Example
+  # @!attribute [r] internal_parser
+  #  @return [Parser::Parser]
   #
-  #     RubyLint::Parser.new('[10, 20]').parse
-  #       # => (root (array (integer "10") (integer "20")))
-  #
-  class Parser < Ripper::SexpBuilderPP
-    ##
-    # Hash containing various Ripper types and the RubyLint types to use
-    # instead.
-    #
-    # @return [Hash]
-    #
-    TYPE_MAPPING = {
-      :ident           => :identifier,
-      :gvar            => :global_variable,
-      :ivar            => :instance_variable,
-      :cvar            => :class_variable,
-      :const           => :constant,
-      :int             => :integer,
-      :float           => :float,
-      :tstring_content => :string,
-      :label           => :symbol,
-      :kw              => :keyword
-    }
-
-    ##
-    # Array containing all the event names of which the methods should simply
-    # returned the passed argument.
-    #
-    # @return [Array]
-    #
-    RETURN_FIRST_ARG_EVENTS = [
-      :arg_paren,
-      :assoclist_from_args,
-      :begin,
-      :block_var,
-      :blockarg,
-      :const_ref,
-      :mlhs_paren,
-      :mrhs_new_from_args,
-      :rest_param,
-      :symbol_literal,
-      :top_const_ref,
-      :var_field,
-      :paren
-    ]
-
-    ##
-    # Array of event names that should return an instance of
-    # {RubyLint::Token::MethodToken}.
-    #
-    # @return [Array]
-    #
-    RETURN_METHOD_EVENTS = [:fcall, :vcall]
-
-    ##
-    # List of modified statements, used to dynamically define the callback
-    # methods.
-    #
-    # @return [Hash]
-    #
-    MOD_STATEMENT_EVENTS = {
-      :while_mod  => :while,
-      :if_mod     => :if,
-      :unless_mod => :unless,
-      :until_mod  => :until
-    }
-
-    ##
-    # Collection of Ripper events of which the callbacks all share similar
-    # code. The corresponding methods are defined on the fly.
-    #
-    # @return [Hash]
-    #
-    BASIC_EVENTS = {
-      :bodystmt         => :body,
-      :class            => :class,
-      :module           => :module,
-      :binary           => :binary,
-      :unary            => :unary,
-      :return           => :return,
-      :else             => :else,
-      :unless           => :unless,
-      :until            => :until,
-      :while            => :while,
-      :dot2             => :dot2,
-      :dot3             => :dot3,
-      :assoc_new        => :key_value,
-      :hash             => :hash,
-      :aref             => :aref,
-      :string_concat    => :string_concat,
-      :string_embexpr   => :embed,
-      :begin            => :begin,
-      :ensure           => :ensure,
-      :defined          => :defined,
-      :super            => :super,
-      :yield0           => :yield,
-      :yield            => :yield,
-      :sclass           => :sclass
-    }
-
-    ##
-    # Hash containing various Ripper event names and the methods these events
-    # should execute.
-    #
-    # @return [Hash]
-    #
-    EVENT_ALIASES = {
-      :dyna_symbol     => :on_symbol,
-      :aref_field      => :on_aref,
-      :bare_assoc_hash => :on_hash,
-      :do_block        => :on_brace_block
-    }
-
-    ##
-    # Array of events (the ones used by ruby-lint) of which the child nodes
-    # should be stripped of `nil` values.
-    #
-    # @return [Array]
-    #
-    COMPACT_EVENT_ARGS = [:body, :unless]
-
-    ##
-    # Array of events of which the first callback parameter should be used for
-    # the child nodes of a callback.
-    #
-    # @return [Array]
-    #
-    UNPACK_EVENT_ARGS = [:else, :hash, :embed, :ensure]
-
-    ##
-    # Hash containing parameter indexes and the node types.
-    #
-    # @return [Hash]
-    #
-    PARAMETER_INDEX_TYPES = {
-      0 => :argument,
-      1 => :optional_argument,
-      2 => :rest_argument,
-      3 => :more_argument,
-      4 => :block_argument
-    }
-
-    SCANNER_EVENTS.each do |type|
-      define_method("on_#{type}") do |value|
-        return Node.new(readable_type_name(type), [value], metadata)
-      end
-    end
-
-    RETURN_FIRST_ARG_EVENTS.each do |event|
-      define_method("on_#{event}") { |*args| return args[0] }
-    end
-
-    RETURN_METHOD_EVENTS.each do |event|
-      define_method("on_#{event}") do |node|
-        return Node.new(
-          :method,
-          [node.children[0], on_params, nil, nil], metadata(node)
-        )
-      end
-    end
-
-    BASIC_EVENTS.each do |original, new|
-      define_method("on_#{original}") do |*args|
-        if COMPACT_EVENT_ARGS.include?(new)
-          args = args.map { |arg| arg.compact rescue arg }.compact
-        end
-
-        args = args[0] if UNPACK_EVENT_ARGS.include?(new)
-
-        return Node.new(new, args, metadata)
-      end
-    end
-
-    MOD_STATEMENT_EVENTS.each do |mod, normal|
-      define_method("on_#{mod}") do |statement, value|
-        value = [value] unless value.is_a?(Array)
-
-        return send("on_#{normal}", statement, value)
-      end
-    end
-
-    EVENT_ALIASES.each do |event, method|
-      define_method("on_#{event}") do |*args|
-        return send(method, *args)
-      end
-    end
-
-    ##
-    # @see Ripper::SexpBuilderPP#initialize
-    #
-    def initialize(code, file = '(ruby-lint)', line = 1)
-      super
-
-      @file = file
-    end
-
-    ##
-    # @return [NilClass]
-    #
-    def on_void_stmt
-      return nil
-    end
-
-    ##
-    # Called at the start of a Ruby program.
-    #
-    # @param  [Array] nodes The various nodes of the program.
-    # @return [RubyLint::Node]
-    #
-    def on_program(nodes)
-      nodes = [nodes] unless nodes.is_a?(Array)
-
-      return Node.new(:root, nodes, :line => 1, :column => 0, :file => @file)
-    end
-
-    ##
-    # @param [String] message The error message.
-    # @raise [RubyLint::ParserError]
-    #
-    def on_parse_error(message)
-      raise ParserError.new(message, lineno, column, @file)
-    end
-
-    ##
-    # Called when a symbol is found.
-    #
-    # @param  [RubyLint::Node|Array] node The value of the symbol. This
-    #  parameter is set to an Array when parsing code such as `:"hello"`.
-    # @return [RubyLint::Node]
-    #
-    def on_symbol(node)
-      node = node[0] if node.is_a?(Array)
-
-      return Node.new(:symbol, node.children, metadata(node))
-    end
-
-    ##
-    # @param  [Array] content The contents of the string.
-    # @return [RubyLint::Node]
-    #
-    def on_string_literal(content)
-      return content[1] || Node.new(:string, [], metadata)
-    end
-
-    ##
-    # Called when a piece of code is embedded using `#expressions` (e.g.
-    # `#$foo`).
-    #
-    # @param [RubyLint::Node] node
-    # @return [RubyLint::Node]
-    #
-    def on_string_dvar(node)
-      return Node.new(:embed, [node], metadata(node))
-    end
-
-    ##
-    # @param  [Array] values The values of the array.
-    # @return [RubyLint::Node]
-    #
-    def on_array(values)
-      values ||= []
-      values   = [values] unless values.is_a?(Array)
-      children = values.flatten
-
-      return Node.new(:array, children, metadata)
-    end
-
-    ##
-    # @param  [Array] regexp Array containing the regular expression's body.
-    # @return [RubyLint::Node] mode The mode for the regular expression.
-    # @return [RubyLint::Node]
-    #
-    def on_regexp_literal(regexp, mode)
-      return Node.new(:regexp, [regexp[0], mode], metadata)
-    end
-
-    ##
-    # @param  [RubyLint::Node] params The parameters of the lamda.
-    # @param  [Array] body The body of the lambda.
-    # @return [RubyLint::Node]
-    #
-    def on_lambda(params, body)
-      return on_brace_block(params, body).updated(:lambda)
-    end
-
-    ##
-    # @param  [RubyLint::Node] params The parameters of the block.
-    # @param  [Array] body The body of the block.
-    # @return [RubyLint::Node]
-    #
-    def on_brace_block(params, body)
-      return Node.new(:block, [params || on_params, on_bodystmt(body)], metadata)
-    end
-
-    ##
-    # @param [RubyLint::Node] left
-    # @param [RubyLint::Node] right
-    # @return [RubyLint::Node]
-    #
-    def on_const_path_ref(left, right)
-      left = left.type == :constant_path ? left.children : left
-
-      return Node.new(:constant_path, [left, right].flatten, metadata)
-    end
-
-    ##
-    # @see #on_constant_path_ref
-    #
-    def on_const_path_field(left, right)
-      return on_const_path_ref(left, right)
-    end
-
-    ##
-    # Called when a variable is assigned to a start (`*`).
-    #
-    # @param [Array|RubyLint::Node] left The variable(s) to the left of the
-    #  star.
-    # @param [Array|RubyLint::Node] right The variable(s) to the right of the
-    #  star.
-    # @return [RubyLint::Node]
-    #
-    def on_mlhs_add_star(left, right)
-      if right
-        left << right.updated(nil, [*right.children, true])
-      # Add a placeholder for the expander token.
-      else
-        left << nil
-      end
-
-      return left
-    end
-
-    ##
-    # @param [RubyLint::Node] variable The data to assign the value to.
-    # @param [RubyLint::Node] value The value to assign.
-    # @return [RubyLint::Node]
-    #
-    def on_assign(variable, value)
-      variable = variable.updated(:local_variable) if variable.identifier?
-
-      # When assigning values to array indexes or hash keys the value should
-      # always be an array. This makes it easier to assign values without
-      # having to check the type of data we're dealing with.
-      if variable.type == :aref and !value.is_a?(Array)
-        value = [value]
-      end
-
-      return Node.new(:assign, [variable, value], metadata(variable))
-    end
-
-    ##
-    # Called when a conditional assignment is found.
-    #
-    # @see RubyLint::Parser#on_assign
-    #
-    def on_opassign(variable, operator, value)
-      return on_assign(variable, value).updated(:op_assign)
-    end
-
-    ##
-    # @param [Array] variables The variables that are being assigned.
-    # @param [Array|RubyLint::Node] values The values to assign.
-    # @return [RubyLint::Node]
-    #
-    def on_massign(variables, values)
-      nodes     = []
-      variables = variables.flatten
-      before    = 0
-
-      if values.is_a?(Node) and values.type == :array
-        values = values.children.dup
-      elsif !values.is_a?(Array)
-        values = [values]
-      end
-
-      var_length = variables.length
-      val_length = values.length
-
-      variables.each_with_index do |variable, index|
-        if !variable
-          values.shift
-          next
-        end
-
-        variable = variable.updated(:local_variable) if variable.identifier?
-
-        # Extract the values for the expander variable based on the amount of
-        # variables, values and the amount of variables that were assigned
-        # before the expander.
-        if variable.children[1]
-          slice_length = val_length - (var_length - 1)
-
-          value = Node.new(
-            :array,
-            values.slice!(index - before, slice_length),
-            metadata(variable)
-          )
-
-          variable = variable.updated(nil, [variable.children[0]])
-        else
-          before += 1
-          value   = values.shift
-        end
-
-        unless value
-          value = Node.new(
-            :keyword,
-            ['nil'],
-            metadata(variable)
-          )
-        end
-
-        nodes << Node.new(:assign, [variable, value], metadata(variable))
-      end
-
-      return Node.new(:mass_assign, nodes, metadata)
-    end
-
-    ##
-    # @param  [RubyLint::Node] variable The variable that was referenced.
-    # @return [RubyLint::Node]
-    #
-    def on_var_ref(variable)
-      variable = variable.updated(:local_variable) if variable.identifier?
-
-      return variable
-    end
-
-    ##
-    # @param [RubyLint::Node] object The object of the field.
-    # @param [Symbol] operator The operator used to separate the object and
-    #  field.
-    # @param [RubyLint::Node] field The field that was referenced.
-    # @return [RubyLint::Node]
-    #
-    def on_field(object, operator, field)
-      return Node.new(:field, [object, field], metadata)
-    end
-
-    ##
-    # Called when a method without parenthesis is called.
-    #
-    # @see RubyLint::Parser#on_method_add_arg
-    #
-    def on_command(name, params)
-      return Node.new(
-        :method,
-        [name.children[0], on_params(params), nil, nil],
-        metadata(name)
-      )
-    end
-
-    ##
-    # Called when a method is invoked on an object.
-    #
-    # @param  [RubyLint::Node] object The object the method was invoked on.
-    # @param  [Symbol] operator The operator used for the method call.
-    # @param  [RubyLint::Node] name The name of the method.
-    # @return [RubyLint::Node]
-    #
-    def on_call(object, operator, name)
-      return Node.new(
-        :method,
-        [name.children[0], on_params, nil, object],
-        metadata(name)
-      )
-    end
-
-    ##
-    # Called when a method is invoked on an object without the use of
-    # parenthesis.
-    #
-    # @see RubyLint::Parser#on_call
-    #
-    def on_command_call(object, operator, name, params)
-      node        = on_call(object, operator, name)
-      children    = node.children.dup
-      children[1] = on_params(params)
-
-      return node.updated(nil, children)
-    end
-
-    ##
-    # @param  [RubyLint::Node] method The method that is called.
-    # @param  [RubyLint::Node|Array] params Array of parameters passed to the
-    #  method.
-    # @return [RubyLint::Node]
-    #
-    def on_method_add_arg(method, params)
-      children = method.children.dup
-
-      if !params.is_a?(Array)
-        children[1] = params
-      end
-
-      return method.updated(nil, children)
-    end
-
-    ##
-    # @param [Mixed] arguments
-    # @param [Mixed] block
-    #
-    def on_args_add_block(arguments, block)
-      return on_params(arguments, nil, nil, nil, block)
-    end
-
-    ##
-    # @param [Mixed] arguments
-    # @param [Mixed] splat
-    # @return [Array]
-    #
-    def on_args_add_star(arguments, splat)
-      # Ripper isn't exactly consistent with its output. In certain cases, such
-      # `*(foo = something_else)` splat will be set to an Array instead of the
-      # assignment node.
-      splat = splat[0] if splat.is_a?(Array)
-
-      return arguments << Node.new(:splat_argument, [splat], metadata(splat))
-    end
-
-    ##
-    # @param  [RubyLint::Node] method The method node.
-    # @param  [RubyLint::Node] block The block passed to the method.
-    # @return [RubyLint::Node]
-    #
-    def on_method_add_block(method, block)
-      children        = method.children.dup
-      index           = method.type == :super ? 1 : -2
-      children[index] = block
-
-      return method.updated(nil, children)
-    end
-
-    ##
-    # @param  [RubyLint::Node] name The name of the method.
-    # @param  [Array] params The parameters of the method.
-    # @param  [Array] body The body of the method.
-    # @return [RubyLint::Node]
-    #
-    def on_def(name, params, body)
-      return Node.new(
-        :method_definition,
-        [name.children[0], params, nil, body],
-        metadata(name)
-      )
-    end
-
-    ##
-    # Called when a method definition using a receiver is found.
-    #
-    # @see RubyLint::Parser#on_def
-    #
-    def on_defs(receiver, operator, name, params, body)
-      return Node.new(
-        :method_definition,
-        [name.children[0], params, receiver, body],
-        metadata(name)
-      )
-    end
-
-    ##
-    # Called when a set of method parameters if found.
-    #
-    # @param  [Array] params The specified parameters.
-    # @return [Array]
-    #
-    def on_params(*params)
-      if params[0].is_a?(Node) and params[0].type == :arguments
-        return params[0]
-      end
-
-      if params[1]
-        params[1] = remap_optional_arguments(params[1])
-      end
-
-      params = group_arguments(params)
-
-      return Node.new(:arguments, params, metadata)
-    end
-
-    ##
-    # @param [RubyLint::Node] statement The statement to evaluate.
-    # @param [Array] body The body of the if statement.
-    # @param [Array|NilClass] rest The rest of the statement, includes the
-    #  elsif and else statements.
-    # @return [RubyLint::Node]
-    #
-    def on_if(statement, body, rest = nil)
-      elsif_stmts = []
-      else_stmt   = nil
-
-      rest ||= []
-      rest   = [rest] unless rest.is_a?(Array)
-
-      rest.compact.each do |node|
-        if node.type == :else
-          else_stmt = node
-        else
-          elsif_stmts << node
-        end
-      end
-
-      return Node.new(
-        :if,
-        [statement, body, elsif_stmts.reverse, else_stmt],
-        metadata
-      )
-    end
-
-    ##
-    # Called when a ternary operator is found.
-    #
-    # @param [RubyLint::Node] statement The statement to evaluate.
-    # @param [RubyLint::Node] true_val The value to use when the statement
-    #  evaluates to true.
-    # @param [RubyLint::Node] false_val The value to use when the statement
-    #  evaluates to false.
-    # @return [RubyLint::Node]
-    #
-    def on_ifop(statement, true_val, false_val)
-      return Node.new(
-        :ternary,
-        [statement, true_val, false_val],
-        metadata
-      )
-    end
-
-    ##
-    # @param [RubyLint::Node] statement The statement to evaluate.
-    # @param [Array] body The body of the statement.
-    # @param [Array] list Array containing the rest of the if statement.
-    # @return [RubyLint::Node]
-    #
-    def on_elsif(statement, body, list)
-      node = Node.new(:elsif, [statement, body], metadata)
-      list = [list] unless list.is_a?(Array)
-
-      list << node
-    end
-
-    ##
-    # @param [Array|RubyLint::Node] variables The variables to create for each
-    #  iteration.
-    # @param [RubyLint::Node] enumerator The value to iterate over.
-    # @param [Array] body The body of the statement.
-    # @return [RubyLint::Node]
-    #
-    def on_for(variables, enumerator, body)
-      variables = [variables] unless variables.is_a?(Array)
-      variables.map! { |n| n.updated(:local_variable) if n.identifier? }
-
-      return Node.new(
-        :for,
-        [variables, enumerator, body],
-        metadata(variables[0])
-      )
-    end
-
-    ##
-    # @param [Array] exceptions A list of exceptions to catch.
-    # @param [RubyLint::Variable|NilClass] variable The variable to store
-    #  information in about the exception.
-    # @param [Array] body The body of the statement.
-    # @param [Array] list Array containing all the rescue, else and ensure
-    #  statements.
-    # @return [RubyLint::Node]
-    #
-    def on_rescue(exceptions, variable, body, list)
-      list = list.is_a?(Array) ? list : [list].compact
-
-      if variable and variable.identifier?
-        variable = variable.updated(:local_variable)
-      end
-
-      list.unshift(
-        Node.new(:rescue, [nil, exceptions, variable, body], metadata)
-      )
-    end
-
-    ##
-    # @param [RubyLint::Node] statement The statement for which to catch
-    #  errors.
-    # @param [RubyLint::Node] body The code to execute when an error was
-    #  raised.
-    # @return [RubyLint::Node]
-    #
-    def on_rescue_mod(statement, body)
-      return Node.new(:rescue, [statement, nil, nil, body], metadata)
-    end
-
-    ##
-    # @param [RubyLint::Node] statement The statement to evaluate.
-    # @param [Array] body The body of the case block such as all the when
-    #  statements.
-    # @return [RubyLint::Node]
-    #
-    def on_case(statement, body)
-      when_statements = []
-      else_statement  = nil
-
-      body.each do |node|
-        if node.type == :when
-          when_statements << node
-        else
-          else_statement = node
-        end
-      end
-
-      return Node.new(
-        :case,
-        [statement, when_statements, else_statement],
-        metadata
-      )
-    end
-
-    ##
-    # @param [RubyLint::Node|Array] values The values to match on.
-    # @param [RubyLint::Node] body The body of the statement.
-    # @param [RubyLint::Node|Array] list The list of other when and else nodes.
-    # @return [RubyLint::Node]
-    #
-    def on_when(values, body, list)
-      list   = [list].compact unless list.is_a?(Array)
-      values = [values] unless values.is_a?(Array)
-
-      node = Node.new(:when, [values, body], metadata)
-
-      list.unshift(node)
-    end
-
-    ##
-    # @return [RubyLint::Node]
-    #
-    def on_zsuper
-      return on_super(nil)
-    end
-
-    private
-
-    ##
-    # Returns a more readable version of a Ripper type name.
-    #
-    # @param  [Symbol] type The type to convert.
-    # @return [Symbol]
-    #
-    def readable_type_name(type)
-      return TYPE_MAPPING.fetch(type, type)
-    end
-
-    ##
-    # Returns a Hash containing metadata such as the line number and the file.
-    #
-    # @param [RubyLint::Node] node When set the line and column number will be
-    #  extracted from this node.
-    # @return [Hash]
-    #
-    def metadata(node = nil)
-      line = node ? node.line   : lineno
-      col  = node ? node.column : column
-
-      return {:line => line, :column => col, :file => @file}
-    end
-
-    ##
-    # Groups a set of parameters into nodes based on the indexes.
-    #
-    # @param [Array] nodes
-    # @return [Array]
-    #
-    def group_arguments(nodes)
-      new_nodes = []
-
-      nodes.each_with_index do |node, index|
-        if !node or (node.is_a?(Array) and node.empty?)
-          next
-        end
-
-        new_nodes << convert_argument_node(node, index)
-      end
+  class Parser
+    attr_reader :internal_parser
 
-      return new_nodes.flatten
+    def initialize
+      builder          = AST::Builder.new
+      @internal_parser = ::Parser::CurrentRuby.new(builder)
     end
 
     ##
-    # Remaps variable/value pairs of optional arguments into single nodes.
+    # Registers the consumer with the internal diagnostics handler.
     #
-    # @param [Array] nodes
-    # @return [Array]
+    # @param [#call] consumer
     #
-    def remap_optional_arguments(nodes)
-      return nodes.map do |node|
-        node[0].updated(nil, [node[0].children[0], node[1]])
-      end
+    def consumer=(consumer)
+      internal_parser.diagnostics.consumer = consumer
     end
 
     ##
-    # Converts a parameter node to a type based on its index.
+    # Parses a block of Ruby code and wraps the resulting AST in a root node.
     #
-    # @param [RubyLint::Node|Array] node
-    # @param [Numeric] index
-    # @return [Mixed]
+    # @param [String] code
+    # @param [String] file
+    # @param [Numeric] line
+    # @return [RubyLint::AST::Node]
     #
-    def convert_argument_node(node, index)
-      if node.is_a?(Array)
-        node = node.map { |n| convert_argument_node(n, index) }
-      else
-        if node.identifier?
-          node = node.updated(:local_variable)
-        end
+    def parse(code, file = '(ruby-lint)', line = 1)
+      buffer        = ::Parser::Source::Buffer.new(file, line)
+      buffer.source = code
+      ast           = internal_parser.parse(buffer)
 
-        if node.type != :splat_argument
-          node = Node.new(PARAMETER_INDEX_TYPES[index], [node])
-        end
-      end
+      internal_parser.reset
 
-      return node
+      return AST::Node.new(:root, [ast])
     end
   end # Parser
 end # RubyLint