opal-wedge 0.9.0.dev

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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,8 @@
+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
+end

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

@@ -0,0 +1,30 @@
+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 'raises an exception when the promise has already been chained' do
+    p = Promise.value(2)
+    p.then {}
+
+    proc {
+      p.always {}
+    }.should raise_error(ArgumentError)
+  end
+end

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,44 @@
+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 'raises an exception when the promise has already been chained' do
+    p = Promise.value(2)
+    p.then {}
+
+    proc {
+      p.rescue {}
+    }.should raise_error(ArgumentError)
+  end
+end

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

@@ -0,0 +1,71 @@
+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 'raises an exception when the promise has already been chained' do
+    p = Promise.value(2)
+    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

@@ -0,0 +1,52 @@
+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 an exception when the promise has already been chained' do
+    p = Promise.value(2)
+    p.then {}
+
+    proc {
+      p.trace {}
+    }.should raise_error(ArgumentError)
+  end
+end

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

@@ -0,0 +1,15 @@
+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

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

@@ -0,0 +1,34 @@
+require 'promise'
+
+describe 'Promise.when' do
+  it 'calls the block with all promises results' do
+    a = Promise.new
+    b = Promise.new
+
+    x = 42
+
+    Promise.when(a, b).then {|y, z|
+      x = y + z
+    }
+
+    a.resolve(1)
+    b.resolve(2)
+
+    x.should == 3
+  end
+
+  it 'can be built lazily' do
+    a = Promise.new
+    b = Promise.value(3)
+
+    x = 42
+
+    Promise.when(a).and(b).then {|c, d|
+      x = c + d
+    }
+
+    a.resolve(2)
+
+    x.should == 5
+  end
+end

data/spec/opal/stdlib/template/paths_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'template'
+
+describe Template do
+  describe ".paths" do
+    it "should be an array of registered templates" do
+      Template.paths.should be_kind_of(Array)
+    end
+  end
+end