ripper_ruby_parser 1.5.1 → 1.6.0

data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb

@@ -496,6 +496,41 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :baz)),
                               nil)
       end
+
+      it 'cleans up a multi-statement begin..end in the when clause' do
+        'case foo; when bar; begin; baz; qux; end; end'.
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)),
+                              nil)
+      end
+
+      it 'cleans up a multi-statement begin..end at start of the when clause' do
+        'case foo; when bar; begin; baz; qux; end; quuz; end'.
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux),
+                                s(:call, nil, :quuz)),
+                              nil)
+      end
+
+      it 'keeps up a multi-statement begin..end in the else clause' do
+        'case foo; when bar; baz; else; begin; qux; quuz; end; end'.
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz)),
+                              s(:block,
+                                s(:call, nil, :qux),
+                                s(:call, nil, :quuz)))
+      end
     end
   end
 end

data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb

@@ -78,15 +78,6 @@ describe RipperRubyParser::Parser do
                                 s(:str, 'baz'))
         end
 
-        it 'works for a simple interpolation in extra-compatible mode' do
-          '/foo#{bar}baz/'.
-            must_be_parsed_as s(:dregx,
-                                'foo',
-                                s(:evstr, s(:call, nil, :bar)),
-                                s(:str, 'baz')),
-                              extra_compatible: true
-        end
-
         it 'works for a regex literal with flags and interpolation' do
           '/foo#{bar}/ixm'.
             must_be_parsed_as s(:dregx,
@@ -267,11 +258,6 @@ describe RipperRubyParser::Parser do
           '"foo\\u273bbar"'.must_be_parsed_as s(:str, 'foo✻bar')
         end
 
-        it 'works with unicode escapes in extra-compatible mode' do
-          '"foo\\u273bbar"'.
-            must_be_parsed_as s(:str, 'foo✻r'), extra_compatible: true
-        end
-
         it 'works with unicode escapes with braces' do
           '"foo\\u{273b}bar"'.must_be_parsed_as s(:str, 'foo✻bar')
         end
@@ -280,10 +266,6 @@ describe RipperRubyParser::Parser do
           '"2\302\275"'.must_be_parsed_as s(:str, '2½')
         end
 
-        it 'converts to unicode if possible in extra-compatible mode' do
-          '"2\302\275"'.must_be_parsed_as s(:str, '2½'), extra_compatible: true
-        end
-
         it 'does not convert to unicode if result is not valid' do
           '"2\x82\302\275"'.
             must_be_parsed_as s(:str,
@@ -291,82 +273,113 @@ describe RipperRubyParser::Parser do
         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
+      describe 'with interpolations 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 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
+        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
+      describe 'with interpolations 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 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
+        it 'works for cvars' do
+          "\"foo\#@@bar\"".must_be_parsed_as s(:dstr,
+                                               'foo',
+                                               s(:evstr, s(:cvar, :@@bar)))
         end
+      end
 
-        describe 'with braces' do
-          it 'works for trivial interpolated strings' do
-            '"#{foo}"'.
-              must_be_parsed_as s(:dstr,
-                                  '',
-                                  s(:evstr,
-                                    s(:call, nil, :foo)))
-          end
+      describe 'with interpolations with braces' do
+        it 'works for trivial interpolated strings' do
+          '"#{foo}"'.
+            must_be_parsed_as s(:dstr,
+                                '',
+                                s(:evstr,
+                                  s(:call, nil, :foo)))
+        end
 
-          it 'works for basic interpolated strings' do
-            '"foo#{bar}"'.
-              must_be_parsed_as s(:dstr,
-                                  'foo',
-                                  s(:evstr,
-                                    s(:call, nil, :bar)))
-          end
+        it 'works for basic interpolated strings' do
+          '"foo#{bar}"'.
+            must_be_parsed_as s(:dstr,
+                                'foo',
+                                s(:evstr,
+                                  s(:call, nil, :bar)))
+        end
 
-          it 'works for strings with several interpolations' do
-            '"foo#{bar}baz#{qux}"'.
-              must_be_parsed_as s(:dstr,
-                                  'foo',
-                                  s(:evstr, s(:call, nil, :bar)),
-                                  s(:str, 'baz'),
-                                  s(:evstr, s(:call, nil, :qux)))
-          end
+        it 'works for strings with several interpolations' do
+          '"foo#{bar}baz#{qux}"'.
+            must_be_parsed_as s(:dstr,
+                                'foo',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, 'baz'),
+                                s(:evstr, s(:call, nil, :qux)))
+        end
 
-          it 'correctly handles two interpolations in a row' do
-            "\"\#{bar}\#{qux}\"".
-              must_be_parsed_as s(:dstr,
-                                  '',
-                                  s(:evstr, s(:call, nil, :bar)),
-                                  s(:evstr, s(:call, nil, :qux)))
-          end
+        it 'correctly handles two interpolations in a row' do
+          "\"\#{bar}\#{qux}\"".
+            must_be_parsed_as s(:dstr,
+                                '',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:evstr, s(:call, nil, :qux)))
+        end
 
-          it 'works with an empty interpolation' do
-            "\"foo\#{}bar\"".
-              must_be_parsed_as s(:dstr,
-                                  'foo',
-                                  s(:evstr),
-                                  s(:str, 'bar'))
-          end
+        it 'works with an empty interpolation' do
+          "\"foo\#{}bar\"".
+            must_be_parsed_as s(:dstr,
+                                'foo',
+                                s(:evstr),
+                                s(:str, 'bar'))
+        end
+
+        it 'correctly handles interpolation with __FILE__ before another interpolation' do
+          "\"foo\#{__FILE__}\#{bar}\"".
+            must_be_parsed_as s(:dstr,
+                                'foo(string)',
+                                s(:evstr, s(:call, nil, :bar)))
+        end
+
+        it 'correctly handles interpolation with __FILE__ after another interpolation' do
+          "\"\#{bar}foo\#{__FILE__}\"".
+            must_be_parsed_as s(:dstr,
+                                '',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, 'foo'),
+                                s(:str, '(string)'))
+        end
+
+        it 'correctly handles nested interpolation' do
+          '"foo#{"bar#{baz}"}"'.
+            must_be_parsed_as s(:dstr,
+                                'foobar',
+                                s(:evstr, s(:call, nil, :baz)))
+        end
+
+        it 'correctly handles consecutive nested interpolation' do
+          '"foo#{"bar#{baz}"}foo#{"bar#{baz}"}"'.
+            must_be_parsed_as s(:dstr,
+                                'foobar',
+                                s(:evstr, s(:call, nil, :baz)),
+                                s(:str, 'foo'),
+                                s(:str, 'bar'),
+                                s(:evstr, s(:call, nil, :baz)))
         end
       end
 
@@ -402,34 +415,13 @@ describe RipperRubyParser::Parser do
                                 s(:evstr, s(:call, nil, :foo)),
                                 s(:str, "\u0000"))
         end
-      end
-
-      describe 'with interpolations and escape sequences in extra-compatible mode' do
-        it 'does not convert to unicode after interpolation' do
-          '"#{foo}2\302\275"'.
-            must_be_parsed_as s(:dstr,
-                                '',
-                                s(:evstr, s(:call, nil, :foo)),
-                                s(:str, (+"2\xC2\xBD").force_encoding('ascii-8bit'))),
-                              extra_compatible: true
-        end
-
-        it 'keeps single null byte as ascii after interpolation' do
-          '"#{foo}\0"'.
-            must_be_parsed_as s(:dstr,
-                                '',
-                                s(:evstr, s(:call, nil, :foo)),
-                                s(:str, (+"\x00").force_encoding('ascii-8bit'))),
-                              extra_compatible: true
-        end
 
         it 'converts string with null to unicode after interpolation' do
           '"#{foo}bar\0"'.
             must_be_parsed_as s(:dstr,
                                 '',
                                 s(:evstr, s(:call, nil, :foo)),
-                                s(:str, "bar\x00")),
-                              extra_compatible: true
+                                s(:str, "bar\x00"))
         end
       end
 
@@ -458,12 +450,6 @@ describe RipperRubyParser::Parser do
           "'foo\\\nbar'".
             must_be_parsed_as s(:str, "foo\\\nbar")
         end
-
-        it 'handles escape sequences correctly in extra-compatible mode' do
-          "'foo\\'bar\\\nbaz\\aqux'".
-            must_be_parsed_as s(:str, "foo'bar\\\nbaz\\aqux"),
-                              extra_compatible: true
-        end
       end
 
       describe 'with %Q-delimited strings' do
@@ -613,10 +599,9 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:str, "bar\tbaz\n")
         end
 
-        it 'works for escape sequences in extra-compatible mode' do
-          "<<FOO\nbar\\tbaz\nFOO".
-            must_be_parsed_as s(:str, "bar\tbaz\n"),
-                              extra_compatible: true
+        it 'converts \r to carriage returns' do
+          "<<FOO\nbar\\rbaz\\r\nFOO".
+            must_be_parsed_as s(:str, "bar\rbaz\r\n")
         end
 
         it 'does not unescape with single quoted version' do
@@ -624,12 +609,6 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:str, "bar\\tbaz\n")
         end
 
-        it 'does not unescape with single quoted version in extra-compatible mode' do
-          "<<'FOO'\nbar\\tbaz\nFOO".
-            must_be_parsed_as s(:str, "bar\\tbaz\n"),
-                              extra_compatible: true
-        end
-
         it 'works with multiple lines with the single quoted version' do
           "<<'FOO'\nbar\nbaz\nFOO".
             must_be_parsed_as s(:str, "bar\nbaz\n")
@@ -660,11 +639,25 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:str, "2½\n")
         end
 
