Fixed metaprogramming bug in Concurrent::Async

Author: jdantonio

lib/concurrent/async.rb

@@ -7,6 +7,11 @@ module Concurrent
   # A mixin module that provides simple asynchronous behavior to any standard
   # class/object or object. 
   #
+  #   Scenario:
+  #     As a stateful, plain old Ruby class/object
+  #     I want safe, asynchronous behavior
+  #     So my long-running methods don't block the main thread
+  #
   # Stateful, mutable objects must be managed carefully when used asynchronously.
   # But Ruby is an object-oriented language so designing with objects and classes
   # plays to Ruby's strengths and is often more natural to many Ruby programmers.
@@ -25,7 +30,7 @@ module Concurrent
   #
   # Very loosely based on the +async+ and +await+ keywords in C#.
   #
-  # @example
+  # @example Defining an asynchronous class
   #   class Echo
   #     include Concurrent::Async
   #
@@ -42,6 +47,18 @@ module Concurrent
   #   horn.async.echo('one') # asynchronous, non-blocking, thread-safe
   #   horn.await.echo('two') # synchronous, blocking, thread-safe
   #
+  # @example Monkey-patching an existing object
+  #   numbers = 1_000_000.times.collect{ rand }
+  #   numbers.extend(Concurrent::Async)
+  #   
+  #   future = numbers.async.max
+  #   future.state #=> :pending
+  #   
+  #   sleep(2)
+  #   
+  #   future.state #=> :fulfilled
+  #   future.value #=> 0.999999138918843
+  #
   # @note Thread safe guarantees can only be made when asynchronous method calls
   #       are not mixed with synchronous method calls. Use only synchronous calls
   #       when the object is used exclusively on a single thread. Use only
@@ -119,7 +136,7 @@ def method_missing(method, *args, &block)
         super unless @delegate.respond_to?(method)
         Async::validate_argc(@delegate, method, *args)
 
-        AwaitDelegator.send(:define_method, method) do |*args|
+        self.define_singleton_method(method) do |*args|
           Async::validate_argc(@delegate, method, *args)
           ivar = Concurrent::IVar.new
           value, reason = nil, nil
@@ -171,7 +188,7 @@ def method_missing(method, *args, &block)
         super unless @delegate.respond_to?(method)
         Async::validate_argc(@delegate, method, *args)
 
-        AsyncDelegator.send(:define_method, method) do |*args|
+        self.define_singleton_method(method) do |*args|
           Async::validate_argc(@delegate, method, *args)
           Concurrent::Future.execute do
             mutex.synchronize do

spec/concurrent/async_spec.rb

@@ -135,29 +135,29 @@ def many(*args, &block) nil; end
         val.should be_rejected
       end
 
-      it 'defines the method after the first call' do
-        pending('failing inconsistently')
-        expect { subject.async.method(:echo) }.to raise_error(NameError)
-        subject.async.echo(:foo)
-        sleep(0.1)
-        expect { subject.async.method(:echo) }.not_to raise_error
+      it 'is aliased as #future' do
+        val = subject.future.wait(5)
+        val.should be_a Concurrent::Future
       end
 
-      it 'does not define the method on name/arity exception' do
-        pending('failing inconsistently')
-        expect { subject.async.method(:bogus) }.to raise_error(NameError)
-        expect { subject.async.bogus }.to raise_error(NameError)
-        expect { subject.async.method(:bogus) }.to raise_error(NameError)
-      end
+      context '#method_missing' do
 
-      it 'uses the same mutex as #await' do
-        subject.await.mutex.should eq subject.async.mutex
-      end
+        it 'defines the method after the first call' do
+          expect { subject.async.method(:echo) }.to raise_error(NameError)
+          subject.async.echo(:foo)
+          sleep(0.1)
+          expect { subject.async.method(:echo) }.not_to raise_error
+        end
 
-      it 'is aliased as #future' do
-        val = subject.future.wait(5)
-        val.should be_a Concurrent::Future
-        val.should be_pending
+        it 'does not define the method on name/arity exception' do
+          expect { subject.async.method(:bogus) }.to raise_error(NameError)
+          expect { subject.async.bogus }.to raise_error(NameError)
+          expect { subject.async.method(:bogus) }.to raise_error(NameError)
+        end
+
+        it 'uses the same mutex as #await' do
+          subject.await.mutex.should eq subject.async.mutex
+        end
       end
     end
 
@@ -206,28 +206,28 @@ def many(*args, &block) nil; end
         val.should be_rejected
       end
 
-      it 'defines the method after the first call' do
-        pending('failing inconsistently')
-        expect { subject.await.method(:echo) }.to raise_error(NameError)
-        subject.await.echo(:foo)
-        expect { subject.await.method(:echo) }.not_to raise_error
+      it 'is aliased as #defer' do
+        val = subject.defer.echo(5)
+        val.should be_a Concurrent::IVar
       end
 
-      it 'does not define the method on name/arity exception' do
-        pending('failing inconsistently')
-        expect { subject.await.method(:bogus) }.to raise_error(NameError)
-        expect { subject.await.bogus }.to raise_error(NameError)
-        expect { subject.await.method(:bogus) }.to raise_error(NameError)
-      end
+      context '#method_missing' do
 
-      it 'uses the same mutex as #async' do
-        subject.await.mutex.should eq subject.async.mutex
-      end
+        it 'defines the method after the first call' do
+          expect { subject.await.method(:echo) }.to raise_error(NameError)
+          subject.await.echo(:foo)
+          expect { subject.await.method(:echo) }.not_to raise_error
+        end
 
-      it 'is aliased as #defer' do
-        val = subject.defer.echo(5)
-        val.should be_a Concurrent::IVar
-        val.should be_fulfilled
+        it 'does not define the method on name/arity exception' do
+          expect { subject.await.method(:bogus) }.to raise_error(NameError)
+          expect { subject.await.bogus }.to raise_error(NameError)
+          expect { subject.await.method(:bogus) }.to raise_error(NameError)
+        end
+
+        it 'uses the same mutex as #async' do
+          subject.await.mutex.should eq subject.async.mutex
+        end
       end
     end
   end