a-ruby-promise 0.0.1

data/spec/promises_aplus/2_2_5_spec.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+describe "2.2.5 `onFulfilled` and `onRejected` must be called as functions (i.e. with no `this` value)." do
+  it "is specific to JavaScript" do skip end
+end

data/spec/promises_aplus/2_2_6_spec.rb

@@ -0,0 +1,238 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" } # we fulfill or reject with this when we don't intend to test against it
+other = { other: "other" } # a value we don't want to be strict equal to
+sentinel = { sentinel: "sentinel" } # a sentinel fulfillment value to test for with strict equality
+sentinel2 = { sentinel2: "sentinel2" }
+sentinel3 = { sentinel3: "sentinel3" }
+
+CallbackAggregator = Struct.new(:times, :ultimate_callback) do
+  def call
+    @so_far = (@so_far || 0) + 1
+    ultimate_callback.call if @so_far == times
+  end
+end
+
+describe "2.2.6: `then` may be called multiple times on the same promise." do
+  include PromisesAplus
+
+  describe "2.2.6.1: If/when `promise` is fulfilled, all respective `onFulfilled` callbacks must execute in the order of their originating calls to `then`." do
+    describe "multiple boring fulfillment handlers" do
+      PromisesAplus.test_fulfilled(self, sentinel) do |promise, done|
+        handler1 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler2 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler3 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        spy = Minitest::Mock.new
+
+        promise.then(handler1, spy)
+        promise.then(handler2, spy)
+        promise.then(handler3, spy)
+
+        promise.then ->(value) {
+          value.must_equal sentinel
+          [handler1, handler2, handler3, spy].each(&:verify)
+          done.call
+        }
+      end
+    end
+
+    describe "multiple fulfillment handlers, one of which throws" do
+      PromisesAplus.test_fulfilled(self, sentinel) do |promise, done|
+        handler1 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler2 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler3 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        spy = Minitest::Mock.new
+
+        promise.then(handler1, spy)
+        promise.then(->(value) { handler2.call(value); throw(other) }, spy)
+        promise.then(handler3, spy)
+
+        promise.then ->(value) {
+          value.must_equal sentinel
+          [handler1, handler2, handler3, spy].each(&:verify)
+          done.call
+        }
+      end
+    end
+
+    describe "results in multiple branching chains with their own fulfillment values" do
+      PromisesAplus.test_fulfilled(self, sentinel) do |promise, done|
+        semi_done = CallbackAggregator.new(3, done)
+
+        promise.then(->(value) {
+          sentinel
+        }).then(->(value) {
+          value.must_equal sentinel
+          semi_done.call
+        })
+
+        promise.then(->(value) {
+          raise Exception.new(sentinel2)
+        }).then(nil, ->(reason) {
+          reason.to_s.must_equal sentinel2.to_s
+          semi_done.call
+        })
+
+        promise.then(->(value) {
+          sentinel3
+        }).then(->(value) {
+          value.must_equal sentinel3
+          semi_done.call
+        })
+      end
+    end
+
+    describe "`onFulfilled` handlers are called in the original order" do
+      PromisesAplus.test_fulfilled(self, dummy) do |promise, done|
+        handler1 = Minitest::Mock.new.expect(:call, 1, [dummy])
+        handler2 = Minitest::Mock.new.expect(:call, 2, [dummy])
+        handler3 = Minitest::Mock.new.expect(:call, 3, [dummy])
+        sequence = Minitest::Mock.new.expect(:call, nil, [1]).expect(:call, nil, [2]).expect(:call, nil, [3])
+
+        promise.then(handler1).then(sequence)
+        promise.then(handler2).then(sequence)
+        promise.then(handler3).then(sequence)
+
+        promise.then ->(value) {
+          value.must_equal dummy
+          [handler1, handler2, handler3, sequence].each(&:verify)
+          done.call
+        }
+      end
+
+      describe "even when one handler is added inside another handler" do
+        PromisesAplus.test_fulfilled(self, dummy) do |promise, done|
+          handler1 = Minitest::Mock.new.expect(:call, 1, [dummy])
+          handler2 = Minitest::Mock.new.expect(:call, 2, [dummy])
+          handler3 = Minitest::Mock.new.expect(:call, 3, [dummy])
+          sequence = Minitest::Mock.new.expect(:call, nil, [1]).expect(:call, nil, [2]).expect(:call, nil, [3])
+
+          # TODO: The JavaScript spec adds handler3 inside this handler,
+          # but since we don't have the delayed execution of handlers, we can't do that!
+          promise.then ->(value) {
+            sequence.call(handler1.call(value))
+            promise.then(handler2).then(sequence)
+          }
+          promise.then(handler3).then(sequence)
+
+          promise.then ->(value) {
+            value.must_equal dummy
+            [handler1, handler2, handler3, sequence].each(&:verify)
+            done.call
+          }
+        end
+      end
+    end
+  end
+
+  describe "2.2.6.2: If/when `promise` is rejected, all respective `onRejected` callbacks must execute in the order of their originating calls to `then`." do
+    describe "multiple boring rejection handlers" do
+      PromisesAplus.test_rejected(self, sentinel) do |promise, done|
+        handler1 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler2 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler3 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        spy = Minitest::Mock.new
+
+        promise.then(spy, handler1)
+        promise.then(spy, handler2)
+        promise.then(spy, handler3)
+
+        promise.then nil, ->(reason) {
+          reason.must_equal sentinel
+          [handler1, handler2, handler3, spy].each(&:verify)
+          done.call
+        }
+      end
+    end
+
+    describe "multiple rejection handlers, one of which throws" do
+      PromisesAplus.test_rejected(self, sentinel) do |promise, done|
+        handler1 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler2 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        handler3 = Minitest::Mock.new.expect(:call, nil, [sentinel])
+        spy = Minitest::Mock.new
+
+        promise.then(spy, handler1)
+        promise.then(spy, ->(reason) { handler2.call(reason); throw(other) })
+        promise.then(spy, handler3)
+
+        promise.then nil, ->(reason) {
+          reason.must_equal sentinel
+          [handler1, handler2, handler3, spy].each(&:verify)
+          done.call
+        }
+      end
+    end
+
+    describe "results in multiple branching chains with their own fulfillment values" do
+      PromisesAplus.test_rejected(self, sentinel) do |promise, done|
+        semi_done = CallbackAggregator.new(3, done)
+
+        promise.then(nil, ->(reason) {
+          sentinel
+        }).then(->(value) {
+          value.must_equal sentinel
+          semi_done.call
+        })
+
+        promise.then(nil, ->(reason) {
+          raise Exception.new(sentinel2)
+        }).then(nil, ->(reason) {
+          reason.to_s.must_equal sentinel2.to_s
+          semi_done.call
+        })
+
+        promise.then(nil, ->(reason) {
+          sentinel3
+        }).then(->(value) {
+          value.must_equal sentinel3
+          semi_done.call
+        })
+      end
+    end
+
+    describe "`onRejected` handlers are called in the original order" do
+      PromisesAplus.test_rejected(self, dummy) do |promise, done|
+        handler1 = Minitest::Mock.new.expect(:call, 1, [dummy])
+        handler2 = Minitest::Mock.new.expect(:call, 2, [dummy])
+        handler3 = Minitest::Mock.new.expect(:call, 3, [dummy])
+        sequence = Minitest::Mock.new.expect(:call, nil, [1]).expect(:call, nil, [2]).expect(:call, nil, [3])
+
+        promise.then(nil, handler1).then(sequence)
+        promise.then(nil, handler2).then(sequence)
+        promise.then(nil, handler3).then(sequence)
+
+        promise.then nil, ->(reason) {
+          reason.must_equal dummy
+          [handler1, handler2, handler3, sequence].each(&:verify)
+          done.call
+        }
+      end
+
+      describe "even when one handler is added inside another handler" do
+        PromisesAplus.test_rejected(self, dummy) do |promise, done|
+          handler1 = Minitest::Mock.new.expect(:call, 1, [dummy])
+          handler2 = Minitest::Mock.new.expect(:call, 2, [dummy])
+          handler3 = Minitest::Mock.new.expect(:call, 3, [dummy])
+          sequence = Minitest::Mock.new.expect(:call, nil, [1]).expect(:call, nil, [2]).expect(:call, nil, [3])
+
+          # TODO: The JavaScript spec adds handler3 inside this handler,
+          # but since we don't have the delayed execution of handlers, we can't do that!
+          promise.then nil, ->(reason) {
+            sequence.call(handler1.call(reason))
+            promise.then(nil, handler2).then(sequence)
+          }
+          promise.then(nil, handler3).then(sequence)
+
+          promise.then nil, ->(reason) {
+            reason.must_equal dummy
+            [handler1, handler2, handler3, sequence].each(&:verify)
+            done.call
+          }
+        end
+      end
+    end
+  end
+end

data/spec/promises_aplus/2_2_7_spec.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" } # we fulfill or reject with this when we don't intend to test against it
+sentinel = { sentinel: "sentinel" } # a sentinel fulfillment value to test for with strict equality
+other = { other: "other" } # a value we don't want to be strict equal to
+
+reasons = {
+  "`nil`" => nil,
+  "`false`" => false,
+  "`0`" => 0,
+  "an error" => StandardError.new,
+  "an error without a stack" => StandardError.new,
+  "a date" => Time.now,
+  "an object" => Object.new,
+  "an always-pending thenable" => Struct.new(:then).new(->(v) {}),
+  "a fulfilled promise" => resolved(dummy),
+  "a rejected promise" => rejected(dummy)
+}
+
+non_functions = {
+  "`nil`" => nil,
+  "`false`" => false,
+  "`5`" => 5,
+  "an object" => Object.new,
+  "an array containing a callable" => [->(value) { other }]
+}
+
+describe "2.2.7: `then` must return a promise: `promise2 = promise1.then(onFulfilled, onRejected)`" do
+  include PromisesAplus
+
+  it "is a promise" do
+    promise1 = deferred.promise
+    promise2 = promise1.then
+
+    promise2.must_be_kind_of Promise
+    done!
+  end
+
+  describe "2.2.7.1: If either `onFulfilled` or `onRejected` returns a value `x`, run the Promise Resolution Procedure `[[Resolve]](promise2, x)`" do
+    it "see separate 3.3 tests" do
+      done! and skip
+    end
+  end
+
+  describe "2.2.7.2: If either `onFulfilled` or `onRejected` throws an exception `e`, `promise2` must be rejected with `e` as the reason." do
+    reasons.each do |description, expected_reason|
+      describe "The reason is #{description}" do
+        PromisesAplus.test_fulfilled(self, dummy) do |promise1, done|
+          promise2 = promise1.then ->(value) {
+            raise Exception, expected_reason.to_s
+          }
+          promise2.then nil, ->(reason) {
+            reason.to_s.must_equal expected_reason.to_s
+            done.call
+          }
+        end
+        PromisesAplus.test_rejected(self, dummy) do |promise1, done|
+          promise2 = promise1.then nil, ->(reason) {
+            raise Exception, expected_reason.to_s
+          }
+          promise2.then nil, ->(reason) {
+            reason.to_s.must_equal expected_reason.to_s
+            done.call
+          }
+        end
+      end
+    end
+  end
+
+  describe "2.2.7.3: If `onFulfilled` is not a function and `promise1` is fulfilled, `promise2` must be fulfilled with the same value." do
+    non_functions.each do |description, non_function|
+      describe "`onFulfilled` is #{description}" do
+        PromisesAplus.test_fulfilled(self, sentinel) do |promise1, done|
+          promise2 = promise1.then(non_function)
+          promise2.then ->(value) {
+            value.must_equal sentinel
+            done.call
+          }
+        end
+      end
+    end
+  end
+
+  describe "2.2.7.4: If `onRejected` is not a function and `promise1` is rejected, `promise2` must be rejected with the same reason." do
+    non_functions.each do |description, non_function|
+      describe "`onRejected` is #{description}" do
+        PromisesAplus.test_rejected(self, sentinel) do |promise1, done|
+          promise2 = promise1.then(nil, non_function)
+          promise2.then nil, ->(reason) {
+            reason.must_equal sentinel
+            done.call
+          }
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require "minitest/autorun"
+require "minitest/mock"
+require "minitest/pride"
+require "a-ruby-promise"
+require_relative "deferred"
+
+Thread.abort_on_exception = true
+
+def resolved(value)
+  Promise.new { fulfill(value) }
+end
+
+def rejected(reason)
+  Promise.new { reject(reason) }
+end
+
+def deferred
+  Deferred.new
+end
+
+def short_sleep
+  sleep 0.05
+end
+
+def assert_unresolved(*promises)
+  promises.each { |promise| promise.must_be :pending? }
+end
+
+def assert_resolved(*promises)
+  promises.each { |promise| promise.wont_be :pending? }
+end
+
+def eventually(&block)
+  time_limit = Time.now + 2
+  loop do
+    begin
+      yield
+    rescue Minitest::Assertion => error
+    end
+    return if error.nil?
+    raise error if Time.now >= time_limit
+    sleep 0.05
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: a-ruby-promise
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tobias Haagen Michaelsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: minitest
+  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: guard
+  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: guard-minitest
+  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: A Ruby Promise implementation that attempts to comply with the Promises/A+
+  specification and test suite.
+email:
+- tobias.michaelsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/a-ruby-promise.rb
+- lib/promise.rb
+- lib/promise/version.rb
+- spec/aplus_spec.rb
+- spec/deferred.rb
+- spec/promise_spec.rb
+- spec/promises_aplus.rb
+- spec/promises_aplus/2_1_2_spec.rb
+- spec/promises_aplus/2_1_3_spec.rb
+- spec/promises_aplus/2_2_1_spec.rb
+- spec/promises_aplus/2_2_2_spec.rb
+- spec/promises_aplus/2_2_3_spec.rb
+- spec/promises_aplus/2_2_4_spec.rb
+- spec/promises_aplus/2_2_5_spec.rb
+- spec/promises_aplus/2_2_6_spec.rb
+- spec/promises_aplus/2_2_7_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tobiashm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Promises in Ruby
+test_files:
+- spec/aplus_spec.rb
+- spec/deferred.rb
+- spec/promise_spec.rb
+- spec/promises_aplus.rb
+- spec/promises_aplus/2_1_2_spec.rb
+- spec/promises_aplus/2_1_3_spec.rb
+- spec/promises_aplus/2_2_1_spec.rb
+- spec/promises_aplus/2_2_2_spec.rb
+- spec/promises_aplus/2_2_3_spec.rb
+- spec/promises_aplus/2_2_4_spec.rb
+- spec/promises_aplus/2_2_5_spec.rb
+- spec/promises_aplus/2_2_6_spec.rb
+- spec/promises_aplus/2_2_7_spec.rb
+- spec/spec_helper.rb