-        it 'does not convert to unicode in extra-compatible mode' do
-          "<<FOO\n2\\302\\275\nFOO".
-            must_be_parsed_as s(:str,
-                                (+"2\xC2\xBD\n").force_encoding('ascii-8bit')),
-                              extra_compatible: true
+        it 'handles interpolation' do
+          "<<FOO\n\#{bar}\nFOO".
+            must_be_parsed_as s(:dstr, '',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, "\n"))
+        end
+
+        it 'handles line continuation after interpolation' do
+          "<<FOO\n\#{bar}\nbaz\\\nqux\nFOO".
+            must_be_parsed_as s(:dstr, '',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, "\nbazqux\n"))
+        end
+
+        it 'handles line continuation after interpolation for the indentable case' do
+          "<<-FOO\n\#{bar}\nbaz\\\nqux\nFOO".
+            must_be_parsed_as s(:dstr, '',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, "\nbazqux\n"))
         end
       end
     end
@@ -739,13 +732,6 @@ describe RipperRubyParser::Parser do
         '%W(2\302\275)'.must_be_parsed_as s(:array, s(:str, '2½'))
       end
 
-      it 'does not convert to unicode if possible in extra-compatible mode' do
-        '%W(2\302\275)'.
-          must_be_parsed_as s(:array,
-                              s(:str, (+"2\xC2\xBD").force_encoding('ascii-8bit'))),
-                            extra_compatible: true
-      end
-
       it 'correctly handles line continuation' do
         "%W(foo\\\nbar baz)".
           must_be_parsed_as s(:array,
@@ -760,20 +746,6 @@ describe RipperRubyParser::Parser do
                               s(:str, 'bar'),
                               s(:str, 'baz'))
       end
-
-      it 'handles escaped spaces in extra-compatible mode' do
-        '%W(foo bar\ baz)'.
-          must_be_parsed_as s(:array, s(:str, 'foo'), s(:str, 'bar baz')),
-                            extra_compatible: true
-      end
-
-      it 'correctly handles line continuation in extra-compatible mode' do
-        "%W(foo\\\nbar baz)".
-          must_be_parsed_as s(:array,
-                              s(:str, "foo\nbar"),
-                              s(:str, 'baz')),
-                            extra_compatible: true
-      end
     end
 
     describe 'for symbol list literals with %i delimiter' do
@@ -912,6 +884,10 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:lit, :__FILE__)
       end
 
+      it 'works for a backtick symbol' do
+        ':`'.must_be_parsed_as s(:lit, :`)
+      end
+
       it 'works for simple dsyms' do
         ':"foo"'.
           must_be_parsed_as s(:lit, :foo)
@@ -1126,5 +1102,16 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:lit, 1000r)
       end
     end
+
+    describe 'in extra compatible mode' do
+      it 'converts \r to carriage returns in double-quoted strings' do
+        '"foo\\rbar"'.must_be_parsed_as s(:str, "foo\rbar"), extra_compatible: true
+      end
+
+      it 'removes \r from heredocs' do
+        "<<FOO\nbar\\rbaz\\r\nFOO".
+          must_be_parsed_as s(:str, "barbaz\n"), extra_compatible: true
+      end
+    end
   end
 end

data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb

@@ -172,6 +172,27 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
+      it 'works with argument destructuring' do
+        'def foo((bar, baz)); end'.
+          must_be_parsed_as s(:defn, :foo,
+                              s(:args, s(:masgn, :bar, :baz)),
+                              s(:nil))
+      end
+
+      it 'works with argument destructuring including splat' do
+        'def foo((bar, *baz)); end'.
+          must_be_parsed_as s(:defn, :foo,
+                              s(:args, s(:masgn, :bar, :'*baz')),
+                              s(:nil))
+      end
+
+      it 'works with nested argument destructuring' do
+        'def foo((bar, (baz, qux))); end'.
+          must_be_parsed_as s(:defn, :foo,
+                              s(:args, s(:masgn, :bar, s(:masgn, :baz, :qux))),
+                              s(:nil))
+      end
+
       it 'works when the method name is an operator' do
         'def +; end'.
           must_be_parsed_as s(:defn, :+, s(:args),
@@ -389,7 +410,7 @@ describe RipperRubyParser::Parser do
     end
 
     describe 'when extra compatibility is turned on' do
-      it 'treats block kwargs as calls' do
+      it 'still treats block kwargs as lvars' do
         'def foo(**bar); baz { |**qux| bar; qux }; end'.
           must_be_parsed_as s(:defn, :foo,
                               s(:args, :"**bar"),
@@ -398,7 +419,7 @@ describe RipperRubyParser::Parser do
                                 s(:args, :"**qux"),
                                 s(:block,
                                   s(:lvar, :bar),
-                                  s(:call, nil, :qux)))),
+                                  s(:lvar, :qux)))),
                             extra_compatible: true
       end
     end