opal-wedge 0.9.0.dev

data/spec/opal/core/language/versions/array_1.9.rb

@@ -0,0 +1,39 @@
+describe "Array literals" do
+  it "[] accepts a literal hash without curly braces as its last parameter" do
+    ["foo", "bar" => :baz].should == ["foo", {"bar" => :baz}]
+    [1, 2, 3 => 6, 4 => 24].should == [1, 2, {3 => 6, 4 => 24}]
+  end
+
+  it "[] treats splatted nil as no element" do
+    [*nil].should == []
+    [1, *nil].should == [1]
+    [1, 2, *nil].should == [1, 2]
+    [1, *nil, 3].should == [1, 3]
+    [*nil, *nil, *nil].should == []
+  end
+end
+
+describe "The unpacking splat operator (*)" do
+  it "when applied to a non-Array value attempts to coerce it to Array if the object respond_to?(:to_a)" do
+    obj = mock("pseudo-array")
+    obj.should_receive(:to_a).and_return([2, 3, 4])
+    [1, *obj].should == [1, 2, 3, 4]
+  end
+
+  it "when applied to a non-Array value uses it unchanged if it does not respond_to?(:to_a)" do
+    obj = Object.new
+    obj.should_not respond_to(:to_a)
+    [1, *obj].should == [1, obj]
+  end
+
+  it "can be used before other non-splat elements" do
+    a = [1, 2]
+    [0, *a, 3].should == [0, 1, 2, 3]
+  end
+
+  it "can be used multiple times in the same containing array" do
+    a = [1, 2]
+    b = [1, 0]
+    [*a, 3, *a, *b].should == [1, 2, 3, 1, 2, 1, 0]
+  end
+end

data/spec/opal/core/language/versions/case_1.9.rb

@@ -0,0 +1,20 @@
+describe "The 'case'-construct" do
+  it "takes multiple expanded arrays" do
+    a1 = ['f', 'o', 'o']
+    a2 = ['b', 'a', 'r']
+
+    case 'f'
+      when *a1, *['x', 'y', 'z']
+        "foo"
+      when *a2, *['x', 'y', 'z']
+        "bar"
+    end.should == "foo"
+
+    case 'b'
+      when *a1, *['x', 'y', 'z']
+        "foo"
+      when *a2, *['x', 'y', 'z']
+        "bar"
+    end.should == "bar"
+  end
+end

data/spec/opal/core/language/versions/def_2_0_spec.rb

@@ -0,0 +1,62 @@
+# TODO: this should be loaded from rubyspec instead
+
+describe "An instance method with keyword arguments" do
+  context "when there is a single keyword argument" do
+    before do
+      def foo(a: 1)
+        a
+      end
+    end
+
+    it "evaluates to the default when a value isn't provided" do
+      foo.should == 1
+    end
+
+    it "evaluates to the provided value" do
+      foo(a: 20).should == 20
+      foo(a: nil).should be_nil
+    end
+
+    it "raises an argument error when an unknown keyword argument is provided" do
+      lambda { foo(b: 20) }.should raise_error(ArgumentError)
+    end
+
+    it "raises an argument error when a non-keyword argument is provided" do
+      lambda { foo(1) }.should raise_error(ArgumentError)
+    end
+  end
+
+  it "treats a sole hash argument correctly" do
+    def foo(a, b: 10)
+      [a, b]
+    end
+    foo(b: "b").should == [{:b => "b"}, 10]
+    foo("a", b: "b").should == ["a", "b"]
+  end
+
+  it "correctly distinguishes between optional and keyword arguments" do
+    def foo(a = true, b: 10)
+      [a, b]
+    end
+    foo(b: 42).should == [true, 42]
+    foo(false, b: 42).should == [false, 42]
+  end
+
+  it "correctly distinguishes between rest and keyword arguments" do
+    def foo(*a, b: 10)
+      [a, b]
+    end
+    foo(1, 2, 3, 4).should == [[1, 2, 3, 4], 10]
+    foo(1, 2, 3, 4, b: 42).should == [[1, 2, 3, 4], 42]
+    foo(b: 42).should == [[], 42]
+  end
+
+  it "should allow keyword rest arguments" do
+    def foo(a: 1, **b)
+      [a, b]
+    end
+    foo(b: 2, c: 3, d: 4).should == [1, {:b => 2, :c => 3, :d => 4}]
+    foo(a: 4, b: 2).should == [4, {:b => 2}]
+    foo.should == [1, {}]
+  end
+end

data/spec/opal/core/language/versions/hash_1.9.rb

@@ -0,0 +1,18 @@
+describe "Hash literal" do
+  describe "new-style hash syntax" do
+    it "constructs a new hash with the given elements" do
+      {foo: 123}.should == {:foo => 123}
+      {rbx: :cool, specs: 'fail_sometimes'}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
+    end
+
+    it "ignores a hanging comma" do
+      {foo: 123,}.should == {:foo => 123}
+      {rbx: :cool, specs: 'fail_sometimes',}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
+    end
+
+    it "can mix and match syntax styles" do
+      {rbx: :cool, :specs => 'fail_sometimes'}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
+      {'rbx' => :cool, specs: 'fail_sometimes'}.should == {'rbx' => :cool, :specs => 'fail_sometimes'}
+    end
+  end
+end

data/spec/opal/core/language/versions/literal_lambda_1.9.rb

@@ -0,0 +1,143 @@
+require File.join(File.dirname(__FILE__), '../fixtures/literal_lambda')
+
+describe "->(){}" do
+  it "can be specified as a literal" do
+    lambda { ->(){} }.should_not raise_error
+  end
+
+  it "returns a Proc object" do
+    ->(){}.should be_an_instance_of(Proc)
+  end
+
+  it "returns a lambda" do
+    ->(){}.lambda?.should be_true
+  end
+
+  it "can be assigned to a variable" do
+    var = ->(){}
+    var.lambda?.should be_true
+  end
+
+  it "understands a do/end block in place of {}" do
+    lambda do
+      ->() do
+      end
+    end.should_not raise_error(SyntaxError)
+  end
+
+  it "requires an associated block" do
+    lambda { eval "->()" }.should raise_error(SyntaxError)
+    lambda { eval "->" }.should raise_error(SyntaxError)
+  end
+
+  it "can be interpolated into a String" do
+    "1+2=#{->{ 1 + 2}.call}".should == "1+2=3"
+  end
+
+  it "can be be used as a Hash key" do
+    h = new_hash
+    # h[->(one=1){ one + 2}.call] = :value
+    h.key?(3).should be_true
+  end
+
+  it "can be used in method parameter lists" do
+    def glark7654(a=-> { :foo   })
+      a.call
+    end
+    glark7654.should == :foo
+  end
+
+  it "accepts an parameter list between the parenthesis" do
+    lambda { ->(a) {} }.should_not raise_error(SyntaxError)
+    lambda { ->(a,b) {} }.should_not raise_error(SyntaxError)
+  end
+
+  it "accepts an empty parameter list" do
+    lambda { ->() {} }.should_not raise_error(SyntaxError)
+  end
+
+  it "allows the parenthesis to be omitted entirely" do
+    lambda { -> {} }.should_not raise_error(SyntaxError)
+    lambda { ->{} }.should_not raise_error(SyntaxError)
+    lambda do
+      -> do
+      end
+    end.should_not raise_error(SyntaxError)
+    ->{}.should be_an_instance_of(Proc)
+  end
+
+  it "aliases each argument to the corresponding parameter" do
+    ->(a) {a}.call(:sym).should == :sym
+    ->(a,b) {[a, b]}.call(:sym, :bol).should == [:sym, :bol]
+  end
+
+  it "accepts parameters with default parameters between the parenthesis" do
+    # lambda { ->(a=1) {} }.should_not raise_error(SyntaxError)
+    # lambda { ->(x=1, b=[]) {} }.should_not raise_error(SyntaxError)
+  end
+
+  it "aliases each argument with a default value to the corresponding parameter" do
+    # ->(a=:cymbal) {a}.call(:sym).should == :sym
+    # ->(a,b=:cymbal) {[a, b]}.call(:sym, :bol).should == [:sym, :bol]
+  end
+
+  it "sets arguments to their default value if one wasn't supplied" do
+    # ->(a=:cymbal) {a}.call.should == :cymbal
+    # ->(a,b=:cymbal) {[a, b]}.call(:sym).should == [:sym, :cymbal]
+  end
+
+  it "accepts a parameter prefixed with an asterisk between the parenthesis" do
+    # lambda { ->(*a) {} }.should_not raise_error(SyntaxError)
+    # lambda { ->(x, *a) {} }.should_not raise_error(SyntaxError)
+  end
+
+  it "assigns all remaining arguments to the variable in the parameter list prefixed with an asterisk, if one exists" do
+    # ->(*a) {a}.call(:per, :cus, :si, :on).should == [:per, :cus, :si, :on]
+    # ->(a,*b) {b}.call(:per, :cus, :si, :on).should == [:cus, :si, :on]
+  end
+
+  it "accepts a parameter prefixed with an ampersand between the parenthesis" do
+    # lambda { ->(&a) {} }.should_not raise_error(SyntaxError)
+    # lambda { ->(x, &a) {} }.should_not raise_error(SyntaxError)
+  end
+
+  it "assigns the given block to the parameter prefixed with an ampersand if such a parameter exists" do
+    # l = ->(&a) { a }.call { :foo }
+    l.call.should == :foo
+  end
+
+  it "assigns nil to the parameter prefixed with an ampersand unless a block was supplied" do
+    # ->(&a) { a }.call.should be_nil
+  end
+
+  it "accepts a combination of argument types between the parenthesis" do
+    # lambda { ->(x, y={}, z  = Object.new, *a, &b) {} }.
+      should_not raise_error(SyntaxError)
+  end
+
+  it "sets parameters appropriately when a combination of parameter types is given between the parenthesis" do
+    # l = ->(x, y={}, z  = Object.new, *a, &b) { [x,y,z,a,b]}
+    l.call(1, [], [], 30, 40).should == [1, [], [], [30, 40], nil]
+    block = lambda { :lamb }
+    l.call(1, [], [], 30, 40, &block).last.should be_an_instance_of(Proc)
+    # l2 = ->(x, y={}, *a) { [x, y, a]}
+    l2.call(:x).should == [:x, {}, []]
+  end
+
+  it "uses lambda's 'rigid' argument handling" do
+    ->(a, b){}.parameters.first.first.should == :req
+    ->(a, b){}.parameters.last.first.should == :req
+    lambda { ->(a, b){}.call 1 }.should raise_error(ArgumentError)
+  end
+
+  it "does not call the associated block" do
+    @called = false
+    ->() { @called = true }
+    @called.should be_false
+  end
+
+  it "evaluates constants as normal blocks do" do
+    l = LiteralLambdaMethods.literal_lambda_with_constant
+    l.().should == "some value"
+  end
+end

data/spec/opal/core/language/versions/not_1.9.rb

@@ -0,0 +1,22 @@
+describe "not()" do
+  # not(arg).method and method(not(arg)) raise SyntaxErrors on 1.8. Here we
+  # use #inspect to test that the syntax works on 1.9
+
+  it "can be used as a function" do
+    lambda do
+      not(true).inspect
+    end.should_not raise_error(SyntaxError)
+  end
+
+  it "returns false if the argument is true" do
+    not(true).inspect.should == "false"
+  end
+
+  it "returns true if the argument is false" do
+    not(false).inspect.should == "true"
+  end
+
+  it "returns true if the argument is nil" do
+    not(nil).inspect.should == "true"
+  end
+end

data/spec/opal/core/language/versions/send_1.9.rb

@@ -0,0 +1,241 @@
+# FIXME: Add error case
+#
+require File.expand_path("../../fixtures/send_1.9.rb", __FILE__)
+require 'language/fixtures/send_1.9'
+
+specs = LangSendSpecs
+
+describe "Invoking a method" do
+  describe "with required args after the rest arguments" do
+    it "binds the required arguments first" do
+      specs.fooM0RQ1(1).should == [[], 1]
+      specs.fooM0RQ1(1,2).should == [[1], 2]
+      specs.fooM0RQ1(1,2,3).should == [[1,2], 3]
+
+      specs.fooM1RQ1(1,2).should == [1, [], 2]
+      specs.fooM1RQ1(1,2,3).should == [1, [2], 3]
+      specs.fooM1RQ1(1,2,3,4).should == [1, [2, 3], 4]
+
+      specs.fooM1O1RQ1(1,2).should == [1, 9, [], 2]
+      specs.fooM1O1RQ1(1,2,3).should == [1, 2, [], 3]
+      specs.fooM1O1RQ1(1,2,3,4).should == [1, 2, [3], 4]
+
+      specs.fooM1O1RQ2(1,2,3).should == [1, 9, [], 2, 3]
+      specs.fooM1O1RQ2(1,2,3,4).should == [1, 2, [], 3, 4]
+      specs.fooM1O1RQ2(1,2,3,4,5).should == [1, 2, [3], 4, 5]
+    end
+  end
+
+  describe "with manditory arguments after optional arguments" do
+    it "binds the required arguments first" do
+      specs.fooO1Q1(0,1).should == [0,1]
+      specs.fooO1Q1(2).should == [1,2]
+
+      specs.fooM1O1Q1(2,3,4).should == [2,3,4]
+      specs.fooM1O1Q1(1,3).should == [1,2,3]
+
+      specs.fooM2O1Q1(1,2,4).should == [1,2,3,4]
+
+      specs.fooM2O2Q1(1,2,3,4,5).should == [1,2,3,4,5]
+      specs.fooM2O2Q1(1,2,3,5).should == [1,2,3,4,5]
+      specs.fooM2O2Q1(1,2,5).should == [1,2,3,4,5]
+
+      specs.fooO4Q1(1,2,3,4,5).should == [1,2,3,4,5]
+      specs.fooO4Q1(1,2,3,5).should == [1,2,3,4,5]
+      specs.fooO4Q1(1,2,5).should == [1,2,3,4,5]
+      specs.fooO4Q1(1,5).should == [1,2,3,4,5]
+      specs.fooO4Q1(5).should == [1,2,3,4,5]
+
+      specs.fooO4Q2(1,2,3,4,5,6).should == [1,2,3,4,5,6]
+      specs.fooO4Q2(1,2,3,5,6).should == [1,2,3,4,5,6]
+      specs.fooO4Q2(1,2,5,6).should == [1,2,3,4,5,6]
+      specs.fooO4Q2(1,5,6).should == [1,2,3,4,5,6]
+      specs.fooO4Q2(5,6).should == [1,2,3,4,5,6]
+    end
+  end
+
+  it "with .() invokes #call" do
+    q = proc { |z| z }
+    q.(1).should == 1
+
+    obj = mock("paren call")
+    obj.should_receive(:call).and_return(:called)
+    obj.().should == :called
+  end
+
+  it "allows a vestigial trailing ',' in the arguments" do
+    # specs.fooM1(1,).should == [1]
+  end
+
+  it "with splat operator attempts to coerce it to an Array if the object respond_to?(:to_a)" do
+    ary = [2,3,4]
+    obj = mock("to_a")
+    obj.should_receive(:to_a).and_return(ary).twice
+    specs.fooM0R(*obj).should == ary
+    specs.fooM1R(1,*obj).should == [1, ary]
+  end
+
+  it "with splat operator * and non-Array value uses value unchanged if it does not respond_to?(:to_ary)" do
+    obj = Object.new
+    obj.should_not respond_to(:to_a)
+
+    specs.fooM0R(*obj).should == [obj]
+    specs.fooM1R(1,*obj).should == [1, [obj]]
+  end
+
+  it "accepts additional arguments after splat expansion" do
+    a = [1,2]
+    specs.fooM4(*a,3,4).should == [1,2,3,4]
+    specs.fooM4(0,*a,3).should == [0,1,2,3]
+  end
+
+  it "accepts final explicit literal Hash arguments after the splat" do
+    a = [1, 2]
+    specs.fooM0RQ1(*a, { :a => 1 }).should == [[1, 2], { :a => 1 }]
+  end
+
+  it "accepts final implicit literal Hash arguments after the splat" do
+    a = [1, 2]
+    specs.fooM0RQ1(*a, :a => 1).should == [[1, 2], { :a => 1 }]
+  end
+
+  it "accepts final Hash arguments after the splat" do
+    a = [1, 2]
+    b = { :a => 1 }
+    specs.fooM0RQ1(*a, b).should == [[1, 2], { :a => 1 }]
+  end
+
+  it "accepts mandatory and explicit literal Hash arguments after the splat" do
+    a = [1, 2]
+    specs.fooM0RQ2(*a, 3, { :a => 1 }).should == [[1, 2], 3, { :a => 1 }]
+  end
+
+  it "accepts mandatory and implicit literal Hash arguments after the splat" do
+    a = [1, 2]
+    specs.fooM0RQ2(*a, 3, :a => 1).should == [[1, 2], 3, { :a => 1 }]
+  end
+
+  it "accepts mandatory and Hash arguments after the splat" do
+    a = [1, 2]
+    b = { :a => 1 }
+    specs.fooM0RQ2(*a, 3, b).should == [[1, 2], 3, { :a => 1 }]
+  end
+
+  it "converts a final splatted explicit Hash to an Array" do
+    a = [1, 2]
+    specs.fooR(*a, 3, *{ :a => 1 }).should == [1, 2, 3, [:a, 1]]
+  end
+
+  it "calls #to_a to convert a final splatted Hash object to an Array" do
+    a = [1, 2]
+    b = { :a => 1 }
+    b.should_receive(:to_a).and_return([:a, 1])
+
+    specs.fooR(*a, 3, *b).should == [1, 2, 3, :a, 1]
+  end
+
+  it "accepts multiple splat expansions in the same argument list" do
+    a = [1,2,3]
+    b = 7
+    c = mock("pseudo-array")
+    c.should_receive(:to_a).and_return([0,0])
+
+    d = [4,5]
+    specs.rest_len(*a,*d,6,*b).should == 7
+    specs.rest_len(*a,*a,*a).should == 9
+    specs.rest_len(0,*a,4,*5,6,7,*c,-1).should == 11
+  end
+
+  it "expands an array to arguments grouped in parentheses" do
+    specs.destructure2([40,2]).should == 42
+  end
+
+  it "expands an array to arguments grouped in parentheses and ignores any rest arguments in the array" do
+    specs.destructure2([40,2,84]).should == 42
+  end
+
+  it "expands an array to arguments grouped in parentheses and sets not specified arguments to nil" do
+    specs.destructure2b([42]).should == [42, nil]
+  end
+
+  it "expands an array to arguments grouped in parentheses which in turn takes rest arguments" do
+    specs.destructure4r([1, 2, 3]).should == [1, 2, [], 3, nil]
+    specs.destructure4r([1, 2, 3, 4]).should == [1, 2, [], 3, 4]
+    specs.destructure4r([1, 2, 3, 4, 5]).should == [1, 2, [3], 4, 5]
+  end
+
+  describe "new-style hash arguments" do
+    describe "as the only parameter" do
+      it "passes without curly braces" do
+        specs.fooM1(rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
+          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "passes without curly braces or parens" do
+        (specs.fooM1 rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
+          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "handles a hanging comma without curly braces" do
+        # specs.fooM1(abc: 123,).should == [{:abc => 123}]
+        # specs.fooM1(rbx: 'cool', specs: :fail_sometimes, non_sym: 1234,).should ==
+          # [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+    end
+
+    describe "as the last parameter" do
+      it "passes without curly braces" do
+        specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
+          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "passes without curly braces or parens" do
+        (specs.fooM3 'abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
+          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "handles a hanging comma without curly braces" do
+        # specs.fooM3('abc', 123, abc: 123,).should == ['abc', 123, {:abc => 123}]
+        # specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234,).should ==
+          # ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+    end
+  end
+
+  describe "mixed new- and old-style hash arguments" do
+    describe "as the only parameter" do
+      it "passes without curly braces" do
+        specs.fooM1(rbx: 'cool', :specs => :fail_sometimes, non_sym: 1234).should ==
+          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "passes without curly braces or parens" do
+        (specs.fooM1 :rbx => 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
+          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "handles a hanging comma without curly braces" do
+        # specs.fooM1(rbx: 'cool', specs: :fail_sometimes, :non_sym => 1234,).should ==
+          # [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+    end
+
+    describe "as the last parameter" do
+      it "passes without curly braces" do
+        specs.fooM3('abc', 123, rbx: 'cool', :specs => :fail_sometimes, non_sym: 1234).should ==
+          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "passes without curly braces or parens" do
+        (specs.fooM3 'abc', 123, :rbx => 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
+          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+
+      it "handles a hanging comma without curly braces" do
+        # specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, :non_sym => 1234,).should ==
+          # ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
+      end
+    end
+  end
+
+end