excon 0.43.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77a0da513895a3cba30b16145e7bea66033973cb
-  data.tar.gz: c573a10ec3c2f569628b1c605dc6d47a25caecf5
+  metadata.gz: 90759d86297bebbce2b0374cb730466df92321ec
+  data.tar.gz: 67e4b85deb2f2b52455b190fa4c3df120fb1c532
 SHA512:
-  metadata.gz: 740736aa1390923d0ce8d30b4739b149509cdfe445e5ea90ef21e2f1f69e1df2603d22d722b9d4ac835c349e503d03349fbfcdc978104057edcc1310d130c654
-  data.tar.gz: fa08c954a4fcb5bc746d3ab32194b7bb41fef491b86b8ac3d5e0436d6c816f3074232e4ee807b132fc450d53f2f84ffe3a770738e5130c7ec65818faa5feea76
+  metadata.gz: bda8264156cb7f3983aaac5cd8327254cc0f06a1ec9f1dc701271798cf06bfe2c207e14fb55bdd9b6deb96ce15843c0b2c6b0f7a5fbb66ead49a21d199b9f976
+  data.tar.gz: 511d4b47dd504535f78a25c4a741fcaea3206ec466fe57c199c6ae8c4ee8d5111ca5a1f8a39cb3e80cfb6f25d7f226df74a2b748f4b2392e3ece823479e470e8

data/Gemfile

@@ -5,7 +5,7 @@ gemspec
 gem 'jruby-openssl', :platform => :jruby
 gem 'unicorn', :platforms => [:mri, :rbx]
 gem 'rubysl', '~> 2.0', :platform => :rbx
-gem 'rack', '~> 1.5'
+gem 'rack', '~> 1.6'
 
 # group :benchmark do
 #   gem 'em-http-request'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    excon (0.43.0)
+    excon (0.44.0)
 
 GEM
   remote: http://rubygems.org/
@@ -13,20 +13,20 @@ GEM
     chronic (0.6.7)
     delorean (2.0.0)
       chronic
-    eventmachine (1.0.0)
-    eventmachine (1.0.0-java)
+    eventmachine (1.0.4)
+    eventmachine (1.0.4-java)
     ffi2-generators (0.1.1)
     formatador (0.2.3)
     i18n (0.6.0)
     jruby-openssl (0.8.8)
       bouncy-castle-java (>= 1.5.0147)
-    json (1.7.3)
-    json (1.7.3-java)
+    json (1.8.2)
+    json (1.8.2-java)
     kgio (2.9.2)
     minitest (4.7.5)
     multi_json (1.3.6)
     open4 (1.3.0)
-    rack (1.5.2)
+    rack (1.6.0)
     rack-protection (1.2.0)
       rack
     raindrops (0.13.0)
@@ -257,11 +257,12 @@ PLATFORMS
 DEPENDENCIES
   activesupport
   delorean
-  eventmachine
+  eventmachine (>= 1.0.4)
   excon!
   jruby-openssl
+  json (>= 1.8.2)
   open4
-  rack (~> 1.5)
+  rack (~> 1.6)
   rake
   rdoc
   rubysl (~> 2.0)

