promise 0.2.0 → 0.2.1

data/AUTHORS

@@ -1 +1,3 @@
 * Ben Lavender <blavender@gmail.com> (Lead developer)
+* Arto Bendiken <arto.bendiken@gmail.com>
+Special thanks to Marc-André Lafortune for some excellent code review

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/future.rb

@@ -1,67 +1,65 @@
 require 'promise'
 
 ##
-# A delayed-execution result, optimistcally evaluated in a new Thread.
+# A delayed-execution result, optimistically evaluated in a new thread.
+#
 # @example
-#     x = future { sleep 5; 1 + 2 }
-#     # do stuff...
-#     y = x * 2     # => 6.  blocks unless 5 seconds has passed.
+#   x = future { sleep 5; 1 + 2 }
+#   # do stuff...
+#   y = x * 2     # => 6.  blocks unless 5 seconds has passed.
 #
 class Future < defined?(BasicObject) ? BasicObject : Object
-
   instance_methods.each { |m| undef_method m unless m =~ /__/ } unless defined?(BasicObject)
 
   ##
-  # Create a new future
+  # Creates a new future.
   #
-  # @yield [] The block to evaluate optimistically
-  # @return [Future]
-  def initialize(block)
-    @promise = promise &block
-    @thread = ::Thread.new do
-      @promise.force
-    end
+  # @yield  [] The block to evaluate optimistically.
+  # @see    Kernel#future
+  def initialize(&block)
+    @promise = ::Promise.new(&block)
+    @thread  = ::Thread.new { @promise.__force__ }
   end
 
   ##
   # The value of the future's evaluation.  Blocks until result available.
   #
-  # @return [Any]
+  # @return [Object]
   def __force__
-    @thread.join
+    @thread.join if @thread
     @promise
   end
   alias_method :force, :__force__
 
   ##
-  # Does this promise support the given method?
+  # Does this future support the given method?
   #
   # @param  [Symbol]
-  # @return [true, false]
+  # @return [Boolean]
   def respond_to?(method)
-    (method == :force) || (method == :__force__) || (__force__.respond_to?(method))
+    :force.equal?(method) || :__force__.equal?(method) || __force__.respond_to?(method)
   end
 
-  # @private
+  private
+
   def method_missing(method, *args, &block)
-    @promise.send(method, *args, &block)
+    __force__.__send__(method, *args, &block)
   end
-
-
 end
 
-
 module Kernel
-
-  # Create a new future
+  ##
+  # Creates a new future.
   #
   # @example Evaluate an operation in another thread
-  #     x = future { 3 + 3 }
-  # @return       [Future]
-  # @yield        [] A block to be optimistically evaluated in another thread
-  # @yieldreturn  [Any] The return value of the block will be the evaluated value of the future. 
+  #   x = future { 3 + 3 }
+  #
+  # @yield       []
+  #   A block to be optimistically evaluated in another thread.
+  # @yieldreturn [Object]
+  #   The return value of the block will be the evaluated value of the future.
+  # @return      [Future]
   def future(&block)
-    Future.new(block)
+    Future.new(&block)
   end
-
 end

data/lib/promise.rb

@@ -1,36 +1,38 @@
 ##
 # A delayed-execution promise.  Promises are only executed once.
+#
 # @example
-#     x = promise { factorial 20 }
-#     y = promise { fibonacci 10**6 }
-#     a = x + 1     # => factorial 20 + 1 after factorial calculates
-#     result = promise { a += y }
-#     abort ""      # whew, we never needed to calculate y
+#   x = promise { factorial 20 }
+#   y = promise { fibonacci 10**6 }
+#   a = x + 1     # => factorial 20 + 1 after factorial calculates
+#   result = promise { a += y }
+#   abort ""      # whew, we never needed to calculate y
+#
 # @example
-#     y = 5
-#     x = promise { y = y + 5 }
-#     x + 5     # => 15
-#     x + 5     # => 15
+#   y = 5
+#   x = promise { y = y + 5 }
+#   x + 5     # => 15
+#   x + 5     # => 15
+#
 class Promise < defined?(BasicObject) ? BasicObject : ::Object
+  NOT_SET = ::Object.new.freeze
 
   instance_methods.each { |m| undef_method m unless m.to_s =~ /__/ }
 
-  NOT_SET = ::Object.new.freeze
-
   ##
-  # Create a new promise
+  # Creates a new promise.
   #
   # @example Lazily evaluate a database call
-  #     result = promise { @db.query("SELECT * FROM TABLE") }
-  # @param [Proc] block
-  # @return [Promise]
-  # @see Kernel#promise
-  def initialize(block)
+  #   result = promise { @db.query("SELECT * FROM TABLE") }
+  #
+  # @yield  [] The block to evaluate lazily.
+  # @see    Kernel#promise
+  def initialize(&block)
     if block.arity > 0
       raise ArgumentError, "Cannot store a promise that requires an argument"
     end
-    @block = block
-    @mutex = ::Mutex.new
+    @block  = block
+    @mutex  = ::Mutex.new
     @result = NOT_SET
     @error  = NOT_SET
   end
@@ -38,19 +40,19 @@ class Promise < defined?(BasicObject) ? BasicObject : ::Object
   ##
   # Force the evaluation of this promise immediately
   #
-  # @return [Any]
+  # @return [Object]
   def __force__
     @mutex.synchronize do
-      if @result == NOT_SET && @error == NOT_SET
+      if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
         begin
           @result = @block.call
         rescue ::Exception => e
           @error = e
         end
       end
-    end if @result == NOT_SET && @error == NOT_SET
+    end if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
     # BasicObject won't send raise to Kernel
-    @error.equal?(NOT_SET) ? @result : (::Kernel.raise @error)
+    @error.equal?(NOT_SET) ? @result : ::Kernel.raise(@error)
   end
   alias_method :force, :__force__
 
@@ -58,28 +60,31 @@ class Promise < defined?(BasicObject) ? BasicObject : ::Object
   # Does this promise support the given method?
   #
   # @param  [Symbol]
-  # @return [true, false]
+  # @return [Boolean]
   def respond_to?(method)
-    (method == :force) || (method == :__force__) || (__force__.respond_to?(method))
+    :force.equal?(method) || :__force__.equal?(method) || __force__.respond_to?(method)
   end
 
+  private
+
   def method_missing(method, *args, &block)
-    __force__
-    @result.send(method, *args, &block)
+    __force__.__send__(method, *args, &block)
   end
 end
 
 module Kernel
-
-  # Create a new promise
+  ##
+  # Creates a new promise.
   #
   # @example Lazily evaluate an arithmetic operation
-  #     x = promise { 3 + 3 }
-  # @return       [Promise]
-  # @yield        [] A block to be lazily evaluated
-  # @yieldreturn  [Any] The return value of the block will be the lazily evaluated value of the promise. 
+  #   x = promise { 3 + 3 }
+  #
+  # @yield       []
+  #   A block to be lazily evaluated.
+  # @yieldreturn [Object]
+  #   The return value of the block will be the lazily evaluated value of the promise.
+  # @return      [Promise]
   def promise(&block)
-    Promise.new(block)
+    Promise.new(&block)
   end
-
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Ben Lavender
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-22 00:00:00 -05:00
+date: 2010-06-29 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,8 +41,8 @@ dependencies:
         segments: 
         - 0
         - 5
-        - 6
-        version: 0.5.6
+        - 8
+        version: 0.5.8
   type: :development
   version_requirements: *id002
 description: "    A glimpse of a promising future in which Ruby supports delayed execution.\n    Provides global 'promise' and 'future' methods.\n"