opal-wedge 0.9.0.dev

data/spec/lib/parser/iter_spec.rb

@@ -0,0 +1,59 @@
+require 'support/parser_helpers'
+
+describe "Iters" do
+  describe "Iter on a command" do
+    it "the outer command call gets the iter" do
+      parsed("a b do; end").should == [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]], [:iter, nil]]
+      parsed("a 1, b do; end").should == [:call, nil, :a, [:arglist, [:int, 1], [:call, nil, :b, [:arglist]]], [:iter, nil]]
+    end
+  end
+
+  describe "with no args" do
+    it "has 'nil' as the args part of sexp" do
+      parsed("proc do; end")[4][1].should == nil
+    end
+  end
+
+  describe "with empty || args" do
+    it "should have args set to nil" do
+      parsed("proc do ||; end")[4][1].should == nil
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      parsed("proc do |a|; end")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      parsed("proc do |a, b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      parsed("proc do |a, b, c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with splat arg" do
+    it "adds a s(:masgn) for the s(:splat) even if its the only arg" do
+      parsed("proc do |*a|; end")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      parsed("proc do |a, *b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+  end
+
+  describe "with opt args" do
+    it "adds a s(:block) arg to end of s(:masgn) for each lasgn" do
+      parsed("proc do |a = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      parsed("proc do |a = 1, b = 2|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "should add lasgn block after all other args" do
+      parsed("proc do |a, b = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
+      parsed("proc do |b = 1, *c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+      parsed("proc do |b = 1, &c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+    end
+  end
+
+  describe "with block arg" do
+    it "should add block arg with s(:block_pass) wrapping s(:lasgn) prefix" do
+      parsed("proc do |&a|; end")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+end

data/spec/lib/parser/lambda_spec.rb

@@ -0,0 +1,64 @@
+require 'support/parser_helpers'
+
+describe "Lambda literals" do
+  it "should parse with either do/end construct or curly braces" do
+    parsed("-> {}").first.should == :call
+    parsed("-> do; end").first.should == :call
+  end
+
+  it "should parse as a call to 'lambda' with the lambda body as a block" do
+    parsed("-> {}").should == [:call, nil, :lambda, [:arglist], [:iter, nil]]
+  end
+
+  describe "with no args" do
+    it "should accept no args" do
+      parsed("-> {}")[4][1].should == nil
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      parsed("->(a) {}")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      parsed("-> (a, b) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      parsed("-> (a, b, c) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with optional braces" do
+    it "parses normal args" do
+      parsed("-> a {}")[4][1].should == [:lasgn, :a]
+      parsed("-> a, b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+    end
+
+    it "parses splat args" do
+      parsed("-> *a {}")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      parsed("-> a, *b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+
+    it "parses opt args" do
+      parsed("-> a = 1 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      parsed("-> a = 1, b = 2 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "parses block args" do
+      parsed("-> &a {}")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+
+  describe "with body statements" do
+    it "should be nil when no statements given" do
+      parsed("-> {}")[4][2].should == nil
+    end
+
+    it "should be the single sexp when given one statement" do
+      parsed("-> { 42 }")[4][2].should == [:int, 42]
+    end
+
+    it "should wrap multiple statements into a s(:block)" do
+      parsed("-> { 42; 3.142 }")[4][2].should == [:block, [:int, 42], [:float, 3.142]]
+    end
+  end
+end

data/spec/lib/parser/literal_spec.rb

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,21 @@
+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 "rewrites as !(lhs =~ rhs)" do
+    parsed("1 !~ 2").should == [:not, [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]]
+  end
+end

data/spec/lib/parser/op_asgn1_spec.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,23 @@
+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/or_spec.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,17 @@
+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
+end

data/spec/lib/parser/sclass_spec.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,276 @@
+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
+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