excon 0.25.3 → 0.26.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    excon (0.25.3)
+    excon (0.26.0)
 
 GEM
   remote: http://rubygems.org/
@@ -9,7 +9,7 @@ GEM
     activesupport (3.2.6)
       i18n (~> 0.6)
       multi_json (~> 1.0)
-    bouncy-castle-java (1.5.0146.1)
+    bouncy-castle-java (1.5.0147)
     chronic (0.6.7)
     delorean (2.0.0)
       chronic
@@ -17,8 +17,8 @@ GEM
     eventmachine (1.0.0-java)
     formatador (0.2.3)
     i18n (0.6.0)
-    jruby-openssl (0.7.7)
-      bouncy-castle-java (>= 1.5.0146.1)
+    jruby-openssl (0.8.8)
+      bouncy-castle-java (>= 1.5.0147)
     json (1.7.3)
     json (1.7.3-java)
     multi_json (1.3.6)

data/README.md

@@ -1,7 +1,9 @@
 excon
 =====
 
-Usable, fast, simple Ruby HTTP 1.0
+Usable, fast, simple Ruby HTTP 1.1
+
+Excon was designed to be simple, fast and performant. It works great as a general HTTP(s) client and is particularly well suited to usage in API clients.
 
 [![Build Status](https://secure.travis-ci.org/geemus/excon.png)](http://travis-ci.org/geemus/excon)
 [![Dependency Status](https://gemnasium.com/geemus/excon.png)](https://gemnasium.com/geemus/excon)
@@ -12,130 +14,142 @@ Getting Started
 
 Install the gem.
 
-    $ sudo gem install excon
+```
+$ sudo gem install excon
+```
 
 Require with rubygems.
 
-    require 'rubygems'
-    require 'excon'
-
-The simplest way to use excon is with one-off requests:
-
-    response = Excon.get('http://geemus.com')
-
-Supported one-off request methods are #connect, #delete, #get, #head, #options, #post, #put, and #trace.
-
-The returned response object has #body, #headers and #status attributes.
-
-Alternately you can create a connection object which is reusable across multiple requests (more performant!).
+```ruby
+require 'rubygems'
+require 'excon'
+```
 
-    connection = Excon.new('http://geemus.com')
-    response_one = connection.get
-    response_two = connection.post(:path => '/foo')
-    response_three = connection.delete(:path => '/bar')
+The easiest way to get started is by using one-off requests. Supported one-off request methods are `connect`, `delete`, `get`, `head`, `options`, `post`, `put`, and `trace`. Requests return a response object which has `body`, `headers`, `remote_ip` and `status` attributes.
 
-Sometimes it is more convenient to specify the request type as an argument:
+```ruby
+response = Excon.get('http://geemus.com')
+response.body       # => "..."
+response.headers    # => {...}
+response.remote_ip  # => "..."
+response.status     # => 200
+```
 
-    response_four = connection.request(:method => :get, :path => '/more')
+For API clients or other ongoing usage, reuse a connection across multiple requests to share options and improve performance.
 
-Both one-off and persistent connections support many other options. Here are a few common examples:
+```ruby
+connection = Excon.new('http://geemus.com')
+get_response = connection.get
+post_response = connection.post(:path => '/foo')
+delete_response = connection.delete(:path => '/bar')
+```
 
-    # Custom headers
-    Excon.get('http://geemus.com', :headers => {'Authorization' => 'Basic 0123456789ABCDEF'})
-    connection.get(:headers => {'Authorization' => 'Basic 0123456789ABCDEF'})
+Options
+-------
 
-    # Changing query strings
-    connection = Excon.new('http://geemus.com/')
-    connection.get(:query => {:foo => 'bar'})
+Both one-off and persistent connections support many other options. The final options for a request are built up by starting with `Excon.defaults`, then merging in options from the connection and finally merging in any request options. In this way you have plenty of options on where and how to set options and can easily setup connections or defaults to match common options for a particular endpoint.
 
-    # POST body encoded with application/x-www-form-urlencoded
-    Excon.post('http://geemus.com',
-      :body => 'language=ruby&class=fog',
-      :headers => { "Content-Type" => "application/x-www-form-urlencoded" })
+Here are a few common examples:
 
-    # same again, but using URI to build the body of parameters
-    Excon.post('http://geemus.com',
-      :body => URI.encode_www_form(:language => 'ruby', :class => 'fog'),
-      :headers => { "Content-Type" => "application/x-www-form-urlencoded" })
+```ruby
+# Custom headers
+Excon.get('http://geemus.com', :headers => {'Authorization' => 'Basic 0123456789ABCDEF'})
+connection.get(:headers => {'Authorization' => 'Basic 0123456789ABCDEF'})
 
-    # request accepts either symbols or strings
-    connection.request(:method => :get)
-    connection.request(:method => 'GET')
+# Changing query strings
+connection = Excon.new('http://geemus.com/')
+connection.get(:query => {:foo => 'bar'})
 
-    # this request can be repeated safely, so retry on errors up to 3 times
-    connection.request(:idempotent => true)
+# POST body encoded with application/x-www-form-urlencoded
+Excon.post('http://geemus.com',
+  :body => 'language=ruby&class=fog',
+  :headers => { "Content-Type" => "application/x-www-form-urlencoded" })
 
-    # this request can be repeated safely, retry up to 6 times
-    connection.request(:idempotent => true, :retry_limit => 6)
+# same again, but using URI to build the body of parameters
+Excon.post('http://geemus.com',
+  :body => URI.encode_www_form(:language => 'ruby', :class => 'fog'),
+  :headers => { "Content-Type" => "application/x-www-form-urlencoded" })
 
-    # opt-out of nonblocking operations for performance and/or as a workaround
-    connection.request(:nonblock => false)
+# request takes a method option, accepting either a symbol or string
+connection.request(:method => :get)
+connection.request(:method => 'GET')
 
-    # opt-in to omitting port from http:80 and https:443
-    connection.request(:omit_default_port => true)
+# expect one or more status codes, or raise an error
+connection.request(:expects => [200, 201], :method => :get)
 
-    # set longer connect_timeout (default is 60 seconds)
-    connection.request(:connect_timeout => 360)
+# this request can be repeated safely, so retry on errors up to 3 times
+connection.request(:idempotent => true)
 
-    # set longer read_timeout (default is 60 seconds)
-    connection.request(:read_timeout => 360)
+# this request can be repeated safely, retry up to 6 times
+connection.request(:idempotent => true, :retry_limit => 6)
 
-    # set longer write_timeout (default is 60 seconds)
-    connection.request(:write_timeout => 360)
+# opt-out of nonblocking operations for performance and/or as a workaround
+connection.request(:nonblock => false)
 
-    # Enable the socket option TCP_NODELAY on the underlying socket.
-    #
-    # This can improve response time when sending frequent short
-    # requests in time-sensitive scenarios.
-    #
-    connection = Excon.new('http://geemus.com/', :tcp_nodelay => true)
+# opt-in to omitting port from http:80 and https:443
+connection.request(:omit_default_port => true)
 
-These options can be combined to make pretty much any request you might need.
+# set longer connect_timeout (default is 60 seconds)
+connection.request(:connect_timeout => 360)
 
-Excon can also expect one or more HTTP status code in response, raising an exception if the response does not meet the criteria.
+# set longer read_timeout (default is 60 seconds)
+connection.request(:read_timeout => 360)
 
-If you need to accept as response one or more HTTP status codes you can declare them in an array:
+# set longer write_timeout (default is 60 seconds)
+connection.request(:write_timeout => 360)
 
-    connection.request(:expects => [200, 201], :method => :get, :path => path, :query => {})
+# Enable the socket option TCP_NODELAY on the underlying socket.
+#
+# This can improve response time when sending frequent short
+# requests in time-sensitive scenarios.
+#
+connection = Excon.new('http://geemus.com/', :tcp_nodelay => true)
+```
 
 Chunked Requests
 ----------------
 
 You can make `Transfer-Encoding: chunked` requests by passing a block that will deliver chunks, delivering an empty chunk to signal completion.
 
-    file = File.open('data')
+```ruby
+file = File.open('data')
 
-    chunker = lambda do
-      # Excon.defaults[:chunk_size] defaults to 1048576, ie 1MB
-      # to_s will convert the nil receieved after everything is read to the final empty chunk
-      file.read(Excon.defaults[:chunk_size]).to_s
-    end
+chunker = lambda do
+  # Excon.defaults[:chunk_size] defaults to 1048576, ie 1MB
+  # to_s will convert the nil receieved after everything is read to the final empty chunk
+  file.read(Excon.defaults[:chunk_size]).to_s
+end
 
-    Excon.post('http://geemus.com', :request_block => chunker)
+Excon.post('http://geemus.com', :request_block => chunker)
 
-    file.close
+file.close
+```
 
 Iterating in this way allows you to have more granular control over writes and to write things where you can not calculate the overall length up front.
 
 Pipelining Requests
 ------------------
 
-You can make use of HTTP pipelining to improve performance. Insead of the normal request/response cyle, pipelining sends a series of requests and then receives a series of responses. You can take advantage of this using the `requests` method, which takes an array of params where each is a hash like request would receive and returns an array of responses.
+You can make use of HTTP pipelining to improve performance. Instead of the normal request/response cyle, pipelining sends a series of requests and then receives a series of responses. You can take advantage of this using the `requests` method, which takes an array of params where each is a hash like request would receive and returns an array of responses.
 
-    connection = Excon.new('http://geemus.com/')
-    connection.requests([{:method => :get}, {:method => :get}])
+```ruby
+connection = Excon.new('http://geemus.com/')
+connection.requests([{:method => :get}, {:method => :get}])
+```
 
 Streaming Responses
 -------------------
 
 You can stream responses by passing a block that will receive each chunk.
 
-    streamer = lambda do |chunk, remaining_bytes, total_bytes|
-      puts chunk
-      puts "Remaining: #{remaining_bytes.to_f / total_bytes}%"
-    end
+```ruby
+streamer = lambda do |chunk, remaining_bytes, total_bytes|
+  puts chunk
+  puts "Remaining: #{remaining_bytes.to_f / total_bytes}%"
+end
 
-    Excon.get('http://geemus.com', :response_block => streamer)
+Excon.get('http://geemus.com', :response_block => streamer)
+```
 
 Iterating over each chunk will allow you to do work on the response incrementally without buffering the entire response first. For very large responses this can lead to significant memory savings.
 
@@ -144,8 +158,10 @@ Proxy Support
 
 You can specify a proxy URL that Excon will use with both HTTP and HTTPS connections:
 
-    connection = Excon.new('http://geemus.com', :proxy => 'http://my.proxy:3128')
-    connection.request(:method => 'GET')
+```ruby
+connection = Excon.new('http://geemus.com', :proxy => 'http://my.proxy:3128')
+connection.request(:method => 'GET')
+```
 
 The proxy URL must be fully specified, including scheme (e.g. "http://") and port.
 
@@ -158,94 +174,96 @@ Stubs
 
 You can stub out requests for testing purposes by enabling mock mode on a connection.
 
-    connection = Excon.new('http://example.com', :mock => true)
+```ruby
+connection = Excon.new('http://example.com', :mock => true)
+```
 
 Or by enabling mock mode for a request.
 
-    connection.request(:method => :get, :path => 'example', :mock => true)
-
-Then you can add stubs, for instance:
+```ruby
+connection.request(:method => :get, :path => 'example', :mock => true)
+```
 
-    # Excon.stub(request_attributes, response_attributes)
-    Excon.stub({:method => :get}, {:body => 'body', :status => 200})
+Add stubs by providing the request_attributes to match and response attributes to return. Response params can be specified as either a hash or block which will yield with response_params.
 
-Omitted attributes are assumed to match, so this stub will match any get request and return an Excon::Response with a body of 'body' and status of 200.  You can add whatever stubs you might like this way and they will be checked against in the order they were added, if none of them match then excon will raise an error to let you know.
+```ruby
+Excon.stub({}, {:body => 'body', :status => 200})
+Excon.stub({}, lambda {|request_params| :body => request_params[:body], :status => 200})
+```
 
-Alternatively you can pass a block instead of `response_attributes` and it will be called with the request params.  For example, you could create a stub that echoes the body given to it like this:
-
-    # Excon.stub(request_attributes, &response_block)
-    Excon.stub({:method => :put}) do |params|
-      {:body => params[:body], :status => 200}
-    end
+Omitted attributes are assumed to match, so this stub will match *any* request and return an Excon::Response with a body of 'body' and status of 200.  You can add whatever stubs you might like this way and they will be checked against in the order they were added, if none of them match then excon will raise an `Excon::Errors::StubNotFound` error to let you know.
 
-In order to clear all previously defined stubs you can use:
+To remove a previously defined stub, or all stubs:
 
-    Excon.stubs.clear
-
-Or to simply remove the last defined stub you can use:
-
-    Excon.stubs.shift
+```ruby
+Excon.unstub({})  # remove first/oldest stub matching {}
+Excon.stubs.clear # remove all stubs
+```
 
 For example, if using RSpec for your test suite you can clear stubs after running each example:
 
-    config.after(:each) do
-      Excon.stubs.clear
-    end
-
-You can also modify 'Excon.defaults` to set a default for all requests, so for a test suite you might do this:
-
-    before(:all) { Excon.defaults[:mock] = true }
-
-For additional information on stubbing, read the pull request notes [here](https://github.com/geemus/excon/issues/29)
-
-HTTPS/SSL Issues
-----------------
-
-By default excon will try to verify peer certificates when using SSL for HTTPS. Unfortunately on some operating systems the defaults will not work. This will likely manifest itself as something like `Excon::Errors::SocketError: SSL_connect returned=1 ...`
-
-If you have the misfortune of running into this problem you have a couple options. If you have certificates but they aren't being auto-discovered, you can specify the path to your certificates:
+```ruby
+config.after(:each) do
+  Excon.stubs.clear
+end
+```
 
-    Excon.defaults[:ssl_ca_path] = '/path/to/certs'
+You can also modify 'Excon.defaults` to set a stub for all requests, so for a test suite you might do this:
 
-Failing that, you can turn off peer verification (less secure):
-
-    Excon.defaults[:ssl_verify_peer] = false
-
-Either of these should allow you to work around the socket error and continue with your work.
+```ruby
+# Mock by default and stub any request as success
+config.before(:all) do
+  Excon.defaults[:mock] = true
+  Excon.stub({}, {:body => 'Fallback', :status => 200})
+  # Add your own stubs here or in specific tests...
+end
+```
 
 Instrumentation
 ---------------
 
 Excon calls can be timed using the [ActiveSupport::Notifications](http://api.rubyonrails.org/classes/ActiveSupport/Notifications.html) API.
 
-    connection = Excon.new('http://geemus.com',
-        :instrumentor => ActiveSupport::Notifications)
+```ruby
+connection = Excon.new(
+  'http://geemus.com',
+  :instrumentor => ActiveSupport::Notifications
+)
+```
 
 Excon will then instrument each request, retry, and error.  The corresponding events are named excon.request, excon.retry, and excon.error respectively.
 
-    ActiveSupport::Notifications.subscribe(/excon/) do |*args|
-      puts "Excon did stuff!"
-    end
+```ruby
+ActiveSupport::Notifications.subscribe(/excon/) do |*args|
+  puts "Excon did stuff!"
+end
+```
 
 If you prefer to label each event with something other than "excon," you may specify
 an alternate name in the constructor:
 
-    connection = Excon.new('http://geemus.com',
-        :instrumentor => ActiveSupport::Notifications,
-        :instrumentor_name => 'my_app')
+```ruby
+connection = Excon.new(
+  'http://geemus.com',
+  :instrumentor => ActiveSupport::Notifications,
+  :instrumentor_name => 'my_app'
+)
+```
 
 If you don't want to add activesupport to your application, simply define a class which implements the same #instrument method like so:
 
-    class SimpleInstrumentor
-      class << self
-        attr_accessor :events
+```ruby
+class SimpleInstrumentor
+  class << self
+    attr_accessor :events
 
-        def instrument(name, params = {}, &block)
-          puts "#{name} just happened."
-          yield if block_given?
-        end
-      end
+    def instrument(name, params = {}, &block)
+      puts "#{name} just happened."
+      yield if block_given?
     end
+  end
+end
+```
 
 The #instrument method will be called for each HTTP request, response, retry, and error.
 
@@ -253,12 +271,31 @@ For debugging purposes you can also use Excon::StandardInstrumentor to output al
 
 See [the documentation for ActiveSupport::Notifications](http://api.rubyonrails.org/classes/ActiveSupport/Notifications.html) for more detail on using the subscription interface.  See excon's instrumentation_test.rb for more examples of instrumenting excon.
 
+HTTPS/SSL Issues
+----------------
+
+By default excon will try to verify peer certificates when using SSL for HTTPS. Unfortunately on some operating systems the defaults will not work. This will likely manifest itself as something like `Excon::Errors::SocketError: SSL_connect returned=1 ...`
+
+If you have the misfortune of running into this problem you have a couple options. If you have certificates but they aren't being auto-discovered, you can specify the path to your certificates:
+
+```ruby
+Excon.defaults[:ssl_ca_path] = '/path/to/certs'
+```
+
+Failing that, you can turn off peer verification (less secure):
+
+```ruby
+Excon.defaults[:ssl_verify_peer] = false
+```
+
+Either of these should allow you to work around the socket error and continue with your work.
+
 Copyright
 ---------
 
 (The MIT License)
 
-Copyright (c) 2010-2013 {geemus (Wesley Beary)}[http://github.com/geemus]
+Copyright (c) 2010-2013 [geemus (Wesley Beary)](http://github.com/geemus)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/changelog.txt

@@ -1,3 +1,16 @@
+0.26.0 09/24/2013
+=================
+
+add basic decompress middleware
+update readme mocking+stubbing info
+add unstub functionality
+avoid modifying original options in request
+jruby fixes
+misc cleanup/fixes
+encoding/compatibility fixes
+close sockets on error
+warn when both request_block and idempotent are set
+
 0.25.3 07/18/2013
 =================
 

data/excon.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'excon'
-  s.version           = '0.25.3'
-  s.date              = '2013-07-18'
+  s.version           = '0.26.0'
+  s.date              = '2013-09-24'
   s.rubyforge_project = 'excon'
 
   ## Make sure your summary is short. The description may be as long
@@ -98,10 +98,12 @@ Gem::Specification.new do |s|
     lib/excon/constants.rb
     lib/excon/errors.rb
     lib/excon/middlewares/base.rb
+    lib/excon/middlewares/decompress.rb
     lib/excon/middlewares/expects.rb
     lib/excon/middlewares/idempotent.rb
     lib/excon/middlewares/instrumentor.rb
     lib/excon/middlewares/mock.rb
+    lib/excon/middlewares/redirect_follower.rb
     lib/excon/middlewares/response_parser.rb
     lib/excon/response.rb
     lib/excon/socket.rb
@@ -115,14 +117,17 @@ Gem::Specification.new do |s|
     tests/data/xs
     tests/errors_tests.rb
     tests/header_tests.rb
+    tests/middlewares/decompress_tests.rb
     tests/middlewares/idempotent_tests.rb
     tests/middlewares/instrumentation_tests.rb
     tests/middlewares/mock_tests.rb
+    tests/middlewares/redirect_follower.rb
     tests/proxy_tests.rb
     tests/query_string_tests.rb
     tests/rackups/basic.rb
     tests/rackups/basic.ru
     tests/rackups/basic_auth.ru
+    tests/rackups/deflater.ru
     tests/rackups/proxy.ru
     tests/rackups/query_string.ru
     tests/rackups/request_headers.ru

data/lib/excon.rb

@@ -8,6 +8,8 @@ require 'rbconfig'
 require 'socket'
 require 'timeout'
 require 'uri'
+require 'zlib'
+require 'stringio'
 
 # Define defaults first so they will be available to other files
 module Excon
@@ -17,6 +19,7 @@ module Excon
     def defaults
       @defaults ||= {
         :chunk_size         => CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
+        :ciphers            => 'HIGH:!SSLv2:!aNULL:!eNULL:!3DES',
         :connect_timeout    => 60,
         :debug_request      => false,
         :debug_response     => false,
@@ -57,10 +60,12 @@ require 'excon/constants'
 require 'excon/connection'
 require 'excon/errors'
 require 'excon/middlewares/base'
+require 'excon/middlewares/decompress'
 require 'excon/middlewares/expects'
 require 'excon/middlewares/idempotent'
 require 'excon/middlewares/instrumentor'
 require 'excon/middlewares/mock'
+require 'excon/middlewares/redirect_follower'
 require 'excon/middlewares/response_parser'
 require 'excon/response'
 require 'excon/socket'
@@ -173,11 +178,13 @@ module Excon
     end
 
     # get a stub matching params or nil
+    #   @param [Hash<Symbol, >] request params to match against, omitted params match all
+    #   @return [Hash<Symbol, >] response params to return from matched request or block to call with params
     def stub_for(request_params={})
       if method = request_params.delete(:method)
         request_params[:method] = method.to_s.downcase.to_sym
       end
-      Excon.stubs.each do |stub, response|
+      Excon.stubs.each do |stub, response_params|
         captures = { :headers => {} }
         headers_match = !stub.has_key?(:headers) || stub[:headers].keys.all? do |key|
           case value = stub[:headers][key]
@@ -203,7 +210,7 @@ module Excon
         end
         if headers_match && non_headers_match
           request_params[:captures] = captures
-          return response
+          return [stub, response_params]
         end
       end
       nil
@@ -214,6 +221,14 @@ module Excon
       @stubs ||= []
     end
 
+    # remove first/oldest stub matching request_params
+    #   @param [Hash<Symbol, >] request params to match against, omitted params match all
+    #   @return [Hash<Symbol, >] response params from deleted stub
+    def unstub(request_params = {})
+      stub = stub_for(request_params)
+      Excon.stubs.delete_at(Excon.stubs.index(stub))
+    end
+
     # Generic non-persistent HTTP methods
     HTTP_VERBS.each do |method|
       module_eval <<-DEF, __FILE__, __LINE__ + 1

data/lib/excon/connection.rb

@@ -39,6 +39,7 @@ module Excon
     #     @option params [Fixnum] :port The port on which to connect, to the destination host
     #     @option params [Hash]   :query Default query; appended to the 'scheme://host:port/path/' in the form of '?key=value'. Will only be used if params[:query] is not supplied to Connection#request
     #     @option params [String] :scheme The protocol; 'https' causes OpenSSL to be used
+    #     @option params [String] :ciphers Only use the specified SSL/TLS cipher suites; use OpenSSL cipher spec format e.g. 'HIGH:!aNULL:!3DES' or 'AES256-SHA:DES-CBC3-SHA'
     #     @option params [String] :proxy Proxy server; e.g. 'http://myproxy.com:8888'
     #     @option params [Fixnum] :retry_limit Set how many times we'll retry a failed request.  (Default 4)
     #     @option params [Class] :instrumentor Responds to #instrument as in ActiveSupport::Notifications
@@ -133,10 +134,16 @@ module Excon
 
           if datum.has_key?(:request_block)
             datum[:headers]['Transfer-Encoding'] = 'chunked'
-          elsif ! (datum[:method].to_s.casecmp('GET') == 0 && datum[:body].nil?)
+          else
+            body = datum[:body].is_a?(String) ? StringIO.new(datum[:body]) : datum[:body]
+
             # The HTTP spec isn't clear on it, but specifically, GET requests don't usually send bodies;
             # if they don't, sending Content-Length:0 can cause issues.
-            datum[:headers]['Content-Length'] = detect_content_length(datum[:body])
+            unless datum[:method].to_s.casecmp('GET') == 0 && body.nil?
+              unless datum[:headers].has_key?('Content-Length')
+                datum[:headers]['Content-Length'] = detect_content_length(body)
+              end
+            end
           end
 
           # add headers to request
@@ -148,9 +155,9 @@ module Excon
 
           # add additional "\r\n" to indicate end of headers
           request << CR_NL
+          socket.write(request) # write out request + headers
 
           if datum.has_key?(:request_block)
-            socket.write(request) # write out request + headers
             while true # write out body with chunked encoding
               chunk = datum[:request_block].call
               if FORCE_ENC
@@ -163,23 +170,16 @@ module Excon
                 break
               end
             end
-          elsif !datum[:body].nil?
-            if datum[:body].is_a?(String) # write out string body
-              socket.write(request << datum[:body]) # write out request + headers + body
-            else # write out file body
-              socket.write(request) # write out request + headers
-              if datum[:body].respond_to?(:binmode)
-                datum[:body].binmode
-              end
-              if datum[:body].respond_to?(:pos=)
-                datum[:body].pos = 0
-              end
-              while chunk = datum[:body].read(datum[:chunk_size])
-                socket.write(chunk)
-              end
+          elsif !body.nil? # write out body
+            if body.respond_to?(:binmode)
+              body.binmode
+            end
+            if body.respond_to?(:pos=)
+              body.pos = 0
+            end
+            while chunk = body.read(datum[:chunk_size])
+              socket.write(chunk)
             end
-          else # write out nil body
-            socket.write(request) # write out request + headers
           end
         end
       rescue => error
@@ -215,7 +215,7 @@ module Excon
     #     @option params [Fixnum] :port The port on which to connect, to the destination host
     #     @option params [Hash]   :query appended to the 'scheme://host:port/path/' in the form of '?key=value'
     #     @option params [String] :scheme The protocol; 'https' causes OpenSSL to be used
-    def request(params, &block)
+    def request(params={}, &block)
       # @data has defaults, merge in new params to override
       datum = @data.merge(params)
       invalid_keys_warning(params, VALID_CONNECTION_KEYS)
@@ -226,7 +226,7 @@ module Excon
 
       # if path is empty or doesn't start with '/', insert one
       unless datum[:path][0, 1] == '/'
-        datum[:path].insert(0, '/')
+        datum[:path] = datum[:path].dup.insert(0, '/')
       end
 
       if block_given?
@@ -234,6 +234,11 @@ module Excon
         datum[:response_block] = Proc.new
       end
 
+      if datum[:request_block] && datum[:idempotent]
+        Excon.display_warning("Excon requests with a :request_block can not be :idempotent (#{caller.first})")
+        datum[:idempotent] = false
+      end
+
       datum[:connection] = self
 
       datum[:stack] = datum[:middlewares].map do |middleware|
@@ -255,6 +260,7 @@ module Excon
         datum
       end
     rescue => error
+      reset
       datum[:error] = error
       if datum[:stack]
         datum[:stack].error_call(datum)
@@ -321,20 +327,14 @@ module Excon
     private
 
     def detect_content_length(body)
-      if body.is_a?(String)
-        if FORCE_ENC
-          body.force_encoding('BINARY')
-        end
-        body.length
-      elsif body.respond_to?(:size)
-        # IO object: File, Tempfile, etc.
+      if body.respond_to?(:size)
+        # IO object: File, Tempfile, StringIO, etc.
         body.size
+      elsif body.respond_to?(:stat)
+        # for 1.8.7 where file does not have size
+        body.stat.size
       else
-        begin
-          File.size(body) # for 1.8.7 where file does not have size
-        rescue
-          0
-        end
+        0
       end
     end
 

data/lib/excon/constants.rb

@@ -77,7 +77,7 @@ module Excon
     :write_timeout
   ]
 
-  VERSION = '0.25.3'
+  VERSION = '0.26.0'
   USER_AGENT = 'excon/' << VERSION
 
   unless ::IO.const_defined?(:WaitReadable)

data/lib/excon/middlewares/decompress.rb

@@ -0,0 +1,18 @@
+module Excon
+  module Middleware
+    class Decompress < Excon::Middleware::Base
+      def response_call(datum)
+        unless datum.has_key?(:response_block)
+          case datum[:response][:headers]['Content-Encoding']
+          when 'deflate'
+            # assume inflate omits header
+            datum[:response][:body] = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(datum[:response][:body])
+          when 'gzip'
+            datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(datum[:response][:body])).read
+          end
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

data/lib/excon/middlewares/idempotent.rb

@@ -6,7 +6,6 @@ module Excon
             Excon::Errors::HTTPStatusError].any? {|ex| datum[:error].kind_of?(ex) } && datum[:retries_remaining] > 1
           # reduces remaining retries, reset connection, and restart request_call
           datum[:retries_remaining] -= 1
-          datum[:connection].reset
           datum.delete(:response)
           datum.delete(:error)
           datum[:connection].request(datum)

data/lib/excon/middlewares/mock.rb

@@ -14,7 +14,7 @@ module Excon
            datum[:body] = datum[:body].read
           end
 
-          if response = Excon.stub_for(datum)
+          if stub = Excon.stub_for(datum)
             datum[:response] = {
               :body       => '',
               :headers    => {},
@@ -22,11 +22,11 @@ module Excon
               :remote_ip  => '127.0.0.1'
             }
 
-            stub_datum = case response
+            stub_datum = case stub.last
             when Proc
-              response.call(datum)
+              stub.last.call(datum)
             else
-              response
+              stub.last
             end
 
             datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})

data/lib/excon/middlewares/redirect_follower.rb

@@ -0,0 +1,45 @@
+module Excon
+  module Middleware
+    class RedirectFollower < Excon::Middleware::Base
+      def response_call(datum)
+        if datum.has_key?(:response) && [:get, :head].include?(datum[:method].to_s.downcase.to_sym)
+          case datum[:response][:status]
+          when 301, 302, 303, 307
+            uri_parser = datum[:uri_parser] || Excon.defaults[:uri_parser]
+            _, location = datum[:response][:headers].detect do |key, value|
+              key.casecmp('Location') == 0
+            end
+            uri = uri_parser.parse(location)
+
+            port_string = if datum[:omit_default_port] && ((uri.scheme.casecmp('http') == 0 && uri.port.to_i == 80) || (uri.scheme.casecmp('https') == 0 && uri.port.to_i == 443))
+              ''
+            else
+              ':' << uri.port.to_s
+            end
+
+            # delete old/redirect response
+            datum.delete(:response)
+
+            response = datum[:connection].request(
+              datum.merge!(
+                :headers    => (datum[:headers] || {}).merge({'Host' => '' << uri.host << port_string}),
+                :host       => uri.host,
+                :path       => uri.path,
+                :port       => uri.port,
+                :query      => uri.query,
+                :scheme     => uri.scheme,
+                :user       => (URI.decode(uri.user) if uri.user),
+                :password   => (URI.decode(uri.password) if uri.password)
+              )
+            )
+            datum.merge!({:response => response.data})
+          else
+            @stack.response_call(datum)
+          end
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

data/lib/excon/socket.rb

@@ -84,47 +84,35 @@ module Excon
 
     def write(data)
       if @data[:nonblock]
-        # We normally return from the return in the else block below, but
-        # we guard that data is still something in case we get weird
-        # values and String#[] returns nil. (This behavior has been observed
-        # in the wild, so this is a simple defensive mechanism)
-        while data
+        if FORCE_ENC
+          data.force_encoding('BINARY')
+        end
+        while true
+          written = nil
           begin
             # I wish that this API accepted a start position, then we wouldn't
             # have to slice data when there is a short write.
             written = @socket.write_nonblock(data)
-          rescue OpenSSL::SSL::SSLError => error
-            if error.message == 'write would block'
+          rescue OpenSSL::SSL::SSLError, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
+            if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
+              raise error
+            else
               if IO.select(nil, [@socket], nil, @data[:write_timeout])
                 retry
               else
-                raise(Excon::Errors::Timeout.new("write timeout reached"))
+                raise Excon::Errors::Timeout.new('write timeout reached')
               end
-            else
-              raise(error)
             end
-          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable
-            if IO.select(nil, [@socket], nil, @data[:write_timeout])
-              retry
-            else
-              raise(Excon::Errors::Timeout.new("write timeout reached"))
-            end
-          else
-            # Fast, common case.
-            # The >= seems weird, why would it have written MORE than we
-            # requested. But we're getting some weird behavior when @socket
-            # is an OpenSSL socket, where it seems like it's saying it wrote
-            # more (perhaps due to SSL packet overhead?).
-            #
-            # Pretty weird, but this is a simple defensive mechanism.
-            return if written >= data.size
-
-            # This takes advantage of the fact that most ruby implementations
-            # have Copy-On-Write strings. Thusly why requesting a subrange
-            # of data, we actually don't copy data because the new string
-            # simply references a subrange of the original.
-            data = data[written, data.size]
           end
+
+          # Fast, common case.
+          break if written == data.size
+
+          # This takes advantage of the fact that most ruby implementations
+          # have Copy-On-Write strings. Thusly why requesting a subrange
+          # of data, we actually don't copy data because the new string
+          # simply references a subrange of the original.
+          data = data[written, data.size]
         end
       else
         begin

data/lib/excon/ssl_socket.rb

@@ -9,7 +9,8 @@ module Excon
 
       # create ssl context
       ssl_context = OpenSSL::SSL::SSLContext.new
-
+      ssl_context.ciphers = @data[:ciphers]
+      
       if @data[:ssl_verify_peer]
         # turn verification on
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
@@ -21,7 +22,16 @@ module Excon
         else # attempt default, fallback to bundled
           ssl_context.cert_store = OpenSSL::X509::Store.new
           ssl_context.cert_store.set_default_paths
-          ssl_context.cert_store.add_file(DEFAULT_CA_FILE)
+
+          # workaround issue #257 (JRUBY-6970)
+          ca_file = DEFAULT_CA_FILE
+          ca_file.gsub!(/^jar:/, "") if ca_file =~ /^jar:file:\//
+
+          begin
+            ssl_context.cert_store.add_file(ca_file)
+          rescue => e
+            Excon.display_warning("Excon unable to add file to cert store, ignoring: #{ca_file}\n[#{e.class}] #{e.message}\n#{e.backtrace.join("\n")}")
+          end
         end
       else
         # turn verification off

data/tests/basic_tests.rb

@@ -67,7 +67,8 @@ with_rackup('ssl_verify_peer.ru') do
 
     basic_tests('https://127.0.0.1:8443',
                 :client_key => File.join(File.dirname(__FILE__), 'data', 'excon.cert.key'),
-                :client_cert => File.join(File.dirname(__FILE__), 'data', 'excon.cert.crt')
+                :client_cert => File.join(File.dirname(__FILE__), 'data', 'excon.cert.crt'),
+                :reset_connection => RUBY_VERSION == '1.9.2'
                )
 
   end

data/tests/middlewares/decompress_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Excon decompression support') do
+  env_init
+
+  with_rackup('deflater.ru') do
+    connection = Excon.new(
+      'http://127.0.0.1:9292/echo',
+      :body         => 'x' * 100,
+      :method       => :post,
+      :middlewares  => Excon.defaults[:middlewares] + [Excon::Middleware::Decompress]
+    )
+
+    tests('deflate').returns('x' * 100) do
+      response = connection.request(:headers => { 'Accept-Encoding' => 'deflate' })
+      response.body
+    end
+
+    tests('gzip').returns('x' * 100) do
+      response = connection.request(:headers => { 'Accept-Encoding' => 'gzip' })
+      response.body
+    end
+  end
+
+  env_restore
+end

data/tests/middlewares/mock_tests.rb

@@ -193,6 +193,32 @@ Shindo.tests('Excon stubs') do
 
   end
 
+  tests("stub_for({})") do
+    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
+    Excon.stub({}, {})
+
+    tests("stub_for({})").returns([{}, {}]) do
+      Excon.stub_for({})
+    end
+
+    Excon.stubs.clear
+  end
+
+  tests("unstub({})") do
+    connection = Excon.new('http://127.0.0.1:9292', :mock => true)
+    Excon.stub({}, {})
+
+    tests("unstub({})").returns([{}, {}]) do
+      Excon.unstub({})
+    end
+
+    tests("request(:method => :get)").raises(Excon::Errors::StubNotFound) do
+      connection.request(:method => :get)
+    end
+
+    Excon.stubs.clear
+  end
+
   tests('mock = false') do
     with_rackup('basic.ru') do
       basic_tests

data/tests/middlewares/redirect_follower.rb

@@ -0,0 +1,32 @@
+Shindo.tests('Excon redirector support') do
+  env_init
+
+  connection = Excon.new(
+    'http://127.0.0.1:9292',
+    :middlewares  => Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower],
+    :mock         => true
+  )
+
+  Excon.stub(
+    { :path => '/old' },
+    {
+      :headers  => { 'Location' => 'http://127.0.0.1:9292/new' },
+      :body     => 'old',
+      :status   => 301
+    }
+  )
+
+  Excon.stub(
+    { :path => '/new' },
+    {
+      :body     => 'new',
+      :status   => 200
+    }
+  )
+
+  tests("request(:method => :get, :path => '/old').body").returns('new') do
+    connection.request(:method => :get, :path => '/old').body
+  end
+
+  env_restore
+end

data/tests/rackups/deflater.ru

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), 'basic')
+
+use Rack::Deflater
+run Basic

data/tests/request_method_tests.rb

@@ -34,6 +34,12 @@ Shindo.tests('Excon request methods') do
         connection.delete.body
       end
 
+      tests('not modifies path argument').returns('path') do
+        path = 'path'
+        connection.get(:path => path)
+        path
+      end
+
     end
 
   end

data/tests/test_helper.rb

@@ -3,9 +3,8 @@ require 'bundler'
 
 Bundler.require(:default, :development)
 
-require 'stringio'
-
 def basic_tests(url = 'http://127.0.0.1:9292', options = {})
+  reset_connection = !!options.delete(:reset_connection)
   [false, true].each do |nonblock|
     options = options.merge({:ssl_verify_peer => false, :nonblock => nonblock })
     connection = Excon.new(url, options)
@@ -77,6 +76,9 @@ def basic_tests(url = 'http://127.0.0.1:9292', options = {})
       tests('POST /body-sink') do
 
         tests('response.body').returns("5000000") do
+          if reset_connection && !nonblock
+            connection.reset
+          end
           response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => 'x' * 5_000_000)
           response.body
         end
@@ -110,6 +112,20 @@ def basic_tests(url = 'http://127.0.0.1:9292', options = {})
           response.body
         end
 
+        tests('with multi-byte strings') do
+          body = "\xC3\xBC" * 100
+          headers = { 'Custom' => body.dup }
+          if RUBY_VERSION >= '1.9'
+            body.force_encoding('BINARY')
+            headers['Custom'].force_encoding('UTF-8')
+          end
+
+          returns(body, 'properly concatenates request+headers and body') do
+            response = connection.request(:method => :post, :path => '/echo', :headers => headers, :body => body)
+            response.body
+          end
+        end
+
       end
 
       tests('PUT /echo') do
@@ -134,6 +150,20 @@ def basic_tests(url = 'http://127.0.0.1:9292', options = {})
           response.body
         end
 
+        tests('with multi-byte strings') do
+          body = "\xC3\xBC" * 100
+          headers = { 'Custom' => body.dup }
+          if RUBY_VERSION >= '1.9'
+            body.force_encoding('BINARY')
+            headers['Custom'].force_encoding('UTF-8')
+          end
+
+          returns(body, 'properly concatenates request+headers and body') do
+            response = connection.request(:method => :put, :path => '/echo', :headers => headers, :body => body)
+            response.body
+          end
+        end
+
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excon
 version: !ruby/object:Gem::Version
-  version: 0.25.3
+  version: 0.26.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -178,10 +178,12 @@ files:
 - lib/excon/constants.rb
 - lib/excon/errors.rb
 - lib/excon/middlewares/base.rb
+- lib/excon/middlewares/decompress.rb
 - lib/excon/middlewares/expects.rb
 - lib/excon/middlewares/idempotent.rb
 - lib/excon/middlewares/instrumentor.rb
 - lib/excon/middlewares/mock.rb
+- lib/excon/middlewares/redirect_follower.rb
 - lib/excon/middlewares/response_parser.rb
 - lib/excon/response.rb
 - lib/excon/socket.rb
@@ -195,14 +197,17 @@ files:
 - tests/data/xs
 - tests/errors_tests.rb
 - tests/header_tests.rb
+- tests/middlewares/decompress_tests.rb
 - tests/middlewares/idempotent_tests.rb
 - tests/middlewares/instrumentation_tests.rb
 - tests/middlewares/mock_tests.rb
+- tests/middlewares/redirect_follower.rb
 - tests/proxy_tests.rb
 - tests/query_string_tests.rb
 - tests/rackups/basic.rb
 - tests/rackups/basic.ru
 - tests/rackups/basic_auth.ru
+- tests/rackups/deflater.ru
 - tests/rackups/proxy.ru
 - tests/rackups/query_string.ru
 - tests/rackups/request_headers.ru
@@ -237,7 +242,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1555854800829677870
+      hash: -2550839664096284654
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: