em-net-http-npn47 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gemspec
+gem 'rake'

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 James Fairbairn
+
+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,54 @@
+[![Build Status](https://secure.travis-ci.org/jfairbairn/em-net-http.png)](http://travis-ci.org/jfairbairn/em-net-http])
+
+Most Ruby web API libraries use <tt>Net::HTTP</tt> (because it's ubiquitous),
+but I want to use them in my non-blocking EventMachine-based applications, and
+I don't want Net::HTTP to block. I therefore wrote this.
+
+Using the magic of Ruby 1.9's Fibers, we monkeypatch <tt>Net::HTTP</tt> to use
+the faster, nonblocking <tt>[em-http-request][1]</tt> under the hood. Obviously this
+will only work from inside the [EventMachine][2] event loop, and from within a spawned
+fiber:
+
+    require 'em-net-http'
+
+    EM.run do
+      Fiber.new do
+        Net::HTTP.start('encrypted.google.com', :use_ssl=>true) do |http|
+          res = http.get('/search?q=james')
+          puts res.body
+        end
+        EM.stop_event_loop
+      end.resume
+    end
+    
+The above will run without blocking your carefully-tuned nonblocking webapp.
+
+There are a few tests (taking advantage of the very useful [Mimic][6] gem)
+that assert that responses are identical to those created by <tt>Net::HTTP</tt>.
+These are by no means exhaustive; if you're using <tt>Net::HTTP</tt> in some other way
+and the <tt>em-net-http</tt>'s behaviour is not what you expect, do send me a failing test
+case.
+
+Currently tested with Ruby (MRI) 1.9.1 and 1.9.2.
+
+### Caveat
+
+The <tt>Net::HTTP</tt> API is a many-headed hydra -- I haven't patched much of it.
+Your mileage may therefore vary. Please feed me patches, pull requests and bug reports!
+
+### Thanks
+
+ * [Luke Redpath][7], for [Mimic][6].
+ * [Mathieu Ravaux][8], for adding streaming and buffering support.
+ * [Jon Swope][9] and [Ary Borenszweig][10], for bug fixes.
+
+[1]: http://github.com/igrigorik/em-http-request
+[2]: http://rubyeventmachine.com/
+[3]: http://rightaws.rubyforge.org/
+[4]: http://github.com/mwunsch/weary
+[5]: http://github.com/mwunsch/tumblr
+[6]: http://github.com/lukeredpath/mimic
+[7]: http://lukeredpath.co.uk/
+[8]: http://mathieuravaux.com/
+[9]: http://www.jonswope.com/
+[10]: http://weblogs.manas.com.ar/ary

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "em-net-http #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.4

data/em-net-http.gemspec

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{em-net-http-npn47}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["James Fairbairn","Neeraj PN"]
+  s.date = %q{2012-11-05}
+  s.description = %q{Monkeypatching Net::HTTP to use em-http-request under the hood.}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "em-net-http.gemspec",
+    "lib/em-net-http.rb",
+    "lib/em-net-http/weary.rb",
+    "lib/test.rb",
+    "lib/test_weary.rb",
+    "spec/em-net-http_spec.rb",
+    "spec/image.jpg",
+    "spec/spec.opts",
+    "spec/spec_helper.rb"
+  ]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.8.10}
+  s.summary = %q{Non-blocking replacement for Net::HTTP, for use in EventMachine}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.10"])
+      s.add_runtime_dependency(%q<addressable>, [">= 0"])
+      s.add_runtime_dependency(%q<em-http-request>, [">= 0.2.10"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_development_dependency(%q<mimic>, [">= 0.3.0"])
+      s.add_development_dependency(%q<weary>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+      s.add_dependency(%q<addressable>, [">= 0"])
+      s.add_dependency(%q<em-http-request>, [">= 0.2.10"])
+      s.add_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_dependency(%q<mimic>, [">= 0.3.0"])
+      s.add_dependency(%q<weary>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+    s.add_dependency(%q<addressable>, [">= 0"])
+    s.add_dependency(%q<em-http-request>, [">= 0.2.10"])
+    s.add_dependency(%q<rspec>, ["~> 2.5"])
+    s.add_dependency(%q<mimic>, [">= 0.3.0"])
+    s.add_dependency(%q<weary>, [">= 0"])
+  end
+end
+

data/lib/em-net-http/weary.rb

@@ -0,0 +1,24 @@
+module Weary
+  class Response
+    # Weary doesn't like Content-Type headers with extra bits on the end, like '; encoding=utf-8'.
+    def content_type ; @content_type.split(';').first ; end
+    
+    def value ; self ; end
+  end
+ 
+  # Weary runs multi-threaded by default. The thread is spawned in perform!(). Let's not do that.
+  class Request
+    def perform!(&block)
+      @on_complete = block if block_given?
+      before_send.call(self) if before_send
+      req = http.request(request)
+      response = Response.new(req, self)
+      if response.redirected? && follows?
+        response.follow_redirect
+      else
+        on_complete.call(response) if on_complete
+        response
+      end
+    end
+  end
+end

data/lib/em-net-http.rb

@@ -0,0 +1,200 @@
+require 'eventmachine'
+require 'addressable/uri'
+require 'em-http-request'
+require 'net/http'
+require 'fiber'
+
+module EventMachine
+  module NetHTTP
+    class Response
+      attr_reader :code, :body, :header, :message, :http_version
+      alias_method :msg, :message
+
+      def initialize(response_header)
+        @code = response_header.http_status.to_s
+        @message = response_header.http_reason
+        @http_version = response_header.http_version
+        @header = response_header
+      end
+
+      def set_body body
+        @already_buffered = true
+        @body = body
+      end
+
+      def content_type
+        self['content-type']
+      end
+
+      def [](k)
+        @header[key(k)]
+      end
+
+      def key?(k)
+        @header.key? key(k)
+      end
+
+      def read_body(dest=nil,&block)
+        @body
+      end
+
+      def to_hash
+        h={}
+        @header.each do |k, v|
+          h[fromkey(k)] = v
+        end
+        h
+      end
+
+      private
+      def key(k)
+        k.upcase.tr('-','_')
+      end
+
+      def fromkey(k)
+        k.tr('_', '-').split('-').map{|i|i.capitalize}.join('-')
+      end
+
+      include Enumerable
+      def each(&blk)
+        @header.each(&blk)
+      end
+
+    end
+  end
+end
+
+
+module Net
+  class HTTPResponse
+    class << self
+      public :response_class
+    end
+
+    alias_method :orig_net_http_read_body, :read_body
+
+    def read_body(dest=nil, &block)
+      return @body if @already_buffered
+      return orig_net_http_read_body(dest, &block) unless ::EM.reactor_running?
+      if block_given?
+        f = Fiber.current
+        @httpreq.callback { |res| f.resume }
+        @httpreq.stream &block
+        Fiber.yield
+      else
+        unless @body || @already_buffered
+          if self.class.body_permitted?
+            f = Fiber.current
+            io = StringIO.new '', 'wb'
+            io.set_encoding 'ASCII-8BIT'
+            @httpreq.callback { |res| f.resume io.string }
+            @httpreq.errback { |err| f.resume err }
+            @httpreq.stream { |chunk| io.write chunk }
+            @body = Fiber.yield
+          end
+          @already_buffered = true
+        end
+        @body
+      end
+    end
+  end
+
+  class HTTP
+    alias_method :orig_net_http_request, :request
+
+    alias_method :orig_net_http_do_start, :do_start
+
+    def do_start
+
+      return orig_net_http_do_start unless ::EM.reactor_running?
+
+      @started = true
+    end
+
+    def request(req, body = nil, &block)
+
+      return orig_net_http_request(req, body, &block) unless ::EM.reactor_running?
+
+      uri = Addressable::URI.parse("#{use_ssl? ? 'https://' : 'http://'}#{addr_port}#{req.path}")
+
+      body = body || req.body
+      opts = body.nil? ? {} : {:body => body}
+      if use_ssl?
+        sslopts = opts[:ssl] = {}
+        sslopts[:verify_peer] = verify_mode == OpenSSL::SSL::VERIFY_PEER
+        sslopts[:private_key_file] = key if key
+        sslopts[:cert_chain_file] = ca_file if ca_file
+      end
+      opts[:timeout] = self.read_timeout
+
+      headers = opts[:head] = {}
+      req.each do |k, v|
+        headers[k] = v
+      end
+
+      headers['content-type'] ||= "application/x-www-form-urlencoded"
+
+      t0 = Time.now
+      httpreq = EM::HttpRequest.new(uri).send(req.class::METHOD.downcase.to_sym, opts)
+
+      f=Fiber.current
+
+      convert_em_http_response = lambda do |res|
+        emres = EM::NetHTTP::Response.new(res.response_header)
+        emres.set_body res.response
+        nhresclass = Net::HTTPResponse.response_class(emres.code)
+        nhres = nhresclass.new(emres.http_version, emres.code, emres.message)
+        emres.to_hash.each do |k, v|
+          nhres.add_field(k, v)
+        end
+        nhres.body = emres.body if req.response_body_permitted? && nhresclass.body_permitted?
+        nhres.instance_variable_set '@read', true
+        f.resume nhres
+      end
+
+
+      if block_given?
+        httpreq.headers { |headers|
+
+          emres = EM::NetHTTP::Response.new(headers)
+          nhresclass = Net::HTTPResponse.response_class(emres.code)
+          nhres = nhresclass.new(emres.http_version, emres.code, emres.message)
+          emres.to_hash.each do |k, v|
+            nhres.add_field(k, v)
+          end
+          f.resume nhres
+        }
+        httpreq.errback {|err|f.resume(:error)}
+
+        nhres = yield_with_error_check(t0)
+        nhres.instance_variable_set :@httpreq, httpreq
+
+        yield nhres
+        nhres
+      else
+        httpreq.callback &convert_em_http_response
+        httpreq.errback {|err|f.resume(:error)}
+
+        yield_with_error_check(t0)
+      end
+    end
+
+    private
+
+    def yield_with_error_check(t0)
+      res = Fiber.yield
+
+      if res == :error
+        raise 'EM::HttpRequest error - request timed out' if Time.now - self.read_timeout > t0
+        raise 'EM::HttpRequest error - unknown error'
+      end
+
+      res
+    end
+
+  end
+end
+
+# Other bits and bobs.
+
+

data/lib/test.rb

@@ -0,0 +1,12 @@
+$: << '.'
+require File.dirname(__FILE__) + '/em-net-http'
+
+EM.run do
+  Fiber.new do
+    Net::HTTP.start('encrypted.google.com', :use_ssl=>true, :verify_mode => OpenSSL::SSL::VERIFY_NONE) do |http|
+      res = http.get('/search?q=james')
+      puts res.body
+    end
+    EM.stop_event_loop
+  end.resume
+end

data/lib/test_weary.rb

@@ -0,0 +1,22 @@
+$: << File.dirname(__FILE__)
+require 'em-net-http'
+require 'weary'
+require 'em-net-http/weary'
+
+EM.run do
+  Fiber.new do
+    class TwitterUser < Weary::Base
+        domain "http://twitter.com/users/"
+
+        get "show" do |resource|
+            resource.with = [:id, :user_id, :screen_name]
+        end
+    end
+
+    user = TwitterUser.new
+    me = user.show(:id => "jfairbairn").perform
+    puts me['status']['text']
+    
+    EM.stop_event_loop
+  end.resume
+end

data/spec/em-net-http_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "em-net-http" do
+
+  it 'should support streaming the response' do
+    assert_identical(:streamed => true) {
+      body = StringIO.new '', 'wb'
+
+      Net::HTTP.start('localhost', Mimic::MIMIC_DEFAULT_PORT) do |http|
+        http.request_get "/image" do |resp|
+          resp.should be_a_kind_of(Net::HTTPOK)
+          resp.read_body { |chunk| body.write chunk }
+          resp
+        end
+      end.tap do |resp|
+        resp.instance_variable_set :@streamed_body, body.string
+      end
+    }
+  end
+
+  it 'should support buffering the response' do
+    assert_identical {
+      Net::HTTP.start('localhost', Mimic::MIMIC_DEFAULT_PORT) do |http|
+        respone = http.request_get "/image" do |resp|
+          resp.should be_a_kind_of(Net::HTTPOK)
+          resp.read_body # force reading the body before the test tears down the EM loop
+          resp
+        end
+        respone.tap { respone.should be_a_kind_of(Net::HTTPOK) }
+      end
+    }
+  end
+
+  describe 'should be compatible' do
+    it 'for Net::HTTP.get()' do
+      run_requests {Net::HTTP.get(URI.parse("http://localhost:#{Mimic::MIMIC_DEFAULT_PORT}/hello"))}
+      @expected_res.should == @actual_res
+    end
+
+    # it 'for Net::HTTP.get_print()' do
+    #   run_requests {Net::HTTP.get_print(URI.parse('http://localhost/hello'))}
+    #   @expected_res.should == @actual_res
+    # end
+
+    # We don't test responses like 100 Continue at the moment.
+    %w(200 201 202 203 204 205 206 300 301 302 303 307 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 500 501 502 503 504 505).each do |code|
+      it "for Net::HTTP.start(host, port, &block) with response code #{code}" do
+        assert_identical {
+          Net::HTTP.start('localhost', Mimic::MIMIC_DEFAULT_PORT) do |http|
+            http.get("/code/#{code}").tap { |resp|
+              # Force the response to be buffered while we are still in the EM loop, since we shut it down EM before the verifications
+              resp.body
+            }
+          end
+        }
+      end
+  
+      it "for Net::HTTP.new(host, port).start(&block) with response code #{code}" do
+        assert_identical {
+          h = Net::HTTP.new('localhost', Mimic::MIMIC_DEFAULT_PORT)
+          h.start do |http|
+            http.get("/code/#{code}")
+          end
+        }
+      end
+    end
+    
+    it "with response code 304" do
+      assert_identical {
+        Net::HTTP.start('localhost', Mimic::MIMIC_DEFAULT_PORT) do |http|
+          req = Net::HTTP::Get.new('/code/304')
+          req['If-Modified-Since'] = Time.now.rfc2822
+          http.request(req)
+        end
+      }
+      
+    end
+    
+    it 'with post' do
+      assert_identical {
+        Net::HTTP.start('localhost', Mimic::MIMIC_DEFAULT_PORT) do |http|
+          req = Net::HTTP::Post.new('/testpost')
+          req.body = 'hello mimic'
+          http.request(req)
+        end
+      }
+      
+    end
+    
+  end
+  
+  def run_requests(&block)
+    @expected_res = yield
+    EM.run do
+      Fiber.new do
+        @actual_res = yield
+      end.resume
+      EM.add_periodic_timer(0.0) do
+        EM.stop_event_loop if @actual_res
+      end
+    end
+  end
+  
+  def assert_identical(streamed=false, &block)
+    run_requests(&block)
+    @actual_res.should be_a_kind_of(Net::HTTPResponse)
+    @actual_res.should match_response(@expected_res, :streamed => streamed)
+  end
+  
+  def match_response(expected, streamed=false)
+    ResponseMatcher.new(expected, streamed)
+  end
+  
+  class ResponseMatcher
+    def initialize(expected, streamed=false)
+      @expected = expected
+      @streamed = streamed
+    end
+    
+    def matches?(actual)
+      # Dates could differ slightly :(
+      expected_date = Time.parse(@expected.delete('date').join)
+      actual_date = Time.parse(actual.delete('date').join)
+      actual_date.should >= expected_date
+      actual_date.should <= expected_date + 2
+
+      actual.class.should == @expected.class
+      actual.code.should == @expected.code
+      actual.to_hash.should == @expected.to_hash.merge({"connection" => ['close']})
+
+      if @streamed
+        actual.instance_variable_get(:@streamed_body).should ==
+          @expected.instance_variable_get(:@streamed_body)
+      else
+        actual.body.should == @expected.body
+      end
+      true
+    end
+    
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'em-net-http'
+require 'time'
+require 'rspec'
+
+require 'mimic'
+
+RSpec.configure do |config|
+  config.before(:all) do
+    Mimic.mimic do
+      Net::HTTPResponse::CODE_TO_OBJ.each do |code, klass|
+        get("/code/#{code}").returning("#{code} #{klass.name}", code.to_i, {})
+      end
+      
+      get('/hello').returning('Hello World!', 200, {'Content-Type'=>'text/plain'})
+      
+      class BigImageResponse
+        def each
+          ::File.open('spec/image.jpg', "rb") { |file|
+            while part = file.read(8192)
+              yield part
+            end
+          }
+        end
+      end
+      resp = BigImageResponse.new
+      get('/image').returning(resp, 200, {"Content-Type" => 'image/jpeg'})
+
+      post('/testpost') do
+        "You said #{request.body.read}."
+      end
+    end
+  end
+  
+  config.after(:all) do
+    Mimic.cleanup!
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: em-net-http-npn47
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- James Fairbairn
+- Neeraj PN
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.10
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: mimic
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: weary
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Monkeypatching Net::HTTP to use em-http-request under the hood.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- em-net-http.gemspec
+- lib/em-net-http.rb
+- lib/em-net-http/weary.rb
+- lib/test.rb
+- lib/test_weary.rb
+- spec/em-net-http_spec.rb
+- spec/image.jpg
+- spec/spec.opts
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Non-blocking replacement for Net::HTTP, for use in EventMachine
+test_files: []
+has_rdoc: