Narnach-future 0.1.1 → 0.2.0

data/README.rdoc

@@ -6,22 +6,24 @@ value in the future. Think of asynchronous messaging and long-lasting method
 calls.
 
 An example:
-  include Future
-  f = future { sleep 5; 123}
-  puts f * 5
-The future will take 5 seconds to run, then 123 is returned.
+  f = Future.new { sleep 5; 123}
+  puts f * 5 #=> 615
+Theis future will take 5 seconds to run, then 123 is returned.
 The call f.*(5) will block until the future is done.
 
 Another example:
-  include Future
-  f1 = future { sleep 5; 10}
-  f2 = future { sleep 3; 20}
-  f3 = future { sleep 1; 30}
+  f1 = Future.new { sleep 5; 10}
+  f2 = Future.new { sleep 3; 20}
+  f3 = Future.new { sleep 1; 30}
   puts f3 + f2 + f1
 Here it only takes 5 seconds to calculate the sum instead of the 9 it would take when done sequentially.
 
 == Recent changes
 
+=== Version 0.2.0
+* Replaced Future Module with Future class. The old syntax is no longer supported.
+* Replaced one-time use of eval with undef_method.
+
 === Version 0.1.1
 * Added specs
 

data/future.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.name         = 'future'
   s.summary      = "A naieve implementation of futures"
   s.description  = "A naieve implementation of futures"
-  s.version      = '0.1.1'
-  s.date         = '2008-12-08'
+  s.version      = '0.2.0'
+  s.date         = '2008-12-10'
   s.platform     = Gem::Platform::RUBY
   s.authors      = ["Wes Oldenbeuving"]
   s.email        = "narnach@gmail.com"

data/lib/future.rb

@@ -4,30 +4,27 @@
 # calls.
 #
 # An example:
-#   include Future
-#   f = future { sleep 5; 123}
+#   f = Future.new { sleep 5; 123}
 #   puts f * 5 #=> 615
-# The future will take 5 seconds to run, then 123 is returned.
+# Theis future will take 5 seconds to run, then 123 is returned.
 # The call f.*(5) will block until the future is done.
 #
 # Another example:
-#   include Future
-#   f1 = future { sleep 5; 10}
-#   f2 = future { sleep 3; 20}
-#   f3 = future { sleep 1; 30}
+#   f1 = Future.new { sleep 5; 10}
+#   f2 = Future.new { sleep 3; 20}
+#   f3 = Future.new { sleep 1; 30}
 #   puts f3 + f2 + f1
 # Here it only takes 5 seconds to calculate the sum instead of the 9 it would take when done sequentially.
-module Future
-  def future(&block)
-    t = Thread.new(&block)
-    class << t
-      (instance_methods - %w[value __send__ __id__]).each do |meth|
-        eval("undef #{meth}")
-      end
-      def method_missing(*args, &block)
-        value.send(*args,&block)
-      end
-    end
-    t
+class Future
+  (instance_methods - %w[__send__ __id__ object_id]).each do |meth|
+    undef_method meth
+  end
+
+  def initialize(&block)
+    @thread = Thread.new(&block)
+  end
+
+  def method_missing(*args, &block)
+    @thread.value.send(*args,&block)
   end
 end

data/spec/future_spec.rb

@@ -1,25 +1,19 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'future'
 
-class TimeTraveller
-  include Future
-end
-
-describe Future, '#future' do
+describe Future, '.new' do
   it 'should return the return value of the block' do
-    tt = TimeTraveller.new
-    f1 = tt.future { 10 }
-    f2 = tt.future { 20 }
-    f3 = tt.future { 30 }
+    f1 = Future.new { 10 }
+    f2 = Future.new { 20 }
+    f3 = Future.new { 30 }
     (f3 + f2 + f1).should == 60
   end
 
   it 'should execute futures in parallel' do
-    tt = TimeTraveller.new
     now = Time.now
-    f1 = tt.future { sleep 0.2; 10 }
-    f2 = tt.future { sleep 0.1; 20 }
-    f3 = tt.future { 30 }
+    f1 = Future.new { sleep 0.2; 10 }
+    f2 = Future.new { sleep 0.1; 20 }
+    f3 = Future.new { 30 }
     f3+f2+f1
     diff = Time.now - now
     diff.should < 0.3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Narnach-future
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Wes Oldenbeuving
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-08 00:00:00 -08:00
+date: 2008-12-10 00:00:00 -08:00
 default_executable: 
 dependencies: []