v1.2.0.pre1

Further improvements to the futures API and future interoperability.

v1.2.0.pre0

This release brings many improvements to the futures implementation.

Please note that this is still only a prerelease. The new features are stable, but the API can change before the final release.

• Better IO error handling under some rare conditions
• Some minor performance improvements in Future
• Future#then – a combination of #map and #flat_map that detects which semantics to use depending on what the block returns.
• Future.reduce – reduces the values of a list of futures to a future that resolves to this value, very useful in scatter-gather situations where you only had Future.all to work with before.
• Future.traverse – combines Array#map and Future.all, a pattern that is repeated again and again in scatter-gather situations.
• Ione's futures can now interoperate with other futures. As long as an object implements #on_complete with the same semantics as Ione::Future#on_complete most of the combinators and composition operators will work. You can also create a class that implements #on_complete and then mix in Ione::FutureCombinators to get #map, #flat_map and friends.

v1.1.3

Mostly an optimization release:

• Optimizations in Future: no locks are taken once a future is completed (resolved/failed).
• Change from Mutex#synchronize to #lock/#unlock in most places. This might sound like a premature optimization, but these locks are in very hot paths and avoiding the yield in #synchronize decreases the overhead of around 40%.
• Added IoReactor#cancel_timer to make it possible to cancel scheduled timers when needed.

v1.1.3.pre0

This prerelsease is for testing only. It's silly to release prereleases of patch releases, but I want to make absolutely sure that the optimizations in this release are correct.

• Optimizations in Future: no locks are taken once a future is completed (resolved/failed).
• Change from Mutex#synchronize to #lock/#unlock in most places. This might sound like a premature optimization, but these locks are in very hot paths and avoiding the yield in #synchronize decreases the overhead of around 40%.

v1.1.2

Bugfix release for a bug introduced in v1.1.1. Now Future.all with a single future works as before, but still creates fewer objects than before.

v1.1.1

This version has been yanked, it contained a silly bug that is fixed in v1.1.2

Optimization release, Future.all, .first and .resolved create fewer objects.

Most significantly Future.resolved and Future.resolved(nil) return a constant future pre-resolved to nil. In addition to existing optimizations of the futures returned by Future.resolved this variant is now very cheap. Future.resolved.value is now only two method calls and no object allocations.

v1.1.0

v1.0 was a clean extraction of Ione from cql-rb, but this release is the first step to making Ione a general purpose toolkit for building reactive applications.

• Ione can now be used to start network servers.
• You can register for notifications on when the connections buffers are drained.

v1.1.0.pre0

First prerelease of v1.1, which will support network servers in addition to clients.

This release includes:

• Support for starting servers with IoReactor#bind
• A simple server example
• BaseConnection#drain, a better version of #close that returns a future and waits for the connection's buffer to be empty before actually closing the socket.

v1.0.0

This is a fork of the reactive core of cql-rb. It's the futures, evented IO and byte buffer features from cql-rb extracted as a library.

v1.0.0.pre2

• Added examples
• Fixed the testing automation
• Added ByteBuffer#index
• Made ByteBuffer#read raise RangeError on negative lengths.
• Made a small optimization that avoids an extra string allocation when creating ByteBuffers