ripper_ruby_parser 1.1.2 → 1.2.0

data/test/{unit/parser_literals_test.rb → ripper_ruby_parser/sexp_handlers/literals_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe '#parse' do
@@ -8,7 +8,7 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:lit, /foo/)
       end
 
-      it 'works for regex literals with escaped right bracket' do
+      it 'works for regex literals with escaped right parenthesis' do
         '/\\)/'.
           must_be_parsed_as s(:lit, /\)/)
       end
@@ -155,12 +155,12 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:str, '\\n')
         end
 
-        it 'works for a representation of a regex literal with escaped right bracket' do
+        it 'works for a representation of a regex literal with escaped right parenthesis' do
           '"/\\\\)/"'.
             must_be_parsed_as s(:str, '/\\)/')
         end
 
-        it 'works for a uselessly escaped right bracket' do
+        it 'works for a uselessly escaped right parenthesis' do
           '"/\\)/"'.
             must_be_parsed_as s(:str, '/)/')
         end
@@ -210,7 +210,6 @@ describe RipperRubyParser::Parser do
 
         # TODO: Implement remaining escape sequence cases.
 
-        # TODO: Behave differently in extra_compatible mode.
         it 'works with unicode escapes (unlike RubyParser)' do
           '"foo\\u273bbar"'.must_be_parsed_as s(:str, 'foo✻bar')
         end
@@ -355,12 +354,12 @@ describe RipperRubyParser::Parser do
     end
 
     describe 'for word list literals' do
-      it 'works for the simle case with %w' do
-        '%W(foo bar)'.
+      it 'works for the simple case with %w' do
+        '%w(foo bar)'.
           must_be_parsed_as s(:array, s(:str, 'foo'), s(:str, 'bar'))
       end
 
-      it 'works for the simle case with %W' do
+      it 'works for the simple case with %W' do
         '%W(foo bar)'.
           must_be_parsed_as s(:array, s(:str, 'foo'), s(:str, 'bar'))
       end
@@ -407,7 +406,7 @@ describe RipperRubyParser::Parser do
         "%I(foo \#{bar} baz)".
           must_be_parsed_as s(:array,
                               s(:lit, :foo),
-                              s(:dsym, "", s(:evstr, s(:call, nil, :bar))),
+                              s(:dsym, '', s(:evstr, s(:call, nil, :bar))),
                               s(:lit, :baz))
       end
 
@@ -416,9 +415,9 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:array,
                               s(:lit, :foo),
                               s(:dsym,
-                                "",
+                                '',
                                 s(:evstr, s(:call, nil, :bar)),
-                                s(:str, "baz")))
+                                s(:str, 'baz')))
       end
     end
 
@@ -559,7 +558,6 @@ describe RipperRubyParser::Parser do
       end
 
       it 'works for a hash with dynamic label keys' do
-        skip 'This is not valid syntax below Ruby 2.2' if RUBY_VERSION < '2.2.0'
         "{'foo': bar}".
           must_be_parsed_as s(:hash,
                               s(:lit, :foo),

data/test/{unit/parser_loops_test.rb → ripper_ruby_parser/sexp_handlers/loops_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe '#parse' do

data/test/{unit/parser_method_calls_test.rb → ripper_ruby_parser/sexp_handlers/method_calls_test.rb}

@@ -1,27 +1,27 @@
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe '#parse' do
     describe 'for method calls' do
       describe 'without a receiver' do
-        it 'works without brackets' do
+        it 'works without parentheses' do
           'foo bar'.
             must_be_parsed_as s(:call, nil, :foo,
                                 s(:call, nil, :bar))
         end
 
-        it 'works with brackets' do
+        it 'works with parentheses' do
           'foo(bar)'.
             must_be_parsed_as s(:call, nil, :foo,
                                 s(:call, nil, :bar))
         end
 
-        it 'works with an empty parameter list and no brackets' do
+        it 'works with an empty parameter list and no parentheses' do
           'foo'.
             must_be_parsed_as s(:call, nil, :foo)
         end
 
-        it 'works with brackets around an empty parameter list' do
+        it 'works with parentheses around an empty parameter list' do
           'foo()'.
             must_be_parsed_as s(:call, nil, :foo)
         end
@@ -31,7 +31,7 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:call, nil, :foo?)
         end
 
-        it 'works with nested calls without brackets' do
+        it 'works with nested calls without parentheses' do
           'foo bar baz'.
             must_be_parsed_as s(:call, nil, :foo,
                                 s(:call, nil, :bar,
@@ -102,7 +102,7 @@ describe RipperRubyParser::Parser do
       end
 
       describe 'with a receiver' do
-        it 'works without brackets' do
+        it 'works without parentheses' do
           'foo.bar baz'.
             must_be_parsed_as s(:call,
                                 s(:call, nil, :foo),
@@ -110,7 +110,7 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :baz))
         end
 
-        it 'works with brackets' do
+        it 'works with parentheses' do
           'foo.bar(baz)'.
             must_be_parsed_as s(:call,
                                 s(:call, nil, :foo),
@@ -118,7 +118,7 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :baz))
         end
 
-        it 'works with brackets around a call with no brackets' do
+        it 'works with parentheses around a call with no parentheses' do
           'foo.bar(baz qux)'.
             must_be_parsed_as s(:call,
                                 s(:call, nil, :foo),
@@ -127,7 +127,7 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :qux)))
         end
 
