ripper_ruby_parser 1.4.2 → 1.5.0

data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
+  let(:parser) { RipperRubyParser::Parser.new }
+
   describe '#parse' do
     describe 'for single assignment' do
       it 'works when assigning to a namespaced constant' do
@@ -17,8 +21,13 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :bar))
       end
 
+      it 'works with blocks' do
+        'foo = begin; bar; end'.
+          must_be_parsed_as s(:lasgn, :foo, s(:call, nil, :bar))
+      end
+
       describe 'with a right-hand splat' do
-        specify do
+        it 'works in the simple case' do
           'foo = *bar'.
             must_be_parsed_as s(:lasgn, :foo,
                                 s(:svalue,
@@ -26,19 +35,15 @@ describe RipperRubyParser::Parser do
                                     s(:call, nil, :bar))))
         end
 
-        specify do
-          'foo = bar, *baz'.
+        it 'works with blocks' do
+          'foo = *begin; bar; end'.
             must_be_parsed_as s(:lasgn, :foo,
-                                s(:svalue,
-                                  s(:array,
-                                    s(:call, nil, :bar),
-                                    s(:splat,
-                                      s(:call, nil, :baz)))))
+                                s(:svalue, s(:splat, s(:call, nil, :bar))))
         end
       end
 
       describe 'with several items on the right hand side' do
-        specify do
+        it 'works in the simple case' do
           'foo = bar, baz'.
             must_be_parsed_as s(:lasgn, :foo,
                                 s(:svalue,
@@ -46,6 +51,16 @@ describe RipperRubyParser::Parser do
                                     s(:call, nil, :bar),
                                     s(:call, nil, :baz))))
         end
+
+        it 'works with a splat' do
+          'foo = bar, *baz'.
+            must_be_parsed_as s(:lasgn, :foo,
+                                s(:svalue,
+                                  s(:array,
+                                    s(:call, nil, :bar),
+                                    s(:splat,
+                                      s(:call, nil, :baz)))))
+        end
       end
 
       describe 'with an array literal on the right hand side' do
@@ -57,6 +72,150 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :baz)))
         end
       end
+
+      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
+
+      describe 'when assigning to a class variable' do
+        it 'works outside a method' do
+          '@@foo = bar'.
+            must_be_parsed_as s(:cvdecl,
+                                :@@foo,
+                                s(:call, nil, :bar))
+        end
+
+        it 'works 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 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 inside method arguments' do
+          'def foo(bar = (@@baz = qux)); end'.
+            must_be_parsed_as s(:defn,
+                                :foo,
+                                s(:args,
+                                  s(:lasgn, :bar,
+                                    s(:cvasgn, :@@baz, s(:call, nil, :qux)))),
+                                s(:nil))
+        end
+
+        it 'works inside method arguments of a singleton method' do
+          'def self.foo(bar = (@@baz = qux)); end'.
+            must_be_parsed_as s(:defs,
+                                s(:self),
+                                :foo,
+                                s(:args,
+                                  s(:lasgn, :bar,
+                                    s(:cvasgn, :@@baz, s(:call, nil, :qux)))),
+                                s(:nil))
+        end
+
+        it 'works inside the receiver in a method definition' do
+          'def (bar = (@@baz = qux)).foo; end'.
+            must_be_parsed_as s(:defs,
+                                s(:lasgn, :bar,
+                                  s(:cvdecl, :@@baz,
+                                    s(:call, nil, :qux))), :foo,
+                                s(:args), s(:nil))
+        end
+      end
+
+      it 'works when assigning to a global variable' do
+        '$foo = bar'.
+          must_be_parsed_as s(:gasgn,
+                              :$foo,
+                              s(:call, nil, :bar))
+      end
+
+      describe 'with a rescue modifier' do
+        it 'works with assigning a bare method call' do
+          'foo = bar rescue baz'.
+            must_be_parsed_as s(:lasgn, :foo,
+                                s(:rescue,
+                                  s(:call, nil, :bar),
+                                  s(:resbody, s(:array), s(:call, nil, :baz))))
+        end
+
+        it 'works with a method call with argument' do
+          'foo = bar(baz) rescue qux'.
+            must_be_parsed_as s(:lasgn, :foo,
+                                s(:rescue,
+                                  s(:call, nil, :bar, s(:call, nil, :baz)),
+                                  s(:resbody, s(:array), s(:call, nil, :qux))))
+        end
+
+        it 'works with a method call with argument without brackets' do
+          expected = if RUBY_VERSION < '2.4.0'
+                       s(:rescue,
+                         s(:lasgn, :foo, s(:call, nil, :bar, s(:call, nil, :baz))),
+                         s(:resbody, s(:array), s(:call, nil, :qux)))
+                     else
+                       s(:lasgn, :foo,
+                         s(:rescue,
+                           s(:call, nil, :bar, s(:call, nil, :baz)),
+                           s(:resbody, s(:array), s(:call, nil, :qux))))
+                     end
+          'foo = bar baz rescue qux'.must_be_parsed_as expected
+        end
+
+        it 'works with a class method call with argument without brackets' do
+          expected = if RUBY_VERSION < '2.4.0'
+                       s(:rescue,
+                         s(:lasgn, :foo, s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
+                         s(:resbody, s(:array), s(:call, nil, :quuz)))
+                     else
+                       s(:lasgn, :foo,
+                         s(:rescue,
+                           s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
+                           s(:resbody, s(:array), s(:call, nil, :quuz))))
+                     end
+          'foo = Bar.baz qux rescue quuz'.
+            must_be_parsed_as expected
+        end
+      end
+
+      it 'sets the correct line numbers' do
+        result = parser.parse 'foo = {}'
+        result.line.must_equal 1
+      end
     end
 
     describe 'for multiple assignment' do
@@ -84,6 +243,155 @@ describe RipperRubyParser::Parser do
                                 s(:lasgn, :bar)),
                               s(:to_ary, s(:call, nil, :baz)))
       end
