ripper_ruby_parser 1.4.2 → 1.5.0

data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe '#parse' do
-    describe 'for blocks' do
+    describe 'for do blocks' do
       it 'works with no statements in the block body' do
         'foo do; end'.
           must_be_parsed_as s(:iter,
@@ -17,6 +19,33 @@ describe RipperRubyParser::Parser do
                               0,
                               s(:redo))
       end
+
+      it 'works with nested begin..end' do
+        'foo do; begin; bar; end; end;'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:call, nil, :bar))
+      end
+
+      it 'works with nested begin..end plus other statements' do
+        'foo do; bar; begin; baz; end; end;'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:block,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)))
+      end
+    end
+
+    describe 'for brace blocks' do
+      it 'works with no statements in the block body' do
+        'foo { }'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0)
+      end
     end
 
     describe 'for block parameters' do
@@ -94,112 +123,85 @@ describe RipperRubyParser::Parser do
                               s(:args, :bar, :baz))
       end
 
-      it 'works with a single splat argument' do
-        'foo do |*bar|; end'.
+      it 'works with an argument with a default value' do
+        'foo do |bar=baz|; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              s(:args, :"*bar"))
+                              s(:args,
+                                s(:lasgn, :bar, s(:call, nil, :baz))))
       end
 
-      it 'works with a combination of regular arguments and a splat argument' do
-        'foo do |bar, *baz|; end'.
+      it 'works with a keyword argument with no default value' do
+        'foo do |bar:|; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              s(:args, :bar, :"*baz"))
-      end
-    end
-
-    describe 'for begin' do
-      it 'works for an empty begin..end block' do
-        'begin end'.must_be_parsed_as s(:nil)
-      end
-
-      it 'works for a simple begin..end block' do
-        'begin; foo; end'.must_be_parsed_as s(:call, nil, :foo)
+                              s(:args,
+                                s(:kwarg, :bar)))
       end
 
-      it 'works for begin..end block with more than one statement' do
-        'begin; foo; bar; end'.
-          must_be_parsed_as s(:block,
+      it 'works with a keyword argument with a default value' do
+        'foo do |bar: baz|; end'.
+          must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              s(:call, nil, :bar))
-      end
-
-      it 'keeps :begin for the argument of a unary operator' do
-        '- begin; foo; end'.
-          must_be_parsed_as s(:call,
-                              s(:begin, s(:call, nil, :foo)),
-                              :-@)
-      end
-
-      it 'keeps :begin for the first argument of a binary operator' do
-        'begin; bar; end + foo'.
-          must_be_parsed_as s(:call,
-                              s(:begin, s(:call, nil, :bar)),
-                              :+,
-                              s(:call, nil, :foo))
+                              s(:args,
+                                s(:kwarg, :bar, s(:call, nil, :baz))))
       end
 
-      it 'keeps :begin for the second argument of a binary operator' do
-        'foo + begin; bar; end'.
-          must_be_parsed_as s(:call,
+      it 'works with a single splat argument' do
+        'foo do |*bar|; end'.
+          must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              :+,
-                              s(:begin, s(:call, nil, :bar)))
+                              s(:args, :"*bar"))
       end
 
-      it 'does not keep :begin for the first argument of a boolean operator' do
-        'begin; bar; end and foo'.
-          must_be_parsed_as s(:and,
-                              s(:call, nil, :bar),
-                              s(:call, nil, :foo))
+      it 'works with a combination of regular arguments and a splat argument' do
+        'foo do |bar, *baz|; end'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args, :bar, :"*baz"))
       end
 
-      it 'keeps :begin for the second argument of a boolean operator' do
-        'foo and begin; bar; end'.
-          must_be_parsed_as s(:and,
+      it 'works with a kwrest argument' do
+        'foo do |**bar|; baz bar; end'.
+          must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              s(:begin, s(:call, nil, :bar)))
+                              s(:args, :"**bar"),
+                              s(:call, nil, :baz,
+                                s(:lvar, :bar)))
       end
 