-        it 'works with nested calls without brackets' do
+        it 'works with nested calls without parentheses' do
           'foo.bar baz qux'.
             must_be_parsed_as s(:call,
                                 s(:call, nil, :foo),

data/test/{unit/parser_operators_test.rb → ripper_ruby_parser/sexp_handlers/operators_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require File.expand_path('../../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe '#parse' do
@@ -88,7 +88,7 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :baz)))
       end
 
-      it 'handles bracketed :||' do
+      it 'handles :|| with parentheses' do
         '(foo || bar) || baz'.
           must_be_parsed_as s(:or,
                               s(:or,
@@ -97,6 +97,15 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
+      it 'handles nested :|| with parentheses' do
+        'foo || (bar || baz) || qux'.
+          must_be_parsed_as  s(:or,
+                               s(:call, nil, :foo),
+                               s(:or,
+                                 s(:or, s(:call, nil, :bar), s(:call, nil, :baz)),
+                                 s(:call, nil, :qux)))
+      end
+
       it 'converts :|| to :or' do
         'foo || bar'.
           must_be_parsed_as s(:or,
@@ -114,6 +123,17 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :baz),
                                   s(:call, nil, :qux))))
       end
+
+      it 'handles triple :&&' do
+        'foo && bar && baz && qux'.
+          must_be_parsed_as s(:and,
+                              s(:call, nil, :foo),
+                              s(:and,
+                                s(:call, nil, :bar),
+                                s(:and,
+                                  s(:call, nil, :baz),
+                                  s(:call, nil, :qux))))
+      end
     end
 
     describe 'for unary numerical operators' do

data/test/{unit → ripper_ruby_parser}/sexp_processor_test.rb

@@ -1,17 +1,17 @@
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 class TestProcessor < RipperRubyParser::SexpProcessor
-  def process_foo exp
+  def process_foo(exp)
     exp.shift
     s(:foo_p)
   end
 
-  def process_bar exp
+  def process_bar(exp)
     exp.shift
     s(:bar_p)
   end
 
-  def process_baz exp
+  def process_baz(exp)
     exp.shift
     s(:baz_p)
   end
@@ -25,13 +25,13 @@ describe RipperRubyParser::SexpProcessor do
   describe '#process' do
     describe 'for a :program sexp' do
       it 'strips off the outer :program node' do
-        sexp = s(:program, s(s(:foo)))
+        sexp = s(:program, s(:stmts, s(:foo)))
         result = processor.process sexp
         result.must_equal s(:foo_p)
       end
 
       it 'transforms a multi-statement :program into a :block sexp' do
-        sexp = s(:program, s(s(:foo), s(:bar)))
+        sexp = s(:program, s(:stmts, s(:foo), s(:bar)))
         result = processor.process sexp
         result.must_equal s(:block, s(:foo_p), s(:bar_p))
       end
@@ -47,13 +47,13 @@ describe RipperRubyParser::SexpProcessor do
 
     describe 'for an :args_add_block sexp' do
       it 'transforms a one-argument sexp to an :arglist' do
-        sexp = s(:args_add_block, s(s(:foo)), false)
+        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(s(:foo), s(:bar)), false)
+        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
@@ -87,7 +87,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'does not create body eleents for an empty definition' do
         sexp = s(:module,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))),
-                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:module, :Foo)
       end
@@ -95,7 +95,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'creates a single body element for a definition with one statement' do
         sexp = s(:module,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))),
-                 s(:bodystmt, s(s(:foo)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:foo)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:module, :Foo, s(:foo_p))
       end
@@ -103,7 +103,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'creates multiple body elements for a definition with more than one statement' do
         sexp = s(:module,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))),
-                 s(:bodystmt, s(s(:foo), s(:bar)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:foo), s(:bar)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:module, :Foo, s(:foo_p), s(:bar_p))
       end
@@ -113,7 +113,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'does not create body eleents for an empty definition' do
         sexp = s(:class,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))), nil,
-                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:class, :Foo, nil)
       end
@@ -121,7 +121,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'creates a single body element for a definition with one statement' do
         sexp = s(:class,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))), nil,
-                 s(:bodystmt, s(s(:foo)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:foo)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:class, :Foo, nil, s(:foo_p))
       end
@@ -129,7 +129,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'creates multiple body elements for a definition with more than one statement' do
         sexp = s(:class,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))), nil,
-                 s(:bodystmt, s(s(:foo), s(:bar)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:foo), s(:bar)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:class, :Foo, nil, s(:foo_p), s(:bar_p))
       end
@@ -138,23 +138,23 @@ describe RipperRubyParser::SexpProcessor do
         sexp = s(:class,
                  s(:const_ref, s(:@const, 'Foo', s(1, 13))),
                  s(:var_ref, s(:@const, 'Bar', s(1, 12))),
-                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:class, :Foo, s(:const, :Bar))
       end
     end
 
     describe 'for a :bodystmt sexp' do
-      it 'creates a :scope sexp with nested :block' do
-        sexp = s(:bodystmt, s(s(:foo), s(:bar)), nil, nil, nil)
+      it 'creates a :block sexp when multiple statements are present' do
+        sexp = s(:bodystmt, s(:stmts, s(:foo), s(:bar)), nil, nil, nil)
         result = processor.process sexp
-        result.must_equal s(s(:block, s(:foo_p), s(:bar_p)))
+        result.must_equal s(:block, s(:foo_p), s(:bar_p))
       end
 
       it 'removes nested :void_stmt sexps' do
-        sexp = s(:bodystmt, s(s(:void_stmt), s(:foo)), nil, nil, nil)
+        sexp = s(:bodystmt, s(:stmts, s(:void_stmt), s(:foo)), nil, nil, nil)
         result = processor.process sexp
-        result.must_equal s(s(:foo_p))
+        result.must_equal s(:foo_p)
       end
     end
 
@@ -163,7 +163,7 @@ describe RipperRubyParser::SexpProcessor do
         sexp = s(:def,
                  s(:@ident, 'foo', s(1, 4)),
                  s(:params, nil, nil, nil, nil, nil),
-                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+                 s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil))
         result = processor.process sexp
         result.must_equal s(:defn, :foo, s(:args), s(:nil))
       end
@@ -177,6 +177,27 @@ describe RipperRubyParser::SexpProcessor do
           result.must_equal s(:args, s(:lvar, :bar))
         end
       end
+
+      describe 'with a ruby 2.4-style doublesplat argument' do
+        it 'creates :lvar sexps' do
+          sexp =  s(:params,
+                    nil, nil, nil, nil, nil,
+                    s(:@ident, 'bar', s(1, 8)),
+                    nil)
+          result = processor.process sexp
+          result.must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
+        end
+      end
+      describe 'with a ruby 2.5-style kwrest argument' do
+        it 'creates :lvar sexps' do
+          sexp =  s(:params,
+                    nil, nil, nil, nil, nil,
+                    s(:kwrest_param, s(:@ident, 'bar', s(1, 8))),
+                    nil)
+          result = processor.process sexp
+          result.must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
+        end
+      end
     end
 
     describe 'for an :assign sexp' do
