opal 0.5.5 → 0.6.0

data/spec/opal/parser/super_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe "The super keyword" do
-  it "should return s(:super) for any arguments" do
-    opal_parse("super 1").should == [:super, [:arglist, [:int, 1]]]
-    opal_parse("super 1, 2").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
-    opal_parse("super 1, *2").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
-  end
-
-  it "should set nil for args when no arguments or parans" do
-    opal_parse("super").should == [:super, nil]
-  end
-
-  it "should always return s(:super) with :arglist when parans are used" do
-    opal_parse("super()").should == [:super, [:arglist]]
-    opal_parse("super(1)").should == [:super, [:arglist, [:int, 1]]]
-    opal_parse("super(1, 2)").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
-    opal_parse("super(1, *2)").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
-  end
-end

data/spec/opal/parser/true_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe "The true keyword" do
-  it "always returns s(:true)" do
-    opal_parse("true").should == [:true]
-  end
-
-  it "cannot be assigned to" do
-    lambda {
-      opal_parse "true = 1"
-    }.should raise_error(Exception)
-
-    lambda {
-      opal_parse "true = true"
-    }.should raise_error(Exception)
-  end
-end

data/spec/opal/parser/undef_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe "The undef keyword" do
-  it "returns s(:undef) with the argument as an s(:lit)" do
-    opal_parse("undef a").should == [:undef, [:sym, :a]]
-  end
-
-  it "appends multiple parts onto end of list" do
-    opal_parse("undef a, b").should == [:undef, [:sym, :a], [:sym, :b]]
-  end
-
-  it "can take symbols or fitems" do
-    opal_parse("undef :foo").should == [:undef, [:sym, :foo]]
-  end
-end

data/spec/opal/parser/unless_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "The unless keyword" do
-  it "returns s(:if) with reversed true and false bodies" do
-    opal_parse("unless 10; 20; end").should == [:if, [:int, 10], nil, [:int, 20]]
-    opal_parse("unless 10; 20; 30; end").should == [:if, [:int, 10], nil, [:block, [:int, 20], [:int, 30]]]
-    opal_parse("unless 10; 20; else; 30; end").should == [:if, [:int, 10], [:int, 30], [:int, 20]]
-  end
-
-  it "returns s(:if) with reversed true and false bodies for prefix unless" do
-    opal_parse("20 unless 10").should == [:if, [:int, 10], nil, [:int, 20]]
-  end
-end

data/spec/opal/parser/while_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe "The while keyword" do
-  it "returns an s(:while) with the given expr, body and true for head" do
-    opal_parse("while 1; 2; end").should == [:while, [:int, 1], [:int, 2], true]
-  end
-
-  it "uses an s(:block) if body has more than one statement" do
-    opal_parse("while 1; 2; 3; end").should == [:while, [:int, 1], [:block, [:int, 2], [:int, 3]], true]
-  end
-
-  it "treats the prefix while statement just like a regular while statement" do
-    opal_parse("1 while 2").should == [:while, [:int, 2], [:int, 1], true]
-  end
-end

data/spec/opal/parser/xstr_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-describe "x-strings" do
-  it "parses simple xstring as s(:xstr)" do
-    opal_parse("`foo`").should == [:xstr, "foo"]
-  end
-
-  it "parses new lines within xstring" do
-    opal_parse("`\nfoo\n\nbar`").should == [:xstr, "\nfoo\n\nbar"]
-  end
-
-  it "allows interpolation within xstring" do
-    opal_parse('`#{bar}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]]]
-    opal_parse('`#{bar}#{baz}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]], [:evstr, [:call, nil, :baz, [:arglist]]]]
-  end
-
-  it "supports ivar interpolation" do
-    opal_parse('`#@foo`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
-    opal_parse('`#@foo.bar`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]], [:str, ".bar"]]
-  end
-
-  it "supports gvar interpolation" do
-    opal_parse('`#$foo`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
-    opal_parse('`#$foo.bar`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]], [:str, ".bar"]]
-  end
-
-  it "supports cvar interpolation" do
-    opal_parse('`#@@foo`').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
-  end
-
-  it "correctly parses block braces within interpolations" do
-    opal_parse('`#{ each { nil } }`').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-  end
-
-  it "parses xstrings within interpolations" do
-    opal_parse('`#{ `bar` }`').should == [:dxstr, "", [:evstr, [:xstr, "bar"]]]
-  end
-
-  it "parses multiple levels of interpolation" do
-    opal_parse('`#{ `#{`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
-      opal_parse('%x{foo}').should == [:xstr, "foo"]
-      opal_parse('%x[foo]').should == [:xstr, "foo"]
-      opal_parse('%x(foo)').should == [:xstr, "foo"]
-    end
-
-    it "can parse empty strings" do
-      opal_parse('%x{}').should == [:xstr, ""]
-      opal_parse('%x[]').should == [:xstr, ""]
-      opal_parse('%x()').should == [:xstr, ""]
-    end
-
-    it "should allow interpolation" do
-      opal_parse('%x{#{foo}}').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      opal_parse('%x[#{foo}]').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      opal_parse('%x(#{foo})').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    end
-
-    it "should allow ivar, gvar and cvar interpolation" do
-      opal_parse('%x{#@foo}').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
-      opal_parse('%x{#$foo}').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
-      opal_parse('%x{#@@foo}').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
-    end
-
-    it "should match '{' and '}' pairs used to start string before ending match" do
-      opal_parse('%x{{}}').should == [:xstr, "{}"]
-      opal_parse('%x{foo{bar}baz}').should == [:xstr, "foo{bar}baz"]
-      opal_parse('%x{{foo}bar}').should == [:xstr, "{foo}bar"]
-      opal_parse('%x{foo{bar}}').should == [:xstr, "foo{bar}"]
-      opal_parse('%x{foo#{bar}baz}').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      opal_parse('%x{a{b{c}d{e}f}g}').should == [:xstr, "a{b{c}d{e}f}g"]
-      opal_parse('%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
-      opal_parse('%x(())').should == [:xstr, "()"]
-      opal_parse('%x(foo(bar)baz)').should == [:xstr, "foo(bar)baz"]
-      opal_parse('%x((foo)bar)').should == [:xstr, "(foo)bar"]
-      opal_parse('%x(foo(bar))').should == [:xstr, "foo(bar)"]
-      opal_parse('%x(foo#{bar}baz)').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      opal_parse('%x(a(b(c)d(e)f)g)').should == [:xstr, "a(b(c)d(e)f)g"]
-      opal_parse('%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
-      opal_parse('%x[[]]').should == [:xstr, "[]"]
-      opal_parse('%x[foo[bar]baz]').should == [:xstr, "foo[bar]baz"]
-      opal_parse('%x[[foo]bar]').should == [:xstr, "[foo]bar"]
-      opal_parse('%x[foo[bar]]').should == [:xstr, "foo[bar]"]
-      opal_parse('%x[foo#{bar}baz]').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      opal_parse('%x[a[b[c]d[e]f]g]').should == [:xstr, "a[b[c]d[e]f]g"]
-      opal_parse('%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
-      opal_parse('%x{#{each { nil } }}').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-    end
-
-    it "parses other Xstrings within interpolations" do
-      opal_parse('%x{#{ %x{} }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
-      opal_parse('%x{#{ `` }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
-      opal_parse('%x{#{ `foo` }}').should == [:dxstr, "", [:evstr, [:xstr, "foo"]]]
-    end
-  end
-
-  describe "cannot be created with %X notation" do
-    it "should not parse" do
-      lambda {
-        opal_parse('%X{}')
-      }.should raise_error(Exception)
-    end
-  end
-end

data/spec/opal/parser/yield_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe "The yield keyword" do
-  it "should return s(:yield) when no arguments given" do
-    opal_parse("yield").should == [:yield]
-  end
-
-  it "appends arguments onto end of s(:yield) without an arglist" do
-    opal_parse("yield 1").should == [:yield, [:int, 1]]
-    opal_parse("yield 1, 2").should == [:yield, [:int, 1], [:int, 2]]
-    opal_parse("yield 1, *2").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
-  end
-
-  it "accepts parans for any number of arguments" do
-    opal_parse("yield()").should == [:yield]
-    opal_parse("yield(1)").should == [:yield, [:int, 1]]
-    opal_parse("yield(1, 2)").should == [:yield, [:int, 1], [:int, 2]]
-    opal_parse("yield(1, *2)").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
-  end
-end