promise.rb 0.7.0.rc1 → 0.7.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b98cd2e53ffcbfb4c387c41a85c9699b8c050f5e
-  data.tar.gz: 22cf6c2bd54e4490470520aca42aa9f15abb24b4
+  metadata.gz: 487aaf8c555487ea2f7b3bbdb77a5a63b0be1f38
+  data.tar.gz: 1a1ede2482f03dd9c55c0050b913bc718b077bea
 SHA512:
-  metadata.gz: 990eedfbc0cfb55355f2ca0bc963e0cec24d3668b7a22e8e97fb643bb6abd71da10dec39c9e4846f243bc3bad51b5e6a544a270d04a600f7fbca2b3d060e7f96
-  data.tar.gz: dffd4ca2bd12d3ee92acb2dc4c719a7aacbe20a4563da016b21ad63d2909c1f22a5c68947b9369f3792b1440edf5e2b37f4b13d8b4e8aa4d14c0d4795ee83e25
+  metadata.gz: 31b9d4895eca8ceab77fcce63730ad620b2d7f294b2bd53eb47c6da412557c714ce58bb99cc1a87995dac172e554e61ea4b0ae94ef6004d63746a3acc2ed8399
+  data.tar.gz: 6bf132f844d4f83b7369ffd79711aa9b772c2d285507908510993099a4c1a54a3aab66eb2de7d2d4271509c62bbea24c71229086deff567adf73f5867d3b4f54

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # promise.rb changelog
 
+## 0.7.0.rc2 (February 17, 2016)
+
+### Bug Fixes
+
+* Avoid re-raising exception that occur in then callbacks (pull #13)
+* Wait for an instance of a subclass of Promise in Promise.all (pull #15)
+
+### Features
+
+* Instantiate exception classes and set missing backtrace in reject (pull #12)
+* Allow Promise#fulfill to be called with a promise (pull #14)
+
+### Breaking Changes
+
+* Make add_callback, dispatch, dispatch! and Promise::Callback private (pull #11)
+* Remove Promise#backtrace, use #reason.backtrace instead (pull #12)
+
 ## 0.7.0.rc1 (February 9, 2016)
 
 ### Bug Fixes

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 10.8
+threshold: 10.6

data/config/reek.yml

@@ -60,7 +60,7 @@ TooManyInstanceVariables:
 TooManyMethods:
   enabled: true
   exclude: []
-  max_methods: 12
+  max_methods: 13
 TooManyStatements:
   enabled: true
   exclude:

data/lib/promise.rb

@@ -11,10 +11,10 @@ class Promise
 
   include Promise::Progress
 
-  attr_reader :state, :value, :reason, :backtrace
+  attr_reader :state, :value, :reason
 
   def self.resolve(obj)
-    return obj if obj.instance_of?(self)
+    return obj if obj.is_a?(self)
     new.tap { |promise| promise.fulfill(obj) }
   end
 
@@ -43,52 +43,68 @@ class Promise
     on_fulfill ||= block
     next_promise = self.class.new
 
-    add_callback { Callback.new(self, on_fulfill, on_reject, next_promise) }
+    add_callback(Callback.new(self, on_fulfill, on_reject, next_promise))
     next_promise
   end
 
-  def add_callback(&generator)
-    if pending?
-      @callbacks << generator
-    else
-      dispatch!(generator.call)
-    end
-  end
-
   def sync
     wait if pending?
     raise reason if rejected?
     value
   end
 
-  def fulfill(value = nil, backtrace = nil)
-    dispatch(backtrace) do
-      @state = :fulfilled
-      @value = value
+  def fulfill(value = nil)
+    if Promise === value
+      Callback.assume_state(value, self)
+    else
+      dispatch do
+        @state = :fulfilled
+        @value = value
+      end
     end
+    nil
   end
 
-  def reject(reason = nil, backtrace = nil)
-    dispatch(backtrace) do
+  def reject(reason = nil)
+    dispatch do
       @state = :rejected
-      @reason = reason || Error
+      @reason = reason_coercion(reason || Error)
     end
   end
 
-  def dispatch(backtrace)
+  def defer
+    yield
+  end
+
+  private
+
+  def reason_coercion(reason)
+    case reason
+    when Exception
+      reason.set_backtrace(caller) unless reason.backtrace
+    when Class
+      reason = reason_coercion(reason.new) if reason <= Exception
+    end
+    reason
+  end
+
+  def add_callback(callback)
+    if pending?
+      @callbacks << callback
+    else
+      dispatch!(callback)
+    end
+  end
+
+  def dispatch
     if pending?
       yield
-      @backtrace = backtrace || caller
-      @callbacks.each { |generator| dispatch!(generator.call) }
+      @callbacks.each { |callback| dispatch!(callback) }
       nil
     end
   end
 
   def dispatch!(callback)
-    defer { callback.dispatch }
-  end
-
-  def defer
-    yield
+    defer { callback.call }
   end
 end

data/lib/promise/callback.rb

@@ -2,6 +2,12 @@
 
 class Promise
   class Callback
+    def self.assume_state(source, target)
+      on_fulfill = target.method(:fulfill)
+      on_reject = target.method(:reject)
+      source.then(on_fulfill, on_reject)
+    end
+
     def initialize(promise, on_fulfill, on_reject, next_promise)
       @promise = promise
       @on_fulfill = on_fulfill
@@ -9,42 +15,25 @@ class Promise
       @next_promise = next_promise
     end
 
-    def block
-      @promise.fulfilled? ? @on_fulfill : @on_reject
-    end
-
-    def param
-      @promise.fulfilled? ? @promise.value : @promise.reason
-    end
-
-    def dispatch
-      if block
-        handle_result { execute }
+    def call
+      if @promise.fulfilled?
+        call_block(@on_fulfill, @promise.value)
       else
-        assume_state(@promise, @next_promise)
+        call_block(@on_reject, @promise.reason)
       end
     end
 
-    def execute
-      block.call(param)
-    rescue => ex
-      @next_promise.reject(ex, @promise.backtrace)
-      raise
-    end
-
-    def handle_result
-      if Promise === (result = yield)
-        assume_state(result, @next_promise)
+    def call_block(block, param)
+      if block
+        begin
+          @next_promise.fulfill(block.call(param))
+        rescue => ex
+          @next_promise.reject(ex)
+        end
       else
-        @next_promise.fulfill(result, @promise.backtrace)
+        self.class.assume_state(@promise, @next_promise)
       end
     end
-
-    def assume_state(source, target)
-      on_fulfill = proc { target.fulfill(source.value, source.backtrace) }
-      on_reject  = proc { target.reject(source.reason, source.backtrace) }
-
-      source.then(on_fulfill, on_reject)
-    end
   end
+  private_constant :Callback
 end

data/lib/promise/group.rb

@@ -32,7 +32,7 @@ class Promise
     end
 
     def promise?(obj)
-      obj.instance_of?(Promise)
+      obj.is_a?(Promise)
     end
 
     def count_promises

data/lib/promise/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 class Promise
-  VERSION = '0.7.0.rc1'
+  VERSION = '0.7.0.rc2'
 end

data/spec/unit/promise_spec.rb

@@ -10,10 +10,10 @@ describe Promise do
 
   let(:backtrace) { caller }
   let(:reason) do
-    StandardError.new('reason').tap { |ex| ex.set_backtrace(backtrace) }
+    StandardError.new('reason').tap { |err| err.set_backtrace(backtrace) }
   end
   let(:other_reason) do
-    StandardError.new('other_reason').tap { |ex| ex.set_backtrace(backtrace) }
+    StandardError.new('other_reason').tap { |err| err.set_backtrace(caller) }
   end
 
   describe '3.1.1 pending' do
@@ -200,6 +200,25 @@ describe Promise do
       expect(order).to eq([1, 2, 3])
     end
 
+    it 'calls all on_fulfill callbacks even if one raises an exception' do
+      order = []
+      on_fulfill = proc do |i, val|
+        order << i
+        expect(val).to eq(value)
+      end
+
+      subject.then(on_fulfill.curry[1])
+      subject.then do |_|
+        order << 2
+        raise 'middle then error'
+      end
+      subject.then(on_fulfill.curry[3])
+
+      subject.fulfill(value)
+
+      expect(order).to eq([1, 2, 3])
+    end
+
     it 'calls multiple on_reject callbacks in order of definition' do
       order = []
       on_reject = proc do |i, reas|
@@ -232,7 +251,6 @@ describe Promise do
 
       expect(promise2).to be_fulfilled
       expect(promise2.value).to eq(other_value)
-      expect(promise2.backtrace).to be(subject.backtrace)
     end
 
     it 'fulfills promise2 with value returned by on_reject' do
@@ -241,25 +259,22 @@ describe Promise do
 
       expect(promise2).to be_fulfilled
       expect(promise2.value).to eq(other_value)
-      expect(promise2.backtrace).to be(subject.backtrace)
     end
 
     it 'rejects promise2 with error raised by on_fulfill' do
       promise2 = subject.then(proc { |_| raise error })
-      expect { subject.fulfill(value) }.to raise_error(error)
+      subject.fulfill(value)
 
       expect(promise2).to be_rejected
       expect(promise2.reason).to eq(error)
-      expect(promise2.backtrace).to be(subject.backtrace)
     end
 
     it 'rejects promise2 with error raised by on_reject' do
       promise2 = subject.then(nil, proc { |_| raise error })
-      expect { subject.reject(reason) }.to raise_error(error)
+      subject.reject(reason)
 
       expect(promise2).to be_rejected
       expect(promise2.reason).to eq(error)
-      expect(promise2.backtrace).to be(subject.backtrace)
     end
 
     describe 'on_fulfill returns promise' do
@@ -272,7 +287,6 @@ describe Promise do
         returned_promise.fulfill(other_value)
         expect(promise2).to be_fulfilled
         expect(promise2.value).to eq(other_value)
-        expect(promise2.backtrace).to be(returned_promise.backtrace)
       end
 
       it 'makes promise2 assume rejected state of returned promise' do
@@ -284,7 +298,6 @@ describe Promise do
         returned_promise.reject(other_reason)
         expect(promise2).to be_rejected
         expect(promise2.reason).to eq(other_reason)
-        expect(promise2.backtrace).to be(returned_promise.backtrace)
       end
     end
 
@@ -298,7 +311,6 @@ describe Promise do
         returned_promise.fulfill(other_value)
         expect(promise2).to be_fulfilled
         expect(promise2.value).to eq(other_value)
-        expect(promise2.backtrace).to be(returned_promise.backtrace)
       end
 
       it 'makes promise2 assume rejected state of returned promise' do
@@ -310,7 +322,6 @@ describe Promise do
         returned_promise.reject(other_reason)
         expect(promise2).to be_rejected
         expect(promise2.reason).to eq(other_reason)
-        expect(promise2.backtrace).to be(returned_promise.backtrace)
       end
     end
 
@@ -321,7 +332,6 @@ describe Promise do
 
         expect(promise2).to be_fulfilled
         expect(promise2.value).to eq(value)
-        expect(promise2.backtrace).to be(subject.backtrace)
       end
     end
 
@@ -332,7 +342,6 @@ describe Promise do
 
         expect(promise2).to be_rejected
         expect(promise2.reason).to eq(reason)
-        expect(promise2.backtrace).to be(subject.backtrace)
       end
     end
   end
@@ -371,15 +380,24 @@ describe Promise do
         expect(subject.fulfill(nil)).to eq(nil)
       end
 
+      it 'does not return anything when given a promise' do
+        expect(subject.fulfill(Promise.new)).to eq(nil)
+      end
+
       it 'does not require a value' do
         subject.fulfill
         expect(subject.value).to be(nil)
       end
 
-      it 'sets the backtrace' do
-        subject.fulfill
-        expect(subject.backtrace.join)
-          .to include(__FILE__ + ':' + (__LINE__ - 2).to_s)
+      it 'assumes the state of a given promise' do
+        promise = Promise.new
+
+        subject.fulfill(promise)
+        expect(subject).to be_pending
+        promise.fulfill(123)
+
+        expect(subject).to be_fulfilled
+        expect(subject.value).to eq(123)
       end
     end
 
@@ -390,14 +408,34 @@ describe Promise do
 
       it 'does not require a reason' do
         subject.reject
-        expect(subject.reason).to be(Promise::Error)
+        expect(subject.reason).to be_a(Promise::Error)
       end
 
       it 'sets the backtrace' do
         subject.reject
-        expect(subject.backtrace.join)
+        expect(subject.reason.backtrace.join)
           .to include(__FILE__ + ':' + (__LINE__ - 2).to_s)
       end
+
+      it 'leaves backtrace if already set' do
+        subject.reject(reason)
+        expect(subject.reason.backtrace).to eq(backtrace)
+      end
+
+      it 'instantiates exception class' do
+        subject.reject(Exception)
+        expect(subject.reason).to be_a(Exception)
+      end
+
+      it 'instantiates exception subclasses' do
+        subject.reject(RuntimeError)
+        expect(subject.reason).to be_a(RuntimeError)
+      end
+
+      it "doesn't instantiate non-error classes" do
+        subject.reject(Hash)
+        expect(subject.reason).to eq(Hash)
+      end
     end
 
     describe '#sync' do
@@ -425,12 +463,25 @@ describe Promise do
         expect(promise.value).to eq(123)
       end
 
-      it 'assumes the state of a given promise' do
+      it 'returns a given promise' do
         promise = Promise.new
         new_promise = Promise.resolve(promise)
-        expect(new_promise.pending?).to eq(true)
+        expect(new_promise.object_id).to eq(promise.object_id)
+      end
+
+      it 'returns a given promise of a subclass of itself' do
+        promise = DelayedPromise.new
+        new_promise = Promise.resolve(promise)
+        expect(new_promise.object_id).to eq(promise.object_id)
+      end
+
+      it 'assumes the state of a given promise of another class' do
+        promise = Promise.new
+        new_promise = DelayedPromise.resolve(promise)
+        expect(new_promise).to be_an_instance_of(DelayedPromise)
+        expect(new_promise).to be_pending
         promise.fulfill(42)
-        expect(new_promise.fulfilled?).to eq(true)
+        expect(new_promise).to be_fulfilled
         expect(new_promise.value).to eq(42)
       end
     end
@@ -492,6 +543,16 @@ describe Promise do
         p1.fulfill(1.0)
         expect(result.sync).to eq([1.0, 2])
       end
+
+      it 'returns an instance of the class it is called on' do
+        p1 = DelayedPromise.new
+
+        result = DelayedPromise.all([p1, 2])
+
+        expect(result).to be_pending
+        p1.fulfill(1.0)
+        expect(result.sync).to eq([1.0, 2])
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: promise.rb
 version: !ruby/object:Gem::Version
-  version: 0.7.0.rc1
+  version: 0.7.0.rc2
 platform: ruby
 authors:
 - Lars Gierth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-09 00:00:00.000000000 Z
+date: 2016-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec