ripper_ruby_parser 0.0.4 → 0.0.5

data/Rakefile

@@ -5,13 +5,13 @@ namespace :test do
   Rake::TestTask.new(:unit) do |t|
     t.libs = ['lib']
     t.test_files = FileList['test/unit/*_test.rb']
-    t.ruby_opts += ["-w"]
+    t.warning = true
   end
 
   Rake::TestTask.new(:end_to_end) do |t|
     t.libs = ['lib']
     t.test_files = FileList['test/end_to_end/*_test.rb']
-    t.ruby_opts += ["-w"]
+    t.warning = true
   end
 
   task :run => [:unit, :end_to_end]

data/lib/ripper_ruby_parser/commenting_sexp_builder.rb

@@ -7,6 +7,7 @@ module RipperRubyParser
       super
       @comment = nil
       @comment_stack = []
+      @in_symbol = false
     end
 
     def on_comment tok
@@ -18,22 +19,42 @@ module RipperRubyParser
     def on_kw tok
       case tok
       when "class", "def", "module"
-        @comment_stack.push @comment
-        @comment = nil
+        unless @in_symbol
+          @comment_stack.push [tok.to_sym, @comment]
+          @comment = nil
+        end
       end
       super
     end
 
+    def on_module *args
+      commentize(:module, super)
+    end
+
     def on_class *args
-      commentize(super)
+      commentize(:class, super)
+    end
+
+    def on_sclass *args
+      commentize(:class, super)
     end
 
     def on_def *args
-      commentize(super)
+      commentize(:def, super)
     end
 
-    def on_module *args
-      commentize(super)
+    def on_defs *args
+      commentize(:def, super)
+    end
+
+    def on_symbeg *args
+      @in_symbol = true
+      super
+    end
+
+    def on_symbol *args
+      @in_symbol = false
+      super
     end
 
     def on_parse_error *args
@@ -58,8 +79,13 @@ module RipperRubyParser
 
     private
 
-    def commentize exp
-      comment = @comment_stack.pop
+    def commentize name, exp
+      tok, comment = @comment_stack.pop
+      unless tok == name
+        p @comment_stack
+        p [tok, comment]
+        raise "Expected on_#{tok} event, got on_#{name}"
+      end
       if comment.nil?
         [:comment, "", exp]
       else

data/lib/ripper_ruby_parser/parser.rb

@@ -13,14 +13,28 @@ module RipperRubyParser
     end
 
     def parse source, filename='(string)', lineno=1
+      # FIXME: Allow parser class to be passed to #initialize also.
       parser = CommentingSexpBuilder.new(source, filename, lineno)
-      result = parser.parse
+
+      result = suppress_warnings { parser.parse }
       raise "Ripper parse failed." if result.nil?
+
       exp = Sexp.from_array(result)
+
       @processor.filename = filename
       @processor.extra_compatible = extra_compatible
       @processor.process exp
     end
+
+    private
+
+    def suppress_warnings
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
+      result = yield
+      $VERBOSE = old_verbose
+      result
+    end
   end
 end
 

data/lib/ripper_ruby_parser/sexp_handlers/arguments.rb

@@ -22,6 +22,11 @@ module RipperRubyParser
         end
         process(args)
       end
+
+      def process_rest_param exp
+        _, ident = exp.shift 2
+        s(:splat, process(ident))
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/arrays.rb

@@ -3,15 +3,7 @@ module RipperRubyParser
     module Arrays
       def process_array exp
         _, elems = exp.shift 2
-        elems = handle_potentially_typeless_sexp(elems)
-        elems.map! do |elem|
-          if elem.first.is_a? Symbol
-            elem
-          else
-            elem.first
-          end
-        end
-        s(:array, *elems)
+        s(:array, *handle_array_elements(elems))
       end
 
       def process_aref exp

data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb

@@ -21,11 +21,11 @@ module RipperRubyParser
           left.shift
         end
 
-        left = create_multiple_assignement_sub_types left
+        left = create_multiple_assignment_sub_types left
 
         right = process(right)
 
-        unless right.sexp_type == :array
+        unless [:array, :splat].include? right.sexp_type
           right = s(:to_ary, right)
         end
 
@@ -35,21 +35,30 @@ module RipperRubyParser
       def process_mrhs_new_from_args exp
         _, inner, last = exp.shift 3
         inner.map! {|item| process(item)}
-        inner.push process(last)
+        inner.push process(last) unless last.nil?
         s(:array, *inner)
       end
 
