opal 0.11.0.rc1 → 0.11.0

data/spec/opal/stdlib/native/initialize_spec.rb

@@ -1,17 +0,0 @@
-require 'native'
-
-describe "Native#initialize" do
-  it "works when Native is included in a BasicObject" do
-    basic_class = Class.new(BasicObject)
-    basic_object = basic_class.new
-    lambda { basic_object.native? }.should raise_error(NoMethodError)
-
-    basic_class.send :include, Native
-    lambda { basic_class.new(`{}`) }.should_not raise_error
-  end
-
-  it "detects a non native object" do
-    object = Object.new
-    lambda { Native::Object.new(object) }.should raise_error(ArgumentError)
-  end
-end

data/spec/opal/stdlib/native/method_missing_spec.rb

@@ -1,51 +0,0 @@
-require 'native'
-
-describe "Native::Object#method_missing" do
-  it "should return values" do
-    Native(`{ a: 23 }`).a.should == 23
-    Native(`{ a: { b: 42 } }`).a.b.should == 42
-  end
-
-  it "should call functions" do
-    Native(`{ a: function() { return 42 } }`).a.should == 42
-  end
-
-  it "should pass the proper this to functions" do
-    %x{
-      function foo() {
-        this.baz = 42;
-      }
-
-      foo.prototype.bar = function () {
-        return this.baz;
-      }
-    }
-
-    obj = `new foo()`
-    Native(obj).bar.should == 42
-    Native(obj).baz = 23
-    Native(obj).bar.should == 23
-  end
-
-  it "should set values" do
-    var = `{}`
-
-    Native(var).a = 42
-    `#{var}.a`.should == 42
-    Native(var).a.should == 42
-  end
-
-  it "should pass the block as function" do
-    Native(`{ a: function(func) { return func(); } }`).a { 42 }.should == 42
-  end
-
-  it "should unwrap arguments" do
-    x = `{}`
-
-    Native(`{ a: function(a, b) { return a === b } }`).a(Native(x), x).should == true
-  end
-
-  it "should wrap result" do
-    Native(`{ a: function() { return {}; } }`).a.class.should == Native::Object
-  end
-end

data/spec/opal/stdlib/native/native_alias_spec.rb

@@ -1,19 +0,0 @@
-require 'native'
-
-describe "Class#native_alias" do
-  it "exposes a method to javascript without the '$' prefix" do
-    klass = Class.new {
-      def a
-        2
-      end
-
-      native_alias :a, :a
-    }
-    instance = klass.new
-    `instance.a()`.should == 2
-  end
-
-  it "raises if the aliased method isn't defined" do
-    lambda { Class.new { native_alias :a, :not_a_method } }.should raise_error(NameError)
-  end
-end

data/spec/opal/stdlib/native/native_class_spec.rb

@@ -1,18 +0,0 @@
-require 'native'
-
-describe "Class#native_class" do
-  class SomeClass
-  end
-
-  after {`delete Opal.global.SomeClass`}
-
-  it "adds current constant to the global JS object" do
-    SomeClass.native_class
-    `Opal.global.SomeClass`.should == SomeClass
-  end
-
-  it 'aliases Class#new to the unprefixed new method in JS world' do
-    SomeClass.native_class
-    `Opal.global.SomeClass["new"]()`.is_a?(SomeClass).should == true
-  end
-end

data/spec/opal/stdlib/native/native_module_spec.rb

@@ -1,13 +0,0 @@
-require 'native'
-
-describe "Module#native_module" do
-  module SomeModule
-  end
-
-  after {`delete Opal.global.SomeModule`}
-
-  it "adds current constant to the global JS object" do
-    SomeModule.native_module
-    `Opal.global.SomeModule`.should == SomeModule
-  end
-end

data/spec/opal/stdlib/native/native_reader_spec.rb

@@ -1,22 +0,0 @@
-require 'native'
-
-describe "Native.native_reader" do
-  it "refers to an attribute on @native" do
-    Class.new {
-      include Native
-
-      native_reader :a
-    }.new(`{ a: 2 }`).a.should == 2
-  end
-
-  it "uses multiple names" do
-    n = Class.new {
-      include Native
-
-      native_reader :a, :b
-    }.new(`{ a: 2, b: 3 }`)
-
-    n.a.should == 2
-    n.b.should == 3
-  end
-end

data/spec/opal/stdlib/native/native_writer_spec.rb

@@ -1,30 +0,0 @@
-require 'native'
-
-describe "Native.native_writer" do
-  it "refers to an attribute on @native" do
-    n = Class.new {
-      include Native
-
-      native_reader :a
-      native_writer :a
-    }.new(`{ a: 2 }`)
-
-    n.a = 4
-    n.a.should == 4
-  end
-
-  it "supports multiple names" do
-    n = Class.new {
-      include Native
-
-      native_reader :a, :b
-      native_writer :a, :b
-    }.new(`{ a: 2, b: 3 }`)
-
-    n.a = 4
-    n.b = 5
-
-    n.a.should == 4
-    n.b.should == 5
-  end
-end

data/spec/opal/stdlib/native/new_spec.rb

@@ -1,92 +0,0 @@
-require 'native'
-
-describe "Native()" do
-  it "should return nil for null or undefined" do
-    Native(`null`).should be_nil
-    Native(`undefined`).should be_nil
-  end
-
-  it "should return String" do
-    Native(`""`).should be_an_instance_of String
-  end
-
-  it "should return Integer" do
-    Native(`0`).should be_an_instance_of Number
-  end
-
-  it "should return Float" do
-    Native(`0.01`).should be_an_instance_of Float
-  end
-
-  it "should return Array" do
-    Native(`[]`).should be_an_instance_of Array
-  end
-
-  it "should return Native::Object" do
-    Native(`{}`).instance_of?(Native::Object).should be_true
-  end
-
-  it "should return Array of String" do
-    Native(`[""]`).first.should be_an_instance_of String
-  end
-
-  it "should return Array of Integer" do
-    Native(`[0]`).first.should be_an_instance_of Number
-  end
-
-  it "should return Array of Float" do
-    Native(`[0.01]`).first.should be_an_instance_of Float
-  end
-
-  it "should return Array of Array" do
-    Native(`[[]]`).first.should be_an_instance_of Array
-  end
-
-  it "should return Array of Native::Object" do
-    Native(`[{}]`).first.instance_of?(Native::Object).should be_true
-  end
-
-  it "should return Object with String" do
-    Native(`{"key": ""}`)["key"].should be_an_instance_of String
-  end
-
-  it "should return Object with Integer" do
-    Native(`{"key": 0}`)["key"].should be_an_instance_of Number
-  end
-
-  it "should return Object with Float" do
-    Native(`{"key": 0.01}`)["key"].should be_an_instance_of Float
-  end
-
-  it "should return Object with Array" do
-    Native(`{"key": []}`)["key"].should be_an_instance_of Array
-  end
-
-  it "should return Native::Object with Native::Object" do
-    Native(`{"key": {}}`)["key"].instance_of?(Native::Object).should be_true
-  end
-
-  it "should return Proc" do
-    Native(`function(){}`).should be_an_instance_of Proc
-  end
-
-  it "should return Proc that return String" do
-    Native(`function(){return ""}`).call.should be_an_instance_of String
-  end
-
-  it "should return Proc that return Integer" do
-    Native(`function(){return 0}`).call.should be_an_instance_of Integer
-  end
-
-  it "should return Proc that return Float" do
-    Native(`function(){return 0.01}`).call.should be_an_instance_of Float
-  end
-
-  it "should return Proc that return Array" do
-    Native(`function(){return []}`).call.should be_an_instance_of Array
-  end
-
-  it "should return Proc that return Native::Object" do
-    Native(`function(){return {}}`).call.instance_of?(Native::Object).should be_true
-  end
-end

data/spec/opal/stdlib/native/struct_spec.rb

@@ -1,12 +0,0 @@
-require 'native'
-
-describe Struct do
-  describe '#to_n' do
-    it 'converts a struct with native attributes to a JS object' do
-      klass = Struct.new(:attribute)
-      obj = klass.new(`{ key: 1 }`)
-      native = obj.to_n
-      `#{native}.attribute.key`.should == 1
-    end
-  end
-end

data/spec/opal/stdlib/promise/always_spec.rb

@@ -1,49 +0,0 @@
-require 'promise'
-
-describe 'Promise#always' do
-  it 'calls the block when it was resolved' do
-    x = 42
-    Promise.value(23).then { |v| x = v }.always { |v| x = 2 }
-    x.should == 2
-  end
-
-  it 'calls the block when it was rejected' do
-    x = 42
-    Promise.error(23).rescue { |v| x = v }.always { |v| x = 2 }
-    x.should == 2
-  end
-
-  it 'acts as resolved' do
-    x = 42
-    Promise.error(23).rescue { |v| x = v }.always { x = 2 }.then { x = 3 }
-    x.should == 3
-  end
-
-  it 'can be called multiple times on resolved promises' do
-    p = Promise.value(2)
-    x = 1
-    p.then { x += 1 }
-    p.fail { x += 2 }
-    p.always { x += 3 }
-
-    x.should == 5
-  end
-
-  it 'can be called multiple times on rejected promises' do
-    p = Promise.error(2)
-    x = 1
-    p.then { x += 1 }
-    p.fail { x += 2 }
-    p.always { x += 3 }
-
-    x.should == 6
-  end
-
-  it 'raises with always! if a promise has already been chained' do
-    p = Promise.new
-
-    p.then! {}
-
-    proc { p.always! {} }.should raise_error(ArgumentError)
-  end
-end

data/spec/opal/stdlib/promise/error_spec.rb

@@ -1,15 +0,0 @@
-require 'promise'
-
-describe 'Promise.error' do
-  it 'rejects the promise with the given error' do
-    Promise.error(23).error.should == 23
-  end
-
-  it 'marks the promise as realized' do
-    Promise.error(23).realized?.should be_true
-  end
-
-  it 'marks the promise as rejected' do
-    Promise.error(23).rejected?.should be_true
-  end
-end

data/spec/opal/stdlib/promise/rescue_spec.rb

@@ -1,53 +0,0 @@
-require 'promise'
-
-describe 'Promise#rescue' do
-  it 'calls the block when the promise has already been rejected' do
-    x = 42
-    Promise.error(23).rescue { |v| x = v }
-    x.should == 23
-  end
-
-  it 'calls the block when the promise is rejected' do
-    a = Promise.new
-    x = 42
-
-    a.rescue { |v| x = v }
-    a.reject(23)
-
-    x.should == 23
-  end
-
-  it 'does not call then blocks when the promise is rejected' do
-    x = 42
-    y = 23
-
-    Promise.error(23).then { y = 42 }.rescue { |v| x = v }
-
-    x.should == 23
-    y.should == 23
-  end
-
-  it 'does not call subsequent rescue blocks' do
-    x = 42
-    Promise.error(23).rescue { |v| x = v }.rescue { x = 42 }
-    x.should == 23
-  end
-
-  it 'can be called multiple times on the same promise' do
-    p = Promise.error(2)
-    x = 1
-    p.then { x += 1 }
-    p.rescue { x += 3 }
-    p.rescue { x += 3 }
-
-    x.should == 7
-  end
-
-  it 'raises with rescue! if a promise has already been chained' do
-    p = Promise.new
-
-    p.then! {}
-
-    proc { p.rescue! {} }.should raise_error(ArgumentError)
-  end
-end

data/spec/opal/stdlib/promise/then_spec.rb

@@ -1,79 +0,0 @@
-require 'promise'
-
-describe 'Promise#then' do
-  it 'calls the block when the promise has already been resolved' do
-    x = 42
-    Promise.value(23).then { |v| x = v }
-    x.should == 23
-  end
-
-  it 'calls the block when the promise is resolved' do
-    a = Promise.new
-    x = 42
-
-    a.then { |v| x = v }
-    a.resolve(23)
-
-    x.should == 23
-  end
-
-  it 'works with multiple chains' do
-    x = 42
-    Promise.value(2).then { |v| v * 2 }.then { |v| v * 4 }.then { |v| x = v }
-    x.should == 16
-  end
-
-  it 'works when a block returns a promise' do
-    a = Promise.new
-    b = Promise.new
-
-    x = 42
-    a.then { b }.then { |v| x = v }
-
-    a.resolve(42)
-    b.resolve(23)
-
-    x.should == 23
-  end
-
-  it 'sends raised exceptions as rejections' do
-    x = nil
-
-    Promise.value(2).then { raise "hue" }.rescue { |v| x = v }
-
-    x.should be_kind_of(RuntimeError)
-  end
-
-  it 'sends raised exceptions inside rescue blocks as next errors' do
-    x = nil
-
-    Promise.value(2).then { raise "hue" }.rescue { raise "omg" }.rescue { |v| x = v }
-
-    x.should be_kind_of(RuntimeError)
-  end
-
-  it 'allows then to be called multiple times' do
-    p = Promise.value(2)
-    x = 1
-    p.then { x += 1 }
-    p.then { x += 1 }
-
-    x.should == 3
-  end
-
-  it 'raises with then! if a promise has already been chained' do
-    p = Promise.new
-
-    p.then! {}
-
-    proc { p.then! {} }.should raise_error(ArgumentError)
-  end
-
-  it 'should pass a delayed falsy value' do
-    p = Promise.new.resolve(5).then { nil }
-
-    p.then do |value|
-      expect(value).to eq(nil)
-    end
-  end
-end