rpromise 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1262691501de1334a31235ac093581f219d4cc44
-  data.tar.gz: d9557239fef9c4d00dd102b48b9f4cc0cb02de26
+  metadata.gz: f827fadaed28b188d96a603fd46c933e06f52e6f
+  data.tar.gz: b76fde2e1c6388e4ca470e4eb8a0a28f779fa9cd
 SHA512:
-  metadata.gz: 3b1e40b5e717eaaf25c8baf8f22c627f75d24e8651a6192a892ac8e39378101e8db0e77c4fc3bc1b37164aec58512f3c03cfa4e455fe0311553fb5150b11241c
-  data.tar.gz: 612ef5ff492f18d43591b95aaaddd81c9b1e5bf9e60546dd5659da0cb3040adab5b9da1a4fde069cff66cbe6230e6c32e456fc1b2ff75d359d04af327d3b7e12
+  metadata.gz: b8b692957a78f776851bb84e5071304b7dd4a9666a9d8b44dd5254e336e7be3ebd82344ac60d98029961ca2cbcbe205ae97e04517d657a9a2c197a65f0e449cc
+  data.tar.gz: e968d06a23ee237efa58935cb4e5b80130c86821c52f2ab1f2cd2055f2fa8c8e87b4103e798eea821eaea5971eedb24d1e11f68f33312d7b9244c0293ed7fd4b

data/README.md

@@ -1,6 +1,9 @@
 # Rpromise
 
 [![Build Status](https://travis-ci.org/samuelmolinari/rpromise.svg?branch=master)](https://travis-ci.org/samuelmolinari/rpromise)
+[![Gem Version](https://badge.fury.io/rb/rpromise.svg)](http://badge.fury.io/rb/rpromise)
+[![Code Climate](https://codeclimate.com/github/samuelmolinari/rpromise/badges/gpa.svg)](https://codeclimate.com/github/samuelmolinari/rpromise)
+[![Test Coverage](https://codeclimate.com/github/samuelmolinari/rpromise/badges/coverage.svg)](https://codeclimate.com/github/samuelmolinari/rpromise)
 
 ## Installation
 
@@ -18,50 +21,120 @@ Or install it yourself as:
 
 ## Usage
 
+### Create a promise
+
 ```ruby
 
 class Task
 
   def async
-    return ::Rpromise.new do |resolve, reject|
-      Thread.new do
-        sleep(1)
-        value = Random.rand * 10
-
-        if value > 5
-          resolve.call(value)
-        else
-          reject.call('Oh boy, what have you done')
-        end
+    ::Rpromise.new do |resolve, reject|
+      sleep(1)
+      value = Random.rand * 10
+
+      if value > 5
+        resolve.call(value)
+      else
+        reject.call('Oh boy, what have you done')
       end
     end
   end
 
 end
 
-on_resolve = lambda do |value|
+```
 
-  puts value
+### Callbacks
 
-  return ::Rpromise.new do |resolve, reject|
-    Thread.new do
-      sleep(1)
-      # Do an async task
-      resolve.call(value + 10)
-    end
-  end
+#### Using method
+
+You can use existing methods as callbacks:
+
+```ruby
+def on_resolve(value)
+  # Do something with the returned value from the promise
 end
 
-on_reject = lambda do |error|
-  puts error
+Task.new.async.then(method(:on_resolve))
+```
+
+#### Using proc
+
+You can use ``Proc`` as a callback
+
+```ruby
+Task.new.async.then(Proc.new do |value|
+  # Do something
+end)
+```
+
+#### Using lambda
+
+You can use ``lambda`` as a callback
+
+```ruby
+Task.new.async.then(lambda do |value|
+  # Do something
+end)
+```
+
+### Chained promises
+
+```ruby
+Rpromise.new do |resolve, reject|
+
+  resolve.call(5)
+
+end.then(lambda do |value|
+
+  # value == 5
+  value + 10
+
+end).then(lambda do |value|
+
+  # value == 15
+  Rpromise.new do |resolve, reject|
+    resolve.call(value / 5)
+  end
+
+end).then(lambda do |value|
+
+  # value == 3
+
+end)
+```
+
+#### Error handling
+
+You can handle errors raised during the async task by passing a callback block as second argument
+
+```ruby
+p = Rpromise.new do |resolve, reject|
+  raise 'Oopss'
 end
 
-Task.new.async
-  .then(on_resolve, on_reject)
-  .then(Proc.new do |value_plus_10|
-    puts value_plus_10 # Returned value from the previous ``then`` promise resolved value
-  end)
+p.then(nil, lambda do |err|
+  err.message # => "Oopss"
+end)
+```
+
+or you can handle the exceptions yourself by making use of the reject callback
+
+```ruby
+p = Rpromise.new do |resolve, reject|
+  begin
+    method_that_could_raise_an_exception()
+    resolve('Everything went ok')
+  rescue Exception => e
+    reject.call('Oh dear, what have I done?!')
+  end
+end
 
+p.then(lambda do |message|
+  # Called if the promise executed without exceptions
+end, lambda do |err|
+  # Called if the promise has raised an exception
+end)
 ```
 
 ## Contributing

data/lib/rpromise/version.rb

@@ -1,3 +1,3 @@
 class Rpromise
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/rpromise.rb

@@ -9,12 +9,18 @@ class Rpromise
 
   Handler = Struct.new(:on_resolved, :on_rejected, :resolve, :reject)
 
-  attr_reader :state
+  attr_reader :state, :thread
 
   def initialize()
     @state = State::PENDING
     @defered = nil
-    yield(method(:resolve!), method(:reject!),self)
+    @thread = Thread.new do
+      begin
+        yield(method(:resolve!), method(:reject!))
+      rescue Exception => e
+        reject!(e)
+      end
+    end
   rescue Exception => e
     reject!(e)
   end
@@ -23,9 +29,9 @@ class Rpromise
     raise ArgumentError unless is_valid_block?(on_resolved)
     raise ArgumentError unless is_valid_block?(on_rejected)
     return self if on_resolved.nil? && on_rejected.nil?
-    return ::Rpromise.new do |resolve, reject, promise|
+    return ::Rpromise.new do |resolve, reject|
       handler = Handler.new(on_resolved, on_rejected, resolve, reject)
-      self.handle(handler)
+      handle(handler)
     end
   end
 
@@ -53,9 +59,6 @@ class Rpromise
     unless @defered.nil?
       handle(@defered)
     end
-
-  rescue
-    reject!(nil)
   end
 
   def reject!(value = nil)
@@ -92,7 +95,5 @@ class Rpromise
       output = callback.call(@value)
       handler.resolve.call(output) unless handler.resolve.nil?
     end
-  rescue
-    handler.reject.call(nil) unless handler.reject.nil?
   end
 end

data/rpromise.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "codeclimate-test-reporter"
 end

data/spec/lib/rpromise_spec.rb

@@ -12,30 +12,27 @@ describe ::Rpromise do
 
   describe '#initialize' do
     it 'uses the resolve! method as callback' do
-      t = nil
+      lock = true
       p = described_class.new do |resolve, reject|
-        t = Thread.new do
-          resolve.call('hi')
-        end
+        resolve.call('hi')
+        lock = false
       end
-      t.join
+      loop { break unless lock }
       expect(p).to be_resolved
     end
 
     it 'uses the reject! method as callback' do
-      t = nil
+      lock = true
       p = described_class.new do |resolve, reject|
-        t = Thread.new do
-          reject.call('hi')
-        end
+        reject.call('hi')
+        lock = false
       end
-      t.join
+      loop { break unless lock }
       expect(p).to be_rejected
     end
   end
 
   describe '#then' do
-
     it 'returns a new promise' do
       expect(promise.then).to be_kind_of described_class
     end
@@ -58,158 +55,112 @@ describe ::Rpromise do
       let(:value2) { Random.rand + value }
       let(:value3) { Random.rand + value + value2 }
 
-      context 'with async task' do
-        before(:each) do
-          @thread = nil
-          @promise = described_class.new do |resolve, reject|
-            @thread = Thread.new do
-              sleep(0.5)
-              resolve.call(value)
-            end
-          end
+      before(:each) do
+        @promise = described_class.new do |resolve, reject|
+          resolve.call(value)
         end
+      end
 
-        it 'returns the resolved value' do
-          lambda_value = nil
-          @promise.then(lambda do |v|
-            lambda_value = v
+      it 'returns the resolved value' do
+        lambda_value = nil
+        lock = true
+        @promise.then(lambda do |v|
+          lambda_value = v
+          lock = false
+        end)
+        loop { break unless lock }
+        expect(@promise).to be_resolved
+        expect(lambda_value).to eq value
+      end
+
+      context 'when multiple then are chained together' do
+        it 'passes its returned value to the next then' do
+          lambda_value_1 = nil
+          lambda_value_2 = nil
+          lambda_value_3 = nil
+          lock = true
+          @promise.then(lambda do |v1|
+            lambda_value_1 = v1
+            return value2
+          end).then(lambda do |v2|
+            lambda_value_2 = v2
+            return value3
+          end).then(lambda do |v3|
+            lambda_value_3 = v3
+            lock = false
           end)
-          expect(lambda_value).to be_nil
-          expect(@promise).to be_pending
-          @thread.join
-          expect(@promise).to be_resolved
-          expect(lambda_value).to eq value
-        end
-        context 'when multiple then are chained together' do
-          it 'passes its returned value to the next then' do
-            lambda_value_1 = nil
-            lambda_value_2 = nil
-            lambda_value_3 = nil
-            @promise.then(lambda do |v1|
-              lambda_value_1 = v1
-              return value2
-            end).then(lambda do |v2|
-              lambda_value_2 = v2
-              return value3
-            end).then(lambda do |v3|
-              lambda_value_3 = v3
-            end)
-            @thread.join
-            expect(lambda_value_1).to eq value
-            expect(lambda_value_2).to eq value2
-            expect(lambda_value_3).to eq value3
-          end
-        end
-        context 'when then resolve callback returns a promise' do
-          it 'uses the next then as handler' do
-            thread2 = nil
-            lambda_value = nil
-            lock = true
-            @promise.then(lambda do |v|
-              return described_class.new do |resolve, reject|
-                thread2 = Thread.new do
-                  sleep(0)
-                  resolve.call('Hello world!')
-                end
-              end
-            end).then(lambda do |hello_world|
-              lambda_value = hello_world
-              lock = false
-            end)
-            loop { break unless lock }
-            expect(lambda_value).to eq 'Hello world!'
-          end
-        end
-        context 'when no callback is passed' do
-          it 'passes original returned value to the next then' do
-            lambda_value = nil
-            @promise.then.then(lambda do |v|
-              lambda_value = v
-            end)
-            @thread.join
-            expect(lambda_value).to eq value
-          end
+          loop { break unless lock }
+          expect(lambda_value_1).to eq value
+          expect(lambda_value_2).to eq value2
+          expect(lambda_value_3).to eq value3
         end
       end
 
-      context 'with non-async task' do
-        let(:promise) do
-          described_class.new do |resolve, reject|
-            resolve.call(value)
-          end
+      context 'when then resolve callback returns a promise' do
+        it 'uses the next then as handler' do
+          thread2 = nil
+          lambda_value = nil
+          lock = true
+          @promise.then(lambda do |v|
+            return described_class.new do |resolve, reject|
+              thread2 = Thread.new do
+                resolve.call('Hello world!')
+              end
+            end
+          end).then(lambda do |hello_world|
+            lambda_value = hello_world
+            lock = false
+          end)
+          loop { break unless lock }
+          expect(lambda_value).to eq 'Hello world!'
         end
+      end
 
-        it 'returns the resolved value' do
+      context 'when no callback is passed' do
+        it 'passes original returned value to the next then' do
           lambda_value = nil
-          promise.then(lambda do |v|
+          lock = true
+          @promise.then.then(lambda do |v|
             lambda_value = v
+            lock = false
           end)
-          expect(lambda_value).to be value
-        end
-
-        context 'when multiple then are chained together' do
-          it 'passes its returned value to the next then' do
-            lambda_value_1 = nil
-            lambda_value_2 = nil
-            lambda_value_3 = nil
-            promise.then(lambda do |v1|
-              lambda_value_1 = v1
-              return value2
-            end).then(lambda do |v2|
-              lambda_value_2 = v2
-              return value3
-            end).then(lambda do |v3|
-              lambda_value_3 = v3
-            end)
-            expect(lambda_value_1).to eq value
-            expect(lambda_value_2).to eq value2
-            expect(lambda_value_3).to eq value3
-          end
-        end
-
-        context 'when no callback is passed' do
-          it 'does not raise any error' do
-            expect { promise.then }.not_to raise_error
-          end
-
-          it 'passes original returned value to the next then' do
-            lambda_value = nil
-            promise.then.then(lambda do |v|
-              lambda_value = v
-            end)
-            expect(lambda_value).to eq value
-          end
+          loop { break unless lock }
+          expect(lambda_value).to eq value
         end
       end
     end
 
     context 'when promise is rejected' do
-      context 'with non-async task' do
-        let(:error) { Random.rand }
-        let(:promise) do
-          described_class.new do |resolve, reject|
-            reject.call(error)
-          end
+      let(:error) { Random.rand }
+      it 'returns exception' do
+        lambda_error = nil
+        lock = true
+        p = described_class.new do |resolve, reject|
+          reject.call(error)
         end
-        it 'returns exception' do
-          lambda_error = nil
-          promise.then(nil, lambda do |e|
-            lambda_error = e
-          end)
-          expect(lambda_error).to eq error
-        end
-        it 'handles raised exceptions within the promise' do
-          lambda_error = nil
-          promise = described_class.new do |resolve, reject|
-            raise 'Oops'
-          end
-          promise.then(nil, lambda do |e|
-            lambda_error = e
-          end)
-          expect(lambda_error).to be_kind_of RuntimeError
-          expect(lambda_error.message).to eq 'Oops'
+        p.then(nil, lambda do |e|
+          lambda_error = e
+          lock = false
+        end)
+        loop { break unless lock }
+        expect(lambda_error).to eq error
+      end
+      it 'handles raised exceptions within the promise' do
+        lambda_error = nil
+        lock = true
+        p = described_class.new do |resolve, reject|
+          raise 'Oops'
         end
+        p.then(nil, lambda do |e|
+          lambda_error = e
+          lock = false
+        end)
+        loop { break unless lock }
+        expect(lambda_error).to be_kind_of RuntimeError
+        expect(lambda_error.message).to eq 'Oops'
       end
+      xit 'handles raised exceptions within resolve!'
+      xit 'handles raised exceptions within handle!'
     end
   end
 

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 require 'rpromise'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rpromise
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Samuel Molinari
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-13 00:00:00.000000000 Z
+date: 2014-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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: Handle async method easily
 email:
 - samuel@molinari.me