promise.rb 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e3533c32b2d839c7fe076eb9ef7e02e38d594cf
-  data.tar.gz: 8041c55194508d424bf52709b0d55f97c75900a5
+  metadata.gz: 18cdca70f20edeb0b04ea3ca124ac37b9421e7e1
+  data.tar.gz: 34498e438956c5f0c6a9e689c8cd9b2ad56c5231
 SHA512:
-  metadata.gz: b7d7ea80750476d1334d79b24c87d6b2c50a3165f336e978064eab63398722bdb5d652aac575ca9826d28305099780e40812ae9def94a23f729a657f345b09d9
-  data.tar.gz: c079077407ed72f4d8b0e0ba688ec623f59a23e2e3ae4240209def4c9d54bfccc19a7105e21e484dc46a6db6fa79e7be7441f45e9ba9877f74a6d8ed68c58806
+  metadata.gz: 7dc20a5fb4be8e4fc352c243f03528a9458cce898051fcb3c2737f7b5a767de2049bdbb522122c6f938af17beaca055b715ca1edb94db968fc6e27f65eb15d28
+  data.tar.gz: 1c97f288a31cff1aa11ef0024026a7fca37818506a0ea804b7fb1fa80b546208e7bcb7b5e74fe4a37fa8a011992b14017ce13c6c0cae9ac7299fce076f540f42

data/.travis.yml

@@ -5,6 +5,7 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
+  - 2.4
   - jruby
 matrix:
   fast_finish: true

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # promise.rb changelog
 
