pure_promise 0.0.1

data/pure_promise.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pure_promise'
+  spec.version       = '0.0.1'
+  spec.authors       = ['Cameron Martin']
+  spec.email         = ['cameronmartin123@gmail.com']
+  spec.summary       = %q{Promises/A+ with a twist}
+  spec.description   = %q{Promises/A+ with a twist. Resolves some of the inconsistencies and annoyances I've experienced with other promises libraries}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/spec/pure_promise/callback_spec.rb

@@ -0,0 +1,26 @@
+describe PurePromise::Callback do
+
+  let(:return_promise) { PurePromise.new }
+
+  describe '#call' do
+
+    it 'delegates to calling proc' do
+      promise = PurePromise.fulfill(:value)
+      callback = double('callback')
+
+      expect(callback).to receive(:call).with(:value).and_return(promise)
+
+      PurePromise::Callback.new(callback, return_promise).call(:value)
+    end
+
+    it 'rejects promise if callback errors' do
+      error = RuntimeError.new
+      callback = proc { raise error }
+
+      PurePromise::Callback.new(callback, return_promise).call(:value)
+
+      expect_rejection(return_promise, with: error)
+    end
+  end
+
+end

data/spec/pure_promise/coercer_spec.rb

@@ -0,0 +1,118 @@
+describe PurePromise::Coercer do
+
+  subject { PurePromise::Coercer.new(thenable, PurePromise) }
+
+  context 'with non-thenable' do
+    let(:thenable) { Object.new }
+
+    describe '.is_thenable?' do
+      it 'is false' do
+        expect(PurePromise::Coercer.is_thenable?(thenable)).to eq(false)
+      end
+    end
+
+    describe '#initialize' do
+      it 'raises TypeError' do
+        expect { subject }.to raise_error(TypeError, 'Can only coerce a thenable')
+      end
+    end
+
+  end
+
+  context 'with PurePromise' do
+    describe '#coerce' do
+      let(:thenable) { PurePromise.new }
+
+      it 'returns promise' do
+        expect(subject.coerce).to equal(thenable)
+      end
+
+    end
+  end
+
+  context 'with conformant thenable' do
+
+    let(:thenable) { Thenable::Conformant.new }
+
+    describe '.is_thenable?' do
+      it 'is true' do
+        expect(PurePromise::Coercer.is_thenable?(thenable)).to eq(true)
+      end
+    end
+
+    describe '#coerce' do
+
+      it 'returns a promise' do
+        expect(subject.coerce).to be_a(PurePromise)
+      end
+
+      it 'fulfills when callback passed to then is called' do
+        promise = subject.coerce
+
+        expect_fulfillment(promise, with: :value) do
+          thenable.fulfill(:value)
+        end
+      end
+
+      it 'rejects when callback passed to then is called' do
+        promise = subject.coerce
+
+        expect_rejection(promise, with: :value) do
+          thenable.reject(:value)
+        end
+      end
+
+      it 'ignores subsequent calls of reject callback' do
+        promise = subject.coerce
+
+        thenable.reject(:value)
+        thenable.reject(:other_value)
+
+        expect_rejection(promise, with: :value)
+      end
+
+      it 'ignores subsequent calls of fulfill callback' do
+        promise = subject.coerce
+
+        thenable.fulfill(:value)
+        thenable.fulfill(:other_value)
+
+        expect_fulfillment(promise, with: :value)
+      end
+
+    end
+  end
+
+  context 'with early erroring thenable' do
+    let(:thenable) { Thenable::EarlyErroring.new(error) }
+
+    let(:error) { RuntimeError.new('Some error') }
+
+    describe '#coerce' do
+      it 'rejects promise with error' do
+        promise = subject.coerce
+
+        expect_rejection(promise, with: error)
+      end
+    end
+
+  end
+
+  context 'with late erroring thenable' do
+    let(:thenable) { Thenable::LateErroring.new(:value, error) }
+
+    let(:error) { RuntimeError.new }
+
+    describe '#coerce' do
+      it 'rejects promise with error' do
+        promise = subject.coerce
+
+        expect_fulfillment(promise, with: :value)
+      end
+    end
+
+  end
+
+
+
+end

data/spec/pure_promise_spec.rb

@@ -0,0 +1,445 @@
+describe PurePromise do
+
+  subject { PurePromise.new }
+
+  let(:fulfill_callback) { double('fulfill_callback').as_null_object }
+  let(:reject_callback) { double('reject_callback').as_null_object }
+
+  describe '#initialize' do
+    it 'yields fullfill and reject methods if block given' do
+      expect do |b|
+        PurePromise.new(&b)
+      end.to yield_with_args(
+                 a_bound_method_of(PurePromise.instance_method(:fulfill)),
+                 a_bound_method_of(PurePromise.instance_method(:reject))
+             )
+    end
+
+    it 'initializes as pending' do
+      expect_pending(PurePromise.new)
+    end
+  end
+
+  describe '.error' do
+
+    it 'rejects to a RuntimeError with no arguments' do
+      promise = PurePromise.error
+
+      expect_rejection(promise, with: an_error(RuntimeError).with_backtrace(caller))
+    end
+
+    it 'rejects to a RuntimeError with message with single string argument' do
+      promise = PurePromise.error('error message')
+
+      expect_rejection(promise, with: an_error(RuntimeError, 'error message').with_backtrace(caller))
+    end
+
+    it 'rejects to a specific error when given an Exception object' do
+      exception = TypeError.new('error message')
+      promise = PurePromise.error(exception)
+
+      expect_rejection(promise, with: an_error(TypeError, 'error message').with_backtrace(caller))
+    end
+
+    it 'rejects to a specific error when given a exception class and string' do
+      promise = PurePromise.error(TypeError, 'error message')
+
+      expect_rejection(promise, with: an_error(TypeError, 'error message').with_backtrace(caller))
+    end
+
+    it 'sets custom backtrace if given third argument' do
+      backtrace = ['something']
+      promise = PurePromise.error(TypeError, 'error message', backtrace)
+
+      expect_rejection(promise, with: an_error(TypeError, 'error message').with_backtrace(backtrace))
+    end
+
+  end
+
+  # TODO: Test delegation of .fulfill and .reject
+
+  describe '#fulfill' do
+    it 'calls fulfill callback when promise transitions to fulfilled' do
+      expect_fulfillment(subject, with: :value) do
+        subject.fulfill(:value)
+      end
+    end
+
+    it 'is fulfilled' do
+      subject.fulfill
+      expect_fulfillment(subject)
+    end
+
+    it 'should raise error if fulfill twice' do
+      subject.fulfill
+      expect { subject.fulfill }.to raise_error(PurePromise::MutationError, 'You can only mutate pending promises')
+    end
+
+    it 'should raise error if fulfilled after being rejected' do
+      subject.reject
+      expect { subject.fulfill }.to raise_error(PurePromise::MutationError, 'You can only mutate pending promises')
+    end
+
+    it 'returns self' do
+      expect(subject.fulfill).to eq(subject)
+    end
+  end
+
+  describe '#reject' do
+    it 'calls reject callback when promise transitions to rejected' do
+      expect_rejection(subject, with: :value) do
+        subject.reject(:value)
+      end
+    end
+
+    it 'is rejected' do
+      subject.reject
+      expect_rejection(subject)
+    end
+
+    it 'should raise error if rejected twice' do
+      subject.reject
+      expect { subject.reject }.to raise_error(PurePromise::MutationError, 'You can only mutate pending promises')
+    end
+
+    it 'should raise error if rejected after being fulfilled' do
+      subject.fulfill
+      expect { subject.reject }.to raise_error(PurePromise::MutationError, 'You can only mutate pending promises')
+    end
+
+    it 'returns self' do
+      expect(subject.reject).to eq(subject)
+    end
+  end
+
+  describe '#resolve' do
+
+    it 'raises TypeError if argument is same as self' do
+      expect { subject.resolve(subject) }.to raise_error(TypeError, 'Promise cannot be resolved to itself')
+    end
+
+    it 'raises TypeError if argument is not a promise' do
+      expect { subject.resolve(Object.new) }.to raise_error(TypeError, 'Argument is not a promise')
+    end
+
+    context 'when argument is a promise' do
+      let(:argument) { PurePromise.new }
+
+      it 'returns self when argument is pending' do
+        return_value = subject.resolve(argument)
+
+        expect(return_value).to eq(subject)
+      end
+
+      it 'fulfills subject if argument is fulfilled' do
+        argument.fulfill(:value)
+        subject.resolve(argument)
+
+        expect_fulfillment(subject, with: :value)
+      end
+
+      it 'rejects subject if argument is rejected' do
+        argument.reject(:value)
+        subject.resolve(argument)
+
+        expect_rejection(subject, with: :value)
+      end
+
+      it 'fulfills subject when argument is fulfilled' do
+        subject.resolve(argument)
+        argument.fulfill(:value)
+
+        expect_fulfillment(subject, with: :value)
+      end
+
+      it 'rejects subject when argument is rejected' do
+        subject.resolve(argument)
+        argument.reject(:value)
+
+        expect_rejection(subject, with: :value)
+      end
+    end
+
+    context 'when argument is a thenable' do
+      it 'fulfills when callback passed to then is called' do
+        thenable = Thenable::Conformant.new
+
+        subject.resolve(thenable)
+
+        expect_fulfillment(subject, with: :value) do
+          thenable.fulfill(:value)
+        end
+      end
+
+      it 'rejects when callback passed to then is called' do
+        thenable = Thenable::Conformant.new
+
+        subject.resolve(thenable)
+
+        expect_rejection(subject, with: :value) do
+          thenable.reject(:value)
+        end
+      end
+    end
+
+  end
+
+  describe '#resolve_into' do
+    let(:argument) { PurePromise.new }
+
+    it 'returns self' do
+      return_value = subject.resolve_into(argument)
+
+      expect(return_value).to equal(subject)
+    end
+
+    it 'raises TypeError if argument is not a PurePromise' do
+      expect { subject.resolve_into(Object.new) }.to raise_error(TypeError, 'Argument must be of same type as self')
+    end
+
+    it 'fulfills promise if self is fulfilled' do
+      subject.fulfill(:value)
+
+      expect(argument).to receive(:fulfill).with(:value)
+      subject.resolve_into(argument)
+    end
+
+    it 'rejects promise if self is rejected' do
+      subject.reject(:value)
+
+      expect(argument).to receive(:reject).with(:value)
+      subject.resolve_into(argument)
+    end
+
+    it 'fulfills promise when self is fulfilled' do
+      subject.resolve_into(argument)
+
+      expect_fulfillment(argument, with: :value) do
+        subject.fulfill(:value)
+      end
+    end
+
+    it 'rejects promise when self is rejected' do
+      subject.resolve_into(argument)
+
+      expect_rejection(argument, with: :value) do
+        subject.reject(:value)
+      end
+    end
+  end
+
+  describe '#then' do
+
+    it 'is a promise' do
+      return_promise = subject.then(fulfill_callback, reject_callback)
+      expect(return_promise).to be_an_instance_of(subject.class)
+    end
+
+    it 'executes callbacks in order' do
+      callbacks = 2.times.map do
+        double('fulfill_callback').as_null_object
+      end.each do |callback|
+        subject.then(callback)
+      end
+
+      callbacks.each do |callback|
+        expect(callback).to receive(:call).and_return(PurePromise.fulfill).ordered
+      end
+
+      subject.fulfill
+    end
+
+    # TODO: Find a better way of testing this
+    it 'calls defer if fulfilled' do
+      subject.fulfill
+      expect(subject).to receive(:defer)
+      subject.then
+    end
+
+    it 'calls defer if rejected' do
+      subject.reject
+      expect(subject).to receive(:defer)
+      subject.then
+    end
+
+    it 'calls defer when fulfilled' do
+      subject.then
+      expect(subject).to receive(:defer)
+      subject.fulfill
+    end
+
+    it 'calls defer when rejected' do
+      subject.then
+      expect(subject).to receive(:defer)
+      subject.reject
+    end
+
+    # REVIEW: Consider moving context 'if/when subject is fulfilled/rejected' into this level
+
+    context 'with no callbacks' do
+
+      before(:each) { @return_promise = subject.then }
+
+      it 'returns a promise that fulfills when subject fulfills' do
+        subject.fulfill(:value)
+
+        expect_fulfillment(@return_promise, with: :value)
+      end
+
+      it 'returns a promise that rejects when subject rejects' do
+        subject.reject(:value)
+
+        expect_rejection(@return_promise, with: :value)
+      end
+
+    end
+
+    context 'with fulfill callback' do
+
+      it 'allows registering fulfill callback by passing a block' do
+        return_promise = subject.then do
+          PurePromise.fulfill(:value)
+        end
+
+        subject.fulfill
+
+        expect_fulfillment(return_promise, with: :value)
+      end
+
+      context 'when callback is registered while pending' do
+
+        it 'fullfills to the value that the return promise of the callback fullfills to' do
+          return_promise = subject.then(proc {
+            PurePromise.fulfill(:value)
+          })
+
+          subject.fulfill
+
+          expect_fulfillment(return_promise, with: :value)
+
+        end
+
+        it 'rejects to the value that the return promise of the callback rejects to' do
+          return_promise = subject.then(proc {
+            PurePromise.reject(:value)
+          })
+          subject.fulfill
+
+          expect_rejection(return_promise, with: :value)
+        end
+
+      end
+
+      context 'when callback is registered after fulfillment' do
+        before(:each) { subject.fulfill }
+
+        it 'fullfills to the value that the return promise of the callback fullfills to' do
+          return_promise = subject.then(proc {
+            PurePromise.fulfill(:value)
+          })
+
+          expect_fulfillment(return_promise, with: :value)
+        end
+
+        it 'rejects to the value that the return promise of the callback rejects to' do
+          return_promise = subject.then(proc {
+            PurePromise.reject(:value)
+          })
+
+          expect_rejection(return_promise, with: :value)
+        end
+      end
+
+    end
+
+    context 'with reject callback' do
+
+      context 'when callback is registered while pending' do
+
+        it 'fullfills to the value that the return promise of the callback fullfills to' do
+          return_promise = subject.then(proc{}, proc {
+            PurePromise.fulfill(:value)
+          })
+
+          subject.reject
+
+          expect_fulfillment(return_promise, with: :value)
+
+        end
+
+        it 'rejects to the value that the return promise of the callback rejects to' do
+          return_promise = subject.then(proc{}, proc {
+            PurePromise.reject(:value)
+          })
+          subject.reject
+
+          expect_rejection(return_promise, with: :value)
+        end
+
+      end
+
+      context 'when callback is registered after rejection' do
+        before(:each) { subject.reject }
+
+        it 'fullfills to the value that the return promise of the callback fullfills to' do
+          return_promise = subject.then(proc{}, proc {
+            PurePromise.fulfill(:value)
+          })
+
+          expect_fulfillment(return_promise, with: :value)
+        end
+
+        it 'rejects to the value that the return promise of the callback rejects to' do
+          return_promise = subject.then(proc{}, proc {
+            PurePromise.reject(:value)
+          })
+
+          expect_rejection(return_promise, with: :value)
+        end
+      end
+    end
+
+  end
+
+  describe '#catch' do
+
+    it 'is called on rejected promise' do
+      subject.reject(:value)
+
+      callback = proc { PurePromise.fulfill }
+
+      expect(callback).to receive(:call).with(:value).and_call_original
+
+      subject.catch(&callback)
+    end
+
+    it 'returns a promise that fulfills with original' do
+      promise = subject.catch { PurePromise.fulfill }
+
+      expect_fulfillment(promise, with: :value) do
+        subject.fulfill(:value)
+      end
+    end
+
+    context 'with no callbacks' do
+
+      before(:each) { @return_promise = subject.catch }
+
+      it 'returns a promise that fulfills when subject fulfills' do
+        subject.fulfill(:value)
+
+        expect_fulfillment(@return_promise, with: :value)
+      end
+
+      it 'returns a promise that rejects when subject rejects' do
+        subject.reject(:value)
+
+        expect_rejection(@return_promise, with: :value)
+      end
+
+    end
+
+
+  end
+
+end