History.txt

== 2.0.5
  * Fix issue #123. Bundled gems were a bit outdated so upgraded to latest
    rspec gem.

  * Fix issue #124. Newer releases of libzmq are not exporting all symbols
    to the global namespace so some lazy loading performed by FFI was
	failing. Now force all symbols into global namespace.

  * Fix "::Fixnum has been deprecated" warnings from MRI 2.4.x+.

  * Force ffi-rzmq-core 1.0.6 or later as dependency.

== 2.0.4
  * Screwed up the release managment. Had wrong version in version.rb. Fixed.
  
== 2.0.3
  * Updated specs to use RSpec 3.x syntax. Never again... if they change it
    then I'm dumping rspec.
    
  * Now loading version.rb during startup so that ZMQ::VERSION returns a string.
  
  * Modified README to point most people to the Ruby gem that wraps the CZMQ
    library. It's a much higher-level library that makes writing zeromq apps
    very easy. This gem is for writing low-level code which most people don't
    want or need to do. This gem is going into maintenance mode only.
  

== 2.0.2 

  * Updated README to make it clearer which versions of libzmq are supported.
  
  * Updated README to use a newer example.

== 2.0.1 / 20140122
  * Fix setsockopt with string parameters for options that have very strict
    requirements (like CURVE_SECRETKEY) (37aed3c)

  * Provide a wrapper for zmq_curve_keypair for ZeroMQ4

== 2.0.0 / 20140108
	* Split out all of the FFI code to its own gem so other projects can use
		it without the effort of duplication.
		
	*	Support libzmq 4 API and its new security API . Thanks to Devin 
	  Christensen (devin-c) and Jason Roelofs (jasonroelofs) for related
	  patches.
	
	* Minor documentation fixes. Thanks to Michael Zaccari (mzaccari) for
	  the fix.
	
	* Improved the readability of any FFI code (now moved to ffi-rzmq-core
	  project). Thanks to Stephen von Takach (stakach) for the patch.
	
	* Updated AUTHORS.txt
	


== 1.0.3 / 20131003
	* Fixes for issues #96 and #97. Thanks to Paul Chechetin (paulche) for 
	  the issues and patches.

== 1.0.2 / 20130929
	* Fix for issue #94. Now includes local_path when searching for a libzmq
	  to load.
	
	* Fix for issue #92. Context and Socket finalizers now track the process'
	  PID to handle a special case when forking a process. Thanks to
	  thinkerbot for the issue and a fix. (Spec is disabled on JRuby since
	  it does not support fork().)
		
	* Fix a few RSpec deprecation warnings related to expectations on specific
	  Exception types.
	
== 1.0.1 / 20130318
	* Fix for issue #77 was not included in 1.0.0 release by mistake.
	
	* Add MIR 2.0.0 to travis runs.
	
	* Add support for LAST_ENDPOINT and MULTICAST_HOPS to Socket#getsockopt.

== 1.0.0 / 20130109
	*	Fix for issue #74 (send_multiple improperly handled single part messages).
	
	* Fix for issue #77 (unbind and disconnect).
	
	*	Fix for issue #75 (socket monitor events).
	
	*	The API is stable. Releasing 1.0.

== 0.9.7 / 20121221
  * BROKE THE API.
    ZMQ::Poller#register and ZMQ::Poller#deregister don't take fd argument
    anymore. ZMQ::Poller#readables and ZMQ::Poller#writables return pollables
    instead of just fd when pollable is other than ZMQ socket.
    ZMQ::Poller#register now returns nil instead of false when no pollable
    or events to register to are given, which is consistent with rest of api.
		Thanks to Pawel Pacana for this code contribution.

  * Added support in ZMQ::Poller for pollables responding to fileno and socket.
    Standard Ruby Sockets and IOs can be now registered in poller to listen for
    events. Thanks to Pawel Pacana for this code contribution.

  * Fixed a bug in ZMQ::Poller#deregister where it would raise exception
    when trying to deregister already closed ZMQ socket. Issue 59.

  * Improved specs to use random inproc socket address to avoid race conditions 
    between tests under same context.

  * Added continous integration for all supported platforms on Travis-CI.
		Thanks to Pawel Pacana for this code contribution.

	*	Signed up for codeclimate.com and made some code changes to get a better
		"grade" from it.
		
	*	Modified the library to *always* load the 'ffi' library upon startup. It 
		used to be conditional for Rubinius. Thanks to brixen for the change.
		
	*	There was a little bit of churn on the zmq "monitor" api. Thanks to
		Nilson Santos F. Jr. for some code to conditionally attach to the
		appropriate api depending on library version.
		
	

== 0.9.6 / 20120808
  * Never released 0.9.5 as a gem. It was available via github only.
  
  * Improved error message when DLL loading fails on Windows.
  
  * Added support for 0mq 2.2. Support for 2.1 might be getting shakey...
    patches to make it fully support 2.1 (assuming it's even broken at
    all) are welcome.
  
  * Added support for 0mq 3.2 (no support for 3.0 or 3.1). Not all methods
    are exposed yet. For example, setting values on the context after it
    has been created is not supported; instead, pass the correct keys
    (:io_threads and :max_sockets) to the call to Context.create or
    Context#new.
    
  * Reduced spec running time from 30+ seconds to under 1 by eliminating
    most uses of "sleep." It now polls sockets to wait for message
    delivery. It also uses a technique of binding an inproc transport and
    busy-looping on the connect side until it succeeds. These techniques
    both allowed me to eliminate most uses of sleep.
    
  * Some changes to support usage on Win7x64 with a 64-bit libzmq DLL.

== 0.9.5 / 20120119
  * BROKE THE API.
    In 0mq 2.x, there were two functions zmq_send() and zmq_recv().
    As of 3.x, those functions were renamed zmq_sendmsg() and
    zmq_recvmsg(). As everyone starts moving to 0mq 3.x, it doesn't
    make sense to make the code break with 2.x. So, I'm breaking this
    binding so that it always uses sendmsg/recvmsg and eliminates the
    original send/recv methods.
    Sorry!
    This is likely to be the last non-backward-compatible API breakage.
    Release 1.0 is around the corner and the API will be stable (I follow
    semantic versioning).
    
  * Introduced ZMQ::NonBlocking. This flag returns the correct value to set
    a socket in non-blocking mode when sending/receiving. This hides the
    differences between 0mq 2.x and 3.x since the constant names have
    changed.

== 0.9.4 / 20120102
  * Fixed bug in Poller#delete. Added specs to catch a regression.
    In short, a socket that was deleted from the Poller set wasn't
    always actually *removed* from the array. This led to a closed
    socket being part of the pollset which would return errno 38.
    This took about 4 days to find. <sigh>
    

== 0.9.3 / 20111214
  * Performance optimizations for #getsockopt.
  
  * Fixed Message#copy and Message#move. They didn't work before.
  
  * Cache LibZM::Msg.size in the ZMQ::Message class so that 
    initialization can skip recalculating what is effectively a
    constant value. This speeds up ZMQ::Message instantiation by
    5 to 10%. Wow.
    
  * Modified calls to #super to use explicit arguments (e.g. #super())
    because otherwise the Ruby runtime has to (at runtime) dig out
    the arguments that are expected to be passed up the chain. By
    explicitly listing the args and using parentheses, the runtime
    can avoid that work and dispatch directly. This effects all
    Ruby runtimes, but it was through the work of Evan Phoenix that
    I figured this out. Results in a 2-5% speedup on method dispatch.
    
  

== 0.9.2 / 20111115
  * Removed all references to the version4 API.
  
  * Dropped support for 3.0.x and added support for 3.1.x. The 0mq
    community has pretty much voted to abandon the path taken in 3.0
    so the 3.1 branch is the API that will be supported.
    
  * Fixed a bug in Poller#delete where it would erroneously return
    false even when it successfully deleted a socket. Issue 46.
    
  * All specs pass for 2.1.x API.
  
  * 3 specs fail when run with 3.1 API; these are due to bugs in the
    0mq library and are *not* ffi-rzmq bugs.
    
  * Rescue LoadErrors when loading libzmq. Print a warning about
    adding libzmq.dll to the Windows PATH for that platform. Print
    the search paths where the gem looks for libzmq.

== 0.9.1 / 20111027
  * Moved LibC and LibZMQ into the ZMQ module namespace. Necessary to
    avoid namespace collisions with other libraries that also use
    the constants LibC and/or LibZMQ.
    
  * Fixed a bug where file descriptors registered on Poll were never 
    returned as readable or writable.
    
  * Added Socket#recv_multipart. This returns the message body and
    return address envelope as separate arrays. Only to be used with
    XREQ/XREP/DEALER/ROUTER sockets.

== 0.9.0 / 20110930
  * Changed the behavior of every method that used to produce exceptions.
    The methods now behave more like the C API functions. They return
    result codes instead of raising exceptions. Further, the "receive"
    methods on Socket now all take an empty string as a buffer to read
    the message into.
    This is a BREAKING CHANGE and is NOT backward compatible with earlier
    releases. I apologize for the inconvenience, but this API will be
    much easier to test/spec and maintain. It will also allow for the
    production of more logical code.
    
  * Major refactoring of Socket internals so that a single gem can
    support libzmq 2.x, 3.x and 4.x APIs without any user intervention.
    The correct libzmq version is detected at runtime and used to
    configure the Ruby classes to conform to the proper API.
    
  * Added Socket#recvmsgs as a convenience method for receiving a
    multipart message into an array of Messages.
    
  * Added support for new 0mq API introduced in the 3.0 branch. 
    API mostly changed for sending and receiving messages with new
    POSIX-compliant send() and recv() functions. The original
    functions were renamed sendmsg() and recvmsg().
    Additionally, most getsockopt() and setsockopt() calls now use
    an int (4 bytes) instead of a mish-mash of 32-bit and 64-bit
    values.
    For a full list of differences, visit the 0mq wiki page at:
    http://www.zeromq.org/docs:3-0-upgrade
    
  * Created a new ext/ directory so that users can copy the libzmq*
    library files directly into the gem for easier distribution. This
    path is checked *before* the usual system paths.
    
  * Rewrote all examples to use the revised API.

== 0.8.2 / 20110728
  * Fixed major bug with Socket#setsockopt when writing 8-byte longs.

  * Clarified a bit of logic for non-blocking sends.

  * Improved readability of exceptions.

== 0.8.1 / 20110504
  * Fixed bug where Socket#setsockopt was using a size from the current
    runtime to determine how many bytes to use for HWM, et al. This was
    incorrect. All of those socket options require 8 bytes. Discovered
    this while getting the code running under mingw on Windows using a
    32-bit Ruby runtime.

== 0.8.0 / 20110307
  * API change!
    Socket#send_message no longer automatically calls
    Message#close on behalf of the user. The user is completely
    responsible for the lifecycle management of all buffers associated
    with the ZMQ::Message objects.
    This is a breaking change.
    If you want the old behavior (auto-close messages on send) then
    use the new Socket#send_and_close method which does as its name
    implies.
  * Fixed bug with type :size_t on Windows (thank you to arvicco)

== 0.7.3 / 20110304
  * Fixed a bug where we had a small memory leak. When closing a socket
    I forgot to release a small amount of native memory used as a cache
    for doing #getsockopt calls.
  * Util.minimum_api? didn't work. Fixed.
  * Added ROUTER/DEALER constants to reflect new naming for XREQ/XREP.
    XREQ and XREP remain aliased for backward compatibility.

== 0.7.2 / 20110224
  * Several minor refactorings to make the code intent clearer and to allow
    for better testing. In particular, the error condition checking for
    a non-blocking send/recv is much clearer.

== 0.7.1 / 20110130
  * Fixed 1.9.1 Binary Encoding bug when UTF8 set as default (Thanks schmurfy)
  * Improved rubinius compat for specs
  * Improved spec compatibility on linux

== 0.7.0 / 20101222
  * Improved performance of calls to Socket#getsockopt. There are usually
    a lot of calls passing RCVMORE, so we now cache those buffers instead
    of reallocating them every time.

  * Updated the docs on Poller#poll to warn about a possible busy-loop
    condition.

  * Fixed some more specs to conform with the 0mq 2.1 requirement that
    all sockets must be closed explicitly otherwise the program may
    hang on exit.

== 0.6.1 / 20101127
  * API Change!
    Moved the #version method from the Util module and made it a class
    method instead. Invoke as ZMQ::Util.version. Used for conditionally
    enabling certain features based upon the 0mq version that is loaded.

  * Preliminary support for the Windows platform. Patches supplied
    by arvicco.

  * Added support for FD and EVENTS socket options. These were added
    in 0mq 2.1.0. Patches + specs supplied by andrewvc.

  * Added support for LINGER, RECONNECT_IVL, BACKLOG  and
    RECOVERY_IVL_MSEC socket options.

  * Conditionally re-enable the socket finalizer when we are running
    with 0mq 2.1.0 or later.

  * Drop support for MRI 1.8.x since the 'ffi' gem has dropped it as a
    supported Ruby runtime with its 1.0 release. No action is taken to
    prevent running with MRI 1.8.x but it won't be supported.

  * Misc. spec fixes. Need more specs!

