ripper_ruby_parser 1.5.1 → 1.6.0

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -113,8 +113,7 @@ module RipperRubyParser
       private
 
       def replace_kwrest_arg_call?(method)
-        method_kwrest_arg?(method) ||
-          !extra_compatible && block_kwrest_arg?(method)
+        kwrest_arg?(method)
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -10,7 +10,7 @@ module RipperRubyParser
         ident, pos = extract_node_symbol_with_position ident
 
         in_method do
-          params = convert_method_args(process(params))
+          params = convert_arguments(process(params))
           kwrest = kwrest_param(params)
           body = with_kwrest(kwrest) { method_body(body) }
         end
@@ -24,7 +24,7 @@ module RipperRubyParser
         ident, = extract_node_symbol_with_position ident
 
         in_method do
-          params = convert_method_args(process(params))
+          params = convert_arguments(process(params))
           kwrest = kwrest_param(params)
           body = with_kwrest(kwrest) { method_body(body) }
         end
@@ -87,11 +87,7 @@ module RipperRubyParser
         when 0
           [s(:nil)]
         else
-          if block.sexp_type == :block
-            block.sexp_body
-          else
-            [block]
-          end
+          unwrap_block block
         end
       end
 
@@ -101,7 +97,7 @@ module RipperRubyParser
         blockarg: '&'
       }.freeze
 
-      def convert_method_args(args)
+      def convert_arguments(args)
         args.map! do |item|
           if item.is_a? Symbol
             item
@@ -110,9 +106,9 @@ module RipperRubyParser
             when :lvar
               item.last
             when *SPECIAL_ARG_MARKER.keys
-              marker = SPECIAL_ARG_MARKER[item.sexp_type]
-              name = extract_node_symbol item.last
-              :"#{marker}#{name}"
+              convert_marked_argument(item)
+            when :masgn
+              convert_masgn_argument(item)
             else
               item
             end
@@ -120,6 +116,31 @@ module RipperRubyParser
         end
       end
 
+      def convert_marked_argument(item)
+        marker = SPECIAL_ARG_MARKER[item.sexp_type]
+        name = extract_node_symbol item.last
+        :"#{marker}#{name}"
+      end
+
+      def convert_masgn_argument(item)
+        args = item[1]
+        args.shift
+        s(:masgn, *convert_destructuring_arguments(args))
+      end
+
+      def convert_destructuring_arguments(args)
+        args.map! do |item|
+          case item.sexp_type
+          when :splat
+            convert_marked_argument(item)
+          when :masgn
+            convert_masgn_argument(item)
+          when :lasgn
+            item[1]
+          end
+        end
+      end
+
       def kwrest_param(params)
         found = params.find { |param| param.to_s =~ /^\*\*(.+)/ }
         Regexp.last_match[1].to_sym if found
@@ -132,20 +153,9 @@ module RipperRubyParser
         result
       end
 
-      def with_block_kwrest(kwrest)
-        @block_kwrest.push kwrest
-        result = yield
-        @block_kwrest.pop
-        result
-      end
-
-      def method_kwrest_arg?(method)
+      def kwrest_arg?(method)
         @kwrest.include?(method)
       end
-
-      def block_kwrest_arg?(method)
-        @block_kwrest.include?(method)
-      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -49,7 +49,7 @@ module RipperRubyParser
         left = process(left)
         right = process(right)
         if integer_literal?(left) && integer_literal?(right)
-          s(:lit, Range.new(left[1], right[1]))
+          with_line_number(left.line, s(:lit, Range.new(left[1], right[1])))
         else
           s(:dot2, left, right)
         end
@@ -60,7 +60,7 @@ module RipperRubyParser
         left = process(left)
         right = process(right)
         if integer_literal?(left) && integer_literal?(right)
-          s(:lit, Range.new(left[1], right[1], true))
+          with_line_number(left.line, s(:lit, Range.new(left[1], right[1], true)))
         else
           s(:dot3, left, right)
         end

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -31,6 +31,8 @@ module RipperRubyParser
       @processors[:@kw] = :process_at_kw
       @processors[:@op] = :process_at_op
       @processors[:@backref] = :process_at_backref
+
+      @processors[:@backtick] = :process_at_backtick
       @processors[:@period] = :process_at_period
 
       @processors[:@tstring_content] = :process_at_tstring_content
@@ -83,12 +85,7 @@ module RipperRubyParser
         statements.first
       else
         first = statements.shift
-        if first.sexp_type == :block
-          first.shift
-          s(:block, *first, *statements)
-        else
-          s(:block, first, *statements)
-        end
+        s(:block, *unwrap_block(first), *statements)
       end
     end
 
@@ -150,7 +147,7 @@ module RipperRubyParser
     def process_BEGIN(exp)
       _, body = exp.shift 2
       body = reject_void_stmt map_process_list body.sexp_body
-      s(:iter, s(:preexe), s(:args), *body)
+      s(:iter, s(:preexe), 0, *body)
     end
 
     def process_END(exp)
@@ -200,19 +197,17 @@ module RipperRubyParser
     end
 
     def process_at_ident(exp)
-      with_position_from_node_symbol(exp) do |ident|
-        if replace_kwrest_arg_lvar? ident
-          s(:call, nil, ident)
-        else
-          s(:lvar, ident)
-        end
-      end
+      make_identifier(:lvar, exp)
     end
 
     def process_at_op(exp)
       make_identifier(:op, exp)
     end
 
+    def process_at_backtick(exp)
+      make_identifier(:backtick, exp)
+    end
+
     def process_at_kw(exp)
       sym, pos = extract_node_symbol_with_position(exp)
       result = case sym
@@ -259,11 +254,7 @@ module RipperRubyParser
 
       return body if body.empty?
 
-      if body.sexp_type == :block
-        body.sexp_body
-      else
-        [body]
-      end
+      unwrap_block body
     end
 
     def make_identifier(type, exp)
@@ -276,9 +267,5 @@ module RipperRubyParser
       _, val, pos = exp.shift 3
       with_position(pos, s(:lit, yield(val)))
     end
-
-    def replace_kwrest_arg_lvar?(ident)
-      extra_compatible && @block_kwrest.include?(ident)
-    end
   end
 end

data/lib/ripper_ruby_parser/unescape.rb

@@ -106,8 +106,7 @@ module RipperRubyParser
       when /^u\{/
         hex_to_unicode_char(bare[2..-2])
       when /^u/
-        hex_to_unicode_char(bare[1..4]) +
-          (extra_compatible ? '' : bare[5..-1])
+        hex_to_unicode_char(bare[1..4]) + bare[5..-1]
       when /^(c|C-).$/
         control(bare[-1].ord).chr
       when /^M-.$/

data/lib/ripper_ruby_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RipperRubyParser
-  VERSION = '1.5.1'
+  VERSION = '1.6.0'
 end

data/test/end_to_end/comments_test.rb

@@ -9,7 +9,7 @@ describe 'Using RipperRubyParser and RubyParser' do
   end
 
   let :oldparser do
-    RubyParser.new
+    RubyParser.for_current_ruby
   end
 
   describe 'for a program with quite some comments' do

data/test/end_to_end/lib_comparison_test.rb

@@ -9,7 +9,7 @@ describe 'Using RipperRubyParser and RubyParser' do
   end
 
   let :oldparser do
-    RubyParser.new
+    RubyParser.for_current_ruby
   end
 
   Dir.glob('lib/**/*.rb').each do |file|

data/test/end_to_end/line_numbering_test.rb

@@ -25,7 +25,7 @@ describe 'Using RipperRubyParser and RubyParser' do
   end
 
   let :oldparser do
-    RubyParser.new
+    RubyParser.for_current_ruby
   end
 
   describe 'for a multi-line program' do

data/test/end_to_end/test_comparison_test.rb

@@ -9,7 +9,7 @@ describe 'Using RipperRubyParser and RubyParser' do
   end
 
   let :oldparser do
-    RubyParser.new
+    RubyParser.for_current_ruby
   end
 
   Dir.glob('test/ripper_ruby_parser/**/*.rb').each do |file|

data/test/ripper_ruby_parser/parser_test.rb

@@ -148,12 +148,12 @@ describe RipperRubyParser::Parser do
     describe 'for the BEGIN keyword' do
       it 'converts to a :preexe iterator' do
         'BEGIN { foo }'.
-          must_be_parsed_as s(:iter, s(:preexe), s(:args), s(:call, nil, :foo))
+          must_be_parsed_as s(:iter, s(:preexe), 0, s(:call, nil, :foo))
       end
 
       it 'works with an empty block' do
         'BEGIN { }'.
-          must_be_parsed_as s(:iter, s(:preexe), s(:args))
+          must_be_parsed_as s(:iter, s(:preexe), 0)
       end
     end
 
@@ -376,6 +376,16 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
+      it 'works for a range literal' do
+        result = parser.parse '0..4'
+        result.line.must_equal 1
+      end
+
+      it 'works for an exclusive range literal' do
+        result = parser.parse '0...4'
+        result.line.must_equal 1
+      end
+
       it 'works for a regular expression back reference' do
         result = parser.parse '$1'
         result.line.must_equal 1

data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb

@@ -210,6 +210,35 @@ describe RipperRubyParser::Parser do
           'foo = Bar.baz qux rescue quuz'.
             must_be_parsed_as expected
         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
@@ -244,6 +273,13 @@ describe RipperRubyParser::Parser do
                               s(:to_ary, s(:call, nil, :baz)))
       end
 
