promise.rb 0.5.0 → 0.6.0

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # promise.rb changelog
 
+## 0.6.0 (December 21, 2013)
+
+* Most of Promise and Callback have been rewritten. Less code.
+* The rejection reason isn't overloaded with the promise's backtrace anymore as
+  introduced in 0.5.0. Instead, Promise#backtrace will be populated with the
+  originating call to #fulfill or #reject.
+* The backtrace no longer guarantees that the actual caller is its first
+  element (thank you JRuby).
+
 ## 0.5.0 (December 16, 2013)
 
 * Fulfillment value and rejection reason are no longer being frozen

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 10
-total_score: 50
+total_score: 55

data/config/flog.yml

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

data/config/reek.yml

@@ -20,7 +20,8 @@ DuplicateMethodCall:
   enabled: true
   exclude: []
   max_calls: 1
-  allow_calls: []
+  allow_calls:
+  - source.backtrace
 FeatureEnvy:
   enabled: false
   exclude: []
@@ -49,7 +50,7 @@ NilCheck:
 RepeatedConditional:
   enabled: true
   exclude: []
-  max_ifs: 2
+  max_ifs: 3
 TooManyInstanceVariables:
   enabled: true
   exclude: []
@@ -57,7 +58,7 @@ TooManyInstanceVariables:
 TooManyMethods:
   enabled: true
   exclude: []
-  max_methods: 14
+  max_methods: 12
 TooManyStatements:
   enabled: true
   exclude:

data/config/rubocop.yml

@@ -47,3 +47,7 @@ ConstantName:
 # Not all trivial readers/writers can be defined with attr_* methods
 TrivialAccessors:
   Enabled: false
+
+SignalException:
+  # Valid values are: semantic, only_raise and only_fail
+  EnforcedStyle: only_raise

data/lib/promise.rb

@@ -8,12 +8,11 @@ require 'promise/progress'
 class Promise
   include Promise::Progress
 
-  attr_reader :value, :reason
+  attr_reader :state, :value, :reason, :backtrace
 
   def initialize
     @state = :pending
-    @on_fulfill = []
-    @on_reject = []
+    @callbacks = []
   end
 
   def pending?
@@ -30,77 +29,54 @@ class Promise
 
   def then(on_fulfill = nil, on_reject = nil, &block)
     on_fulfill ||= block
-    next_promise = add_callbacks(on_fulfill, on_reject)
+    next_promise = Promise.new
 
-    maybe_dispatch(@on_fulfill.last, @on_reject.last)
+    add_callback { Callback.new(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?
-    fail reason if rejected?
+    raise reason if rejected?
     value
   end
 
-  def fulfill(value = nil)
-    dispatch(@on_fulfill, value) do
+  def fulfill(value = nil, backtrace = nil)
+    dispatch(backtrace) do
       @state = :fulfilled
       @value = value
     end
   end
 
-  def reject(reason = nil)
-    reason = build_reason(reason || RuntimeError, caller)
-    dispatch(@on_reject, reason) do
+  def reject(reason = RuntimeError, backtrace = nil)
+    dispatch(backtrace) do
       @state = :rejected
       @reason = reason
     end
   end
 
-  private
-
-  def add_callbacks(on_fulfill, on_reject)
-    next_promise = self.class.new
-    @on_fulfill << FulfillCallback.new(on_fulfill, next_promise)
-    @on_reject << RejectCallback.new(on_reject, next_promise)
-    next_promise
-  end
-
-  def dispatch(callbacks, arg)
+  def dispatch(backtrace)
     if pending?
       yield
-      callbacks.each { |callback| dispatch!(callback, arg) }
-    end
-
-    # Callback#assume_state uses #dispatch as returned_promise's on_fulfill
-    # and on_reject callback. Without an explicit return value, the implicit
-    # return value might be the callbacks array, and thus returned_promise
-    # would be fulfilled (or rejected) with that array. It would be frozen
-    # from then on, letting further calls to #then crash.
-    nil
-  end
-
-  def maybe_dispatch(fulfill_callback, reject_callback)
-    if fulfilled?
-      dispatch!(fulfill_callback, value)
-    end
-
-    if rejected?
-      dispatch!(reject_callback, reason)
+      @backtrace = backtrace || caller
+      @callbacks.each { |generator| dispatch!(generator.call) }
+      nil
     end
   end
 
-  def dispatch!(callback, arg)
-    defer { callback.dispatch(arg) }
+  def dispatch!(callback)
+    defer { callback.dispatch(self) }
   end
 
   def defer
     yield
   end
-
-  def build_reason(reason, backtrace)
-    reason = reason.new if reason.respond_to?(:new)
-    reason.set_backtrace(backtrace) unless reason.backtrace
-    reason
-  end
 end

data/lib/promise/callback.rb

@@ -2,55 +2,47 @@
 
 class Promise
   class Callback
-    def initialize(block, next_promise)
-      @block = block
+    def initialize(on_fulfill, on_reject, next_promise)
+      @on_fulfill, @on_reject = on_fulfill, on_reject
       @next_promise = next_promise
     end
 
-    private
+    def block_for(promise)
+      promise.fulfilled? ? @on_fulfill : @on_reject
+    end
 
-    def execute(value)
-      @block.call(value)
-    rescue => error
-      @next_promise.reject(error)
-      raise
+    def param_for(promise)
+      promise.fulfilled? ? promise.value : promise.reason
     end
 
-    def handle_result(result)
-      if Promise === result
-        assume_state(result)
+    def dispatch(promise)
+      if (block = block_for(promise))
+        handle_result(promise) { execute(promise, block) }
       else
-        @next_promise.fulfill(result)
+        assume_state(promise, @next_promise)
       end
     end
 
-    def assume_state(returned_promise)
-      on_fulfill = @next_promise.method(:fulfill)
-      on_reject = @next_promise.method(:reject)
-
-      returned_promise.then(on_fulfill, on_reject)
+    def execute(promise, block)
+      block.call(param_for(promise))
+    rescue => ex
+      @next_promise.reject(ex, promise.backtrace)
+      raise
     end
-  end
 
-  class FulfillCallback < Callback
-    def dispatch(value)
-      if @block
-        result = execute(value)
-        handle_result(result)
+    def handle_result(promise)
+      if Promise === (result = yield)
+        assume_state(result, @next_promise)
       else
-        handle_result(value)
+        @next_promise.fulfill(result, promise.backtrace)
       end
     end
-  end
 
-  class RejectCallback < Callback
-    def dispatch(reason)
-      if @block
-        result = execute(reason)
-        handle_result(result)
-      else
-        @next_promise.reject(reason)
-      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
 end

data/lib/promise/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 class Promise
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/spec/promise_spec.rb

@@ -223,6 +223,7 @@ 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
@@ -231,22 +232,25 @@ 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 { |_| fail(error) })
+      promise2 = subject.then(proc { |_| raise error })
       expect { subject.fulfill(value) }.to raise_error(error)
 
       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 { |_| fail(error) })
+      promise2 = subject.then(nil, proc { |_| raise error })
       expect { subject.reject(reason) }.to raise_error(error)
 
       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
@@ -259,6 +263,7 @@ 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
@@ -270,6 +275,7 @@ 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
 
@@ -283,6 +289,7 @@ 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
@@ -294,6 +301,7 @@ 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
 
@@ -304,6 +312,7 @@ describe Promise do
 
         expect(promise2).to be_fulfilled
         expect(promise2.value).to eq(value)
+        expect(promise2.backtrace).to be(subject.backtrace)
       end
     end
 
@@ -314,6 +323,7 @@ describe Promise do
 
         expect(promise2).to be_rejected
         expect(promise2.reason).to eq(reason)
+        expect(promise2.backtrace).to be(subject.backtrace)
       end
     end
   end
@@ -355,6 +365,12 @@ describe Promise 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)
+    end
   end
 
   describe '#reject' do
@@ -364,30 +380,14 @@ describe Promise do
 
     it 'does not require a reason' do
       subject.reject
-      expect(subject.reason).to be_a(RuntimeError)
-    end
-
-    it 'allows nil reason' do
-      subject.reject(nil)
-      expect(subject.reason).to be_a(RuntimeError)
+      expect(subject.reason).to be(RuntimeError)
     end
 
     it 'sets the backtrace' do
       subject.reject
-      expect(subject.reason.backtrace[0])
+      expect(subject.backtrace.join)
         .to include(__FILE__ + ':' + (__LINE__ - 2).to_s)
     end
-
-    it 'does not override backtrace' do
-      subject.reject(reason)
-      expect(subject.reason.backtrace).to be(backtrace)
-    end
-
-    it 'builds exception object for custom error class' do
-      cls = Class.new(StandardError)
-      subject.reject(cls)
-      expect(subject.reason).to be_a(cls)
-    end
   end
 
   describe '#sync' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: promise.rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-16 00:00:00.000000000 Z
+date: 2013-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec