ripper_ruby_parser 1.6.1 → 1.7.0

data/test/ripper_ruby_parser/sexp_processor_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
 
 class TestProcessor < RipperRubyParser::SexpProcessor
   def process_foo(exp)
@@ -24,280 +24,280 @@ describe RipperRubyParser::SexpProcessor do
     TestProcessor.new
   end
 
-  describe '#process' do
-    describe 'for a :program sexp' do
-      it 'strips off the outer :program node' do
+  describe "#process" do
+    describe "for a :program sexp" do
+      it "strips off the outer :program node" do
         sexp = s(:program, s(:stmts, s(:foo)))
         result = processor.process sexp
-        result.must_equal s(:foo_p)
+        _(result).must_equal s(:foo_p)
       end
 
-      it 'transforms a multi-statement :program into a :block sexp' do
+      it "transforms a multi-statement :program into a :block sexp" do
         sexp = s(:program, s(:stmts, s(:foo), s(:bar)))
         result = processor.process sexp
-        result.must_equal s(:block, s(:foo_p), s(:bar_p))
+        _(result).must_equal s(:block, s(:foo_p), s(:bar_p))
       end
     end
 
-    describe 'for a :string_literal sexp' do
-      it 'transforms a simple sexp to :str' 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', s(1, 1), '"')))
+                   s(:@tstring_content, "foo", s(1, 1), '"')))
         result = processor.process sexp
-        result.must_equal s(:str, 'foo')
+        _(result).must_equal s(:str, "foo")
       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)))
+    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)))
         result = processor.process sexp
-        result.must_equal s(:call, nil, :foo, s(:foo_p))
+        _(result).must_equal s(:call, nil, :foo, s(:foo_p))
       end
     end
 
-    describe 'for a :var_ref sexp' do
-      it 'transforms the sexp to a :lvar sexp' do
-        sexp = s(:var_ref, s(:@ident, 'bar', s(1, 4)))
+    describe "for a :var_ref sexp" do
+      it "transforms the sexp to a :lvar sexp" do
+        sexp = s(:var_ref, s(:@ident, "bar", s(1, 4)))
         result = processor.process sexp
-        result.must_equal s(:lvar, :bar)
+        _(result).must_equal s(:lvar, :bar)
       end
     end
 
-    describe 'for a :vcall sexp' do
-      it 'transforms the sexp to a :call sexp' do
-        sexp = s(:vcall, s(:@ident, 'bar', s(1, 4)))
+    describe "for a :vcall sexp" do
+      it "transforms the sexp to a :call sexp" do
+        sexp = s(:vcall, s(:@ident, "bar", s(1, 4)))
         result = processor.process sexp
-        result.must_equal s(:call, nil, :bar)
+        _(result).must_equal s(:call, nil, :bar)
       end
     end
 
-    describe 'for a :module sexp' do
-      it 'does not create body elements for an empty definition' do
+    describe "for a :module sexp" do
+      it "does not create body elements for an empty definition" do
         sexp = s(:module,
-                 s(:const_ref, s(:@const, 'Foo', s(1, 13))),
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
                  s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 3))), nil, nil, nil))
         result = processor.process sexp
-        result.must_equal s(:module, :Foo)
+        _(result).must_equal s(:module, :Foo)
       end
 
-      it 'creates a single body element for a definition with one statement' 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(:const_ref, s(:@const, "Foo", s(1, 13))),
                  s(:bodystmt, s(:stmts, s(:foo)), nil, nil, nil))
         result = processor.process sexp
-        result.must_equal s(:module, :Foo, s(:foo_p))
+        _(result).must_equal s(:module, :Foo, s(:foo_p))
       end
 
-      it 'creates multiple body elements for a definition with more than one statement' 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(:const_ref, s(:@const, "Foo", s(1, 13))),
                  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))
+        _(result).must_equal s(:module, :Foo, s(:foo_p), s(:bar_p))
       end
     end
 
-    describe 'for a :class sexp' do
-      it 'does not create body eleents for an empty definition' do
+    describe "for a :class sexp" 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(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
                  s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 8))), nil, nil, nil))
         result = processor.process sexp
-        result.must_equal s(:class, :Foo, nil)
+        _(result).must_equal s(:class, :Foo, nil)
       end
 
-      it 'creates a single body element for a definition with one statement' 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(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
                  s(:bodystmt, s(:stmts, s(:foo)), nil, nil, nil))
         result = processor.process sexp
-        result.must_equal s(:class, :Foo, nil, s(:foo_p))
+        _(result).must_equal s(:class, :Foo, nil, s(:foo_p))
       end
 
-      it 'creates multiple body elements for a definition with more than one statement' 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(:const_ref, s(:@const, "Foo", s(1, 13))), 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))
+        _(result).must_equal s(:class, :Foo, nil, s(:foo_p), s(:bar_p))
       end
 