-      it 'does not keep :begin for the first argument of a shift operator' do
-        'begin; bar; end << foo'.
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :bar),
-                              :<<,
-                              s(:call, nil, :foo))
+      it 'works with a regular argument after a splat argument' do
+        'foo do |*bar, baz|; end'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              s(:args, :"*bar", :baz))
       end
 
-      it 'does not keep :begin for the second argument of a shift operator' do
-        'foo >> begin; bar; end'.
-          must_be_parsed_as s(:call,
+      it 'works with a combination of regular arguments and a kwrest argument' do
+        'foo do |bar, **baz|; qux bar, baz; end'.
+          must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              :>>,
-                              s(:call, nil, :bar))
+                              s(:args, :bar, :"**baz"),
+                              s(:call, nil, :qux,
+                                s(:lvar, :bar),
+                                s(:lvar, :baz)))
       end
+    end
 
-      it 'keeps :begin for the first argument of a ternary operator' do
-        'begin; foo; end ? bar : baz'.
-          must_be_parsed_as s(:if,
-                              s(:begin, s(:call, nil, :foo)),
-                              s(:call, nil, :bar),
-                              s(:call, nil, :baz))
+    describe 'for begin' do
+      it 'works for an empty begin..end block' do
+        'begin end'.must_be_parsed_as s(:nil)
       end
 
-      it 'keeps :begin for the second argument of a ternary operator' do
-        'foo ? begin; bar; end : baz'.
-          must_be_parsed_as s(:if,
-                              s(:call, nil, :foo),
-                              s(:begin, s(:call, nil, :bar)),
-                              s(:call, nil, :baz))
+      it 'works for a simple begin..end block' do
+        'begin; foo; end'.must_be_parsed_as s(:call, nil, :foo)
       end
 
-      it 'keeps :begin for the third argument of a ternary operator' do
-        'foo ? bar : begin; baz; end'.
-          must_be_parsed_as s(:if,
+      it 'works for begin..end block with more than one statement' do
+        'begin; foo; bar; end'.
+          must_be_parsed_as s(:block,
                               s(:call, nil, :foo),
-                              s(:call, nil, :bar),
-                              s(:begin, s(:call, nil, :baz)))
+                              s(:call, nil, :bar))
       end
 
       it 'keeps :begin for the truepart of a postfix if' do
@@ -336,12 +338,31 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :qux)))
       end
 
-      it 'works in the postfix case' do
-        'foo rescue bar'.
+      it 'works rescuing a splatted list of exception types' do
+        'begin; foo; rescue *bar; baz; end'.
           must_be_parsed_as s(:rescue,
                               s(:call, nil, :foo),
                               s(:resbody,
-                                s(:array),
+                                s(:splat, s(:call, nil, :bar)),
+                                s(:call, nil, :baz)))
+      end
+
+      it 'works rescuing a complex list of exception types' do
+        'begin; foo; rescue *bar, Baz; qux; end'.
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array,
+                                  s(:splat, s(:call, nil, :bar)),
+                                  s(:const, :Baz)),
+                                s(:call, nil, :qux)))
+      end
+
+      it 'works with a nested begin..end block' do
+        'begin; foo; rescue; begin; bar; end; end'.
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody, s(:array),
                                 s(:call, nil, :bar)))
       end
 
@@ -357,7 +378,7 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :baz))))
       end
 
-      it 'works in a method body inside begin..end' do
+      it 'works in a method body inside begin..end with rescue' do
         'def foo; bar; begin; baz; rescue; qux; end; quuz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
@@ -368,6 +389,47 @@ describe RipperRubyParser::Parser do
                                 s(:resbody, s(:array), s(:call, nil, :qux))),
                               s(:call, nil, :quuz))
       end
+
+      it 'works in a method body inside begin..end without rescue' do
+        'def foo; bar; begin; baz; qux; end; quuz; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args),
+                              s(:call, nil, :bar),
+                              s(:block,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)),
+                              s(:call, nil, :quuz))
+      end
+
+      it 'works in a method body fully inside begin..end' do
+        'def foo; begin; bar; baz; end; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args),
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz))
+      end
+    end
+
+    describe 'for the postfix rescue modifier' do
+      it 'works in the basic case' do
+        'foo rescue bar'.
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :bar)))
+      end
+
+      it 'works when the fallback value is a keyword' do
+        'foo rescue next'.
+          must_be_parsed_as s(:rescue,
+                              s(:call, nil, :foo),
+                              s(:resbody,
+                                s(:array),
+                                s(:next)))
+      end
     end
 
     describe 'for the ensure statement' do
@@ -554,6 +616,14 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :bar))
       end
 
+      it 'works in the simple case without parentheses' do
+        '-> foo { bar }'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :lambda),
+                              s(:args, :foo),
+                              s(:call, nil, :bar))
+      end
+
       it 'works when there are zero arguments' do
         '->() { bar }'.
           must_be_parsed_as s(:iter,

data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
@@ -29,6 +31,14 @@ describe RipperRubyParser::Parser do
                               nil)
       end
 
+      it 'works with a begin..end block' do
+        'if foo; begin; bar; end; end'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              nil)
+      end
+
       it 'works with an else clause' do
         'if foo; bar; else; baz; end'.
           must_be_parsed_as s(:if,
@@ -61,6 +71,14 @@ describe RipperRubyParser::Parser do
                               nil)
       end
 
+      it 'handles bare integer literal in condition' do
+        'if 1; bar; end'.
+          must_be_parsed_as s(:if,
+                              s(:lit, 1),
+                              s(:call, nil, :bar),
+                              nil)
+      end
+
       it 'handles bare regex literal in condition' do
         'if /foo/; bar; end'.
           must_be_parsed_as s(:if,
@@ -108,6 +126,37 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :qux),
                               s(:call, nil, :baz))
       end
+
+      it 'cleans up begin..end block in condition' do
+        'if begin foo end; bar; end'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), nil)
+      end
+
+      it 'handles special conditions inside begin..end block' do
+        'if begin foo..bar end; baz; end'.
+          must_be_parsed_as s(:if,
+                              s(:flip2, s(:call, nil, :foo), s(:call, nil, :bar)),
+                              s(:call, nil, :baz),
+                              nil)
+      end
+
+      it 'works with assignment in the condition' do
+        'if foo = bar; baz; end'.
+          must_be_parsed_as s(:if,
+                              s(:lasgn, :foo,
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz), nil)
+      end
+
+      it 'works with bracketed assignment in the condition' do
+        'if (foo = bar); baz; end'.
+          must_be_parsed_as s(:if,
+                              s(:lasgn, :foo,
+                                s(:call, nil, :bar)),
+                              s(:call, nil, :baz), nil)
+      end
     end
 
     describe 'for postfix if' do
@@ -150,6 +199,13 @@ describe RipperRubyParser::Parser do
                               nil,
                               s(:call, nil, :baz))
       end
+
+      it 'cleans up begin..end block in condition' do
+        'foo if begin bar end'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), nil)
+      end
     end
 
     describe 'for regular unless' do
@@ -285,6 +341,17 @@ describe RipperRubyParser::Parser do
                                 nil))
       end
 
+      it 'works with an else' do
+        'if foo; bar; elsif baz; qux; else; quuz; end'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:if,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux),
+                                s(:call, nil, :quuz)))
+      end
+
       it 'works with an empty else' do
         'if foo; bar; elsif baz; qux; else; end'.
           must_be_parsed_as s(:if,
@@ -330,6 +397,17 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :quuz),
                                 nil))
       end
+
+      it 'cleans up begin..end block in condition' do
+        'if foo; bar; elsif begin baz end; qux; end'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:if,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux),
+                                nil))
+      end
     end
 
     describe 'for case block' do
@@ -377,6 +455,19 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :qux))
       end
 
+      it 'works with multiple statements in the else block' do
+        'case foo; when bar; baz; else; qux; 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(:block,
+                                s(:call, nil, :qux),
+                                s(:call, nil, :quuz)))
+      end
+
       it 'works with an empty when block' do
         'case foo; when bar; end'.
           must_be_parsed_as s(:case,