excon 0.0.14 → 0.0.15

data/Rakefile

@@ -16,25 +16,8 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/*_test.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
+require 'shindo/rake'
+Shindo::Rake.new
 
 task :test => :check_dependencies
 

data/VERSION

@@ -1 +1 @@
-0.0.14
+0.0.15

data/benchmarks/excon_vs.rb

@@ -1,4 +1,4 @@
-Bundler.require_env(:benchmarks)
+require 'eventmachine'
 
 require File.join(File.dirname(__FILE__), '..', 'lib/excon')
 

data/excon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{excon}
-  s.version = "0.0.14"
+  s.version = "0.0.15"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wesley Beary"]
-  s.date = %q{2010-01-04}
+  s.date = %q{2010-01-06}
   s.description = %q{speed, persistence, http(s)}
   s.email = %q{wbeary@engineyard.com}
   s.extra_rdoc_files = [
@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
      ".gitignore",
-     "Gemfile",
      "README.rdoc",
      "Rakefile",
      "VERSION",
@@ -31,7 +30,6 @@ Gem::Specification.new do |s|
      "lib/excon/errors.rb",
      "lib/excon/response.rb",
      "tests/config.ru",
-     "tests/mock_tests.rb",
      "tests/test_helper.rb",
      "tests/threaded_tests.rb"
   ]

data/lib/excon.rb

@@ -8,6 +8,7 @@ require 'openssl'
 require 'socket'
 require 'uri'
 
+require 'excon/connection'
 require 'excon/errors'
 require 'excon/response'
 
@@ -15,29 +16,8 @@ module Excon
 
   CHUNK_SIZE = 1048576 # 1 megabyte
 
-  def self.reload
-    load 'excon/connection.rb'
-  end
-
-  def self.mock!
-    @mocking = true
-    @mocks = {}
-
-    def self.mocks
-      @mocks
-    end
-
-    self.reload
-  end
-
-  def self.mocking?
-    !!@mocking
-  end
-
   def self.new(url)
     Excon::Connection.new(url)
   end
 
 end
-
-Excon.reload

data/lib/excon/connection.rb

@@ -1,175 +1,130 @@
-unless Excon.mocking?
+module Excon
+  class Connection
 
-  module Excon
-    class Connection
-
-      def initialize(url)
-        @uri = URI.parse(url)
-        Thread.current[:_excon_connections] ||= {}
-      end
+    def initialize(url)
+      @uri = URI.parse(url)
+    end
 
-      def request(params)
-        begin
-          params[:path] ||= ''
-          unless params[:path][0..0] == '/'
-            params[:path] = "/#{params[:path]}"
-          end
-          if params[:query] && !params[:query].empty?
-            params[:path] << "?#{params[:query]}"
-          end
-          request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
-          params[:headers] ||= {}
-          params[:headers]['Host'] = params[:host] || @uri.host
-          if params[:body] && !params[:headers]['Content-Length']
-            params[:headers]['Content-Length'] = params[:body].length
-          end
-          for key, value in params[:headers]
-            request << "#{key}: #{value}\r\n"
+    def request(params)
+      begin
+        params[:path] ||= ''
+        unless params[:path][0..0] == '/'
+          params[:path] = "/#{params[:path]}"
+        end
+        if params[:query] && !params[:query].empty?
+          params[:path] << "?#{params[:query]}"
+        end
+        request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
+        params[:headers] ||= {}
+        params[:headers]['Host'] = params[:host] || @uri.host
+        if params[:body] && !params[:headers]['Content-Length']
+          params[:headers]['Content-Length'] = params[:body].length
+        end
+        for key, value in params[:headers]
+          request << "#{key}: #{value}\r\n"
+        end
+        request << "\r\n"
+        socket.write(request)
+
+        if params[:body]
+          if params[:body].is_a?(String)
+            socket.write(params[:body])
+          else
+            while chunk = params[:body].read(CHUNK_SIZE)
+              socket.write(chunk)
+            end
           end
-          request << "\r\n"
-          connection.write(request)
+        end
 
-          if params[:body]
-            if params[:body].is_a?(String)
-              connection.write(params[:body])
-            else
-              while chunk = params[:body].read(CHUNK_SIZE)
-                connection.write(chunk)
-              end
-            end
+        response = Excon::Response.new
+        response.status = socket.readline[9..11].to_i
+        while true
+          data = socket.readline.chop!
+          unless data.empty?
+            key, value = data.split(': ')
+            response.headers[key] = value
+          else
+            break
           end
+        end
 
-          response = Excon::Response.new
-          response.status = connection.readline[9..11].to_i
-          while true
-            data = connection.readline.chop!
-            unless data.empty?
-              key, value = data.split(': ')
-              response.headers[key] = value
-            else
-              break
-            end
+        unless params[:method] == 'HEAD'
+          block = if !params[:block] || (params[:expects] && ![*params[:expects]].include?(response.status))
+            response.body = ''
+            lambda { |chunk| response.body << chunk }
+          else
+            params[:block]
           end
 
-          unless params[:method] == 'HEAD'
-            block = if !params[:block] || (params[:expects] && ![*params[:expects]].include?(response.status))
-              response.body = ''
-              lambda { |chunk| response.body << chunk }
-            else
-              params[:block]
+          if response.headers['Content-Length']
+            remaining = response.headers['Content-Length'].to_i
+            while remaining > 0
+              block.call(socket.read([CHUNK_SIZE, remaining].min))
+              remaining -= CHUNK_SIZE
             end
-
-            if response.headers['Content-Length']
-              remaining = response.headers['Content-Length'].to_i
-              while remaining > 0
-                block.call(connection.read([CHUNK_SIZE, remaining].min))
-                remaining -= CHUNK_SIZE
-              end
-            elsif response.headers['Transfer-Encoding'] == 'chunked'
-              while true
-                chunk_size = connection.readline.chop!.to_i(16)
-                chunk = connection.read(chunk_size + 2).chop! # 2 == "/r/n".length
-                if chunk_size > 0
-                  block.call(chunk)
-                else
-                  break
-                end
+          elsif response.headers['Transfer-Encoding'] == 'chunked'
+            while true
+              chunk_size = socket.readline.chop!.to_i(16)
+              chunk = socket.read(chunk_size + 2).chop! # 2 == "/r/n".length
+              if chunk_size > 0
+                block.call(chunk)
+              else
+                break
               end
-            elsif response.headers['Connection'] == 'close'
-              block.call(connection.read)
-              Thread.current[:_excon_connections][@uri.to_s] = nil
             end
+          elsif response.headers['Connection'] == 'close'
+            block.call(socket.read)
+            reset_socket
           end
-        rescue => connection_error
-          Thread.current[:_excon_connections][@uri.to_s] = nil
-          raise(connection_error)
-        end
-
-        if params[:expects] && ![*params[:expects]].include?(response.status)
-          Thread.current[:_excon_connections][@uri.to_s] = nil
-          raise(Excon::Errors.status_error(params, response))
-        else
-          response
-        end
-
-      rescue => request_error
-        if params[:idempotent] &&
-            (!request_error.is_a?(Excon::Errors::Error) || response.status != 404)
-          retries_remaining ||= 4
-          retries_remaining -= 1
-          if retries_remaining > 0
-            retry
-          end
-        else
-          raise(request_error)
         end
+      rescue => socket_error
+        reset_socket
+        raise(socket_error)
       end
 
-      private
-
-      def connection
-        if !Thread.current[:_excon_connections][@uri.to_s] || Thread.current[:_excon_connections][@uri.to_s].closed?
-          Thread.current[:_excon_connections][@uri.to_s] = establish_connection
-        end
-        Thread.current[:_excon_connections][@uri.to_s]
+      if params[:expects] && ![*params[:expects]].include?(response.status)
+        reset_socket
+        raise(Excon::Errors.status_error(params, response))
+      else
+        response
       end
 
-      def establish_connection
-        connection = TCPSocket.open(@uri.host, @uri.port)
-
-        if @uri.scheme == 'https'
-          @ssl_context = OpenSSL::SSL::SSLContext.new
-          @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          connection = OpenSSL::SSL::SSLSocket.new(connection, @ssl_context)
-          connection.sync_close = true
-          connection.connect
+    rescue => request_error
+      if params[:idempotent] &&
+          (!request_error.is_a?(Excon::Errors::Error) || response.status != 404)
+        retries_remaining ||= 4
+        retries_remaining -= 1
+        if retries_remaining > 0
+          retry
         end
-
-        connection
+      else
+        raise(request_error)
       end
     end
-  end
 
-else
+    private
 
-  module Excon
-    class Connection
+    def reset_socket
+      new_socket = TCPSocket.open(@uri.host, @uri.port)
 
-      def initialize(url)
+      if @uri.scheme == 'https'
+        @ssl_context = OpenSSL::SSL::SSLContext.new
+        @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        new_socket = OpenSSL::SSL::SSLSocket.new(new_socket, @ssl_context)
+        new_socket.sync_close = true
+        new_socket.connect
       end
 
-      def request(params)
-        for key in Excon.mocks.keys
-          if key == params
-            response = Excon.mocks[key]
-            break
-          end
-        end
-        unless response
-          response = Excon::Response.new
-          response.status = 404
-          response.headers = { 'Content-Length' => 0 }
-        end
-
-        if params[:expects] && ![*params[:expects]].include?(response.status)
-          raise(Excon::Errors.status_error(params[:expects], response.status, response))
-        else
-          response
-        end
+      Thread.current[:_excon_sockets][@uri.to_s] = new_socket
+    end
 
-      rescue => request_error
-        if params[:idempotent]
-          retries_remaining ||= 3
-          retries_remaining -= 1
-          if retries_remaining > 0
-            retry
-          end
-        else
-          raise(request_error)
-        end
+    def socket
+      Thread.current[:_excon_sockets] ||= {}
+      if !Thread.current[:_excon_sockets][@uri.to_s] || Thread.current[:_excon_sockets][@uri.to_s].closed?
+        reset_socket
       end
-
+      Thread.current[:_excon_sockets][@uri.to_s]
     end
-  end
 
+  end
 end

data/tests/config.ru

@@ -1,4 +1,4 @@
-Bundler.require_env(:test_server)
+require 'sinatra'
 
 class App < Sinatra::Base
   get '/id/:id/wait/:wait' do |id, wait|

data/tests/test_helper.rb

@@ -1,13 +1,13 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/excon'))
 
-Bundler.require_env(:test)
+require 'open4'
 
 def local_file(*parts)
   File.expand_path(File.join(File.dirname(__FILE__), *parts))
 end
 
-def with_rackup(configru = local_file('config.ru'), rackup = local_file('..', 'bin', 'rackup'))
-  pid, w, r, e = Open4.popen4("#{rackup} #{configru}")
+def with_rackup(configru = local_file('config.ru'))
+  pid, w, r, e = Open4.popen4("rackup #{configru}")
   while `lsof -p #{pid} -P -i | grep ruby | grep TCP`.chomp.empty?; end
   yield
   Process.kill(9, pid)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: excon
 version: !ruby/object:Gem::Version 
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors: 
 - Wesley Beary
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-04 00:00:00 -08:00
+date: 2010-01-06 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -24,7 +24,6 @@ extra_rdoc_files:
 files: 
 - .document
 - .gitignore
-- Gemfile
 - README.rdoc
 - Rakefile
 - VERSION
@@ -37,7 +36,6 @@ files:
 - lib/excon/errors.rb
 - lib/excon/response.rb
 - tests/config.ru
-- tests/mock_tests.rb
 - tests/test_helper.rb
 - tests/threaded_tests.rb
 has_rdoc: true

data/Gemfile

@@ -1,14 +0,0 @@
-disable_system_gems
-
-only :test do
-  gem 'shindo'
-  gem 'open4'
-end
-
-only :test_server do
-  gem 'sinatra', :require_as => 'sinatra/base'
-end
-
-only :benchmarks do
-  gem 'eventmachine'
-end

data/tests/mock_tests.rb

@@ -1,40 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
-
-Excon.mock!
-
-request = {
-  :host   => 'www.google.com',
-  :method => 'GET',
-  :path   => '/'
-}
-response = Excon::Response.new({
-  :status   => 200,
-  :headers  => { 'Content-Length' => '11' },
-  :body     => 'Hello World'
-})
-Excon.mocks[request] = response
-
-Shindo.tests do
-
-  before do
-    @connection = Excon.new('http://www.google.com')
-    @response = @connection.request({
-      :host   => 'www.google.com',
-      :method => 'GET',
-      :path   => '/'
-    })
-  end
-
-  test("status => 200") do
-    @response.status == 200
-  end
-
-  test("headers => { 'Content-Length' => '11' }") do
-    @response.headers == { 'Content-Length' => '11' }
-  end
-
-  test("body => 'Hello World") do
-    @response.body == 'Hello World'
-  end
-
-end