opal 0.10.0 → 0.11.0

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

@@ -1,13 +0,0 @@
-require 'native'
-
-describe "Native::Object#each" do
-  it "enumerates on object properties" do
-    Native(`{ a: 2, b: 3 }`).each {|name, value|
-      ((name == :a && value == 2) || (name == :b && value == 3)).should be_true
-    }
-  end
-
-  it "accesses the native when no block is given" do
-    Native(`{ a: 2, b: 3, each: function() { return 42; } }`).each.should == 42
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'native'
-
-describe "Native::Object#[]" do
-  it "should return the same value for bridged classes" do
-    Native(`2`).should === 2
-    Native(`"lol"`).should === "lol"
-  end
-
-  it "should return functions as is" do
-    Native(`{ a: function(){} }`)[:a].should be_kind_of Proc
-  end
-
-  it "should wrap natives into a Native object" do
-    Native(`{ a: { b: 2 } }`)[:a][:b].should == 2
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'native'
-
-describe 'Native exposure' do
-  describe Class do
-    describe '#native_alias' do
-      it 'exposes a method to javascript' do
-        c = Class.new do
-          def ruby_method
-            :ruby
-          end
-
-          native_alias :rubyMethod, :ruby_method
-        end
-
-        `#{c.new}.rubyMethod()`.should == :ruby
-      end
-    end
-
-    describe '#native_class' do
-      it 'exposes a Class on the JS global object' do
-        c = Class.new do
-          def self.name
-            'Pippo'
-          end
-
-          native_class
-        end
-
-        `Pippo`.should == c
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'native'
-
-describe Hash do
-  describe '#initialize' do
-    it "returns a hash with a nil value" do
-      h = Hash.new(`{a: null}`)
-      h[:a].should == nil
-    end
-  end
-
-  describe '#to_n' do
-    it "should return a js object representing hash" do
-      Hash.new({:a => 100, :b => 200}.to_n).should == {:a => 100, :b => 200}
-    end
-  end
-end
-
-describe "Hash#to_n" do
-end

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

@@ -1,51 +0,0 @@
-require 'native'
-
-describe Hash do
-  it 'turns a native JS object into a hash' do
-    obj = %x{
-      {
-        a: 1,
-        b: "two",
-        c: {
-          d: 1,
-        },
-        e: [
-          {
-            f: 'g',
-          },
-        ],
-      }
-    }
-
-    h = Hash.new(obj)
-    expected_hash = {
-      a: 1,
-      b: "two",
-      c: {
-        d: 1,
-      },
-      e: [
-        {
-          f: 'g',
-        },
-      ],
-    }
-
-    expect(h).to eq(expected_hash)
-  end
-
-  describe '#to_n' do
-    it 'converts a hash with native objects as values' do
-      obj = { 'a_key' => `{ key: 1 }` }
-      native = obj.to_n
-      `#{native}.a_key.key`.should == 1
-    end
-
-    it 'passes Ruby objects that cannot be converted' do
-      object = Object.new
-      hash = { foo: object }
-      native = hash.to_n
-      expect(`#{native}.foo`).to eq object
-    end
-  end
-end

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

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

@@ -1,51 +0,0 @@
-require 'promise'
-
-describe 'Promise#trace' do
-  it 'calls the block with all the previous results' do
-    x = 42
-
-    Promise.value(1).then { 2 }.then { 3 }.trace {|a, b, c|
-      x = a + b + c
-    }
-
-    x.should == 6
-  end
-
-  it 'calls the then after the trace' do
-    x = 42
-
-    Promise.value(1).then { 2 }.then { 3 }.trace {|a, b, c|
-      a + b + c
-    }.then { |v| x = v }
-
-    x.should == 6
-  end
-
-  it 'includes the first value' do
-    x = 42
-
-    Promise.value(1).trace { |a| x = a }
-
-    x.should == 1
-  end
-
-  it 'works after a when' do
-    x = 42
-
-    Promise.value(1).then {
-      Promise.when Promise.value(2), Promise.value(3)
-    }.trace {|a, b|
-      x = a + b[0] + b[1]
-    }
-
-    x.should == 6
-  end
-
-  it 'raises with trace! if a promise has already been chained' do
-    p = Promise.new
-
-    p.then! {}
-
-    proc { p.trace! {} }.should raise_error(ArgumentError)
-  end
-end

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

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