@@ -201,7 +222,7 @@ describe RipperRubyParser::SexpProcessor do
       it 'creates an :iter sexp' do
         sexp = s(:method_add_block,
                  s(:call, s(:foo), :".", s(:@ident, 'baz', s(1, 2))),
-                 s(:brace_block, nil, s(s(:bar))))
+                 s(:brace_block, nil, s(:stmts, s(:bar))))
         result = processor.process sexp
         result.must_equal s(:iter,
                             s(:call, s(:foo_p), :baz), 0,
@@ -216,7 +237,7 @@ describe RipperRubyParser::SexpProcessor do
                      s(:block_var,
                        s(:params, s(s(:@ident, 'i', s(1, 6))), nil, nil, nil, nil),
                        nil),
-                     s(s(:bar))))
+                     s(:stmts, s(:bar))))
           result = processor.process sexp
           result.must_equal s(:iter,
                               s(:call, s(:foo_p), :baz),
@@ -229,7 +250,7 @@ describe RipperRubyParser::SexpProcessor do
     describe 'for an :if sexp' do
       describe 'with a single statement in the if body' do
         it 'uses the statement sexp as the body' do
-          sexp = s(:if, s(:foo), s(s(:bar)), nil)
+          sexp = s(:if, s(:foo), s(:stmts, s(:bar)), nil)
           result = processor.process sexp
           result.must_equal s(:if, s(:foo_p), s(:bar_p), nil)
         end
@@ -237,7 +258,7 @@ describe RipperRubyParser::SexpProcessor do
 
       describe 'with multiple statements in the if body' do
         it 'uses a block containing the statement sexps as the body' do
-          sexp = s(:if, s(:foo), s(s(:bar), s(:baz)), nil)
+          sexp = s(:if, s(:foo), s(:stmts, s(:bar), s(:baz)), nil)
           result = processor.process sexp
           result.must_equal s(:if, s(:foo_p), s(:block, s(:bar_p), s(:baz_p)), nil)
         end
@@ -246,7 +267,7 @@ describe RipperRubyParser::SexpProcessor do
 
     describe 'for an :array sexp' do
       it 'pulls up the element sexps' do
-        sexp = s(:array, s(s(:foo), s(:bar), s(:baz)))
+        sexp = s(:array, s(:words, s(:foo), s(:bar), s(:baz)))
         result = processor.process sexp
         result.must_equal s(:array, s(:foo_p), s(:bar_p), s(:baz_p))
       end
@@ -264,9 +285,9 @@ describe RipperRubyParser::SexpProcessor do
 
     describe 'for a :when sexp' do
       it 'turns nested :when clauses into a list' do
-        sexp = s(:when, s(s(:foo)), s(s(:bar)),
-                 s(:when, s(s(:foo)), s(s(:bar)),
-                   s(:when, s(s(:foo)), s(s(:bar)), nil)))
+        sexp = s(:when, s(:args, s(:foo)), s(:stmts, s(:bar)),
+                 s(:when, s(:args, s(:foo)), s(:stmts, s(:bar)),
+                   s(:when, s(:args, s(:foo)), s(:stmts, s(:bar)), nil)))
         result = processor.process sexp
         result.must_equal s(s(:when, s(:array, s(:foo_p)), s(:bar_p)),
                             s(:when, s(:array, s(:foo_p)), s(:bar_p)),
@@ -289,24 +310,4 @@ describe RipperRubyParser::SexpProcessor do
       result.must_equal :Foo
     end
   end
-
-  describe '#trickle_up_line_numbers' do
-    it 'works through several nested levels' do
-      inner = s(:foo)
-      outer = s(:bar, s(:baz, s(:qux, inner)))
-      outer.line = 42
-      processor.send :trickle_down_line_numbers, outer
-      inner.line.must_equal 42
-    end
-  end
-
-  describe '#trickle_down_line_numbers' do
-    it 'works through several nested levels' do
-      inner = s(:foo)
-      inner.line = 42
-      outer = s(:bar, s(:baz, s(:qux, inner)))
-      processor.send :trickle_up_line_numbers, outer
-      outer.line.must_equal 42
-    end
-  end
 end