ripper_ruby_parser 1.1.1 → 1.1.2

data/test/unit/parser_test.rb

@@ -2,248 +2,216 @@ 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"
+  describe '#parse' do
+    it 'returns an s-expression' do
+      result = parser.parse 'foo'
       result.must_be_instance_of Sexp
     end
 
-    it "post-processes its result with the passed sexp processor" do
+    it 'post-processes its result with the passed sexp processor' do
       sexp_p = MiniTest::Mock.new
       sexp_p.expect :process, s(:result), [Sexp]
       sexp_p.expect :filename=, nil, ['(string)']
       sexp_p.expect :extra_compatible=, nil, [false]
 
       parser = RipperRubyParser::Parser.new sexp_p
-      result = parser.parse "any code"
+      result = parser.parse 'any code'
 
       result.must_equal s(:result)
       sexp_p.verify
     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".
+    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 namespaced module name" do
-        "module Foo::Bar; end".
+    describe 'for a module declaration' do
+      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 brackets" do
-      it "works with lone ()" do
-        "()".must_be_parsed_as s(:nil)
+    describe 'for empty brackets' do
+      it 'works with lone ()' do
+        '()'.must_be_parsed_as s(:nil)
       end
     end
 
-    describe "for the return statement" do
-      it "works with no arguments" do
-        "return".
+    describe 'for the return statement' do
+      it 'works with no arguments' do
+        'return'.
           must_be_parsed_as s(:return)
       end
 
-      it "works with one argument" do
-        "return foo".
+      it 'works with one argument' do
+        'return foo'.
           must_be_parsed_as s(:return,
                               s(:call, nil, :foo))
       end
 
-      it "works with a splat argument" do
-        "return *foo".
+      it 'works with a splat argument' do
+        'return *foo'.
           must_be_parsed_as s(:return,
                               s(:svalue,
                                 s(:splat,
                                   s(:call, nil, :foo))))
       end
 
-      it "works with multiple arguments" do
-        "return foo, bar".
+      it 'works with multiple arguments' do
+        'return foo, bar'.
           must_be_parsed_as s(:return,
                               s(:array,
                                 s(:call, nil, :foo),
                                 s(:call, nil, :bar)))
       end
 
-      it "works with a regular argument and a splat argument" do
-        "return foo, *bar".
+      it 'works with a regular argument and a splat argument' do
+        'return foo, *bar'.
           must_be_parsed_as s(:return,
                               s(:array,
                                 s(:call, nil, :foo),
                                 s(:splat,
                                   s(:call, nil, :bar))))
       end
-    end
-
-    describe "for the until statement" do
-      it "works in the prefix block case with do" do
-        "until foo do; bar; end".
-          must_be_parsed_as s(:until,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar), true)
-      end
-
-      it "works in the prefix block case without do" do
-        "until foo; bar; end".
-          must_be_parsed_as s(:until,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar), true)
-      end
-
-      it "works in the single-line postfix case" do
-        "foo until bar".
-          must_be_parsed_as s(:until,
-                              s(:call, nil, :bar),
-                              s(:call, nil, :foo), true)
-      end
-
-      it "works in the block postfix case" do
-        "begin; foo; end until bar".
-          must_be_parsed_as s(:until,
-                              s(:call, nil, :bar),
-                              s(:call, nil, :foo), false)
-      end
-    end
 
-    describe "for the while statement" do
-      it "works with do" do
-        "while foo do; bar; end".
-          must_be_parsed_as s(:while,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar), true)
+      it 'works with a function call with parentheses' do
+        'return foo(bar)'.
+          must_be_parsed_as s(:return,
+                              s(:call, nil, :foo,
+                                s(:call, nil, :bar)))
       end
 
-      it "works without do" do
-        "while foo; bar; end".
-          must_be_parsed_as s(:while,
-                              s(:call, nil, :foo),
-                              s(:call, nil, :bar), true)
+      it 'works with a function call without parentheses' do
+        'return foo bar'.
+          must_be_parsed_as s(:return,
+                              s(:call, nil, :foo,
+                                s(:call, nil, :bar)))
       end
     end
 
-    describe "for the for statement" do
-      it "works with do" do
-        "for foo in bar do; baz; end".
+    describe 'for the for statement' do
+      it 'works with do' do
+        'for foo in bar do; baz; end'.
           must_be_parsed_as s(:for,
                               s(:call, nil, :bar),
                               s(:lasgn, :foo),
                               s(:call, nil, :baz))
       end
 
-      it "works without do" do
-        "for foo in bar; baz; end".
+      it 'works without do' do
+        'for foo in bar; baz; end'.
           must_be_parsed_as s(:for,
                               s(:call, nil, :bar),
                               s(:lasgn, :foo),
                               s(:call, nil, :baz))
       end
 
-      it "works with an empty body" do
-        "for foo in bar; end".
+      it 'works with an empty body' do
+        'for foo in bar; end'.
           must_be_parsed_as s(:for,
                               s(:call, nil, :bar),
                               s(:lasgn, :foo))
       end
     end
 
-    describe "for a begin..end block" do
-      it "works with no statements" do
-        "begin; end".
+    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".
+      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".
+      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 the undef statement" do
-      it "works with a single bareword identifier" do
-        "undef foo".
+    describe 'for the undef statement' do
+      it 'works with a single bareword identifier' do
+        'undef foo'.
           must_be_parsed_as s(:undef, s(:lit, :foo))
       end
 
-      it "works with a single symbol" do
-        "undef :foo".
+      it 'works with a single symbol' do
+        'undef :foo'.
           must_be_parsed_as s(:undef, s(:lit, :foo))
       end
 
-      it "works with multiple bareword identifiers" do
-        "undef foo, bar".
+      it 'works with multiple bareword identifiers' do
+        'undef foo, bar'.
           must_be_parsed_as s(:block,
                               s(:undef, s(:lit, :foo)),
                               s(:undef, s(:lit, :bar)))
       end
 
-      it "works with multiple bareword symbols" do
-        "undef :foo, :bar".
+      it 'works with multiple bareword symbols' do
+        'undef :foo, :bar'.
           must_be_parsed_as s(:block,
                               s(:undef, s(:lit, :foo)),
                               s(:undef, s(:lit, :bar)))
       end
     end
 
-    describe "for the alias statement" do
-      it "works with regular barewords" do
-        "alias foo bar".
+    describe 'for the alias statement' do
+      it 'works with regular barewords' do
+        'alias foo bar'.
           must_be_parsed_as s(:alias,
                               s(:lit, :foo), s(:lit, :bar))
       end
 
-      it "works with symbols" do
-        "alias :foo :bar".
+      it 'works with symbols' do
+        'alias :foo :bar'.
           must_be_parsed_as s(:alias,
                               s(:lit, :foo), s(:lit, :bar))
       end
 
-      it "works with operator barewords" do
-        "alias + -".
+      it 'works with operator barewords' do
+        'alias + -'.
           must_be_parsed_as s(:alias,
                               s(:lit, :+), s(:lit, :-))
       end
 
-      it "works with global variables" do
-        "alias $foo $bar".
+      it 'works with global variables' do
+        'alias $foo $bar'.
           must_be_parsed_as s(:valias, :$foo, :$bar)
       end
     end
 
-    describe "for arguments" do
-      it "works for a simple case with splat" do
-        "foo *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".
+      it 'works for a multi-argument case with splat' do
+        'foo bar, *baz'.
           must_be_parsed_as s(:call,
                               nil,
                               :foo,
@@ -251,15 +219,15 @@ describe RipperRubyParser::Parser do
                               s(:splat, s(:call, nil, :baz)))
       end
 
-      it "works for a simple case passing a block" do
-        "foo &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".
+      it 'works for a bare hash' do
+        'foo bar => baz'.
           must_be_parsed_as s(:call, nil, :foo,
                               s(:hash,
                                 s(:call, nil, :bar),
@@ -267,29 +235,29 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe "for collection indexing" do
-      it "works in the simple case" do
-        "foo[bar]".
+    describe 'for collection indexing' do
+      it 'works in the simple case' do
+        'foo[bar]'.
           must_be_parsed_as s(:call,
                               s(:call, nil, :foo),
                               :[],
                               s(:call, nil, :bar))
       end
 
-      it "works without any indexes" do
-        "foo[]".must_be_parsed_as s(:call, s(:call, nil, :foo),
+      it 'works without any indexes' do
+        'foo[]'.must_be_parsed_as s(:call, s(:call, nil, :foo),
                                     :[])
       end
 
-      it "drops self from self[]" do
-        "self[foo]".must_be_parsed_as s(:call, nil, :[],
+      it 'drops self from self[]' do
+        'self[foo]'.must_be_parsed_as s(:call, nil, :[],
                                         s(:call, nil, :foo))
       end
     end
 
-    describe "for method definitions" do
-      it "works with def with receiver" do
-        "def foo.bar; end".
+    describe 'for method definitions' do
+      it 'works with def with receiver' do
+        'def foo.bar; end'.
           must_be_parsed_as s(:defs,
                               s(:call, nil, :foo),
                               :bar,
@@ -297,8 +265,8 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it "works with def with receiver and multiple statements" do
-        "def foo.bar; baz; qux; end".
+      it 'works with def with receiver and multiple statements' do
+        'def foo.bar; baz; qux; end'.
           must_be_parsed_as s(:defs,
                               s(:call, nil, :foo),
                               :bar,
@@ -307,16 +275,16 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :qux))
       end
 
-      it "works with a method argument with a default value" do
-        "def foo bar=nil; end".
+      it 'works with a method argument with a default value' do
+        'def foo bar=nil; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args, s(:lasgn, :bar, s(:nil))),
                               s(:nil))
       end
 
-      it "works with several method arguments with default values" do
-        "def foo bar=1, baz=2; end".
+      it 'works with several method arguments with default values' do
+        'def foo bar=1, baz=2; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args,
@@ -325,47 +293,47 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it "works with brackets around the parameter list" do
-        "def foo(bar); end".
+      it 'works with brackets around the parameter list' do
+        'def foo(bar); end'.
           must_be_parsed_as s(:defn, :foo, s(:args, :bar), s(:nil))
       end
 
-      it "works with a simple splat" do
-        "def foo *bar; end".
+      it 'works with a simple splat' do
+        'def foo *bar; end'.
           must_be_parsed_as s(:defn, :foo, s(:args, :"*bar"), s(:nil))
       end
 
-      it "works with a regular argument plus splat" do
-        "def foo bar, *baz; end".
+      it 'works with a regular argument plus splat' do
+        'def foo bar, *baz; end'.
           must_be_parsed_as s(:defn, :foo, s(:args, :bar, :"*baz"), s(:nil))
       end
 
-      it "works with a nameless splat" do
-        "def foo *; end".
+      it 'works with a nameless splat' do
+        'def foo *; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args, :"*"),
                               s(:nil))
       end
 
-      it "works for a simple case with explicit block parameter" do
-        "def foo &bar; end".
+      it 'works for a simple case with explicit block parameter' do
+        'def foo &bar; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args, :"&bar"),
                               s(:nil))
       end
 
-      it "works with a regular argument plus explicit block parameter" do
-        "def foo bar, &baz; end".
+      it 'works with a regular argument plus explicit block parameter' do
+        'def foo bar, &baz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args, :bar, :"&baz"),
                               s(:nil))
       end
 
-      it "works with a default value plus explicit block parameter" do
-        "def foo bar=1, &baz; end".
+      it 'works with a default value plus explicit block parameter' do
+        'def foo bar=1, &baz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args,
@@ -374,8 +342,8 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it "works with a default value plus mandatory argument" do
-        "def foo bar=1, baz; end".
+      it 'works with a default value plus mandatory argument' do
+        'def foo bar=1, baz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args,
@@ -384,16 +352,16 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it "works with a splat plus explicit block parameter" do
-        "def foo *bar, &baz; end".
+      it 'works with a splat plus explicit block parameter' do
+        'def foo *bar, &baz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args, :"*bar", :"&baz"),
                               s(:nil))
       end
 
-      it "works with a default value plus splat" do
-        "def foo bar=1, *baz; end".
+      it 'works with a default value plus splat' do
+        'def foo bar=1, *baz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args,
@@ -402,8 +370,8 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it "works with a default value, splat, plus final mandatory arguments" do
-        "def foo bar=1, *baz, qux, quuz; end".
+      it 'works with a default value, splat, plus final mandatory arguments' do
+        'def foo bar=1, *baz, qux, quuz; end'.
           must_be_parsed_as s(:defn,
                               :foo,
                               s(:args,
@@ -412,39 +380,66 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it "works when the method name is an operator" do
-        "def +; end".
+      it 'works with a named argument with a default value' do
+        'def foo bar: 1; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
+                                s(:kwarg, :bar, s(:lit, 1))),
+                              s(:nil))
+      end
+
+      it 'works with a named argument with no default value' do
+        skip 'Default values are required in Ruby 2.0' if RUBY_VERSION < '2.1.0'
+        'def foo bar:; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args,
+                                s(:kwarg, :bar)),
+                              s(:nil))
+      end
+
+      it 'works with a double splat' do
+        'def foo **bar; end'.
+          must_be_parsed_as s(:defn,
+                              :foo,
+                              s(:args, :'**bar'),
+                              s(:nil))
+      end
+
+      it 'works when the method name is an operator' do
+        'def +; end'.
           must_be_parsed_as s(:defn, :+, s(:args),
                               s(:nil))
       end
     end
 
-    describe "for blocks" do
-      it "works with no statements in the block body" do
-        "foo do; end".
+    describe 'for blocks' do
+      it 'works with no statements in the block body' do
+        'foo do; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0)
       end
 
-      it "works with next with no arguments" do
-        "foo do; next; end".
+      it 'works with next with no arguments' do
+        'foo do; next; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
                               s(:next))
       end
 
-      it "works with next with one argument" do
-        "foo do; next bar; end".
+      it 'works with next with one argument' do
+        'foo do; next bar; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
                               s(:next, s(:call, nil, :bar)))
       end
 
-      it "works with next with several arguments" do
-        "foo do; next bar, baz; end".
+      it 'works with next with several arguments' do
+        'foo do; next bar, baz; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
@@ -454,24 +449,44 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :baz))))
       end
 
-      it "works with break with no arguments" do
-        "foo do; break; end".
+      it 'works with next with a function call with parentheses' do
+        'foo do; next foo(bar); end'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:next,
+                                s(:call, nil, :foo,
+                                  s(:call, nil, :bar))))
+      end
+
+      it 'works with next with a function call without parentheses' do
+        'foo do; next foo bar; end'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:next,
+                                s(:call, nil, :foo,
+                                  s(:call, nil, :bar))))
+      end
+
+      it 'works with break with no arguments' do
+        'foo do; break; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
                               s(:break))
       end
 
-      it "works with break with one argument" do
-        "foo do; break bar; end".
+      it 'works with break with one argument' do
+        'foo do; break bar; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
                               s(:break, s(:call, nil, :bar)))
       end
 
-      it "works with break with several arguments" do
-        "foo do; break bar, baz; end".
+      it 'works with break with several arguments' do
+        'foo do; break bar, baz; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
@@ -481,199 +496,233 @@ describe RipperRubyParser::Parser do
                                   s(:call, nil, :baz))))
       end
 
-      it "works with redo" do
-        "foo do; redo; end".
+      it 'works with break with a function call with parentheses' do
+        'foo do; break foo(bar); end'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:break,
+                                s(:call, nil, :foo,
+                                  s(:call, nil, :bar))))
+      end
+
+      it 'works with break with a function call without parentheses' do
+        'foo do; break foo bar; end'.
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:break,
+                                s(:call, nil, :foo,
+                                  s(:call, nil, :bar))))
+      end
+
+      it 'works with redo' do
+        'foo do; redo; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               0,
                               s(:redo))
       end
 
-      it "works with zero arguments" do
-        "foo do ||; end".
+      it 'works with zero arguments' do
+        'foo do ||; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               s(:args))
       end
 
-      it "works with one argument" do
-        "foo do |bar|; end".
+      it 'works with one argument' do
+        'foo do |bar|; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               s(:args, :bar))
       end
 
-      it "works with multiple arguments" do
-        "foo do |bar, baz|; end".
+      it 'works with multiple arguments' do
+        'foo do |bar, baz|; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               s(:args, :bar, :baz))
       end
 
-      it "works with a single splat argument" do
-        "foo do |*bar|; end".
+      it 'works with a single splat argument' do
+        'foo do |*bar|; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               s(:args, :"*bar"))
       end
 
-      it "works with a combination of regular arguments and a splat argument" do
-        "foo do |bar, *baz|; end".
+      it 'works with a combination of regular arguments and a splat argument' do
+        'foo do |bar, *baz|; end'.
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
                               s(:args, :bar, :"*baz"))
       end
     end
 
-    describe "for yield" do
-      it "works with no arguments and no brackets" do
-        "yield".
+    describe 'for yield' do
+      it 'works with no arguments and no brackets' do
+        'yield'.
           must_be_parsed_as s(:yield)
       end
 
-      it "works with brackets but no arguments" do
-        "yield()".
+      it 'works with brackets but no arguments' do
+        'yield()'.
           must_be_parsed_as s(:yield)
       end
 
-      it "works with one argument and no brackets" do
-        "yield foo".
+      it 'works with one argument and no brackets' do
+        'yield foo'.
           must_be_parsed_as s(:yield, s(:call, nil, :foo))
       end
 
-      it "works with one argument and brackets" do
-        "yield(foo)".
+      it 'works with one argument and brackets' do
+        'yield(foo)'.
           must_be_parsed_as s(:yield, s(:call, nil, :foo))
       end
 
-      it "works with multiple arguments and no brackets" do
-        "yield foo, bar".
+      it 'works with multiple arguments and no brackets' do
+        'yield foo, bar'.
           must_be_parsed_as s(:yield,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar))
       end
 
-      it "works with multiple arguments and brackets" do
-        "yield(foo, bar)".
+      it 'works with multiple arguments and brackets' do
+        'yield(foo, bar)'.
           must_be_parsed_as s(:yield,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar))
       end
 
-      it "works with splat" do
-        "yield foo, *bar".
+      it 'works with splat' do
+        'yield foo, *bar'.
           must_be_parsed_as s(:yield,
                               s(:call, nil, :foo),
                               s(:splat, s(:call, nil, :bar)))
       end
+
+      it 'works with a function call with parentheses' do
+        'yield foo(bar)'.
+          must_be_parsed_as s(:yield,
+                              s(:call, nil, :foo,
+                                s(:call, nil, :bar)))
+      end
+
+      it 'works with a function call without parentheses' do
+        'yield foo bar'.
+          must_be_parsed_as s(:yield,
+                              s(:call, nil, :foo,
+                                s(:call, nil, :bar)))
+      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__".
+    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 }".
+    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
     end
 
-    describe "for the BEGIN keyword" do
-      it "converts to a :preexe iterator" do
-        "BEGIN { foo }".
+    describe 'for the BEGIN keyword' do
+      it 'converts to a :preexe iterator' do
+        'BEGIN { foo }'.
           must_be_parsed_as s(:iter, s(:preexe), s(:args), s(:call, nil, :foo))
       end
     end
 
-    describe "for constant lookups" do
-      it "works when explicitely starting from the root namespace" do
-        "::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".
+      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,
+      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".
+    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".
+      it 'works for instance variables' do
+        '@foo'.
           must_be_parsed_as s(:ivar, :@foo)
       end
 
-      it "works for global variables" do
-        "$foo".
+      it 'works for global variables' do
+        '$foo'.
           must_be_parsed_as s(:gvar, :$foo)
       end
 
-      it "works for regexp match references" do
-        "$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, :"&") }
 
-      it "works for class variables" do
-        "@@foo".
+      it 'works for class variables' do
+        '@@foo'.
           must_be_parsed_as s(:cvar, :@@foo)
       end
     end
 
-    describe "for single assignment" do
-      it "works when assigning to an instance variable" do
-        "@foo = bar".
+    describe 'for single assignment' do
+      it 'works when assigning to an instance variable' do
+        '@foo = bar'.
           must_be_parsed_as s(:iasgn,
                               :@foo,
                               s(:call, nil, :bar))
       end
 
-      it "works when assigning to a constant" do
-        "FOO = bar".
+      it 'works when assigning to a constant' do
+        'FOO = bar'.
           must_be_parsed_as s(:cdecl,
                               :FOO,
                               s(:call, nil, :bar))
       end
 
-      it "works when assigning to a collection element" do
-        "foo[bar] = baz".
+      it 'works when assigning to a collection element' do
+        'foo[bar] = baz'.
           must_be_parsed_as s(:attrasgn,
                               s(:call, nil, :foo),
                               :[]=,
@@ -681,47 +730,47 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
-      it "works when assigning to an attribute" do
-        "foo.bar = baz".
+      it 'works when assigning to an attribute' do
+        'foo.bar = baz'.
           must_be_parsed_as s(:attrasgn,
                               s(:call, nil, :foo),
                               :bar=,
                               s(:call, nil, :baz))
       end
 
-      it "works when assigning to a class variable" do
-        "@@foo = bar".
+      it 'works when assigning to a class variable' do
+        '@@foo = bar'.
           must_be_parsed_as s(:cvdecl,
                               :@@foo,
                               s(:call, nil, :bar))
       end
 
-      it "works when assigning to a class variable inside a method" do
-        "def foo; @@bar = baz; end".
+      it 'works when assigning to a class variable inside a method' do
+        'def foo; @@bar = baz; end'.
           must_be_parsed_as s(:defn,
                               :foo, s(:args),
                               s(:cvasgn, :@@bar, s(:call, nil, :baz)))
       end
 
-      it "works when assigning to a class variable inside a method with a receiver" do
-        "def self.foo; @@bar = baz; end".
+      it 'works when assigning to a class variable inside a method with a receiver' do
+        'def self.foo; @@bar = baz; end'.
           must_be_parsed_as s(:defs,
                               s(:self),
                               :foo, s(:args),
                               s(:cvasgn, :@@bar, s(:call, nil, :baz)))
       end
 
-      it "works when assigning to a global variable" do
-        "$foo = bar".
+      it 'works when assigning to a global variable' do
+        '$foo = bar'.
           must_be_parsed_as s(:gasgn,
                               :$foo,
                               s(:call, nil, :bar))
       end
     end
 
-    describe "for operator assignment" do
-      it "works with +=" do
-        "foo += bar".
+    describe 'for operator assignment' do
+      it 'works with +=' do
+        'foo += bar'.
           must_be_parsed_as s(:lasgn,
                               :foo,
                               s(:call,
@@ -730,8 +779,8 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :bar)))
       end
 
-      it "works with -=" do
-        "foo -= bar".
+      it 'works with -=' do
+        'foo -= bar'.
           must_be_parsed_as s(:lasgn,
                               :foo,
                               s(:call,
@@ -740,16 +789,16 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :bar)))
       end
 
-      it "works with ||=" do
-        "foo ||= bar".
+      it 'works with ||=' do
+        'foo ||= bar'.
           must_be_parsed_as s(:op_asgn_or,
                               s(:lvar, :foo),
                               s(:lasgn, :foo,
                                 s(:call, nil, :bar)))
       end
 
-      it "works when assigning to an instance variable" do
-        "@foo += bar".
+      it 'works when assigning to an instance variable' do
+        '@foo += bar'.
           must_be_parsed_as s(:iasgn,
                               :@foo,
                               s(:call,
@@ -758,8 +807,8 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :bar)))
       end
 
