ripper_ruby_parser 1.7.1 → 1.7.2

data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb

@@ -234,34 +234,4 @@ describe RipperRubyParser::SexpHandlers::MethodCalls do
         .must_be_parsed_as s(:call, s(:call, nil, :foo), :call)
     end
   end
-
-  describe "when processing a Sexp" do
-    let(:processor) { RipperRubyParser::SexpProcessor.new }
-
-    describe "#process_command_call" do
-      it "processes a Ruby 2.5 style period Sexp" do
-        sexp = s(:call,
-                 s(:vcall, s(:@ident, "foo", s(1, 0))),
-                 :'.',
-                 s(:@ident, "bar", s(1, 4)))
-        _(processor.process(sexp)).must_equal s(:call, s(:call, nil, :foo), :bar)
-      end
-
-      it "processes a Ruby 2.6 style period Sexp" do
-        sexp = s(:call,
-                 s(:vcall, s(:@ident, "foo", s(1, 0))),
-                 s(:@period, ".", s(1, 3)),
-                 s(:@ident, "bar", s(1, 4)))
-        _(processor.process(sexp)).must_equal s(:call, s(:call, nil, :foo), :bar)
-      end
-
-      it "raises an error for an unknown call operator" do
-        sexp = s(:call,
-                 s(:vcall, s(:@ident, "foo", s(1, 0))),
-                 :'>.',
-                 s(:@ident, "bar", s(1, 4)))
-        _(-> { processor.process(sexp) }).must_raise KeyError
-      end
-    end
-  end
 end

data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb

@@ -5,7 +5,7 @@ require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
 describe RipperRubyParser::Parser do
   describe "#parse" do
     describe "for instance method definitions" do
-      it "treats kwargs as a local variable" do
+      it "treats kwrest argument as a local variable" do
         _("def foo(**bar); bar; end")
           .must_be_parsed_as s(:defn,
                                :foo,
@@ -13,7 +13,7 @@ describe RipperRubyParser::Parser do
                                s(:lvar, :bar))
       end
 
-      it "treats kwargs as a local variable when other arguments are present" do
+      it "treats kwrest argument as a local variable when other arguments are present" do
         _("def foo(bar, **baz); baz; end")
           .must_be_parsed_as s(:defn,
                                :foo,
@@ -21,7 +21,7 @@ describe RipperRubyParser::Parser do
                                s(:lvar, :baz))
       end
 
-      it "treats kwargs as a local variable when an explicit block is present" do
+      it "treats kwrest argument as a local variable when an explicit block is present" do
         _("def foo(**bar, &baz); bar; end")
           .must_be_parsed_as s(:defn,
                                :foo,
@@ -29,7 +29,7 @@ describe RipperRubyParser::Parser do
                                s(:lvar, :bar))
       end
 
-      it "treats block kwargs as lvars" do
+      it "treats block kwrest argument as an lvar" do
         _("def foo(**bar); baz { |**qux| bar; qux }; end")
           .must_be_parsed_as s(:defn, :foo,
                                s(:args, :"**bar"),
@@ -82,6 +82,14 @@ describe RipperRubyParser::Parser do
                                s(:nil))
       end
 
+      it "works with a nameless kwrest argument" 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")
           .must_be_parsed_as s(:defn,

data/test/ripper_ruby_parser/sexp_handlers/string_literals_test.rb

@@ -0,0 +1,973 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
+
+describe RipperRubyParser::Parser do
+  let(:parser) { RipperRubyParser::Parser.new }
+
+  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 parenthesis" do
+        _('/\\)/')
+          .must_be_parsed_as s(:lit, /\)/)
+      end
+
+      it "works for regex literals with escape sequences" do
+        _('/\\)\\n\\\\/')
+          .must_be_parsed_as s(:lit, /\)\n\\/)
+      end
+
+      it "does not fix encoding" do
+        _('/2\302\275/')
+          .must_be_parsed_as s(:lit, /2\302\275/)
+      end
+
+      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")
+          .must_be_parsed_as s(:lit, /foo/x)
+      end
+
+      it "works for multi-line regex literals" do
+        _("/foo\nbar/")
+          .must_be_parsed_as s(:lit, Regexp.new("foo\nbar"))
+      end
+
+      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/ixmn")
+          .must_be_parsed_as s(:lit, /foo/mixn)
+      end
+
+      it "works with the no-encoding flag" do
+        _("/foo/n")
+          .must_be_parsed_as s(:lit, /foo/n)
+      end
+
+      it "works with line continuation" do
+        _("/foo\\\nbar/")
+          .must_be_parsed_as s(:lit, /foobar/)
+      end
+
+      describe "for a %r-delimited regex literal" do
+        it "works for the simple case with escape sequences" do
+          _('%r[foo\nbar]')
+            .must_be_parsed_as s(:lit, /foo\nbar/)
+        end
+
+        it "works for a multi-line regex" do
+          _("%r[foo\nbar]")
+            .must_be_parsed_as s(:lit, Regexp.new("foo\nbar"))
+        end
+
+        it "works with odd delimiters and escape sequences" do
+          _('%r_foo\nbar_')
+            .must_be_parsed_as s(:lit, /foo\nbar/)
+        end
+      end
+
+      describe "with interpolations" do
+        it "works for a simple interpolation" do
+          _('/foo#{bar}baz/')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 s(:str, "baz"))
+        end
+
+        it "works for a regex literal with flags and interpolation" do
+          _('/foo#{bar}/ixm')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 7)
+        end
+
+        it "works with the no-encoding flag" do
+          _('/foo#{bar}/n')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr,
+                                   s(:call, nil, :bar)), 32)
+        end
+
+        it "works with the unicode-encoding flag" do
+          _('/foo#{bar}/u')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr,
+                                   s(:call, nil, :bar)), 16)
+        end
+
+        it "works with unicode flag plus other flag" do
+          _('/foo#{bar}/un')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr,
+                                   s(:call, nil, :bar)), 48)
+        end
+
+        it "works with the euc-encoding flag" do
+          _('/foo#{bar}/e')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr,
+                                   s(:call, nil, :bar)), 16)
+        end
+
+        it "works with the sjis-encoding flag" do
+          _('/foo#{bar}/s')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr,
+                                   s(:call, nil, :bar)), 16)
+        end
+
+        it "works for a regex literal with interpolate-once flag" do
+          _('/foo#{bar}/o')
+            .must_be_parsed_as s(:dregx_once,
+                                 "foo",
+                                 s(:evstr, s(:call, nil, :bar)))
+        end
+
+        it "works with an empty interpolation" do
+          _('/foo#{}bar/')
+            .must_be_parsed_as s(:dregx,
+                                 "foo",
+                                 s(:evstr),
+                                 s(:str, "bar"))
+        end
+
+        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
+            _('/foo#{"bar"}baz/').must_be_parsed_as s(:lit, /foobarbaz/)
+          end
+
+          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
+        _("''")
+          .must_be_parsed_as s(:str, "")
+      end
+
+      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"
+      end
+
+      it "handles line breaks within double-quoted strings" do
+        _("\"foo\nbar\"")
+          .must_be_parsed_as s(:str, "foo\nbar")
+      end
+
+      it "handles line continuation with double-quoted strings" do
+        _("\"foo\\\nbar\"")
+          .must_be_parsed_as s(:str, "foobar")
+      end
+
+      it "escapes line continuation with double-quoted strings" do
+        _("\"foo\\\\\nbar\"")
+          .must_be_parsed_as s(:str, "foo\\\nbar")
+      end
+
+      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")
+        end
+
+        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 parenthesis" do
+          _('"/\\\\)/"')
+            .must_be_parsed_as s(:str, '/\\)/')
+        end
+
+        it "works for a uselessly escaped right parenthesis" do
+          _('"/\\)/"')
+            .must_be_parsed_as s(:str, "/)/")
+        end
+
+        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")
+        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")
+        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")
+
+          _('"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")
+        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")
+        end
+
+        it "works with unicode escapes" do
+          _('"foo\\u273bbar"').must_be_parsed_as s(:str, "foo✻bar")
+        end
+
+        it "works with unicode escapes with braces" do
+          _('"foo\\u{273b}bar"').must_be_parsed_as s(:str, "foo✻bar")
+        end
+
+        it "works with unicode escapes with braces with 5 hex chars" do
+          _('"foo\\u{101D1}bar"').must_be_parsed_as s(:str, "foo𐇑bar")
+        end
+
+        it "works with unicode escapes with braces with 6 hex chars" do
+          _('"foo\\u{10FFFF}bar"').must_be_parsed_as s(:str, "foo\u{10FFFF}bar")
+        end
+
+        it "converts to unicode if possible" do
+          _('"2\302\275"').must_be_parsed_as s(:str, "2½")
+        end
+
+        it "does not convert to unicode if result is not valid" do
+          _('"2\x82\302\275"')
+            .must_be_parsed_as s(:str,
+                                 (+"2\x82\xC2\xBD").force_encoding("ascii-8bit"))
+        end
+      end
+
+      describe "with interpolations 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")
+        end
+
+        it "performs the interpolation when it is at the start" do
+          _('"#{"foo"}bar"').must_be_parsed_as s(:str, "foobar")
+        end
+      end
+
+      describe "with interpolations without braces" do
+        it "works for ivars" do
+          _("\"foo\#@bar\"").must_be_parsed_as s(:dstr,
+                                                 "foo",
+                                                 s(:evstr, s(:ivar, :@bar)))
+        end
+
+        it "works for gvars" do
+          _("\"foo\#$bar\"").must_be_parsed_as s(:dstr,
+                                                 "foo",
+                                                 s(:evstr, s(:gvar, :$bar)))
+        end
+
+        it "works for cvars" do
+          _("\"foo\#@@bar\"").must_be_parsed_as s(:dstr,
+                                                  "foo",
+                                                  s(:evstr, s(:cvar, :@@bar)))
+        end
+      end
+
+      describe "with interpolations 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
+          _('"foo#{bar}"')
+            .must_be_parsed_as s(:dstr,
+                                 "foo",
+                                 s(:evstr,
+                                   s(:call, nil, :bar)))
+        end
+
+        it "works for strings with several interpolations" do
+          _('"foo#{bar}baz#{qux}"')
+            .must_be_parsed_as s(:dstr,
+                                 "foo",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 s(:str, "baz"),
+                                 s(:evstr, s(:call, nil, :qux)))
+        end
+
+        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 with an empty interpolation" do
+          _("\"foo\#{}bar\"")
+            .must_be_parsed_as s(:dstr,
+                                 "foo",
+                                 s(:evstr),
+                                 s(:str, "bar"))
+        end
+
+        it "correctly handles interpolation with __FILE__ before another interpolation" do
+          _("\"foo\#{__FILE__}\#{bar}\"")
+            .must_be_parsed_as s(:dstr,
+                                 "foo(string)",
+                                 s(:evstr, s(:call, nil, :bar)))
+        end
+
+        it "correctly handles interpolation with __FILE__ after another interpolation" do
+          _("\"\#{bar}foo\#{__FILE__}\"")
+            .must_be_parsed_as s(:dstr,
+                                 "",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 s(:str, "foo"),
+                                 s(:str, "(string)"))
+        end
+
+        it "correctly handles nested interpolation" do
+          _('"foo#{"bar#{baz}"}"')
+            .must_be_parsed_as s(:dstr,
+                                 "foobar",
+                                 s(:evstr, s(:call, nil, :baz)))
+        end
+
+        it "correctly handles consecutive nested interpolation" do
+          _('"foo#{"bar#{baz}"}foo#{"bar#{baz}"}"')
+            .must_be_parsed_as s(:dstr,
+                                 "foobar",
+                                 s(:evstr, s(:call, nil, :baz)),
+                                 s(:str, "foo"),
+                                 s(:str, "bar"),
+                                 s(:evstr, s(:call, nil, :baz)))
+        end
+      end
+
+      describe "with interpolations and escape sequences" do
+        it "works when interpolations are 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 when interpolations contain a mix of other string-like literals" do
+          _('"#{[:foo, \'bar\']}\\n"')
+            .must_be_parsed_as s(:dstr,
+                                 "",
+                                 s(:evstr, s(:array, s(:lit, :foo), s(:str, "bar"))),
+                                 s(:str, "\n"))
+        end
+
+        it "converts to unicode after interpolation" do
+          _('"#{foo}2\302\275"')
+            .must_be_parsed_as s(:dstr,
+                                 "",
+                                 s(:evstr, s(:call, nil, :foo)),
+                                 s(:str, "2½"))
+        end
+
+        it "convert single null byte to unicode after interpolation" do
+          _('"#{foo}\0"')
+            .must_be_parsed_as s(:dstr,
+                                 "",
+                                 s(:evstr, s(:call, nil, :foo)),
+                                 s(:str, "\u0000"))
+        end
+
+        it "converts string with null to unicode after interpolation" do
+          _('"#{foo}bar\0"')
+            .must_be_parsed_as s(:dstr,
+                                 "",
+                                 s(:evstr, s(:call, nil, :foo)),
+                                 s(:str, "bar\x00"))
+        end
+      end
+
+      describe "with single quoted strings" do
+        it "works with escaped single quotes" do
+          _("'foo\\'bar'")
+            .must_be_parsed_as s(:str, "foo'bar")
+        end
+
+        it "works with embedded backslashes" do
+          _("'foo\\abar'")
+            .must_be_parsed_as s(:str, 'foo\abar')
+        end
+
+        it "works with escaped embedded backslashes" do
+          _("'foo\\\\abar'")
+            .must_be_parsed_as s(:str, 'foo\abar')
+        end
+
+        it "works with sequences of backslashes" do
+          _("'foo\\\\\\abar'")
+            .must_be_parsed_as s(:str, 'foo\\\\abar')
+        end
+
+        it "does not process line continuation" do
+          _("'foo\\\nbar'")
+            .must_be_parsed_as s(:str, "foo\\\nbar")
+        end
+      end
+
+      describe "with %Q-delimited strings" do
+        it "works for the simple case" do
+          _("%Q[bar]")
+            .must_be_parsed_as s(:str, "bar")
+        end
+
+        it "works for escape sequences" do
+          _('%Q[foo\\nbar]')
+            .must_be_parsed_as s(:str, "foo\nbar")
+        end
+
+        it "works for multi-line strings" do
+          _("%Q[foo\nbar]")
+            .must_be_parsed_as s(:str, "foo\nbar")
+        end
+
+        it "handles line continuation" do
+          _("%Q[foo\\\nbar]")
+            .must_be_parsed_as s(:str, "foobar")
+        end
+      end
+
+      describe "with %q-delimited strings" do
+        it "works for the simple case" do
+          _("%q[bar]")
+            .must_be_parsed_as s(:str, "bar")
+        end
+
+        it "does not handle for escape sequences" do
+          _('%q[foo\\nbar]')
+            .must_be_parsed_as s(:str, 'foo\nbar')
+        end
+
+        it "works for multi-line strings" do
+          _("%q[foo\nbar]")
+            .must_be_parsed_as s(:str, "foo\nbar")
+        end
+
+        it "handles line continuation" do
+          _("%q[foo\\\nbar]")
+            .must_be_parsed_as s(:str, "foo\\\nbar")
+        end
+      end
+
+      describe "with %-delimited strings" do
+        it "works for the simple case" do
+          _("%(bar)")
+            .must_be_parsed_as s(:str, "bar")
+        end
+
+        it "works for escape sequences" do
+          _('%(foo\nbar)')
+            .must_be_parsed_as s(:str, "foo\nbar")
+        end
+
+        it "works for multiple lines" do
+          _("%(foo\nbar)")
+            .must_be_parsed_as s(:str, "foo\nbar")
+        end
+
+        it "works with line continuations" do
+          _("%(foo\\\nbar)")
+            .must_be_parsed_as s(:str, "foobar")
+        end
+
+        it "works for odd delimiters" do
+          _('%!foo\nbar!')
+            .must_be_parsed_as s(:str, "foo\nbar")
+        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")
+        end
+
+        it "performs the concatenation when the right string has interpolations" do
+          _("\"foo\" \"bar\#{baz}\"")
+            .must_be_parsed_as s(:dstr,
+                                 "foobar",
+                                 s(:evstr, s(:call, nil, :baz)))
+        end
+
+        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
+            _("\"foo\#{bar}\" \"baz\#{qux}\"")
+              .must_be_parsed_as s(:dstr,
+                                   "foo",
+                                   s(:evstr, s(:call, nil, :bar)),
+                                   s(:str, "baz"),
+                                   s(:evstr, s(:call, nil, :qux)))
+          end
+
+          it "removes empty substrings from the concatenation" do
+            _("\"foo\#{bar}\" \"\#{qux}\"")
+              .must_be_parsed_as s(:dstr,
+                                   "foo",
+                                   s(:evstr, s(:call, nil, :bar)),
+                                   s(:evstr, s(:call, nil, :qux)))
+          end
+        end
+      end
+
+      describe "for heredocs" do
+        it "works for the simple case" do
+          _("<<FOO\nbar\nFOO")
+            .must_be_parsed_as s(:str, "bar\n")
+        end
+
+        it "works with multiple lines" do
+          _("<<FOO\nbar\nbaz\nFOO")
+            .must_be_parsed_as s(:str, "bar\nbaz\n")
+        end
+
+        it "works for the indentable case" do
+          _("<<-FOO\n  bar\n  FOO")
+            .must_be_parsed_as s(:str, "  bar\n")
+        end
+
+        it "works for the automatically outdenting case" do
+          _("  <<~FOO\n  bar\n  FOO")
+            .must_be_parsed_as s(:str, "bar\n")
+        end
+
+        it "works for escape sequences" do
+          _("<<FOO\nbar\\tbaz\nFOO")
+            .must_be_parsed_as s(:str, "bar\tbaz\n")
+        end
+
+        it 'converts \r to carriage returns' do
+          _("<<FOO\nbar\\rbaz\\r\nFOO")
+            .must_be_parsed_as s(:str, "bar\rbaz\r\n")
+        end
+
+        it "does not unescape with single quoted version" do
+          _("<<'FOO'\nbar\\tbaz\nFOO")
+            .must_be_parsed_as s(:str, "bar\\tbaz\n")
+        end
+
+        it "works with multiple lines with the single quoted version" do
+          _("<<'FOO'\nbar\nbaz\nFOO")
+            .must_be_parsed_as s(:str, "bar\nbaz\n")
+        end
+
+        it "does not unescape with indentable single quoted version" do
+          _("<<-'FOO'\n  bar\\tbaz\n  FOO")
+            .must_be_parsed_as s(:str, "  bar\\tbaz\n")
+        end
+
+        it "does not unescape the automatically outdenting single quoted version" do
+          _("<<~'FOO'\n  bar\\tbaz\n  FOO")
+            .must_be_parsed_as s(:str, "bar\\tbaz\n")
+        end
+
+        it "handles line continuation" do
+          _("<<FOO\nbar\\\nbaz\nFOO")
+            .must_be_parsed_as s(:str, "barbaz\n")
+        end
+
+        it "escapes line continuation" do
+          _("<<FOO\nbar\\\\\nbaz\nFOO")
+            .must_be_parsed_as s(:str, "bar\\\nbaz\n")
+        end
+
+        it "converts to unicode" do
+          _("<<FOO\n2\\302\\275\nFOO")
+            .must_be_parsed_as s(:str, "2½\n")
+        end
+
+        it "handles interpolation" do
+          _("<<FOO\n\#{bar}\nFOO")
+            .must_be_parsed_as s(:dstr, "",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 s(:str, "\n"))
+        end
+
+        it "handles line continuation after interpolation" do
+          _("<<FOO\n\#{bar}\nbaz\\\nqux\nFOO")
+            .must_be_parsed_as s(:dstr, "",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 s(:str, "\nbazqux\n"))
+        end
+
+        it "handles line continuation after interpolation for the indentable case" do
+          _("<<-FOO\n\#{bar}\nbaz\\\nqux\nFOO")
+            .must_be_parsed_as s(:dstr, "",
+                                 s(:evstr, s(:call, nil, :bar)),
+                                 s(:str, "\nbazqux\n"))
+        end
+      end
+    end
+
+    describe "for word list literals with %w delimiter" do
+      it "works for the simple case" do
+        _("%w(foo bar)")
+          .must_be_parsed_as s(:array, s(:str, "foo"), s(:str, "bar"))
+      end
+
+      it "does not perform interpolation" do
+        _('%w(foo\\nbar baz)')
+          .must_be_parsed_as s(:array, s(:str, 'foo\\nbar'), s(:str, "baz"))
+      end
+
+      it "handles line continuation" do
+        _("%w(foo\\\nbar baz)")
+          .must_be_parsed_as s(:array, s(:str, "foo\nbar"), s(:str, "baz"))
+      end
+
+      it "handles escaped spaces" do
+        _('%w(foo bar\ baz)')
+          .must_be_parsed_as s(:array, s(:str, "foo"), s(:str, "bar baz"))
+      end
+    end
+
+    describe "for word list literals with %W delimiter" do
+      it "works for the simple case" do
+        _("%W(foo bar)")
+          .must_be_parsed_as s(:array, s(:str, "foo"), s(:str, "bar"))
+      end
+
+      it "handles escaped spaces" do
+        _('%W(foo bar\ baz)')
+          .must_be_parsed_as s(:array, s(:str, "foo"), s(:str, "bar baz"))
+      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"))
+      end
+
+      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"))
+      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
+
+      it "correctly handles escape sequences" do
+        _('%W(foo\nbar baz)')
+          .must_be_parsed_as s(:array,
+                               s(:str, "foo\nbar"),
+                               s(:str, "baz"))
+      end
+
+      it "converts to unicode if possible" do
+        _('%W(2\302\275)').must_be_parsed_as s(:array, s(:str, "2½"))
+      end
+
+      it "correctly handles line continuation" do
+        _("%W(foo\\\nbar baz)")
+          .must_be_parsed_as s(:array,
+                               s(:str, "foo\nbar"),
+                               s(:str, "baz"))
+      end
+
+      it "correctly handles multiple lines" do
+        _("%W(foo\nbar baz)")
+          .must_be_parsed_as s(:array,
+                               s(:str, "foo"),
+                               s(:str, "bar"),
+                               s(:str, "baz"))
+      end
+    end
+
+    describe "for symbol list literals with %i delimiter" do
+      it "works for the simple case" do
+        _("%i(foo bar)")
+          .must_be_parsed_as s(:array, s(:lit, :foo), s(:lit, :bar))
+      end
+
+      it "does not perform interpolation" do
+        _('%i(foo\\nbar baz)')
+          .must_be_parsed_as s(:array, s(:lit, :"foo\\nbar"), s(:lit, :baz))
+      end
+
+      it "handles line continuation" do
+        _("%i(foo\\\nbar baz)")
+          .must_be_parsed_as s(:array, s(:lit, :"foo\nbar"), s(:lit, :baz))
+      end
+    end
+
+    describe "for symbol list literals with %I delimiter" do
+      it "works for the simple case" do
+        _("%I(foo bar)")
+          .must_be_parsed_as s(:array, s(:lit, :foo), s(:lit, :bar))
+      end
+
+      it "correctly handles escape sequences" do
+        _('%I(foo\nbar baz)')
+          .must_be_parsed_as s(:array,
+                               s(:lit, :"foo\nbar"),
+                               s(:lit, :baz))
+      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
+
+      it "correctly handles line continuation" do
+        _("%I(foo\\\nbar baz)")
+          .must_be_parsed_as s(:array,
+                               s(:lit, :"foo\nbar"),
+                               s(:lit, :baz))
+      end
+
+      it "correctly handles multiple lines" do
+        _("%I(foo\nbar baz)")
+          .must_be_parsed_as s(:array,
+                               s(:lit, :foo),
+                               s(:lit, :bar),
+                               s(:lit, :baz))
+      end
+    end
+
+    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")
+          .must_be_parsed_as s(:lit, :@foo)
+      end
+
+      it "works for symbols that look like class names" do
+        _(":Foo")
+          .must_be_parsed_as s(:lit, :Foo)
+      end
+
+      it "works for symbols that look like keywords" do
+        _(":class").must_be_parsed_as s(:lit, :class)
+      end
+
+      it "works for :__LINE__" do
+        _(":__LINE__")
+          .must_be_parsed_as s(:lit, :__LINE__)
+      end
+
+      it "works for :__FILE__" do
+        _(":__FILE__")
+          .must_be_parsed_as s(:lit, :__FILE__)
+      end
+
+      it "works for a backtick symbol" do
+        _(":`").must_be_parsed_as s(:lit, :`)
+      end
+
+      it "works for simple dsyms" do
+        _(':"foo"')
+          .must_be_parsed_as s(:lit, :foo)
+      end
+
+      it "works for dsyms with interpolations" do
+        _(':"foo#{bar}"')
+          .must_be_parsed_as s(:dsym,
+                               "foo",
+                               s(:evstr, s(:call, nil, :bar)))
+      end
+
+      it "works for dsyms with interpolations at the start" do
+        _(':"#{bar}"')
+          .must_be_parsed_as s(:dsym,
+                               "",
+                               s(:evstr, s(:call, nil, :bar)))
+      end
+
+      it "works for dsyms with escape sequences" do
+        _(':"foo\nbar"')
+          .must_be_parsed_as s(:lit, :"foo\nbar")
+      end
+
+      it "works for dsyms with multiple lines" do
+        _(":\"foo\nbar\"")
+          .must_be_parsed_as s(:lit, :"foo\nbar")
+      end
+
+      it "works for dsyms with line continuations" do
+        _(":\"foo\\\nbar\"")
+          .must_be_parsed_as s(:lit, :foobar)
+      end
+
+      it "works with single quoted dsyms" do
+        _(":'foo'")
+          .must_be_parsed_as s(:lit, :foo)
+      end
+
+      it "works with single quoted dsyms with escaped single quotes" do
+        _(":'foo\\'bar'")
+          .must_be_parsed_as s(:lit, :'foo\'bar')
+      end
+
+      it "works with single quoted dsyms with multiple lines" do
+        _(":'foo\nbar'")
+          .must_be_parsed_as s(:lit, :"foo\nbar")
+      end
+
+      it "works with single quoted dsyms with line continuations" do
+        _(":'foo\\\nbar'")
+          .must_be_parsed_as s(:lit, :"foo\\\nbar")
+      end
+
+      it "works with single quoted dsyms with embedded backslashes" do
+        _(":'foo\\abar'")
+          .must_be_parsed_as s(:lit, :"foo\\abar")
+      end
+
+      it "works with barewords that need to be interpreted as symbols" do
+        _("alias foo bar")
+          .must_be_parsed_as s(:alias,
+                               s(:lit, :foo), s(:lit, :bar))
+      end
+
+      it "assigns a line number to the result" do
+        result = parser.parse ":foo"
+        _(result.line).must_equal 1
+      end
+    end
+
+    describe "for backtick string literals" do
+      it "works for basic backtick strings" do
+        _("`foo`")
+          .must_be_parsed_as s(:xstr, "foo")
+      end
+
+      it "works for interpolated backtick strings" do
+        _('`foo#{bar}`')
+          .must_be_parsed_as s(:dxstr,
+                               "foo",
+                               s(:evstr, s(:call, nil, :bar)))
+      end
+
+      it "works for backtick strings interpolated at the start" do
+        _('`#{foo}`')
+          .must_be_parsed_as s(:dxstr, "",
+                               s(:evstr, s(:call, nil, :foo)))
+      end
+
+      it "works for backtick strings with escape sequences" do
+        _('`foo\\n`')
+          .must_be_parsed_as s(:xstr, "foo\n")
+      end
+
+      it "works for backtick strings with multiple lines" do
+        _("`foo\nbar`")
+          .must_be_parsed_as s(:xstr, "foo\nbar")
+      end
+
+      it "works for backtick strings with line continuations" do
+        _("`foo\\\nbar`")
+          .must_be_parsed_as s(:xstr, "foobar")
+      end
+    end
+  end
+end