a-ruby-promise 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5e232579789fc7da3951b73e4eaf841cade3a27
+  data.tar.gz: 5abeb4887d52eb58764b13f6ec793cc9299a6382
+SHA512:
+  metadata.gz: 72bd28e4bc5cc0621bf7a7203a089d6e5006444c8c11ed2a994f7094536217d2f081fd26d6ab2562c727431c82aea400a75b4658133ef7712c54c09c4553021d
+  data.tar.gz: 98d4668c57d5b47f257cdf01461e106aa527f58c707d72ba775e91eee30942ae871ff4cf66ea4d4f5f784119ee9a38913d93b1c8f1e50060b40eb1c2bc736bfc

data/lib/a-ruby-promise.rb

@@ -0,0 +1 @@
+require "promise"

data/lib/promise.rb

@@ -0,0 +1,95 @@
+require "promise/version"
+
+class Promise
+
+  attr_reader :state, :value, :reason
+
+  def initialize(&block)
+    @state = :pending
+    @value = nil
+    @reason = nil
+    @callbacks = []
+    @errbacks = []
+    instance_eval(&block) if block_given?
+  end
+
+  %w[pending fulfilled rejected].each do |state|
+    define_method("#{state}?") { @state == state.to_sym }
+  end
+
+  def then(on_fulfilled = nil, on_rejected = nil)
+    result = Promise.new
+
+    call_and_fulfill = ->(value) {
+      begin
+        if function?(on_fulfilled)
+          new_value = on_fulfilled.call(value)
+          if Promise === new_value
+            new_value.then(->(v) { result.fulfill(v) }, ->(r) { result.reject(r) })
+          else
+            result.fulfill(new_value)
+          end
+        else
+          result.fulfill(value)
+        end
+      rescue Exception => e
+        result.reject(e)
+      end
+    }
+
+    call_and_reject = ->(reason) {
+      begin
+        if function?(on_rejected)
+          new_value = on_rejected.call(reason)
+          if Promise === new_value
+            new_value.then(->(v) { result.fulfill(v) }, ->(r) { result.reject(r) })
+          else
+            result.fulfill(new_value)
+          end
+        else
+          result.reject(reason)
+        end
+      rescue Exception => e
+        result.reject(e)
+      end
+    }
+
+    case @state
+    when :pending
+      @callbacks << call_and_fulfill
+      @errbacks << call_and_reject
+    when :fulfilled
+      call_and_fulfill.call(@value)
+    when :rejected
+      call_and_reject.call(@reason)
+    end
+
+    result
+  end
+
+protected
+
+  def fulfill(value)
+    return unless @state == :pending
+    @state = :fulfilled
+    @value = value
+    while callback = @callbacks.shift
+      callback.call(value) rescue nil
+    end
+  end
+
+  def reject(reason)
+    return unless @state == :pending
+    @state = :rejected
+    @reason = reason
+    while errback = @errbacks.shift
+      errback.call(reason) rescue nil
+    end
+  end
+
+private
+
+  def function?(obj)
+    obj.respond_to? :call
+  end
+end

data/lib/promise/version.rb

@@ -0,0 +1,3 @@
+class Promise
+  VERSION = "0.0.1"
+end

data/spec/aplus_spec.rb

@@ -0,0 +1,46 @@
+require_relative "spec_helper"
+
+# Test suite from the `aplus` Python Promise implementation.
+# https://github.com/xogeny/aplus#testing
+
+describe Promise do
+  describe "Handles the case where the arguments to then are not functions or promises." do
+    it "3.2.6.4 pending" do
+      d = deferred
+      p1 = d.promise
+      p2 = p1.then(5)
+      d.fulfill(10)
+      p1.value.must_equal 10
+      p2.state.must_equal :fulfilled
+      p2.value.must_equal 10
+    end
+
+    it "3.2.6.4 fulfilled" do
+      p1 = resolved(10)
+      p2 = p1.then(5)
+      p1.value.must_equal 10
+      p2.state.must_equal :fulfilled
+      p2.value.must_equal 10
+    end
+  end
+
+  describe "Handles the case where the arguments to then are values, not functions or promises." do
+    it "3.2.6.5 pending" do
+      d = deferred
+      p1 = d.promise
+      p2 = p1.then(nil, 5)
+      d.reject("Error")
+      p1.reason.must_equal "Error"
+      p2.state.must_equal :rejected
+      p2.reason.must_equal "Error"
+    end
+
+    it "3.2.6.5 rejected" do
+      p1 = rejected("Error")
+      p2 = p1.then(nil, 5)
+      p1.reason.must_equal "Error"
+      p2.state.must_equal :rejected
+      p2.reason.must_equal "Error"
+    end
+  end
+end

data/spec/deferred.rb

@@ -0,0 +1,16 @@
+class Deferred
+  attr_reader :promise
+
+  def initialize
+    @promise = Promise.new
+  end
+
+  def fulfill(value)
+    @promise.__send__(:fulfill, value)
+  end
+  alias_method :resolve, :fulfill
+
+  def reject(reason)
+    @promise.__send__(:reject, reason)
+  end
+end

data/spec/promise_spec.rb

@@ -0,0 +1,50 @@
+require_relative "spec_helper"
+
+def timeout_promise(promise, timeout_in_seconds)
+  Promise.new do
+    promise.then method(:fulfill)
+    Thread.new do
+      sleep timeout_in_seconds
+      reject "Timeout reached"
+    end
+  end
+end
+
+describe Promise do
+  describe "simple fulfillment" do
+    it "must call success handler after fulfill" do
+      v = nil
+      d = deferred
+      p = d.promise
+      p.then ->(value) { v = value }
+      v.must_equal nil
+      d.fulfill(42)
+      v.must_equal 42
+    end
+  end
+
+  describe "timeout" do
+    it "fulfills quickly" do
+      d = deferred
+      p1 = d.promise
+      p2 = timeout_promise(p1, 0.05)
+      d.fulfill "ok"
+      p2.state.must_equal :fulfilled
+      p2_value = nil
+      p2.then ->(value) { p2_value = value }
+      p2_value.must_equal "ok"
+    end
+
+    it "rejects after some time" do
+      d = deferred
+      p1 = d.promise
+      p2 = timeout_promise(p1, 0.05)
+      sleep 0.1
+      d.fulfill "ok"
+      p2.state.must_equal :rejected
+      p2_reason = nil
+      p2.then nil, ->(reason) { p2_reason = reason }
+      p2_reason.must_equal "Timeout reached"
+    end
+  end
+end

data/spec/promises_aplus.rb

@@ -0,0 +1,58 @@
+# http://promises-aplus.github.io/promises-spec/
+# https://github.com/promises-aplus/promises-tests
+module PromisesAplus
+  def setup
+    @done = false
+  end
+
+  def teardown
+    time_limit = Time.now + 2
+    loop do
+      return if @done == true
+      raise Minitest::Assertion.new("`done` was never called") if Time.now >= time_limit
+      sleep 0.05
+    end
+  end
+
+  def done!
+    @done = true
+  end
+
+  def self.test_fulfilled(base, value, &test)
+    base.it "already-fulfilled" do
+      test.call(resolved(value), method(:done!))
+    end
+
+    base.it "immediately-fulfilled" do
+      d = deferred()
+      test.call(d.promise, method(:done!))
+      d.resolve(value)
+    end
+
+    base.it "eventually-fulfilled" do
+      d = deferred()
+      test.call(d.promise, method(:done!))
+      short_sleep
+      d.resolve(value)
+    end
+  end
+
+  def self.test_rejected(base, reason, &test)
+    base.it "already-rejected" do
+      test.call(rejected(reason), method(:done!))
+    end
+
+    base.it "immediately-rejected" do
+      d = deferred
+      test.call(d.promise, method(:done!))
+      d.reject(reason)
+    end
+
+    base.it "eventually-rejected" do
+      d = deferred
+      test.call(d.promise, method(:done!))
+      short_sleep
+      d.reject(reason)
+    end
+  end
+end

data/spec/promises_aplus/2_1_2_spec.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" }
+
+describe "2.1.2.1: When fulfilled, a promise: must not transition to any other state." do
+  include PromisesAplus
+
+  PromisesAplus.test_fulfilled(self, dummy) do |promise, done|
+    on_fulfilled_called = false
+
+    promise.then ->(v) {
+      onFulfilledCalled = true
+    }, ->(r) {
+      on_fulfilled_called.must_equal false
+      done.call
+    }
+
+    short_sleep and done.call
+  end
+
+  it "trying to fulfill then immediately reject" do
+    d = deferred
+    on_fulfilled_called = false
+    d.promise.then ->(v) {
+      on_fulfilled_called = true
+    }, ->(r) {
+      on_fulfilled_called.must_equal false
+      done!
+    }
+    d.resolve(dummy)
+    d.reject(dummy)
+
+    short_sleep and done!
+  end
+
+  it "trying to fulfill then reject, delayed" do
+    d = deferred
+    on_fulfilled_called = false
+
+    d.promise.then ->(v) {
+      on_fulfilled_called = true
+    }, ->(r) {
+      on_fulfilled_called.must_equal false
+      done!
+    }
+
+    d.resolve(dummy)
+    Thread.new do
+      short_sleep
+      d.reject(dummy)
+    end
+
+    2.times { short_sleep } and done!
+  end
+end

data/spec/promises_aplus/2_1_3_spec.rb

@@ -0,0 +1,76 @@
+# 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
+
+describe "2.1.3.1: When rejected, a promise: must not transition to any other state." do
+  include PromisesAplus
+
+  PromisesAplus.test_rejected(self, dummy) do |promise, done|
+    on_rejected_called = false
+
+    promise.then ->(v) {
+      on_rejected_called.must_equal false
+      done.call
+    }, ->(r) {
+      on_rejected_called = true
+    }
+
+    short_sleep and done.call
+  end
+
+  it "trying to reject then immediately fulfill" do
+    d = deferred
+    on_rejected_called = false
+
+    d.promise.then ->(v) {
+      on_rejected_called.must_equal false
+      done!
+    }, ->(r) {
+      on_rejected_called = true
+    }
+
+    d.reject(dummy)
+    d.resolve(dummy)
+    short_sleep and done!
+  end
+
+  it "trying to reject then fulfill, delayed" do
+    d = deferred
+    on_rejected_called = false
+
+    d.promise.then ->(v) {
+      on_rejected_called.must_equal false
+      done!
+    }, ->(r) {
+      on_rejected_called = true
+    }
+
+    Thread.new do
+      short_sleep
+      d.reject(dummy)
+      d.resolve(dummy)
+    end
+    2.times { short_sleep } and done!
+  end
+
+  it "trying to reject immediately then fulfill delayed" do
+    d = deferred
+    on_rejected_called = false
+
+    d.promise.then ->(v) {
+      on_rejected_called.must_equal false
+      done!
+    }, ->(r) {
+      on_rejected_called = true
+    }
+
+    d.reject(dummy)
+    Thread.new do
+      short_sleep
+      d.resolve(dummy)
+    end
+    2.times { short_sleep } and done!
+  end
+end

data/spec/promises_aplus/2_2_1_spec.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" }
+
+describe "2.2.1: Both `onFulfilled` and `onRejected` are optional arguments." do
+  include PromisesAplus
+
+  describe "2.2.1.1: If `onFulfilled` is not a function, it must be ignored." do
+    [nil, false, 5, Object.new].each do |non_function|
+      describe "applied to a directly-rejected promise" do
+        it "`onFulfilled` is `#{non_function.inspect}`" do
+          rejected(dummy).then(non_function, ->(r) {
+            done!
+          })
+        end
+      end
+
+      describe "applied to a promise rejected and then chained off of" do
+        it "`onFulfilled` is #{non_function.inspect}" do
+          rejected(dummy).then(->(v) { }, nil).then(non_function, ->(r) {
+            done!
+          })
+        end
+      end
+    end
+  end
+
+  describe "2.2.1.2: If `onRejected` is not a function, it must be ignored." do
+    [nil, false, 5, Object.new].each do |non_function|
+      describe "applied to a directly-fulfilled promise" do
+        it "`onRejected` is `#{non_function.inspect}`" do
+          resolved(dummy).then(->(v) {
+            done!
+          }, non_function)
+        end
+      end
+
+      describe "applied to a promise fulfilled and then chained off of" do
+        it "`onRejected` is `#{non_function.inspect}`" do
+          resolved(dummy).then(nil, ->(r) { }).then(->(v) {
+            done!
+          }, non_function)
+        end
+      end
+    end
+  end
+end