ripper_ruby_parser 1.4.2 → 1.5.0

data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
@@ -58,6 +60,34 @@ describe RipperRubyParser::Parser do
                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
                               s(:call, nil, :baz), true)
       end
+
+      it 'cleans up begin..end block in condition' do
+        'while begin foo end; bar; end'.
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), true)
+      end
+
+      it 'cleans up begin..end block in condition in the postfix case' do
+        'foo while begin bar end'.
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), true)
+      end
+
+      it 'works with do and an empty body' do
+        'while foo do; end'.
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :foo),
+                              nil, true)
+      end
+
+      it 'works without do and with an empty body' do
+        'while foo; end'.
+          must_be_parsed_as s(:while,
+                              s(:call, nil, :foo),
+                              nil, true)
+      end
     end
 
     describe 'for the until statement' do
@@ -116,6 +146,64 @@ describe RipperRubyParser::Parser do
                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
                               s(:call, nil, :baz), true)
       end
+
+      it 'cleans up begin..end block in condition' do
+        'until begin foo end; bar; end'.
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar), true)
+      end
+
+      it 'cleans up begin..end block in condition in the postfix case' do
+        'foo until begin bar end'.
+          must_be_parsed_as s(:until,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo), true)
+      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
+
+      it 'works with explicit multiple assignment' do
+        'for foo, bar in baz; end'.
+          must_be_parsed_as s(:for,
+                              s(:call, nil, :baz),
+                              s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :foo),
+                                  s(:lasgn, :bar))))
+      end
+
+      it 'works with multiple assignment with trailing comma' do
+        'for foo, in bar; end'.
+          must_be_parsed_as s(:for,
+                              s(:call, nil, :bar),
+                              s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :foo))))
+      end
     end
   end
 end

data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
-describe RipperRubyParser::Parser do
-  describe '#parse' do
+describe RipperRubyParser::SexpHandlers::MethodCalls do
+  describe 'when parsing with RipperRubyParser::Parser#parse' do
     describe 'for method calls' do
       describe 'without a receiver' do
         it 'works without parentheses' do
@@ -135,13 +137,34 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :baz,
                                   s(:call, nil, :qux)))
         end
+
+        it 'does not keep :begin around a method receiver' do
+          'begin; foo; end.bar'.
+            must_be_parsed_as s(:call, s(:call, nil, :foo), :bar)
+        end
       end
 
-      describe 'safe call' do
-        before do
-          skip 'This is not valid syntax below Ruby 2.3' if RUBY_VERSION < '2.3.0'
+      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 'safe call' do
         it 'works without arguments' do
           'foo&.bar'.must_be_parsed_as s(:safe_call, s(:call, nil, :foo), :bar)
         end
@@ -211,4 +234,34 @@ describe RipperRubyParser::Parser do
         must_be_parsed_as s(:call, s(:call, nil, :foo), :call)
     end
   end
+
+  describe 'when processing a Sexp' do
+    let(:processor) { RipperRubyParser::SexpProcessor.new }
+
+    describe '#process_command_call' do
+      it 'processes a Ruby 2.5 style period Sexp' do
+        sexp = s(:call,
+                 s(:vcall, s(:@ident, 'foo', s(1, 0))),
+                 :'.',
+                 s(:@ident, 'bar', s(1, 4)))
+        processor.process(sexp).must_equal s(:call, s(:call, nil, :foo), :bar)
+      end
+
+      it 'processes a Ruby 2.6 style period Sexp' do
+        sexp = s(:call,
+                 s(:vcall, s(:@ident, 'foo', s(1, 0))),
+                 s(:@period, '.', s(1, 3)),
+                 s(:@ident, 'bar', s(1, 4)))
+        processor.process(sexp).must_equal s(:call, s(:call, nil, :foo), :bar)
+      end
+
+      it 'raises an error for an unknown call operator' do
+        sexp = s(:call,
+                 s(:vcall, s(:@ident, 'foo', s(1, 0))),
+                 :'>.',
+                 s(:@ident, 'bar', s(1, 4)))
+        -> { processor.process(sexp) }.must_raise
+      end
+    end
+  end
 end

data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  describe '#parse' do
+    describe 'for instance method definitions' do
+      it 'treats kwargs as a local variable' do
+        'def foo(**bar); bar; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :"**bar"),
+                              s(:lvar, :bar))
+      end
+
+      it 'treats kwargs as a local variable when other arguments are present' do
+        'def foo(bar, **baz); baz; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :bar, :"**baz"),
+                              s(:lvar, :baz))
+      end
+
+      it 'treats kwargs as a local variable when an explicit block is present' do
+        'def foo(**bar, &baz); bar; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :"**bar", :"&baz"),
+                              s(:lvar, :bar))
+      end
+
+      it 'treats block kwargs as lvars' do
+        'def foo(**bar); baz { |**qux| bar; qux }; end'.
+          must_be_parsed_as s(:defn, :foo,
+                              s(:args, :"**bar"),
+                              s(:iter,
+                                s(:call, nil, :baz),
+                                s(:args, :"**qux"),
+                                s(:block,
+                                  s(:lvar, :bar),
+                                  s(:lvar, :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 singleton method definitions' do
+      it 'works with empty body' do
+        'def foo.bar; end'.
+          must_be_parsed_as s(:defs,
+                              s(:call, nil, :foo),
+                              :bar,
+                              s(:args),
+                              s(:nil))
+      end
+
+      it 'works with a body with 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 simple splat' do
+        'def foo.bar *baz; end'.
+          must_be_parsed_as s(:defs,
+                              s(:call, nil, :foo),
+                              :bar,
+                              s(:args, :"*baz"),
+                              s(:nil))
+      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 'treats keywords as symbols' do
+        'alias next foo'.
+          must_be_parsed_as s(:alias, s(:lit, :next), s(:lit, :foo))
+      end
+
+      it 'works with global variables' do
+        'alias $foo $bar'.
+          must_be_parsed_as s(:valias, :$foo, :$bar)
+      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 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 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 'when extra compatibility is turned on' do
+      it 'treats block kwargs as calls' do
+        'def foo(**bar); baz { |**qux| bar; qux }; end'.
+          must_be_parsed_as s(:defn, :foo,
+                              s(:args, :"**bar"),
+                              s(:iter,
+                                s(:call, nil, :baz),
+                                s(:args, :"**qux"),
+                                s(:block,
+                                  s(:lvar, :bar),
+                                  s(:call, nil, :qux)))),
+                            extra_compatible: true
+      end
+    end
+  end
+end