+      it 'works with blocks' do
+        'foo, bar = begin; baz; end'.
+          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 a rescue modifier' do
         'foo, bar = baz rescue qux'.
           must_be_parsed_as s(:rescue,
@@ -314,6 +350,17 @@ describe RipperRubyParser::Parser do
                                     s(:call, nil, :quuz)))))
       end
 
+      it 'works with destructuring with multiple levels' do
+        '((foo, bar)) = baz'.
+          must_be_parsed_as s(:masgn,
+                              s(:array,
+                                s(:masgn,
+                                  s(:array,
+                                    s(:lasgn, :foo),
+                                    s(:lasgn, :bar)))),
+                              s(:to_ary, s(:call, nil, :baz)))
+      end
+
       it 'works with instance variables' do
         '@foo, @bar = baz'.
           must_be_parsed_as s(:masgn,
@@ -455,7 +502,45 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :bar)))
       end
 
-      it 'works when assigning to a collection element' 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
+
+      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
+
+      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
+
+    describe 'for operator assignment to an attribute' do
+      it 'works with +=' do
+        'foo.bar += baz'.
+          must_be_parsed_as s(:op_asgn2,
+                              s(:call, nil, :foo),
+                              :bar=, :+,
+                              s(:call, nil, :baz))
+      end
+
+      it 'works with ||=' do
+        'foo.bar ||= baz'.
+          must_be_parsed_as s(:op_asgn2,
+                              s(:call, nil, :foo),
+                              :bar=, :'||',
+                              s(:call, nil, :baz))
+      end
+    end
+
+    describe 'for operator assignment to a collection element' do
+      it 'works with +=' do
         'foo[bar] += baz'.
           must_be_parsed_as s(:op_asgn1,
                               s(:call, nil, :foo),
@@ -464,7 +549,7 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
-      it 'works with ||= when assigning to a collection element' do
+      it 'works with ||=' do
         'foo[bar] ||= baz'.
           must_be_parsed_as s(:op_asgn1,
                               s(:call, nil, :foo),
@@ -473,100 +558,90 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
-      it 'works when assigning to an attribute' do
-        'foo.bar += baz'.
-          must_be_parsed_as s(:op_asgn2,
+      it 'handles multiple indices' do
+        'foo[bar, baz] += qux'.
+          must_be_parsed_as s(:op_asgn1,
                               s(:call, nil, :foo),
-                              :bar=, :+,
-                              s(:call, nil, :baz))
+                              s(:arglist,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)),
+                              :+,
+                              s(:call, nil, :qux))
       end
 
-      it 'works with ||= when assigning to an attribute' do
-        'foo.bar ||= baz'.
-          must_be_parsed_as s(:op_asgn2,
+      it 'works with a function call without parentheses' do
+        'foo[bar] += baz qux'.
+          must_be_parsed_as s(:op_asgn1,
                               s(:call, nil, :foo),
-                              :bar=, :'||',
-                              s(:call, nil, :baz))
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, nil, :baz, s(:call, nil, :qux)))
       end
 
-      describe 'assigning to a collection element' do
-        it 'handles multiple indices' do
-          'foo[bar, baz] += qux'.
-            must_be_parsed_as s(:op_asgn1,
-                                s(:call, nil, :foo),
-                                s(:arglist,
-                                  s(:call, nil, :bar),
-                                  s(:call, nil, :baz)),
-                                :+,
-                                s(:call, nil, :qux))
-        end
-
-        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
-
-        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
-
-        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
+      it 'works with a function call with parentheses' do
+        'foo[bar] += baz(qux)'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, nil, :baz, s(:call, nil, :qux)))
       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
+      it 'works with a method call without parentheses' do
+        'foo[bar] += baz.qux quuz'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz)))
       end
 
-      it 'works with a literal' do
-        'foo = 0'.
-          must_be_parsed_as s(:lasgn, :foo, s(:lit, 0)),
-                            extra_compatible: true
+      it 'works with a method call with parentheses' do
+        'foo[bar] += baz.qux(quuz)'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz)))
       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)))),
+      it 'works with a function call without parentheses in extra compatible mode' do
+        'foo[bar] += baz qux'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:array, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, nil, :baz, s(:call, nil, :qux))),
                             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)))),
+      it 'works with a function call with parentheses in extra compatible mode' do
+        'foo[bar] += baz(qux)'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, nil, :baz, 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))),
+      it 'works with a method call without parentheses in extra compatible mode' do
+        'foo[bar] += baz.qux quuz'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:array, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz))),
                             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))),
+      it 'works with a method call with parentheses in extra compatible mode' do
+        'foo[bar] += baz.qux(quuz)'.
+          must_be_parsed_as s(:op_asgn1,
+                              s(:call, nil, :foo),
+                              s(:arglist, s(:call, nil, :bar)),
+                              :+,
+                              s(:call, s(:call, nil, :baz), :qux, s(:call, nil, :quuz))),
                             extra_compatible: true
       end
     end