ripper_ruby_parser 1.6.1 → 1.7.0

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'sexp_processor'
-require 'ripper_ruby_parser/sexp_handlers'
-require 'ripper_ruby_parser/unescape'
+require "sexp_processor"
+require "ripper_ruby_parser/sexp_handlers"
+require "ripper_ruby_parser/unescape"
 
 module RipperRubyParser
   # Processes the sexp created by Ripper to what RubyParser would produce.
@@ -241,7 +241,7 @@ module RipperRubyParser
       _, str, pos = exp.shift 3
       name = str[1..-1]
       with_position pos do
-        if name =~ /[0-9]/
+        if /[0-9]/.match?(name)
           s(:nth_ref, name.to_i)
         else
           s(:back_ref, name.to_sym)

data/lib/ripper_ruby_parser/unescape.rb

@@ -23,15 +23,15 @@ module RipperRubyParser
       )/x.freeze
 
     SINGLE_LETTER_ESCAPES = {
-      'a' => "\a",
-      'b' => "\b",
-      'e' => "\e",
-      'f' => "\f",
-      'n' => "\n",
-      'r' => "\r",
-      's' => "\s",
-      't' => "\t",
-      'v' => "\v"
+      "a" => "\a",
+      "b" => "\b",
+      "e" => "\e",
+      "f" => "\f",
+      "n" => "\n",
+      "r" => "\r",
+      "s" => "\s",
+      "t" => "\t",
+      "v" => "\v"
     }.freeze
 
     SINGLE_LETTER_ESCAPES_REGEXP =
@@ -61,7 +61,7 @@ module RipperRubyParser
       string.gsub(ESCAPE_SEQUENCE_REGEXP) do
         bare = Regexp.last_match[1]
         if bare == "\n"
-          ''
+          ""
         else
           unescaped_value(bare)
         end
@@ -88,7 +88,7 @@ module RipperRubyParser
         bare = Regexp.last_match[1]
         case bare
         when "\n"
-          ''
+          ""
         else
           '\\\\'
         end

data/lib/ripper_ruby_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RipperRubyParser
-  VERSION = '1.6.1'
+  VERSION = "1.7.0"
 end

data/test/end_to_end/comments_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'ruby_parser'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "ruby_parser"
 
-describe 'Using RipperRubyParser and RubyParser' do
+describe "Using RipperRubyParser and RubyParser" do
   let :newparser do
     RipperRubyParser::Parser.new
   end
@@ -12,9 +12,9 @@ describe 'Using RipperRubyParser and RubyParser' do
     RubyParser.for_current_ruby
   end
 
-  describe 'for a program with quite some comments' do
+  describe "for a program with quite some comments" do
     let :program do
-      <<-END
+      <<-RUBY
       # Foo
       class Foo
         # The foo
@@ -37,7 +37,7 @@ describe 'Using RipperRubyParser and RubyParser' do
           end
         end
       end
-      END
+      RUBY
     end
 
     let :original do
@@ -48,12 +48,12 @@ describe 'Using RipperRubyParser and RubyParser' do
       newparser.parse program
     end
 
-    it 'gives the same result' do
-      imitation.must_equal original
+    it "gives the same result" do
+      _(imitation).must_equal original
     end
 
-    it 'gives the same result with comments' do
-      to_comments(imitation).must_equal to_comments(original)
+    it "gives the same result with comments" do
+      _(to_comments(imitation)).must_equal to_comments(original)
     end
   end
 end

data/test/end_to_end/comparison_test.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'ruby_parser'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "ruby_parser"
 
-describe 'Using RipperRubyParser and RubyParser' do
-  describe 'for a simple well known program' do
+describe "Using RipperRubyParser and RubyParser" do
+  describe "for a simple well known program" do
     let :program do
       "puts 'Hello World'"
     end
 
-    it 'gives the same result with line numbers' do
-      program.must_be_parsed_as_before with_line_numbers: true
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 
-  describe 'for a more complex program' do
+  describe "for a more complex program" do
     let :program do
-      <<-END
+      <<-RUBY
       module Quux
         class Foo
           def bar
@@ -32,27 +32,27 @@ describe 'Using RipperRubyParser and RubyParser' do
       end
 
       Quux::Foo.new.bar
-      END
+      RUBY
     end
 
-    it 'gives the same result with line numbers' do
-      program.must_be_parsed_as_before with_line_numbers: true
+    it "gives the same result" do
+      _(program).must_be_parsed_as_before
     end
   end
 
-  describe 'for an example with yield from Reek' do
+  describe "for an example with yield from Reek" do
     let :program do
-      'def fred() yield(3) if block_given?; end'
+      "def fred() yield(3) if block_given?; end"
     end
 
-    it 'gives the same result with line numbers' do
-      program.must_be_parsed_as_before with_line_numbers: true
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 
-  describe 'for an example with floats from Reek' do
+  describe "for an example with floats from Reek" do
     let :program do
-      <<-END
+      <<-RUBY
         def total_envy
           fred = @item
           total = 0
@@ -60,17 +60,17 @@ describe 'Using RipperRubyParser and RubyParser' do
           total += fred.tax
           total *= 1.15
         end
-      END
+      RUBY
     end
 
-    it 'gives the same result' do
-      program.must_be_parsed_as_before
+    it "gives the same result" do
+      _(program).must_be_parsed_as_before
     end
   end
 
-  describe 'for an example with operators and explicit block parameter from Reek' do
+  describe "for an example with operators and explicit block parameter from Reek" do
     let :program do
-      <<-END
+      <<-RUBY
         def parse(arg, argv, &error)
           if !(val = arg) and (argv.empty? or /\\A-/ =~ (val = argv[0]))
             return nil, block, nil
@@ -84,21 +84,21 @@ describe 'Using RipperRubyParser and RubyParser' do
           end
           val
         end
-      END
+      RUBY
     end
 
-    it 'gives the same result' do
-      program.must_be_parsed_as_before
+    it "gives the same result" do
+      _(program).must_be_parsed_as_before
     end
   end
 
-  describe 'for an example of a complex regular expression from Reek' do
+  describe "for an example of a complex regular expression from Reek" do
     let :program do
       "/(\#{@types})\\s*(\\w+)\\s*\\(([^)]*)\\)/"
     end
 
-    it 'gives the same result with line numbers' do
-      program.must_be_parsed_as_before with_line_numbers: true
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 end

data/test/end_to_end/lib_comparison_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'ruby_parser'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "ruby_parser"
 
-describe 'Using RipperRubyParser and RubyParser' do
+describe "Using RipperRubyParser and RubyParser" do
   let :newparser do
     RipperRubyParser::Parser.new
   end
@@ -12,17 +12,17 @@ describe 'Using RipperRubyParser and RubyParser' do
     RubyParser.for_current_ruby
   end
 
-  Dir.glob('lib/**/*.rb').each do |file|
+  Dir.glob("lib/**/*.rb").each do |file|
     describe "for #{file}" do
       let :program do
         File.read file
       end
 
-      it 'gives the same result' do
+      it "gives the same result" do
         original = oldparser.parse program
         imitation = newparser.parse program
 
-        formatted(imitation).must_equal formatted(original)
+        _(formatted(imitation)).must_equal formatted(original)
       end
     end
   end

data/test/end_to_end/line_numbering_test.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'ruby_parser'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "ruby_parser"
 
-describe 'Using RipperRubyParser and RubyParser' do
-  describe 'for a multi-line program' do
+describe "Using RipperRubyParser and RubyParser" do
+  describe "for a multi-line program" do
     let :program do
-      <<-END
+      <<-RUBY
       class Foo
         def foo()
           bar()
@@ -17,15 +17,15 @@ describe 'Using RipperRubyParser and RubyParser' do
       module Bar
         @@baz = {}
       end
-      END
+      RUBY
     end
 
-    it 'gives the same result' do
-      program.must_be_parsed_as_before
+    it "gives the same result" do
+      _(program).must_be_parsed_as_before
     end
 
-    it 'gives the same result with line numbers' do
-      program.must_be_parsed_as_before with_line_numbers: true
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 end

data/test/end_to_end/samples_comparison_test.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'ruby_parser'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "ruby_parser"
 
-describe 'Using RipperRubyParser and RubyParser' do
-  Dir.glob(File.expand_path('../samples/*.rb', File.dirname(__FILE__))).each do |file|
+describe "Using RipperRubyParser and RubyParser" do
+  Dir.glob(File.expand_path("../samples/*.rb", File.dirname(__FILE__))).each do |file|
     it "gives the same result for #{file}" do
       program = File.read file
-      program.must_be_parsed_as_before
+      _(program).must_be_parsed_as_before
     end
   end
 end

data/test/end_to_end/test_comparison_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'ruby_parser'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "ruby_parser"
 
-describe 'Using RipperRubyParser and RubyParser' do
+describe "Using RipperRubyParser and RubyParser" do
   let :newparser do
     RipperRubyParser::Parser.new
   end
@@ -12,20 +12,20 @@ describe 'Using RipperRubyParser and RubyParser' do
     RubyParser.for_current_ruby
   end
 
-  Dir.glob('test/ripper_ruby_parser/**/*.rb').each do |file|
+  Dir.glob("test/ripper_ruby_parser/**/*.rb").each do |file|
     describe "for #{file}" do
       let :program do
         File.read file
       end
 
-      it 'gives the same result' do
+      it "gives the same result" do
         # Clone string because ruby_parser destroys it when there's a heredoc
         # inside.
         copy = program.clone
         original = oldparser.parse program
         imitation = newparser.parse copy
 
-        formatted(imitation).must_equal formatted(original)
+        _(formatted(imitation)).must_equal formatted(original)
       end
     end
   end

data/test/pt_testcase/pt_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
-require 'pt_testcase'
+require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
+require "pt_testcase"
 
 class TestParser < RipperRubyParser::Parser
   def process(input)
@@ -9,17 +9,17 @@ class TestParser < RipperRubyParser::Parser
   end
 end
 
-SKIPPED_TESTS = ['dstr_heredoc_windoze_sucks'].freeze
+SKIPPED_TESTS = ["dstr_heredoc_windoze_sucks"].freeze
 
 class RubyParserTestCase < ParseTreeTestCase
   def self.previous(_key)
-    'Ruby'
+    "Ruby"
   end
 
   def self.generate_test(klass, node, data, input_name, _output_name)
-    if data['Ruby'].is_a? Array
+    if data["Ruby"].is_a? Array
       klass.send :define_method, "test_#{node}" do
-        skip 'Not a parser test'
+        skip "Not a parser test"
       end
       return
     end
@@ -31,7 +31,7 @@ class RubyParserTestCase < ParseTreeTestCase
       return
     end
 
-    super klass, node, data, input_name, 'ParseTree'
+    super klass, node, data, input_name, "ParseTree"
   end
 end
 

data/test/ripper_ruby_parser/commenting_ripper_parser_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__))
 
 describe RipperRubyParser::CommentingRipperParser do
   def parse_with_builder(str)
@@ -12,195 +12,189 @@ describe RipperRubyParser::CommentingRipperParser do
     @empty_params_list ||= s(:params, *([nil] * 7))
   end
 
-  describe 'handling comments' do
-    it 'produces a comment node surrounding a commented def' do
+  describe "handling comments" do
+    # Handle different results for dynamic symbol strings. This was changed in
+    # Ruby 2.6.3 and up. See https://bugs.ruby-lang.org/issues/15670
+    let(:dsym_string_type) { RUBY_VERSION < "2.6.3" ? :xstring : :string_content }
+
+    it "produces a comment node surrounding a commented def" do
       result = parse_with_builder "# Foo\ndef foo; end"
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              "# Foo\n",
-                              s(:def,
-                                s(:@ident, 'foo', s(2, 4)),
-                                empty_params_list,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(2, 12))), nil, nil, nil),
-                                s(2, 0)))))
-    end
-
-    it 'produces a blank comment node surrounding a def that has no comment' do
-      result = parse_with_builder 'def foo; end'
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              '',
-                              s(:def,
-                                s(:@ident, 'foo', s(1, 4)),
-                                empty_params_list,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(1, 12))), nil, nil, nil),
-                                s(1, 0)))))
-    end
-
-    it 'produces a comment node surrounding a commented class' do
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "# Foo\n",
+                                 s(:def,
+                                   s(:@ident, "foo", s(2, 4)),
+                                   empty_params_list,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(2, 12))), nil, nil, nil),
+                                   s(2, 0)))))
+    end
+
+    it "produces a blank comment node surrounding a def that has no comment" do
+      result = parse_with_builder "def foo; end"
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "",
+                                 s(:def,
+                                   s(:@ident, "foo", s(1, 4)),
+                                   empty_params_list,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(1, 12))), nil, nil, nil),
+                                   s(1, 0)))))
+    end
+
+    it "produces a comment node surrounding a commented class" do
       result = parse_with_builder "# Foo\nclass Foo; end"
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              "# Foo\n",
-                              s(:class,
-                                s(:const_ref, s(:@const, 'Foo', s(2, 6))),
-                                nil,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(2, 10))), nil, nil, nil),
-                                s(2, 0)))))
-    end
-
-    it 'produce a blank comment node surrounding a class that has no comment' do
-      result = parse_with_builder 'class Foo; end'
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              '',
-                              s(:class,
-                                s(:const_ref, s(:@const, 'Foo', s(1, 6))),
-                                nil,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(1, 10))), nil, nil, nil),
-                                s(1, 0)))))
-    end
-
-    it 'produces a comment node surrounding a commented module' do
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "# Foo\n",
+                                 s(:class,
+                                   s(:const_ref, s(:@const, "Foo", s(2, 6))),
+                                   nil,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(2, 10))), nil, nil, nil),
+                                   s(2, 0)))))
+    end
+
+    it "produce a blank comment node surrounding a class that has no comment" do
+      result = parse_with_builder "class Foo; end"
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "",
+                                 s(:class,
+                                   s(:const_ref, s(:@const, "Foo", s(1, 6))),
+                                   nil,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(1, 10))), nil, nil, nil),
+                                   s(1, 0)))))
+    end
+
+    it "produces a comment node surrounding a commented module" do
       result = parse_with_builder "# Foo\nmodule Foo; end"
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              "# Foo\n",
-                              s(:module,
-                                s(:const_ref, s(:@const, 'Foo', s(2, 7))),
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(2, 11))), nil, nil, nil),
-                                s(2, 0)))))
-    end
-
-    it 'produces a blank comment node surrounding a module that has no comment' do
-      result = parse_with_builder 'module Foo; end'
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              '',
-                              s(:module,
-                                s(:const_ref, s(:@const, 'Foo', s(1, 7))),
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(1, 11))), nil, nil, nil),
-                                s(1, 0)))))
-    end
-
-    it 'is not confused by a symbol containing a keyword' do
-      result = parse_with_builder ':class; def foo; end'
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:symbol_literal, s(:symbol, s(:@kw, 'class', s(1, 1)))),
-                            s(:comment,
-                              '',
-                              s(:def,
-                                s(:@ident, 'foo', s(1, 12)),
-                                empty_params_list,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
-                                s(1, 8)))))
-    end
-
-    it 'is not confused by a dynamic symbol' do
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "# Foo\n",
+                                 s(:module,
+                                   s(:const_ref, s(:@const, "Foo", s(2, 7))),
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(2, 11))), nil, nil, nil),
+                                   s(2, 0)))))
+    end
+
+    it "produces a blank comment node surrounding a module that has no comment" do
+      result = parse_with_builder "module Foo; end"
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "",
+                                 s(:module,
+                                   s(:const_ref, s(:@const, "Foo", s(1, 7))),
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(1, 11))), nil, nil, nil),
+                                   s(1, 0)))))
+    end
+
+    it "is not confused by a symbol containing a keyword" do
+      result = parse_with_builder ":class; def foo; end"
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:symbol_literal, s(:symbol, s(:@kw, "class", s(1, 1)))),
+                               s(:comment,
+                                 "",
+                                 s(:def,
+                                   s(:@ident, "foo", s(1, 12)),
+                                   empty_params_list,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
+                                   s(1, 8)))))
+    end
+
+    it "is not confused by a dynamic symbol" do
       result = parse_with_builder ":'foo'; def bar; end"
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:dyna_symbol,
-                              s(:xstring, s(:@tstring_content, 'foo', s(1, 2), ":'"))),
-                            s(:comment,
-                              '',
-                              s(:def,
-                                s(:@ident, 'bar', s(1, 12)),
-                                empty_params_list,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
-                                s(1, 8)))))
-    end
-
-    it 'is not confused by a dynamic symbol containing a class definition' do
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:dyna_symbol,
+                                 s(dsym_string_type,
+                                   s(:@tstring_content, "foo", s(1, 2), ":'"))),
+                               s(:comment,
+                                 "",
+                                 s(:def,
+                                   s(:@ident, "bar", s(1, 12)),
+                                   empty_params_list,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
+                                   s(1, 8)))))
+    end
+
+    it "is not confused by a dynamic symbol containing a class definition" do
       result = parse_with_builder ":\"foo\#{class Bar;end}\""
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:dyna_symbol,
-                              s(:xstring,
-                                s(:@tstring_content, 'foo', s(1, 2), ':"'),
-                                s(:string_embexpr,
-                                  s(:stmts,
-                                    s(:comment,
-                                      '',
-                                      s(:class,
-                                        s(:const_ref, s(:@const, 'Bar', s(1, 13))),
-                                        nil,
-                                        s(:bodystmt,
-                                          s(:stmts, s(:void_stmt, s(1, 17))), nil, nil, nil),
-                                        s(1, 7)))))))))
-    end
-
-    it 'turns an embedded document into a comment node' do
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:dyna_symbol,
+                                 s(dsym_string_type,
+                                   s(:@tstring_content, "foo", s(1, 2), ':"'),
+                                   s(:string_embexpr,
+                                     s(:stmts,
+                                       s(:comment,
+                                         "",
+                                         s(:class,
+                                           s(:const_ref, s(:@const, "Bar", s(1, 13))),
+                                           nil,
+                                           s(:bodystmt,
+                                             s(:stmts, s(:void_stmt, s(1, 17))),
+                                             nil, nil, nil),
+                                           s(1, 7)))))))))
+    end
+
+    it "turns an embedded document into a comment node" do
       result = parse_with_builder "=begin Hello\nthere\n=end\nclass Foo; end"
-      result.must_equal s(:program,
-                          s(:stmts,
-                            s(:comment,
-                              "=begin Hello\nthere\n=end\n",
-                              s(:class,
-                                s(:const_ref, s(:@const, 'Foo', s(4, 6))),
-                                nil,
-                                s(:bodystmt,
-                                  s(:stmts, s(:void_stmt, s(4, 10))), nil, nil, nil),
-                                s(4, 0)))))
+      _(result).must_equal s(:program,
+                             s(:stmts,
+                               s(:comment,
+                                 "=begin Hello\nthere\n=end\n",
+                                 s(:class,
+                                   s(:const_ref, s(:@const, "Foo", s(4, 6))),
+                                   nil,
+                                   s(:bodystmt,
+                                     s(:stmts, s(:void_stmt, s(4, 10))), nil, nil, nil),
+                                   s(4, 0)))))
     end
   end
 
-  describe 'handling syntax errors' do
-    it 'raises an error for an incomplete source' do
-      proc {
-        parse_with_builder 'def foo'
-      }.must_raise RipperRubyParser::SyntaxError
+  describe "handling syntax errors" do
+    it "raises an error for an incomplete source" do
+      _(proc { parse_with_builder "def foo" }).must_raise RipperRubyParser::SyntaxError
     end
 
-    it 'raises an error for an invalid class name' do
-      proc {
-        parse_with_builder 'class foo; end'
-      }.must_raise RipperRubyParser::SyntaxError
+    it "raises an error for an invalid class name" do
+      _(proc { parse_with_builder "class foo; end" })
+        .must_raise RipperRubyParser::SyntaxError
     end
 
-    it 'raises an error aliasing $1 as foo' do
-      proc {
-        parse_with_builder 'alias foo $1'
-      }.must_raise RipperRubyParser::SyntaxError
+    it "raises an error aliasing $1 as foo" do
+      _(proc { parse_with_builder "alias foo $1" }).must_raise RipperRubyParser::SyntaxError
     end
 
-    it 'raises an error aliasing foo as $1' do
-      proc {
-        parse_with_builder 'alias $1 foo'
-      }.must_raise RipperRubyParser::SyntaxError
+    it "raises an error aliasing foo as $1" do
+      _(proc { parse_with_builder "alias $1 foo" }).must_raise RipperRubyParser::SyntaxError
     end
 
-    it 'raises an error aliasing $2 as $1' do
-      proc {
-        parse_with_builder 'alias $1 $2'
-      }.must_raise RipperRubyParser::SyntaxError
+    it "raises an error aliasing $2 as $1" do
+      _(proc { parse_with_builder "alias $1 $2" }).must_raise RipperRubyParser::SyntaxError
     end
 
-    it 'raises an error assigning to $1' do
-      proc {
-        parse_with_builder '$1 = foo'
-      }.must_raise RipperRubyParser::SyntaxError
+    it "raises an error assigning to $1" do
+      _(proc { parse_with_builder "$1 = foo" }).must_raise RipperRubyParser::SyntaxError
     end
 
-    it 'raises an error using an invalid parameter name' do
-      proc {
-        parse_with_builder 'def foo(BAR); end'
-      }.must_raise RipperRubyParser::SyntaxError
+    it "raises an error using an invalid parameter name" do
+      _(proc { parse_with_builder "def foo(BAR); end" })
+        .must_raise RipperRubyParser::SyntaxError
     end
   end
 end