ripper_ruby_parser 1.4.2 → 1.5.0

data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb

@@ -1,17 +1,9 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe '#parse' do
-    describe 'for negated operators' do
-      specify do
-        'foo !~ bar'.must_be_parsed_as s(:not,
-                                         s(:call,
-                                           s(:call, nil, :foo),
-                                           :=~,
-                                           s(:call, nil, :bar)))
-      end
-    end
-
     describe 'for boolean operators' do
       it 'handles :and' do
         'foo and bar'.
@@ -134,6 +126,60 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :baz),
                                   s(:call, nil, :qux))))
       end
+
+      it 'handles :!=' do
+        'foo != bar'.
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :!=,
+                              s(:call, nil, :bar))
+      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))
+      end
+
+      it 'keeps :begin for the second argument of a binary operator' do
+        'foo + begin; bar; end'.
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :+,
+                              s(:begin, s(:call, nil, :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))
+      end
+
+      it 'keeps :begin for the second argument of a boolean operator' do
+        'foo and begin; bar; end'.
+          must_be_parsed_as s(:and,
+                              s(:call, nil, :foo),
+                              s(:begin, s(:call, nil, :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))
+      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,
+                              s(:call, nil, :foo),
+                              :>>,
+                              s(:call, nil, :bar))
+      end
     end
 
     describe 'for the range operator' do
@@ -161,6 +207,20 @@ describe RipperRubyParser::Parser do
                               s(:str, 'z'))
       end
 
+      it 'handles non-literal begin' do
+        'foo..3'.
+          must_be_parsed_as s(:dot2,
+                              s(:call, nil, :foo),
+                              s(:lit, 3))
+      end
+
+      it 'handles non-literal end' do
+        '3..foo'.
+          must_be_parsed_as s(:dot2,
+                              s(:lit, 3),
+                              s(:call, nil, :foo))
+      end
+
       it 'handles non-literals' do
         'foo..bar'.
           must_be_parsed_as s(:dot2,
@@ -194,7 +254,21 @@ describe RipperRubyParser::Parser do
                               s(:str, 'z'))
       end
 
-      it 'handles non-literals' do
+      it 'handles non-literal begin' do
+        'foo...3'.
+          must_be_parsed_as s(:dot3,
+                              s(:call, nil, :foo),
+                              s(:lit, 3))
+      end
+
+      it 'handles non-literal end' do
+        '3...foo'.
+          must_be_parsed_as s(:dot3,
+                              s(:lit, 3),
+                              s(:call, nil, :foo))
+      end
+
+      it 'handles two non-literals' do
         'foo...bar'.
           must_be_parsed_as s(:dot3,
                               s(:call, nil, :foo),
@@ -202,7 +276,7 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for unary numerical operators' do
+    describe 'for unary operators' do
       it 'handles unary minus with an integer literal' do
         '- 1'.must_be_parsed_as s(:call, s(:lit, 1), :-@)
       end
@@ -232,6 +306,94 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :foo),
                               :+@)
       end
+
+      it 'handles unary !' do
+        '!foo'.
+          must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
+      end
+
+      it 'converts :not to :!' do
+        'not foo'.
+          must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
+      end
+
+      it 'handles unary ! with a number literal' do
+        '!1'.
+          must_be_parsed_as s(:call, s(:lit, 1), :!)
+      end
+
+      it 'keeps :begin for the argument' do
+        '- begin; foo; end'.
+          must_be_parsed_as s(:call,
+                              s(:begin, s(:call, nil, :foo)),
+                              :-@)
+      end
+    end
+
+    describe 'for the ternary operater' do
+      it 'works in the simple case' do
+        'foo ? bar : baz'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz))
+      end
+
+      it 'keeps :begin for the first argument' 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))
+      end
+
+      it 'keeps :begin for the second argument' 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))
+      end
+
+      it 'keeps :begin for the third argument' do
+        'foo ? bar : begin; baz; end'.
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:begin, s(:call, nil, :baz)))
+      end
+    end
+
+    describe 'for match operators' do
+      it 'handles :=~ with two non-literals' do
+        'foo =~ bar'.
+          must_be_parsed_as s(:call,
+                              s(:call, nil, :foo),
+                              :=~,
+                              s(:call, nil, :bar))
+      end
+
+      it 'handles :=~ with literal regexp on the left hand side' do
+        '/foo/ =~ bar'.
+          must_be_parsed_as s(:match2,
+                              s(:lit, /foo/),
+                              s(:call, nil, :bar))
+      end
+
+      it 'handles :=~ with literal regexp on the right hand side' do
+        'foo =~ /bar/'.
+          must_be_parsed_as s(:match3,
+                              s(:lit, /bar/),
+                              s(:call, nil, :foo))
+      end
+
+      it 'handles negated match operators' do
+        'foo !~ bar'.must_be_parsed_as s(:not,
+                                         s(:call,
+                                           s(:call, nil, :foo),
+                                           :=~,
+                                           s(:call, nil, :bar)))
+      end
     end
   end
 end

data/test/ripper_ruby_parser/sexp_processor_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 class TestProcessor < RipperRubyParser::SexpProcessor
@@ -39,26 +41,14 @@ describe RipperRubyParser::SexpProcessor do
 
     describe 'for a :string_literal sexp' do
       it 'transforms a simple sexp to :str' do
-        sexp = s(:string_literal, s(:string_content, s(:@tstring_content, 'foo')))
+        sexp = s(:string_literal,
+                 s(:string_content,
+                   s(:@tstring_content, 'foo', s(1, 1), '"')))
         result = processor.process sexp
         result.must_equal s(:str, 'foo')
       end
     end
 
-    describe 'for an :args_add_block sexp' do
-      it 'transforms a one-argument sexp to an :arglist' do
-        sexp = s(:args_add_block, s(:args, s(:foo)), false)
-        result = processor.process sexp
-        result.must_equal s(:arglist, s(:foo_p))
-      end
-
-      it 'transforms a multi-argument sexp to an :arglist' do
-        sexp = s(:args_add_block, s(:args, s(:foo), s(:bar)), false)
-        result = processor.process sexp
-        result.must_equal s(:arglist, s(:foo_p), s(:bar_p))
-      end
-    end
-
     describe 'for a :command sexp' do
       it 'transforms a sexp to a :call' do
         sexp = s(:command, s(:@ident, 'foo', s(1, 0)), s(:arglist, s(:foo)))
@@ -298,14 +288,14 @@ describe RipperRubyParser::SexpProcessor do
   end
 
   describe '#extract_node_symbol' do
-    it 'processes an identifier sexp to a bare symbol' do
-      sexp = s(:@ident, 'foo', s(1, 0))
+    it 'processes an lvar sexp to a bare symbol' do
+      sexp = s(:lvar, 'foo')
       result = processor.send :extract_node_symbol, sexp
       result.must_equal :foo
     end
 
     it 'processes a const sexp to a bare symbol' do
-      sexp = s(:@const, 'Foo', s(1, 0))
+      sexp = s(:const, 'Foo')
       result = processor.send :extract_node_symbol, sexp
       result.must_equal :Foo
     end

data/test/ripper_ruby_parser/version_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 describe RipperRubyParser do
   it 'knows its own version' do
     RipperRubyParser::VERSION.wont_be_nil

data/test/samples/comments.rb

@@ -0,0 +1,13 @@
+=begin
+This is an unusual type of comment that needs to be handled correctly
+=end
+
+class Foo
+
+end
+
+# This is a more common type of comment
+
+class Bar
+
+end

data/test/samples/conditionals.rb

@@ -0,0 +1,23 @@
+# Conditionals
+
+if begin foo end
+  bar
+end
+
+if begin foo..bar end
+  baz
+end
+
+if foo
+elsif begin bar end
+end
+
+if foo
+elsif begin bar..baz end
+end
+
+if 1
+  bar
+else
+  baz
+end

data/test/samples/loops.rb

@@ -0,0 +1,36 @@
+# Loop samples
+
+def for_samples
+  for foo in bar
+  end
+
+  for foo, bar in baz
+  end
+
+  for foo, in bar
+  end
+end
+
+# begin..end in conditions
+#
+def while_until_samples
+  while begin foo end
+    bar
+  end
+
+  until begin foo end
+    bar
+  end
+
+  while begin foo end do
+    bar
+  end
+
+  until begin foo end do
+    bar
+  end
+
+  foo while begin bar end
+
+  foo until begin bar end
+end