+
+      it 'works with a rescue modifier' do
+        'foo, bar = baz rescue qux'.
+          must_be_parsed_as s(:rescue,
+                              s(:masgn,
+                                s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                                s(:to_ary, s(:call, nil, :baz))),
+                              s(:resbody, s(:array), s(:call, nil, :qux)))
+      end
+
+      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
+
+      it 'works with a right-hand single splat' do
+        'foo, bar = *baz'.
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                              s(:splat, s(:call, nil, :baz)))
+      end
+
+      it 'works with a splat in a list of values on the right hand' 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(:splat, s(:call, nil, :qux))))
+      end
+
+      it 'works with a right-hand single splat with begin..end block' do
+        'foo, bar = *begin; baz; end'.
+          must_be_parsed_as s(:masgn,
+                              s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                              s(:splat,
+                                s(:call, nil, :baz)))
+      end
+
+      it 'sets the correct line numbers' do
+        result = parser.parse 'foo, bar = {}, {}'
+        result.line.must_equal 1
+      end
     end
 
     describe 'for assignment to a collection element' do
@@ -99,6 +407,88 @@ describe RipperRubyParser::Parser do
     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(: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
+
       describe 'assigning to a collection element' do
         it 'handles multiple indices' do
           'foo[bar, baz] += qux'.
@@ -111,31 +501,74 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :qux))
         end
 
-        it 'works with &&=' do
+        it 'works with boolean operators' do
           'foo &&= bar'.
             must_be_parsed_as s(:op_asgn_and,
                                 s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
         end
-      end
-    end
 
-    describe 'for multiple assignment' do
-      describe 'with a right-hand splat' do
-        specify do
-          'foo, bar = *baz'.
-            must_be_parsed_as s(:masgn,
-                                s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                                s(:splat, s(:call, nil, :baz)))
+        it 'works with boolean operators and blocks' do
+          'foo &&= begin; bar; end'.
+            must_be_parsed_as s(:op_asgn_and,
+                                s(:lvar, :foo), s(:lasgn, :foo, s(:call, nil, :bar)))
         end
-        specify 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(:splat, s(:call, nil, :qux))))
+
+        it 'works with arithmetic operators and blocks' do
+          'foo += begin; bar; end'.
+            must_be_parsed_as s(:lasgn, :foo,
+                                s(:call, s(:lvar, :foo), :+, s(:call, nil, :bar)))
         end
       end
     end
+
+    describe 'when extra compatibility is turned on' do
+      it 'works with a bare method call' do
+        'foo = bar'.
+          must_be_parsed_as s(:lasgn, :foo, s(:call, nil, :bar)),
+                            extra_compatible: true
+      end
+
+      it 'works with a literal' do
+        'foo = 0'.
+          must_be_parsed_as s(:lasgn, :foo, s(:lit, 0)),
+                            extra_compatible: true
+      end
+
+      it 'works with a bare method call with rescue modifier' do
+        'foo = bar rescue baz'.
+          must_be_parsed_as s(:lasgn, :foo,
+                              s(:rescue,
+                                s(:call, nil, :bar),
+                                s(:resbody, s(:array), s(:call, nil, :baz)))),
+                            extra_compatible: true
+      end
+
+      it 'works with a method call with argument with bracket with rescue modifier' do
+        'foo = bar(baz) rescue qux'.
+          must_be_parsed_as s(:lasgn, :foo,
+                              s(:rescue,
+                                s(:call, nil, :bar, s(:call, nil, :baz)),
+                                s(:resbody, s(:array), s(:call, nil, :qux)))),
+                            extra_compatible: true
+      end
+
+      it 'works with a method call with argument without bracket with rescue modifier' do
+        'foo = bar baz rescue qux'.
+          must_be_parsed_as s(:rescue,
+                              s(:lasgn, :foo, s(:call, nil, :bar, s(:call, nil, :baz))),
+                              s(:resbody, s(:array), s(:call, nil, :qux))),
+                            extra_compatible: true
+      end
+
+      it 'works with a class method call with argument without bracket with rescue modifier' do
+        'foo = Bar.baz qux rescue quuz'.
+          must_be_parsed_as s(:rescue,
+                              s(:lasgn,
+                                :foo,
+                                s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
+                              s(:resbody, s(:array), s(:call, nil, :quuz))),
+                            extra_compatible: true
+      end
+    end
   end
 end