-      it "works when assigning to a collection element" do
-        "foo[bar] += baz".
+      it 'works when assigning to a collection element' do
+        'foo[bar] += baz'.
           must_be_parsed_as s(:op_asgn1,
                               s(:call, nil, :foo),
                               s(:arglist, s(:call, nil, :bar)),
@@ -767,8 +816,8 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
-      it "works with ||= when assigning to a collection element" do
-        "foo[bar] ||= baz".
+      it 'works with ||= when assigning to a collection element' do
+        'foo[bar] ||= baz'.
           must_be_parsed_as s(:op_asgn1,
                               s(:call, nil, :foo),
                               s(:arglist, s(:call, nil, :bar)),
@@ -776,8 +825,8 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
-      it "works when assigning to an attribute" do
-        "foo.bar += baz".
+      it 'works when assigning to an attribute' do
+        'foo.bar += baz'.
           must_be_parsed_as s(:op_asgn2,
                               s(:call, nil, :foo),
                               :bar=,
@@ -785,8 +834,8 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :baz))
       end
 
-      it "works with ||= when assigning to an attribute" do
-        "foo.bar ||= baz".
+      it 'works with ||= when assigning to an attribute' do
+        'foo.bar ||= baz'.
           must_be_parsed_as s(:op_asgn2,
                               s(:call, nil, :foo),
                               :bar=,
@@ -795,9 +844,9 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe "for multiple assignment" do
-      it "works the same number of items on each side" do
-        "foo, bar = baz, qux".
+    describe 'for multiple assignment' do
+      it 'works the same number of items on each side' do
+        'foo, bar = baz, qux'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                               s(:array,
@@ -805,16 +854,16 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :qux)))
       end
 
-      it "works with a single item on the right-hand side" do
-        "foo, bar = baz".
+      it 'works with a single item on the right-hand side' do
+        'foo, bar = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                               s(:to_ary,
                                 s(:call, nil, :baz)))
       end
 
-      it "works with left-hand splat" do
-        "foo, *bar = baz, qux".
+      it 'works with left-hand splat' do
+        'foo, *bar = baz, qux'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
                               s(:array,
@@ -822,15 +871,15 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :qux)))
       end
 
-      it "works with brackets around the left-hand side" do
-        "(foo, bar) = baz".
+      it 'works with brackets around the left-hand side' do
+        '(foo, bar) = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                               s(:to_ary, s(:call, nil, :baz)))
       end
 
-      it "works with complex destructuring" do
-        "foo, (bar, baz) = qux".
+      it 'works with complex destructuring' do
+        'foo, (bar, baz) = qux'.
           must_be_parsed_as s(:masgn,
                               s(:array,
                                 s(:lasgn, :foo),
@@ -839,8 +888,8 @@ describe RipperRubyParser::Parser do
                               s(:to_ary, s(:call, nil, :qux)))
       end
 
-      it "works with complex destructuring of the value" do
-        "foo, (bar, baz) = [qux, [quz, quuz]]".
+      it 'works with complex destructuring of the value' do
+        'foo, (bar, baz) = [qux, [quz, quuz]]'.
           must_be_parsed_as s(:masgn,
                               s(:array,
                                 s(:lasgn, :foo),
@@ -851,22 +900,22 @@ describe RipperRubyParser::Parser do
                                   s(:array, s(:call, nil, :quz), s(:call, nil, :quuz)))))
       end
 
-      it "works with instance variables" do
-        "@foo, @bar = baz".
+      it 'works with instance variables' do
+        '@foo, @bar = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
                               s(:to_ary, s(:call, nil, :baz)))
       end
 
-      it "works with class variables" do
-        "@@foo, @@bar = baz".
+      it 'works with class variables' do
+        '@@foo, @@bar = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
                               s(:to_ary, s(:call, nil, :baz)))
       end
 
-      it "works with attributes" do
-        "foo.bar, foo.baz = qux".
+      it 'works with attributes' do
+        'foo.bar, foo.baz = qux'.
           must_be_parsed_as s(:masgn,
                               s(:array,
                                 s(:attrasgn, s(:call, nil, :foo), :bar=),
@@ -874,8 +923,8 @@ describe RipperRubyParser::Parser do
                               s(:to_ary, s(:call, nil, :qux)))
       end
 
-      it "works with collection elements" do
-        "foo[1], bar[2] = baz".
+      it 'works with collection elements' do
+        'foo[1], bar[2] = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array,
                                 s(:attrasgn,
@@ -885,15 +934,15 @@ describe RipperRubyParser::Parser do
                               s(:to_ary, s(:call, nil, :baz)))
       end
 
-      it "works with constants" do
-        "Foo, Bar = baz".
+      it 'works with constants' do
+        'Foo, Bar = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
                               s(:to_ary, s(:call, nil, :baz)))
       end
 
-      it "works with instance variables and splat" do
-        "@foo, *@bar = baz".
+      it 'works with instance variables and splat' do
+        '@foo, *@bar = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array,
                                 s(:iasgn, :@foo),
@@ -903,126 +952,102 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe "for operators" do
-      it "handles :!=" do
-        "foo != bar".
+    describe 'for operators' do
+      it 'handles :!=' do
+        'foo != bar'.
           must_be_parsed_as s(:call,
                               s(:call, nil, :foo),
                               :!=,
                               s(:call, nil, :bar))
       end
 
-      it "handles :=~ with two non-literals" do
-        "foo =~ bar".
+      it 'handles :=~ with two non-literals' do
+        'foo =~ bar'.
           must_be_parsed_as s(:call,
                               s(:call, nil, :foo),
                               :=~,
                               s(:call, nil, :bar))
       end
 
-      it "handles :=~ with literal regexp on the left hand side" do
-        "/foo/ =~ bar".
+      it 'handles :=~ with literal regexp on the left hand side' do
+        '/foo/ =~ bar'.
           must_be_parsed_as s(:match2,
                               s(:lit, /foo/),
                               s(:call, nil, :bar))
       end
 
-      it "handles :=~ with literal regexp on the right hand side" do
-        "foo =~ /bar/".
+      it 'handles :=~ with literal regexp on the right hand side' do
+        'foo =~ /bar/'.
           must_be_parsed_as s(:match3,
                               s(:lit, /bar/),
                               s(:call, nil, :foo))
       end
 
-      it "handles unary minus with a number literal" do
-        "-1".
-          must_be_parsed_as s(:lit, -1)
-      end
-
-      it "handles unary minus with a non-literal" do
-        "-foo".
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :foo),
-                              :-@)
-      end
-
-      it "handles unary plus with a number literal" do
-        "+ 1".
-          must_be_parsed_as s(:lit, 1)
-      end
-
-      it "handles unary plus with a non-literal" do
-        "+ foo".
-          must_be_parsed_as s(:call,
-                              s(:call, nil, :foo),
-                              :+@)
-      end
-
-      it "handles unary !" do
-        "!foo".
+      it 'handles unary !' do
+        '!foo'.
           must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
       end
 
-      it "converts :not to :!" do
-        "not foo".
+      it 'converts :not to :!' do
+        'not foo'.
           must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
       end
 
-      it "handles unary ! with a number literal" do
-        "!1".
+      it 'handles unary ! with a number literal' do
+        '!1'.
           must_be_parsed_as s(:call, s(:lit, 1), :!)
       end
 
-      it "handles the range operator with positive number literals" do
-        "1..2".
+      it 'handles the range operator with positive number literals' do
+        '1..2'.
           must_be_parsed_as s(:lit, 1..2)
       end
 
-      it "handles the range operator with negative number literals" do
-        "-1..-2".
+      it 'handles the range operator with negative number literals' do
+        '-1..-2'.
           must_be_parsed_as s(:lit, -1..-2)
       end
 
-      it "handles the range operator with string literals" do
+      it 'handles the range operator with string literals' do
         "'a'..'z'".
           must_be_parsed_as s(:dot2,
-                              s(:str, "a"),
-                              s(:str, "z"))
+                              s(:str, 'a'),
+                              s(:str, 'z'))
       end
 
-      it "handles the range operator with non-literals" do
-        "foo..bar".
+      it 'handles the range operator with non-literals' do
+        'foo..bar'.
           must_be_parsed_as s(:dot2,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar))
       end
 
-      it "handles the exclusive range operator with positive number literals" do
-        "1...2".
+      it 'handles the exclusive range operator with positive number literals' do
+        '1...2'.
           must_be_parsed_as s(:lit, 1...2)
       end
 
-      it "handles the exclusive range operator with negative number literals" do
-        "-1...-2".
+      it 'handles the exclusive range operator with negative number literals' do
+        '-1...-2'.
           must_be_parsed_as s(:lit, -1...-2)
       end
 
-      it "handles the exclusive range operator with string literals" do
+      it 'handles the exclusive range operator with string literals' do
         "'a'...'z'".
           must_be_parsed_as s(:dot3,
-                              s(:str, "a"),
-                              s(:str, "z"))
+                              s(:str, 'a'),
+                              s(:str, 'z'))
       end
 
-      it "handles the exclusive range operator with non-literals" do
-        "foo...bar".
+      it 'handles the exclusive range operator with non-literals' do
+        'foo...bar'.
           must_be_parsed_as s(:dot3,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar))
       end
 
-      it "handles the ternary operator" do
-        "foo ? bar : baz".
+      it 'handles the ternary operator' do
+        'foo ? bar : baz'.
           must_be_parsed_as s(:if,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar),
@@ -1030,9 +1055,9 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe "for expressions" do
-      it "handles assignment inside binary operator expressions" do
-        "foo + (bar = 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),
                               :+,
@@ -1041,8 +1066,8 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :baz)))
       end
 
-      it "handles assignment inside unary operator expressions" do
-        "+(foo = bar)".
+      it 'handles assignment inside unary operator expressions' do
+        '+(foo = bar)'.
           must_be_parsed_as s(:call,
                               s(:lasgn, :foo, s(:call, nil, :bar)),
                               :+@)
@@ -1051,8 +1076,8 @@ describe RipperRubyParser::Parser do
 
     # 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,
@@ -1060,7 +1085,7 @@ describe RipperRubyParser::Parser do
         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),
@@ -1070,7 +1095,7 @@ describe RipperRubyParser::Parser do
         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,
@@ -1081,7 +1106,7 @@ describe RipperRubyParser::Parser do
         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,
@@ -1089,7 +1114,7 @@ describe RipperRubyParser::Parser do
         result.comments.must_equal "# Foo\n# Bar\n"
       end
 
-      it "drops comments inside method bodies" do
+      it 'drops comments inside method bodies' do
         result = parser.parse <<-END
           # Foo
           class Foo
@@ -1114,7 +1139,7 @@ describe RipperRubyParser::Parser do
         result[4].comments.must_equal "# bar\n"
       end
 
-      it "handles the use of symbols that are keywords" do
+      it 'handles the use of symbols that are keywords' do
         result = parser.parse "# Foo\ndef bar\n:class\nend"
         result.must_equal s(:defn,
                             :bar,
@@ -1123,7 +1148,7 @@ describe RipperRubyParser::Parser do
         result.comments.must_equal "# Foo\n"
       end
 
-      it "handles use of singleton class inside methods" do
+      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,
@@ -1136,33 +1161,33 @@ describe RipperRubyParser::Parser do
 
     # 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"
+    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 brackets" do
-        result = parser.parse "foo()"
+      it 'works for a method call with brackets' 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"
+      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"
+      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"
+      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
@@ -1170,27 +1195,27 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it "works for a constant reference" do
-        result = parser.parse "Foo"
+      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"
+      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"
+      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"
+      it 'works for a class variable' do
+        result = parser.parse '@@foo'
         result.line.must_equal 1
       end
 
-      it "works for a local variable" do
+      it 'works for a local variable' do
         result = parser.parse "foo = bar\nfoo\n"
         result.sexp_type.must_equal :block
         result[1].line.must_equal 1
@@ -1198,67 +1223,67 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it "works for an integer literal" do
-        result = parser.parse "42"
+      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"
+      it 'works for a float literal' do
+        result = parser.parse '3.14'
         result.line.must_equal 1
       end
 
-      it "works for a regular expression back reference" do
-        result = parser.parse "$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"
+      it 'works for self' do
+        result = parser.parse 'self'
         result.line.must_equal 1
       end
 
-      it "works for __FILE__" do
-        result = parser.parse "__FILE__"
+      it 'works for __FILE__' do
+        result = parser.parse '__FILE__'
         result.line.must_equal 1
       end
 
-      it "works for nil" do
-        result = parser.parse "nil"
+      it 'works for nil' do
+        result = parser.parse 'nil'
         result.line.must_equal 1
       end
 
-      it "works for a symbol literal" do
-        result = parser.parse ":foo"
+      it 'works for a symbol literal' do
+        result = parser.parse ':foo'
         result.line.must_equal 1
       end
 
-      it "works for a class definition" do
-        result = parser.parse "class Foo; end"
+      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"
+      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"
+      it 'works for a method definition' do
+        result = parser.parse 'def foo; end'
         result.line.must_equal 1
       end
 
-      it "works for assignment of the empty hash" do
-        result = parser.parse "foo = {}"
+      it 'works for assignment of the empty hash' do
+        result = parser.parse 'foo = {}'
         result.line.must_equal 1
       end
 
-      it "works for multiple assignment of empty hashes" do
-        result = parser.parse "foo, bar = {}, {}"
+      it 'works for multiple assignment of empty hashes' do
+        result = parser.parse 'foo, bar = {}, {}'
         result.line.must_equal 1
       end
 
-      it "assigns line numbers to nested sexps without their own line numbers" do
+      it 'assigns line numbers to nested sexps without their own line numbers' do
         result = parser.parse "foo(bar) do\nnext baz\nend\n"
         result.must_equal s(:iter,
                             s(:call, nil, :foo, s(:call, nil, :bar)),
@@ -1270,8 +1295,8 @@ describe RipperRubyParser::Parser do
         nums.must_equal [1, 2]
       end
 
-      describe "when a line number is passed" do
-        it "shifts all line numbers as appropriate" do
+      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),