data/test/samples/misc.rb

@@ -1,5 +1,21 @@
 # Miscellaneous samples
 
+BEGIN {
+  begin
+    foo
+  end
+}
+
+BEGIN {}
+
+END {
+  begin
+    bar
+  end
+}
+
+END {}
+
 # regular expressions with different encoding flags
 regular = /foo/
 noenc = /foo/n
@@ -18,19 +34,19 @@ sjis = /foo#{bar}/s
 enc = __ENCODING__
 
 class Foo
-# calling #[] on self
-# https://github.com/seattlerb/ruby_parser/issues/250
+  # calling #[] on self
+  # https://github.com/seattlerb/ruby_parser/issues/250
   def bar
     self[:foo]
   end
 
-# required keyword arguments and no parentheses
-# https://github.com/seattlerb/ruby_parser/pull/254
+  # required keyword arguments and no parentheses
+  # https://github.com/seattlerb/ruby_parser/pull/254
   def foo a:, b:
     puts "A: #{a}, B: #{b}"
   end
 
-# Combinations of begin..end and diverse operators
+  # Combinations of begin..end and diverse operators
   def qux
     begin end
     begin; foo; end
@@ -45,5 +61,141 @@ class Foo
     foo and begin; bar; end
     begin; foo; end if bar
     begin; foo; end unless bar
+    begin; foo; end.bar
+    foo ||= begin; bar; end
+    foo += begin; bar; end
+    foo[qux] ||= begin; bar; end
+    foo = begin; bar; end
+    foo = begin; if bar; baz; end; end
+    baz = begin; foo; ensure; bar; end
+    foo = *begin; bar; end
+    foo = bar, *begin; baz; end
+    foo, bar = *begin; baz; end
+    foo if begin bar end
+  end
+
+  # Nested do and begin blocks
+  def quuz
+    foo do
+      bar
+
+      begin
+        baz
+      rescue
+        qux
+      end
+
+      quuz
+    end
+  end
+
+  # Nested begin/rescue blocks
+  def quuz
+    begin
+      bar
+    rescue
+      begin
+        baz
+      end
+    end
+
+    begin
+      bar
+    rescue
+      begin
+        baz
+      rescue
+        qux
+      end
+    end
+
+    begin
+      bar
+    rescue
+      begin
+        baz
+      end
+      begin
+        qux
+      end
+    end
+  end
+
+  # Begin/end blocks and case statements
+  def quuz
+    case foo
+    when bar
+      begin
+        baz
+      end
+    end
+  end
+
+  # Using splat and double-splat args
+  def barbaz(*foo, **bar)
+    puts [foo, bar]
+    foo.each do |baz, **qux|
+      puts [foo, bar, baz, qux]
+    end
+    puts [foo, bar]
+  end
+
+  def barbaz_block(*foo, **bar, &block)
+    puts [foo, bar]
+  end
+
+  def self.barbaz(*foo, **bar)
+    puts [foo, bar]
+    foo.each do |baz, **qux|
+      puts [foo, bar, baz, qux]
+    end
+    puts [foo, bar]
+  end
+
+  # rescue
+  def barfoo
+    foo
+  rescue *bar
+    baz
+  rescue *quuz, Bar
+    zyxxy
+  rescue *qux => err
+    puts err
+  end
+
+  # alias
+  alias foo bar
+  alias :foo bar
+  alias :foo :bar
+  alias foo :bar
+  alias :+ -
+  alias next bar
+
+  # rescue with assignment
+  foo = bar rescue baz
+  foo = bar baz rescue qux
+  foo = bar(baz) rescue qux
+  foo, bar = baz qux rescue quuz
+  @foo = bar baz rescue qux
+  @@foo = bar baz rescue qux
+  FOO = bar baz rescue qux
+  $foo = bar baz rescue qux
+  foo = Foo.bar(baz) rescue qux
+  foo = Foo.bar baz rescue qux
+
+  # Assignment to class variables inside method argument
+  # definitions.
+  def foo(bar = (@@baz = qux))
+  end
+
+  def self.foo(bar = (@@baz = qux))
+  end
+
+  def (bar = (@@baz = qux)).foo
+  end
+
+  # Assignment to global variables inside method argument
+  # definitions.
+  def foo(bar = ($baz = qux))
   end
 end