+## 0.7.4 (August 25, 2017)
+
+### Features
+
+* Add an observer API, used internally to improve performance (pull #34)
+
 ## 0.7.3 (April 28, 2017)
 
 ### Features

data/Rakefile

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-if Gem.ruby_version >= Gem::Version.new('2.1')
+if Gem.ruby_version >= Gem::Version.new('2.2')
   require 'devtools'
   Devtools.init_rake_tasks
 
@@ -19,3 +19,9 @@ else
   RSpec::Core::RakeTask.new(:spec)
   task :default => :spec
 end
+
+
+desc "Run the benchmark suite in benchmark/run.rb"
+task :benchmark do
+  require "./benchmark/run.rb"
+end

data/benchmark/run.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative './setup.rb'
+
+PromiseBenchmark.profile_memory do
+  Promise.all([
+                Promise.all([
+                              Promise.resolve(1),
+                              Promise.resolve(2),
+                              Promise.resolve(3)
+                            ]),
+                Promise.all([
+                              Promise.resolve(1),
+                              Promise.resolve(2),
+                              Promise.resolve(3)
+                            ]),
+                Promise.all([
+                              Promise.resolve(1),
+                              Promise.resolve(2),
+                              Promise.resolve(3)
+                            ])
+              ]).then { |value| value }.sync
+end
+
+puts "\n"
+
+PromiseBenchmark.benchmark do |x|
+  x.report 'Promise.all w/promises' do
+    Promise.all([
+                  Promise.all([
+                                Promise.resolve(1),
+                                Promise.resolve(2),
+                                Promise.resolve(3)
+                              ]),
+                  Promise.all([
+                                Promise.resolve(1),
+                                Promise.resolve(2),
+                                Promise.resolve(3)
+                              ]),
+                  Promise.all([
+                                Promise.resolve(1),
+                                Promise.resolve(2),
+                                Promise.resolve(3)
+                              ])
+                ]).then { |value| value }
+  end
+  x.report 'Promise.all w/values' do
+    Promise.all([
+                  Promise.all([
+                                1,
+                                2,
+                                3
+                              ]),
+                  Promise.all([
+                                1,
+                                2,
+                                3
+                              ]),
+                  Promise.all([
+                                1,
+                                2,
+                                3
+                              ])
+                ]).then { |value| value }.sync
+  end
+  x.report('Promise.resolve') { Promise.resolve(true) }
+  x.report('Promise.resolve.sync') { Promise.resolve(true).sync }
+  x.report('Promise.resolve#then') do
+    Promise.resolve(true).then { |value| value }.sync
+  end
+  x.report('Promise.new#then') { Promise.new.then { |value| value } }
+  x.report('Promise.resolve nested') do
+    Promise.resolve(true).then { |_value| Promise.resolve(false) }.sync
+  end
+end

data/benchmark/setup.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'promise'
+require 'benchmark/ips'
+require 'benchmark/memory'
+require 'memory_profiler'
+
+module PromiseBenchmark
+  module_function
+
+  # Pass a block which will be benchmarked
+  def benchmark
+    Benchmark.ips { |x| yield(x) }
+    Benchmark.memory { |x| yield(x) }
+  end
+
+  # Pass a block which will be profiled for memory usage
+  def profile_memory
+    report = MemoryProfiler.report { yield }
+    report.pretty_print
+  end
+end

data/config/flog.yml

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

data/config/reek.yml

@@ -33,7 +33,7 @@ IrresponsibleModule:
 LongParameterList:
   enabled: true
   exclude: []
-  max_params: 2
+  max_params: 3
   overrides:
     initialize:
       max_params: 4
@@ -50,9 +50,7 @@ NilCheck:
   enabled: true
   exclude: []
 RepeatedConditional:
-  enabled: true
-  exclude: []
-  max_ifs: 4
+  enabled: false
 TooManyInstanceVariables:
   enabled: true
   exclude: []
@@ -60,11 +58,7 @@ TooManyInstanceVariables:
 TooManyMethods:
   enabled: false
 TooManyStatements:
-  enabled: true
-  exclude:
-  - initialize
-  - each
-  max_statements: 7
+  enabled: false
 UncommunicativeMethodName:
   enabled: true
   exclude: []
@@ -103,3 +97,5 @@ UtilityFunction:
   enabled: false
   exclude: []
   max_helper_calls: 0
+InstanceVariableAssumption:
+  enabled: false

data/config/rubocop.yml

@@ -14,7 +14,7 @@ ParameterLists:
 
 MethodLength:
   CountComments: false
-  Max: 11
+  Max: 20
 
 # Avoid more than `Max` levels of nesting.
 BlockNesting:

data/lib/promise.rb

@@ -2,7 +2,7 @@
 
 require 'promise/version'
 
-require 'promise/callback'
+require 'promise/observer'
 require 'promise/progress'
 require 'promise/group'
 
@@ -11,6 +11,7 @@ class Promise
   BrokenError = Class.new(Error)
 
   include Promise::Progress
+  include Promise::Observer
 
   attr_accessor :source
   attr_reader :state, :value, :reason
@@ -38,7 +39,6 @@ class Promise
 
   def initialize
     @state = :pending
-    @callbacks = []
   end
 
   def pending?
@@ -57,7 +57,16 @@ class Promise
     on_fulfill ||= block
     next_promise = self.class.new
 
-    add_callback(Callback.new(on_fulfill, on_reject, next_promise))
+    case state
+    when :fulfilled
+      defer { next_promise.promise_fulfilled(value, on_fulfill) }
+    when :rejected
+      defer { next_promise.promise_rejected(reason, on_reject) }
+    else
+      next_promise.source = self
+      subscribe(next_promise, on_fulfill, on_reject)
+    end
+
     next_promise
   end
 
@@ -76,24 +85,39 @@ class Promise
   end
 
   def fulfill(value = nil)
-    if Promise === value
-      value.add_callback(self)
-    else
-      dispatch do
-        @state = :fulfilled
-        @source = nil
-        @value = value
+    return self unless pending?
+
+    if value.is_a?(Promise)
+      case value.state
+      when :fulfilled
+        fulfill(value.value)
+      when :rejected
+        reject(value.reason)
+      else
+        @source = value
+        value.subscribe(self, nil, nil)
       end
+    else
+      @source = nil
+
+      @state = :fulfilled
+      @value = value
+
+      notify_fulfillment if defined?(@observers)
     end
+
     self
   end
 
   def reject(reason = nil)
-    dispatch do
-      @state = :rejected
-      @source = nil
-      @reason = reason_coercion(reason || Error)
-    end
+    return self unless pending?
+
+    @source = nil
+    @state = :rejected
+    @reason = reason_coercion(reason || Error)
+
+    notify_rejection if defined?(@observers)
+
     self
   end
 
@@ -107,6 +131,29 @@ class Promise
     end
   end
 
+  # Subscribe the given `observer` for status changes of a `Promise`.
+  #
+  # The observer will be notified about state changes of the promise
+  # by calls to its `#promise_fulfilled` or `#promise_rejected` methods.
+  #
+  # These methods will be called with two arguments,
+  # the first being the observed `Promise`, the second being the
+  # `on_fulfill_arg` or `on_reject_arg` given to `#subscribe`.
+  #
+  # @param [Promise::Observer] observer
+  # @param [Object] on_fulfill_arg
+  # @param [Object] on_reject_arg
+  def subscribe(observer, on_fulfill_arg, on_reject_arg)
+    raise Error, 'Non-pending promises can not be observed' unless pending?
+
+    unless observer.is_a?(Observer)
+      raise ArgumentError, 'Expected `observer` to be a `Promise::Observer`'
+    end
+
+    @observers ||= []
+    @observers.push(observer, on_fulfill_arg, on_reject_arg)
+  end
+
   protected
 
   # Override to defer calling the callback for Promises/A+ spec compliance
@@ -114,12 +161,19 @@ class Promise
     yield
   end
 
-  def add_callback(callback)
-    if pending?
-      @callbacks << callback
-      callback.source = self
+  def promise_fulfilled(value, on_fulfill)
+    if on_fulfill
+      settle_from_handler(value, &on_fulfill)
+    else
+      fulfill(value)
+    end
+  end
+
+  def promise_rejected(reason, on_reject)
+    if on_reject
+      settle_from_handler(reason, &on_reject)
     else
-      dispatch!(callback)
+      reject(reason)
     end
   end
 
@@ -135,21 +189,29 @@ class Promise
     reason
   end
 
-  def dispatch
-    if pending?
-      yield
-      @callbacks.each { |callback| dispatch!(callback) }
-      nil
+  def notify_fulfillment
+    defer do
+      @observers.each_slice(3) do |observer, on_fulfill_arg|
+        observer.promise_fulfilled(value, on_fulfill_arg)
+      end
+
+      @observers = nil
     end
   end
 
-  def dispatch!(callback)
+  def notify_rejection
     defer do
-      if fulfilled?
-        callback.fulfill(value)
-      else
-        callback.reject(reason)
+      @observers.each_slice(3) do |observer, _on_fulfill_arg, on_reject_arg|
+        observer.promise_rejected(reason, on_reject_arg)
       end
+
+      @observers = nil
     end
   end
+
+  def settle_from_handler(value)
+    fulfill(yield(value))
+  rescue => ex
+    reject(ex)
+  end
 end

data/lib/promise/group.rb

@@ -1,5 +1,7 @@
 class Promise
   class Group
+    include Promise::Observer
+
     attr_accessor :source
     attr_reader :promise
 
@@ -7,6 +9,7 @@ class Promise
       @promise = result_promise
       @inputs = inputs
       @remaining = count_promises
+
       if @remaining.zero?
         promise.fulfill(inputs)
       else
@@ -21,17 +24,7 @@ class Promise
       end
     end
 
-    private
-
-    def chain_inputs
-      on_fulfill = method(:on_fulfill)
-      on_reject = promise.public_method(:reject)
-      each_promise do |input_promise|
-        input_promise.then(on_fulfill, on_reject)
-      end
-    end
-
-    def on_fulfill(_result)
+    def promise_fulfilled(_value = nil, _arg = nil)
       @remaining -= 1
       if @remaining.zero?
         result = @inputs.map { |obj| promise?(obj) ? obj.value : obj }
@@ -39,6 +32,25 @@ class Promise
       end
     end
 
+    def promise_rejected(reason, _arg = nil)
+      promise.reject(reason)
+    end
+
+    private
+
+    def chain_inputs
+      each_promise do |input_promise|
+        case input_promise.state
+        when :fulfilled
+          promise_fulfilled
+        when :rejected
+          promise_rejected(input_promise.reason)
+        else
+          input_promise.subscribe(self, nil, nil)
+        end
+      end
+    end
+
     def promise?(obj)
       obj.is_a?(Promise)
     end

data/lib/promise/observer.rb

@@ -0,0 +1,11 @@
+class Promise
+  # The `Promise::Observer` module allows an object to be
+  # notified of `Promise` state changes.
+  #
+  # See `Promise#subscribe`.
+  module Observer
+    def promise_fulfilled(_value, _on_fulfill_arg); end
+
+    def promise_rejected(_reason, _on_reject_arg); end
+  end
+end

data/lib/promise/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 class Promise
-  VERSION = '0.7.3'.freeze
+  VERSION = '0.7.4'.freeze
 end

data/promise.rb.gemspec

@@ -19,4 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'benchmark-memory'
+  spec.add_development_dependency 'memory_profiler'
 end

data/spec/unit/promise_spec.rb

@@ -42,10 +42,6 @@ describe Promise do
       subject.fulfill(other_value)
       expect(subject.value).to eq(value)
     end
-
-    it 'freezes the value' do
-      skip 'Dropped in 74da6e9'
-    end
   end
 
   describe '3.1.3 rejected' do
@@ -62,10 +58,6 @@ describe Promise do
       subject.reject(other_reason)
       expect(subject.reason).to eq(reason)
     end
-
-    it 'freezes the reason' do
-      skip 'Dropped in 74da6e9'
-    end
   end
 
   describe '3.2.1 on_fulfill' do
@@ -169,7 +161,7 @@ describe Promise do
   end
 
   describe '3.2.4' do
-    it 'returns before on_fulfill or on_reject is called' do
+    it 'returns before on_fulfill is called when fulfilling a promise' do
       called = false
       p1 = DelayedPromise.new
       p2 = p1.then { called = true }
@@ -181,6 +173,57 @@ describe Promise do
       expect(called).to eq(true)
       expect(p2).to be_fulfilled
     end
+
+    it 'returns before on_reject is called when rejecting a promise' do
+      called = false
+      p1 = DelayedPromise.new
+      p2 = p1.then(nil, lambda do |err|
+        called = true
+        raise err
+      end)
+
+      p1.reject(42)
+
+      expect(called).to eq(false)
+      DelayedPromise.call_deferred
+      expect(called).to eq(true)
+      expect(p2).to be_rejected
+    end
+
+    it 'returns before on_fulfill is called for a fulfilled promise' do
+      called = false
+      p1 = DelayedPromise.new
+      p1.fulfill(42)
+
+      p2 = p1.then { called = true }
+
+      expect(p2).to be_pending
+      expect(called).to eq(false)
+
+      DelayedPromise.call_deferred
+
+      expect(called).to eq(true)
+      expect(p2).to be_fulfilled
+    end
+
+    it 'returns before on_reject is called for a rejected promise' do
+      called = false
+      p1 = DelayedPromise.new
+      p1.reject(42)
+
+      p2 = p1.then(nil, lambda { |err|
+        called = true
+        raise err
+      })
+
+      expect(p2).to be_pending
+      expect(called).to eq(false)
+
+      DelayedPromise.call_deferred
+
+      expect(called).to eq(true)
+      expect(p2).to be_rejected
+    end
   end
 
   describe '3.2.5' do
@@ -346,6 +389,343 @@ describe Promise do
     end
   end
 
+  describe '#fulfill' do
+    describe 'when called on a pending Promise' do
+      it 'fulfills the Promise with the given value' do
+        promise = Promise.new
+        promise.fulfill(:foo)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to equal(:foo)
+      end
+
+      it 'can be called without arguments' do
+        promise = Promise.new
+        promise.fulfill
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to be_nil
+      end
+
+      it 'returns self on a pending promise' do
+        promise = Promise.new
+        expect(promise.fulfill(:foo)).to equal(promise)
+      end
+
+      it 'returns self on a rejected promise' do
+        promise = Promise.new
+        promise.reject(:baz)
+        expect(promise.fulfill(:foo)).to equal(promise)
+      end
+
+      it 'unsets any `source` associations' do
+        other = Promise.new
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        other.fulfill(:foo)
+
+        expect(promise.source).to be_nil
+      end
+
+      it 'unsets any references to previously set observers' do
+        promise = Promise.new
+
+        observer = Class.new { include Promise::Observer }.new
+        promise.subscribe(observer, nil, nil)
+
+        promise.fulfill(:foo)
+
+        expect(promise.instance_variable_get(:@observers)).to be_nil
+      end
+    end
+
+    describe 'when called on a fulfilled Promise' do
+      it 'returns self' do
+        promise = Promise.new
+        promise.fulfill(:foo)
+
+        expect(promise.fulfill(:bar)).to equal(promise)
+      end
+
+      it 'can not change the fulfillment value' do
+        promise = Promise.new
+        promise.fulfill(:foo)
+        promise.fulfill(:bar)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to equal(:foo)
+      end
+    end
+
+    describe 'when called on a rejected Promise' do
+      it 'returns self' do
+        promise = Promise.new
+        promise.reject(:foo)
+
+        expect(promise.fulfill(:bar)).to equal(promise)
+      end
+
+      it 'can not change the rejection reason' do
+        promise = Promise.new
+        promise.reject(:foo)
+        promise.fulfill(:bar)
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to equal(:foo)
+      end
+
+      it 'does not set a fulfilment value' do
+        promise = Promise.new
+        promise.reject(:foo)
+        promise.fulfill(:bar)
+
+        expect(promise.value).to be_nil
+      end
+    end
+
+    describe 'when the fulfillment value is a pending Promise' do
+      it 'leaves the promise in a pending state' do
+        other = Promise.new
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        expect(promise).to be_pending
+      end
+
+      it 'sets the given Promise as the source' do
+        other = Promise.new
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        expect(promise.source).to equal(other)
+      end
+
+      it 'propagates promise fulfillment' do
+        other = Promise.new
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        other.fulfill(:foo)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to equal(:foo)
+      end
+
+      it 'propagates promise rejection' do
+        other = Promise.new
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        other.reject(:foo)
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to equal(:foo)
+      end
+    end
+
+    describe 'when the fulfillment value is a fulfilled Promise' do
+      it 'fulfills the Promise with the same value' do
+        other = Promise.new
+        other.fulfill(:foo)
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to equal(:foo)
+      end
+
+      it 'works with Promise subclasses' do
+        other = Class.new(Promise).new
+        other.fulfill(:foo)
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to equal(:foo)
+      end
+    end
+
+    describe 'when the fulfillment value is a rejected Promise' do
+      it 'fulfills the Promise with the same value' do
+        other = Promise.new
+        other.reject(:foo)
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to equal(:foo)
+      end
+
+      it 'works with Promise subclasses' do
+        other = Class.new(Promise).new
+        other.reject(:foo)
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to equal(:foo)
+      end
+    end
+  end
+
+  describe '#reject' do
+    describe 'when called on a pending Promise' do
+      it 'rejects the Promise with the given value' do
+        promise = Promise.new
+        promise.reject(:foo)
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to equal(:foo)
+      end
+
+      it 'can be called without arguments' do
+        promise = Promise.new
+        promise.reject
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to be_an_instance_of(Promise::Error)
+      end
+
+      it 'returns self' do
+        promise = Promise.new
+        expect(promise.reject(:foo)).to equal(promise)
+      end
+
+      it 'unsets any `source` associations' do
+        other = Promise.new
+
+        promise = Promise.new
+        promise.fulfill(other)
+
+        other.reject(:foo)
+
+        expect(promise.source).to be_nil
+      end
+
+      it 'unsets any references to previously set observers' do
+        promise = Promise.new
+
+        observer = Class.new { include Promise::Observer }.new
+        promise.subscribe(observer, nil, nil)
+
+        promise.reject(:foo)
+
+        expect(promise.instance_variable_get(:@observers)).to be_nil
+      end
+    end
+
+    describe 'when called on a fulfilled Promise' do
+      it 'returns self' do
+        promise = Promise.new
+        promise.fulfill(:foo)
+
+        expect(promise.reject(:bar)).to equal(promise)
+      end
+
+      it 'can not change the fulfillment value' do
+        promise = Promise.new
+        promise.fulfill(:foo)
+        promise.reject(:bar)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to equal(:foo)
+      end
+
+      it 'does not set a rejection reason' do
+        promise = Promise.new
+        promise.fulfill(:foo)
+        promise.reject(:bar)
+
+        expect(promise.reason).to be_nil
+      end
+    end
+
+    describe 'when called on a rejected Promise' do
+      it 'returns self' do
+        promise = Promise.new
+        promise.reject(:foo)
+
+        expect(promise.reject(:bar)).to equal(promise)
+      end
+
+      it 'can not change the rejection reason' do
+        promise = Promise.new
+        promise.reject(:foo)
+        promise.reject(:bar)
+
+        expect(promise).to be_rejected
+        expect(promise.reason).to equal(:foo)
+      end
+    end
+  end
+
+  describe '#subscribe' do
+    it 'sets up the observer to be notified of promise fulfillment' do
+      promise = Promise.new
+
+      observer = Class.new { include Promise::Observer }.new
+      promise.subscribe(observer, :fulfill_arg, :reject_arg)
+
+      expect(observer).to receive(:promise_fulfilled).with(:foo, :fulfill_arg)
+      promise.fulfill(:foo)
+    end
+
+    it 'sets up the observer to be notified of promise rejection' do
+      promise = Promise.new
+
+      observer = Class.new { include Promise::Observer }.new
+      promise.subscribe(observer, :fulfill_arg, :reject_arg)
+
+      expect(observer).to receive(:promise_rejected).with(:foo, :reject_arg)
+      promise.reject(:foo)
+    end
+
+    it 'fails when called on a fulfilled promise' do
+      promise = Promise.new
+      promise.fulfill(:foo)
+
+      observer = Class.new { include Promise::Observer }.new
+
+      expected_message = 'Non-pending promises can not be observed'
+      expect {
+        promise.subscribe(observer, :fulfill_arg, :reject_arg)
+      }.to raise_error(Promise::Error, expected_message)
+    end
+
+    it 'fails when called on a rejected promise' do
+      promise = Promise.new
+      promise.reject(:foo)
+
+      observer = Class.new { include Promise::Observer }.new
+
+      expected_message = 'Non-pending promises can not be observed'
+      expect {
+        promise.subscribe(observer, :fulfill_arg, :reject_arg)
+      }.to raise_error(Promise::Error, expected_message)
+    end
+
+    it 'fails when the given observer is not a `Promise::Observer`' do
+      promise = Promise.new
+
+      observer = Object.new
+
+      expected_message = 'Expected `observer` to be a `Promise::Observer`'
+      expect {
+        promise.subscribe(observer, :fulfill_arg, :reject_arg)
+      }.to raise_error(ArgumentError, expected_message)
+    end
+  end
+
   describe 'extras' do
     describe '#rescue' do
       it 'provides an on_reject callback' do
@@ -563,11 +943,20 @@ describe Promise do
     end
 
     describe '.all' do
-      it 'returns a fulfilled promise for an array with no promises' do
-        obj = Object.new
-        promise = Promise.all([1, 'b', obj])
-        expect(promise.fulfilled?).to eq(true)
-        expect(promise.value).to eq([1, 'b', obj])
+      it "fulfills the result with inputs if they don't contain promises" do
+        input = [1, 'b']
+        promise = Promise.all(input)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to eq([1, 'b'])
+      end
+
+      it 'fulfills the result when all args are already fulfilled' do
+        input = [1, Promise.resolve(2.0)]
+        promise = Promise.all(input)
+
+        expect(promise).to be_fulfilled
+        expect(promise.value).to eq([1, 2.0])
       end
 
       it 'fulfills the result when all args are fulfilled' do
@@ -597,6 +986,16 @@ describe Promise do
         expect(result.value).to eq(['a', :b])
       end
 
+      it 'rejects the result when any input promise is already rejected' do
+        p1 = Promise.new
+        p2 = Promise.new.reject(:foo)
+
+        result = Promise.all([p1, p2])
+
+        expect(result).to be_rejected
+        expect(result.reason).to eq(:foo)
+      end
+
       it 'rejects the result when any args is rejected' do
         p1 = Promise.new
         p2 = Promise.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: promise.rb
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Lars Gierth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-28 00:00:00.000000000 Z
+date: 2017-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,6 +24,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-memory
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Promises/A+ for Ruby
 email:
 - lars.gierth@gmail.com
@@ -39,6 +81,8 @@ files:
 - README.md
 - Rakefile
 - UNLICENSE
+- benchmark/run.rb
+- benchmark/setup.rb
 - config/devtools.yml
 - config/flay.yml
 - config/flog.yml
@@ -47,8 +91,8 @@ files:
 - config/rubocop.yml
 - config/yardstick.yml
 - lib/promise.rb
-- lib/promise/callback.rb
 - lib/promise/group.rb
+- lib/promise/observer.rb
 - lib/promise/progress.rb
 - lib/promise/version.rb
 - promise.rb.gemspec

data/lib/promise/callback.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-class Promise
-  class Callback
-    attr_accessor :source
-
-    def initialize(on_fulfill, on_reject, next_promise)
-      @on_fulfill = on_fulfill
-      @on_reject = on_reject
-      @next_promise = next_promise
-      @next_promise.source = self
-    end
-
-    def fulfill(value)
-      if @on_fulfill
-        call_block(@on_fulfill, value)
-      else
-        @next_promise.fulfill(value)
-      end
-    end
-
-    def reject(reason)
-      if @on_reject
-        call_block(@on_reject, reason)
-      else
-        @next_promise.reject(reason)
-      end
-    end
-
-    def wait
-      source.wait
-    end
-
-    private
-
-    def call_block(block, param)
-      @next_promise.fulfill(block.call(param))
-    rescue => ex
-      @next_promise.reject(ex)
-    end
-  end
-  private_constant :Callback
-end