ripper_ruby_parser 1.4.2 → 1.5.0

data/lib/ripper_ruby_parser/syntax_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   class SyntaxError < RuntimeError; end
 end

data/lib/ripper_ruby_parser/unescape.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   # Implements string unescaping
   #
   # @api private
   module Unescape
-    module_function
-
     ESCAPE_SEQUENCE_REGEXP =
       /\\(
         [0-7]{1,3}        | # octal character
         x[0-9a-fA-F]{1,2} | # hex byte
-        u[0-9a-fA-F]{4}   | # unicode character
+        u[0-9a-fA-F]+     | # unicode character
+        u{[0-9a-fA-F]{4}} | # unicode character
         M-\\C-.           | # meta-ctrl
         C-\\M-.           | # ctrl-meta
         M-\\c.            | # meta-ctrl (shorthand)
@@ -19,7 +20,7 @@ module RipperRubyParser
         M-.               | # meta
         \n                | # line continuation
         .                   # single-character
-      )/x
+      )/x.freeze
 
     SINGLE_LETTER_ESCAPES = {
       'a' => "\a",
@@ -49,6 +50,7 @@ module RipperRubyParser
       string.gsub(/\\(
         '   | # single quote
         \\  | # backslash
+        [ ] | # space
         \n    # newline
       )/x) do
         Regexp.last_match[1]
@@ -93,27 +95,46 @@ module RipperRubyParser
       end
     end
 
+    private
+
     def unescaped_value(bare)
       case bare
       when SINGLE_LETTER_ESCAPES_REGEXP
         SINGLE_LETTER_ESCAPES[bare]
       when /^x/
-        bare[1..-1].to_i(16).chr
+        hex_to_char(bare[1..-1])
+      when /^u\{/
+        hex_to_unicode_char(bare[2..-2])
       when /^u/
-        bare[1..-1].to_i(16).chr(Encoding::UTF_8)
+        hex_to_unicode_char(bare[1..4]) +
+          (extra_compatible ? '' : bare[5..-1])
       when /^(c|C-).$/
-        (bare[-1].ord & 0b1001_1111).chr
+        control(bare[-1].ord).chr
       when /^M-.$/
-        (bare[-1].ord | 0b1000_0000).chr
+        meta(bare[-1].ord).chr
       when /^(M-\\C-|C-\\M-|M-\\c|c\\M-).$/
-        (bare[-1].ord & 0b1001_1111 | 0b1000_0000).chr
+        meta(control(bare[-1].ord)).chr
       when /^[0-7]+/
         bare.to_i(8).chr
-      when "\n"
-        bare
       else
         bare
       end
     end
+
+    def hex_to_unicode_char(str)
+      str.to_i(16).chr(Encoding::UTF_8)
+    end
+
+    def hex_to_char(str)
+      str.to_i(16).chr
+    end
+
+    def control(val)
+      val & 0b1001_1111
+    end
+
+    def meta(val)
+      val | 0b1000_0000
+    end
   end
 end

data/lib/ripper_ruby_parser/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
-  VERSION = '1.4.2'.freeze
+  VERSION = '1.5.0'
 end

data/test/end_to_end/comments_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 

data/test/end_to_end/comparison_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 

data/test/end_to_end/lib_comparison_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 

data/test/end_to_end/line_numbering_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 

data/test/end_to_end/samples_comparison_test.rb

@@ -1,37 +1,13 @@
+# frozen_string_literal: true
+
 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(File.expand_path('../samples/*.rb', File.dirname(__FILE__))).each do |file|
-    describe "for #{file}" do
-      let :program do
-        File.read file
-      end
-
-      let :original do
-        oldparser.parse program
-      end
-
-      let :imitation do
-        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
+    it "gives the same result for #{file}" do
+      program = File.read file
+      program.must_be_parsed_as_before
     end
   end
 end

data/test/end_to_end/test_comparison_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 

data/test/pt_testcase/pt_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'pt_testcase'
 

data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::CommentingRipperParser do
@@ -99,7 +101,7 @@ describe RipperRubyParser::CommentingRipperParser do
       result.must_equal s(:program,
                           s(:stmts,
                             s(:dyna_symbol,
-                              s(:xstring, s(:@tstring_content, 'foo', s(1, 2)))),
+                              s(:xstring, s(:@tstring_content, 'foo', s(1, 2), ":'"))),
                             s(:comment,
                               '',
                               s(:def,
@@ -114,7 +116,7 @@ describe RipperRubyParser::CommentingRipperParser do
                           s(:stmts,
                             s(:dyna_symbol,
                               s(:xstring,
-                                s(:@tstring_content, 'foo', s(1, 2)),
+                                s(:@tstring_content, 'foo', s(1, 2), ':"'),
                                 s(:string_embexpr,
                                   s(:stmts,
                                     s(:comment,
@@ -128,6 +130,18 @@ describe RipperRubyParser::CommentingRipperParser do
                                           nil,
                                           nil)))))))))
     end
+
+    it 'turns an embedded document into a comment node' do
+      result = parse_with_builder "=begin Hello\nthere\n=end\nclass Foo; end"
+      result.must_equal s(:program,
+                          s(:stmts,
+                            s(:comment,
+                              "=begin Hello\nthere\n=end\n",
+                              s(:class,
+                                s(:const_ref, s(:@const, 'Foo', s(4, 6))),
+                                nil,
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
+    end
   end
 
   describe 'handling syntax errors' do

data/test/ripper_ruby_parser/parser_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
@@ -28,6 +30,11 @@ describe RipperRubyParser::Parser do
     end
 
     describe 'for a module declaration' do
+      it 'works with a simple module name' do
+        'module Foo; end'.
+          must_be_parsed_as s(:module, :Foo)
+      end
+
       it 'works with a namespaced module name' do
         'module Foo::Bar; end'.
           must_be_parsed_as s(:module,
@@ -41,83 +48,6 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for the return statement' do
-      it 'works with no arguments' do
-        'return'.
-          must_be_parsed_as s(:return)
-      end
-
-      it 'works with one argument' do
-        'return foo'.
-          must_be_parsed_as s(:return,
-                              s(:call, nil, :foo))
-      end
-
-      it 'works with a splat argument' do
-        'return *foo'.
-          must_be_parsed_as s(:return,
-                              s(:svalue,
-                                s(:splat,
-                                  s(:call, nil, :foo))))
-      end
-
-      it 'works with multiple arguments' do
-        'return foo, bar'.
-          must_be_parsed_as s(:return,
-                              s(:array,
-                                s(:call, nil, :foo),
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works with a regular argument and a splat argument' do
-        'return foo, *bar'.
-          must_be_parsed_as s(:return,
-                              s(:array,
-                                s(:call, nil, :foo),
-                                s(:splat,
-                                  s(:call, nil, :bar))))
-      end
-
-      it 'works with a function call with parentheses' do
-        'return foo(bar)'.
-          must_be_parsed_as s(:return,
-                              s(:call, nil, :foo,
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works with a function call without parentheses' do
-        'return foo bar'.
-          must_be_parsed_as s(:return,
-                              s(:call, nil, :foo,
-                                s(:call, nil, :bar)))
-      end
-    end
-
-    describe 'for the for statement' do
-      it 'works with do' do
-        'for foo in bar do; baz; end'.
-          must_be_parsed_as s(:for,
-                              s(:call, nil, :bar),
-                              s(:lasgn, :foo),
-                              s(:call, nil, :baz))
-      end
-
-      it 'works without do' do
-        'for foo in bar; baz; end'.
-          must_be_parsed_as s(:for,
-                              s(:call, nil, :bar),
-                              s(:lasgn, :foo),
-                              s(:call, nil, :baz))
-      end
-
-      it 'works with an empty body' do
-        'for foo in bar; end'.
-          must_be_parsed_as s(:for,
-                              s(:call, nil, :bar),
-                              s(:lasgn, :foo))
-      end
-    end
-
     describe 'for a begin..end block' do
       it 'works with no statements' do
         'begin; end'.
@@ -137,57 +67,6 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for the undef statement' do
-      it 'works with a single bareword identifier' do
-        'undef foo'.
-          must_be_parsed_as s(:undef, s(:lit, :foo))
-      end
-
-      it 'works with a single symbol' do
-        'undef :foo'.
-          must_be_parsed_as s(:undef, s(:lit, :foo))
-      end
-
-      it 'works with multiple bareword identifiers' do
-        'undef foo, bar'.
-          must_be_parsed_as s(:block,
-                              s(:undef, s(:lit, :foo)),
-                              s(:undef, s(:lit, :bar)))
-      end
-
-      it 'works with multiple bareword symbols' do
-        'undef :foo, :bar'.
-          must_be_parsed_as s(:block,
-                              s(:undef, s(:lit, :foo)),
-                              s(:undef, s(:lit, :bar)))
-      end
-    end
-
-    describe 'for the alias statement' do
-      it 'works with regular barewords' do
-        'alias foo bar'.
-          must_be_parsed_as s(:alias,
-                              s(:lit, :foo), s(:lit, :bar))
-      end
-
-      it 'works with symbols' do
-        'alias :foo :bar'.
-          must_be_parsed_as s(:alias,
-                              s(:lit, :foo), s(:lit, :bar))
-      end
-
-      it 'works with operator barewords' do
-        'alias + -'.
-          must_be_parsed_as s(:alias,
-                              s(:lit, :+), s(:lit, :-))
-      end
-
-      it 'works with global variables' do
-        'alias $foo $bar'.
-          must_be_parsed_as s(:valias, :$foo, :$bar)
-      end
-    end
-
     describe 'for arguments' do
       it 'works for a simple case with splat' do
         'foo *bar'.
@@ -222,241 +101,6 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for collection indexing' do
-      it 'works in the simple case' do
-        'foo[bar]'.
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :foo),
-                              :[],
-                              s(:call, nil, :bar))
-      end
-
-      it 'works without any indexes' do
-        'foo[]'.must_be_parsed_as s(:call, s(:call, nil, :foo),
-                                    :[])
-      end
-
-      it 'works with self[]' do
-        'self[foo]'.must_be_parsed_as s(:call, s(:self), :[],
-                                        s(:call, nil, :foo))
-      end
-    end
-
-    describe 'for method definitions' do
-      it 'works with def with receiver' do
-        'def foo.bar; end'.
-          must_be_parsed_as s(:defs,
-                              s(:call, nil, :foo),
-                              :bar,
-                              s(:args),
-                              s(:nil))
-      end
-
-      it 'works with def with receiver and multiple statements' do
-        'def foo.bar; baz; qux; end'.
-          must_be_parsed_as s(:defs,
-                              s(:call, nil, :foo),
-                              :bar,
-                              s(:args),
-                              s(:call, nil, :baz),
-                              s(:call, nil, :qux))
-      end
-
-      it 'works with a method argument with a default value' do
-        'def foo bar=nil; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args, s(:lasgn, :bar, s(:nil))),
-                              s(:nil))
-      end
-
-      it 'works with several method arguments with default values' do
-        'def foo bar=1, baz=2; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:lasgn, :bar, s(:lit, 1)),
-                                s(:lasgn, :baz, s(:lit, 2))),
-                              s(:nil))
-      end
-
-      it 'works with parentheses around the parameter list' do
-        'def foo(bar); end'.
-          must_be_parsed_as s(:defn, :foo, s(:args, :bar), s(:nil))
-      end
-
-      it 'works with a simple splat' do
-        'def foo *bar; end'.
-          must_be_parsed_as s(:defn, :foo, s(:args, :"*bar"), s(:nil))
-      end
-
-      it 'works with a regular argument plus splat' do
-        'def foo bar, *baz; end'.
-          must_be_parsed_as s(:defn, :foo, s(:args, :bar, :"*baz"), s(:nil))
-      end
-
-      it 'works with a nameless splat' do
-        'def foo *; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args, :"*"),
-                              s(:nil))
-      end
-
-      it 'works for a simple case with explicit block parameter' do
-        'def foo &bar; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args, :"&bar"),
-                              s(:nil))
-      end
-
-      it 'works with a regular argument plus explicit block parameter' do
-        'def foo bar, &baz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args, :bar, :"&baz"),
-                              s(:nil))
-      end
-
-      it 'works with a default value plus explicit block parameter' do
-        'def foo bar=1, &baz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:lasgn, :bar, s(:lit, 1)),
-                                :"&baz"),
-                              s(:nil))
-      end
-
-      it 'works with a default value plus mandatory argument' do
-        'def foo bar=1, baz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:lasgn, :bar, s(:lit, 1)),
-                                :baz),
-                              s(:nil))
-      end
-
-      it 'works with a splat plus explicit block parameter' do
-        'def foo *bar, &baz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args, :"*bar", :"&baz"),
-                              s(:nil))
-      end
-
-      it 'works with a default value plus splat' do
-        'def foo bar=1, *baz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:lasgn, :bar, s(:lit, 1)),
-                                :"*baz"),
-                              s(:nil))
-      end
-
-      it 'works with a default value, splat, plus final mandatory arguments' do
-        'def foo bar=1, *baz, qux, quuz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:lasgn, :bar, s(:lit, 1)),
-                                :"*baz", :qux, :quuz),
-                              s(:nil))
-      end
-
-      it 'works with a named argument with a default value' do
-        'def foo bar: 1; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:kwarg, :bar, s(:lit, 1))),
-                              s(:nil))
-      end
-
-      it 'works with a named argument with no default value' do
-        'def foo bar:; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args,
-                                s(:kwarg, :bar)),
-                              s(:nil))
-      end
-
-      it 'works with a double splat' do
-        'def foo **bar; end'.
-          must_be_parsed_as s(:defn,
-                              :foo,
-                              s(:args, :'**bar'),
-                              s(:nil))
-      end
-
-      it 'works when the method name is an operator' do
-        'def +; end'.
-          must_be_parsed_as s(:defn, :+, s(:args),
-                              s(:nil))
-      end
-    end
-
-    describe 'for yield' do
-      it 'works with no arguments and no parentheses' do
-        'yield'.
-          must_be_parsed_as s(:yield)
-      end
-
-      it 'works with parentheses but no arguments' do
-        'yield()'.
-          must_be_parsed_as s(:yield)
-      end
-
-      it 'works with one argument and no parentheses' do
-        'yield foo'.
-          must_be_parsed_as s(:yield, s(:call, nil, :foo))
-      end
-
-      it 'works with one argument and parentheses' do
-        'yield(foo)'.
-          must_be_parsed_as s(:yield, s(:call, nil, :foo))
-      end
-
-      it 'works with multiple arguments and no parentheses' do
-        'yield foo, bar'.
-          must_be_parsed_as s(:yield,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar))
-      end
-
-      it 'works with multiple arguments and parentheses' do
-        'yield(foo, bar)'.
-          must_be_parsed_as s(:yield,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar))
-      end
-
-      it 'works with splat' do
-        'yield foo, *bar'.
-          must_be_parsed_as s(:yield,
-                              s(:call, nil, :foo),
-                              s(:splat, s(:call, nil, :bar)))
-      end
-
-      it 'works with a function call with parentheses' do
-        'yield foo(bar)'.
-          must_be_parsed_as s(:yield,
-                              s(:call, nil, :foo,
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works with a function call without parentheses' do
-        'yield foo bar'.
-          must_be_parsed_as s(:yield,
-                              s(:call, nil, :foo,
-                                s(:call, nil, :bar)))
-      end
-    end
-
     describe 'for the __ENCODING__ keyword' do
       it 'evaluates to the equivalent of Encoding::UTF_8' do
         '__ENCODING__'.
@@ -494,6 +138,11 @@ describe RipperRubyParser::Parser do
         'END { foo }'.
           must_be_parsed_as s(:iter, s(:postexe), 0, s(:call, nil, :foo))
       end
+
+      it 'works with an empty block' do
+        'END { }'.
+          must_be_parsed_as s(:iter, s(:postexe), 0)
+      end
     end
 
     describe 'for the BEGIN keyword' do
@@ -501,6 +150,11 @@ describe RipperRubyParser::Parser do
         'BEGIN { foo }'.
           must_be_parsed_as s(:iter, s(:preexe), s(:args), s(:call, nil, :foo))
       end
+
+      it 'works with an empty block' do
+        'BEGIN { }'.
+          must_be_parsed_as s(:iter, s(:preexe), s(:args))
+      end
     end
 
     describe 'for constant lookups' do
@@ -553,307 +207,6 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for single assignment' do
-      it 'works when assigning to an instance variable' do
-        '@foo = bar'.
-          must_be_parsed_as s(:iasgn,
-                              :@foo,
-                              s(:call, nil, :bar))
-      end
-
-      it 'works when assigning to a constant' do
-        'FOO = bar'.
-          must_be_parsed_as s(:cdecl,
-                              :FOO,
-                              s(:call, nil, :bar))
-      end
-
-      it 'works when assigning to a collection element' do
-        'foo[bar] = baz'.
-          must_be_parsed_as s(:attrasgn,
-                              s(:call, nil, :foo),
-                              :[]=,
-                              s(:call, nil, :bar),
-                              s(:call, nil, :baz))
-      end
-
-      it 'works when assigning to an attribute' do
-        'foo.bar = baz'.
-          must_be_parsed_as s(:attrasgn,
-                              s(:call, nil, :foo),
-                              :bar=,
-                              s(:call, nil, :baz))
-      end
-
-      it 'works when assigning to a class variable' do
-        '@@foo = bar'.
-          must_be_parsed_as s(:cvdecl,
-                              :@@foo,
-                              s(:call, nil, :bar))
-      end
-
-      it 'works when assigning to a class variable inside a method' do
-        'def foo; @@bar = baz; end'.
-          must_be_parsed_as s(:defn,
-                              :foo, s(:args),
-                              s(:cvasgn, :@@bar, s(:call, nil, :baz)))
-      end
-
-      it 'works when assigning to a class variable inside a method with a receiver' do
-        'def self.foo; @@bar = baz; end'.
-          must_be_parsed_as s(:defs,
-                              s(:self),
-                              :foo, s(:args),
-                              s(:cvasgn, :@@bar, s(:call, nil, :baz)))
-      end
-
-      it 'works when assigning to a global variable' do
-        '$foo = bar'.
-          must_be_parsed_as s(:gasgn,
-                              :$foo,
-                              s(:call, nil, :bar))
-      end
-    end
-
-    describe 'for operator assignment' do
-      it 'works with +=' do
-        'foo += bar'.
-          must_be_parsed_as s(:lasgn,
-                              :foo,
-                              s(:call,
-                                s(:lvar, :foo),
-                                :+,
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works with -=' do
-        'foo -= bar'.
-          must_be_parsed_as s(:lasgn,
-                              :foo,
-                              s(:call,
-                                s(:lvar, :foo),
-                                :-,
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works with ||=' do
-        'foo ||= bar'.
-          must_be_parsed_as s(:op_asgn_or,
-                              s(:lvar, :foo),
-                              s(:lasgn, :foo,
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works when assigning to an instance variable' do
-        '@foo += bar'.
-          must_be_parsed_as s(:iasgn,
-                              :@foo,
-                              s(:call,
-                                s(:ivar, :@foo),
-                                :+,
-                                s(:call, nil, :bar)))
-      end
-
-      it 'works when assigning to a collection element' do
-        'foo[bar] += baz'.
-          must_be_parsed_as s(:op_asgn1,
-                              s(:call, nil, :foo),
-                              s(:arglist, s(:call, nil, :bar)),
-                              :+,
-                              s(:call, nil, :baz))
-      end
-
-      it 'works with ||= when assigning to a collection element' do
-        'foo[bar] ||= baz'.
-          must_be_parsed_as s(:op_asgn1,
-                              s(:call, nil, :foo),
-                              s(:arglist, s(:call, nil, :bar)),
-                              :"||",
-                              s(:call, nil, :baz))
-      end
-
-      it 'works when assigning to an attribute' do
-        'foo.bar += baz'.
-          must_be_parsed_as s(:op_asgn2,
-                              s(:call, nil, :foo),
-                              :bar=,
-                              :+,
-                              s(:call, nil, :baz))
-      end
-
-      it 'works with ||= when assigning to an attribute' do
-        'foo.bar ||= baz'.
-          must_be_parsed_as s(:op_asgn2,
-                              s(:call, nil, :foo),
-                              :bar=,
-                              :"||",
-                              s(:call, nil, :baz))
-      end
-    end
-
-    describe 'for multiple assignment' do
-      it 'works the same number of items on each side' 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(:call, nil, :qux)))
-      end
-
-      it 'works with a single item on the right-hand side' do
-        'foo, bar = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                              s(:to_ary,
-                                s(:call, nil, :baz)))
-      end
-
-      it 'works with left-hand splat' do
-        'foo, *bar = baz, qux'.
-          must_be_parsed_as s(:masgn,
-                              s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
-                              s(:array,
-                                s(:call, nil, :baz),
-                                s(:call, nil, :qux)))
-      end
-
-      it 'works with parentheses around the left-hand side' do
-        '(foo, bar) = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                              s(:to_ary, s(:call, nil, :baz)))
-      end
-
-      it 'works with complex destructuring' do
-        'foo, (bar, baz) = qux'.
-          must_be_parsed_as s(:masgn,
-                              s(:array,
-                                s(:lasgn, :foo),
-                                s(:masgn,
-                                  s(:array, s(:lasgn, :bar), s(:lasgn, :baz)))),
-                              s(:to_ary, s(:call, nil, :qux)))
-      end
-
-      it 'works with complex destructuring of the value' do
-        'foo, (bar, baz) = [qux, [quz, quuz]]'.
-          must_be_parsed_as s(:masgn,
-                              s(:array,
-                                s(:lasgn, :foo),
-                                s(:masgn, s(:array, s(:lasgn, :bar), s(:lasgn, :baz)))),
-                              s(:to_ary,
-                                s(:array,
-                                  s(:call, nil, :qux),
-                                  s(:array, s(:call, nil, :quz), s(:call, nil, :quuz)))))
-      end
-
-      it 'works with instance variables' do
-        '@foo, @bar = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
-                              s(:to_ary, s(:call, nil, :baz)))
-      end
-
-      it 'works with class variables' do
-        '@@foo, @@bar = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
-                              s(:to_ary, s(:call, nil, :baz)))
-      end
-
-      it 'works with attributes' do
-        'foo.bar, foo.baz = qux'.
-          must_be_parsed_as s(:masgn,
-                              s(:array,
-                                s(:attrasgn, s(:call, nil, :foo), :bar=),
-                                s(:attrasgn, s(:call, nil, :foo), :baz=)),
-                              s(:to_ary, s(:call, nil, :qux)))
-      end
-
-      it 'works with collection elements' do
-        'foo[1], bar[2] = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array,
-                                s(:attrasgn,
-                                  s(:call, nil, :foo), :[]=, s(:lit, 1)),
-                                s(:attrasgn,
-                                  s(:call, nil, :bar), :[]=, s(:lit, 2))),
-                              s(:to_ary, s(:call, nil, :baz)))
-      end
-
-      it 'works with constants' do
-        'Foo, Bar = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
-                              s(:to_ary, s(:call, nil, :baz)))
-      end
-
-      it 'works with instance variables and splat' do
-        '@foo, *@bar = baz'.
-          must_be_parsed_as s(:masgn,
-                              s(:array,
-                                s(:iasgn, :@foo),
-                                s(:splat, s(:iasgn, :@bar))),
-                              s(:to_ary,
-                                s(:call, nil, :baz)))
-      end
-    end
-
-    describe 'for operators' do
-      it 'handles :!=' do
-        'foo != bar'.
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :foo),
-                              :!=,
-                              s(:call, nil, :bar))
-      end
-
-      it 'handles :=~ with two non-literals' do
-        'foo =~ bar'.
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :foo),
-                              :=~,
-                              s(:call, nil, :bar))
-      end
-
-      it 'handles :=~ with literal regexp on the left hand side' do
-        '/foo/ =~ bar'.
-          must_be_parsed_as s(:match2,
-                              s(:lit, /foo/),
-                              s(:call, nil, :bar))
-      end
-
-      it 'handles :=~ with literal regexp on the right hand side' do
-        'foo =~ /bar/'.
-          must_be_parsed_as s(:match3,
-                              s(:lit, /bar/),
-                              s(:call, nil, :foo))
-      end
-
-      it 'handles unary !' do
-        '!foo'.
-          must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
-      end
-
-      it 'converts :not to :!' do
-        'not foo'.
-          must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
-      end
-
-      it 'handles unary ! with a number literal' do
-        '!1'.
-          must_be_parsed_as s(:call, s(:lit, 1), :!)
-      end
-
-      it 'handles the ternary operator' do
-        'foo ? bar : baz'.
-          must_be_parsed_as s(:if,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar),
-                              s(:call, nil, :baz))
-      end
-    end
-
     describe 'for expressions' do
       it 'handles assignment inside binary operator expressions' do
         'foo + (bar = baz)'.
@@ -938,15 +291,6 @@ describe RipperRubyParser::Parser do
         result[4].comments.must_equal "# 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(: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,
@@ -1052,11 +396,6 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it 'works for a symbol literal' do
-        result = parser.parse ':foo'
-        result.line.must_equal 1
-      end
-
       it 'works for a class definition' do
         result = parser.parse 'class Foo; end'
         result.line.must_equal 1
@@ -1072,16 +411,6 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it 'works for assignment of the empty hash' do
-        result = parser.parse 'foo = {}'
-        result.line.must_equal 1
-      end
-
-      it 'works for multiple assignment of empty hashes' do
-        result = parser.parse 'foo, bar = {}, {}'
-        result.line.must_equal 1
-      end
-
       it 'assigns line numbers to nested sexps without their own line numbers' do
         result = parser.parse "foo(bar) do\nnext baz\nend\n"
         result.must_equal s(:iter,