== v8.1.0
- add Redis#unix_socket,redis?, UNIXSocket#redis?
Predicates indicating if you have a redis or unix socket channel.

== v8.0.0
- Redis#write! does not time out.
A write to redis is not wrapped in Timeout.timeout() anymore
and cannot be timed out. The timeout argument is a no-op.

- Add IChannel::TimeoutError
Redis#get!, UNIXSocket#get!, UNIXSocket#write! raise
IChannel::TimeoutError instead of Timeout::Error.

- Remove use of timeout.rb from lib/
retire 'timeout.rb' from stdlib

== v7.1.0
- Redis#last_msg, UNIXSocket#last_msg return last read value
after a channel has been closed.
The old behavior was to return nil. I'm not sure why I decided to
do that but it's not useful.


== v7.0.0
- IChannel::UNIXSocket#get! raises Timeout::Error
When a read does not complete in time a Timeout::Error will be
raised (IChannel::Redis#get! already has this behavior).

- IChannel::Redis#get is a blocking read.
IChannel::Redis#get now blocks on read(by using the BRPOP command)

- Remove serialization support for IChannel::UNIXSocket.
The support is severely limited and the source of too many
edge cases to continue support. Even if serialization was
limited to a single machine it only works under specific
circumstances.

== v6.1.1.1
- Documentation improvements

== v6.1.1
- Add support for Rubinius, JRuby (1.9+ mode)

- Fix the optional dependency on Redis.
This was totally broken :/ We explicitly required Redis in lib/ichannel.rb.
Now we require "ichannel/redis" when IChannel.redis is invoked, which in turn
requires "redis", so the dependency is only exposed when invoking that method.

== v6.1.0
- Redis#last_msg, UNIXSocket#last_msg changes.
The last_msg method returns the last value read by #get when a channel is
not readable.

- change IChannel from being a class to a module.
There's no need to create an instance of IChannel anymore.

- Add IChannel::Redis.
Add Redis as a backend.

== v6.0.0
- IChannel::UNIXSocket can now be serialized by Marshal.
IChannel::UNIXSocket can be serialized by Marshal but there's a gotcha: it
only really works on the same machine between one or more Ruby processes.
The UNIXSocket#marshal_dump method is implemented to dump the FDs in an array,
so this feature won't fair well across different machines or time but I've
found this feature useful nonetheless.

- add IChannel.unix(…)
Returns an instance of IChannel::UNIXSocket.

- add IChannel::UNIXSocket
rename IChannel as IChannel::UNIXSocket in preparation for multiple
backends(UNIXSocket, Redis, …).

== v5.2.0
- add IChannel#last_msg.
Reads the last message written to the channel by reading until the channel
is empty. The last message is cached and reset to nil on call to #close.

== v5.1.1.1, v5.1.1.2, v5.1.1.3, v5.1.1.4, v5.1.1.5
- doc improvements
a set of releases that improved the README & api docs.

== v5.1.1
- Change socket type to use TCP.
The use of UDP could result in bugs because of its unordered nature.

== v5.1.0
- Remove restriction on size of message.
IChannel#get can read a message of any size(before hand it was limited to
1MB in size). Thanks to @quezacoatl.

- IChannel#readable? no longer blocks.
IChannel#readable? no longer blocks for 0.1 seconds on IO.select call.
Thanks to quezacoatl(https://github.com/quezacoatl) for the initial
implementation.

== v5.0.0
- Remove IChannel#empty?
I think the #readable? method is all you need, and is a much more
accurate description of what the method is asking. We cannot determine
if the channel is really empty, but we can ask if it is readable at the
time you ask.

== v4.1.0
- Add IChannel#readable?
A method that can tell you whether or not a read would block.
When it returns true, a read shouldn't block, on the other hand
if it were false it'd likely block by the time you call #get.
== v4.0.0
- Modify IChannel#empty?
It now returns true in case the underlying UNIXSocket being used as a
reader is closed.

== v3.1.0
- Add IChannel#empty?.
IChannel#empty? returns true when the channel is empty(nothing to read).

- Micro speed improvement on #write!, & #recv! operations.
By passing nil instead of creating two empty arrays for every read/write
operation we should see a very small improvement in their performance.

- Add ChangeLog.txt