ripper_ruby_parser 1.1.1 → 1.1.2

data/test/unit/parser_literals_test.rb

@@ -1,342 +1,352 @@
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
-  describe "#parse" do
-    describe "for regexp literals" do
-      it "works for a simple regex literal" do
-        "/foo/".
+  describe '#parse' do
+    describe 'for regexp literals' do
+      it 'works for a simple regex literal' do
+        '/foo/'.
           must_be_parsed_as s(:lit, /foo/)
       end
 
-      it "works for regex literals with escaped right bracket" do
+      it 'works for regex literals with escaped right bracket' do
         '/\\)/'.
           must_be_parsed_as s(:lit, /\)/)
       end
 
-      it "works for regex literals with escape sequences" do
+      it 'works for regex literals with escape sequences' do
         '/\\)\\n\\\\/'.
           must_be_parsed_as s(:lit, /\)\n\\/)
       end
 
-      it "works for a regex literal with the multiline flag" do
-        "/foo/m".
+      it 'works for a regex literal with the multiline flag' do
+        '/foo/m'.
           must_be_parsed_as s(:lit, /foo/m)
       end
 
-      it "works for a regex literal with the extended flag" do
-        "/foo/x".
+      it 'works for a regex literal with the extended flag' do
+        '/foo/x'.
           must_be_parsed_as s(:lit, /foo/x)
       end
 
-      it "works for a regex literal with the ignorecase flag" do
-        "/foo/i".
+      it 'works for a regex literal with the ignorecase flag' do
+        '/foo/i'.
           must_be_parsed_as s(:lit, /foo/i)
       end
 
-      it "works for a regex literal with a combination of flags" do
-        "/foo/ixm".
+      it 'works for a regex literal with a combination of flags' do
+        '/foo/ixm'.
           must_be_parsed_as s(:lit, /foo/ixm)
       end
 
-      it "works with the no-encoding flag" do
+      it 'works with the no-encoding flag' do
         parser = RipperRubyParser::Parser.new
-        result = parser.parse "/foo/n"
+        result = parser.parse '/foo/n'
         # Use inspect since regular == finds no difference between /foo/n
         # and /foo/
         result.inspect.must_equal s(:lit, /foo/n).inspect
       end
 
-      describe "with interpolations" do
-        it "works for a simple interpolation" do
+      describe 'with interpolations' do
+        it 'works for a simple interpolation' do
           '/foo#{bar}baz/'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr, s(:call, nil, :bar)),
-                                s(:str, "baz"))
+                                s(:str, 'baz'))
         end
 
-        it "works for a regex literal with flags and interpolation" do
+        it 'works for a regex literal with flags and interpolation' do
           '/foo#{bar}/ixm'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr, s(:call, nil, :bar)),
                                 7)
         end
 
-        it "works with the no-encoding flag" do
+        it 'works with the no-encoding flag' do
           '/foo#{bar}/n'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr,
                                   s(:call, nil, :bar)), 32)
         end
 
-        it "works with the unicode-encoding flag" do
+        it 'works with the unicode-encoding flag' do
           '/foo#{bar}/u'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr,
                                   s(:call, nil, :bar)), 16)
         end
 
-        it "works with the euc-encoding flag" do
+        it 'works with the euc-encoding flag' do
           '/foo#{bar}/e'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr,
                                   s(:call, nil, :bar)), 16)
         end
 
-        it "works with the sjis-encoding flag" do
+        it 'works with the sjis-encoding flag' do
           '/foo#{bar}/s'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr,
                                   s(:call, nil, :bar)), 16)
         end
 
-        it "works for a regex literal with interpolate-once flag" do
+        it 'works for a regex literal with interpolate-once flag' do
           '/foo#{bar}/o'.
             must_be_parsed_as s(:dregx_once,
-                                "foo",
+                                'foo',
                                 s(:evstr, s(:call, nil, :bar)))
         end
 
-        it "works with an empty interpolation" do
+        it 'works with an empty interpolation' do
           '/foo#{}bar/'.
             must_be_parsed_as s(:dregx,
-                                "foo",
+                                'foo',
                                 s(:evstr),
-                                s(:str, "bar"))
+                                s(:str, 'bar'))
         end
 
-        describe "containing just a literal string" do
-          it "performs the interpolation when it is at the end" do
+        describe 'containing just a literal string' do
+          it 'performs the interpolation when it is at the end' do
             '/foo#{"bar"}/'.must_be_parsed_as s(:lit, /foobar/)
           end
 
-          it "performs the interpolation when it is in the middle" do
+          it 'performs the interpolation when it is in the middle' do
             '/foo#{"bar"}baz/'.must_be_parsed_as s(:lit, /foobarbaz/)
           end
 
-          it "performs the interpolation when it is at the start" do
+          it 'performs the interpolation when it is at the start' do
             '/#{"foo"}bar/'.must_be_parsed_as s(:lit, /foobar/)
           end
         end
       end
     end
 
-    describe "for string literals" do
-      it "works for empty strings" do
+    describe 'for string literals' do
+      it 'works for empty strings' do
         "''".
-          must_be_parsed_as s(:str, "")
+          must_be_parsed_as s(:str, '')
       end
 
-      it "sets the encoding for literal strings to utf8 even if ascii would do" do
+      it 'sets the encoding for literal strings to utf8 even if ascii would do' do
         parser = RipperRubyParser::Parser.new
-        result = parser.parse "\"foo\""
-        result.must_equal s(:str, "foo")
-        result[1].encoding.to_s.must_equal "UTF-8"
+        result = parser.parse '"foo"'
+        result.must_equal s(:str, 'foo')
+        result[1].encoding.to_s.must_equal 'UTF-8'
       end
 
-      describe "with double-quoted strings with escape sequences" do
-        it "works for strings with escape sequences" do
-          "\"\\n\"".
+      describe 'with double-quoted strings with escape sequences' do
+        it 'works for strings with escape sequences' do
+          '"\\n"'.
             must_be_parsed_as s(:str, "\n")
         end
 
-        it "works for strings with useless escape sequences" do
-          "\"F\\OO\"".
-            must_be_parsed_as s(:str, "FOO")
+        it 'works for strings with useless escape sequences' do
+          '"F\\OO"'.
+            must_be_parsed_as s(:str, 'FOO')
         end
 
-        it "works for strings with escaped backslashes" do
-          "\"\\\\n\"".
-            must_be_parsed_as s(:str, "\\n")
+        it 'works for strings with escaped backslashes' do
+          '"\\\\n"'.
+            must_be_parsed_as s(:str, '\\n')
         end
 
-        it "works for a representation of a regex literal with escaped right bracket" do
-          "\"/\\\\)/\"".
-            must_be_parsed_as s(:str, "/\\)/")
+        it 'works for a representation of a regex literal with escaped right bracket' do
+          '"/\\\\)/"'.
+            must_be_parsed_as s(:str, '/\\)/')
         end
 
-        it "works for a uselessly escaped right bracket" do
-          "\"/\\)/\"".
-            must_be_parsed_as s(:str, "/)/")
+        it 'works for a uselessly escaped right bracket' do
+          '"/\\)/"'.
+            must_be_parsed_as s(:str, '/)/')
         end
 
-        it "works for a string containing escaped quotes" do
-          "\"\\\"\"".
-            must_be_parsed_as s(:str, "\"")
+        it 'works for a string containing escaped quotes' do
+          '"\\""'.
+            must_be_parsed_as s(:str, '"')
         end
 
-        it "works with hex escapes" do
-          "\"\\x36\"".must_be_parsed_as s(:str, "6")
-          "\"\\x4a\"".must_be_parsed_as s(:str, "J")
-          "\"\\x4A\"".must_be_parsed_as s(:str, "J")
-          "\"\\x3Z\"".must_be_parsed_as s(:str, "\x03Z")
+        it 'works with hex escapes' do
+          '"\\x36"'.must_be_parsed_as s(:str, '6')
+          '"\\x4a"'.must_be_parsed_as s(:str, 'J')
+          '"\\x4A"'.must_be_parsed_as s(:str, 'J')
+          '"\\x3Z"'.must_be_parsed_as s(:str, "\x03Z")
         end
 
-        it "works with single-letter escapes" do
-          "\"foo\\abar\"".must_be_parsed_as s(:str, "foo\abar")
-          "\"foo\\bbar\"".must_be_parsed_as s(:str, "foo\bbar")
-          "\"foo\\ebar\"".must_be_parsed_as s(:str, "foo\ebar")
-          "\"foo\\fbar\"".must_be_parsed_as s(:str, "foo\fbar")
-          "\"foo\\nbar\"".must_be_parsed_as s(:str, "foo\nbar")
-          "\"foo\\rbar\"".must_be_parsed_as s(:str, "foo\rbar")
-          "\"foo\\sbar\"".must_be_parsed_as s(:str, "foo\sbar")
-          "\"foo\\tbar\"".must_be_parsed_as s(:str, "foo\tbar")
-          "\"foo\\vbar\"".must_be_parsed_as s(:str, "foo\vbar")
+        it 'works with single-letter escapes' do
+          '"foo\\abar"'.must_be_parsed_as s(:str, "foo\abar")
+          '"foo\\bbar"'.must_be_parsed_as s(:str, "foo\bbar")
+          '"foo\\ebar"'.must_be_parsed_as s(:str, "foo\ebar")
+          '"foo\\fbar"'.must_be_parsed_as s(:str, "foo\fbar")
+          '"foo\\nbar"'.must_be_parsed_as s(:str, "foo\nbar")
+          '"foo\\rbar"'.must_be_parsed_as s(:str, "foo\rbar")
+          '"foo\\sbar"'.must_be_parsed_as s(:str, "foo\sbar")
+          '"foo\\tbar"'.must_be_parsed_as s(:str, "foo\tbar")
+          '"foo\\vbar"'.must_be_parsed_as s(:str, "foo\vbar")
         end
 
-        it "works with octal number escapes" do
-          "\"foo\\123bar\"".must_be_parsed_as s(:str, "foo\123bar")
-          "\"foo\\23bar\"".must_be_parsed_as s(:str, "foo\023bar")
-          "\"foo\\3bar\"".must_be_parsed_as s(:str, "foo\003bar")
+        it 'works with octal number escapes' do
+          '"foo\\123bar"'.must_be_parsed_as s(:str, "foo\123bar")
+          '"foo\\23bar"'.must_be_parsed_as s(:str, "foo\023bar")
+          '"foo\\3bar"'.must_be_parsed_as s(:str, "foo\003bar")
 
-          "\"foo\\118bar\"".must_be_parsed_as s(:str, "foo\0118bar")
-          "\"foo\\18bar\"".must_be_parsed_as s(:str, "foo\0018bar")
+          '"foo\\118bar"'.must_be_parsed_as s(:str, "foo\0118bar")
+          '"foo\\18bar"'.must_be_parsed_as s(:str, "foo\0018bar")
         end
 
-        it "works with simple short hand control sequence escapes" do
-          "\"foo\\cabar\"".must_be_parsed_as s(:str, "foo\cabar")
-          "\"foo\\cZbar\"".must_be_parsed_as s(:str, "foo\cZbar")
+        it 'works with simple short hand control sequence escapes' do
+          '"foo\\cabar"'.must_be_parsed_as s(:str, "foo\cabar")
+          '"foo\\cZbar"'.must_be_parsed_as s(:str, "foo\cZbar")
         end
 
-        it "works with simple regular control sequence escapes" do
-          "\"foo\\C-abar\"".must_be_parsed_as s(:str, "foo\C-abar")
-          "\"foo\\C-Zbar\"".must_be_parsed_as s(:str, "foo\C-Zbar")
+        it 'works with simple regular control sequence escapes' do
+          '"foo\\C-abar"'.must_be_parsed_as s(:str, "foo\C-abar")
+          '"foo\\C-Zbar"'.must_be_parsed_as s(:str, "foo\C-Zbar")
         end
 
         # TODO: Implement remaining escape sequence cases.
 
         # TODO: Behave differently in extra_compatible mode.
-        it "works with unicode escapes (unlike RubyParser)" do
-          "\"foo\\u273bbar\"".must_be_parsed_as s(:str, "foo✻bar")
+        it 'works with unicode escapes (unlike RubyParser)' do
+          '"foo\\u273bbar"'.must_be_parsed_as s(:str, 'foo✻bar')
         end
       end
 
-      describe "with interpolations" do
-        describe "containing just a literal string" do
-          it "performs the interpolation when it is at the end" do
-            '"foo#{"bar"}"'.must_be_parsed_as s(:str, "foobar")
+      describe 'with interpolations' do
+        describe 'containing just a literal string' do
+          it 'performs the interpolation when it is at the end' do
+            '"foo#{"bar"}"'.must_be_parsed_as s(:str, 'foobar')
           end
 
-          it "performs the interpolation when it is in the middle" do
-            '"foo#{"bar"}baz"'.must_be_parsed_as s(:str, "foobarbaz")
+          it 'performs the interpolation when it is in the middle' do
+            '"foo#{"bar"}baz"'.must_be_parsed_as s(:str, 'foobarbaz')
           end
 
-          it "performs the interpolation when it is at the start" do
-            '"#{"foo"}bar"'.must_be_parsed_as s(:str, "foobar")
+          it 'performs the interpolation when it is at the start' do
+            '"#{"foo"}bar"'.must_be_parsed_as s(:str, 'foobar')
           end
         end
 
-        describe "without braces" do
-          it "works for ivars" do
+        describe 'without braces' do
+          it 'works for ivars' do
             "\"foo\#@bar\"".must_be_parsed_as s(:dstr,
-                                                "foo",
+                                                'foo',
                                                 s(:evstr, s(:ivar, :@bar)))
           end
 
-          it "works for gvars" do
+          it 'works for gvars' do
             "\"foo\#$bar\"".must_be_parsed_as s(:dstr,
-                                                "foo",
+                                                'foo',
                                                 s(:evstr, s(:gvar, :$bar)))
           end
 
-          it "works for cvars" do
+          it 'works for cvars' do
             "\"foo\#@@bar\"".must_be_parsed_as s(:dstr,
-                                                 "foo",
+                                                 'foo',
                                                  s(:evstr, s(:cvar, :@@bar)))
           end
         end
 
-        describe "with braces" do
-          it "works for trivial interpolated strings" do
+        describe 'with braces' do
+          it 'works for trivial interpolated strings' do
             '"#{foo}"'.
               must_be_parsed_as s(:dstr,
-                                  "",
+                                  '',
                                   s(:evstr,
                                     s(:call, nil, :foo)))
           end
 
-          it "works for basic interpolated strings" do
+          it 'works for basic interpolated strings' do
             '"foo#{bar}"'.
               must_be_parsed_as s(:dstr,
-                                  "foo",
+                                  'foo',
                                   s(:evstr,
                                     s(:call, nil, :bar)))
           end
 
-          it "works for strings with several interpolations" do
+          it 'works for strings with several interpolations' do
             '"foo#{bar}baz#{qux}"'.
               must_be_parsed_as s(:dstr,
-                                  "foo",
+                                  'foo',
                                   s(:evstr, s(:call, nil, :bar)),
-                                  s(:str, "baz"),
+                                  s(:str, 'baz'),
                                   s(:evstr, s(:call, nil, :qux)))
           end
 
-          it "correctly handles two interpolations in a row" do
+          it 'correctly handles two interpolations in a row' do
             "\"\#{bar}\#{qux}\"".
               must_be_parsed_as s(:dstr,
-                                  "",
+                                  '',
                                   s(:evstr, s(:call, nil, :bar)),
                                   s(:evstr, s(:call, nil, :qux)))
           end
 
-          it "works for strings with interpolations followed by escape sequences" do
+          it 'works for strings with interpolations followed by escape sequences' do
             '"#{foo}\\n"'.
               must_be_parsed_as s(:dstr,
-                                  "",
+                                  '',
                                   s(:evstr, s(:call, nil, :foo)),
                                   s(:str, "\n"))
           end
 
-          it "works with an empty interpolation" do
+          it 'works with an empty interpolation' do
             "\"foo\#{}bar\"".
               must_be_parsed_as s(:dstr,
-                                  "foo",
+                                  'foo',
                                   s(:evstr),
-                                  s(:str, "bar"))
+                                  s(:str, 'bar'))
           end
         end
       end
 
-      describe "with string concatenation" do
-        it "performs the concatenation in the case of two simple literal strings" do
-          "\"foo\" \"bar\"".must_be_parsed_as s(:str, "foobar")
+      describe 'with string concatenation' do
+        it 'performs the concatenation in the case of two simple literal strings' do
+          '"foo" "bar"'.must_be_parsed_as s(:str, 'foobar')
         end
 
-        it "performs the concatenation when the right string has interpolations" do
+        it 'performs the concatenation when the right string has interpolations' do
           "\"foo\" \"bar\#{baz}\"".
             must_be_parsed_as s(:dstr,
-                                "foobar",
+                                'foobar',
                                 s(:evstr, s(:call, nil, :baz)))
         end
 
-        it "performs the concatenation when the left string has interpolations" do
-          "\"foo\#{bar}\" \"baz\"".
-            must_be_parsed_as s(:dstr,
-                                "foo",
-                                s(:evstr, s(:call, nil, :bar)),
-                                s(:str, "baz"))
+        describe 'when the left string has interpolations' do
+          it 'performs the concatenation' do
+            "\"foo\#{bar}\" \"baz\"".
+              must_be_parsed_as s(:dstr,
+                                  'foo',
+                                  s(:evstr, s(:call, nil, :bar)),
+                                  s(:str, 'baz'))
+          end
+
+          it 'performs the concatenation with an empty string' do
+            "\"foo\#{bar}\" \"\"".
+              must_be_parsed_as s(:dstr,
+                                  'foo',
+                                  s(:evstr, s(:call, nil, :bar)),
+                                  s(:str, ''))
+          end
         end
 
-        describe "when both strings have interpolations" do
-          it "performs the concatenation" do
+        describe 'when both strings have interpolations' do
+          it 'performs the concatenation' do
             "\"foo\#{bar}\" \"baz\#{qux}\"".
               must_be_parsed_as s(:dstr,
-                                  "foo",
+                                  'foo',
                                   s(:evstr, s(:call, nil, :bar)),
-                                  s(:str, "baz"),
+                                  s(:str, 'baz'),
                                   s(:evstr, s(:call, nil, :qux)))
           end
 
-          it "removes empty substrings from the concatenation" do
+          it 'removes empty substrings from the concatenation' do
             "\"foo\#{bar}\" \"\#{qux}\"".
               must_be_parsed_as s(:dstr,
-                                  "foo",
+                                  'foo',
                                   s(:evstr, s(:call, nil, :bar)),
                                   s(:evstr, s(:call, nil, :qux)))
           end
@@ -344,149 +354,194 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe "for word list literals" do
-      it "correctly handles interpolation" do
+    describe 'for word list literals' do
+      it 'works for the simle case with %w' do
+        '%W(foo bar)'.
+          must_be_parsed_as s(:array, s(:str, 'foo'), s(:str, 'bar'))
+      end
+
+      it 'works for the simle case with %W' do
+        '%W(foo bar)'.
+          must_be_parsed_as s(:array, s(:str, 'foo'), s(:str, 'bar'))
+      end
+
+      it 'correctly handles interpolation' do
         "%W(foo \#{bar} baz)".
           must_be_parsed_as  s(:array,
-                               s(:str, "foo"),
-                               s(:dstr, "", s(:evstr, s(:call, nil, :bar))),
-                               s(:str, "baz"))
+                               s(:str, 'foo'),
+                               s(:dstr, '', s(:evstr, s(:call, nil, :bar))),
+                               s(:str, 'baz'))
       end
 
-      it "correctly handles braceless interpolation" do
+      it 'correctly handles braceless interpolation' do
         "%W(foo \#@bar baz)".
           must_be_parsed_as  s(:array,
-                               s(:str, "foo"),
-                               s(:dstr, "", s(:evstr, s(:ivar, :@bar))),
-                               s(:str, "baz"))
+                               s(:str, 'foo'),
+                               s(:dstr, '', s(:evstr, s(:ivar, :@bar))),
+                               s(:str, 'baz'))
+      end
+
+      it 'correctly handles in-word interpolation' do
+        "%W(foo \#{bar}baz)".
+          must_be_parsed_as s(:array,
+                              s(:str, 'foo'),
+                              s(:dstr,
+                                '',
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, 'baz')))
       end
     end
 
-    describe "for character literals" do
-      it "works for simple character literals" do
-        "?a".
-          must_be_parsed_as s(:str, "a")
+    describe 'for symbol list literals' do
+      it 'works for an array created with %i' do
+        '%i(foo bar)'.
+          must_be_parsed_as s(:array, s(:lit, :foo), s(:lit, :bar))
       end
 
-      it "works for escaped character literals" do
-        "?\\n".
+      it 'works for an array created with %I' do
+        '%I(foo bar)'.
+          must_be_parsed_as s(:array, s(:lit, :foo), s(:lit, :bar))
+      end
+
+      it 'correctly handles interpolation' do
+        "%I(foo \#{bar} baz)".
+          must_be_parsed_as s(:array,
+                              s(:lit, :foo),
+                              s(:dsym, "", s(:evstr, s(:call, nil, :bar))),
+                              s(:lit, :baz))
+      end
+
+      it 'correctly handles in-word interpolation' do
+        "%I(foo \#{bar}baz)".
+          must_be_parsed_as s(:array,
+                              s(:lit, :foo),
+                              s(:dsym,
+                                "",
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, "baz")))
+      end
+    end
+
+    describe 'for character literals' do
+      it 'works for simple character literals' do
+        '?a'.
+          must_be_parsed_as s(:str, 'a')
+      end
+
+      it 'works for escaped character literals' do
+        '?\\n'.
           must_be_parsed_as s(:str, "\n")
       end
 
-      it "works for escaped character literals with ctrl" do
-        "?\\C-a".
+      it 'works for escaped character literals with ctrl' do
+        '?\\C-a'.
           must_be_parsed_as s(:str, "\u0001")
       end
 
-      it "works for escaped character literals with meta" do
-        "?\\M-a".
-          must_be_parsed_as s(:str, "\xE1".force_encoding("ascii-8bit"))
+      it 'works for escaped character literals with meta' do
+        '?\\M-a'.
+          must_be_parsed_as s(:str, "\xE1".force_encoding('ascii-8bit'))
       end
 
-      it "works for escaped character literals with meta plus shorthand ctrl" do
-        "?\\M-\\ca".
-          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      it 'works for escaped character literals with meta plus shorthand ctrl' do
+        '?\\M-\\ca'.
+          must_be_parsed_as s(:str, "\x81".force_encoding('ascii-8bit'))
       end
 
-      it "works for escaped character literals with shorthand ctrl plus meta" do
-        "?\\c\\M-a".
-          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      it 'works for escaped character literals with shorthand ctrl plus meta' do
+        '?\\c\\M-a'.
+          must_be_parsed_as s(:str, "\x81".force_encoding('ascii-8bit'))
       end
 
-      it "works for escaped character literals with meta plus ctrl" do
-        "?\\M-\\C-a".
-          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      it 'works for escaped character literals with meta plus ctrl' do
+        '?\\M-\\C-a'.
+          must_be_parsed_as s(:str, "\x81".force_encoding('ascii-8bit'))
       end
 
-      it "works for escaped character literals with ctrl plus meta" do
-        "?\\C-\\M-a".
-          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      it 'works for escaped character literals with ctrl plus meta' do
+        '?\\C-\\M-a'.
+          must_be_parsed_as s(:str, "\x81".force_encoding('ascii-8bit'))
       end
     end
 
-    describe "for symbol literals" do
-      it "works for simple symbols" do
-        ":foo".
+    describe 'for symbol literals' do
+      it 'works for simple symbols' do
+        ':foo'.
           must_be_parsed_as s(:lit, :foo)
       end
 
-      it "works for symbols that look like instance variable names" do
-        ":@foo".
+      it 'works for symbols that look like instance variable names' do
+        ':@foo'.
           must_be_parsed_as s(:lit, :@foo)
       end
 
-      it "works for simple dsyms" do
+      it 'works for simple dsyms' do
         ':"foo"'.
           must_be_parsed_as s(:lit, :foo)
       end
 
-      it "works for dsyms with interpolations" do
+      it 'works for dsyms with interpolations' do
         ':"foo#{bar}"'.
           must_be_parsed_as s(:dsym,
-                              "foo",
+                              'foo',
                               s(:evstr, s(:call, nil, :bar)))
       end
     end
 
-    describe "for backtick string literals" do
-      it "works for basic backtick strings" do
+    describe 'for backtick string literals' do
+      it 'works for basic backtick strings' do
         '`foo`'.
-          must_be_parsed_as s(:xstr, "foo")
+          must_be_parsed_as s(:xstr, 'foo')
       end
 
-      it "works for interpolated backtick strings" do
+      it 'works for interpolated backtick strings' do
         '`foo#{bar}`'.
           must_be_parsed_as s(:dxstr,
-                              "foo",
+                              'foo',
                               s(:evstr, s(:call, nil, :bar)))
       end
 
-      it "works for backtick strings with escape sequences" do
+      it 'works for backtick strings with escape sequences' do
         '`foo\\n`'.
           must_be_parsed_as s(:xstr, "foo\n")
       end
     end
 
-    describe "for array literals" do
-      it "works for an empty array" do
-        "[]".
+    describe 'for array literals' do
+      it 'works for an empty array' do
+        '[]'.
           must_be_parsed_as s(:array)
       end
 
-      it "works for a simple case with splat" do
-        "[*foo]".
+      it 'works for a simple case with splat' do
+        '[*foo]'.
           must_be_parsed_as s(:array,
                               s(:splat, s(:call, nil, :foo)))
       end
 
-      it "works for a multi-element case with splat" do
-        "[foo, *bar]".
+      it 'works for a multi-element case with splat' do
+        '[foo, *bar]'.
           must_be_parsed_as s(:array,
                               s(:call, nil, :foo),
                               s(:splat, s(:call, nil, :bar)))
       end
-
-      it "works for an array created with %W" do
-        "%W(foo bar)".
-          must_be_parsed_as s(:array, s(:str, "foo"), s(:str, "bar"))
-      end
     end
 
-    describe "for hash literals" do
-      it "works for an empty hash" do
-        "{}".
+    describe 'for hash literals' do
+      it 'works for an empty hash' do
+        '{}'.
           must_be_parsed_as s(:hash)
       end
 
-      it "works for a hash with one pair" do
-        "{foo => bar}".
+      it 'works for a hash with one pair' do
+        '{foo => bar}'.
           must_be_parsed_as s(:hash,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar))
       end
 
-      it "works for a hash with multiple pairs" do
-        "{foo => bar, baz => qux}".
+      it 'works for a hash with multiple pairs' do
+        '{foo => bar, baz => qux}'.
           must_be_parsed_as s(:hash,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar),
@@ -494,26 +549,67 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :qux))
       end
 
-      it "works for a hash with label keys (Ruby 1.9 only)" do
-        "{foo: bar, baz: qux}".
+      it 'works for a hash with label keys' do
+        '{foo: bar, baz: qux}'.
           must_be_parsed_as s(:hash,
                               s(:lit, :foo),
                               s(:call, nil, :bar),
                               s(:lit, :baz),
                               s(:call, nil, :qux))
       end
+
+      it 'works for a hash with dynamic label keys' do
+        skip 'This is not valid syntax below Ruby 2.2' if RUBY_VERSION < '2.2.0'
+        "{'foo': bar}".
+          must_be_parsed_as s(:hash,
+                              s(:lit, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it 'works for a hash with splat' do
+        '{foo: bar, baz: qux, **quux}'.
+          must_be_parsed_as s(:hash,
+                              s(:lit, :foo), s(:call, nil, :bar),
+                              s(:lit, :baz), s(:call, nil, :qux),
+                              s(:kwsplat, s(:call, nil, :quux)))
+      end
     end
 
-    describe "for number literals" do
-      it "works for floats" do
-        "3.14".
+    describe 'for number literals' do
+      it 'works for floats' do
+        '3.14'.
           must_be_parsed_as s(:lit, 3.14)
       end
 
-      it "works for octal integer literals" do
-        "0700".
+      it 'works for octal integer literals' do
+        '0700'.
           must_be_parsed_as s(:lit, 448)
       end
+
+      it 'handles negative sign for integers' do
+        '-1'.
+          must_be_parsed_as s(:lit, -1)
+      end
+
+      it 'handles space after negative sign for integers' do
+        '-1 '.
+          must_be_parsed_as s(:lit, -1)
+      end
+
+      it 'handles negative sign for floats' do
+        '-3.14'.
+          must_be_parsed_as s(:lit, -3.14)
+      end
+
+      it 'handles space after negative sign for floats' do
+        '-3.14 '.
+          must_be_parsed_as s(:lit, -3.14)
+      end
+
+      it 'handles positive sign' do
+        '+1'.
+          must_be_parsed_as s(:lit, 1)
+      end
     end
   end
 end