== 0.6.0 / 20100911
  * API Change! Modified ZMQ::Message by removing automatic memory
    management. While doing some performance tests I saw that
    defining/undefining the finalizer added 15-30% processing
    overhead on the latency test. So, I split this functionality
    out to a subclass called ZMQ::ManagedMemory. Any existing code
    that relies on the default Message class to clean up after itself
    will now have a memory leak. Explicitly call #close on these
    received messages *unless* they are sent out again. The #send
    method automatically closes call on your behalf.

  * Rubinius/rbx compatibility! Requires an rbx code pull from git
    from 20100911 or later to get the necessary code fixes.

  * Modify Message to use the @pointer directly rather than indirectly
    via the @struct object. Provides better compatibility for rbx
    since rbx does not yet support the FFI pointer protocol for structs
    like the FFI gem.

  * Modify Message to pass libC's free function for disposing of message
    data buffers rather than trying to callback into ruby code to
    do the same thing. External thread callbacks into ruby code will
    never be supported in rbx; this also improves compatibility and
    performance with MRI and JRuby. (In particular, MRI enqueues these
    kinds of callbacks and spawns a *new* thread to execute each one.
    Avoiding the ruby callback entirely eliminates this extra work
    for MRI.)

  * Modify FFI wrapper to capture the libC dynamic library to fetch
    a pointer to the free function.

  * Modify FFI wrapper to remove the FFI::Function callback used
    by Message. It's no longer necessary since we now use free
    directly.

== 0.5.1 / 20100830
  * Works with 0mq 2.0.8 release.

  * Removed the socket finalizer. The current 0mq framework cannot
    handle the case where zmq_close is called on a socket that was
    created from another thread. Therefore, the garbage collection
    thread causes the framework to break. Version 2.1 (or later)
    should fix this 0mq limitation.

  * Misc fixes. See commits.

== 0.5.0 / 20100606
  * Updated the bindings to conform to the 0mq 2.0.7 release.
  Several parts of the API changed.

  * Updated all examples to use the new Context api.

  * Added Socket#getsockopt.

  * Added a Socket#identity and Socket#identity= method pair to
  allow for easy get/put on socket identities. Useful for async
  request/reply using XREQ/XREP sockets.

  * Added more specs (slowly but surely).

  * Support multi-part messages (new as of 2.0.7). I am unsure how
  to best support multi-part messages so the Message (and related)
  API may change in the future. Added Socket#more_parts?.

  * Lots of fixes. Many classes use finalizers to deallocate native
  memory when they go out of scope; be sure to use JRuby 1.5.1 or
  later to get important finalizer fixes.

== 0.4.1 / 20100511
  * I was misusing all of the FFI memory allocator classes. I now
  wrap libc and use malloc/free directly for creating buffers
  used by libzmq.

== 0.4.0 / 20100510
  * Changed the Socket#recv method signature to take an optional
  message object as its first argument. This allows the library
  user to allocate and pass in their own message object for the
  purposes of zero-copy. Original behavior was for the library to
  *always* allocate a new message object to receive a message into.
  Hopefully this is the last change required.

  * Modified the Socket constructor to take an optional hash as its
  final argument. It honors two keys; :receiver_klass and
  :sender_klass. Passing in a new constant for either (or both) keys
  will override the class used by Socket for allocating new
  Message objects.

== 0.3.1 / 20100509
  * Modified ZMQ::Message so we have both an UnmanagedMessage where
  memory management is manual via the #close method, and Message where
  memory management is automated via a finalizer method run during
  garbage collection.

  * Updated ZMQ::Message docs to make it clearer how to use a subclass
  and FFI::Struct to lazily access the message buffer. This gets us as
  close to zero-copy as possible for performance.

  * Fixed a memory leak in Message where the FFI::Struct backing the
  C struct was not being freed.

  * Tested the FFI code against MRI 1.8.x and 1.9.x. It works!

  * Patched a potential problem in LibZMQ::MessageDeallocator. It was
  crashing under MRI because it complained that FFI::Pointer did not
  have a free method. It now checks for :free before calling it.
  Need to investigate this further because it never happened under
  JRuby.

  * Modified the Socket constructor slightly to allow for using
  unmanaged or managed messages.

  * Changed the /examples to print a throughput (msgs/s) number upon
  completion.

== 0.3.0 / 20100507
* ZMQ::Socket#send and ZMQ::Socket#recv semantics changed
  * The official 0mq ruby bindings utilize strings for #send and #recv.
    However, to do so requires lots of copying to and from buffers which
    greatly impacts performance. These methods now return a ZMQ::Message
    object which can be subclassed to do lazy evaluation of the buffer.

  * Added ZMQ::Socket#send_string and ZMQ::Socket#recv_string. They
    automatically convert the messages to strings just like the official
    0mq ruby bindings.

  * Fixed bug in ZMQ::Util#error_string

  * Split the ZMQ::Message class into two classes. The base class called
    UnmanagedMessage requires manual memory management. The Message
    class (used by default by Socket) has a finalizer defined to
    automatically release memory when the message object gets garbage
    collected.


== 0.2.0 / 20100505

* 1 major enhancement
  * Birthday!