-      it 'passes on the given ancestor' do
+      it "passes on the given ancestor" do
         sexp = s(:class,
-                 s(:const_ref, s(:@const, 'Foo', s(1, 13))),
-                 s(:var_ref, s(:@const, 'Bar', s(1, 12))),
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
+                 s(:var_ref, s(:@const, "Bar", s(1, 12))),
                  s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 7))), nil, nil, nil))
         result = processor.process sexp
-        result.must_equal s(:class, :Foo, s(:const, :Bar))
+        _(result).must_equal s(:class, :Foo, s(:const, :Bar))
       end
     end
 
-    describe 'for a :bodystmt sexp' do
-      it 'creates a :block sexp when multiple statements are present' do
+    describe "for a :bodystmt sexp" do
+      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(: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
+      it "removes nested :void_stmt sexps" do
         sexp = s(:bodystmt, s(:stmts, s(:void_stmt), s(:foo)), nil, nil, nil)
         result = processor.process sexp
-        result.must_equal s(:foo_p)
+        _(result).must_equal s(:foo_p)
       end
     end
 
-    describe 'for a :def sexp' do
-      it 'transforms the sexp for a basic function definition' do
+    describe "for a :def sexp" do
+      it "transforms the sexp for a basic function definition" do
         sexp = s(:def,
-                 s(:@ident, 'foo', s(1, 4)),
+                 s(:@ident, "foo", s(1, 4)),
                  s(:params, nil, nil, nil, nil, nil),
                  s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 3))), nil, nil, nil))
         result = processor.process sexp
-        result.must_equal s(:defn, :foo, s(:args), s(:nil))
+        _(result).must_equal s(:defn, :foo, s(:args), s(:nil))
       end
     end
 
-    describe 'for a :params sexp' do
-      describe 'with a normal arguments' do
-        it 'creates :lvar sexps' do
-          sexp =  s(:params, s(s(:@ident, 'bar', s(1, 8))), nil, nil, nil, nil)
+    describe "for a :params sexp" do
+      describe "with a normal arguments" do
+        it "creates :lvar sexps" do
+          sexp =  s(:params, s(s(:@ident, "bar", s(1, 8))), nil, nil, nil, nil)
           result = processor.process sexp
-          result.must_equal s(:args, s(:lvar, :bar))
+          _(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
+      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)),
+                    s(:@ident, "bar", s(1, 8)),
                     nil)
           result = processor.process sexp
-          result.must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
+          _(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
+      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))),
+                    s(:kwrest_param, s(:@ident, "bar", s(1, 8))),
                     nil)
           result = processor.process sexp
-          result.must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
+          _(result).must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
         end
       end
     end
 
-    describe 'for an :assign sexp' do
-      it 'creates a :lasgn sexp' do
+    describe "for an :assign sexp" do
+      it "creates a :lasgn sexp" do
         sexp = s(:assign,
-                 s(:var_field, s(:@ident, 'a', s(1, 0))),
-                 s(:@int, '1', s(1, 4)))
+                 s(:var_field, s(:@ident, "a", s(1, 0))),
+                 s(:@int, "1", s(1, 4)))
         result = processor.process sexp
-        result.must_equal s(:lasgn, :a, s(:lit, 1))
+        _(result).must_equal s(:lasgn, :a, s(:lit, 1))
       end
     end
 
-    describe 'for a :binary sexp' do
-      it 'creates a :call sexp' do
+    describe "for a :binary sexp" do
+      it "creates a :call sexp" do
         sexp = s(:binary, s(:bar), :==, s(:foo))
         result = processor.process sexp
-        result.must_equal s(:call, s(:bar_p), :==, s(:foo_p))
+        _(result).must_equal s(:call, s(:bar_p), :==, s(:foo_p))
       end
     end
 
-    describe 'for a :method_add_block sexp' do
-      it 'creates an :iter sexp' do
+    describe "for a :method_add_block sexp" do
+      it "creates an :iter sexp" do
         sexp = s(:method_add_block,
-                 s(:call, s(:foo), :".", s(:@ident, 'baz', s(1, 2))),
+                 s(:call, s(:foo), :".", s(:@ident, "baz", s(1, 2))),
                  s(:brace_block, nil, s(:stmts, s(:bar))))
         result = processor.process sexp
-        result.must_equal s(:iter,
-                            s(:call, s(:foo_p), :baz), 0,
-                            s(:bar_p))
+        _(result).must_equal s(:iter,
+                               s(:call, s(:foo_p), :baz), 0,
+                               s(:bar_p))
       end
 
-      describe 'with a block parameter' do
-        it 'creates an :iter sexp with an :args sexp for the block parameter' do
+      describe "with a block parameter" do
+        it "creates an :iter sexp with an :args sexp for the block parameter" do
           sexp = s(:method_add_block,
-                   s(:call, s(:foo), :".", s(:@ident, 'baz', s(1, 2))),
+                   s(:call, s(:foo), :".", s(:@ident, "baz", s(1, 2))),
                    s(:brace_block,
                      s(:block_var,
-                       s(:params, s(s(:@ident, 'i', s(1, 6))), nil, nil, nil, nil),
+                       s(:params, s(s(:@ident, "i", s(1, 6))), nil, nil, nil, nil),
                        nil),
                      s(:stmts, s(:bar))))
           result = processor.process sexp
-          result.must_equal s(:iter,
-                              s(:call, s(:foo_p), :baz),
-                              s(:args, :i),
-                              s(:bar_p))
+          _(result).must_equal s(:iter,
+                                 s(:call, s(:foo_p), :baz),
+                                 s(:args, :i),
+                                 s(:bar_p))
         end
       end
     end
 
-    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
+    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(:stmts, s(:bar)), nil)
           result = processor.process sexp
-          result.must_equal s(:if, s(:foo_p), s(:bar_p), nil)
+          _(result).must_equal s(:if, s(:foo_p), s(:bar_p), nil)
         end
       end
 
-      describe 'with multiple statements in the if body' do
-        it 'uses a block containing the statement sexps as the body' 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(: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)
+          _(result).must_equal s(:if, s(:foo_p), s(:block, s(:bar_p), s(:baz_p)), nil)
         end
       end
     end
 
-    describe 'for an :array sexp' do
-      it 'pulls up the element sexps' do
+    describe "for an :array sexp" do
+      it "pulls up the element sexps" do
         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))
+        _(result).must_equal s(:array, s(:foo_p), s(:bar_p), s(:baz_p))
       end
     end
 
-    describe 'for a :const_path_ref sexp' do
-      it 'returns a :colon2 sexp' do
+    describe "for a :const_path_ref sexp" do
+      it "returns a :colon2 sexp" do
         sexp = s(:const_path_ref,
-                 s(:var_ref, s(:@const, 'Foo', s(1, 0))),
-                 s(:@const, 'Bar', s(1, 5)))
+                 s(:var_ref, s(:@const, "Foo", s(1, 0))),
+                 s(:@const, "Bar", s(1, 5)))
         result = processor.process sexp
-        result.must_equal s(:colon2, s(:const, :Foo), :Bar)
+        _(result).must_equal s(:colon2, s(:const, :Foo), :Bar)
       end
     end
 
-    describe 'for a :when sexp' do
-      it 'turns nested :when clauses into a list' do
+    describe "for a :when sexp" do
+      it "turns nested :when clauses into a list" do
         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)),
-                            s(:when, s(:array, s(:foo_p)), s(:bar_p)),
-                            nil)
+        _(result).must_equal s(s(:when, s(:array, s(:foo_p)), s(:bar_p)),
+                               s(:when, s(:array, s(:foo_p)), s(:bar_p)),
+                               s(:when, s(:array, s(:foo_p)), s(:bar_p)),
+                               nil)
       end
     end
   end
 
-  describe '#extract_node_symbol' do
-    it 'processes an lvar sexp to a bare symbol' do
-      sexp = s(:lvar, 'foo')
+  describe "#extract_node_symbol" do
+    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
+      _(result).must_equal :foo
     end
 
-    it 'processes a const sexp to a bare symbol' do
-      sexp = s(:const, 'Foo')
+    it "processes a const sexp to a bare symbol" do
+      sexp = s(:const, "Foo")
       result = processor.send :extract_node_symbol, sexp
-      result.must_equal :Foo
+      _(result).must_equal :Foo
     end
   end
 end

data/test/ripper_ruby_parser/version_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 describe RipperRubyParser do
-  it 'knows its own version' do
-    RipperRubyParser::VERSION.wont_be_nil
+  it "knows its own version" do
+    _(RipperRubyParser::VERSION).wont_be_nil
   end
 end

data/test/samples/lambdas.rb

@@ -0,0 +1,5 @@
+-> { }
+->() { }
+->(foo) { foo + bar }
+lambda { }
+lambda { |foo| foo + bar }

data/test/samples/misc.rb

@@ -276,3 +276,6 @@ end
 
 # Special symbols
 [:`, :|, :*, :&, :%, :'^', :-@, :+@, :'~@']
+
+# Blocks
+foo do |bar, | end

data/test/samples/strings.rb

@@ -49,6 +49,13 @@ FOO
 foo\rbar\tbaz\r
 FOO
 
+# Dedented heredocs
+foo = <<~BAR
+  baz
+  #{qux}
+  quuz
+BAR
+
 # Line continuation
 "foo\
 bar"

data/test/test_helper.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'simplecov'
+require "simplecov"
 SimpleCov.start do
-  add_filter '/test/'
+  add_filter "/test/"
 end
 
-require 'minitest/autorun'
+require "minitest/autorun"
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
-require 'ripper_ruby_parser'
+require "ripper_ruby_parser"
 
 module MiniTest
   class Spec
@@ -40,7 +40,9 @@ module MiniTest
     end
 
     def fix_lines(exp)
-      return s(:lit, :__LINE__).line(exp.line) if exp.sexp_type == :lit && exp.line == exp[1]
+      if exp.sexp_type == :lit && exp.line == exp[1]
+        return s(:lit, :__LINE__).line(exp.line)
+      end
 
       exp.sexp_body = exp.sexp_body.map do |sub_exp|
         if sub_exp.is_a? Sexp