opal 0.10.0 → 0.11.0

data/spec/opal/core/language/proc_spec.rb

@@ -1,263 +0,0 @@
-describe "A Proc" do
-  it "captures locals from the surrounding scope" do
-    var = 1
-    lambda { var }.call.should == 1
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "overwrites a captured local when used as an argument" do
-      var = 1
-      lambda { |var| var }.call(2).should == 2
-      var.should == 2
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "does not capture a local when an argument has the same name" do
-      var = 1
-      lambda { |var| var }.call(2).should == 2
-      var.should == 1
-    end
-  end
-
-  describe "taking zero arguments" do
-    before :each do
-      @l = lambda { 1 }
-    end
-
-    it "does not raise an exception if no values are passed" do
-      @l.call.should == 1
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "does not raise an exception if a value is passed" do
-        @l.call(0).should == 1
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "raises an ArgumentErro if a value is passed" do
-        lambda { @l.call(0) }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "taking || arguments" do
-    before :each do
-      @l = lambda { || 1 }
-    end
-
-    it "does not raise an exception when passed no values" do
-      @l.call.should == 1
-    end
-
-    it "raises an ArgumentError if a value is passed" do
-      lambda { @l.call(0) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "taking |a| arguments" do
-    before :each do
-      @l = lambda { |a| a }
-    end
-
-    it "assigns the value passed to the argument" do
-      @l.call(2).should == 2
-    end
-
-    it "does not destructure a single Array value" do
-      @l.call([1, 2]).should == [1, 2]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should equal(obj)
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "assigns nil to the argument if no value is passed" do
-        @l.call.should be_nil
-      end
-
-      it "assigns all the values passed to the argument as an Array" do
-        @l.call(1, 2).should == [1, 2]
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "raises an ArgumentError if no value is passed" do
-        lambda { @l.call }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "taking |a, b| arguments" do
-    before :each do
-      @l = lambda { |a, b| [a, b] }
-    end
-
-    it "raises an ArgumentError if passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError if passed one value" do
-      lambda { @l.call(0) }.should raise_error(ArgumentError)
-    end
-
-    it "assigns the values passed to the arguments" do
-      @l.call(1, 2).should == [1, 2]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("proc call to_ary")
-      obj.should_not_receive(:to_ary)
-
-      lambda { @l.call(obj) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "taking |a, *b| arguments" do
-    before :each do
-      @l = lambda { |a, *b| [a, b] }
-    end
-
-    it "raises an ArgumentError if passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    it "does not destructure a single Array value yielded" do
-      @l.call([1, 2, 3]).should == [[1, 2, 3], []]
-    end
-
-    it "assigns all passed values after the first to the rest argument" do
-        @l.call(1, 2, 3).should == [1, [2, 3]]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == [obj, []]
-    end
-  end
-
-  describe "taking |*| arguments" do
-    before :each do
-      # @l = lambda { |*| 1 }
-    end
-
-    it "does not raise an exception when passed no values" do
-      @l.call.should == 1
-    end
-
-    it "does not raise an exception when passed multiple values" do
-      @l.call(2, 3, 4).should == 1
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == 1
-    end
-  end
-
-  describe "taking |*a| arguments" do
-    before :each do
-      @l = lambda { |*a| a }
-    end
-
-    it "assigns [] to the argument when passed no values" do
-      @l.call.should == []
-    end
-
-    it "assigns the argument an Array wrapping one passed value" do
-      @l.call(1).should == [1]
-    end
-
-    it "assigns the argument an Array wrapping all values passed" do
-      @l.call(1, 2, 3).should == [1, 2, 3]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == [obj]
-    end
-  end
-
-  describe "taking |a, | arguments" do
-    before :each do
-      # @l = lambda { |a, | a }
-    end
-
-    it "raises an ArgumentError when passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError when passed more than one value" do
-      lambda { @l.call(1, 2) }.should raise_error(ArgumentError)
-    end
-
-    it "assigns the argument the value passed" do
-      @l.call(1).should == 1
-    end
-
-    it "does not destructure when passed a single Array" do
-      @l.call([1,2]).should == [1, 2]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == obj
-    end
-  end
-
-  describe "taking |(a, b)| arguments" do
-    before :each do
-      # @l = lambda { |(a, b)| [a, b] }
-    end
-
-    it "raises an ArgumentError when passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "raises an ArgumentError when passed a single Array" do
-        lambda { @l.call([1, 2]) }.should raise_error(ArgumentError)
-      end
-
-      it "raises an ArgumentError when passed a single object" do
-        obj = mock("block yield to_ary")
-        obj.should_not_receive(:to_ary)
-
-        lambda { @l.call(obj) }.should raise_error(ArgumentError)
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "destructures a single Array value yielded" do
-        @l.call([1, 2]).should == [1, 2]
-      end
-
-      it "calls #to_ary to convert a single passed object to an Array" do
-        obj = mock("block yield to_ary")
-        obj.should_receive(:to_ary).and_return([1, 2])
-
-        @l.call(obj).should == [1, 2]
-      end
-
-      it "raises an TypeError if #to_ary does not return an Array" do
-        obj = mock("block yield to_ary invalid")
-        obj.should_receive(:to_ary).and_return(1)
-
-        lambda { @l.call(obj) }.should raise_error(TypeError)
-      end
-    end
-  end
-end

data/spec/opal/core/language/regexp_spec.rb

@@ -1,20 +0,0 @@
-describe "Literal Regexps" do
-  it "yields a Regexp" do
-    /Hello/.should be_kind_of(Regexp)
-  end
-end
-
-describe "Regexps with interpolation" do
-  it "allows interpolation of strings" do
-    str = "foo|bar"
-    /#{str}/.should == /foo|bar/
-  end
-
-  it "allows interpolation to interact with other Regexp constructs" do
-    str = "foo)|(bar"
-    /(#{str})/.should == /(foo)|(bar)/
-
-    str = "a"
-    /[#{str}-z]/.should == /[a-z]/
-  end
-end

data/spec/opal/core/language/rescue_spec.rb

@@ -1,18 +0,0 @@
-describe 'rescue' do
-  it 'wraps a try{}catch{} to a function when there is a method call on returning value' do
-    begin
-      1 + 1
-    rescue
-    end.should == 2
-  end
-
-  it 'explicitely adds return to the rescue part when there is ensure statement' do
-    begin
-      1 + 1
-    rescue
-      3
-    ensure
-      4
-    end.should == 2
-  end
-end

data/spec/opal/core/language/send_spec.rb

@@ -1,230 +0,0 @@
-require File.expand_path('../fixtures/send', __FILE__)
-
-# Why so many fixed arg tests?  JRuby and I assume other Ruby impls have
-# separate call paths for simple fixed arity methods.  Testing up to five
-# will verify special and generic arity code paths for all impls.
-#
-# Method naming conventions:
-# M - Manditory Args
-# O - Optional Arg
-# R - Rest Arg
-# Q - Post Manditory Args (1.9)
-
-specs = LangSendSpecs
-
-describe "Invoking a method" do
-  describe "with zero arguments" do
-    it "requires no arguments passed" do
-      specs.fooM0.should == 100
-    end
-
-    it "raises ArgumentError if the method has a positive arity" do
-      lambda {
-        specs.fooM1
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "with only manditory arguments" do
-    it "requires exactly the same number of passed values" do
-      specs.fooM1(1).should == [1]
-      specs.fooM2(1,2).should == [1,2]
-      specs.fooM3(1,2,3).should == [1,2,3]
-      specs.fooM4(1,2,3,4).should == [1,2,3,4]
-      specs.fooM5(1,2,3,4,5).should == [1,2,3,4,5]
-    end
-
-    it "raises ArgumentError if the methods arity doesn't match" do
-      lambda {
-        specs.fooM1(1,2)
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "with optional arguments" do
-    it "uses the optional argument if none is is passed" do
-      specs.fooM0O1.should == [1]
-    end
-
-    it "uses the passed argument if available" do
-      specs.fooM0O1(2).should == [2]
-    end
-
-    it "raises ArgumentError if extra arguments are passed" do
-      lambda {
-        specs.fooM0O1(2,3)
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "with manditory and optional arguments" do
-    it "uses the passed values in left to right order" do
-      specs.fooM1O1(2).should == [2,1]
-    end
-
-    it "raises an ArgumentError if there are no values for the manditory args" do
-      lambda {
-        specs.fooM1O1
-      }.should raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError if too many values are passed" do
-      lambda {
-        specs.fooM1O1(1,2,3)
-      }.should raise_error(ArgumentError)
-    end
-    
-    it "keeps the block if supplied" do
-      block = lambda {}
-      specs.fooM1O2(1, foo: :bar, &block).should == [1, {foo: :bar}, block]
-    end
-  end
-
-  describe "with a rest argument" do
-    it "is an empty array if there are no additional arguments" do
-      specs.fooM0R().should == []
-      specs.fooM1R(1).should == [1, []]
-    end
-
-    it "gathers unused arguments" do
-      specs.fooM0R(1).should == [1]
-      specs.fooM1R(1,2).should == [1, [2]]
-    end
-  end
-
-  it "with a block makes it available to yield" do
-    specs.oneb(10) { 200 }.should == [10,200]
-  end
-
-  it "with a block converts the block to a Proc" do
-    prc = specs.makeproc { "hello" }
-    prc.should be_kind_of(Proc)
-    prc.call.should == "hello"
-  end
-
-  it "with an object as a block uses 'to_proc' for coercion" do
-    o = LangSendSpecs::ToProc.new(:from_to_proc)
-
-    specs.makeproc(&o).call.should == :from_to_proc
-
-    specs.yield_now(&o).should == :from_to_proc
-  end
-
-  it "raises a SyntaxError with both a literal block and an object as block" do
-    lambda {
-      eval "specs.oneb(10, &l){ 42 }"
-    }.should raise_error(SyntaxError)
-  end
-
-  it "with same names as existing variables is ok" do
-    foobar = 100
-
-    def foobar; 200; end
-
-    foobar.should == 100
-    foobar().should == 200
-  end
-
-  it "with splat operator makes the object the direct arguments" do
-    a = [1,2,3]
-    specs.fooM3(*a).should == [1,2,3]
-  end
-
-  it "without parentheses works" do
-    (specs.fooM3 1,2,3).should == [1,2,3]
-  end
-
-  it "with a space separating method name and parenthesis treats expression in parenthesis as first argument" do
-    specs.weird_parens().should == "55"
-  end
-
-  ruby_version_is "" ... "1.9" do
-    describe "allows []=" do
-      before :each do
-        @obj = LangSendSpecs::AttrSet.new
-      end
-
-      it "with *args in the [] expanded to individual arguments" do
-        ary = [2,3]
-        (@obj[1, *ary] = 4).should == 4
-        @obj.result.should == [1,2,3,4]
-      end
-
-      it "with multiple *args" do
-        ary = [2,3]
-        post = [4,5]
-        (@obj[1, *ary] = *post).should == [4,5]
-        @obj.result.should == [1,2,3,[4,5]]
-      end
-
-      it "with multiple *args and unwraps the last splat" do
-        ary = [2,3]
-        post = [4]
-        (@obj[1, *ary] = *post).should == 4
-        @obj.result.should == [1,2,3,4]
-      end
-
-      it "with a *args and multiple rhs args" do
-        ary = [2,3]
-        (@obj[1, *ary] = 4, 5).should == [4,5]
-        @obj.result.should == [1,2,3,[4,5]]
-      end
-    end
-  end
-
-  it "passes literal hashes without curly braces as the last parameter" do
-    specs.fooM3('abc', 456, 'rbx' => 'cool',
-         'specs' => 'fail sometimes', 'oh' => 'weh').should == \
-     ['abc', 456, {'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
-  end
-
-  it "passes a literal hash without curly braces or parens" do
-    (specs.fooM3 'abc', 456, 'rbx' => 'cool',
-        'specs' => 'fail sometimes', 'oh' => 'weh').should == \
-     ['abc', 456, { 'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
-  end
-
-  it "allows to literal hashes without curly braces as the only parameter" do
-    specs.fooM1(:rbx => :cool, :specs => :fail_sometimes).should ==
-      [{ :rbx => :cool, :specs => :fail_sometimes }]
-
-    (specs.fooM1 :rbx => :cool, :specs => :fail_sometimes).should ==
-      [{ :rbx => :cool, :specs => :fail_sometimes }]
-  end
-
-  describe "when the method is not available" do
-    it "invokes method_missing" do
-      o = LangSendSpecs::MethodMissing.new
-      o.not_there(1,2)
-      o.message.should == :not_there
-      o.args.should == [1,2]
-    end
-  end
-
-end
-
-describe "Invoking a private setter method" do
-  describe "permits self as a receiver" do
-    it "for normal assignment" do
-      receiver = LangSendSpecs::PrivateSetter.new
-      receiver.call_self_foo_equals(42)
-      receiver.foo.should == 42
-    end
-
-    it "for multiple assignment" do
-      receiver = LangSendSpecs::PrivateSetter.new
-      receiver.call_self_foo_equals_masgn(42)
-      receiver.foo.should == 42
-    end
-  end
-end
-
-describe "Invoking a private getter method" do
-  it "does not permit self as a receiver" do
-    receiver = LangSendSpecs::PrivateGetter.new
-    lambda { receiver.call_self_foo }.should raise_error(NoMethodError)
-    lambda { receiver.call_self_foo_or_equals(6) }.should raise_error(NoMethodError)
-  end
-end
-
-# language_version __FILE__, "send"

data/spec/opal/core/language/string_spec.rb

@@ -1,44 +0,0 @@
-describe "Ruby character strings" do
-  it "are produced from character shortcuts" do
-    ?z.should == 'z'
-  end
-
-  it "should parse string into %[]" do 
-    %[foo].should == "foo"
-    %|bar|.should == "bar"
-    %'baz'.should == "baz"
-  end
-
-  it "interpolate string" do 
-    a = 1
-    %[#{a}23].should == "123"
-  end
-
-  it "should not process escape characters in single-quoted heredocs" do
-    s = <<'EOD'
-      hey\now\brown\cow
-    EOD
-    s.strip.should == 'hey\now\brown\cow'
-  end
-
-  it "should ignore single-quote escapes in single-quoted heredocs" do
-    s = <<'EOD'
-      they\'re greeeeaaat!
-    EOD
-    s.strip.should == 'they\\\'re greeeeaaat!'
-  end
-
-  it "should process escape characters in double quoted heredocs" do
-    s = <<"EOD"
-      hey\now\brown\cow
-    EOD
-    s.strip.should == "hey\now\brown\cow"
-  end
-
-  it "should treat bare-word heredoc identifiers as double-quoted" do
-    s = <<EOD
-      hey\now\brown\cow
-    EOD
-    s.strip.should == "hey\now\brown\cow"
-  end
-end

data/spec/opal/core/language/ternary_operator_spec.rb

@@ -1,20 +0,0 @@
-describe "Ternary condition operator" do
-  it "returns the second argument if the condition is true" do
-    (true ? 1 : 2).should == 1
-  end
-
-  it "returns the third argument if the condition is false" do
-    (false ? 1 : 2).should == 2
-  end
-
-  it "doesn't get confused if : follows a string literal" do
-    # this could be interpreted as a Ruby 1.9 symbol hash key
-    (true ?'str':'another str').should == 'str'
-  end
-
-  it "doesn't interpret ?? as an identifier" do
-    obj = mock("object with a query method")
-    obj.should_receive("m?").and_return(true)
-    (obj.m?? 1 : 2).should == 1
-  end
-end