data/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2009-2014 [CONTRIBUTORS.md](https://github.com/excon/excon/blob/master/CONTRIBUTORS.md)
+Copyright (c) 2009-2015 [CONTRIBUTORS.md](https://github.com/excon/excon/blob/master/CONTRIBUTORS.md)
 
 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

data/README.md

@@ -145,6 +145,10 @@ connection = Excon.new('http://geemus.com/', :nonblock => false)
 connection = Excon.new('http://username:password@secure.geemus.com')
 connection = Excon.new('http://secure.geemus.com',
   :user => 'username', :password => 'password')
+
+# use custom uri parser
+require 'addressable/uri'
+connection = Excon.new('http://geemus.com/', uri_parser: Addressable::URI)
 ```
 
 ## Chunked Requests

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'date'
-
+include Rake::DSL
 #############################################################################
 #
 # Helper functions

data/changelog.txt

@@ -1,3 +1,13 @@
+0.44.0 01/30/2015
+=================
+
+re-implement timeout using IO.select
+document custom URI parser usage
+fix ruby 2.2 build
+improved IPv6 support
+Excon::Utils improvements
+add 429 errors
+
 0.43.0 01/09/2015
 =================
 

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.43.0'
-  s.date              = '2015-01-09'
+  s.version           = '0.44.0'
+  s.date              = '2015-01-30'
   s.rubyforge_project = 'excon'
 
   ## Make sure your summary is short. The description may be as long
@@ -56,12 +56,13 @@ Gem::Specification.new do |s|
   # s.add_development_dependency('DEVDEPNAME', [">= 1.1.0", "< 2.0.0"])
   s.add_development_dependency('activesupport')
   s.add_development_dependency('delorean')
-  s.add_development_dependency('eventmachine')
+  s.add_development_dependency('eventmachine', '>= 1.0.4')
   s.add_development_dependency('open4')
   s.add_development_dependency('rake')
   s.add_development_dependency('rdoc')
   s.add_development_dependency('shindo')
   s.add_development_dependency('sinatra')
+  s.add_development_dependency('json', '>= 1.8.2')
 
   ## Leave this section as-is. It will be automatically generated from the
   ## contents of your Git repository via the gemspec task. DO NOT REMOVE
@@ -100,6 +101,7 @@ Gem::Specification.new do |s|
     lib/excon/connection.rb
     lib/excon/constants.rb
     lib/excon/errors.rb
+    lib/excon/extensions/uri.rb
     lib/excon/headers.rb
     lib/excon/middlewares/base.rb
     lib/excon/middlewares/decompress.rb

data/lib/excon.rb

@@ -11,6 +11,8 @@ require 'uri'
 require 'zlib'
 require 'stringio'
 
+require 'excon/extensions/uri'
+
 require 'excon/middlewares/base'
 require 'excon/middlewares/expects'
 require 'excon/middlewares/idempotent'
@@ -50,8 +52,8 @@ module Excon
     end
 
     def display_warning(warning)
-      # Respect Ruby's $VERBOSE setting, unless EXCON_DEBUG is set
-      if !$VERBOSE.nil? || ENV['EXCON_DEBUG']
+      # Show warning if $VERBOSE or ENV['EXCON_DEBUG'] is set
+      if $VERBOSE || ENV['EXCON_DEBUG']
         $stderr.puts '[excon][WARNING] ' << warning << "\n#{ caller.join("\n") }"
       end
     end
@@ -102,18 +104,19 @@ module Excon
     #   @param [Hash<Symbol, >] params One or more option params to set on the Connection instance
     #   @return [Connection] A new Excon::Connection instance
     def new(url, params = {})
-      uri_parser = params[:uri_parser] || Excon.defaults[:uri_parser]
+      uri_parser = params[:uri_parser] || defaults[:uri_parser]
       uri = uri_parser.parse(url)
       unless uri.scheme
         raise ArgumentError.new("Invalid URI: #{uri}")
       end
       params = {
         :host       => uri.host,
+        :hostname   => uri.hostname,
         :path       => uri.path,
         :port       => uri.port,
         :query      => uri.query,
         :scheme     => uri.scheme
-      }.merge!(params)
+      }.merge(params)
       if uri.password
         params[:password] = Utils.unescape_uri(uri.password)
       end

data/lib/excon/connection.rb

@@ -35,7 +35,8 @@ module Excon
     #   @param [Hash<Symbol, >] params One or more optional params
     #     @option params [String] :body Default text to be sent over a socket. Only used if :body absent in Connection#request params
     #     @option params [Hash<Symbol, String>] :headers The default headers to supply in a request. Only used if params[:headers] is not supplied to Connection#request
-    #     @option params [String] :host The destination host's reachable DNS name or IP, in the form of a String
+    #     @option params [String] :host The destination host's reachable DNS name or IP, in the form of a String. IPv6 addresses must be wrapped (e.g. [::1]).  See URI#host.
+    #     @option params [String] :hostname Same as host, but usable for socket connections. IPv6 addresses must not be wrapped (e.g. ::1).  See URI#hostname.
     #     @option params [String] :path Default path; appears after 'scheme://host:port/'. Only used if params[:path] is not supplied to Connection#request
     #     @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
@@ -358,6 +359,12 @@ module Excon
         #params = params.dup
         #invalid_keys.each {|key| params.delete(key) }
       end
+
+      if validation == :connection && params.key?(:host) && !params.key?(:hostname)
+        Excon.display_warning('hostname is missing! For IPv6 support, provide both host and hostname: Excon::Connection#new(:host => uri.host, :hostname => uri.hostname, ...).')
+        params[:hostname] = params[:host]
+      end
+
       params
     end
 
@@ -421,6 +428,7 @@ module Excon
           uri = @data[:proxy].is_a?(String) ? URI.parse(@data[:proxy]) : @data[:proxy]
           @data[:proxy] = {
             :host       => uri.host,
+            :hostname   => uri.hostname,
             # path is only sensible for a Unix socket proxy
             :path       => uri.scheme == UNIX ? uri.path : nil,
             :port       => uri.port,

data/lib/excon/constants.rb

@@ -1,6 +1,6 @@
 module Excon
 
-  VERSION = '0.43.0'
+  VERSION = '0.44.0'
 
   CR_NL = "\r\n"
 
@@ -73,6 +73,7 @@ module Excon
     :connect_timeout,
     :family,
     :host,
+    :hostname,
     :omit_default_port,
     :nonblock,
     :reuseaddr,

data/lib/excon/errors.rb

@@ -79,6 +79,7 @@ module Excon
     class RequestedRangeNotSatisfiable < ClientError; end     # 416
     class ExpectationFailed < ClientError; end                # 417
     class UnprocessableEntity < ClientError; end              # 422
+    class TooManyRequests < ClientError; end                  # 429
     class InternalServerError < ServerError; end              # 500
     class NotImplemented < ServerError; end                   # 501
     class BadGateway < ServerError; end                       # 502
@@ -123,6 +124,7 @@ module Excon
         416 => [Excon::Errors::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
         417 => [Excon::Errors::ExpectationFailed, 'Expectation Failed'],
         422 => [Excon::Errors::UnprocessableEntity, 'Unprocessable Entity'],
+        429 => [Excon::Errors::TooManyRequests, 'Too Many Requests'],
         500 => [Excon::Errors::InternalServerError, 'InternalServerError'],
         501 => [Excon::Errors::NotImplemented, 'Not Implemented'],
         502 => [Excon::Errors::BadGateway, 'Bad Gateway'],

data/lib/excon/extensions/uri.rb

@@ -0,0 +1,33 @@
+# TODO: Remove this monkey patch once ruby 1.9.3+ is the minimum supported version.
+#
+# This patch backports URI#hostname to ruby 1.9.2 and older.
+# URI#hostname is used for IPv6 support in Excon.
+#
+# URI#hostname was added in stdlib in v1_9_3_0 in this commit:
+#   https://github.com/ruby/ruby/commit/5fd45a4b79dd26f9e7b6dc41142912df911e4d7d
+#
+# Addressable::URI is also an URI parser accepted in some parts of Excon.
+# Addressable::URI#hostname was added in addressable-2.3.5+ in this commit:
+#   https://github.com/sporkmonger/addressable/commit/1b94abbec1f914d5f707c92a10efbb9e69aab65e
+#
+# Users who want to use Addressable::URI to parse URIs must upgrade to 2.3.5 or newer.
+require 'uri'
+unless URI("http://foo/bar").respond_to?(:hostname)
+  module URI
+    class Generic
+      # extract the host part of the URI and unwrap brackets for IPv6 addresses.
+      #
+      # This method is same as URI::Generic#host except
+      # brackets for IPv6 (and future IP) addresses are removed.
+      #
+      # u = URI("http://[::1]/bar")
+      # p u.hostname      #=> "::1"
+      # p u.host          #=> "[::1]"
+      #
+      def hostname
+        v = self.host
+        /\A\[(.*)\]\z/ =~ v ? $1 : v
+      end
+    end
+  end
+end

data/lib/excon/middlewares/redirect_follower.rb

@@ -26,6 +26,7 @@ module Excon
             params.merge!(
               :scheme     => uri.scheme || datum[:scheme],
               :host       => uri.host   || datum[:host],
+              :hostname   => uri.hostname || datum[:hostname],
               :port       => uri.port   || datum[:port],
               :path       => uri.path,
               :query      => uri.query

data/lib/excon/socket.rb

@@ -10,6 +10,7 @@ module Excon
       Excon.display_warning('Excon::Socket#params is deprecated use Excon::Socket#data instead.')
       @data
     end
+
     def params=(new_params)
       Excon.display_warning('Excon::Socket#params= is deprecated use Excon::Socket#data= instead.')
       @data = new_params
@@ -24,118 +25,59 @@ module Excon
       @nonblock = data[:nonblock]
       @read_buffer = ''
       @eof = false
-
       connect
     end
 
-    def read(max_length=nil)
+    def read(max_length = nil)
       if @eof
         return max_length ? nil : ''
       elsif @nonblock
-        begin
-          if max_length
-            until @read_buffer.length >= max_length
-              @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
-            end
-          else
-            while true
-              @read_buffer << @socket.read_nonblock(@data[:chunk_size])
-            end
-          end
-        rescue OpenSSL::SSL::SSLError => error
-          if error.message == 'read would block'
-            if IO.select([@socket], nil, nil, @data[:read_timeout])
-              retry
-            else
-              raise(Excon::Errors::Timeout.new("read timeout reached"))
-            end
-          else
-            raise(error)
-          end
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
-          if @read_buffer.empty?
-            # if we didn't read anything, try again...
-            if IO.select([@socket], nil, nil, @data[:read_timeout])
-              retry
-            else
-              raise(Excon::Errors::Timeout.new("read timeout reached"))
-            end
-          end
-        rescue EOFError
-          @eof = true
-        end
+        read_nonblock(max_length)
+      else
+        read_block(max_length)
+      end
+    end
 
-        if max_length
-          if @read_buffer.empty?
-            nil # EOF met at beginning
-          else
-            @read_buffer.slice!(0, max_length)
-          end
+    def readline
+      return legacy_readline if RUBY_VERSION.to_f <= 1.8_7
+      begin
+        buffer = ''
+        buffer << @socket.read_nonblock(1) while buffer[-1] != "\n"
+        buffer
+      rescue Errno::EAGAIN
+        if timeout_reached('read')
+          raise_timeout_error('read')
         else
-          # read until EOFError, so return everything
-          @read_buffer.slice!(0, @read_buffer.length)
+          retry
         end
-      else
-        begin
-          Timeout.timeout(@data[:read_timeout]) do
-            @socket.read(max_length)
+      rescue OpenSSL::SSL::SSLError => e
+        if e.message == 'read would block'
+          if timeout_reached('read')
+            raise_timeout_error('read')
+          else
+            retry
           end
-        rescue Timeout::Error
-          raise Excon::Errors::Timeout.new('read timeout reached')
+        else
+          raise(error)
         end
       end
     end
 
-    def readline
-      begin
+    def legacy_readline
+       begin
         Timeout.timeout(@data[:read_timeout]) do
           @socket.readline
-        end
+      end
       rescue Timeout::Error
-        raise Excon::Errors::Timeout.new('read timeout reached')
+      raise Excon::Errors::Timeout.new('read timeout reached')
       end
     end
 
     def write(data)
       if @nonblock
-        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, 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')
-              end
-            end
-          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
+        write_nonblock(data)
       else
-        begin
-          Timeout.timeout(@data[:write_timeout]) do
-            @socket.write(data)
-          end
-        rescue Timeout::Error
-          raise(Excon::Errors::Timeout.new('write timeout reached'))
-        end
+        write_block(data)
       end
     end
 
@@ -155,10 +97,10 @@ module Excon
 
       if @data[:proxy]
         family = @data[:proxy][:family] || ::Socket::Constants::AF_UNSPEC
-        args = [@data[:proxy][:host], @data[:proxy][:port], family, ::Socket::Constants::SOCK_STREAM]
+        args = [@data[:proxy][:hostname], @data[:proxy][:port], family, ::Socket::Constants::SOCK_STREAM]
       else
         family = @data[:family] || ::Socket::Constants::AF_UNSPEC
-        args = [@data[:host], @data[:port], family, ::Socket::Constants::SOCK_STREAM]
+        args = [@data[:hostname], @data[:port], family, ::Socket::Constants::SOCK_STREAM]
       end
       if RUBY_VERSION >= '1.9.2' && defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
         args << nil << nil << false # no reverse lookup
@@ -181,27 +123,19 @@ module Excon
             end
           end
 
-          begin
-            Timeout.timeout(@data[:connect_timeout]) do
-              if @nonblock
-                socket.connect_nonblock(sockaddr)
-              else
-                socket.connect(sockaddr)
-              end
-            end
-          rescue Timeout::Error
-            raise Excon::Errors::Timeout.new('connect timeout reached')
+          if @nonblock
+            socket.connect_nonblock(sockaddr)
+          else
+            socket.connect(sockaddr)
           end
-
           @socket = socket
           break
         rescue Errno::EINPROGRESS
           unless IO.select(nil, [socket], nil, @data[:connect_timeout])
-            raise(Excon::Errors::Timeout.new("connect timeout reached"))
+            raise(Excon::Errors::Timeout.new('connect timeout reached'))
           end
           begin
             socket.connect_nonblock(sockaddr)
-
             @socket = socket
             break
           rescue Errno::EISCONN
@@ -217,10 +151,8 @@ module Excon
         end
       end
 
-      unless @socket
-        # this will be our last encountered exception
-        raise exception
-      end
+      # this will be our last encountered exception
+      fail exception unless @socket
 
       if @data[:tcp_nodelay]
         @socket.setsockopt(::Socket::IPPROTO_TCP,
@@ -229,6 +161,136 @@ module Excon
       end
     end
 
+    def read_nonblock(max_length)
+      begin
+            if max_length
+              until @read_buffer.length >= max_length
+                @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
+              end
+            else
+              loop do
+                @read_buffer << @socket.read_nonblock(@data[:chunk_size])
+              end
+            end
+          rescue OpenSSL::SSL::SSLError => error
+            if error.message == 'read would block'
+              if timeout_reached('read')  
+                raise_timeout_error('read') 
+              else 
+                retry
+              end
+            else
+              raise(error)
+            end
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+            if @read_buffer.empty?
+              # if we didn't read anything, try again...
+              if timeout_reached('read') 
+                raise_timeout_error('read') 
+              else
+                retry
+              end
+            end
+          rescue EOFError
+            @eof = true
+          end
+
+      if max_length
+        if @read_buffer.empty?
+          nil # EOF met at beginning
+        else
+          @read_buffer.slice!(0, max_length)
+        end
+      else
+        # read until EOFError, so return everything
+        @read_buffer.slice!(0, @read_buffer.length)
+      end
+    end
+
+    def read_block(max_length)
+      @socket.read(max_length)
+    rescue OpenSSL::SSL::SSLError => error
+      if error.message == 'read would block'
+        if timeout_reached('read') 
+          raise_timeout_error('read') 
+        else
+          retry
+        end
+      else
+        raise(error)
+      end
+    rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+      if @read_buffer.empty?
+        if timeout_reached('read') 
+          raise_timeout_error('read') 
+        else
+          retry
+        end
+      end
+    rescue EOFError
+      @eof = true
+    end
+
+    def write_nonblock(data)
+      if FORCE_ENC
+        data.force_encoding('BINARY')
+          end
+      loop do
+        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, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
+          if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
+            raise error
+          else
+            if timeout_reached('write') 
+              raise_timeout_error('write') 
+            else 
+              retry
+            end
+          end
+        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
+    end
+
+    def write_block(data)
+      @socket.write(data)
+    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 timeout_reached('write') 
+          raise_timeout_error('write') 
+        else
+          retry
+        end
+      end
+    end
+
+    def timeout_reached(type)
+      if type == 'read'
+        args = [[@socket], nil, nil, @data[:read_timeout]]
+      else
+        args = [nil, [@socket], nil, @data[:write_timeout]]
+      end
+      IO.select(*args) ? nil : true
+    end
+
+    def raise_timeout_error(type)
+      fail Excon::Errors::Timeout.new("#{type} timeout reached")
+    end
+
     def unpacked_sockaddr
       @unpacked_sockaddr ||= ::Socket.unpack_sockaddr_in(@socket.to_io.getsockname)
     rescue ArgumentError => e
@@ -236,6 +298,5 @@ module Excon
         raise
       end
     end
-
   end
 end

data/lib/excon/ssl_socket.rb

@@ -1,9 +1,8 @@
 module Excon
   class SSLSocket < Socket
-
-    HAVE_NONBLOCK = [:connect_nonblock, :read_nonblock, :write_nonblock].all? {|m|
+    HAVE_NONBLOCK = [:connect_nonblock, :read_nonblock, :write_nonblock].all? do |m|
       OpenSSL::SSL::SSLSocket.public_method_defined?(m)
-    }
+    end
 
     def initialize(data = {})
       super
@@ -16,6 +15,7 @@ module Excon
       if defined?(OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS)
         ssl_context_options &= ~OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
       end
+
       if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
         ssl_context_options |= OpenSSL::SSL::OP_NO_COMPRESSION
       end
@@ -25,6 +25,7 @@ module Excon
       if @data[:ssl_version]
         ssl_context.ssl_version = @data[:ssl_version]
       end
+
       if @data[:ssl_verify_peer]
         # turn verification on
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
@@ -46,11 +47,11 @@ module Excon
 
           # workaround issue #257 (JRUBY-6970)
           ca_file = DEFAULT_CA_FILE
-          ca_file.gsub!(/^jar:/, "") if ca_file =~ /^jar:file:\//
+          ca_file.gsub!(/^jar:/, '') if ca_file =~ /^jar:file:\//
 
           begin
             ssl_context.cert_store.add_file(ca_file)
-          rescue => e
+          rescue
             Excon.display_warning("Excon unable to add file to cert store, ignoring: #{ca_file}\n[#{e.class}] #{e.message}")
           end
         end
@@ -75,7 +76,7 @@ module Excon
         else
           ssl_context.key = OpenSSL::PKey::RSA.new(File.read(private_key_path), private_key_pass)
         end
-      elsif @data.has_key?(:certificate) && @data.has_key?(:private_key)
+      elsif @data.key?(:certificate) && @data.key?(:private_key)
         ssl_context.cert = OpenSSL::X509::Certificate.new(@data[:certificate])
         if OpenSSL::PKey.respond_to? :read
           ssl_context.key = OpenSSL::PKey.read(@data[:private_key], private_key_pass)
@@ -90,7 +91,7 @@ module Excon
 
         if @data[:proxy][:password] || @data[:proxy][:user]
           auth = ['' << @data[:proxy][:user].to_s << ':' << @data[:proxy][:password].to_s].pack('m').delete(Excon::CR_NL)
-          request << "Proxy-Authorization: Basic " << auth << Excon::CR_NL
+          request << 'Proxy-Authorization: Basic ' << auth << Excon::CR_NL
         end
 
         request << 'Proxy-Connection: Keep-Alive' << Excon::CR_NL
@@ -101,7 +102,7 @@ module Excon
         @socket.write(request)
 
         # eat the proxy's connection response
-        Excon::Response.parse(self, { :expects => 200, :method => "CONNECT" })
+        Excon::Response.parse(self,  :expects => 200, :method => 'CONNECT')
       end
 
       # convert Socket to OpenSSL::SSL::SSLSocket
@@ -114,24 +115,22 @@ module Excon
       end
 
       begin
-        Timeout.timeout(@data[:connect_timeout]) do
-          if @nonblock
-            while true
-              begin
-                @socket.connect_nonblock
-                break # connect succeeded
-              rescue OpenSSL::SSL::SSLError => error
-                # would block, rescue and retry as select is non-helpful
-                unless error.message == 'read would block'
-                  raise error
-                end
-              end
+        if @nonblock
+          loop do
+            begin
+              @socket.connect_nonblock
+              break # connect succeeded
+            rescue OpenSSL::SSL::SSLError => error
+              # would block, rescue and retry as select is non-helpful
+              raise error unless error.message == 'read would block'
             end
-          else
-            @socket.connect
           end
+        else
+          @socket.connect
         end
-      rescue Timeout::Error
+      rescue OpenSSL::SSL::SSLError => e
+        raise e
+      rescue
         raise Excon::Errors::Timeout.new('connect timeout reached')
       end
 
@@ -150,6 +149,5 @@ module Excon
       @nonblock = HAVE_NONBLOCK && @nonblock
       super
     end
-
   end
 end

data/lib/excon/utils.rb

@@ -64,27 +64,21 @@ module Excon
 
     # Escapes HTTP reserved and unwise characters in +str+
     def escape_uri(str)
-      str = str.dup
       str.force_encoding('BINARY') if FORCE_ENC
-      str.gsub!(UNESCAPED) { "%%%02X" % $1[0].ord }
-      str
+      str.gsub(UNESCAPED) { "%%%02X" % $1[0].ord }
     end
 
     # Unescapes HTTP reserved and unwise characters in +str+
     def unescape_uri(str)
-      str = str.dup
       str.force_encoding('BINARY') if FORCE_ENC
-      str.gsub!(ESCAPED) { $1.hex.chr }
-      str
+      str.gsub(ESCAPED) { $1.hex.chr }
     end
 
     # Unescape form encoded values in +str+
     def unescape_form(str)
-      str = str.dup
       str.force_encoding('BINARY') if FORCE_ENC
       str.gsub!(/\+/, ' ')
-      str.gsub!(ESCAPED) { $1.hex.chr }
-      str
+      str.gsub(ESCAPED) { $1.hex.chr }
     end
   end
 end

data/tests/basic_tests.rb

@@ -6,6 +6,7 @@ Shindo.tests('Excon basics') do
       tests('GET /content-length/100').returns(200) do
         connection = Excon::Connection.new({
           :host             => '127.0.0.1',
+          :hostname         => '127.0.0.1',
           :nonblock         => false,
           :port             => 9292,
           :scheme           => 'http',
@@ -169,6 +170,7 @@ Shindo.tests('Excon basics (ssl file)',['focus']) do
     tests('GET /content-length/100').raises(Excon::Errors::SocketError) do
       connection = Excon::Connection.new({
         :host             => '127.0.0.1',
+        :hostname         => '127.0.0.1',
         :nonblock         => false,
         :port             => 8443,
         :scheme           => 'https',
@@ -191,6 +193,7 @@ Shindo.tests('Excon basics (ssl file paths)',['focus']) do
     tests('GET /content-length/100').raises(Excon::Errors::SocketError) do
       connection = Excon::Connection.new({
         :host             => '127.0.0.1',
+        :hostname         => '127.0.0.1',
         :nonblock         => false,
         :port             => 8443,
         :scheme           => 'https',

data/tests/middlewares/escape_path_tests.rb

@@ -5,6 +5,7 @@ Shindo.tests('Excon Decompress Middleware') do
       tests('GET /echo%20dirty').returns(200) do
         connection = Excon::Connection.new({
           :host             => '127.0.0.1',
+          :hostname         => '127.0.0.1',
           :middlewares      => Excon.defaults[:middlewares] + [Excon::Middleware::EscapePath],
           :nonblock         => false,
           :port             => 9292,
@@ -20,6 +21,7 @@ Shindo.tests('Excon Decompress Middleware') do
       tests('GET /echo dirty').returns(200) do
         connection = Excon::Connection.new({
           :host             => '127.0.0.1',
+          :hostname         => '127.0.0.1',
           :middlewares      => Excon.defaults[:middlewares] + [Excon::Middleware::EscapePath],
           :nonblock         => false,
           :port             => 9292,

data/tests/request_tests.rb

@@ -2,55 +2,58 @@ Shindo.tests('Request Tests') do
   with_server('good') do
 
     tests('persistent connections') do
+      ip_ports = %w(127.0.0.1:9292)
+      ip_ports << "[::1]:9293" unless RUBY_PLATFORM == 'java'
+      ip_ports.each do |ip_port|
+
+        tests("with default :persistent => true, #{ip_port}") do
+          connection = nil
+
+          returns(['1', '2'], 'uses a persistent connection') do
+            connection = Excon.new("http://#{ip_port}", :persistent => true)
+            2.times.map do
+              connection.request(:method => :get, :path => '/echo/request_count').body
+            end
+          end
 
-      tests('with default :persistent => true') do
-        connection = nil
-
-        returns(['1', '2'], 'uses a persistent connection') do
-          connection = Excon.new('http://127.0.0.1:9292', :persistent => true)
-          2.times.map do
-            connection.request(:method => :get, :path => '/echo/request_count').body
+          returns(['3', '1', '2'], ':persistent => false resets connection') do
+            ret = []
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count',
+                                      :persistent => false).body
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count').body
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count').body
           end
         end
 
-        returns(['3', '1', '2'], ':persistent => false resets connection') do
-          ret = []
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count',
-                                    :persistent => false).body
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count').body
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count').body
-        end
-      end
+        tests("with default :persistent => false, #{ip_port}") do
+          connection = nil
 
-      tests('with default :persistent => false') do
-        connection = nil
+          returns(['1', '1'], 'does not use a persistent connection') do
+            connection = Excon.new("http://#{ip_port}", :persistent => false)
+            2.times.map do
+              connection.request(:method => :get, :path => '/echo/request_count').body
+            end
+          end
 
-        returns(['1', '1'], 'does not use a persistent connection') do
-          connection = Excon.new('http://127.0.0.1:9292', :persistent => false)
-          2.times.map do
-            connection.request(:method => :get, :path => '/echo/request_count').body
+          returns(['1', '2', '3', '1'], ':persistent => true enables persistence') do
+            ret = []
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count',
+                                      :persistent => true).body
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count',
+                                      :persistent => true).body
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count').body
+            ret << connection.request(:method => :get,
+                                      :path   => '/echo/request_count').body
           end
         end
 
-        returns(['1', '2', '3', '1'], ':persistent => true enables persistence') do
-          ret = []
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count',
-                                    :persistent => true).body
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count',
-                                    :persistent => true).body
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count').body
-          ret << connection.request(:method => :get,
-                                    :path   => '/echo/request_count').body
-        end
       end
-
     end
-
   end
 end

data/tests/servers/good.rb

@@ -333,5 +333,6 @@ end
 
 EM.run do
   EM.start_server("127.0.0.1", 9292, GoodServer)
+  EM.start_server("::1", 9293, GoodServer) unless RUBY_PLATFORM == 'java'
   $stderr.puts "ready"
 end

data/tests/utils_tests.rb

@@ -65,4 +65,17 @@ Shindo.tests('Excon::Utils') do
     end
 
   end
+
+  tests('#escape_uri').returns('/hello%20excon') do
+    Excon::Utils.escape_uri('/hello excon')
+  end
+
+  tests('#unescape_uri').returns('/hello excon') do
+    Excon::Utils.unescape_uri('/hello%20excon')
+  end
+
+  tests('#unescape_form').returns('message=We love excon!') do
+    Excon::Utils.unescape_form('message=We+love+excon!')
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excon
 version: !ruby/object:Gem::Version
-  version: 0.43.0
+  version: 0.44.0
 platform: ruby
 authors:
 - dpiddy (Dan Peterson)
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2015-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -46,14 +46,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.4
 - !ruby/object:Gem::Dependency
   name: open4
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +124,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
 description: EXtended http(s) CONnections
 email: geemus@gmail.com
 executables: []
@@ -163,6 +177,7 @@ files:
 - lib/excon/connection.rb
 - lib/excon/constants.rb
 - lib/excon/errors.rb
+- lib/excon/extensions/uri.rb
 - lib/excon/headers.rb
 - lib/excon/middlewares/base.rb
 - lib/excon/middlewares/decompress.rb