mr_darcy 0.1.0 → 0.2.0

data/lib/mr_darcy/promise/state/base.rb

@@ -21,11 +21,11 @@ module MrDarcy
         end
 
         def resolve
-          raise "Can't resolve from #{get_state} state"
+          raise RuntimeError, "Can't resolve from #{get_state} state"
         end
 
         def reject
-          raise "Cant reject from #{get_state} state"
+          raise RuntimeError, "Cant reject from #{get_state} state"
         end
 
         private

data/lib/mr_darcy/promise/thread.rb

@@ -1,11 +1,13 @@
+require 'thread'
+require 'fiber'
+
 module MrDarcy
   module Promise
     class Thread < Base
 
       def initialize *args
-        @wait_lock = Mutex.new
-        @wait_cond = ConditionVariable.new
-        @wait_lock.lock
+        @semaphore = Mutex.new
+        semaphore.synchronize { @complete = false }
         super
       end
 
@@ -19,43 +21,60 @@ module MrDarcy
         self
       end
 
-      def resolve value
-        super
-        @wait_cond.signal
-      end
-
-      def reject value
-        super
-        @wait_cond.signal
-      end
-
       private
 
       def schedule_promise &block
         ::Thread.new &block
       end
 
-      def wait_if_unresolved
-        @wait_cond.wait @wait_lock if unresolved?
+      def did_resolve value
+        complete!
       end
 
-      def semaphore
-        @semaphore ||= Mutex.new
+      def did_reject value
+        complete!
+      end
+
+      def wait_if_unresolved
+        return if complete?
+        semaphore.synchronize do
+          @wait = ConditionVariable.new
+          @wait.wait(semaphore)
+        end
       end
 
       def generate_child_promise
         ChildPromise.new driver: :thread
       end
 
+      def complete?
+        semaphore.synchronize { @complete }
+      end
+
+      def complete!
+        semaphore.synchronize do
+          @complete = true
+          @wait.broadcast if @wait
+        end
+      end
+
+      def semaphore
+        @semaphore
+      end
+
       def set_value_to value
         semaphore.synchronize { super }
       end
 
-      def state_machine_resolve
+      def state_machine
+        semaphore.synchronize { super }
+      end
+
+      def child_promise
         semaphore.synchronize { super }
       end
 
-      def state_machine_reject
+      def value
         semaphore.synchronize { super }
       end
 

data/lib/mr_darcy/role.rb

@@ -11,20 +11,23 @@ module MrDarcy
     def pollute player
       guard_against_false_players player
 
-      @module.instance_methods.each do |method_name|
-        implementation = @module.instance_method method_name
-        player.define_singleton_method method_name, implementation
+      if jruby?
+        pollute_with_module_extension player
+      else
+        pollute_with_singleton_methods player
       end
     end
 
     def clean player
-      @module.instance_methods.each do |method_name|
-        player.singleton_class.send :remove_method, method_name if player.respond_to? method_name
-      end
+      clean_singleton_methods player unless jruby?
     end
 
     private
 
+    def jruby?
+      RUBY_ENGINE == 'jruby'
+    end
+
     def guard_against_false_players player
       options.each do |test_type, values|
         case test_type
@@ -41,5 +44,22 @@ module MrDarcy
         end
       end
     end
+
+    def pollute_with_module_extension player
+      player.send :extend, @module
+    end
+
+    def pollute_with_singleton_methods player
+      @module.instance_methods.each do |method_name|
+        implementation = @module.instance_method method_name
+        player.define_singleton_method method_name, implementation
+      end
+    end
+
+    def clean_singleton_methods player
+      @module.instance_methods.each do |method_name|
+        player.singleton_class.send :remove_method, method_name if player.respond_to? method_name
+      end
+    end
   end
 end

data/lib/mr_darcy/version.rb

@@ -1,3 +1,3 @@
 module MrDarcy
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/acceptance/dci_bank_transfer_spec.rb

@@ -22,7 +22,7 @@ class BankTransfer < MrDarcy::Context
       money_source.subtract_funds amount
       money_destination.receive_funds amount
     else
-      raise "insufficient funds"
+      raise RuntimeError, "insufficient funds"
     end
     amount
   end
@@ -35,28 +35,24 @@ describe 'DCI Bank Transfer' do
   let(:money_destination) { Account.new destination_balance }
 
   MrDarcy.all_drivers.each do |driver|
-    if driver == :synchronous
-      describe "Driver #{driver}" do
-        let(:context) { BankTransfer.new money_source: money_source, money_destination: money_destination, driver: driver }
+    describe "Driver #{driver}" do
+      let(:context) { BankTransfer.new money_source: money_source, money_destination: money_destination, driver: driver }
 
-        When 'the source balance is 10' do
-          let(:source_balance) { 10 }
+      When 'the source balance is 10' do
+        let(:source_balance) { 10 }
 
