opal 1.0.3 → 1.1.1.rc1

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

@@ -0,0 +1,12 @@
+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/pp_spec.rb

@@ -0,0 +1,5 @@
+describe 'Object#pretty_inspect' do
+  it "doesn't throw due to the use of #<<" do
+    expect("test".pretty_inspect).to eq %{"test"\n}
+  end
+end

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

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

@@ -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,53 @@
+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

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

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

@@ -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/source_map_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'opal/source_map'
+
+describe 'Opal::SourceMap::VLQ' do
+  it 'encodes properly' do
+    Opal::SourceMap::VLQ.encode([0]).should == 'A'
+  end
+end

data/spec/opal/stdlib/strscan/scan_spec.rb

@@ -0,0 +1,11 @@
+require 'strscan'
+
+describe "StringScanner#scan" do
+  context "when the regex has multiple alternatives" do
+    it "still anchors to the beginning of the remaining text" do
+      # regression test; see GH issue 1074
+      scanner = StringScanner.new("10\nb = `2E-16`")
+      scanner.scan(/[\d_]+\.[\d_]+\b|[\d_]+(\.[\d_]+)?[eE][-+]?[\d_]+\b/).should be_nil
+    end
+  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

data/spec/opal/stdlib/thread/mutex_spec.rb

@@ -0,0 +1,40 @@
+require 'thread'
+
+describe Mutex do
+  before do
+    @mutex = Mutex.new
+  end
+
+  it "cannot be locked twice" do
+    @mutex.lock
+    lambda do
+      @mutex.lock
+    end.should raise_error(ThreadError)
+  end
+
+  it "reports locked? status" do
+    @mutex.locked?.should be_false
+    @mutex.lock
+    @mutex.locked?.should be_true
+  end
+
+  it "reports locked? status with try_lock" do
+    @mutex.try_lock.should be_true
+    @mutex.locked?.should be_true
+    @mutex.try_lock.should be_false
+  end
+
+  it "is locked and unlocked by synchronize" do
+    @mutex.synchronize do
+      @mutex.locked?.should be_true
+    end
+    @mutex.locked?.should be_false
+  end
+
+  it "will not be locked by synchronize if already locked" do
+    @mutex.lock
+    lambda do
+      @mutex.synchronize {}
+    end.should raise_error(ThreadError)
+  end
+end

data/spec/opal/stdlib/thread/thread_queue_spec.rb

@@ -0,0 +1,32 @@
+require 'thread'
+
+describe Thread::Queue do
+  before do
+    @queue = Thread::Queue.new
+  end
+
+  it "is aliased as ::Queue" do
+    ::Thread::Queue.should == ::Queue
+  end
+
+  it "will not allow deadlock" do
+    lambda do
+      @queue.pop
+    end.should raise_error(ThreadError)
+  end
+
+  it "pops in FIFO order" do
+    @queue.push(1)
+    @queue.push(2)
+
+    @queue.pop.should == 1
+    @queue.pop.should == 2
+  end
+
+  it "can be cleared by clear" do
+    @queue.push(1)
+    @queue.clear
+    @queue.size.should == 0
+    @queue.empty?.should be_true
+  end
+end

data/spec/opal/stdlib/thread/thread_spec.rb

@@ -0,0 +1,60 @@
+require 'thread'
+
+# Our implementation of Thread only supports faux thread-local variables.
+# Since we can't actually create a thread, nothing in rubyspec will run.
+describe Thread do
+  it "returns a value for current" do
+    Thread.current.should_not be_nil
+  end
+
+  it "only has current in list" do
+    Thread.list.should == [Thread.current]
+  end
+
+  it "does not allow creation of new threads" do
+    lambda do
+      Thread.new {}
+    end.should raise_error(NotImplementedError)
+  end
+
+  describe "local storage" do
+    before do
+      @current = Thread.current
+      @current.send(:core_initialize!)
+    end
+
+    it "stores fiber-local variables" do
+      @current[:a] = 'hello'
+      @current[:a].should == 'hello'
+    end
+
+    it "returns fiber-local keys that are assigned" do
+      @current[:a] = 'hello'
+      @current.key?(:a).should be_true
+      @current.keys.should === ['a']
+    end
+
+    it "considers fiber-local keys, as symbols or strings equal" do
+      @current[:a]  = 1
+      @current['a'] = 2
+      @current.keys.size.should == 1
+      @current[:a].should == 2
+    end
+
+    it "implements thread-local variables" do
+      @current.thread_variable_set('a', 1)
+      @current.thread_variable_get('a').should == 1
+      @current.thread_variables.should == ['a']
+    end
+
+    it "distinguishes between fiber-local and thread-local variables" do
+      @current[:a] = 1
+      @current.thread_variables.should == []
+
+      @current.thread_variable_set(:a, 2)
+
+      @current[:a].should == 1
+      @current.thread_variable_get(:a).should == 2
+    end
+  end
+end