opal 0.10.6 → 0.11.0.rc1

data/spec/lib/parser/literal_spec.rb

@@ -1,118 +0,0 @@
-require 'support/parser_helpers'
-
-describe Opal::Parser do
-
-  it "parses true keyword" do
-    parsed("true").should == [:true]
-  end
-
-  it "true cannot be assigned to" do
-    lambda {
-      parsed "true = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses false keyword" do
-    parsed("false").should == [:false]
-  end
-
-  it "false cannot be assigned to" do
-    lambda {
-      parsed "true = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses nil keyword" do
-    parsed("nil").should == [:nil]
-  end
-
-  it "nil cannot be assigned to" do
-    lambda {
-      parsed "nil = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses self keyword" do
-    parsed("self").should == [:self]
-  end
-
-  it "self cannot be assigned to" do
-    lambda {
-      parsed "self = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses __FILE__ and should always return a s(:str) with given parser filename" do
-    parsed("__FILE__", "foo").should == [:str, "foo"]
-  end
-
-  it "parses __LINE__ and should always return a literal number of the current line" do
-    parsed("__LINE__").should == [:int, 1]
-    parsed("\n__LINE__").should == [:int, 2]
-  end
-
-  it "parses integers as a s(:int) sexp" do
-    parsed("32").should == [:int, 32]
-  end
-
-  it "parses floats as a s(:float)" do
-    parsed("3.142").should == [:float, 3.142]
-  end
-
-  describe "parsing arrays" do
-    it "should parse empty arrays as s(:array)" do
-      parsed("[]").should == [:array]
-    end
-
-    it "should append regular args onto end of array sexp" do
-      parsed("[1]").should == [:array, [:int, 1]]
-      parsed("[1, 2]").should == [:array, [:int, 1], [:int, 2]]
-      parsed("[1, 2, 3]").should == [:array, [:int, 1], [:int, 2], [:int, 3]]
-    end
-
-    it "should return a single item s(:array) with given splat if no norm args" do
-      parsed("[*1]").should == [:array, [:splat, [:int, 1]]]
-    end
-
-    it "should allow splats combined with any number of norm args" do
-      parsed("[1, *2]").should == [:array, [:int, 1], [:splat, [:int, 2]]]
-      parsed("[1, 2, *3]").should == [:array, [:int, 1], [:int, 2], [:splat, [:int, 3]]]
-    end
-  end
-
-  describe "parsing hashes" do
-    it "without any assocs should return an empty hash sexp" do
-      parsed("{}").should == [:hash]
-    end
-
-    it "adds each assoc pair as individual args onto sexp" do
-      parsed("{1 => 2}").should == [:hash, [:int, 1], [:int, 2]]
-      parsed("{1 => 2, 3 => 4}").should == [:hash, [:int, 1], [:int, 2], [:int, 3], [:int, 4]]
-    end
-
-    it "supports 1.9 style hash keys" do
-      parsed("{ a: 1 }").should == [:hash, [:sym, :a], [:int, 1]]
-      parsed("{ a: 1, b: 2 }").should == [:hash, [:sym, :a], [:int, 1], [:sym, :b], [:int, 2]]
-    end
-
-    it "parses hash arrows without spaces around arguments" do
-      parsed("{1=>2}").should == [:hash, [:int, 1], [:int, 2]]
-      parsed("{:foo=>2}").should == [:hash, [:sym, :foo], [:int, 2]]
-    end
-  end
-
-  describe "parsing regexps" do
-    it "parses a regexp" do
-      parsed("/lol/").should == [:regexp, 'lol', nil]
-    end
-
-    it "parses regexp options" do
-      parsed("/lol/i").should == [:regexp, 'lol', 'i']
-    end
-
-    it "can parse regexps using %r notation" do
-      parsed('%r(foo)').should == [:regexp, 'foo', nil]
-      parsed('%r(foo)i').should == [:regexp, 'foo', 'i']
-    end
-  end
-end

data/spec/lib/parser/masgn_spec.rb

@@ -1,37 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Masgn" do
-  describe "with a single lhs splat" do
-    it "returns a s(:masgn)" do
-      parsed('*a = 1, 2').first.should == :masgn
-      parsed('* = 1, 2').first.should == :masgn
-    end
-
-    it "wraps splat inside a s(:array)" do
-      parsed('*a = 1, 2')[1].should == [:array, [:splat, [:lasgn, :a]]]
-      parsed('* = 1, 2')[1].should == [:array, [:splat]]
-    end
-  end
-
-  describe "with more than 1 lhs item" do
-    it "returns a s(:masgn) " do
-      parsed('a, b = 1, 2').first.should == :masgn
-    end
-
-    it "collects all lhs args into an s(:array)" do
-      parsed('a, b = 1, 2')[1].should == [:array, [:lasgn, :a], [:lasgn, :b]]
-      parsed('@a, @b = 1, 2')[1].should == [:array, [:iasgn, :@a], [:iasgn, :@b]]
-    end
-
-    it "supports splat parts" do
-      parsed('a, *b = 1, 2')[1].should == [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]
-      parsed('@a, * = 1, 2')[1].should == [:array, [:iasgn, :@a], [:splat]]
-    end
-  end
-
-  describe "with a single rhs argument" do
-    it "should wrap rhs in an s(:to_ary)" do
-      parsed('a, b = 1')[2].should == [:to_ary, [:int, 1]]
-    end
-  end
-end

data/spec/lib/parser/module_spec.rb

@@ -1,27 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The module keyword" do
-  it "returns an empty s(:block) when given an empty body" do
-    parsed('module A; end').should == [:module, [:const, :A], [:block]]
-  end
-
-  it "does not place single expressions into a s(:block)" do
-    parsed('module A; 1; end').should == [:module, [:const, :A], [:int, 1]]
-  end
-
-  it "adds multiple body expressions into a s(:block)" do
-    parsed('module A; 1; 2; end').should == [:module, [:const, :A], [:block, [:int, 1], [:int, 2]]]
-  end
-
-  it "should accept just a constant for the module name" do
-    parsed('module A; end')[1].should == [:const, :A]
-  end
-
-  it "should accept a prefix constant for the module name" do
-    parsed('module ::A; end')[1].should == [:colon3, :A]
-  end
-
-  it "should accepts a nested constant for the module name" do
-    parsed('module A::B; end')[1].should == [:colon2, [:const, :A], :B]
-  end
-end

data/spec/lib/parser/not_spec.rb

@@ -1,21 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The not keyword" do
-  it "returns a call sexp" do
-    parsed("not self").should == [:call, [:self], '!'.to_sym, [:arglist]]
-    parsed("not 42").should == [:call, [:int, 42], '!'.to_sym, [:arglist]]
-  end
-end
-
-describe "The '!' expression" do
-  it "returns a call sexp" do
-    parsed("!self").should == [:call, [:self], '!'.to_sym, [:arglist]]
-    parsed("!42").should == [:call, [:int, 42], '!'.to_sym, [:arglist]]
-  end
-end
-
-describe "The '!~' expression" do
-  it "does not rewrite as !(lhs =~ rhs)" do
-    parsed("1 !~ 2").should == [:call, [:int, 1], :!~, [:arglist, [:int, 2]]]
-  end
-end

data/spec/lib/parser/op_asgn1_spec.rb

@@ -1,23 +0,0 @@
-require 'support/parser_helpers'
-
-describe "op_asgn1" do
-  it "returns s(:op_asgn1)" do
-    parsed('self[:foo] += 1')[0].should == :op_asgn1
-  end
-
-  it "correctly assigns the receiver" do
-    parsed("self[:foo] += 1")[1].should == [:self]
-  end
-
-  it "returns an arglist for args inside braces" do
-    parsed("self[:foo] += 1")[2].should == [:arglist, [:sym, :foo]]
-  end
-
-  it "only uses the operator, not with '=' appended" do
-    parsed("self[:foo] += 1")[3].should == '+'
-  end
-
-  it "uses a simple sexp, not an arglist" do
-    parsed("self[:foo] += 1")[4].should == [:int, 1]
-  end
-end

data/spec/lib/parser/op_asgn2_spec.rb

@@ -1,23 +0,0 @@
-require 'support/parser_helpers'
-
-describe "op_asgn2" do
-  it "returns s(:op_asgn2)" do
-    parsed('self.foo += 1')[0].should == :op_asgn2
-  end
-
-  it "correctly assigns the receiver" do
-    parsed("self.foo += 1")[1].should == [:self]
-  end
-
-  it "appends '=' onto the identifier in the sexp" do
-    parsed("self.foo += 1")[2].should == :foo=
-  end
-
-  it "only uses the operator, not with '=' appended" do
-    parsed("self.foo += 1")[3].should == :+
-  end
-
-  it "uses a simple sexp, not an arglist" do
-    parsed("self.foo += 1")[4].should == [:int, 1]
-  end
-end

data/spec/lib/parser/op_asgn_spec.rb

@@ -1,17 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Operator assignment statements on local variables" do
-  it "parses |= with a lvar on the left and parenthesized expr on the right" do
-    # regression test; see GH issue 995
-    asgn = [:lasgn, :var, [:int, 1]]
-    opasgn = [:lasgn, :var, [:call, [:lvar, :var], :|, [:arglist, [:paren, [:int, 1]]]]]
-    parsed('var = 1; var |= (1)').should == [:block, asgn, opasgn]
-  end
-
-  it "parses >>= with a lvar on the left and parenthesized expr on the right" do
-    # regression test; see GH issue 995
-    asgn = [:lasgn, :var, [:int, 1]]
-    opasgn = [:lasgn, :var, [:call, [:lvar, :var], :>>, [:arglist, [:paren, [:int, 1]]]]]
-    parsed('var = 1; var >>= (1)').should == [:block, asgn, opasgn]
-  end
-end

data/spec/lib/parser/or_spec.rb

@@ -1,13 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The or statement" do
-  it "should always return s(:or)" do
-    parsed("1 or 2").should == [:or, [:int, 1], [:int, 2]]
-  end
-end
-
-describe "The || expression" do
-  it "should always return s(:or)" do
-    parsed("1 || 2").should == [:or, [:int, 1], [:int, 2]]
-  end
-end

data/spec/lib/parser/return_spec.rb

@@ -1,22 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The return keyword" do
-  it "should return s(:return) when given no arguments" do
-    parsed("return").should == [:return]
-  end
-
-  it "returns s(:return) with the direct argument when given one argument" do
-    parsed("return 1").should == [:return, [:int, 1]]
-    parsed("return *2").should == [:return, [:splat, [:int, 2]]]
-  end
-
-  it "returns s(:return) with an s(:array) when args size > 1" do
-    parsed("return 1, 2").should == [:return, [:array, [:int, 1], [:int, 2]]]
-    parsed("return 1, *2").should == [:return, [:array, [:int, 1], [:splat, [:int, 2]]]]
-  end
-
-  it "can handle a %{string literal with percent syntax}" do
-    # regression test; see GH issue 1089
-    parsed("return %{a}").should == [:return, [:str, "a"]]
-  end
-end

data/spec/lib/parser/sclass_spec.rb

@@ -1,21 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Singleton classes" do
-  it "returns an empty s(:block) when given an empty body" do
-    parsed('class << A; end')[2].should == [:block]
-  end
-
-  it "does not place single expressions into an s(:block)" do
-    parsed('class << A; 1; end')[2].should == [:int, 1]
-  end
-
-  it "adds multiple body expressions into a s(:block)" do
-    parsed('class << A; 1; 2; end')[2].should == [:block, [:int, 1], [:int, 2]]
-  end
-
-  it "should accept any expressions for singleton part" do
-    parsed('class << A; end').should == [:sclass, [:const, :A], [:block]]
-    parsed('class << self; end').should == [:sclass, [:self], [:block]]
-  end
-end
-

data/spec/lib/parser/string_spec.rb

@@ -1,286 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Strings" do
-  it "parses empty strings" do
-    parsed('""').should == [:str, ""]
-    parsed("''").should == [:str, ""]
-  end
-
-  it "parses a simple string without interpolation as s(:str)" do
-    parsed('"foo # { } bar"').should == [:str, "foo # { } bar"]
-  end
-
-  it "does not interpolate with single quotes" do
-    parsed("'\#{foo}'").should == [:str, "\#{foo}"]
-    parsed("'\#@foo'").should == [:str, "\#@foo"]
-    parsed("'\#$foo'").should == [:str, "\#$foo"]
-    parsed("'\#@@foo'").should == [:str, "\#@@foo"]
-  end
-
-  it "supports interpolation with double quotes" do
-    parsed('"#{foo}"').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    parsed('"#@foo"').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
-    parsed('"#$foo"').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
-    parsed('"#@@foo"').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
-  end
-
-  it "allows underscores in ivar, gvar and cvar interpolation" do
-    parsed('"#@foo_bar"').should == [:dstr, "", [:evstr, [:ivar, :@foo_bar]]]
-    parsed('"#$foo_bar"').should == [:dstr, "", [:evstr, [:gvar, :$foo_bar]]]
-    parsed('"#@@foo_bar"').should == [:dstr, "", [:evstr, [:cvar, :@@foo_bar]]]
-  end
-
-  describe "from %Q construction" do
-    it "can use '[', '(', '{' or '<' matching pairs for string boundry" do
-      parsed('%Q{foo}').should == [:str, "foo"]
-      parsed('%Q[foo]').should == [:str, "foo"]
-      parsed('%Q(foo)').should == [:str, "foo"]
-      parsed('%Q<foo>').should == [:str, "foo"]
-    end
-
-    it "can use valid characters as string boundrys" do
-      parsed('%q!Ford!').should == [:str, 'Ford']
-      parsed('%qaForda').should == [:str, 'Ford']
-      parsed('%q?Ford?').should == [:str, 'Ford']
-    end
-
-    it "can parse empty strings" do
-      parsed('%Q{}').should == [:str, ""]
-      parsed('%Q[]').should == [:str, ""]
-      parsed('%Q()').should == [:str, ""]
-    end
-
-    it "should allow interpolation" do
-      parsed('%Q(#{foo})').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%Q[#{foo}]').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%Q{#{foo}}').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    end
-
-    it "should allow ivar, gvar and cvar interpolation" do
-      parsed('%Q{#@foo}').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
-      parsed('%Q{#$foo}').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
-      parsed('%Q{#@@foo}').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
-    end
-
-    it "should match '{' and '}' pairs used to start string before ending match" do
-      parsed('%Q{{}}').should == [:str, "{}"]
-      parsed('%Q{foo{bar}baz}').should == [:str, "foo{bar}baz"]
-      parsed('%Q{{foo}bar}').should == [:str, "{foo}bar"]
-      parsed('%Q{foo{bar}}').should == [:str, "foo{bar}"]
-      parsed('%Q{foo#{bar}baz}').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%Q{a{b{c}d{e}f}g}').should == [:str, "a{b{c}d{e}f}g"]
-      parsed('%Q{a{b{c}#{foo}d}e}').should == [:dstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
-    end
-
-    it "should match '(' and ')' pairs used to start string before ending match" do
-      parsed('%Q(())').should == [:str, "()"]
-      parsed('%Q(foo(bar)baz)').should == [:str, "foo(bar)baz"]
-      parsed('%Q((foo)bar)').should == [:str, "(foo)bar"]
-      parsed('%Q(foo(bar))').should == [:str, "foo(bar)"]
-      parsed('%Q(foo#{bar}baz)').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%Q(a(b(c)d(e)f)g)').should == [:str, "a(b(c)d(e)f)g"]
-      parsed('%Q(a(b(c)#{foo}d)e)').should == [:dstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
-    end
-
-    it "should match '[' and ']' pairs used to start string before ending match" do
-      parsed('%Q[[]]').should == [:str, "[]"]
-      parsed('%Q[foo[bar]baz]').should == [:str, "foo[bar]baz"]
-      parsed('%Q[[foo]bar]').should == [:str, "[foo]bar"]
-      parsed('%Q[foo[bar]]').should == [:str, "foo[bar]"]
-      parsed('%Q[foo#{bar}baz]').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%Q[a[b[c]d[e]f]g]').should == [:str, "a[b[c]d[e]f]g"]
-      parsed('%Q[a[b[c]#{foo}d]e]').should == [:dstr, "a[b[c]", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d]e"]]
-    end
-
-    it "correctly parses block braces within interpolations" do
-      parsed('%Q{#{each { nil } }}').should == [:dstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-    end
-
-    it "parses other Qstrings within interpolations" do
-      parsed('%Q{#{ %Q{} }}').should == [:dstr, "", [:evstr, [:str, ""]]]
-    end
-  end
-
-  describe "from character shortcuts" do
-    it "produces a string sexp" do
-      parsed("?a").should == [:str, "a"]
-      parsed("?&").should == [:str, "&"]
-    end
-
-    it "parses escape sequences" do
-      parsed("?\\n").should == [:str, "\n"]
-      parsed("?\\t").should == [:str, "\t"]
-    end
-
-    it "parses a string sexp as a command arg" do
-      parsed("foo ?a").should == [:call, nil, :foo, [:arglist, [:str, "a"]]]
-    end
-  end
-
-  it "parses %[] strings" do
-    parsed('%[]').should == [:str, '']
-    parsed('%[foo]').should == [:str, 'foo']
-  end
-
-  it "parses %<> strings" do
-    parsed('%<>').should == [:str, '']
-    parsed('%<foo>').should == [:str, 'foo']
-  end
-
-  it "parses %&& strings" do
-    parsed('%&&').should == [:str, '']
-    parsed('%&foo&').should == [:str, 'foo']
-  end
-end
-
-
-describe "x-strings" do
-  it "parses simple xstring as s(:xstr)" do
-    parsed("`foo`").should == [:xstr, "foo"]
-  end
-
-  it "parses new lines within xstring" do
-    parsed("`\nfoo\n\nbar`").should == [:xstr, "\nfoo\n\nbar"]
-  end
-
-  it "allows interpolation within xstring" do
-    parsed('`#{bar}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]]]
-    parsed('`#{bar}#{baz}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]], [:evstr, [:call, nil, :baz, [:arglist]]]]
-  end
-
-  it "supports ivar interpolation" do
-    parsed('`#@foo`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
-    parsed('`#@foo.bar`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]], [:str, ".bar"]]
-  end
-
-  it "supports gvar interpolation" do
-    parsed('`#$foo`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
-    parsed('`#$foo.bar`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]], [:str, ".bar"]]
-  end
-
-  it "supports cvar interpolation" do
-    parsed('`#@@foo`').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
-  end
-
-  it "correctly parses block braces within interpolations" do
-    parsed('`#{ each { nil } }`').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-  end
-
-  it "parses xstrings within interpolations" do
-    parsed('`#{ `bar` }`').should == [:dxstr, "", [:evstr, [:xstr, "bar"]]]
-  end
-
-  it "parses multiple levels of interpolation" do
-    parsed('`#{ `#{`bar`}` }`').should == [:dxstr, "", [:evstr, [:dxstr, "", [:evstr, [:xstr, "bar"]]]]]
-  end
-
-  describe "created using %x notation" do
-    it "can use '[', '(' or '{' matching pairs for string boundry" do
-      parsed('%x{foo}').should == [:xstr, "foo"]
-      parsed('%x[foo]').should == [:xstr, "foo"]
-      parsed('%x(foo)').should == [:xstr, "foo"]
-    end
-
-    it "can parse empty strings" do
-      parsed('%x{}').should == [:xstr, ""]
-      parsed('%x[]').should == [:xstr, ""]
-      parsed('%x()').should == [:xstr, ""]
-    end
-
-    it "should allow interpolation" do
-      parsed('%x{#{foo}}').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%x[#{foo}]').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%x(#{foo})').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    end
-
-    it "should allow ivar, gvar and cvar interpolation" do
-      parsed('%x{#@foo}').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
-      parsed('%x{#$foo}').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
-      parsed('%x{#@@foo}').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
-    end
-
-    it "should match '{' and '}' pairs used to start string before ending match" do
-      parsed('%x{{}}').should == [:xstr, "{}"]
-      parsed('%x{foo{bar}baz}').should == [:xstr, "foo{bar}baz"]
-      parsed('%x{{foo}bar}').should == [:xstr, "{foo}bar"]
-      parsed('%x{foo{bar}}').should == [:xstr, "foo{bar}"]
-      parsed('%x{foo#{bar}baz}').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%x{a{b{c}d{e}f}g}').should == [:xstr, "a{b{c}d{e}f}g"]
-      parsed('%x{a{b{c}#{foo}d}e}').should == [:dxstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
-    end
-
-    it "should match '(' and ')' pairs used to start string before ending match" do
-      parsed('%x(())').should == [:xstr, "()"]
-      parsed('%x(foo(bar)baz)').should == [:xstr, "foo(bar)baz"]
-      parsed('%x((foo)bar)').should == [:xstr, "(foo)bar"]
-      parsed('%x(foo(bar))').should == [:xstr, "foo(bar)"]
-      parsed('%x(foo#{bar}baz)').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%x(a(b(c)d(e)f)g)').should == [:xstr, "a(b(c)d(e)f)g"]
-      parsed('%x(a(b(c)#{foo}d)e)').should == [:dxstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
-    end
-
-    it "should match '[' and ']' pairs used to start string before ending match" do
-      parsed('%x[[]]').should == [:xstr, "[]"]
-      parsed('%x[foo[bar]baz]').should == [:xstr, "foo[bar]baz"]
-      parsed('%x[[foo]bar]').should == [:xstr, "[foo]bar"]
-      parsed('%x[foo[bar]]').should == [:xstr, "foo[bar]"]
-      parsed('%x[foo#{bar}baz]').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%x[a[b[c]d[e]f]g]').should == [:xstr, "a[b[c]d[e]f]g"]
-      parsed('%x[a[b[c]#{foo}d]e]').should == [:dxstr, "a[b[c]", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d]e"]]
-    end
-
-    it "correctly parses block braces within interpolations" do
-      parsed('%x{#{each { nil } }}').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-    end
-
-    it "parses other Xstrings within interpolations" do
-      parsed('%x{#{ %x{} }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
-      parsed('%x{#{ `` }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
-      parsed('%x{#{ `foo` }}').should == [:dxstr, "", [:evstr, [:xstr, "foo"]]]
-    end
-  end
-
-  describe "cannot be created with %X notation" do
-    it "should not parse" do
-      lambda {
-        parsed('%X{}')
-      }.should raise_error(Exception)
-    end
-  end
-
-  describe "contiguous strings" do
-    it "concatenates parts" do
-      parsed('"a" "b"').should == [:dstr, "a", [:str, "b"]]
-    end
-  end
-
-end
-
-describe "Heredocs" do
-
-  it "parses as a s(:str)" do
-    parsed("a = <<-FOO\nbar\nFOO")[2].should == [:str, "bar\n"]
-  end
-
-  it "allows start marker to be wrapped in quotes" do
-    parsed("a = <<-'FOO'\nbar\nFOO")[2].should == [:str, "bar\n"]
-    parsed("a = <<-\"FOO\"\nbar\nFOO")[2].should == [:str, "bar\n"]
-  end
-
-  it "does not parse EOS unless beginning of line" do
-    parsed("<<-FOO\ncontentFOO\nFOO").should == [:str, "contentFOO\n"]
-  end
-
-  it "does not parse EOS unless end of line" do
-    parsed("<<-FOO\nsome FOO content\nFOO").should == [:str, "some FOO content\n"]
-  end
-
-  it "parses postfix code as if it appeared after heredoc" do
-    parsed("<<-FOO.class\ncode\nFOO").should == [:call, [:str, "code\n"], :class, [:arglist]]
-    parsed("bar(<<-FOO, 1, 2, 3)\ncode\nFOO").should == [:call, nil, :bar,
-                                                              [:arglist, [:str, "code\n"],
-                                                                         [:int, 1],
-                                                                         [:int, 2],
-                                                                         [:int, 3]]]
-  end
-end