+      def process_mrhs_add_star exp
+        exp = generic_add_star exp
+        unless exp.first.is_a? Symbol
+          exp = exp.first
+        end
+        exp
+      end
+
       def process_mlhs_add_star exp
         generic_add_star exp
       end
 
       def process_mlhs_paren exp
         _, contents = exp.shift 2
+
         items = handle_potentially_typeless_sexp(contents)
 
-        items = create_multiple_assignement_sub_types items
+        return items if items.first.is_a? Symbol
 
-        s(:masgn, s(:array, *items))
+        s(:masgn, s(:array, *create_multiple_assignment_sub_types(items)))
       end
 
       def process_opassign exp
@@ -64,10 +73,14 @@ module RipperRubyParser
 
       private
 
-      def create_multiple_assignement_sub_types sexp_list
+      def create_multiple_assignment_sub_types sexp_list
         sexp_list.map! do |item|
           if item.sexp_type == :splat
-            s(:splat, create_valueless_assignment_sub_type(item[1]))
+            if item[1].nil?
+              s(:splat)
+            else
+              s(:splat, create_valueless_assignment_sub_type(item[1]))
+            end
           else
             create_valueless_assignment_sub_type item
           end
@@ -88,9 +101,11 @@ module RipperRubyParser
       def create_operator_assignment_sub_type lvalue, value, operator
         case lvalue.sexp_type
         when :aref_field
-          s(:op_asgn1, lvalue[1], s(:arglist, lvalue[2][1]), operator, value)
+          _, arr, arglist = lvalue
+          s(:op_asgn1, arr, arglist, operator, value)
         when :field
-          s(:op_asgn2, lvalue[1], :"#{lvalue[3][1]}=", operator, value)
+          _, obj, _, (_, field) = lvalue
+          s(:op_asgn2, obj, :"#{field}=", operator, value)
         else
           if operator == :"||"
             s(:op_asgn_or, lvalue, create_assignment_sub_type(lvalue, value))
@@ -104,9 +119,12 @@ module RipperRubyParser
       def create_regular_assignment_sub_type lvalue, value
         case lvalue.sexp_type
         when :aref_field
-          s(:attrasgn, lvalue[1], :[]=, s(:arglist, lvalue[2][1], value))
+          _, arr, arglist = lvalue
+          arglist << value
+          s(:attrasgn, arr, :[]=, arglist)
         when :field
-          s(:attrasgn, lvalue[1], :"#{lvalue[3][1]}=", s(:arglist, value))
+          _, obj, _, (_, field) = lvalue
+          s(:attrasgn, obj, :"#{field}=", s(:arglist, value))
         else
           create_assignment_sub_type lvalue, value
         end

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -4,7 +4,7 @@ module RipperRubyParser
       def process_method_add_block exp
         _, call, block = exp.shift 3
         block = process(block)
-        args = convert_block_args(block[1])
+        args = block[1]
         stmt = block[2].first
         if stmt.nil?
           s(:iter, process(call), args)
@@ -25,27 +25,36 @@ module RipperRubyParser
         _, normal, defaults, rest, _, block = exp.shift 6
 
         args = [*normal].map do |id|
-          extract_node_symbol id
+          process(id)
         end
 
         assigns = [*defaults].map do |pair|
-          sym = extract_node_symbol pair[0]
+          sym = process(pair[0])
           args << sym
-          val = process pair[1]
-          s(:lasgn, sym, val)
+          val = process(pair[1])
+          s(:lasgn, sym[1], val)
         end
 
-        # FIXME: Delay conflating all arguments until later, so that
-        # #convert_block_args doesn't need to tease this apart again.
-        add_arg_unless_nil(rest, args) {|name| :"*#{name}" }
+        args << process(rest) unless rest.nil?
+        args << process(block) unless block.nil?
+        args << s(:block, *assigns) if assigns.length > 0
 
-        add_arg_unless_nil(block, args) {|name| :"&#{name}" }
+        s(:args, *args)
+      end
 
-        if assigns.length > 0
-          args << s(:block, *assigns)
-        end
+      def process_block_var exp
+        _, args, _ = exp.shift 3
 
-        s(:args, *args)
+        names = process(args)
+        names.shift
+
+        if names.length == 1 and names.first.sexp_type == :lvar
+          s(:lasgn, names.first[1])
+        elsif names.length == 1 and names.first.sexp_type == :masgn
+          names.first
+        else
+          s(:masgn, s(:array, *names.map { |name| arg_name_to_lasgn(name) }))
+        end
       end
 
       def process_begin exp
@@ -57,7 +66,7 @@ module RipperRubyParser
       end
 
       def process_rescue exp
-        _, eclass, evar, block, _ = exp.shift 5
+        _, eclass, evar, block, after = exp.shift 5
         rescue_block = map_body(block)
 
         arr = []
@@ -76,34 +85,46 @@ module RipperRubyParser
           arr << easgn
         end
 
-        s(:resbody, s(:array, *arr),
-          wrap_in_block(rescue_block))
+        s(
+          s(:resbody, s(:array, *arr), wrap_in_block(rescue_block)),
+          *process(after))
       end
 
       def process_bodystmt exp
-        _, body, rescue_block, _, ensure_block = exp.shift 5
+        _, body, rescue_block, else_block, ensure_block = exp.shift 5
 
         body = map_body body
 
-        unless rescue_block or ensure_block
-          return s(:scope, s(:block, *body))
-        end
+        #unless rescue_block or ensure_block
+        #  return s(:scope, s(:block, *body))
+        #end
 
         body = wrap_in_block(body)
 
+        body = if body.nil?
+                 s()
+               else
+                 s(body)
+               end
+
         if rescue_block
-          if body.nil?
-            body = s(:rescue, process(rescue_block))
-          else
-            body = s(:rescue, body, process(rescue_block))
-          end
+          body.push(*process(rescue_block))
+          body << process(else_block) if else_block
+          body = s(s(:rescue, *body))
+        elsif else_block
+          body << process(else_block)
         end
 
         if ensure_block
-          body = s(:ensure, body, process(ensure_block))
+          body << process(ensure_block)
+          body = s(s(:ensure, *body))
         end
 
-        s(:scope, s(:block, body))
+        if body.length == 1 and body.first.sexp_type == :block
+          s(:scope, *body)
+        else
+          s(:scope, s(:block, *body))
+        end
       end
 
       def process_rescue_mod exp
@@ -154,12 +175,21 @@ module RipperRubyParser
         end
       end
 
-      def add_arg_unless_nil(item, args)
-        unless item.nil?
-          name = extract_node_symbol item[1]
-          args << yield(name)
+      def arg_name_to_lasgn(name)
+        case name.sexp_type
+        when :lvar
+          s(:lasgn, name[1])
+        when :splat
+          if name[1].nil?
+            s(:splat)
+          else
+            s(:splat, s(:lasgn, name[1][1]))
+          end
+        else
+          name
         end
       end
+
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -26,7 +26,7 @@ module RipperRubyParser
 
       def process_if_mod exp
         _, cond, truepart = exp.shift 3
-        s(:if, process(cond), process(truepart), nil)
+        process_if s(:if, cond, s(truepart), nil)
       end
 
       def process_unless_mod exp
@@ -59,8 +59,16 @@ module RipperRubyParser
           end
         end
 
-        s(s(:when,
-            process(s(:array, values)),
+        values = handle_array_elements values
+        values = values.map do |val|
+          if val.sexp_type == :splat
+            s(:when, val[1], nil)
+          else
+            val
+          end
+        end
+
+        s(s(:when, s(:array, *values),
             handle_statement_list(truepart)),
           *falsepart)
       end

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -23,25 +23,6 @@ module RipperRubyParser
         end
       end
 
-      def convert_block_args(args)
-        if args
-          names = args[1][1..-1]
-          if names.length > 1 or names.first =~ /^\*/
-            s(:masgn, s(:array, *names.map { |name| arg_name_to_lasgn(name) }))
-          else
-            s(:lasgn, names.first)
-          end
-        end
-      end
-
-      def arg_name_to_lasgn(name)
-        if name =~ /^\*(.*)/
-          s(:splat, s(:lasgn, $1.to_sym))
-        else
-          s(:lasgn, name)
-        end
-      end
-
       def handle_statement_list exp
         statements = map_body exp
 
@@ -60,8 +41,9 @@ module RipperRubyParser
         ident.to_sym
       end
 
-      def with_position pos, exp
+      def with_position pos, exp=nil
         (line, _) = pos
+        exp = yield if exp.nil?
         with_line_number line, exp
       end
 
@@ -77,9 +59,9 @@ module RipperRubyParser
 
       def generic_add_star exp
         _, args, splatarg = exp.shift 3
-        items = args.map { |sub| process(sub) }
+        items = handle_potentially_typeless_sexp args
         items << s(:splat, process(splatarg))
-        s(*items)
+        items
       end
 
       def is_literal? exp
@@ -118,6 +100,17 @@ module RipperRubyParser
           s(:array, *args)
         end
       end
+
+      def handle_array_elements elems
+        elems = handle_potentially_typeless_sexp(elems)
+        elems.map do |elem|
+          if elem.first.is_a? Symbol
+            elem
+          else
+            elem.first
+          end
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -41,6 +41,13 @@ module RipperRubyParser
         with_position_from_node_symbol(ident) {|method|
           s(:call, nil, method, s(:arglist)) }
       end
+
+      def process_super exp
+        _, args = exp.shift 2
+        args = process(args)
+        args.shift
+        s(:super, *args)
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -4,15 +4,17 @@ module RipperRubyParser
       def process_def exp
         _, ident, params, body = exp.shift 4
         ident, pos = extract_node_symbol_with_position ident
+        params = convert_special_args(process(params))
         with_position(pos,
-                      s(:defn, ident, process(params), method_body(body)))
+                      s(:defn, ident, params, method_body(body)))
       end
 
       def process_defs exp
-        _, receiver, _, method, args, body = exp.shift 6
+        _, receiver, _, method, params, body = exp.shift 6
+        params = convert_special_args(process(params))
         s(:defs, process(receiver),
           extract_node_symbol(method),
-          process(args), in_method { process(body) })
+          params, in_method { process(body) })
       end
 
       def process_return exp
@@ -81,6 +83,28 @@ module RipperRubyParser
         end
         scope
       end
+
+      SPECIAL_ARG_MARKER = {
+        :splat => "*",
+        :blockarg => "&"
+      }
+
+      def convert_special_args args
+        args.map! do |item|
+          if item.is_a? Symbol
+            item
+          else
+            if (marker = SPECIAL_ARG_MARKER[item.sexp_type])
+              name = extract_node_symbol item[1]
+              :"#{marker}#{name}"
+            elsif item.sexp_type == :lvar
+              item[1]
+            else
+              item
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -1,7 +1,7 @@
 module RipperRubyParser
   module SexpHandlers
     module Operators
-      BINARY_OPERTOR_MAP = {
+      BINARY_OPERATOR_MAP = {
         "&&".to_sym => :and,
         "||".to_sym => :or,
         :and => :and,
@@ -13,6 +13,11 @@ module RipperRubyParser
         :not => :not
       }
 
+      NEGATED_BINARY_OPERATOR_MAP = {
+        :"!~" => :=~,
+        :"!=" => :==
+      }
+
       def process_binary exp
         _, left, op, right = exp.shift 4
         if op == :=~
@@ -23,21 +28,18 @@ module RipperRubyParser
           else
             s(:call, process(left), op, s(:arglist, process(right)))
           end
-        elsif op == :"!="
-          s(:not, s(:call, process(left), :==, s(:arglist, process(right))))
-        else
-          mapped = BINARY_OPERTOR_MAP[op]
-          if mapped
-            left = process(left)
-            right = process(right)
-            if mapped == left.sexp_type
-              s(left.sexp_type, left[1], s(mapped, left[2], right))
-            else
-              s(mapped, left, right)
-            end
+        elsif (mapped = NEGATED_BINARY_OPERATOR_MAP[op])
+          s(:not, process(s(:binary, left, mapped, right)))
+        elsif (mapped = BINARY_OPERATOR_MAP[op])
+          left = process(left)
+          right = process(right)
+          if mapped == left.sexp_type
+            s(left.sexp_type, left[1], s(mapped, left[2], right))
           else
-            s(:call, process(left), op, s(:arglist, process(right)))
+            s(mapped, left, right)
           end
+        else
+          s(:call, process(left), op, s(:arglist, process(right)))
         end
       end
 

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -71,6 +71,11 @@ module RipperRubyParser
                        s(:class, const, parent, class_or_module_body(body)))
     end
 
+    def process_sclass exp
+      _, klass, block = exp.shift 3
+      s(:sclass, process(klass), class_or_module_body(block))
+    end
+
     def process_var_ref exp
       _, contents = exp.shift 2
       process(contents)
@@ -178,7 +183,14 @@ module RipperRubyParser
 
     def process_at_backref exp
       _, str, pos = exp.shift 3
-      with_position(pos, s(:nth_ref, str[1..-1].to_i))
+      name = str[1..-1]
+      with_position pos do
+        if name =~ /[0-9]/
+          s(:nth_ref, name.to_i)
+        else
+          s(:back_ref, name.to_sym)
+        end
+      end
     end
 
     private

