ripper_ruby_parser 0.0.3 → 0.0.4

data/README.rdoc

@@ -12,10 +12,7 @@ Parse with Ripper, produce sexps that are compatible with RubyParser.
 
 * Drop-in replacement for RubyParser.
 * Should handle 1.9 syntax gracefully.
-* Only tested with MRI 1.9.3. Definitely does not work with the ripper gem for
-  MRI 1.8.
-* Many edge cases are surely not yet taken care of (but hey, it's version
-  0.0.1).
+* Needs MRI 1.9.3.
 
 == Install
 
@@ -23,8 +20,6 @@ Parse with Ripper, produce sexps that are compatible with RubyParser.
 
 == Synopsis
 
-Basic usage:
-
   require 'ripper_ruby_parser'
 
   parser = RipperRubyParser::Parser.new
@@ -34,7 +29,7 @@ Basic usage:
 
 == Requirements
 
-* Ruby 1.9.3. It may work with lower 1.9 versions. Let me know if it does.
+* Ruby 1.9.3.
 * sexp_processor
 
 == Hacking and contributing

data/lib/ripper_ruby_parser/commenting_sexp_builder.rb

@@ -1,4 +1,6 @@
 require 'ripper'
+require 'ripper_ruby_parser/syntax_error'
+
 module RipperRubyParser
   class CommentingSexpBuilder < Ripper::SexpBuilderPP
     def initialize *args
@@ -34,6 +36,26 @@ module RipperRubyParser
       commentize(super)
     end
 
+    def on_parse_error *args
+      raise SyntaxError.new(*args)
+    end
+
+    def on_class_name_error *args
+      raise SyntaxError.new(*args)
+    end
+
+    def on_alias_error *args
+      raise SyntaxError.new(*args)
+    end
+
+    def on_assign_error *args
+      raise SyntaxError.new(*args)
+    end
+
+    def on_param_error *args
+      raise SyntaxError.new(*args)
+    end
+
     private
 
     def commentize exp

data/lib/ripper_ruby_parser/parser.rb

@@ -5,14 +5,20 @@ module RipperRubyParser
   # Main parser class. Brings together Ripper and our
   # RipperRubyParser::SexpProcessor.
   class Parser
+    attr_accessor :extra_compatible
+
     def initialize processor=SexpProcessor.new
       @processor = processor
+      @extra_compatible = false
     end
 
     def parse source, filename='(string)', lineno=1
       parser = CommentingSexpBuilder.new(source, filename, lineno)
-      exp = Sexp.from_array(parser.parse)
+      result = 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
   end

data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb

@@ -120,12 +120,18 @@ module RipperRubyParser
         :gvar => :gasgn
       }
 
+      ASSIGNMENT_IN_METHOD_SUB_TYPE_MAP = {
+        :cvar => :cvasgn
+      }
+
       def create_assignment_sub_type lvalue, value
         s(map_assignment_lvalue_type(lvalue.sexp_type), lvalue[1], value)
       end
 
       def map_assignment_lvalue_type type
-        ASSIGNMENT_SUB_TYPE_MAP[type] || type
+        @in_method_body && ASSIGNMENT_IN_METHOD_SUB_TYPE_MAP[type] ||
+        ASSIGNMENT_SUB_TYPE_MAP[type] ||
+        type
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -6,7 +6,11 @@ module RipperRubyParser
         block = process(block)
         args = convert_block_args(block[1])
         stmt = block[2].first
-        s(:iter, process(call), args, stmt)
+        if stmt.nil?
+          s(:iter, process(call), args)
+        else
+          s(:iter, process(call), args, stmt)
+        end
       end
 
       def process_brace_block exp
@@ -31,6 +35,8 @@ module RipperRubyParser
           s(:lasgn, sym, 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}" }
 
         add_arg_unless_nil(block, args) {|name| :"&#{name}" }
@@ -47,12 +53,12 @@ module RipperRubyParser
 
         block = process(body)[1]
 
-        strip_wrapping_block(block)
+        strip_wrapping_block(block.compact)
       end
 
       def process_rescue exp
         _, eclass, evar, block, _ = exp.shift 5
-        rescue_block = s(*map_body(block))
+        rescue_block = map_body(block)
 
         arr = []
         if eclass
@@ -74,6 +80,32 @@ module RipperRubyParser
           wrap_in_block(rescue_block))
       end
 
+      def process_bodystmt exp
+        _, body, rescue_block, _, ensure_block = exp.shift 5
+
+        body = map_body body
+
+        unless rescue_block or ensure_block
+          return s(:scope, s(:block, *body))
+        end
+
+        body = wrap_in_block(body)
+
+        if rescue_block
+          if body.nil?
+            body = s(:rescue, process(rescue_block))
+          else
+            body = s(:rescue, body, process(rescue_block))
+          end
+        end
+
+        if ensure_block
+          body = s(:ensure, body, process(ensure_block))
+        end
+
+        s(:scope, s(:block, body))
+      end
+
       def process_rescue_mod exp
         _, scary, safe = exp.shift 3
         s(:rescue, process(scary), s(:resbody, s(:array), process(safe)))
@@ -106,10 +138,12 @@ module RipperRubyParser
 
       def handle_generic_block exp
         _, args, stmts = exp.shift 3
+        # FIXME: Symbol :block is irrelevant.
         s(:block, process(args), s(handle_statement_list(stmts)))
       end
 
       def strip_wrapping_block(block)
+        return block unless block.sexp_type == :block
         case block.length
         when 1
           s(:nil)

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -3,14 +3,25 @@ module RipperRubyParser
     module Conditionals
       def process_if exp
         _, cond, truepart, falsepart = exp.shift 4
-        s(:if,
-          process(cond),
-          handle_statement_list(truepart),
-          process(falsepart))
+
+        cond = process(cond)
+        truepart = handle_statement_list(truepart)
+        falsepart = process(falsepart)
+
+        if cond.sexp_type == :not
+          cond = cond[1]
+          truepart, falsepart = falsepart, truepart
+        end
+
+        s(:if, cond, truepart, falsepart)
       end
 
       def process_elsif exp
-        process_if exp
+        _, cond, truepart, falsepart = exp.shift 4
+
+        s(:if, process(cond),
+          handle_statement_list(truepart),
+          process(falsepart))
       end
 
       def process_if_mod exp

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -24,7 +24,22 @@ module RipperRubyParser
       end
 
       def convert_block_args(args)
-        args && s(:lasgn, args[1][1])
+        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
@@ -78,7 +93,10 @@ module RipperRubyParser
       end
 
       def wrap_in_block statements
-        if statements.length == 1
+        case statements.length
+        when 0
+          nil
+        when 1
           statements.first
         else
           s(:block, *statements)

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -9,7 +9,7 @@ module RipperRubyParser
       def process_string_content exp
         exp.shift
 
-        string, rest = extract_string_parts exp
+        string, rest = extract_unescaped_string_parts exp
 
         if rest.empty?
           s(:str, string)
@@ -23,12 +23,37 @@ module RipperRubyParser
         s(:evstr, process(list.first))
       end
 
+      def process_xstring_literal exp
+        _, content = exp.shift 2
+        string, rest = extract_unescaped_string_parts content
+        if rest.empty?
+          s(:xstr, string)
+        else
+          s(:dxstr, string, *rest)
+        end
+      end
+
       def process_regexp_literal exp
-        _, content, _ = exp.shift 3
+        _, content, (_, flags, _) = exp.shift 3
 
-        string = extract_inner_string content[0]
+        string, rest = extract_string_parts content
 
-        s(:lit, Regexp.new(string[1]))
+        numflags = 0
+        flags =~ /m/ and numflags |= Regexp::MULTILINE
+        flags =~ /x/ and numflags |= Regexp::EXTENDED
+        flags =~ /i/ and numflags |= Regexp::IGNORECASE
+
+        if rest.empty?
+          s(:lit, Regexp.new(string, numflags))
+        else
+          rest << numflags if numflags > 0
+          sexp_type = if flags =~ /o/
+                     :dregx_once
+                   else
+                     :dregx
+                   end
+          s(sexp_type, string, *rest)
+        end
       end
 
       def process_symbol_literal exp
@@ -44,7 +69,7 @@ module RipperRubyParser
       def process_dyna_symbol exp
         _, list = exp.shift 2
 
-        string, rest = extract_string_parts list
+        string, rest = extract_unescaped_string_parts list
         if rest.empty?
           s(:lit, string.to_sym)
         else
@@ -59,38 +84,45 @@ module RipperRubyParser
 
       private
 
-      def extract_inner_string exp
-        process(exp) || s(:str, "")
-      end
-
       def extract_string_parts exp
         inner = exp.shift
 
-        string = extract_inner_string(inner)
+        string = process(inner)
         rest = []
 
-        if string.sexp_type == :str
+        if string.nil?
+          string = ""
+        elsif string.sexp_type == :str
           string = string[1]
         else
           rest << string
           string = ""
         end
 
-        string = unescape(string)
-
         until exp.empty? do
           result = process(exp.shift)
-          if result.sexp_type == :str
-            result[1] = unescape(result[1])
-          end
           rest << result
         end
 
         return string, rest
       end
 
+      def extract_unescaped_string_parts exp
+        string, rest = extract_string_parts exp
+
+        string = unescape(string)
+
+        rest.each do |sub_exp|
+          if sub_exp.sexp_type == :str
+            sub_exp[1] = unescape(sub_exp[1])
+          end
+        end
+
+        return string, rest
+      end
+
       def unescape string
-        string.gsub(/(\\[n\\"])/) do
+        string.gsub(/(\\[^)])/) do
           eval "\"#{$1}\""
         end
       end

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -12,7 +12,7 @@ module RipperRubyParser
         _, receiver, _, method, args, body = exp.shift 6
         s(:defs, process(receiver),
           extract_node_symbol(method),
-          process(args), process(body))
+          process(args), in_method { process(body) })
       end
 
       def process_return exp
@@ -62,12 +62,19 @@ module RipperRubyParser
 
       private
 
+      def in_method
+        @in_method_body = true
+        result = yield
+        @in_method_body = false
+        result
+      end
+
       def make_method_name_literal exp
         process(exp).tap {|it| it[0] = :lit}
       end
 
       def method_body exp
-        scope = process exp
+        scope = in_method { process exp }
         block = scope[1]
         if block.length == 1
           block.push s(:nil)

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -28,7 +28,13 @@ module RipperRubyParser
         else
           mapped = BINARY_OPERTOR_MAP[op]
           if mapped
-            s(mapped, process(left), process(right))
+            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
           else
             s(:call, process(left), op, s(:arglist, process(right)))
           end

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -6,6 +6,7 @@ module RipperRubyParser
   # Processes the sexp created by Ripper to what RubyParser would produce.
   class SexpProcessor < ::SexpProcessor
     attr_accessor :filename
+    attr_accessor :extra_compatible
 
     def initialize
       super
@@ -27,6 +28,10 @@ module RipperRubyParser
       @processors[:@backref] = :process_at_backref
 
       @processors[:@tstring_content] = :process_at_tstring_content
+
+      @errors = []
+
+      @in_method_body = false
     end
 
     def process exp
@@ -66,28 +71,6 @@ module RipperRubyParser
                        s(:class, const, parent, class_or_module_body(body)))
     end
 
-    def process_bodystmt exp
-      _, body, rescue_block, _, ensure_block = exp.shift 5
-
-      body = map_body body
-
-      unless rescue_block or ensure_block
-        return s(:scope, s(:block, *body))
-      end
-
-      body = wrap_in_block(body)
-
-      if rescue_block
-        body = s(:rescue, body, process(rescue_block))
-      end
-
-      if ensure_block
-        body = s(:ensure, body, process(ensure_block))
-      end
-
-      s(:scope, body)
-    end
-
     def process_var_ref exp
       _, contents = exp.shift 2
       process(contents)
@@ -133,7 +116,7 @@ module RipperRubyParser
 
     # number literals
     def process_at_int exp
-      make_literal(exp) {|val| val.to_i }
+      make_literal(exp) {|val| Integer(val) }
     end
 
     def process_at_float exp
@@ -142,7 +125,13 @@ module RipperRubyParser
 
     # character literals
     def process_at_CHAR exp
-      make_literal(exp) {|val| eval(val) }
+      make_literal(exp) do |val|
+        if extra_compatible
+          val[1].ord
+        else
+          val[1]
+        end
+      end
     end
 
     def process_at_label exp

data/lib/ripper_ruby_parser/syntax_error.rb

@@ -0,0 +1,5 @@
+module RipperRubyParser
+  class SyntaxError < RuntimeError
+
+  end
+end

data/lib/ripper_ruby_parser/version.rb

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

data/test/end_to_end/comparison_test.rb

@@ -86,7 +86,7 @@ describe "Using RipperRubyParser and RubyParser" do
     end
   end
 
-  describe "for a example with operators and explicit block parameter from Reek" do
+  describe "for an example with operators and explicit block parameter from Reek" do
     let :program do
       <<-END
         def parse(arg, argv, &error)
@@ -112,5 +112,18 @@ describe "Using RipperRubyParser and RubyParser" do
       formatted(imitation).must_equal formatted(original)
     end
   end
+
+  describe "for an example of a complex regular expression from Reek" do
+    let :program do
+      "/(\#{@types})\\s*(\\w+)\\s*\\(([^)]*)\\)/"
+    end
+
+    it "gives the same result" do
+      original = oldparser.parse program
+      imitation = newparser.parse program
+
+      formatted(imitation).must_equal formatted(original)
+    end
+  end
 end
 

data/test/end_to_end/error_conditions_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe "Handling errors" do
+  describe "RipperRubyParser::Parser#parse" do
+    let :newparser do
+      RipperRubyParser::Parser.new
+    end
+
+    it "raises an error for an incomplete source" do
+      proc {
+        newparser.parse "def foo"
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it "raises an error for an invalid class name" do
+      proc {
+        newparser.parse("class foo; end")
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it "raises an error aliasing $1 as foo" do
+      proc {
+        newparser.parse "alias foo $1"
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it "raises an error aliasing foo as $1" do
+      proc {
+        newparser.parse "alias $1 foo"
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it "raises an error aliasing $2 as $1" do
+      proc {
+        newparser.parse "alias $1 $2"
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it "raises an error assigning to $1" do
+      proc {
+        newparser.parse "$1 = foo"
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it "raises an error using an invalid parameter name" do
+      proc {
+        newparser.parse "def foo(BAR); end"
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+  end
+end

data/test/end_to_end/samples_comparison_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require 'ruby_parser'
+
+describe "Using RipperRubyParser and RubyParser" do
+  let :newparser do
+    RipperRubyParser::Parser.new
+  end
+
+  let :oldparser do
+    RubyParser.new
+  end
+
+  Dir.glob("samples/**/*.rb").each do |file|
+    describe "for #{file}" do
+      let :program do
+        File.read file
+      end
+
+      it "gives the same result" do
+        newparser.extra_compatible = true
+        original = oldparser.parse program
+        imitation = newparser.parse program
+
+        formatted(imitation).must_equal formatted(original)
+      end
+    end
+  end
+end

data/test/unit/parser_test.rb

@@ -12,6 +12,7 @@ describe RipperRubyParser::Parser do
       sexp_p = MiniTest::Mock.new
       sexp_p.expect :process, s(:result), [Sexp]
       sexp_p.expect :filename=, nil, ['(string)']
+      sexp_p.expect :extra_compatible=, nil, [false]
 
       parser = RipperRubyParser::Parser.new sexp_p
       result = parser.parse "any code"
@@ -74,6 +75,24 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :qux, s(:arglist)),
                               nil))
       end
+
+      it "handles a negative condition correctly" do
+        result = parser.parse "if not foo; bar; end"
+        result.must_equal s(:if,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "handles a negative condition in elsif correctly" do
+        result = parser.parse "if foo; bar; elsif not baz; qux; end"
+        result.must_equal s(:if,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:if,
+                              s(:not, s(:call, nil, :baz, s(:arglist))),
+                              s(:call, nil, :qux, s(:arglist)), nil))
+      end
     end
 
     describe "for unless" do
@@ -273,6 +292,12 @@ describe RipperRubyParser::Parser do
     end
 
     describe "for the rescue statement" do
+      it "works with empty main and rescue bodies" do
+        result = parser.parse "begin; rescue; end"
+        result.must_equal s(:rescue,
+                            s(:resbody, s(:array), nil))
+      end
+
       it "works with single statement main and rescue bodies" do
         result = parser.parse "begin; foo; rescue; bar; end"
         result.must_equal s(:rescue,
@@ -343,6 +368,20 @@ describe RipperRubyParser::Parser do
                               s(:array),
                               s(:call, nil, :bar, s(:arglist))))
       end
+
+      it "works in a plain method body" do
+        result = parser.parse "def foo; bar; rescue; baz; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args),
+                            s(:scope,
+                              s(:block,
+                                s(:rescue,
+                                  s(:call, nil, :bar, s(:arglist)),
+                                  s(:resbody,
+                                    s(:array),
+                                    s(:call, nil, :baz, s(:arglist)))))))
+      end
     end
 
     describe "for the ensure statement" do
@@ -522,6 +561,11 @@ describe RipperRubyParser::Parser do
         result = parser.parse "3.14"
         result.must_equal s(:lit, 3.14)
       end
+
+      it "works for octal integer literals" do
+        result = parser.parse "0700"
+        result.must_equal s(:lit, 448)
+      end
     end
 
     describe "for collection indexing" do
@@ -535,7 +579,7 @@ describe RipperRubyParser::Parser do
     end
 
     describe "for method definitions" do
-      it "works with def with reciever" do
+      it "works with def with receiver" do
         result = parser.parse "def foo.bar; end"
         result.must_equal s(:defs,
                             s(:call, nil, :foo, s(:arglist)),
@@ -649,7 +693,7 @@ describe RipperRubyParser::Parser do
     end
 
     describe "for method calls" do
-      describe "without a reciever" do
+      describe "without a receiver" do
         it "works without brackets" do
           result = parser.parse "foo bar"
           result.must_equal s(:call, nil, :foo,
@@ -687,7 +731,7 @@ describe RipperRubyParser::Parser do
         end
       end
 
-      describe "with a reciever" do
+      describe "with a receiver" do
         it "works without brackets" do
           result = parser.parse "foo.bar baz"
           result.must_equal s(:call,
@@ -755,6 +799,13 @@ describe RipperRubyParser::Parser do
     end
 
     describe "for blocks" do
+      it "works with no statements in the block body" do
+        result = parser.parse "foo do; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil)
+      end
+
       it "works with next with no arguments" do
         result = parser.parse "foo do; next; end"
         result.must_equal s(:iter,
@@ -816,6 +867,43 @@ describe RipperRubyParser::Parser do
                             nil,
                             s(:redo))
       end
+
+      it "works with one argument" do
+        result = parser.parse "foo do |bar|; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:lasgn, :bar))
+      end
+
+      it "works with multiple arguments" do
+        result = parser.parse "foo do |bar, baz|; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:masgn,
+                              s(:array,
+                                s(:lasgn, :bar),
+                                s(:lasgn, :baz))))
+      end
+
+      it "works with a single splat argument" do
+        result = parser.parse "foo do |*bar|; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:masgn,
+                              s(:array,
+                                s(:splat, s(:lasgn, :bar)))))
+      end
+
+      it "works with a combination of regular arguments and a splat argument" do
+        result = parser.parse "foo do |bar, *baz|; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:masgn,
+                              s(:array,
+                                s(:lasgn, :bar),
+                                s(:splat, s(:lasgn, :baz)))))
+      end
+
     end
 
     describe "for yield" do
@@ -882,6 +970,11 @@ describe RipperRubyParser::Parser do
         result.must_equal s(:str, "\n")
       end
 
+      it "works for strings with useless escape sequences" do
+        result = parser.parse "\"F\\OO\""
+        result.must_equal s(:str, "FOO")
+      end
+
       it "works for strings with escaped backslashes" do
         result = parser.parse "\"\\\\n\""
         result.must_equal s(:str, "\\n")
@@ -950,6 +1043,49 @@ describe RipperRubyParser::Parser do
         result.must_equal s(:lit, /\)\n\\/)
       end
 
+      it "works for regexes with interpolations" do
+        result = parser.parse '/foo#{bar}baz/'
+        result.must_equal s(:dregx,
+                            "foo",
+                            s(:evstr, s(:call, nil, :bar, s(:arglist))),
+                            s(:str, "baz"))
+      end
+
+      it "works for a regex literal with the multiline flag" do
+        result = parser.parse "/foo/m"
+        result.must_equal s(:lit, /foo/m)
+      end
+
+      it "works for a regex literal with the extended flag" do
+        result = parser.parse "/foo/x"
+        result.must_equal s(:lit, /foo/x)
+      end
+
+      it "works for a regex literal with the ignorecase flag" do
+        result = parser.parse "/foo/i"
+        result.must_equal s(:lit, /foo/i)
+      end
+
+      it "works for a regex literal with a combination of flags" do
+        result = parser.parse "/foo/ixm"
+        result.must_equal s(:lit, /foo/ixm)
+      end
+
+      it "works for a regex literal with flags and interpolation" do
+        result = parser.parse '/foo#{bar}/ixm'
+        result.must_equal s(:dregx,
+                            "foo",
+                            s(:evstr, s(:call, nil, :bar, s(:arglist))),
+                            7)
+      end
+
+      it "works for a regex literal with interpolate-once flag" do
+        result = parser.parse '/foo#{bar}/o'
+        result.must_equal s(:dregx_once,
+                            "foo",
+                            s(:evstr, s(:call, nil, :bar, s(:arglist))))
+      end
+
       it "works for simple dsyms" do
         result = parser.parse ':"foo"'
         result.must_equal s(:lit, :foo)
@@ -966,6 +1102,30 @@ describe RipperRubyParser::Parser do
         result = parser.parse "?a"
         result.must_equal s(:lit, "a")
       end
+
+      it "works for character literals in extra compatible mode" do
+        parser.extra_compatible = true
+        result = parser.parse "?a"
+        result.must_equal s(:lit, 97)
+      end
+
+      it "works for basic backtick strings" do
+        result = parser.parse '`foo`'
+        result.must_equal s(:xstr, "foo")
+      end
+
+      it "works for interpolated backtick strings" do
+        result = parser.parse '`foo#{bar}`'
+        result.must_equal s(:dxstr,
+                            "foo",
+                            s(:evstr, s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "works for backtick strings with escape sequences" do
+        result = parser.parse '`foo\\n`'
+        result.must_equal s(:xstr, "foo\n")
+      end
+
     end
 
     describe "for the __FILE__ keyword" do
@@ -1074,6 +1234,25 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :bar, s(:arglist)))
       end
 
+      it "works when assigning to a class variable inside a method" do
+        result = parser.parse "def foo; @@bar = baz; end"
+        result.must_equal s(:defn,
+                            :foo, s(:args),
+                            s(:scope,
+                              s(:block,
+                                s(:cvasgn, :@@bar, s(:call, nil, :baz, s(:arglist))))))
+      end
+
+      it "works when assigning to a class variable inside a method with a receiver" do
+        result = parser.parse "def self.foo; @@bar = baz; end"
+        result.must_equal s(:defs,
+                            s(:self),
+                            :foo, s(:args),
+                            s(:scope,
+                              s(:block,
+                                s(:cvasgn, :@@bar, s(:call, nil, :baz, s(:arglist))))))
+      end
+
       it "works when assigning to a global variable" do
         result = parser.parse "$foo = bar"
         result.must_equal s(:gasgn,
@@ -1281,6 +1460,15 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :bar, s(:arglist)))
       end
 
+      it "handles double :and" do
+        result = parser.parse "foo and bar and baz"
+        result.must_equal s(:and,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:and,
+                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
       it "handles :or" do
         result = parser.parse "foo or bar"
         result.must_equal s(:or,
@@ -1288,6 +1476,33 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :bar, s(:arglist)))
       end
 
+      it "handles double :or" do
+        result = parser.parse "foo or bar or baz"
+        result.must_equal s(:or,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:or,
+                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "handles :or after :and" do
+        result = parser.parse "foo and bar or baz"
+        result.must_equal s(:or,
+                            s(:and,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist))),
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+
+      it "handles :and after :or" do
+        result = parser.parse "foo or bar and baz"
+        result.must_equal s(:and,
+                            s(:or,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist))),
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+
       it "converts :&& to :and" do
         result = parser.parse "foo && bar"
         result.must_equal s(:and,
@@ -1469,12 +1684,12 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it "works for a method call with reciever" do
+      it "works for a method call with receiver" do
         result = parser.parse "foo.bar"
         result.line.must_equal 1
       end
 
-      it "works for a method call with reciever and arguments" do
+      it "works for a method call with receiver and arguments" do
         result = parser.parse "foo.bar baz"
         result.line.must_equal 1
       end
@@ -1580,11 +1795,12 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it "assigns line numbers to all nested sexps" do
-        result = parser.parse "foo() do\nend\n"
+      it "assigns line numbers to nested sexps that don't generate their own line numbers" do
+        result = parser.parse "foo() do\nnext\nend\n"
         result.must_equal s(:iter,
-                            s(:call,
-                              nil, :foo, s(:arglist)), nil, s(:block))
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:next))
         arglist = result[1][3]
         block = result[3]
         nums = [ arglist.line, block.line ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ripper_ruby_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-21 00:00:00.000000000 Z
+date: 2012-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &16124900 !ruby/object:Gem::Requirement
+  requirement: &22929360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *16124900
+  version_requirements: *22929360
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &16124380 !ruby/object:Gem::Requirement
+  requirement: &22928840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 2.11.2
   type: :development
   prerelease: false
-  version_requirements: *16124380
+  version_requirements: *22928840
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &16123900 !ruby/object:Gem::Requirement
+  requirement: &22928360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *16123900
+  version_requirements: *22928360
 - !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &16123420 !ruby/object:Gem::Requirement
+  requirement: &22927880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.3.1
   type: :development
   prerelease: false
-  version_requirements: *16123420
+  version_requirements: *22927880
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &16123040 !ruby/object:Gem::Requirement
+  requirement: &22927500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *16123040
+  version_requirements: *22927500
 description: 
 email:
 - matijs@matijs.net
@@ -92,13 +92,16 @@ files:
 - lib/ripper_ruby_parser/parser.rb
 - lib/ripper_ruby_parser/version.rb
 - lib/ripper_ruby_parser/sexp_handlers.rb
+- lib/ripper_ruby_parser/syntax_error.rb
 - lib/ripper_ruby_parser/sexp_processor.rb
 - test/test_helper.rb
 - test/end_to_end/lib_comparison_test.rb
+- test/end_to_end/samples_comparison_test.rb
 - test/end_to_end/comparison_test.rb
 - test/end_to_end/comments_test.rb
 - 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_test.rb
 - test/unit/sexp_processor_test.rb
 - test/unit/version_test.rb
@@ -134,8 +137,10 @@ summary: Parse with Ripper, produce sexps that are compatible with RubyParser.
 test_files:
 - test/end_to_end/comments_test.rb
 - test/end_to_end/comparison_test.rb
+- test/end_to_end/error_conditions_test.rb
 - test/end_to_end/lib_comparison_test.rb
 - test/end_to_end/line_numbering_test.rb
+- test/end_to_end/samples_comparison_test.rb
 - test/end_to_end/test_comparison_test.rb
 - test/test_helper.rb
 - test/unit/commenting_sexp_builder_test.rb