ripper_ruby_parser 0.0.5 → 0.0.6

data/lib/ripper_ruby_parser/parser.rb

@@ -23,7 +23,13 @@ module RipperRubyParser
 
       @processor.filename = filename
       @processor.extra_compatible = extra_compatible
-      @processor.process exp
+      result = @processor.process exp
+
+      if result == s(:void_stmt)
+        nil
+      else
+        result
+      end
     end
 
     private

data/lib/ripper_ruby_parser/sexp_handlers/arrays.rb

@@ -7,8 +7,13 @@ module RipperRubyParser
       end
 
       def process_aref exp
-        _, item, idx = exp.shift 3
-        s(:call, process(item), :[], process(idx))
+        _, coll, idx = exp.shift 3
+
+        coll = process(coll)
+        coll = nil if coll == s(:self)
+
+        idx = process(idx) || s(:arglist)
+        s(:call, coll, :[], idx)
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb

@@ -98,6 +98,11 @@ module RipperRubyParser
         return item
       end
 
+      OPERATOR_ASSIGNMENT_MAP = {
+        :"||" => :op_asgn_or,
+        :"&&" => :op_asgn_and
+      }
+
       def create_operator_assignment_sub_type lvalue, value, operator
         case lvalue.sexp_type
         when :aref_field
@@ -107,8 +112,8 @@ module RipperRubyParser
           _, obj, _, (_, field) = lvalue
           s(:op_asgn2, obj, :"#{field}=", operator, value)
         else
-          if operator == :"||"
-            s(:op_asgn_or, lvalue, create_assignment_sub_type(lvalue, value))
+          if (mapped = OPERATOR_ASSIGNMENT_MAP[operator])
+            s(mapped, lvalue, create_assignment_sub_type(lvalue, value))
           else
             operator_call = s(:call, lvalue, operator, s(:arglist, value))
             create_assignment_sub_type lvalue, operator_call

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -81,7 +81,7 @@ module RipperRubyParser
 
         if evar
           evar = process(evar)[1]
-          easgn = s(:lasgn, :e, s(:gvar, :$!))
+          easgn = s(:lasgn, evar, s(:gvar, :$!))
           arr << easgn
         end
 

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -20,7 +20,35 @@ module RipperRubyParser
 
       def process_string_embexpr exp
         _, list = exp.shift 2
-        s(:evstr, process(list.first))
+        val = process(list.first)
+        if val.sexp_type == :str
+          val
+        else
+          s(:evstr, val)
+        end
+      end
+
+      def process_string_dvar exp
+        _, list = exp.shift 2
+        val = process(list)
+        s(:evstr, val)
+      end
+
+      def process_string_concat exp
+        _, left, right = exp.shift 3
+
+        left = process(left)
+        right = process(right)
+
+        if left.sexp_type == :str
+          right[1] = left[1] + right[1]
+          right
+        else # Expecting left.sexp_type == :dstr
+          _, first, *rest = right
+          left.push s(:str, first)
+          left.push(*rest)
+          left
+        end
       end
 
       def process_xstring_literal exp
@@ -37,11 +65,7 @@ module RipperRubyParser
         _, content, (_, flags, _) = exp.shift 3
 
         string, rest = extract_string_parts content
-
-        numflags = 0
-        flags =~ /m/ and numflags |= Regexp::MULTILINE
-        flags =~ /x/ and numflags |= Regexp::EXTENDED
-        flags =~ /i/ and numflags |= Regexp::IGNORECASE
+        numflags = character_flags_to_numerical flags
 
         if rest.empty?
           s(:lit, Regexp.new(string, numflags))
@@ -104,6 +128,11 @@ module RipperRubyParser
           rest << result
         end
 
+        while not(rest.empty?) and rest.first.sexp_type == :str
+          str = rest.shift
+          string += str[1]
+        end
+
         return string, rest
       end
 
@@ -121,11 +150,61 @@ module RipperRubyParser
         return string, rest
       end
 
+      SINGLE_LETTER_ESCAPES = {
+        "a" => "\a",
+        "b" => "\b",
+        "e" => "\e",
+        "f" => "\f",
+        "n" => "\n",
+        "r" => "\r",
+        "s" => "\s",
+        "t" => "\t",
+        "v" => "\v",
+      }
+
+      SINGLE_LETTER_ESCAPES_REGEXP =
+        Regexp.new("^[#{SINGLE_LETTER_ESCAPES.keys.join}]$")
+
       def unescape string
-        string.gsub(/(\\[^)])/) do
-          eval "\"#{$1}\""
+        string.gsub(/\\(
+          [0-7]{1,3}        | # octal character
+          x[0-9a-fA-F]{1,2} | # hex byte
+          u[0-9a-fA-F]{4}   | # unicode character
+          C-.               | # control (regular)
+          c.                | # control (shorthand)
+          .                   # single-character
+        )/x) do
+          bare = $1
+          case bare
+          when SINGLE_LETTER_ESCAPES_REGEXP
+            SINGLE_LETTER_ESCAPES[bare]
+          when /^x/
+            bare[1..-1].to_i(16).chr
+          when /^u/
+            bare[1..-1].to_i(16).chr(Encoding::UTF_8)
+          when /^(c|C-)(.)$/
+            ($2.ord & 0b1001_1111).chr
+          when /^[0-7]+/
+            bare.to_i(8).chr
+          else
+            bare
+          end
         end
       end
+
+      def character_flags_to_numerical flags
+        numflags = 0
+
+        flags =~ /m/ and numflags |= Regexp::MULTILINE
+        flags =~ /x/ and numflags |= Regexp::EXTENDED
+        flags =~ /i/ and numflags |= Regexp::IGNORECASE
+
+        flags =~ /n/ and numflags |= Regexp::NOENCODING
+        flags =~ /[ues]/ and numflags |= Regexp::FIXEDENCODING
+
+        numflags
+      end
+
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -3,20 +3,30 @@ module RipperRubyParser
     module Loops
       def process_until exp
         _, cond, block = exp.shift 3
-        s(:until, process(cond), handle_statement_list(block), true)
+
+        make_until(process(cond), handle_statement_list(block), true)
       end
 
       def process_until_mod exp
         _, cond, block = exp.shift 3
 
-        check_at_start = block.sexp_type != :begin
+        check_at_start = check_at_start?(block)
 
-        s(:until, process(cond), process(block), check_at_start)
+        make_until(process(cond), process(block), check_at_start)
       end
 
       def process_while exp
         _, cond, block = exp.shift 3
-        s(:while, process(cond), handle_statement_list(block), true)
+
+        make_while(process(cond), handle_statement_list(block), true)
+      end
+
+      def process_while_mod exp
+        _, cond, block = exp.shift 3
+
+        check_at_start = check_at_start?(block)
+
+        make_while(process(cond), process(block), check_at_start)
       end
 
       def process_for exp
@@ -25,6 +35,28 @@ module RipperRubyParser
           s(:lasgn, process(var)[1]),
           handle_statement_list(block))
       end
+
+      private
+
+      def make_guarded_block(type, inverse, cond, block, check_at_start)
+        if cond.sexp_type == :not
+          type = inverse
+          cond = cond[1]
+        end
+        s(type, cond, block, check_at_start)
+      end
+
+      def make_until(cond, block, check_at_start)
+        make_guarded_block(:until, :while, cond, block, check_at_start)
+      end
+
+      def make_while(cond, block, check_at_start)
+        make_guarded_block(:while, :until, cond, block, check_at_start)
+      end
+
+      def check_at_start?(block)
+        block.sexp_type != :begin
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -20,6 +20,7 @@ module RipperRubyParser
 
       def process_binary exp
         _, left, op, right = exp.shift 4
+
         if op == :=~
           if left.sexp_type == :regexp_literal
             s(:match2, process(left), process(right))
@@ -31,13 +32,7 @@ module RipperRubyParser
         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(mapped, left, right)
-          end
+          rebalance_binary(s(mapped, process(left), process(right)))
         else
           s(:call, process(left), op, s(:arglist, process(right)))
         end
@@ -73,6 +68,18 @@ module RipperRubyParser
         _, cond, truepart, falsepart = exp.shift 4
         s(:if, process(cond), process(truepart), process(falsepart))
       end
+
+      private
+
+      def rebalance_binary exp
+        op, left, right = exp
+
+        if op == left.sexp_type
+          s(op, left[1], rebalance_binary(s(op, left[2], right)))
+        else
+          s(op, left, right)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -48,12 +48,8 @@ module RipperRubyParser
     def process_program exp
       _, content = exp.shift 2
 
-      if content.length == 1
-        process(content.first)
-      else
-        statements = content.map { |sub_exp| process(sub_exp) }
-        s(:block, *statements)
-      end
+      statements = content.map { |sub_exp| process(sub_exp) }
+      wrap_in_block statements
     end
 
     def process_module exp
@@ -91,6 +87,10 @@ module RipperRubyParser
       s(:colon2, process(left), extract_node_symbol(right))
     end
 
+    def process_const_path_field exp
+      s(:const, process_const_path_ref(exp))
+    end
+
     def process_const_ref exp
       _, ref = exp.shift 3
       process(ref)
@@ -101,6 +101,10 @@ module RipperRubyParser
       s(:colon3, extract_node_symbol(ref))
     end
 
+    def process_top_const_field exp
+      s(:const, process_top_const_ref(exp))
+    end
+
     def process_paren exp
       _, body = exp.shift 2
       if body.size == 0

data/lib/ripper_ruby_parser/version.rb

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

data/test/end_to_end/comparison_test.rb

@@ -125,5 +125,25 @@ describe "Using RipperRubyParser and RubyParser" do
       formatted(imitation).must_equal formatted(original)
     end
   end
+
+  describe "for an example with regular expressions with different encoding flags" do
+    it "gives the same result" do
+      program = <<-END
+        regular = /foo/
+        noenc = /foo/n
+        utf8 = /foo/u
+        euc = /foo/e
+        sjis = /foo/s
+
+        regular = /foo\#{bar}/
+        noenc = /foo\#{bar}/n
+        utf8 = /foo\#{bar}/u
+        euc = /foo\#{bar}/e
+        sjis = /foo\#{bar}/s
+      END
+
+      program.must_be_parsed_as_before
+    end
+  end
 end
 

data/test/test_helper.rb

@@ -36,9 +36,18 @@ class MiniTest::Spec
     result = parser.parse code
     assert_equal sexp, result
   end
+
+  def assert_parsed_as_before code
+    oldparser = RubyParser.new
+    newparser = RipperRubyParser::Parser.new
+    expected = oldparser.parse code.dup
+    result = newparser.parse code
+    assert_equal formatted(expected), formatted(result)
+  end
 end
 
 module MiniTest::Expectations
   infect_an_assertion :assert_parsed_as, :must_be_parsed_as
+  infect_an_assertion :assert_parsed_as_before, :must_be_parsed_as_before, :unary
 end
 

data/test/unit/parser_assignment_test.rb

@@ -2,6 +2,22 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe "#parse" do
+    describe "for single assignment" do
+      it "works when assigning to a namespaced constant" do
+        "Foo::Bar = baz".
+          must_be_parsed_as s(:cdecl,
+                              s(:colon2, s(:const, :Foo), :Bar),
+                              s(:call, nil, :baz, s(:arglist)))
+      end
+
+      it "works when assigning to constant in the root namespace" do
+        "::Foo = bar".
+          must_be_parsed_as s(:cdecl,
+                              s(:colon3, :Foo),
+                              s(:call, nil, :bar, s(:arglist)))
+      end
+    end
+
     describe "for multiple assignment" do
       specify do
         "foo, * = bar".
@@ -45,6 +61,12 @@ describe RipperRubyParser::Parser do
                                 :+,
                                 s(:call, nil, :qux, s(:arglist)))
         end
+
+        it "works with &&=" do
+          "foo &&= bar".
+            must_be_parsed_as s(:op_asgn_and,
+                                s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar, s(:arglist))))
+        end
       end
     end
 

data/test/unit/parser_blocks_test.rb

@@ -68,5 +68,17 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :bar, s(:arglist)))
       end
     end
+
+    describe "for rescue" do
+      it "works with assignment to an error variable" do
+        "begin; foo; rescue => bar; baz; end".
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:resbody,
+                                s(:array,
+                                  s(:lasgn, :bar, s(:gvar, :$!))),
+                                s(:call, nil, :baz, s(:arglist))))
+      end
+    end
   end
 end

data/test/unit/parser_literals_test.rb

@@ -0,0 +1,179 @@
+# coding: utf-8
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for regexp literals" do
+      it "works with the no-encoding flag" do
+        parser = RipperRubyParser::Parser.new
+        result = parser.parse "/foo/n"
+        # Use inspect since regular == finds no difference between /foo/n
+        # and /foo/
+        result.inspect.must_equal s(:lit, /foo/n).inspect
+      end
+
+      describe "with interpolations" do
+        it "works with the no-encoding flag" do
+          '/foo#{bar}/n'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr,
+                                  s(:call, nil, :bar, s(:arglist))), 32)
+        end
+
+        it "works with the unicode-encoding flag" do
+          '/foo#{bar}/u'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr,
+                                  s(:call, nil, :bar, s(:arglist))), 16)
+        end
+
+        it "works with the euc-encoding flag" do
+          '/foo#{bar}/e'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr,
+                                  s(:call, nil, :bar, s(:arglist))), 16)
+        end
+
+        it "works with the sjis-encoding flag" do
+          '/foo#{bar}/s'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr,
+                                  s(:call, nil, :bar, s(:arglist))), 16)
+        end
+
+        describe "containing just a literal string" do
+          it "performs the interpolation when it is at the end" do
+            '/foo#{"bar"}/'.must_be_parsed_as s(:lit, /foobar/)
+          end
+
+          it "performs the interpolation when it is in the middle" do
+            '/foo#{"bar"}baz/'.must_be_parsed_as s(:lit, /foobarbaz/)
+          end
+
+          it "performs the interpolation when it is at the start" do
+            '/#{"foo"}bar/'.must_be_parsed_as s(:lit, /foobar/)
+          end
+        end
+      end
+    end
+
+    describe "for string literals" do
+      describe "with escape sequences" do
+        it "works with hex escapes" do
+          "\"\\x36\"".must_be_parsed_as s(:str, "6")
+          "\"\\x4a\"".must_be_parsed_as s(:str, "J")
+          "\"\\x4A\"".must_be_parsed_as s(:str, "J")
+          "\"\\x3Z\"".must_be_parsed_as s(:str, "\x03Z")
+        end
+
+        it "works with single-letter escapes" do
+          "\"foo\\abar\"".must_be_parsed_as s(:str, "foo\abar")
+          "\"foo\\bbar\"".must_be_parsed_as s(:str, "foo\bbar")
+          "\"foo\\ebar\"".must_be_parsed_as s(:str, "foo\ebar")
+          "\"foo\\fbar\"".must_be_parsed_as s(:str, "foo\fbar")
+          "\"foo\\nbar\"".must_be_parsed_as s(:str, "foo\nbar")
+          "\"foo\\rbar\"".must_be_parsed_as s(:str, "foo\rbar")
+          "\"foo\\sbar\"".must_be_parsed_as s(:str, "foo\sbar")
+          "\"foo\\tbar\"".must_be_parsed_as s(:str, "foo\tbar")
+          "\"foo\\vbar\"".must_be_parsed_as s(:str, "foo\vbar")
+        end
+
+        it "works with octal number escapes" do
+          "\"foo\\123bar\"".must_be_parsed_as s(:str, "foo\123bar")
+          "\"foo\\23bar\"".must_be_parsed_as s(:str, "foo\023bar")
+          "\"foo\\3bar\"".must_be_parsed_as s(:str, "foo\003bar")
+
+          "\"foo\\118bar\"".must_be_parsed_as s(:str, "foo\0118bar")
+          "\"foo\\18bar\"".must_be_parsed_as s(:str, "foo\0018bar")
+        end
+
+        it "works with simple short hand control sequence escapes" do
+          "\"foo\\cabar\"".must_be_parsed_as s(:str, "foo\cabar")
+          "\"foo\\cZbar\"".must_be_parsed_as s(:str, "foo\cZbar")
+        end
+
+        it "works with simple regular control sequence escapes" do
+          "\"foo\\C-abar\"".must_be_parsed_as s(:str, "foo\C-abar")
+          "\"foo\\C-Zbar\"".must_be_parsed_as s(:str, "foo\C-Zbar")
+        end
+
+        # TODO: Implement remaining escape sequence cases.
+
+        # TODO: Behave differently in extra_compatible mode.
+        it "works with unicode escapes (unlike RubyParser)" do
+          "\"foo\\u273bbar\"".must_be_parsed_as s(:str, "foo✻bar")
+        end
+      end
+
+      describe "with interpolations" do
+        describe "containing just a literal string" do
+          it "performs the interpolation when it is at the end" do
+            '"foo#{"bar"}"'.must_be_parsed_as s(:str, "foobar")
+          end
+
+          it "performs the interpolation when it is in the middle" do
+            '"foo#{"bar"}baz"'.must_be_parsed_as s(:str, "foobarbaz")
+          end
+
+          it "performs the interpolation when it is at the start" do
+            '"#{"foo"}bar"'.must_be_parsed_as s(:str, "foobar")
+          end
+        end
+
+        describe "without braces" do
+          it "works for ivars" do
+            "\"foo\#@bar\"".must_be_parsed_as s(:dstr,
+                                                "foo",
+                                                s(:evstr, s(:ivar, :@bar)))
+          end
+
+          it "works for gvars" do
+            "\"foo\#$bar\"".must_be_parsed_as s(:dstr,
+                                                "foo",
+                                                s(:evstr, s(:gvar, :$bar)))
+          end
+
+          it "works for cvars" do
+            "\"foo\#@@bar\"".must_be_parsed_as s(:dstr,
+                                                "foo",
+                                                s(:evstr, s(:cvar, :@@bar)))
+          end
+        end
+      end
+
+      describe "with string concatenation" do
+        it "performs the concatenation in the case of two simple literal strings" do
+          "\"foo\" \"bar\"".must_be_parsed_as s(:str, "foobar")
+        end
+
+        it "performs the concatenation when the right string has interpolations" do
+          "\"foo\" \"bar\#{baz}\"".
+            must_be_parsed_as s(:dstr,
+                                "foobar",
+                                s(:evstr, s(:call, nil, :baz, s(:arglist))))
+        end
+
+        it "performs the concatenation when the left string has interpolations" do
+          "\"foo\#{bar}\" \"baz\"".
+            must_be_parsed_as s(:dstr,
+                                "foo",
+                                s(:evstr, s(:call, nil, :bar, s(:arglist))),
+                                s(:str, "baz"))
+        end
+
+        it "performs the concatenation when both strings have interpolations" do
+          "\"foo\#{bar}\" \"baz\#{qux}\"".
+            must_be_parsed_as s(:dstr,
+                                "foo",
+                                s(:evstr, s(:call, nil, :bar, s(:arglist))),
+                                s(:str, "baz"),
+                                s(:evstr, s(:call, nil, :qux, s(:arglist))))
+        end
+      end
+    end
+  end
+end

data/test/unit/parser_loops_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe "#parse" do
+    describe "for the while statement" do
+      it "works in the single-line postfix case" do
+        "foo while bar".
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, nil, :foo, s(:arglist)), true)
+      end
+
+      it "works in the block postfix case" do
+        "begin; foo; end while bar".
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, nil, :foo, s(:arglist)), false)
+      end
+
+      it "normalizes a negative condition" do
+        "while not foo; bar; end".
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist)), true)
+      end
+
+      it "normalizes a negative condition in the postfix case" do
+        "foo while not bar".
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, nil, :foo, s(:arglist)), true)
+      end
+    end
+
+    describe "for the until statement" do
+      it "normalizes a negative condition" do
+        "until not foo; bar; end".
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist)), true)
+
+      end
+
+      it "normalizes a negative condition in the postfix case" do
+        "foo until not bar".
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, nil, :foo, s(:arglist)), true)
+      end
+    end
+  end
+end

data/test/unit/parser_operators_test.rb

@@ -12,5 +12,18 @@ describe RipperRubyParser::Parser do
                                              s(:call, nil, :bar, s(:arglist)))))
       end
     end
+
+    describe "for boolean operators" do
+      it "handles triple :and" do
+        "foo and bar and baz and qux".
+          must_be_parsed_as s(:and,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:and,
+                                s(:call, nil, :bar, s(:arglist)),
+                                s(:and,
+                                  s(:call, nil, :baz, s(:arglist)),
+                                  s(:call, nil, :qux, s(:arglist)))))
+      end
+    end
   end
 end

data/test/unit/parser_test.rb

@@ -21,6 +21,12 @@ describe RipperRubyParser::Parser do
       sexp_p.verify
     end
 
