ione 1.1.5 → 1.2.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db1f327275f2a707826e35fe337e9244e24579d3
-  data.tar.gz: 49634515f2915a2d148fc9bd7261d3995a9c9624
+  metadata.gz: b1ae6f32b5b3e404b07f6ec0a0b20856a0458719
+  data.tar.gz: 6a1e98dcd2cb657b2cbbe7dcc29514e38c672608
 SHA512:
-  metadata.gz: 5573efe1dab6a07649012f63b02dd160023033ba674cb582050d57aaeef4a98cbd00d43651d6d732c3e2d98e32b2cdf838a678836904b9066cf4bb9fda22d806
-  data.tar.gz: 8a0b37f8dde7c69f1f05a4bed764c2c3cb5acdd2460fed882d71dd4bc0c1155983e07a2cf2c2ee76510eff1afd8b4f8496a310b308c7838bf411df4a99b0d4ac
+  metadata.gz: b57e6559e0be8dca588b6f4b7d1cf069041848d368de377ad0c4db94f4863c0d0194d66843190fc18f1de2c92a0465429d32773d4994c8aee405a584aa167544
+  data.tar.gz: 8a30c9516df0d52376ebda8958446fdb35d4fb9adbe4028d180afb438f31061bb77ede9ecebde1e7a640ba19364a2a2a35acc691288585de35e2ea64453d5526

data/lib/ione/future.rb

@@ -44,8 +44,13 @@ module Ione
     #
     # @param [Ione::Future] future the future to observe
     def observe(future)
-      future.on_value { |v| fulfill(v) }
-      future.on_failure { |e| fail(e) }
+      future.on_complete do |_, v, e|
+        if e
+          fail(e)
+        else
+          fulfill(v)
+        end
+      end
     end
 
     # Run the given block and fulfill this promise with its result. If the block
@@ -81,12 +86,14 @@ module Ione
     # The value of the combined future is an array of the values of the
     # constituent futures.
     #
-    # @param [Array<Ione::Future>] futures the futures to combine
+    # @param [Array<Ione::Future>] futures the futures to combine (this argument
+    #   can be a splatted array or a regular array passed as sole argument)
     # @return [Ione::Future<Array>] an array of the values of the constituent
     #   futures
     def all(*futures)
       return resolved([]) if futures.empty?
-      return futures.first.map { |v| [v] } if futures.size == 1
+      futures = futures.size == 1 && futures.first.is_a?(Enumerable) ? futures.first : futures
+      return futures.first.map { |v| [v] } if futures.is_a?(Array) && futures.size == 1
       CombinedFuture.new(futures)
     end
 
@@ -94,14 +101,90 @@ module Ione
     # (resolved) of the specified futures. If all of the futures fail, the
     # returned future will also fail (with the error of the last failed future).
     #
-    # @param [Array<Ione::Future>] futures the futures to monitor
+    # @param [Array<Ione::Future>] futures the futures to monitor (this argument
+    #   can be a splatted array or a regular array passed as sole argument)
     # @return [Ione::Future] a future which represents the first completing future
     def first(*futures)
       return resolved if futures.empty?
-      return futures.first if futures.size == 1
+      futures = futures.size == 1 && futures.first.is_a?(Enumerable) ? futures.first : futures
+      return futures.first if futures.is_a?(Array) && futures.size == 1
       FirstFuture.new(futures)
     end
 
+    # Takes calls the block once for each element in an array, expecting each
+    # invocation to return a future, and returns a future that resolves to
+    # an array of the values of those futures.
+    #
+    # @example
+    #   ids = [1, 2, 3]
+    #   future = Future.traverse(ids) { |id| load_thing(id) }
+    #   future.value # => [thing1, thing2, thing3]
+    #
+    # @param [Array<Object>] values an array whose elements will be passed to
+    #   the block, one by one
+    # @yieldparam [Object] value each element from the array
+    # @yieldreturn [Ione::Future] a future
+    # @return [Ione::Future] a future that will resolve to an array of the values
+    #   of the futures returned by the block
+    def traverse(values, &block)
+      all(*values.map(&block))
+    rescue => e
+      failed(e)
+    end
+
+    # Returns a future that will resolve to a value which is the reduction of
+    # the values of a list of source futures.
+    #
+    # This is essentially a parallel, streaming version of {Enumerable#reduce},
+    # but for futures. Use this method for example when you want to do a number
+    # of asynchronous operations in parallel and then merge the results together
+    # when all are done.
+    #
+    # The block will not be called concurrently, which means that unless you're
+    # handling the initial value or other values in the scope of the block you
+    # don't need (and shouldn't) do any locking to ensure that the accumulator
+    # passed to the block is safe to modify. It is, of course, even better if
+    # you don't modify the accumulator, but return a new, immutable value on
+    # each invocation.
+    #
+    # @example Merging the results of multipe asynchronous calls
+    #   futures = ... # a list of futures that will resolve to hashes
+    #   merged_future = Future.reduce(futures, {}) do |accumulator, value|
+    #     accumulator.merge(value)
+    #   end
+    #
+    # @example Reducing with an associative and commutative function, like addition
+    #   futures = ... # a list of futures that will resolve to numbers
+    #   sum_future = Future.reduce(futures, 0, ordered: false) do |accumulator, value|
+    #     accumulator + value
+    #   end
+    #
+    # @param [Array<Ione::Future>] futures an array of futures whose values
+    #   should be reduced
+    # @param [Object] initial_value the initial value of the accumulator
+    # @param [Hash] options
+    # @option options [Boolean] :ordered (true) whether or not to respect the
+    #   order of the input when reducing – when true the block will be called
+    #   with the values of the source futures in the order they have in the
+    #   given list, when false the block will be called in the order that the
+    #   futures resolve (which means that your reducer function needs to be
+    #   associative and commutative).
+    # @yieldparam [Object] accumulator the value of the last invocation of the
+    #   block, or the initial value if this is the first invocation
+    # @yieldparam [Object] value the value of one of the source futures
+    # @yieldreturn [Object] the value to pass as accumulator to the next
+    #   invocation of the block
+    # @return [Ione::Future] a future that will resolve to the value returned
+    #   from the last invocation of the block, or nil when the list of futures
+    #   is empty.
+    def reduce(futures, initial_value=nil, options=nil, &reducer)
+      if options && options[:ordered] == false
+        UnorderedReducingFuture.new(futures, initial_value, reducer)
+      else
+        OrderedReducingFuture.new(futures, initial_value, reducer)
+      end
+    end
+
     # Creates a new pre-resolved future.
     #
     # @param [Object, nil] value the value of the created future
@@ -131,10 +214,19 @@ module Ione
     # @yieldreturn [Object] the transformed value
     # @return [Ione::Future] a new future representing the transformed value
     def map(value=nil, &block)
-      CompletableFuture.new.tap do |f|
-        on_failure { |e| f.fail(e) }
-        on_value { |v| run(f, value, block, v) }
+      f = CompletableFuture.new
+      on_complete do |_, v, e|
+        if e
+          f.fail(e)
+        else
+          begin
+            f.resolve(block ? block.call(v) : value)
+          rescue => e
+            f.fail(e)
+          end
+        end
       end
+      f
     end
 
     # Returns a new future representing a transformation of this future's value,
@@ -149,16 +241,82 @@ module Ione
     # @yieldreturn [Ione::Future] a future representing the transformed value
     # @return [Ione::Future] a new future representing the transformed value
     def flat_map(&block)
-      CompletableFuture.new.tap do |f|
-        on_failure { |e| f.fail(e) }
-        on_value { |v| chain(f, block, v) }
+      f = CompletableFuture.new
+      on_complete do |_, v, e|
+        if e
+          f.fail(e)
+        else
+          begin
+            ff = block.call(v)
+            ff.on_complete do |_, vv, ee|
+              if ee
+                f.fail(ee)
+              else
+                f.resolve(vv)
+              end
+            end
+          rescue => e
+            f.fail(e)
+          end
+        end
       end
+      f
+    end
+
+    # Returns a new future representing a transformation of this future's value,
+    # similarily to {#map}, but acts as {#flat_map} when the block returns a
+    # {Future}.
+    #
+    # This method is useful when you want to transform the value of a future,
+    # but whether or not it can be done synchronously or require an asynchronous
+    # operation depends on the value of the future.
+    #
+    # @example
+    #   future1 = load_something
+    #   future2 = future1.then do |result|
+    #     if result.empty?
+    #       # make a new async call to load fallback value
+    #       load_something_else
+    #     else
+    #       result
+    #     end
+    #   end
+    #
+    # @yieldparam [Object] value the value of this future
+    # @yieldreturn [Object, Ione::Future] the transformed value, or a future
+    #   that will resolve to the transformed value.
+    # @return [Ione::Future] a new future representing the transformed value
+    def then(&block)
+      f = CompletableFuture.new
+      on_complete do |_, v, e|
+        if e
+          f.fail(e)
+        else
+          begin
+            fv = block.call(v)
+            if fv.respond_to?(:on_complete)
+              fv.on_complete do |_, vv, ee|
+                if ee
+                  f.fail(ee)
+                else
+                  f.resolve(vv)
+                end
+              end
+            else
+              f.resolve(fv)
+            end
+          rescue => e
+            f.fail(e)
+          end
+        end
+      end
+      f
     end
 
     # Returns a new future which represents either the value of the original
     # future, or the result of the given block, if the original future fails.
     #
-    # This method is similar to{#map}, but is triggered by a failure. You can
+    # This method is similar to {#map}, but is triggered by a failure. You can
     # also think of it as a `rescue` block for asynchronous operations.
     #
     # If the block raises an error a failed future with that error will be
@@ -175,10 +333,19 @@ module Ione
     # @yieldreturn [Object] the value of the new future
     # @return [Ione::Future] a new future representing a value recovered from the error
     def recover(value=nil, &block)
-      CompletableFuture.new.tap do |f|
-        on_failure { |e| run(f, value, block, e) }
-        on_value { |v| f.resolve(v) }
+      f = CompletableFuture.new
+      on_complete do |_, v, e|
+        if e
+          begin
+            f.resolve(block ? block.call(e) : value)
+          rescue => e
+            f.fail(e)
+          end
+        else
+          f.resolve(v)
+        end
       end
+      f
     end
 
     # Returns a new future which represents either the value of the original
@@ -204,27 +371,26 @@ module Ione
     # @return [Ione::Future] a new future representing a value recovered from the
     #   error
     def fallback(&block)
-      CompletableFuture.new.tap do |f|
-        on_failure { |e| chain(f, block, e) }
-        on_value { |v| f.resolve(v) }
+      f = CompletableFuture.new
+      on_complete do |_, v, e|
+        if e
+          begin
+            ff = block.call(e)
+            ff.on_complete do |_, vv, ee|
+              if ee
+                f.fail(ee)
+              else
+                f.resolve(vv)
+              end
+            end
+          rescue => e
+            f.fail(e)
+          end
+        else
+          f.resolve(v)
+        end
       end
-    end
-
-    private
-
-    def run(f, value, producer, arg)
-      value = producer ? producer.call(arg) : value
-      f.resolve(value)
-    rescue => e
-      f.fail(e)
-    end
-
-    def chain(f, constructor, arg)
-      ff = constructor.call(arg)
-      ff.on_failure { |e| f.fail(e) }
-      ff.on_value { |v| f.resolve(v) }
-    rescue => e
-      f.fail(e)
+      f
     end
   end
 
@@ -251,7 +417,7 @@ module Ione
         end
       end
       if run_immediately
-        listener.call(self) rescue nil
+        listener.call(self, @value, @error) rescue nil
       end
       nil
     end
@@ -417,7 +583,7 @@ module Ione
         listener.call(v) rescue nil
       end
       complete_listeners.each do |listener|
-        listener.call(self) rescue nil
+        listener.call(self, v, nil) rescue nil
       end
       nil
     end
@@ -442,7 +608,7 @@ module Ione
         listener.call(error) rescue nil
       end
       complete_listeners.each do |listener|
-        listener.call(self) rescue nil
+        listener.call(self, nil, error) rescue nil
       end
       nil
     end
@@ -452,40 +618,135 @@ module Ione
   class CombinedFuture < CompletableFuture
     def initialize(futures)
       super()
-      values = Array.new(futures.size)
-      remaining = futures.size
+      remaining = futures.count
+      values = Array.new(remaining)
       futures.each_with_index do |f, i|
-        f.on_value do |v|
-          @lock.lock
-          begin
-            values[i] = v
-            remaining -= 1
-          ensure
-            @lock.unlock
+        f.on_complete do |_, v, e|
+          unless failed?
+            if e
+              fail(e)
+            else
+              @lock.lock
+              begin
+                values[i] = v
+                remaining -= 1
+              ensure
+                @lock.unlock
+              end
+              if remaining == 0
+                resolve(values)
+              end
+            end
           end
-          if remaining == 0
-            resolve(values)
+        end
+      end
+    end
+  end
+
+  # @private
+  class ReducingFuture < CompletableFuture
+    def initialize(futures, initial_value, reducer)
+      super()
+      @futures = Array(futures)
+      @remaining = @futures.size
+      @initial_value = initial_value
+      @accumulator = initial_value
+      @reducer = reducer
+    end
+
+    private
+
+    def reduce_one(value)
+      unless failed?
+        @lock.lock
+        begin
+          if @accumulator
+            @accumulator = @reducer.call(@accumulator, value)
+          else
+            @accumulator = value
           end
+          @remaining -= 1
+        rescue => e
+          @lock.unlock
+          fail(e)
+        else
+          @lock.unlock
         end
-        f.on_failure do |e|
-          unless failed?
+        unless failed?
+          if @remaining == 0
+            resolve(@accumulator)
+            :done
+          else
+            :continue
+          end
+        end
+      end
+    end
+  end
+
+  # @private
+  class OrderedReducingFuture < ReducingFuture
+    def initialize(futures, initial_value, reducer)
+      super
+      if @remaining > 0
+        reduce_next(0)
+      else
+        resolve(@initial_value)
+      end
+    end
+
+    private
+
+    def reduce_next(i)
+      @futures[i].on_complete do |_, v, e|
+        unless failed?
+          if e
             fail(e)
+          elsif reduce_one(v) == :continue
+            reduce_next(i + 1)
           end
         end
       end
     end
   end
 
+  # @private
+  class UnorderedReducingFuture < ReducingFuture
+    def initialize(futures, initial_value, reducer)
+      super
+      if @remaining > 0
+        futures.each do |f|
+          f.on_complete do |_, v, e|
+            unless failed?
+              if e
+                fail(e)
+              else
+                reduce_one(v)
+              end
+            end
+          end
+        end
+      else
+        resolve(@initial_value)
+      end
+    end
+  end
+
   # @private
   class FirstFuture < CompletableFuture
     def initialize(futures)
       super()
       futures.each do |f|
-        f.on_value do |value|
-          resolve(value) unless completed?
-        end
-        f.on_failure do |e|
-          fail(e) if futures.all?(&:failed?)
+        f.on_complete do |_, v, e|
+          unless completed?
+            if e
+              if futures.all?(&:failed?)
+                fail(e)
+              end
+            else
+              resolve(v)
+            end
+          end
         end
       end
     end
@@ -516,7 +777,7 @@ module Ione
     end
 
     def on_complete(&listener)
-      listener.call(self) rescue nil
+      listener.call(self, @value, nil) rescue nil
     end
 
     def on_value(&listener)
@@ -554,7 +815,7 @@ module Ione
     end
 
     def on_complete(&listener)
-      listener.call(self) rescue nil
+      listener.call(self, nil, @error) rescue nil
     end
 
     def on_value

data/lib/ione/io/base_connection.rb

@@ -9,7 +9,6 @@ module Ione
         @host = host
         @port = port
         @state = :connecting
-        @lock = Mutex.new
         @closed_promise = Promise.new
       end
 
@@ -17,10 +16,7 @@ module Ione
       #
       # @return [true, false] returns false if the connection was already closed
       def close(cause=nil)
-        @lock.synchronize do
-          return false if @state == :closed
-          @state = :closed
-        end
+        return false if @state == :closed
         if @io
           begin
             @io.close
@@ -29,6 +25,7 @@ module Ione
             # nothing to do, the socket was most likely already closed
           end
         end
+        @state = :closed
         if cause
           @closed_promise.fail(cause)
         else

data/lib/ione/io/connection.rb

@@ -14,6 +14,7 @@ module Ione
         @unblocker = unblocker
         @clock = clock
         @socket_impl = socket_impl
+        @lock = Mutex.new
         @write_buffer = ByteBuffer.new
         @connected_promise = Promise.new
         on_closed(&method(:cleanup_on_close))

data/lib/ione/io/io_reactor.rb

@@ -293,21 +293,13 @@ module Ione
       end
 
       def cancel_timer(timer_future)
-        timer = nil
         @lock.lock
-        begin
-          if (timer_pair = @timers.find { |pair| (p = pair[1]) && p.future == timer_future })
-            @timers = @timers.reject { |pair| pair[1].nil? || pair == timer_pair }
-            timer = timer_pair[1]
-            timer_pair[1] = nil
-          end
-        ensure
-          @lock.unlock
-        end
-        if timer
-          timer.fail(CancelledError.new)
-        end
+        timer_pair = @timers.find { |pair| (p = pair[1]) && p.future == timer_future }
+        @timers = @timers.reject { |pair| pair[1].nil? || pair == timer_pair }
+        timer_pair && timer_pair[1].fail(CancelledError.new)
         nil
+      ensure
+        @lock.unlock
       end
 
       def close_sockets
@@ -349,25 +341,21 @@ module Ione
           writables << s if s.connecting? || s.writable?
           connecting << s if s.connecting?
         end
-        r, w, _ = @selector.select(readables, writables, nil, timeout)
-        connecting.each(&:connect)
-        r && r.each(&:read)
-        w && w.each(&:flush)
+        begin
+          r, w, _ = @selector.select(readables, writables, nil, timeout)
+          connecting.each(&:connect)
+          r && r.each(&:read)
+          w && w.each(&:flush)
+        rescue IOError, Errno::EBADF
+        end
       end
 
       def check_timers!
-        now = @clock.now
-        @timers.each do |pair|
-          if pair[1] && pair[0] <= now
-            timer = nil
-            @lock.lock
-            begin
-              timer = pair[1]
-              pair[1] = nil
-            ensure
-              @lock.unlock
-            end
-            timer.fulfill
+        timers = @timers
+        timers.each do |pair|
+          if pair[1] && pair[0] <= @clock.now
+            pair[1].fulfill
+            pair[1] = nil
           end
         end
       end

data/lib/ione/io/server_connection.rb

@@ -8,6 +8,7 @@ module Ione
         super(host, port)
         @io = socket
         @unblocker = unblocker
+        @lock = Mutex.new
         @write_buffer = ByteBuffer.new
         @state = :connected
       end

data/lib/ione/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Ione
-  VERSION = '1.1.5'.freeze
+  VERSION = '1.2.0.pre0'.freeze
 end

data/spec/ione/future_spec.rb

@@ -194,21 +194,48 @@ module Ione
     describe '#on_complete' do
       context 'registers listeners and' do
         it 'notifies all listeners when the promise is fulfilled' do
+          c1, c2 = false, false
+          future.on_complete { c1 = true }
+          future.on_complete { c2 = true }
+          promise.fulfill('bar')
+          c1.should be_true
+          c2.should be_true
+        end
+
+        it 'passes the future as the first parameter to the block' do
+          f1, f2 = nil, nil
+          future.on_complete { |f| f1 = f }
+          future.on_complete { |f| f2 = f }
+          promise.fulfill('bar')
+          f1.should equal(future)
+          f2.should equal(future)
+        end
+
+        it 'passes the value as the second parameter to the block' do
           v1, v2 = nil, nil
-          future.on_complete { |f| v1 = f.value }
-          future.on_complete { |f| v2 = f.value }
+          future.on_complete { |_, v| v1 = v }
+          future.on_complete { |_, v| v2 = v }
           promise.fulfill('bar')
           v1.should == 'bar'
           v2.should == 'bar'
         end
 
         it 'notifies all listeners when the promise fails' do
+          c1, c2 = nil, nil
+          future.on_complete { c1 = true }
+          future.on_complete { c2 = true }
+          future.fail(error)
+          c1.should be_true
+          c2.should be_true
+        end
+
+        it 'passes the error as the third parameter' do
           e1, e2 = nil, nil
-          future.on_complete { |f| begin; f.value; rescue => err; e1 = err; end }
-          future.on_complete { |f| begin; f.value; rescue => err; e2 = err; end }
+          future.on_complete { |_, _, e| e1 = e }
+          future.on_complete { |_, _, e| e2 = e }
           future.fail(error)
-          e1.message.should == error.message
-          e2.message.should == error.message
+          e1.should equal(error)
+          e2.should equal(error)
         end
 
         it 'notifies all listeners when the promise is fulfilled, even when one raises an error' do
@@ -228,8 +255,21 @@ module Ione
         end
 
         it 'notifies listeners registered after the promise was fulfilled' do
+          f, v, e = nil, nil, nil
           promise.fulfill('bar')
-          expect { future.on_complete { |v| raise 'blurgh' } }.to_not raise_error
+          future.on_complete { |ff, vv, ee| f = ff; v = vv; e = ee }
+          f.should equal(future)
+          v.should == 'bar'
+          e.should be_nil
+        end
+
+        it 'notifies listeners registered after the promise failed' do
+          f, v, e = nil, nil, nil
+          promise.fail(StandardError.new('bork'))
+          future.on_complete { |ff, vv, ee| f = ff; v = vv; e = ee }
+          f.should equal(future)
+          v.should be_nil
+          e.message.should == 'bork'
         end
 
         it 'notifies listeners registered after the promise failed' do
@@ -366,7 +406,7 @@ module Ione
         future.value.should == 'bar'
       end
 
-      it 'blocks on #value until fulfilled, when value is nil' do
+      it 'blocks on #value until completed, when value is nil' do
         d = delayed(promise) do |p|
           p.fulfill
         end
@@ -382,7 +422,7 @@ module Ione
         expect { future.value }.to raise_error('bork')
       end
 
-      it 'allows multiple threads to block on #value until fulfilled' do
+      it 'allows multiple threads to block on #value until completed' do
         listeners = Array.new(10) do
           async(future) do |f|
             f.value
@@ -396,7 +436,7 @@ module Ione
 
     describe '#map' do
       context 'returns a new future that' do
-        it 'will be fulfilled with the result of the given block' do
+        it 'will be resolved with the result of the given block' do
           mapped_value = nil
           p = Promise.new
           f = p.future.map { |v| v * 2 }
@@ -405,7 +445,7 @@ module Ione
           mapped_value.should == 3 * 2
         end
 
-        it 'will be fulfilled with the specified value' do
+        it 'will be resolved with the specified value' do
           mapped_value = nil
           p = Promise.new
           f = p.future.map(7)
@@ -414,7 +454,7 @@ module Ione
           mapped_value.should == 7
         end
 
-        it 'will be fulfilled with the result of the given block, even if a value is specified' do
+        it 'will be resolved with the result of the given block, even if a value is specified' do
           mapped_value = nil
           p = Promise.new
           f = p.future.map(7) { |v| v * 2 }
@@ -423,7 +463,7 @@ module Ione
           mapped_value.should == 3 * 2
         end
 
-        it 'will be fulfilled with nil when neither value nor block is specified' do
+        it 'will be resolved with nil when neither value nor block is specified' do
           mapped_value = 3
           p = Promise.new
           f = p.future.map
@@ -454,45 +494,97 @@ module Ione
     end
 
     describe '#flat_map' do
-      it 'works like #map, but expects that the block returns a future' do
+      context 'returns a future that' do
+        it 'passes the value of the source future to the block, and resolves to the value of the future returned by the block' do
+          p = Promise.new
+          f = p.future.flat_map { |v| Future.resolved(v * 2) }
+          p.fulfill(3)
+          f.value.should == 3 * 2
+        end
+
+        it 'fails when the block raises an error' do
+          p = Promise.new
+          f = p.future.flat_map { |v| raise 'Hurgh' }
+          p.fulfill(3)
+          expect { f.value }.to raise_error('Hurgh')
+        end
+      end
+
+      it 'accepts anything that implements #on_complete as a chained future' do
+        fake_future = double(:fake_future)
+        fake_future.stub(:on_complete) { |&listener| listener.call(nil, :foobar) }
         p = Promise.new
-        f = p.future.flat_map { |v| Future.resolved(v * 2) }
-        p.fulfill(3)
-        f.value.should == 3 * 2
+        f = p.future.flat_map { fake_future }
+        p.fulfill
+        f.value.should == :foobar
+      end
+    end
+
+    describe '#then' do
+      context 'when the block returns a future' do
+        it 'works like #flat_map' do
+          p = Promise.new
+          f = p.future.then { |v| Future.resolved(v * 2) }
+          p.fulfill(3)
+          f.value.should == 3 * 2
+        end
+      end
+
+      context 'when the block returns something that quacks like a future' do
+        it 'works like #flat_map' do
+          fake_future = double(:fake_future)
+          fake_future.stub(:on_complete) { |&listener| listener.call(nil, :foobar) }
+          p = Promise.new
+          f = p.future.then { |v| fake_future }
+          p.fulfill
+          f.value.should == :foobar
+        end
       end
 
-      it 'fails when the block raises an error' do
+      context 'when the block returns something that does not quack like a future' do
+        it 'works like #map' do
+          p = Promise.new
+          f = p.future.then { |v| v * 2 }
+          p.fulfill(3)
+          f.value.should == 3 * 2
+        end
+      end
+
+      it 'returns a failed future when the block raises an error' do
         p = Promise.new
-        f = p.future.flat_map { |v| raise 'Hurgh' }
-        p.fulfill(3)
-        expect { f.value }.to raise_error('Hurgh')
+        f = p.future.then { |v| raise 'blurgh' }
+        d = delayed do
+          p.fulfill
+        end
+        d.value
+        expect { f.value }.to raise_error('blurgh')
       end
     end
 
     describe '#recover' do
       context 'returns a new future that' do
-        it 'becomes fulfilled with a value created by the block when the source future fails' do
+        it 'resolves to a value created by the block when the source future fails' do
           p = Promise.new
           f = p.future.recover { 'foo' }
           p.fail(error)
           f.value.should == 'foo'
         end
 
-        it 'becomes fulfilled with a specfied value when the source future fails' do
+        it 'resolves to a specfied value when the source future fails' do
           p = Promise.new
           f = p.future.recover('bar')
           p.fail(error)
           f.value.should == 'bar'
         end
 
-        it 'becomes fulfilled with a value created by the block even when a value is specified when the source future fails' do
+        it 'resovles to a value created by the block even when a value is specified when the source future fails' do
           p = Promise.new
           f = p.future.recover('bar') { 'foo' }
           p.fail(error)
           f.value.should == 'foo'
         end
 
-        it 'becomes fulfilled with nil value when no value nor block is specified and the source future fails' do
+        it 'resolves to nil value when no value nor block is specified and the source future fails' do
           p = Promise.new
           f = p.future.recover
           p.fail(error)
@@ -506,7 +598,7 @@ module Ione
           f.value.should == error.message
         end
 
-        it 'becomes fulfilled with the value of the source future when the source future is fulfilled' do
+        it 'resolves to the value of the source future when the source future is resolved' do
           p = Promise.new
           f = p.future.recover { 'foo' }
           p.fulfill('bar')
@@ -567,6 +659,187 @@ module Ione
           p1.fail(StandardError.new('fnork'))
           expect { f.value }.to raise_error('bork')
         end
+
+        it 'accepts anything that implements #on_complete as a fallback future' do
+          fake_future = double(:fake_future)
+          fake_future.stub(:on_complete) { |&listener| listener.call(nil, 'foo') }
+          p = Promise.new
+          f = p.future.fallback { fake_future }
+          p.fail(error)
+          f.value.should == 'foo'
+        end
+      end
+    end
+
+    describe '.traverse' do
+      it 'combines Array#map and Future.all' do
+        future = Future.traverse([1, 2, 3]) do |element|
+          Future.resolved(element * 2)
+        end
+        future.value.should == [2, 4, 6]
+      end
+
+      it 'fails if any of the source futures fail' do
+        future = Future.traverse([1, 2, 3]) do |element|
+          if element == 2
+            Future.failed(StandardError.new('BORK'))
+          else
+            Future.resolved(element * 2)
+          end
+        end
+        future.should be_failed
+      end
+
+      it 'fails if any of the block invocations fail' do
+        future = Future.traverse([1, 2, 3]) do |element|
+          if element == 2
+            raise 'BORK'
+          else
+            Future.resolved(element * 2)
+          end
+        end
+        future.should be_failed
+      end
+
+      it 'accepts anything that implements #on_complete as futures' do
+        fake_future = double(:fake_future)
+        fake_future.stub(:on_complete) { |&listener| listener.call(nil, :foobar) }
+        future = Future.traverse([1, 2, 3]) { fake_future }
+        future.value.should == [:foobar, :foobar, :foobar]
+      end
+
+      it 'accepts an enumerable of values' do
+        future = Future.traverse([1, 2, 3].to_enum) { |v| Future.resolved(v * 2) }
+        future.value.should == [2, 4, 6]
+      end
+    end
+
+    describe '.reduce' do
+      it 'returns a future which represents the value of reducing the values of the inputs' do
+        futures = [
+          Future.resolved({'foo' => 'bar'}),
+          Future.resolved({'qux' => 'baz'}),
+          Future.resolved({'hello' => 'world'})
+        ]
+        future = Future.reduce(futures, {}) do |accumulator, value|
+          accumulator.merge(value)
+        end
+        future.value.should == {'foo' => 'bar', 'qux' => 'baz', 'hello' => 'world'}
+      end
+
+      it 'calls the block with the values in the order of the source futures' do
+        promises = [Promise.new, Promise.new, Promise.new, Promise.new, Promise.new]
+        futures = promises.map(&:future)
+        future = Future.reduce(futures, []) do |accumulator, value|
+          accumulator.push(value)
+        end
+        promises[1].fulfill(1)
+        promises[0].fulfill(0)
+        promises[2].fulfill(2)
+        promises[4].fulfill(4)
+        promises[3].fulfill(3)
+        future.value.should == [0, 1, 2, 3, 4]
+      end
+
+      it 'uses the first value as initial value when no intial value is given' do
+        promises = [Promise.new, Promise.new, Promise.new]
+        futures = promises.map(&:future)
+        future = Future.reduce(futures) do |sum, n|
+          sum + n
+        end
+        promises[1].fulfill(2)
+        promises[0].fulfill(1)
+        promises[2].fulfill(3)
+        future.value.should == 6
+      end
+
+      it 'fails if any of the source futures fail' do
+        futures = [Future.resolved(0), Future.failed(StandardError.new('BORK')), Future.resolved(2)]
+        future = Future.reduce(futures, []) do |accumulator, value|
+          accumulator.push(value)
+        end
+        future.should be_failed
+      end
+
+      it 'fails if any of the block invocations fail' do
+        futures = [Future.resolved(0), Future.resolved(1), Future.resolved(2)]
+        future = Future.reduce(futures, []) do |accumulator, value|
+          if value == 2
+            raise 'BORK'
+          else
+            accumulator.push(value)
+          end
+        end
+        future.should be_failed
+      end
+
+      context 'when the list of futures is empty' do
+        it 'returns a future that resolves to the initial value' do
+          Future.reduce([], :foo).value.should == :foo
+        end
+
+        it 'returns a future that resolves to nil there is also no initial value' do
+          Future.reduce([]).value.should be_nil
+        end
+      end
+
+      it 'accepts anything that implements #on_complete as futures' do
+        ff1, ff2, ff3 = double, double, double
+        ff1.stub(:on_complete) { |&listener| listener.call(nil, 1) }
+        ff2.stub(:on_complete) { |&listener| listener.call(nil, 2) }
+        ff3.stub(:on_complete) { |&listener| listener.call(nil, 3) }
+        future = Future.reduce([ff1, ff2, ff3], 0) { |sum, n| sum + n }
+        future.value.should == 6
+      end
+
+      it 'accepts an enumerable of futures' do
+        futures = [Future.resolved(1), Future.resolved(2), Future.resolved(3)].to_enum
+        future = Future.reduce(futures, 0) { |sum, n| sum + n }
+        future.value.should == 6
+      end
+
+      context 'when the :ordered option is false' do
+        it 'calls the block with the values in the order of completion, when the :ordered option is false' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future)
+          future = Future.reduce(futures, [], ordered: false) do |accumulator, value|
+            accumulator.push(value)
+          end
+          promises[1].fulfill(1)
+          promises[0].fulfill(0)
+          promises[2].fulfill(2)
+          future.value.should == [1, 0, 2]
+        end
+
+        it 'fails if any of the source futures fail' do
+          futures = [Future.resolved(0), Future.failed(StandardError.new('BORK')), Future.resolved(2)]
+          future = Future.reduce(futures, [], ordered: false) do |accumulator, value|
+            accumulator.push(value)
+          end
+          future.should be_failed
+        end
+
+        it 'fails if any of the block invocations fail' do
+          futures = [Future.resolved(0), Future.resolved(1), Future.resolved(2)]
+          future = Future.reduce(futures, [], ordered: false) do |accumulator, value|
+            if value == 1
+              raise 'BORK'
+            else
+              accumulator.push(value)
+            end
+          end
+          future.should be_failed
+        end
+
+        context 'when the list of futures is empty' do
+          it 'returns a future that resolves to the initial value' do
+            Future.reduce([], :foo, ordered: false).value.should == :foo
+          end
+
+          it 'returns a future that resolves to nil there is also no initial value' do
+            Future.reduce([], nil, ordered: false).value.should be_nil
+          end
+        end
       end
     end
 
@@ -582,22 +855,7 @@ module Ione
           f.should be_resolved
         end
 
-        it 'resolves when the source futures are resolved' do
-          sequence = []
-          p1 = Promise.new
-          p2 = Promise.new
-          p3 = Promise.new
-          f = Future.all(p1.future, p2.future, p3.future)
-          p1.future.on_value { sequence << 1 } 
-          p2.future.on_value { sequence << 2 } 
-          p3.future.on_value { sequence << 3 }
-          p2.fulfill
-          p1.fulfill
-          p3.fulfill
-          sequence.should == [2, 1, 3]
-        end
-
-        it 'returns an array of the values of the source futures, in order ' do
+        it 'returns an array of the values of the source futures, in order' do
           p1 = Promise.new
           p2 = Promise.new
           p3 = Promise.new
@@ -630,6 +888,31 @@ module Ione
           f = Future.resolved(1)
           Future.all(f).value.should == [1]
         end
+
+        it 'accepts a list of futures' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future)
+          f = Future.all(futures)
+          promises.each(&:fulfill)
+          f.value.should have(3).items
+        end
+
+        it 'accepts an enumerable of futures' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future).to_enum
+          f = Future.all(futures)
+          promises.each(&:fulfill)
+          f.value.should have(3).items
+        end
+
+        it 'accepts anything that implements #on_complete as futures' do
+          ff1, ff2, ff3 = double, double, double
+          ff1.stub(:on_complete) { |&listener| listener.call(nil, 1) }
+          ff2.stub(:on_complete) { |&listener| listener.call(nil, 2) }
+          ff3.stub(:on_complete) { |&listener| listener.call(nil, 3) }
+          future = Future.all(ff1, ff2, ff3)
+          future.value.should == [1, 2, 3]
+        end
       end
     end
 
@@ -704,6 +987,30 @@ module Ione
         it 'completes with the value of the given future, when only one is given' do
           Future.first(Future.resolved('foo')).value.should == 'foo'
         end
+
+        it 'accepts a list of futures' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future)
+          f = Future.first(futures)
+          promises.each(&:fulfill)
+          f.should be_resolved
+        end
+
+        it 'accepts an enumerable of futures' do
+          promises = [Promise.new, Promise.new, Promise.new]
+          futures = promises.map(&:future).to_enum
+          f = Future.first(futures)
+          promises.each(&:fulfill)
+          f.should be_resolved
+        end
+
+        it 'accepts anything that implements #on_complete as futures' do
+          ff1, ff2 = double, double
+          ff1.stub(:on_complete) { |&listener| listener.call(nil, 1) }
+          ff2.stub(:on_complete) { |&listener| listener.call(nil, 2) }
+          future = Future.first(ff1, ff2)
+          future.value.should == 1
+        end
       end
     end
 
@@ -732,9 +1039,10 @@ module Ione
         end
 
         it 'calls its complete callbacks immediately' do
-          f = nil
-          future.on_complete { |ff| f = ff }
-          f.should_not be_nil
+          f, v = nil, nil
+          future.on_complete { |ff, vv| f = ff; v = vv }
+          f.should equal(future)
+          v.should == 'hello world'
         end
 
         it 'does not block on #value' do
@@ -772,9 +1080,10 @@ module Ione
         end
 
         it 'calls its complete callbacks immediately' do
-          f = nil
-          future.on_complete { |ff| f = ff }
-          f.should_not be_nil
+          f, e = nil, nil
+          future.on_complete { |ff, _, ee| f = ff; e = ee }
+          f.should equal(future)
+          e.message.should == 'bork'
         end
 
         it 'does not block on #value' do

data/spec/ione/io/io_reactor_spec.rb

@@ -340,6 +340,20 @@ module Ione
           loop_body.tick
         end
 
+        it 'does nothing when IO.select raises Errno::EBADF' do
+          selector.should_receive(:select) do
+            raise Errno::EBADF
+          end
+          loop_body.tick
+        end
+
+        it 'does nothing when IO.select raises IOError' do
+          selector.should_receive(:select) do
+            raise IOError
+          end
+          loop_body.tick
+        end
+
         it 'calls #read on all readable sockets returned by the selector' do
           socket.stub(:connected?).and_return(true)
           socket.should_receive(:read)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.2.0.pre0
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-26 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies: []
 description: Reactive programming framework for Ruby, painless evented IO, futures
   and an efficient byte buffer
@@ -56,9 +56,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2