data/lib/ripper_ruby_parser/version.rb

@@ -1,3 +1,3 @@
 module RipperRubyParser
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/test/end_to_end/comments_test.rb

@@ -2,22 +2,6 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 
 describe "Using RipperRubyParser and RubyParser" do
-  def to_comments exp
-    inner = exp.map do |sub_exp|
-      if sub_exp.is_a? Sexp
-        to_comments sub_exp
-      else
-        sub_exp
-      end
-    end
-
-    if exp.comments.nil?
-      s(*inner)
-    else
-      s(:comment, exp.comments, s(*inner))
-    end
-  end
-
   let :newparser do
     RipperRubyParser::Parser.new
   end

data/test/end_to_end/samples_comparison_test.rb

@@ -16,13 +16,23 @@ describe "Using RipperRubyParser and RubyParser" do
         File.read file
       end
 
-      it "gives the same result" do
+      let :original do
+        oldparser.parse program
+      end
+
+      let :imitation do
         newparser.extra_compatible = true
-        original = oldparser.parse program
-        imitation = newparser.parse program
+        newparser.parse program
+      end
 
+      it "gives the same result" do
         formatted(imitation).must_equal formatted(original)
       end
+
+      it "gives the same result with comments" do
+        formatted(to_comments(imitation)).
+          must_equal formatted(to_comments(original))
+      end
     end
   end
 end

data/test/test_helper.rb

@@ -9,16 +9,36 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'ripper_ruby_parser'
 
-class MiniTest::Unit::TestCase
+class MiniTest::Spec
   def formatted exp
     exp.to_s.gsub(/\), /, "),\n")
   end
 
-  def suppress_warnings
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-    result = yield
-    $VERBOSE = old_verbose
-    result
+  def to_comments exp
+    inner = exp.map do |sub_exp|
+      if sub_exp.is_a? Sexp
+        to_comments sub_exp
+      else
+        sub_exp
+      end
+    end
+
+    comments = exp.comments.to_s.gsub(/\n\s*\n/, "\n")
+    if comments.empty?
+      s(*inner)
+    else
+      s(:comment, comments, s(*inner))
+    end
+  end
+
+  def assert_parsed_as sexp, code
+    parser = RipperRubyParser::Parser.new
+    result = parser.parse code
+    assert_equal sexp, result
   end
 end
+
+module MiniTest::Expectations
+  infect_an_assertion :assert_parsed_as, :must_be_parsed_as
+end
+

data/test/unit/parser_assignment_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for multiple assignment" do
+      specify do
+        "foo, * = bar".
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:splat)),
+                              s(:to_ary, s(:call, nil, :bar, s(:arglist))))
+      end
+
+      specify do
+        "(foo, *bar) = baz".
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:lasgn, :foo),
+                                s(:splat, s(:lasgn, :bar))),
+                              s(:to_ary, s(:call, nil, :baz, s(:arglist))))
+      end
+    end
+
+    describe "for assignment to a collection element" do
+      it "handles multiple indices" do
+        "foo[bar, baz] = qux".
+          must_be_parsed_as s(:attrasgn,
+                              s(:call, nil, :foo, s(:arglist)),
+                              :[]=,
+                              s(:arglist,
+                                s(:call, nil, :bar, s(:arglist)),
+                                s(:call, nil, :baz, s(:arglist)),
+                                s(:call, nil, :qux, s(:arglist))))
+      end
+    end
+
+    describe "for operator assignment" do
+      describe "assigning to a collection element" do
+        it "handles multiple indices" do
+          "foo[bar, baz] += qux".
+            must_be_parsed_as s(:op_asgn1,
+                                s(:call, nil, :foo, s(:arglist)),
+                                s(:arglist,
+                                  s(:call, nil, :bar, s(:arglist)),
+                                  s(:call, nil, :baz, s(:arglist))),
+                                :+,
+                                s(:call, nil, :qux, s(:arglist)))
+        end
+      end
+    end
+
+    describe "for multiple assignment" do
+      describe "with a right-hand splat" do
+        specify do
+          "foo, bar = *baz".
+            must_be_parsed_as s(:masgn,
+                                s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                                s(:splat, s(:call, nil, :baz, s(:arglist))))
+        end
+        specify do
+          "foo, bar = baz, *qux".
+            must_be_parsed_as s(:masgn,
+                                s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                                s(:array,
+                                  s(:call, nil, :baz, s(:arglist)),
+                                  s(:splat, s(:call, nil, :qux, s(:arglist)))))
+        end
+      end
+    end
+  end
+end