-          And 'the destination balance is 5' do
-            let(:destination_balance) { 5 }
+        And 'the destination balance is 5' do
+          let(:destination_balance) { 5 }
 
-            When 'I transfer 8' do
-              subject { context.transfer(8).final }
+          When 'I transfer 8' do
+            subject { context.transfer(8).final }
 
-              its('money_source.available_balance')      { should eq 2 }
-              its('money_destination.available_balance') { should eq 13 }
-              its(:result) { should be_nil }
-            end
+            its('money_source.available_balance')      { should eq 2 }
+            its('money_destination.available_balance') { should eq 13 }
+            its(:result) { should eq 8 }
           end
         end
       end
-    else
-      pending "not working with driver #{driver} :("
     end
   end
 end

data/spec/acceptance/em_http_request_spec.rb

@@ -1,22 +1,25 @@
-require 'spec_helper'
-require 'eventmachine'
-require 'em-http-request'
+unless RUBY_ENGINE=='jruby'
+  require 'spec_helper'
+  require 'eventmachine'
+  require 'em-http-request'
 
-describe "Wrapping em-http-request" do
-  let(:promise) do
-    MrDarcy::Promise.new driver: :em do |p|
-      http = EM::HttpRequest.new('http://camp.ruby.org.nz/').get
-      http.errback do
-        p.reject http.error
-      end
-      http.callback do
-        p.resolve http.response
-      end
+  describe "Wrapping em-http-request" do
+    let(:promise) do
+      MrDarcy::Promise.new driver: :em do |p|
+        http = EM::HttpRequest.new('http://camp.ruby.org.nz/').get
+        http.errback do
+          p.reject http.error
+        end
+        http.callback do
+          p.resolve http.response
+        end
+      end.final
     end
-  end
 
-  subject { promise }
+    subject { promise }
+
+    it_should_behave_like 'a resolved promise'
+    its(:result) { should match /Rails Camp NZ/i }
+  end
 
-  it_should_behave_like 'a resolved promise'
-  its(:result) { should match /Rails Camp NZ/i }
 end

data/spec/acceptance/simple_promise_with_fail_spec.rb

@@ -4,8 +4,8 @@ describe "Promise with fail" do
 
   MrDarcy.all_drivers.each do |driver|
     describe "with driver #{driver}" do
-      let(:promise) { MrDarcy::Promise.new(driver: driver, &promise_block).fail { |v| v+1 } }
-      subject { promise }
+      let(:promise) { MrDarcy::Promise.new(driver: driver, &promise_block) }
+      subject { promise.fail { |v| v+1 } }
 
       When 'the promise resolves' do
         let(:promise_block) { proc { |p| p.resolve 1 } }

data/spec/lib/mr_darcy/promise/base_spec.rb

@@ -73,7 +73,7 @@ describe MrDarcy::Promise::Base do
       before { mock_promise.reject :bad }
 
       When 'the fail block re-fails' do
-        let(:fail_block) { proc { raise :bad } }
+        let(:fail_block) { proc { raise RuntimeError, :bad } }
 
         it_behaves_like 'a rejected promise'
       end

data/spec/lib/mr_darcy/promise/child_promise_spec.rb

@@ -4,8 +4,6 @@ describe MrDarcy::Promise::ChildPromise do
   let(:child_promise) { MrDarcy::Promise::ChildPromise.new driver: :Synchronous }
   subject { child_promise }
 
-  it { should be_a MrDarcy::Deferred }
-
   it { should respond_to :resolve_block }
   it { should respond_to :reject_block }
 
@@ -26,37 +24,36 @@ describe MrDarcy::Promise::ChildPromise do
         let(:resolve_block) { proc { :new_value } }
 
         it 'resolves' do
-          expect { subject }.to change { child_promise.resolved? }.from(false).to(true)
+          expect { subject }.to change { child_promise.promise.resolved? }.from(false).to(true)
         end
 
         it 'sets the new value' do
-          expect { subject }.to change { child_promise.result }.to(:new_value)
+          expect { subject }.to change { child_promise.promise.result }.to(:new_value)
         end
       end
 
       When 'the resolve block returns a new promise' do
-        let(:promise_block) { proc {} }
-        let(:promise) { MrDarcy::Promise::Synchronous.new promise_block }
+        let(:promise) { MrDarcy::Promise::Synchronous.new proc {} }
         let(:resolve_block) { proc { promise } }
 
         it 'doesn\'t resolve' do
-          expect { subject }.not_to change { child_promise.resolved? }
+          expect { subject }.not_to change { child_promise.promise.resolved? }
         end
 
         it 'doesn\'t set the value' do
-          expect { subject }.not_to change { child_promise.result }
+          expect { subject }.not_to change { child_promise.promise.result }
         end
 
         When 'the promise eventually resolves' do
-          before { child_promise.parent_resolved resolve_value }
+          before  { child_promise.parent_resolved resolve_value }
           subject { promise.resolve :mr_good_stuff }
 
           it 'resolves' do
-            expect { subject }.to change{ child_promise.resolved? }.from(false).to(true)
+            expect { subject }.to change{ child_promise.promise.resolved? }.from(false).to(true)
           end
 
           it 'has the new value' do
-            expect { subject }.to change { child_promise.result }.to(:mr_good_stuff)
+            expect { subject }.to change { child_promise.promise.result }.to(:mr_good_stuff)
           end
         end
 
@@ -65,11 +62,11 @@ describe MrDarcy::Promise::ChildPromise do
           subject { promise.reject :mr_bad_stuff }
 
           it 'rejects' do
-            expect { subject }.to change{ child_promise.rejected? }.from(false).to(true)
+            expect { subject }.to change{ child_promise.promise.rejected? }.from(false).to(true)
           end
 
           it 'has the new value' do
-            expect { subject }.to change { child_promise.result }.to(:mr_bad_stuff)
+            expect { subject }.to change { child_promise.promise.result }.to(:mr_bad_stuff)
           end
         end
       end
@@ -78,12 +75,12 @@ describe MrDarcy::Promise::ChildPromise do
     Otherwise do
       it 'is resolved' do
         subject
-        expect(child_promise).to be_resolved
+        expect(child_promise.promise).to be_resolved
       end
 
       it 'is resolved with the supplied value' do
         subject
-        expect(child_promise.result).to eq(resolve_value)
+        expect(child_promise.promise.result).to eq(resolve_value)
       end
     end
   end
@@ -105,25 +102,24 @@ describe MrDarcy::Promise::ChildPromise do
         let(:reject_block) { proc { :new_value } }
 
         it 'resolves' do
-          expect { subject }.to change { child_promise.resolved? }.from(false).to(true)
+          expect { subject }.to change { child_promise.promise.resolved? }.from(false).to(true)
         end
 
         it 'sets the new value' do
-          expect { subject }.to change { child_promise.result }.to(:new_value)
+          expect { subject }.to change { child_promise.promise.result }.to(:new_value)
         end
       end
 
       When 'the reject block returns a new promise' do
-        let(:promise_block) { proc {} }
-        let(:promise) { MrDarcy::Promise::Synchronous.new promise_block }
+        let(:promise) { MrDarcy::Promise::Synchronous.new proc {} }
         let(:reject_block) { proc { promise } }
 
         it 'doesn\'t reject' do
-          expect { subject }.not_to change { child_promise.rejected? }
+          expect { subject }.not_to change { child_promise.promise.rejected? }
         end
 
         it 'doesn\'t set the value' do
-          expect { subject }.not_to change { child_promise.result }
+          expect { subject }.not_to change { child_promise.promise.result }
         end
 
         When 'the promise eventually resolves' do
@@ -131,11 +127,11 @@ describe MrDarcy::Promise::ChildPromise do
           subject { promise.resolve :mr_good_stuff }
 
           it 'resolves' do
-            expect { subject }.to change{ child_promise.resolved? }.from(false).to(true)
+            expect { subject }.to change{ child_promise.promise.resolved? }.from(false).to(true)
           end
 
           it 'has the new value' do
-            expect { subject }.to change { child_promise.result }.to(:mr_good_stuff)
+            expect { subject }.to change { child_promise.promise.result }.to(:mr_good_stuff)
           end
         end
 
@@ -144,11 +140,11 @@ describe MrDarcy::Promise::ChildPromise do
           subject { promise.reject :mr_bad_stuff }
 
           it 'rejects' do
-            expect { subject }.to change{ child_promise.rejected? }.from(false).to(true)
+            expect { subject }.to change{ child_promise.promise.rejected? }.from(false).to(true)
           end
 
           it 'has the new value' do
-            expect { subject }.to change { child_promise.result }.to(:mr_bad_stuff)
+            expect { subject }.to change { child_promise.promise.result }.to(:mr_bad_stuff)
           end
         end
       end
@@ -157,12 +153,12 @@ describe MrDarcy::Promise::ChildPromise do
     Otherwise do
       it 'is rejected' do
         subject
-        expect(child_promise).to be_rejected
+        expect(child_promise.promise).to be_rejected
       end
 
       it 'is rejected with the supplied value' do
         subject
-        expect(child_promise.result).to eq(reject_value)
+        expect(child_promise.promise.result).to eq(reject_value)
       end
     end
   end

data/spec/lib/mr_darcy/promise/em_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe MrDarcy::Promise::EM do
+  describe '#initialize' do
+    describe 'JRuby warning' do
+      subject { -> { MrDarcy::Promise::EM.new proc {} } }
+
+      When 'running on jruby' do
+        before { stub_const 'RUBY_ENGINE', 'jruby' }
+
+        it { should raise_error }
+      end
+
+      Otherwise do
+        it { should_not raise_error }
+      end unless RUBY_ENGINE == 'jruby'
+    end
+
+  end
+end