+    describe "for an empty program" do
+      it "returns nil" do
+        "".must_be_parsed_as nil
+      end
+    end
+
     describe "for a class declaration" do
       it "works with a namespaced class name" do
         result = parser.parse "class Foo::Bar; end"
@@ -576,6 +582,17 @@ describe RipperRubyParser::Parser do
                             :[],
                             s(:arglist, s(:call, nil, :bar, s(:arglist))))
       end
+
+      it "works without any indexes" do
+        "foo[]".must_be_parsed_as s(:call, s(:call, nil, :foo, s(:arglist)),
+                                    :[], s(:arglist))
+      end
+
+      it "drops self from self[]" do
+        "self[foo]".must_be_parsed_as s(:call, nil, :[],
+                                        s(:arglist,
+                                          s(:call, nil, :foo, s(:arglist))))
+      end
     end
 
     describe "for method definitions" do
@@ -981,13 +998,13 @@ describe RipperRubyParser::Parser do
       end
 
       it "works for a double-quoted string representing a regex literal with escaped right bracket" do
-        result = parser.parse "\"/\\)/\""
+        result = parser.parse "\"/\\\\)/\""
         result.must_equal s(:str, "/\\)/")
       end
 
-      it "works for a single-quoted string representing a regex literal with escaped right bracket" do
-        result = parser.parse "'/\\)/'"
-        result.must_equal s(:str, "/\\)/")
+      it "works for a double-quoted string containing a uselessly escaped right bracket" do
+        result = parser.parse "\"/\\)/\""
+        result.must_equal s(:str, "/)/")
       end
 
       it "works for a string containing escaped quotes" do
@@ -1153,7 +1170,7 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe "for constant references" do
+    describe "for constant lookups" do
       it "works when explicitely starting from the root namespace" do
         result = parser.parse "::Foo"
         result.must_equal s(:colon3, :Foo)
@@ -1165,6 +1182,12 @@ describe RipperRubyParser::Parser do
                             s(:colon2, s(:const, :Foo), :Bar),
                             :Baz)
       end
+
+      it "works looking up a constant in a non-constant" do
+        "foo::Bar".must_be_parsed_as s(:colon2,
+                                       s(:call, nil, :foo, s(:arglist)),
+                                       :Bar)
+      end
     end
 
     describe "for variable references" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ripper_ruby_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-02 00:00:00.000000000 Z
+date: 2012-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &18762580 !ruby/object:Gem::Requirement
+  requirement: &21062800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *18762580
+  version_requirements: *21062800
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &18762060 !ruby/object:Gem::Requirement
+  requirement: &21062280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 2.11.2
   type: :development
   prerelease: false
-  version_requirements: *18762060
+  version_requirements: *21062280
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &18761580 !ruby/object:Gem::Requirement
+  requirement: &21061800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *18761580
+  version_requirements: *21061800
 - !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &18761100 !ruby/object:Gem::Requirement
+  requirement: &21061320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.3.1
   type: :development
   prerelease: false
-  version_requirements: *18761100
+  version_requirements: *21061320
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &18760720 !ruby/object:Gem::Requirement
+  requirement: &21060940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *18760720
+  version_requirements: *21060940
 description: 
 email:
 - matijs@matijs.net
@@ -102,6 +102,7 @@ files:
 - test/end_to_end/test_comparison_test.rb
 - test/end_to_end/line_numbering_test.rb
 - test/end_to_end/error_conditions_test.rb
+- test/unit/parser_literals_test.rb
 - test/unit/parser_test.rb
 - test/unit/parser_blocks_test.rb
 - test/unit/sexp_processor_test.rb
@@ -110,6 +111,7 @@ files:
 - test/unit/version_test.rb
 - test/unit/parser_assignment_test.rb
 - test/unit/parser_method_calls_test.rb
+- test/unit/parser_loops_test.rb
 - test/unit/commenting_sexp_builder_test.rb
 - README.rdoc
 - Rakefile
@@ -152,6 +154,8 @@ test_files:
 - test/unit/parser_assignment_test.rb
 - test/unit/parser_blocks_test.rb
 - test/unit/parser_conditionals_test.rb
+- test/unit/parser_literals_test.rb
+- test/unit/parser_loops_test.rb
 - test/unit/parser_method_calls_test.rb
 - test/unit/parser_operators_test.rb
 - test/unit/parser_test.rb