data/test/unit/parser_blocks_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for block parameters" do
+      specify do
+        "foo do |(bar, baz)| end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :bar),
+                                  s(:lasgn, :baz))))
+      end
+
+      specify do
+        "foo do |(bar, *baz)| end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :bar),
+                                  s(:splat, s(:lasgn, :baz)))))
+      end
+
+      specify do
+        "foo do |bar,*| end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:masgn, s(:array, s(:lasgn, :bar), s(:splat))))
+      end
+
+      it "behaves differently from RubyParser with a trailing comma in the block parameters" do
+        "foo do |bar, | end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:lasgn, :bar))
+      end
+    end
+
+    describe "for rescue/else/ensure" do
+      it "works for a block with multiple rescue statements" do
+        "begin foo; rescue; bar; rescue; baz; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :bar, s(:arglist))),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works for a block with rescue and else" do
+        "begin; foo; rescue; bar; else; baz; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :bar, s(:arglist))),
+                              s(:call, nil, :baz, s(:arglist)))
+      end
+
+      it "works for a block with only else" do
+        "begin; foo; else; bar; end".
+          must_be_parsed_as s(:block,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist)))
+      end
+    end
+  end
+end

data/test/unit/parser_conditionals_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for postfix if" do
+      it "normalizes negative conditions" do
+        "foo if not bar".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :bar, s(:arglist)),
+                              nil,
+                              s(:call, nil, :foo, s(:arglist)))
+      end
+    end
+
+    describe "for case" do
+      it "emulates RubyParser's strange handling of splat" do
+        "case foo; when *bar; baz; end".
+          must_be_parsed_as s(:case, s(:call, nil, :foo, s(:arglist)),
+                              s(:when,
+                                s(:array,
+                                  s(:when, s(:call, nil, :bar, s(:arglist)),
+                                  nil)),
+                                s(:call, nil, :baz, s(:arglist))),
+                              nil)
+
+      end
+    end
+  end
+end

data/test/unit/parser_method_calls_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for calls to super" do
+      specify { "super".must_be_parsed_as s(:zsuper) }
+      specify { "super foo".must_be_parsed_as s(:super,
+                                                s(:call, nil, :foo, s(:arglist))) }
+      specify {
+        "super foo, bar".must_be_parsed_as s(:super,
+                                             s(:call, nil, :foo, s(:arglist)),
+                                             s(:call, nil, :bar, s(:arglist))) }
+      specify {
+        "super foo, *bar".must_be_parsed_as s(:super,
+                                              s(:call, nil, :foo, s(:arglist)),
+                                              s(:splat,
+                                                s(:call, nil, :bar, s(:arglist)))) }
+      specify {
+        "super foo, *bar, &baz".
+          must_be_parsed_as s(:super,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:splat, s(:call, nil, :bar, s(:arglist))),
+                              s(:block_pass, s(:call, nil, :baz, s(:arglist)))) }
+    end
+  end
+end
+

data/test/unit/parser_operators_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for negated operators" do
+      specify do
+        "foo !~ bar".must_be_parsed_as s(:not,
+                                         s(:call,
+                                           s(:call, nil, :foo, s(:arglist)),
+                                           :=~,
+                                           s(:arglist,
+                                             s(:call, nil, :bar, s(:arglist)))))
+      end
+    end
+  end
+end

data/test/unit/parser_test.rb

@@ -29,6 +29,10 @@ describe RipperRubyParser::Parser do
                             nil,
                             s(:scope))
       end
+
+      it "works for singleton classes" do
+        "class << self; end".must_be_parsed_as s(:sclass, s(:self), s(:scope))
+      end
     end
 
     describe "for a module declaration" do
@@ -254,8 +258,7 @@ describe RipperRubyParser::Parser do
 
     describe "for the for statement" do
       it "works with do" do
