cool.io 1.4.1-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3c3fb24366477f5c9b84e6d2382c1130fb63ada
+  data.tar.gz: 11fc33983352f1d82da7d12106c39703747ea6c0
+SHA512:
+  metadata.gz: 3a75a1e77f44ff93546039f1d5995b9379a8c6979acc93529568f864798a3586ce60821133c2dc0dd0d98041e676ad00040b9e3d0752d60b2e0724cd22dfde45
+  data.tar.gz: a0a5440b6d2ff3523aadc46e7277ec7bcd9225c0375e77ea3832f24e25b617a1d9f8aa56a407fd0612d99b2e8399f4b0b01ec1e36d7d902df6a765e825c30d1b

data/.gitignore

@@ -0,0 +1,29 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+tmp
+
+## RUBINIUS
+*.rbc
+
+## PROJECT::SPECIFIC
+conftest.dSYM
+
+*.lock
+.ruby-version

data/.rspec

@@ -0,0 +1,3 @@
+--color 
+--format documentation 
+--backtrace

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
+  - rbx
+
+matrix:
+  allow_failures:
+    - rvm: rbx

data/CHANGES.md

@@ -0,0 +1,229 @@
+1.4.1
+-----
+
+* Use SleepEx instead of Sleep for better fix of process hung problem on windows environment
+* Use rake-compiler-dock for cross compilation
+
+1.4.0
+-----
+
+* Update libev to 4.20
+* Sleep in timeout instead of select on Windows
+
+1.3.1
+-----
+
+* Fix several bugs for JRuby support enhancement
+* Fix deadlock bug on Windows environment
+* Use RSpec3
+
+1.3.0
+-----
+
+* Block evaluation doesn't change self for keeping consistency with Ruby block
+* Remove EventMachine emulation module
+* Remove HttpClient
+* DSL syntax is no longer available by default. Need to require 'cool.io/dsl' in user code
+* Update libev to 4.19
+
+1.2.4
+-----
+
+* Fix a bug that #close for unconnected Socket doesn't detach all watchers (#33)
+* Remove 1.8 support code
+* Use standard library instead of own hosts list (#34)
+
+1.2.3
+-----
+
+* Fix CPU consuming issue on Windows.
+
+1.2.2
+-----
+
+* Add timeout option to Loop#run and Loop#run_once. Default by nil
+* Support Ruby 2.2.0
+
+1.2.1
+-----
+
+* Release the GIL when libev polls (#24)
+* Add Listener#listen method to change backlog size
+
+1.2.0
+-----
+
+* Support Windows environment via cross compilation
+* Include iobuffer library
+* Update to libev 4.15
+* Remove Ruby 1.8 support
+
+1.1.0
+-----
+
+* Switch from Jeweler to Bundler for the gem boilerplate
+* Fix firing of Coolio::HttpClient#on_request_complete (#15)
+* Fix failure to resolve Init_cool symbol on win32 mingw (#14)
+* Fix closing /etc/hosts in the DNS resolver (#12)
+* Refactor StatWatcher to pass pervious and current path state ala Node.js
+* spec:valgrind Rake task to run specs under valgrind
+* Use rake-compiler to build cool.io
+* Upgrade to libev 4.04
+
+1.0.0
+-----
+
+* Fancy new DSL
+
+0.9.0
+-----
+
+* Rename the project to cool.io
+* Bump the version all the way to 0.9! Hell yeah! 1.0 soon!
+* Rename the main module from Rev to Coolio, with deprecation warnings for Rev
+* Use Jeweler to manage the gem
+* Update to RSpec 2.0
+* Update to libev 4.01
+* Initial Rubinius support
+
+0.3.2
+-----
+
+* Perform a blocking system call if we're the only thread running (1.8 only)
+* Run in non-blocking mode if we're the only thread in the process (1.8 only)
+* Make Rev::Loop#run_nonblock signal-safe
+* Fix spurious firing of Rev::AsyncWatchers
+
+0.3.1
+-----
+
+* Configurable intervals for Rev::StatWatcher
+* Fix broken version number :(
+* Removed warning about spuriously readable sockets from Rev::Listener
+* Rev::Listener ignores ECONNABORTED from accept_nonblock
+* Document rationale for EAGAIN/ECONNABORTED handling in Rev::Listener
+
+0.3.0
+-----
+
+* Add Rev::StatWatcher to monitor filesystem changes
+* Add Rev::Listener#fileno for accessing the underlying file descriptor
+* Support for creating Rev::Listeners from existing TCPServers/UNIXServers
+* Upgrade to libev 3.8
+* Simplified code loading
+* Pull in iobuffer gem and change outstanding uses of Rev::Buffer to IO::Buffer
+* Fix memory leaks resulting from strange semantics of Ruby's xrealloc
+* Rev::UNIXServer: use path instead of the first argument
+* Rev::Server-based classes can build off ::*Server objects
+
+0.2.4
+-----
+
+* Ugh, botched my first release from the git repo.  Oh well.  Try, try again.
+
+0.2.3
+-----
+
+* Initial Windows support
+* Initial Ruby 1.8.7 and 1.9.1 support
+* Upgrade to libev 3.52
+* Add checks for sys/resource.h and don't allow getting/setting maxfds if it
+  isn't present
+
+0.2.2
+-----
+
+* Correct a pointer arithmetic error in the buffering code that could result
+  in data corruption.
+* Upgrade to libev 3.41
+* Relax HTTP/1.1 reponse parser to allow the "reason" portion of the response
+  header to be omitted
+
+0.2.1
+-----
+
+* Upgrade to libev 3.31
+* Rev::Loop#run_once and Rev::Loop#run_nonblock now return the number of events
+  received when they were running
+* Remove inheritence relationship between Rev::IO and Rev::IOWatcher
+* Loosen HTTP/1.1 response parser to accept a common malformation in HTTP/1.1
+  chunk headers
+* Add underscore prefix to instance variables to avoid conflicts in subclasses
+* Remove Rev::SSLServer until it can be made more useful
+
+0.2.0
+-----
+
+* Initial Ruby 1.8.6 support
+* Omit Rev::LIBEV_VERSION constant
+* Catch Errno::ECONNRESET when writing to sockets
+* SSL support via Rev::SSL, with a small C extension subclassing Ruby's
+  OpenSSL::SSL::SSLSocket allowing for non-blocking SSL handshakes
+* Initial Rev::Utils implementation with #ncpus and methods to query and
+  change the maximum number of file descriptors for the current process.
+* Initial Rev::AsyncWatcher implementation for cross-thread signaling
+* Handle unspecified Content-Length when encoding is identity in HttpClient
+* Fix bug in HttpClient processing zero Content-Length
+* Get rid of method_missing stuff in Rev::HttpClient
+* Have Rev::HttpClient close the connection on error
+* Allow Rev::TCPSocket#on_connect to be private when accepting connections
+  from a Rev::TCPServer
+
+0.1.4
+-----
+
+* Calibrate Rev::TimerWatchers against ev_time() and ev_now() when the watcher
+  is attached to the loop to ensure that the timeout interval is correct.
+* Add check to ensure that a Rev::Loop cannot be run from within a callback
+* Store Rev::Loop.default in a Thread-specific instance variable
+* Upgrade libev to 0.3.0
+* Rename BufferedIO to IO
+* Fixed bug in BufferedIO#write_output_buffer causing it to spin endlessly on
+  an empty buffer.
+* Added has_active_watchers? to Rev::Loop to check for active watchers
+
+0.1.3
+-----
+
+* Fixed bug in Rev::Buffer read_from and write_to: now rb_sys_fail on failed
+  reads/writes.
+* Change Rev::Buffer memory pools to purge on a periodic interval, rather than
+  whenever the GC marks the object.
+* Fix bug in tracking the active watcher count.  Factor shared watcher behavior
+  from rev_watcher.h to rev_watcher.c.
+
+0.1.2
+-----
+
+* Commit initial specs
+* Improve RDoc for the library
+* Eliminate "zero copy" writes as they bypass the event loop
+* Added Rev::Buffer C extension to provide high speed buffered writes
+* Implement Rev::TCPSocket#peeraddr to improve compatibility with Ruby sockets
+* Added Rev::Listener.close for clean shutdown of a listener
+* Rev::Loop.default used to call ev_loop_default() (in C).  However, this
+  registers signal handlers which conflict with Ruby's own.  Now the behavior
+  has been changed to return a thread-local singleton of Rev::Loop.
+* Creating a new Rev::TCPListener will disable reverse lookups in BasicSocket
+* Made backlog for Rev::TCPListener user-definable
+* Rev::TCPSocket now implements an on_resolve_failed callback for failed DNS
+  resolution.  By default it's aliased to on_connect_failed.
+* Changed event_callbacks to use instance_exec rather than passing the
+  watcher object as an argument.  Documented use of defining an event
+  callback as a block
+* Subsecond precision for Rev::TimerWatchers
+
+0.1.1
+-----
+
+* Added Rev::HttpClient, an asynchronous HTTP/1.1 client written on top of
+  the Rev::TCPSocket class
+* Imported HTTP response parser from the RFuzz project
+* Added exception handling for Errno::ECONNRESET and Errno::EAGAIN
+* Fixed bugs in buffered writer which resulted in exceptions if all data
+  couldn't be written with a nonblocking write.
+
+0.1.0
+-----
+
+* Initial public release

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in cool.io.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-10 Tony Arcieri
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+Cool.io
+=======
+
+### If you are interested in Celluloid based IO framework, please check out [Celluloid::IO](http://github.com/celluloid/celluloid-io)
+
+Cool.io is an event library for Ruby, built on the libev event library which 
+provides a cross-platform interface to high performance system calls .  This 
+includes the epoll system call for Linux, the kqueue system call for BSDs and 
+OS X, and the completion ports interface for Solaris.
+
+Cool.io also binds asynchronous wrappers to Ruby's core socket classes so you can
+use them in conjunction with Cool.io to build asynchronous event-driven 
+applications.
+
+You can include Cool.io in your programs with:
+
+	require 'cool.io'
+
+
+Anatomy
+-------
+
+Cool.io builds on two core classes which bind to the libev API:
+
+* Cool.io::Loop - This class represents an event loop which uses underlying high
+  performance system calls to wait for events.
+
+* Cool.io::Watcher - This is the base class for event observers.  Once you attach
+  an event observer to a loop and start running it, you will begin receiving
+  callbacks to particlar methods when events occur.
+
+Watchers
+--------
+
+There are presently four types of watchers:
+
+* Cool.io::IOWatcher - This class waits for an IO object to become readable,
+  writable, or both.
+
+* Cool.io::TimerWatcher - This class waits for a specified duration then fires
+  an event.  You can also configure it to fire an event at specified intervals.
+
+* Cool.io::StatWatcher - Monitors files or directories for changes
+
+* Cool.io::AsyncWatcher - Can be used to wake up a Cool.io::Loop running in a
+  different thread. This allows each thread to run a separate Cool.io::Loop and
+  for the different event loops to be able to signal each other.
+
+Using Watchers
+--------------
+
+Watchers have five important methods:
+
+* attach(loop) - This binds a watcher to the specified event loop.  If the
+  watcher is already bound to a loop it will be detached first, then attached
+  to the new one.
+
+* detach - This completely unbinds a watcher from an event loop.
+
+* disable - This stops the watcher from receiving events but does not unbind
+  it from the loop.  If you are trying to toggle a watcher on and off, it's
+  best to use this method (and enable) as it performs better than completely
+  removing the watcher from the event loop.
+
+* enable - This re-enables a watcher which has been disabled in the past.
+  The watcher must still be bound to an event loop.
+
+* evloop - This returns the Cool.io::Loop object which the watcher is currently
+  bound to.
+
+Asynchronous Wrappers
+---------------------
+
+Several classes which provide asynchronous event-driven wrappers for Ruby's
+core socket classes are also provided.  Among these are:
+
+* Cool.io::TCPSocket - A buffered wrapper to core Ruby's Socket class for use with
+  TCP sockets.  You can asynchronously create outgoing TCP connections using 
+  its Cool.io::TCPSocket.connect method.  Cool.io::TCPSocket provides write buffering
+  to ensure that writing never blocks, and has asynchronous callbacks for
+  several events, including when the connection is opened (or failed), when
+  data is received, when the write buffer has been written out completely,
+  and when the connection closes.
+
+* Cool.io::TCPServer - A wrapper for TCPServer which creates new instances of
+  Cool.io::TCPSocket (or any subclass you wish to provide) whenever an incoming
+  connection is received.
+
+Example Program
+---------------
+
+Cool.io provides a Sinatra-like DSL for authoring event-driven programs:
+
+    require 'cool.io'
+    require 'cool.io/dsl'
+
+    ADDR = '127.0.0.1'
+    PORT = 4321
+
+    cool.io.connection :echo_server_connection do
+      on_connect do
+        puts "#{remote_addr}:#{remote_port} connected"
+      end
+
+      on_close do
+        puts "#{remote_addr}:#{remote_port} disconnected"
+      end
+
+      on_read do |data|
+        write data
+      end
+    end
+
+    puts "Echo server listening on #{ADDR}:#{PORT}"
+    cool.io.server ADDR, PORT, :echo_server_connection
+    cool.io.run
+    
+This creates a new connection class called :echo_server_connection and defines
+a set of callbacks for when various events occur.
+
+We then create a new server on the given address and port. When this server
+receives new connections, it will create new instances of the given connection
+class for each connection.
+
+Finally, we kick everything off with cool.io.run. Calling cool.io.run will 
+block, listening for events on our server.
+    
+Using Cool.io subclasses directly
+---------------------------------
+
+Below is an example of how to write an echo server using a subclass instead of
+the DSL:
+
+	require 'cool.io'
+	HOST = 'localhost'
+	PORT = 4321
+
+	class EchoServerConnection < Cool.io::TCPSocket
+	  def on_connect
+	    puts "#{remote_addr}:#{remote_port} connected"
+	  end
+
+	  def on_close
+	    puts "#{remote_addr}:#{remote_port} disconnected"
+	  end
+
+	  def on_read(data)
+	    write data
+	  end
+	end
+
+	server = Cool.io::TCPServer.new(HOST, PORT, EchoServerConnection)
+	server.attach(Cool.io::Loop.default)
+
+	puts "Echo server listening on #{HOST}:#{PORT}"
+	Cool.io::Loop.default.run
+
+Here a new observer type (EchoServerConnection) is made by subclassing an
+existing one and adding new implementations to existing event handlers.
+
+A new event loop is created, and a new Cool.io::TCPServer (whose base class is
+Cool.io::Watcher) is created and attached to the event loop.
+
+Once this is done, the event loop is started with event_loop.run.  This method
+will block until there are no active watchers for the loop or the loop is
+stopped explicitly with event_loop.stop.