cool.io 1.2.0-x86-mingw32

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - rbx

data/CHANGES.md

@@ -0,0 +1,176 @@
+1.2.0
+-----
+
+* Support Windows environment via cross compilation
+* Include iobuffer library
+* Update to libev 4.15
+
+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 "http://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,172 @@
+Cool.io
+=======
+
+### NOTE: cool.io is in maintenance mode only and is not being actively developed
+### Please check out [Celluloid::IO](http://github.com/celluloid/celluloid-io) instead!
+
+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 'rubygems'
+	require 'cool.io'
+
+Questions? Sign up for the mailing list by emailing: [cool.io@librelist.com](mailto:cool.io@librelist.com)
+
+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.
+
+* Cool.io::HttpClient - An HTTP/1.1 client with support for chunked encoding
+  and streaming response processing through asynchronous callbacks.
+
+Example Program
+---------------
+
+Cool.io provides a Sinatra-like DSL for authoring event-driven programs:
+
+    require 'rubygems'
+    require 'cool.io'
+
+    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.

data/Rakefile

@@ -0,0 +1,81 @@
+require 'bundler/gem_tasks'
+require 'rake/clean'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end
+
+task :default => %w(compile spec)
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cool.io #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/extensiontask'
+
+spec = eval(File.read("cool.io.gemspec"))
+
+def configure_cross_compilation(ext)
+  unless RUBY_PLATFORM =~ /mswin|mingw/
+    ext.cross_compile = true
+    ext.cross_platform = 'i386-mingw32'#['i386-mswin32-60', 'i386-mingw32']
+  end
+end
+
+Rake::ExtensionTask.new('iobuffer_ext', spec) do |ext|
+  ext.ext_dir = 'ext/iobuffer'
+  configure_cross_compilation(ext)
+end
+
+Rake::ExtensionTask.new('http11_client', spec) do |ext|
+  ext.ext_dir = 'ext/http11_client'
+  configure_cross_compilation(ext)
+end
+
+Rake::ExtensionTask.new('cool.io_ext', spec) do |ext|
+  ext.ext_dir = 'ext/cool.io'
+  configure_cross_compilation(ext)
+end
+
+# Rebuild parser Ragel
+task :http11_parser do
+  Dir.chdir "ext/http11_client" do
+    target = "http11_parser.c"
+    File.unlink target if File.exist? target
+    sh "ragel http11_parser.rl | rlgen-cd -G2 -o #{target}"
+    raise "Failed to build C source" unless File.exist? target
+  end
+end
+
+# adapted from http://flavoriffic.blogspot.com/2009/06/easily-valgrind-gdb-your-ruby-c.html
+def specs_command
+  require "find"
+  files = []
+  Find.find("spec") do |f|
+    files << f if File.basename(f) =~ /.*spec.*\.rb$/
+  end
+  cmdline = "#{RUBY} -I.:lib:ext:spec \
+               -e '%w[#{files.join(' ')}].each { |f| require f }'"
+end
+
+namespace :spec do
+  desc "run specs with valgrind"
+  task :valgrind => :compile do
+    system "valgrind --num-callers=15 \
+      --partial-loads-ok=yes --undef-value-errors=no \
+      --tool=memcheck --leak-check=yes --track-fds=yes \
+      --show-reachable=yes #{specs_command}"
+  end
+end
+
+CLEAN.include "**/*.rbc", "**/*.o", "**/*.so", "**/*.bundle"
+CLEAN.exclude "vendor/**/*.rbc", "vendor/**/*.o", "vendor/**/*.so", "vendor/**/*.bundle"