-        result = suppress_warnings {
-          parser.parse "for foo in bar do; baz; end" }
+        result = parser.parse "for foo in bar do; baz; end"
         result.must_equal s(:for,
                             s(:call, nil, :bar, s(:arglist)),
                             s(:lasgn, :foo),
@@ -263,8 +266,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works without do" do
-        result = suppress_warnings {
-          parser.parse "for foo in bar; baz; end" }
+        result = parser.parse "for foo in bar; baz; end"
         result.must_equal s(:for,
                             s(:call, nil, :bar, s(:arglist)),
                             s(:lasgn, :foo),
@@ -321,8 +323,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with assignment to an error variable" do
-        result = suppress_warnings {
-          parser.parse "begin; foo; rescue => e; bar; end" }
+        result = parser.parse "begin; foo; rescue => e; bar; end"
         result.must_equal s(:rescue,
                             s(:call, nil, :foo, s(:arglist)),
                             s(:resbody,
@@ -340,8 +341,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with filtering of the exception type and assignment to an error variable" do
-        result = suppress_warnings {
-          parser.parse "begin; foo; rescue Bar => e; baz; end" }
+        result = parser.parse "begin; foo; rescue Bar => e; baz; end"
         result.must_equal s(:rescue,
                             s(:call, nil, :foo, s(:arglist)),
                             s(:resbody,
@@ -1188,6 +1188,9 @@ describe RipperRubyParser::Parser do
         result.must_equal s(:nth_ref, 1)
       end
 
+      specify { "$'".must_be_parsed_as s(:back_ref, :"'") }
+      specify { "$&".must_be_parsed_as s(:back_ref, :"&") }
+
       it "works for class variables" do
         result = parser.parse "@@foo"
         result.must_equal s(:cvar, :@@foo)
@@ -1263,7 +1266,7 @@ describe RipperRubyParser::Parser do
 
     describe "for operator assignment" do
       it "works with +=" do
-        result = suppress_warnings { parser.parse "foo += bar" }
+        result = parser.parse "foo += bar"
         result.must_equal s(:lasgn,
                             :foo,
                             s(:call,
@@ -1273,7 +1276,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with -=" do
-        result = suppress_warnings { parser.parse "foo -= bar" }
+        result = parser.parse "foo -= bar"
         result.must_equal s(:lasgn,
                             :foo,
                             s(:call,
@@ -1283,7 +1286,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with ||=" do
-        result = suppress_warnings { parser.parse "foo ||= bar" }
+        result = parser.parse "foo ||= bar"
         result.must_equal s(:op_asgn_or,
                             s(:lvar, :foo),
                             s(:lasgn, :foo,
@@ -1339,7 +1342,7 @@ describe RipperRubyParser::Parser do
 
     describe "for multiple assignment" do
       it "works the same number of items on each side" do
-        result = suppress_warnings { parser.parse "foo, bar = baz, qux" }
+        result = parser.parse "foo, bar = baz, qux"
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                             s(:array,
@@ -1348,7 +1351,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with a single item on the right-hand side" do
-        result = suppress_warnings { parser.parse "foo, bar = baz" }
+        result = parser.parse "foo, bar = baz"
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                             s(:to_ary,
@@ -1356,7 +1359,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with left-hand splat" do
-        result = suppress_warnings { parser.parse "foo, *bar = baz, qux" }
+        result = parser.parse "foo, *bar = baz, qux"
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
                             s(:array,
@@ -1365,7 +1368,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with brackets around the left-hand side" do
-        result = suppress_warnings { parser.parse "(foo, bar) = baz" }
+        result = parser.parse "(foo, bar) = baz"
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                             s(:to_ary,
@@ -1373,7 +1376,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with complex destructuring" do
-        result = suppress_warnings { parser.parse "foo, (bar, baz) = qux" }
+        result = parser.parse "foo, (bar, baz) = qux"
         result.must_equal s(:masgn,
                             s(:array,
                               s(:lasgn, :foo),
@@ -1620,7 +1623,7 @@ describe RipperRubyParser::Parser do
 
     describe "for expressions" do
       it "handles assignment inside binary operator expressions" do
-        result = suppress_warnings { parser.parse "foo + (bar = baz)" }
+        result = parser.parse "foo + (bar = baz)"
         result.must_equal s(:call,
                             s(:call, nil, :foo, s(:arglist)),
                             :+,
@@ -1631,7 +1634,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "handles assignment inside unary operator expressions" do
-        result = suppress_warnings { parser.parse "+(foo = bar)" }
+        result = parser.parse "+(foo = bar)"
         result.must_equal s(:call,
                             s(:lasgn, :foo, s(:call, nil, :bar, s(:arglist))),
                             :+@,
@@ -1650,6 +1653,15 @@ describe RipperRubyParser::Parser do
         result.comments.must_equal "# Foo\n"
       end
 
+      it "handles comments for methods with explicit receiver" do
+        result = parser.parse "# Foo\ndef foo.bar; end"
+        result.must_equal s(:defs,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :bar,
+                            s(:args), s(:scope, s(:block)))
+        result.comments.must_equal "# Foo\n"
+      end
+
       it "matches comments to the correct entity" do
         result = parser.parse "# Foo\nclass Foo\n# Bar\ndef bar\nend\nend"
         result.must_equal s(:class, :Foo, nil,
@@ -1669,6 +1681,27 @@ describe RipperRubyParser::Parser do
                             s(:args), s(:scope, s(:block, s(:nil))))
         result.comments.must_equal "# Foo\n# Bar\n"
       end
+
+      it "handles the use of symbols that are keywords" do
+        result = parser.parse "# Foo\ndef bar\n:class\nend"
+        result.must_equal s(:defn,
+                            :bar,
+                            s(:args),
+                            s(:scope, s(:block, s(:lit, :class))))
+        result.comments.must_equal "# Foo\n"
+      end
+
+      it "handles use of singleton class inside methods" do
+        result = parser.parse "# Foo\ndef bar\nclass << self\nbaz\nend\nend"
+        result.must_equal s(:defn,
+                            :bar,
+                            s(:args),
+                            s(:scope,
+                              s(:block,
+                                s(:sclass, s(:self),
+                                  s(:scope, s(:call, nil, :baz, s(:arglist)))))))
+        result.comments.must_equal "# Foo\n"
+      end
     end
 
     # Note: differences in the handling of line numbers are not caught by
@@ -1786,12 +1819,12 @@ describe RipperRubyParser::Parser do
       end
 
       it "works for assignment of the empty hash" do
-        result = suppress_warnings { parser.parse "foo = {}" }
+        result = parser.parse "foo = {}"
         result.line.must_equal 1
       end
 
       it "works for multiple assignment of empty hashes" do
-        result = suppress_warnings { parser.parse "foo, bar = {}, {}" }
+        result = parser.parse "foo, bar = {}, {}"
         result.line.must_equal 1
       end
 

data/test/unit/sexp_processor_test.rb

@@ -185,11 +185,11 @@ describe RipperRubyParser::SexpProcessor do
     end
 
     describe "for a :params sexp" do
-      describe "with a normal argument" do
-        it "uses the bare argument names" do
+      describe "with a normal arguments" do
+        it "creates :lvar sexps" do
           sexp =  s(:params, s(s(:@ident, "bar", s(1, 8))), nil, nil, nil, nil)
           result = processor.process sexp
-          result.must_equal s(:args, :bar)
+          result.must_equal s(:args, s(:lvar, :bar))
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ripper_ruby_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-31 00:00:00.000000000 Z
+date: 2012-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &22929360 !ruby/object:Gem::Requirement
+  requirement: &18762580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *22929360
+  version_requirements: *18762580
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &22928840 !ruby/object:Gem::Requirement
+  requirement: &18762060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 2.11.2
   type: :development
   prerelease: false
-  version_requirements: *22928840
+  version_requirements: *18762060
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &22928360 !ruby/object:Gem::Requirement
+  requirement: &18761580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *22928360
+  version_requirements: *18761580
 - !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &22927880 !ruby/object:Gem::Requirement
+  requirement: &18761100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.3.1
   type: :development
   prerelease: false
-  version_requirements: *22927880
+  version_requirements: *18761100
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &22927500 !ruby/object:Gem::Requirement
+  requirement: &18760720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *22927500
+  version_requirements: *18760720
 description: 
 email:
 - matijs@matijs.net
@@ -103,8 +103,13 @@ files:
 - test/end_to_end/line_numbering_test.rb
 - test/end_to_end/error_conditions_test.rb
 - test/unit/parser_test.rb
+- test/unit/parser_blocks_test.rb
 - test/unit/sexp_processor_test.rb
+- test/unit/parser_operators_test.rb
+- test/unit/parser_conditionals_test.rb
 - test/unit/version_test.rb
+- test/unit/parser_assignment_test.rb
+- test/unit/parser_method_calls_test.rb
 - test/unit/commenting_sexp_builder_test.rb
 - README.rdoc
 - Rakefile
@@ -144,6 +149,11 @@ test_files:
 - test/end_to_end/test_comparison_test.rb
 - test/test_helper.rb
 - test/unit/commenting_sexp_builder_test.rb
+- test/unit/parser_assignment_test.rb
+- test/unit/parser_blocks_test.rb
+- test/unit/parser_conditionals_test.rb
+- test/unit/parser_method_calls_test.rb
+- test/unit/parser_operators_test.rb
 - test/unit/parser_test.rb
 - test/unit/sexp_processor_test.rb
 - test/unit/version_test.rb