ripper_ruby_parser 1.6.1 → 1.7.0

data/test/ripper_ruby_parser/parser_test.rb

@@ -1,306 +1,306 @@
 # 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::Parser do
   let(:parser) { RipperRubyParser::Parser.new }
-  describe '#parse' do
-    it 'returns an s-expression' do
-      result = parser.parse 'foo'
-      result.must_be_instance_of Sexp
+  describe "#parse" do
+    it "returns an s-expression" do
+      result = parser.parse "foo"
+      _(result).must_be_instance_of Sexp
     end
 
-    describe 'for an empty program' do
-      it 'returns nil' do
-        ''.must_be_parsed_as nil
+    describe "for an empty program" do
+      it "returns nil" do
+        _("").must_be_parsed_as nil
       end
     end
 
-    describe 'for a class declaration' do
-      it 'works with a namespaced class name' do
-        'class Foo::Bar; end'.
-          must_be_parsed_as s(:class,
-                              s(:colon2, s(:const, :Foo), :Bar),
-                              nil)
+    describe "for a class declaration" do
+      it "works with a namespaced class name" do
+        _("class Foo::Bar; end")
+          .must_be_parsed_as s(:class,
+                               s(:colon2, s(:const, :Foo), :Bar),
+                               nil)
       end
 
-      it 'works for singleton classes' do
-        'class << self; end'.must_be_parsed_as s(:sclass, s(:self))
+      it "works for singleton classes" do
+        _("class << self; end").must_be_parsed_as s(:sclass, s(:self))
       end
     end
 
-    describe 'for a module declaration' do
-      it 'works with a simple module name' do
-        'module Foo; end'.
-          must_be_parsed_as s(:module, :Foo)
+    describe "for a module declaration" do
+      it "works with a simple module name" do
+        _("module Foo; end")
+          .must_be_parsed_as s(:module, :Foo)
       end
 
-      it 'works with a namespaced module name' do
-        'module Foo::Bar; end'.
-          must_be_parsed_as s(:module,
-                              s(:colon2, s(:const, :Foo), :Bar))
+      it "works with a namespaced module name" do
+        _("module Foo::Bar; end")
+          .must_be_parsed_as s(:module,
+                               s(:colon2, s(:const, :Foo), :Bar))
       end
     end
 
-    describe 'for empty parentheses' do
-      it 'works with lone ()' do
-        '()'.must_be_parsed_as s(:nil)
+    describe "for empty parentheses" do
+      it "works with lone ()" do
+        _("()").must_be_parsed_as s(:nil)
       end
     end
 
-    describe 'for a begin..end block' do
-      it 'works with no statements' do
-        'begin; end'.
-          must_be_parsed_as s(:nil)
+    describe "for a begin..end block" do
+      it "works with no statements" do
+        _("begin; end")
+          .must_be_parsed_as s(:nil)
       end
 
-      it 'works with one statement' do
-        'begin; foo; end'.
-          must_be_parsed_as s(:call, nil, :foo)
+      it "works with one statement" do
+        _("begin; foo; end")
+          .must_be_parsed_as s(:call, nil, :foo)
       end
 
-      it 'works with multiple statements' do
-        'begin; foo; bar; end'.
-          must_be_parsed_as s(:block,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar))
+      it "works with multiple statements" do
+        _("begin; foo; bar; end")
+          .must_be_parsed_as s(:block,
+                               s(:call, nil, :foo),
+                               s(:call, nil, :bar))
       end
     end
 
-    describe 'for arguments' do
-      it 'works for a simple case with splat' do
-        'foo *bar'.
-          must_be_parsed_as s(:call,
-                              nil,
-                              :foo,
-                              s(:splat, s(:call, nil, :bar)))
+    describe "for arguments" do
+      it "works for a simple case with splat" do
+        _("foo *bar")
+          .must_be_parsed_as s(:call,
+                               nil,
+                               :foo,
+                               s(:splat, s(:call, nil, :bar)))
       end
 
-      it 'works for a multi-argument case with splat' do
-        'foo bar, *baz'.
-          must_be_parsed_as s(:call,
-                              nil,
-                              :foo,
-                              s(:call, nil, :bar),
-                              s(:splat, s(:call, nil, :baz)))
+      it "works for a multi-argument case with splat" do
+        _("foo bar, *baz")
+          .must_be_parsed_as s(:call,
+                               nil,
+                               :foo,
+                               s(:call, nil, :bar),
+                               s(:splat, s(:call, nil, :baz)))
       end
 
-      it 'works for a simple case passing a block' do
-        'foo &bar'.
-          must_be_parsed_as s(:call, nil, :foo,
-                              s(:block_pass,
-                                s(:call, nil, :bar)))
+      it "works for a simple case passing a block" do
+        _("foo &bar")
+          .must_be_parsed_as s(:call, nil, :foo,
+                               s(:block_pass,
+                                 s(:call, nil, :bar)))
       end
 
-      it 'works for a bare hash' do
-        'foo bar => baz'.
-          must_be_parsed_as s(:call, nil, :foo,
-                              s(:hash,
-                                s(:call, nil, :bar),
-                                s(:call, nil, :baz)))
+      it "works for a bare hash" do
+        _("foo bar => baz")
+          .must_be_parsed_as s(:call, nil, :foo,
+                               s(:hash,
+                                 s(:call, nil, :bar),
+                                 s(:call, nil, :baz)))
       end
     end
 
-    describe 'for the __ENCODING__ keyword' do
-      it 'evaluates to the equivalent of Encoding::UTF_8' do
-        '__ENCODING__'.
-          must_be_parsed_as s(:colon2, s(:const, :Encoding), :UTF_8)
+    describe "for the __ENCODING__ keyword" do
+      it "evaluates to the equivalent of Encoding::UTF_8" do
+        _("__ENCODING__")
+          .must_be_parsed_as s(:colon2, s(:const, :Encoding), :UTF_8)
       end
     end
 
-    describe 'for the __FILE__ keyword' do
-      describe 'when not passing a file name' do
+    describe "for the __FILE__ keyword" do
+      describe "when not passing a file name" do
         it "creates a string sexp with value '(string)'" do
-          '__FILE__'.
-            must_be_parsed_as s(:str, '(string)')
+          _("__FILE__")
+            .must_be_parsed_as s(:str, "(string)")
         end
       end
 
-      describe 'when passing a file name' do
-        it 'creates a string sexp with the file name' do
-          result = parser.parse '__FILE__', 'foo'
-          result.must_equal s(:str, 'foo')
+      describe "when passing a file name" do
+        it "creates a string sexp with the file name" do
+          result = parser.parse "__FILE__", "foo"
+          _(result).must_equal s(:str, "foo")
         end
       end
     end
 
-    describe 'for the __LINE__ keyword' do
-      it 'creates a literal sexp with value of the line number' do
-        '__LINE__'.
-          must_be_parsed_as s(:lit, 1)
-        "\n__LINE__".
-          must_be_parsed_as s(:lit, 2)
+    describe "for the __LINE__ keyword" do
+      it "creates a literal sexp with value of the line number" do
+        _("__LINE__")
+          .must_be_parsed_as s(:lit, 1)
+        _("\n__LINE__")
+          .must_be_parsed_as s(:lit, 2)
       end
     end
 
-    describe 'for the END keyword' do
-      it 'converts to a :postexe iterator' do
-        'END { foo }'.
-          must_be_parsed_as s(:iter, s(:postexe), 0, s(:call, nil, :foo))
+    describe "for the END keyword" do
+      it "converts to a :postexe iterator" do
+        _("END { foo }")
+          .must_be_parsed_as s(:iter, s(:postexe), 0, s(:call, nil, :foo))
       end
 
-      it 'works with an empty block' do
-        'END { }'.
-          must_be_parsed_as s(:iter, s(:postexe), 0)
+      it "works with an empty block" do
+        _("END { }")
+          .must_be_parsed_as s(:iter, s(:postexe), 0)
       end
 
-      it 'assigns correct line numbers' do
-        "END {\nfoo\n}".
-          must_be_parsed_as s(:iter,
-                              s(:postexe).line(1), 0,
-                              s(:call, nil, :foo).line(2)).line(1),
-                            with_line_numbers: true
+      it "assigns correct line numbers" do
+        _("END {\nfoo\n}")
+          .must_be_parsed_as s(:iter,
+                               s(:postexe).line(1), 0,
+                               s(:call, nil, :foo).line(2)).line(1),
+                             with_line_numbers: true
       end
 
-      it 'assigns correct line numbers to a embedded begin block' do
-        "END {\nbegin\nfoo\nend\n}".
-          must_be_parsed_as s(:iter,
-                              s(:postexe).line(1), 0,
-                              s(:call, nil, :foo).line(3)).line(1),
-                            with_line_numbers: true
+      it "assigns correct line numbers to a embedded begin block" do
+        _("END {\nbegin\nfoo\nend\n}")
+          .must_be_parsed_as s(:iter,
+                               s(:postexe).line(1), 0,
+                               s(:call, nil, :foo).line(3)).line(1),
+                             with_line_numbers: true
       end
     end
 
-    describe 'for the BEGIN keyword' do
-      it 'converts to a :preexe iterator' do
-        'BEGIN { foo }'.
-          must_be_parsed_as s(:iter, s(:preexe), 0, s(:call, nil, :foo))
+    describe "for the BEGIN keyword" do
+      it "converts to a :preexe iterator" do
+        _("BEGIN { 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), 0)
+      it "works with an empty block" do
+        _("BEGIN { }")
+          .must_be_parsed_as s(:iter, s(:preexe), 0)
       end
 
-      it 'assigns correct line numbers' do
-        "BEGIN {\nfoo\n}".
-          must_be_parsed_as s(:iter,
-                              s(:preexe).line(1), 0,
-                              s(:call, nil, :foo).line(2)).line(1),
-                            with_line_numbers: true
+      it "assigns correct line numbers" do
+        _("BEGIN {\nfoo\n}")
+          .must_be_parsed_as s(:iter,
+                               s(:preexe).line(1), 0,
+                               s(:call, nil, :foo).line(2)).line(1),
+                             with_line_numbers: true
       end
 
-      it 'assigns correct line numbers to a embedded begin block' do
-        "BEGIN {\nbegin\nfoo\nend\n}".
-          must_be_parsed_as s(:iter,
-                              s(:preexe).line(1), 0,
-                              s(:begin,
-                                s(:call, nil, :foo).line(3)).line(2)).line(1),
-                            with_line_numbers: true
+      it "assigns correct line numbers to a embedded begin block" do
+        _("BEGIN {\nbegin\nfoo\nend\n}")
+          .must_be_parsed_as s(:iter,
+                               s(:preexe).line(1), 0,
+                               s(:begin,
+                                 s(:call, nil, :foo).line(3)).line(2)).line(1),
+                             with_line_numbers: true
       end
     end
 
-    describe 'for constant lookups' do
-      it 'works when explicitely starting from the root namespace' do
-        '::Foo'.
-          must_be_parsed_as s(:colon3, :Foo)
+    describe "for constant lookups" do
+      it "works when explicitely starting from the root namespace" do
+        _("::Foo")
+          .must_be_parsed_as s(:colon3, :Foo)
       end
 
-      it 'works with a three-level constant lookup' do
-        'Foo::Bar::Baz'.
-          must_be_parsed_as s(:colon2,
-                              s(:colon2, s(:const, :Foo), :Bar),
-                              :Baz)
+      it "works with a three-level constant lookup" do
+        _("Foo::Bar::Baz")
+          .must_be_parsed_as s(:colon2,
+                               s(:colon2, s(:const, :Foo), :Bar),
+                               :Baz)
       end
 
-      it 'works looking up a constant in a non-constant' do
-        'foo::Bar'.must_be_parsed_as s(:colon2,
-                                       s(:call, nil, :foo),
-                                       :Bar)
+      it "works looking up a constant in a non-constant" do
+        _("foo::Bar").must_be_parsed_as s(:colon2,
+                                          s(:call, nil, :foo),
+                                          :Bar)
       end
     end
 
-    describe 'for variable references' do
-      it 'works for self' do
-        'self'.
-          must_be_parsed_as s(:self)
+    describe "for variable references" do
+      it "works for self" do
+        _("self")
+          .must_be_parsed_as s(:self)
       end
 
-      it 'works for instance variables' do
-        '@foo'.
-          must_be_parsed_as s(:ivar, :@foo)
+      it "works for instance variables" do
+        _("@foo")
+          .must_be_parsed_as s(:ivar, :@foo)
       end
 
-      it 'works for global variables' do
-        '$foo'.
-          must_be_parsed_as s(:gvar, :$foo)
+      it "works for global variables" do
+        _("$foo")
+          .must_be_parsed_as s(:gvar, :$foo)
       end
 
-      it 'works for regexp match references' do
-        '$1'.
-          must_be_parsed_as s(:nth_ref, 1)
+      it "works for regexp match references" do
+        _("$1")
+          .must_be_parsed_as s(:nth_ref, 1)
       end
 
-      specify { "$'".must_be_parsed_as s(:back_ref, :"'") }
-      specify { '$&'.must_be_parsed_as s(:back_ref, :"&") }
+      specify { _("$'").must_be_parsed_as s(:back_ref, :"'") }
+      specify { _("$&").must_be_parsed_as s(:back_ref, :"&") }
 
-      it 'works for class variables' do
-        '@@foo'.
-          must_be_parsed_as s(:cvar, :@@foo)
+      it "works for class variables" do
+        _("@@foo")
+          .must_be_parsed_as s(:cvar, :@@foo)
       end
     end
 
-    describe 'for expressions' do
-      it 'handles assignment inside binary operator expressions' do
-        'foo + (bar = baz)'.
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :foo),
-                              :+,
-                              s(:lasgn,
-                                :bar,
-                                s(:call, nil, :baz)))
+    describe "for expressions" do
+      it "handles assignment inside binary operator expressions" do
+        _("foo + (bar = baz)")
+          .must_be_parsed_as s(:call,
+                               s(:call, nil, :foo),
+                               :+,
+                               s(:lasgn,
+                                 :bar,
+                                 s(:call, nil, :baz)))
       end
 
-      it 'handles assignment inside unary operator expressions' do
-        '+(foo = bar)'.
-          must_be_parsed_as s(:call,
-                              s(:lasgn, :foo, s(:call, nil, :bar)),
-                              :+@)
+      it "handles assignment inside unary operator expressions" do
+        _("+(foo = bar)")
+          .must_be_parsed_as s(:call,
+                               s(:lasgn, :foo, s(:call, nil, :bar)),
+                               :+@)
       end
     end
 
     # Note: differences in the handling of comments are not caught by Sexp's
     # implementation of equality.
-    describe 'for comments' do
-      it 'handles method comments' do
+    describe "for comments" do
+      it "handles method comments" do
         result = parser.parse "# Foo\ndef foo; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args), s(:nil))
-        result.comments.must_equal "# Foo\n"
+        _(result).must_equal s(:defn,
+                               :foo,
+                               s(:args), s(:nil))
+        _(result.comments).must_equal "# Foo\n"
       end
 
-      it 'handles comments for methods with explicit receiver' do
+      it "handles comments for methods with explicit receiver" do
         result = parser.parse "# Foo\ndef foo.bar; end"
-        result.must_equal s(:defs,
-                            s(:call, nil, :foo),
-                            :bar,
-                            s(:args),
-                            s(:nil))
-        result.comments.must_equal "# Foo\n"
+        _(result).must_equal s(:defs,
+                               s(:call, nil, :foo),
+                               :bar,
+                               s(:args),
+                               s(:nil))
+        _(result.comments).must_equal "# Foo\n"
       end
 
-      it 'matches comments to the correct entity' do
+      it "matches comments to the correct entity" do
         result = parser.parse "# Foo\nclass Foo\n# Bar\ndef bar\nend\nend"
-        result.must_equal s(:class, :Foo, nil,
-                            s(:defn, :bar,
-                              s(:args), s(:nil)))
-        result.comments.must_equal "# Foo\n"
+        _(result).must_equal s(:class, :Foo, nil,
+                               s(:defn, :bar,
+                                 s(:args), s(:nil)))
+        _(result.comments).must_equal "# Foo\n"
         defn = result[3]
-        defn.sexp_type.must_equal :defn
-        defn.comments.must_equal "# Bar\n"
+        _(defn.sexp_type).must_equal :defn
+        _(defn.comments).must_equal "# Bar\n"
       end
 
-      it 'combines multi-line comments' do
+      it "combines multi-line comments" do
         result = parser.parse "# Foo\n# Bar\ndef foo; end"
-        result.must_equal s(:defn,
-                            :foo,
-                            s(:args), s(:nil))
-        result.comments.must_equal "# Foo\n# Bar\n"
+        _(result).must_equal s(:defn,
+                               :foo,
+                               s(:args), s(:nil))
+        _(result.comments).must_equal "# Foo\n# Bar\n"
       end
 
-      it 'drops comments inside method bodies' do
-        result = parser.parse <<-END
+      it "drops comments inside method bodies" do
+        result = parser.parse <<-RUBY
           # Foo
           class Foo
             # foo
@@ -313,241 +313,241 @@ describe RipperRubyParser::Parser do
               baz
             end
           end
-        END
-        result.must_equal s(:class,
-                            :Foo,
-                            nil,
-                            s(:defn, :foo, s(:args), s(:call, nil, :bar)),
-                            s(:defn, :bar, s(:args), s(:call, nil, :baz)))
-        result.comments.must_equal "# Foo\n"
-        result[3].comments.must_equal "# foo\n"
-        result[4].comments.must_equal "# bar\n"
-      end
-
-      it 'handles use of singleton class inside methods' do
+        RUBY
+        _(result).must_equal s(:class,
+                               :Foo,
+                               nil,
+                               s(:defn, :foo, s(:args), s(:call, nil, :bar)),
+                               s(:defn, :bar, s(:args), s(:call, nil, :baz)))
+        _(result.comments).must_equal "# Foo\n"
+        _(result[3].comments).must_equal "# foo\n"
+        _(result[4].comments).must_equal "# bar\n"
+      end
+
+      it "handles use of singleton class inside methods" do
         result = parser.parse "# Foo\ndef bar\nclass << self\nbaz\nend\nend"
-        result.must_equal s(:defn,
-                            :bar,
-                            s(:args),
-                            s(:sclass, s(:self),
-                              s(:call, nil, :baz)))
-        result.comments.must_equal "# Foo\n"
+        _(result).must_equal s(:defn,
+                               :bar,
+                               s(:args),
+                               s(:sclass, s(:self),
+                                 s(:call, nil, :baz)))
+        _(result.comments).must_equal "# Foo\n"
       end
 
       # TODO: Prefer assigning comment to the BEGIN instead
-      it 'assigns comments on BEGIN blocks to the following item' do
+      it "assigns comments on BEGIN blocks to the following item" do
         result = parser.parse "# Bar\nBEGIN { }\n# Foo\nclass Bar\n# foo\ndef foo; end\nend"
-        result.must_equal s(:block,
-                            s(:iter, s(:preexe), 0),
-                            s(:class, :Bar, nil,
-                              s(:defn, :foo, s(:args), s(:nil))))
-        result[2].comments.must_equal "# Bar\n# Foo\n"
-        result[2][3].comments.must_equal "# foo\n"
+        _(result).must_equal s(:block,
+                               s(:iter, s(:preexe), 0),
+                               s(:class, :Bar, nil,
+                                 s(:defn, :foo, s(:args), s(:nil))))
+        _(result[2].comments).must_equal "# Bar\n# Foo\n"
+        _(result[2][3].comments).must_equal "# foo\n"
       end
 
-      it 'assigns comments on multiple BEGIN blocks to the following item' do
+      it "assigns comments on multiple BEGIN blocks to the following item" do
         result = parser.parse "# Bar\nBEGIN { }\n# Baz\nBEGIN { }\n# Foo\ndef foo; end"
-        result.must_equal s(:block,
-                            s(:iter, s(:preexe), 0),
-                            s(:iter, s(:preexe), 0),
-                            s(:defn, :foo, s(:args), s(:nil)))
-        result[3].comments.must_equal "# Bar\n# Baz\n# Foo\n"
+        _(result).must_equal s(:block,
+                               s(:iter, s(:preexe), 0),
+                               s(:iter, s(:preexe), 0),
+                               s(:defn, :foo, s(:args), s(:nil)))
+        _(result[3].comments).must_equal "# Bar\n# Baz\n# Foo\n"
       end
 
-      it 'assigns comments on BEGIN blocks to the first following item' do
+      it "assigns comments on BEGIN blocks to the first following item" do
         result = parser.parse "# Bar\nBEGIN { }\n# Baz\nBEGIN { }\n# Foo\ndef foo; end"
-        result.must_equal s(:block,
-                            s(:iter, s(:preexe), 0),
-                            s(:iter, s(:preexe), 0),
-                            s(:defn, :foo, s(:args), s(:nil)))
-        result[3].comments.must_equal "# Bar\n# Baz\n# Foo\n"
+        _(result).must_equal s(:block,
+                               s(:iter, s(:preexe), 0),
+                               s(:iter, s(:preexe), 0),
+                               s(:defn, :foo, s(:args), s(:nil)))
+        _(result[3].comments).must_equal "# Bar\n# Baz\n# Foo\n"
       end
     end
 
     # Note: differences in the handling of line numbers are not caught by
     # Sexp's implementation of equality.
-    describe 'assigning line numbers' do
-      it 'works for a plain method call' do
-        result = parser.parse 'foo'
-        result.line.must_equal 1
+    describe "assigning line numbers" do
+      it "works for a plain method call" do
+        result = parser.parse "foo"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a method call with parentheses' do
-        result = parser.parse 'foo()'
-        result.line.must_equal 1
+      it "works for a method call with parentheses" do
+        result = parser.parse "foo()"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a method call with receiver' do
-        result = parser.parse 'foo.bar'
-        result.line.must_equal 1
+      it "works for a method call with receiver" do
+        result = parser.parse "foo.bar"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a method call with receiver and arguments' do
-        result = parser.parse 'foo.bar baz'
-        result.line.must_equal 1
+      it "works for a method call with receiver and arguments" do
+        result = parser.parse "foo.bar baz"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a method call with arguments' do
-        result = parser.parse 'foo bar'
-        result.line.must_equal 1
+      it "works for a method call with arguments" do
+        result = parser.parse "foo bar"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a block with two lines' do
+      it "works for a block with two lines" do
         result = parser.parse "foo\nbar\n"
-        result.sexp_type.must_equal :block
-        result[1].line.must_equal 1
-        result[2].line.must_equal 2
-        result.line.must_equal 1
+        _(result.sexp_type).must_equal :block
+        _(result[1].line).must_equal 1
+        _(result[2].line).must_equal 2
+        _(result.line).must_equal 1
       end
 
-      it 'works for a constant reference' do
-        result = parser.parse 'Foo'
-        result.line.must_equal 1
+      it "works for a constant reference" do
+        result = parser.parse "Foo"
+        _(result.line).must_equal 1
       end
 
-      it 'works for an instance variable' do
-        result = parser.parse '@foo'
-        result.line.must_equal 1
+      it "works for an instance variable" do
+        result = parser.parse "@foo"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a global variable' do
-        result = parser.parse '$foo'
-        result.line.must_equal 1
+      it "works for a global variable" do
+        result = parser.parse "$foo"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a class variable' do
-        result = parser.parse '@@foo'
-        result.line.must_equal 1
+      it "works for a class variable" do
+        result = parser.parse "@@foo"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a local variable' do
-        "foo = bar\nfoo\n".
-          must_be_parsed_as s(:block,
-                              s(:lasgn, :foo, s(:call, nil, :bar).line(1)).line(1),
-                              s(:lvar, :foo).line(2)).line(1),
-                            with_line_numbers: true
+      it "works for a local variable" do
+        _("foo = bar\nfoo\n")
+          .must_be_parsed_as s(:block,
+                               s(:lasgn, :foo, s(:call, nil, :bar).line(1)).line(1),
+                               s(:lvar, :foo).line(2)).line(1),
+                             with_line_numbers: true
       end
 
-      it 'works for an integer literal' do
-        result = parser.parse '42'
-        result.line.must_equal 1
+      it "works for an integer literal" do
+        result = parser.parse "42"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a float literal' do
-        result = parser.parse '3.14'
-        result.line.must_equal 1
+      it "works for a float literal" do
+        result = parser.parse "3.14"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a range literal' do
-        result = parser.parse '0..4'
-        result.line.must_equal 1
+      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
+      it "works for an exclusive range literal" do
+        result = parser.parse "0...4"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a symbol literal' do
-        result = parser.parse ':foo'
-        result.line.must_equal 1
+      it "works for a symbol literal" do
+        result = parser.parse ":foo"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a keyword-like symbol literal' do
-        result = parser.parse ':and'
-        result.line.must_equal 1
+      it "works for a keyword-like symbol literal" do
+        result = parser.parse ":and"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a string literal' do
+      it "works for a string literal" do
         result = parser.parse '"foo"'
-        result.line.must_equal 1
+        _(result.line).must_equal 1
       end
 
-      it 'works for a backtick string literal' do
-        result = parser.parse '`foo`'
-        result.line.must_equal 1
+      it "works for a backtick string literal" do
+        result = parser.parse "`foo`"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a plain regexp literal' do
-        result = parser.parse '/foo/'
-        result.line.must_equal 1
+      it "works for a plain regexp literal" do
+        result = parser.parse "/foo/"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a regular expression back reference' do
-        result = parser.parse '$1'
-        result.line.must_equal 1
+      it "works for a regular expression back reference" do
+        result = parser.parse "$1"
+        _(result.line).must_equal 1
       end
 
-      it 'works for self' do
-        result = parser.parse 'self'
-        result.line.must_equal 1
+      it "works for self" do
+        result = parser.parse "self"
+        _(result.line).must_equal 1
       end
 
-      it 'works for __FILE__' do
-        result = parser.parse '__FILE__'
-        result.line.must_equal 1
+      it "works for __FILE__" do
+        result = parser.parse "__FILE__"
+        _(result.line).must_equal 1
       end
 
-      it 'works for nil' do
-        result = parser.parse 'nil'
-        result.line.must_equal 1
+      it "works for nil" do
+        result = parser.parse "nil"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a class definition' do
-        result = parser.parse 'class Foo; end'
-        result.line.must_equal 1
+      it "works for a class definition" do
+        result = parser.parse "class Foo; end"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a module definition' do
-        result = parser.parse 'module Foo; end'
-        result.line.must_equal 1
+      it "works for a module definition" do
+        result = parser.parse "module Foo; end"
+        _(result.line).must_equal 1
       end
 
-      it 'works for a method definition' do
-        result = parser.parse 'def foo; end'
-        result.line.must_equal 1
+      it "works for a method definition" do
+        result = parser.parse "def foo; end"
+        _(result.line).must_equal 1
       end
 
-      it 'assigns line numbers to nested sexps without their own line numbers' do
-        "foo(bar) do\nnext baz\nend\n".
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo, s(:call, nil, :bar).line(1)).line(1),
-                              0,
-                              s(:next, s(:call, nil, :baz).line(2)).line(2)).line(1),
-                            with_line_numbers: true
+      it "assigns line numbers to nested sexps without their own line numbers" do
+        _("foo(bar) do\nnext baz\nend\n")
+          .must_be_parsed_as s(:iter,
+                               s(:call, nil, :foo, s(:call, nil, :bar).line(1)).line(1),
+                               0,
+                               s(:next, s(:call, nil, :baz).line(2)).line(2)).line(1),
+                             with_line_numbers: true
       end
 
-      describe 'when a line number is passed' do
-        it 'shifts all line numbers as appropriate' do
-          result = parser.parse "foo\nbar\n", '(string)', 3
-          result.must_equal s(:block,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar))
-          result.line.must_equal 3
-          result[1].line.must_equal 3
-          result[2].line.must_equal 4
+      describe "when a line number is passed" do
+        it "shifts all line numbers as appropriate" do
+          result = parser.parse "foo\nbar\n", "(string)", 3
+          _(result).must_equal s(:block,
+                                 s(:call, nil, :foo),
+                                 s(:call, nil, :bar))
+          _(result.line).must_equal 3
+          _(result[1].line).must_equal 3
+          _(result[2].line).must_equal 4
         end
       end
     end
   end
 
-  describe '#trickle_up_line_numbers' do
-    it 'works through several nested levels' do
+  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
       parser.send :trickle_down_line_numbers, outer
-      inner.line.must_equal 42
+      _(inner.line).must_equal 42
     end
   end
 
-  describe '#trickle_down_line_numbers' do
-    it 'works through several nested levels' do
+  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)))
       parser.send :trickle_up_line_numbers, outer
-      outer.line.must_equal 42
+      _(outer.line).must_equal 42
     end
   end
 end