rosarium 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0c296247c0162ee53783379115ff4a8aaa6a33e
+  data.tar.gz: fcfdc65d25c8610894b0c00087b4a12762c53056
+SHA512:
+  metadata.gz: 36bc6091d46684b63bb142db5b4b638785ea69552f8e00f2377c7dfdbe88be38abcc9d60fe827bca648308c30071f272b58ff7aca87e86679f888527897e4ae9
+  data.tar.gz: 6a6a19090556dfba2defc71ff3c2ac44e884682003df62439148c39b1c546e49f7b4a074276c83362552fc66b1e47984ccac758c7ab0e9116f447fd2fab88e2c

data/Gemfile

@@ -0,0 +1 @@
+gem 'rspec', '~> 3.4'

data/Gemfile.lock

@@ -0,0 +1,25 @@
+GEM
+  specs:
+    diff-lcs (1.2.5)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 3.4)
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2016 Rachel Evans
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,119 @@
+# Rosarium
+
+A library for implementing Promises - or something like them - in ruby.
+
+# Why?
+
+Because I keep hitting bugs and annoying inflexibilities in `concurrent-ruby`,
+whereas I really enjoy the stability and flexibility of JavaScript's "Q"
+library (<https://github.com/kriskowal/q/wiki/API-Reference>).
+
+I'm not expecting anyone but me to use this code at this time.  But you're
+welcome to do so, if you like.
+
+# Example
+
+```
+  require 'rosarium'
+```
+
+## Static methods for creating promises:
+
+```
+  # Immediately ready for async execution:
+  promise = Rosarium::Promise.execute { ... }
+
+  # Immediately fulfilled:
+  promise = Rosarium::Promise.resolve(anything_except_a_promise)
+
+  # Immediately rejected:
+  promise = Rosarium::Promise.reject(an_exception)
+
+  # The same promise (returns its argument)
+  a_promise = Rosarium::Promise.resolve(a_promise)
+
+  # Once all promises in the list are fulfilled, then fulfill with a list of
+  # their values.  If any promise in the list is rejected, then reject with
+  # the same reason:
+  promise = Rosarium::Promise.all([ promise1, promise2, ... ])
+
+  # Wait for all the promises in the list to become settled (fulfilled or
+  # rejected); then fulfill with the list of promises.
+  promise = Rosarium::Promise.all_settled([ promise1, promise2, ... ])
+```
+
+## Deferreds
+
+```
+  # Create a "deferred":
+  deferred = Rosarium::Promise.defer
+  promise = deferred.promise
+```
+
+then later, use the "deferred" to fulfill or reject the promise:
+
+```
+  # Fulfill:
+  deferred.resolve(anything_except_a_promise)
+
+  # Reject:
+  deferred.reject(an_exception)
+
+  # Fulfill or reject, once the other promise is fulfilled / rejected:
+  deferred.resolve(other_promise)
+```
+
+## Methods of promises:
+
+```
+  # One of: :pending, :resolving, :fulfilled, :rejected.
+  promise.state
+
+  # Wait for the promise to be settled, then return its value (if fulfilled -
+  # note the value may be nil), or nil (if rejected).
+  promise.value
+
+  # Wait for the promise to be settled, then return its reason (if rejected),
+  # or nil (if fulfilled).
+  promise.reason
+
+  # true iff state == :fulfilled
+  promise.fulfilled?
+
+  # true iff state == :rejected
+  promise.rejected?
+
+  # Wait for the promise to be settled, then return its value (if fulfilled),
+  # or raise with the rejection reason (if rejected).
+  promise.value!
+
+  # Wait for the promise to be settled
+  promise.wait
+```
+
+Chaining promises together:
+
+```
+  # Handling promise1 fulfillment:
+  promise2 = promise1.then { |promise1_value| ... }
+
+  # Four different ways of handling promise1 rejection:
+  promise2 = promise1.then(Proc.new { |promise1_reason| ... })
+  promise2 = promise1.rescue { |promise1_reason| ... }
+  promise2 = promise1.catch { |promise1_reason| ... }
+  promise2 = promise1.on_error { |promise1_reason| ... }
+
+  # Handle both fulfillment and rejection:
+  promise2 = promise1.then(Proc.new { |promise1_reason| ... }) { |promise1_value| ... }
+```
+
+# Miscellany
+
+Promise code (every time a ruby block appears in the above examples) is run
+via a fixed-size thread pool, currently set to 10 threads.  Execution order is
+not defined.
+
+In comparison to the Promises/A+ spec <https://promisesaplus.com/>, these
+promises have an extra possible state, `:resolving`.  You are encouraged to
+use `#fulfilled?` and `#rejected?` instead anyway.
+

data/lib/rosarium/deferred.rb

@@ -0,0 +1,25 @@
+module Rosarium
+
+  class Deferred
+
+    def initialize(promise, resolver, rejecter)
+      @promise = promise
+      @resolver = resolver
+      @rejecter = rejecter
+    end
+
+    def promise
+      @promise
+    end
+
+    def resolve(value)
+      @resolver.call(value)
+    end
+
+    def reject(reason)
+      @rejecter.call(reason)
+    end
+
+  end
+
+end

data/lib/rosarium/fixed_thread_executor.rb

@@ -0,0 +1,61 @@
+module Rosarium
+
+  class FixedThreadExecutor
+
+    def initialize(max = 1)
+      @max = max
+      @mutex = Mutex.new
+      @waiting = []
+      @executing = 0
+      @threads = []
+    end
+
+    def submit(&block)
+      @mutex.synchronize do
+        @waiting << block
+        if @executing < @max
+          @executing = @executing + 1
+          t = Thread.new { execute_and_count_down }
+          @threads.push t
+        end
+      end
+    end
+
+    def discard
+      @mutex.synchronize { @waiting.clear }
+    end
+
+    def wait_until_idle
+      loop do
+        t = @mutex.synchronize { @threads.shift }
+        t or break
+        t.join
+      end
+    end
+
+    private
+
+    def execute_and_count_down
+      begin
+        execute
+      ensure
+        @mutex.synchronize do
+          @executing = @executing - 1
+        end
+      end
+    end
+
+    def execute
+      while true
+        block = @mutex.synchronize { @waiting.shift }
+        block or break
+        begin
+          block.call
+        rescue Exception => e
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rosarium/promise.rb

@@ -0,0 +1,111 @@
+module Rosarium
+
+  class Promise < SimplePromise
+
+    DEFAULT_ON_FULFILL = Proc.new {|value| value}
+    DEFAULT_ON_REJECT = Proc.new {|reason| raise reason}
+
+    def self.defer
+      new_deferred
+    end
+
+    def self.resolve(value)
+      if value.kind_of? Promise
+        return value
+      end
+
+      deferred = new_deferred
+      deferred.resolve(value)
+      deferred.promise
+    end
+
+    def self.reject(reason)
+      deferred = new_deferred
+      deferred.reject(reason)
+      deferred.promise
+    end
+
+    def self.execute(&block)
+      deferred = new_deferred
+      EXECUTOR.submit do
+        begin
+          deferred.resolve block.call
+        rescue Exception => e
+          deferred.reject e
+        end
+      end
+      deferred.promise
+    end
+
+    def self.all_settled(promises)
+      return resolve([]) if promises.empty?
+
+      deferred = new_deferred
+      promises = promises.dup
+
+      check = Proc.new do
+        if promises.all? {|promise| promise.fulfilled? or promise.rejected?}
+          deferred.resolve promises
+        end
+      end
+
+      promises.each do |promise|
+        promise.then(check) { check.call }
+      end
+
+      deferred.promise
+    end
+
+    def self.all(promises)
+      return resolve([]) if promises.empty?
+
+      deferred = new_deferred
+      promises = promises.dup
+
+      do_reject = Proc.new {|reason| deferred.reject reason}
+      do_fulfill = Proc.new do
+        if promises.all?(&:fulfilled?)
+          deferred.resolve(promises.map &:value)
+        end
+      end
+
+      promises.each do |promise|
+        promise.then(do_reject) { do_fulfill.call }
+      end
+
+      deferred.promise
+    end
+
+    def then(on_rejected = nil, &on_fulfilled)
+      deferred = self.class.new_deferred
+
+      on_fulfilled ||= DEFAULT_ON_FULFILL
+      on_rejected ||= DEFAULT_ON_REJECT
+
+      on_resolution do
+        callback, arg = if fulfilled?
+                          [ on_fulfilled, value ]
+                        else
+                          [ on_rejected, reason ]
+                        end
+
+        begin
+          deferred.resolve(callback.call arg)
+        rescue Exception => e
+          deferred.reject e
+        end
+      end
+
+      deferred.promise
+    end
+
+    def rescue(&block)
+      self.then(block)
+    end
+
+    alias_method :catch, :rescue
+    alias_method :on_error, :rescue
+
+  end
+
+end

data/lib/rosarium/simple_promise.rb

@@ -0,0 +1,155 @@
+module Rosarium
+
+  class SimplePromise
+
+    def self.new_deferred
+      promise = new
+      resolver = promise.method :resolve
+      rejecter = promise.method :reject
+
+      class <<promise
+        undef :resolve
+        undef :reject
+      end
+
+      Deferred.new(promise, resolver, rejecter)
+    end
+
+    def initialize
+      @state = :pending
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @on_resolution = []
+    end
+
+    def state
+      synchronized { @state }
+    end
+
+    def value
+      wait
+      synchronized { @value }
+    end
+
+    def reason
+      wait
+      synchronized { @reason }
+    end
+
+    def fulfilled?
+      state == :fulfilled
+    end
+
+    def rejected?
+      state == :rejected
+    end
+
+    def value!
+      wait
+      synchronized do
+        if @state == :rejected
+          raise @reason
+        else
+          @value
+        end
+      end
+    end
+
+    def wait
+      on_resolution do
+        @mutex.synchronize { @condition.broadcast }
+      end
+
+      @mutex.synchronize do
+        loop do
+          return if @state == :fulfilled or @state == :rejected
+          @condition.wait @mutex
+        end
+      end
+    end
+
+    private
+
+    def synchronized
+      @mutex.synchronize { yield }
+    end
+
+    public
+
+    def resolve(value)
+      _resolve(value, nil)
+    end
+
+    def reject(reason)
+      raise "reason must be an Exception" unless reason.kind_of? Exception
+      _resolve(nil, reason)
+    end
+
+    private
+
+    def _resolve(value, reason)
+      callbacks = []
+      add_on_resolution = false
+
+      synchronized do
+        if @state == :pending
+          if value.kind_of? SimplePromise
+            @state = :resolving
+            add_on_resolution = true
+          elsif reason.nil?
+            @value = value
+            @state = :fulfilled
+            callbacks.concat @on_resolution
+            @on_resolution.clear
+          else
+            @reason = reason
+            @state = :rejected
+            callbacks.concat @on_resolution
+            @on_resolution.clear
+          end
+        end
+      end
+
+      if add_on_resolution
+        value.on_resolution { copy_resolution_from value }
+      end
+
+      callbacks.each {|c| EXECUTOR.submit { c.call } }
+    end
+
+    def copy_resolution_from(other)
+      callbacks = []
+
+      synchronized do
+        if @state == :resolving
+          @value = other.value
+          @reason = other.reason
+          @state = other.state
+          callbacks.concat @on_resolution
+          @on_resolution.clear
+        end
+      end
+
+      callbacks.each {|c| EXECUTOR.submit { c.call } }
+    end
+
+    protected
+
+    def on_resolution(&block)
+      immediate = synchronized do
+        if @state == :fulfilled or @state == :rejected
+          true
+        else
+          @on_resolution << block
+          false
+        end
+      end
+
+      block.call if immediate
+
+      nil
+    end
+
+  end
+
+end

data/lib/rosarium.rb

@@ -0,0 +1,10 @@
+require_relative 'rosarium/fixed_thread_executor'
+require_relative 'rosarium/simple_promise'
+require_relative 'rosarium/deferred'
+require_relative 'rosarium/promise'
+
+module Rosarium
+
+  EXECUTOR = FixedThreadExecutor.new(10)
+
+end

data/spec/deferred_spec.rb

@@ -0,0 +1,134 @@
+require "rosarium"
+require_relative "./promise_test_helper"
+
+describe "deferred promises" do
+
+  include PromiseTestHelper
+
+  it "creates a pending promise" do
+    deferred = Rosarium::Promise.defer
+    check_pending deferred.promise
+  end
+
+  it "deferred can be fulfilled only once" do
+    deferred = Rosarium::Promise.defer
+    check_pending deferred.promise
+    deferred.resolve 7
+    check_fulfilled deferred.promise, 7
+    deferred.resolve 8
+    check_fulfilled deferred.promise, 7
+    deferred.reject an_error
+    check_fulfilled deferred.promise, 7
+  end
+
+  it "deferred can be rejected only once" do
+    e = an_error
+    deferred = Rosarium::Promise.defer
+    check_pending deferred.promise
+    deferred.reject e
+    check_rejected deferred.promise, e
+    deferred.reject an_error("again")
+    check_rejected deferred.promise, e
+    deferred.resolve 9
+    check_rejected deferred.promise, e
+  end
+
+  it "can only be rejected with an exception" do
+    deferred = Rosarium::Promise.defer
+    check_pending deferred.promise
+    expect { deferred.reject "123" }.to raise_error /reason must be an Exception/
+    check_pending deferred.promise
+  end
+
+  it "can be resolved with an already-fulfilled promise" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    d2.resolve 7
+    d1.resolve(d2.promise)
+    check_fulfilled d1.promise, 7
+  end
+
+  it "can be resolved with an already-rejected promise" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    e = an_error
+    d2.reject e
+    d1.resolve(d2.promise)
+    check_rejected d1.promise, e
+  end
+
+  it "can be resolved with a later-fulfilled promise" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    d1.resolve(d2.promise)
+    check_resolving d1.promise
+    d2.resolve 7
+    d1.promise.wait
+    check_fulfilled d1.promise, 7
+  end
+
+  it "can be resolved with a later-rejected promise" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    d1.resolve(d2.promise)
+    check_resolving d1.promise
+    e = an_error
+    d2.reject e
+    d1.promise.wait
+    check_rejected d1.promise, e
+  end
+
+  it "waits for a value (fulfilled)" do
+    d = Rosarium::Promise.defer
+    check_pending d.promise
+    Thread.new { sleep 0.1; d.resolve 7 }
+    v = d.promise.value
+    expect(v).to eq(7)
+  end
+
+  it "waits for a value (rejected)" do
+    d = Rosarium::Promise.defer
+    check_pending d.promise
+    Thread.new { sleep 0.1; d.reject an_error }
+    v = d.promise.value
+    expect(v).to eq(nil)
+    expect(d.promise).to be_rejected
+  end
+
+  it "waits for a reason (fulfilled)" do
+    d = Rosarium::Promise.defer
+    check_pending d.promise
+    Thread.new { sleep 0.1; d.resolve 7 }
+    r = d.promise.reason
+    expect(r).to eq(nil)
+    expect(d.promise).to be_fulfilled
+  end
+
+  it "waits for a reason (rejected)" do
+    d = Rosarium::Promise.defer
+    check_pending d.promise
+    e = an_error
+    Thread.new { sleep 0.1; d.reject e }
+    r = d.promise.reason
+    expect(r).to eq(e)
+  end
+
+  it "waits for a value! (fulfilled)" do
+    d = Rosarium::Promise.defer
+    check_pending d.promise
+    Thread.new { sleep 0.1; d.resolve 7 }
+    v = d.promise.value!
+    expect(v).to eq(7)
+  end
+
+  it "waits for a value! (rejected)" do
+    d = Rosarium::Promise.defer
+    check_pending d.promise
+    e = an_error
+    Thread.new { sleep 0.1; d.reject e }
+    expect {
+      d.promise.value!
+    }.to raise_error(e)
+  end
+
+end

data/spec/fixed_thread_executor_spec.rb

@@ -0,0 +1,38 @@
+require "rosarium"
+
+describe Rosarium::FixedThreadExecutor do
+
+  it "runs a job" do
+    ex = Rosarium::FixedThreadExecutor.new(1)
+    done = false
+    ex.submit { done = true }
+    ex.wait_until_idle
+    expect(done).to be_truthy
+  end
+
+  it "discards exceptions" do
+    ex = Rosarium::FixedThreadExecutor.new(1)
+    done = false
+    ex.submit { raise "bang" }
+    ex.submit { done = true }
+    ex.wait_until_idle
+    expect(done).to be_truthy
+  end
+
+  it "runs jobs concurrently" do
+    ex = Rosarium::FixedThreadExecutor.new(3)
+    m = Mutex.new
+    done = []
+    3.times do
+      ex.submit do
+        m.synchronize { done << "s" }
+        sleep 0.1
+        m.synchronize { done << "e" }
+      end
+    end
+    ex.wait_until_idle
+    expect(done).to eq(%w[ s s s e e e ])
+  end
+
+end
+

data/spec/promise_methods_spec.rb

@@ -0,0 +1,71 @@
+require "rosarium"
+require_relative "./promise_test_helper"
+
+describe Rosarium::Promise do
+
+  include PromiseTestHelper
+
+  # Chaining promises
+
+  it "supports simple 'then'" do
+    deferred = Rosarium::Promise.defer
+    chained = deferred.promise.then {|arg| arg * 2}
+    check_pending chained
+    deferred.resolve 7
+    sleep 0.1
+    check_fulfilled chained, 14
+  end
+
+  it "rejects if 'then' raises an error" do
+    e = an_error
+    deferred = Rosarium::Promise.defer
+    chained = deferred.promise.then { raise e }
+    check_pending chained
+    deferred.resolve 7
+    sleep 0.1
+    check_rejected chained, e
+  end
+
+  it "rejects if the parent rejects" do
+    e = an_error
+    deferred = Rosarium::Promise.defer
+    then_called = false
+    chained = deferred.promise.then { then_called = true }
+    check_pending chained
+    deferred.reject e
+    chained.wait
+    check_rejected chained, e
+    expect(then_called).to be_falsy
+  end
+
+  it "supports then(on_rejected)" do
+    e = an_error
+    e2 = an_error("another")
+    deferred = Rosarium::Promise.defer
+    got_args = nil
+    chained = deferred.promise.then(Proc.new {|*args| got_args = args; raise e2 }) { raise "should never be called" }
+    deferred.reject e
+    chained.wait
+    check_rejected chained, e2
+    expect(got_args).to eq([e])
+  end
+
+  it "on_rejected can cause fulfilled" do
+    deferred = Rosarium::Promise.defer
+    chained = deferred.promise.then(Proc.new {7}) { raise "should never be called" }
+    deferred.reject an_error
+    chained.wait
+    check_fulfilled chained, 7
+  end
+
+  it "supports rescue/catch/on_error" do
+    %i[ rescue catch on_error ].each do |method|
+      deferred = Rosarium::Promise.defer
+      chained = deferred.promise.send(method) { 7 }
+      deferred.reject an_error
+      chained.wait
+      check_fulfilled chained, 7
+    end
+  end
+
+end

data/spec/promise_static_spec.rb

@@ -0,0 +1,103 @@
+require "rosarium"
+require_relative "./promise_test_helper"
+
+describe "instantly-resolved promises" do
+
+  include PromiseTestHelper
+
+  it "returns the same promise" do
+    d = Rosarium::Promise.defer
+    t = Rosarium::Promise.resolve d.promise
+    expect(t).to eq(d.promise)
+  end
+
+  it "creates a fulfilled promise" do
+    t = Rosarium::Promise.resolve 7
+    check_fulfilled t, 7
+    expect(t).not_to respond_to(:fulfill)
+    expect(t).not_to respond_to(:reject)
+  end
+
+  it "creates a rejected promise" do
+    e = an_error
+    t = Rosarium::Promise.reject an_error
+    check_rejected t, an_error
+    expect(t).not_to respond_to(:fulfill)
+    expect(t).not_to respond_to(:reject)
+  end
+
+  it "creates an immediately-executable promise" do
+    promise = Rosarium::Promise.execute do
+      sleep 0.1 ; 7
+    end
+    check_pending promise
+    sleep 0.2
+    check_fulfilled promise, 7
+  end
+
+  it "catches errors from the executed block and rejects" do
+    e = RuntimeError.new("bang")
+    promise = Rosarium::Promise.execute do
+      sleep 0.1 ; raise e
+    end
+    check_pending promise
+    sleep 0.2
+    check_rejected promise, e
+  end
+
+  it "supports all_settled (empty)" do
+    promise = Rosarium::Promise.all_settled []
+    check_fulfilled promise, []
+  end
+
+  it "supports all_settled (non-empty)" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    promise = Rosarium::Promise.all_settled [d1.promise, d2.promise]
+    check_pending promise
+
+    d1.resolve 7
+    check_pending promise
+
+    e = an_error
+    d2.reject e
+    promise.wait
+    check_fulfilled promise, [ d1.promise, d2.promise ]
+  end
+
+  it "supports all (empty)" do
+    promise = Rosarium::Promise.all []
+    check_fulfilled promise, []
+  end
+
+  it "supports all (reject)" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    d3 = Rosarium::Promise.defer
+    promise = Rosarium::Promise.all [d1.promise, d2.promise, d3.promise]
+    check_pending promise
+
+    d1.resolve 7
+    check_pending promise
+
+    e = an_error
+    d3.reject e
+    promise.wait
+    check_rejected promise, e
+  end
+
+  it "supports all (fulfill)" do
+    d1 = Rosarium::Promise.defer
+    d2 = Rosarium::Promise.defer
+    promise = Rosarium::Promise.all [d1.promise, d2.promise]
+    check_pending promise
+
+    d1.resolve 7
+    check_pending promise
+
+    d2.resolve 8
+    promise.wait
+    check_fulfilled promise, [7,8]
+  end
+
+end

data/spec/promise_test_helper.rb

@@ -0,0 +1,39 @@
+module PromiseTestHelper
+
+  def check_pending(promise)
+    expect(promise.state).to eq(:pending)
+    expect(promise).not_to be_fulfilled
+    expect(promise).not_to be_rejected
+    # expect(promise.value).to be_nil # should block
+    # expect(promise.reason).to be_nil # should block
+  end
+
+  def check_resolving(promise)
+    expect(promise.state).to eq(:resolving)
+    expect(promise).not_to be_fulfilled
+    expect(promise).not_to be_rejected
+    # expect(promise.value).to be_nil # should block
+    # expect(promise.reason).to be_nil # should block
+  end
+
+  def check_fulfilled(promise, value)
+    expect(promise.state).to eq(:fulfilled)
+    expect(promise).to be_fulfilled
+    expect(promise).not_to be_rejected
+    expect(promise.value).to eq(value)
+    expect(promise.reason).to be_nil
+  end
+
+  def check_rejected(promise, e)
+    expect(promise.state).to eq(:rejected)
+    expect(promise).not_to be_fulfilled
+    expect(promise).to be_rejected
+    expect(promise.value).to eq(nil)
+    expect(promise.reason).to eq(e)
+  end
+
+  def an_error(message = "bang")
+    RuntimeError.new(message)
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: rosarium
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rachel Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: |2
+      Rosarium implements something that's a bit like Promises,
+      inspired by the stability and ease of use of Q
+      (<https://github.com/kriskowal/q/wiki/API-Reference>).
+email: git@rve.org.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/rosarium.rb
+- lib/rosarium/deferred.rb
+- lib/rosarium/fixed_thread_executor.rb
+- lib/rosarium/promise.rb
+- lib/rosarium/simple_promise.rb
+- spec/deferred_spec.rb
+- spec/fixed_thread_executor_spec.rb
+- spec/promise_methods_spec.rb
+- spec/promise_static_spec.rb
+- spec/promise_test_helper.rb
+homepage: http://rve.org.uk/gems/rosarium
+licenses:
+- Apache-2.0
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Promises, or something like them
+test_files: []