excon 0.38.0 → 0.39.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2Q1NWY3Zjk1ZmMzZTc5ZTFjODAzZGMyZmUwMTljYTkyYTFjNjAxMw==
+    YzFlMDNlOTJjZTE5MGExNDI4OWNiNWIyZDNkZTZmNWQ4MjA0M2RkOQ==
   data.tar.gz: !binary |-
-    NjFkNTZhNTlmMGFkN2MwNjJjNDEzZjM2MGYyYjg3OTNhNTM5NjM5Yw==
+    ZmZkMzdhZTA0MWNiZWU3MWU0MTMyMzU1Y2QzYWMzOGE2NzcyNjdjNg==
 SHA512:
   metadata.gz: !binary |-
-    NjE0NGE3NzdiMDA4YTg0NWIyNDMxNGMyMDBiY2I4MDkzZjRjYWU4NzE1Nzhl
-    Yjk5N2YyYjRlYzdlMDBlM2VhYTU1MTQ4OTU5Zjc2YTc4OWY1OWMwMTNjODdm
-    ZDkxZWVhODdiYmVkNzgzMGU2MGY1NjNmMjBhOTQ2MThmNWQzNGY=
+    MDc2MTgzZWEwMzIwNDA0MzM1Mjk4NTM5MGNlODU1YmYwNmUyNGRlM2EyZmY5
+    YWZmNTI1YzhmZjI2MjViOWE2NGVjNjY4YWRjOTY1YzI5YmZjMTM3NGZiNTY1
+    YjM2NjM5ZDUyY2EyMDRjMjgxMWYxMWE2YjNjZWFlZTY0YzgzZWI=
   data.tar.gz: !binary |-
-    NWQ5OTYyMzhlNzMwZWRlMGY1ODUxMWFkZjU0MWQ1MmRiMjUyMGNjMDA1ZjIw
-    ZjI2YTlhNzZiN2Y1ODg4MGFjMTNjNDljMmU5NzFiNmFhNzMyMjk1YTQxMzg0
-    YjdhYWNlZmUwYjI4MTc1ZTU2NDAwNThlMjljODVjMTc1ZjIyNTg=
+    NDk1YTIzM2RhZjJmY2ViYzBhMGY2Y2FkYTViNzRmMzBhOTZjMjgxNDEyMjMw
+    MTgwMGNiYzcyYmVlY2U0NGRlZTE4OTA1ZWVjNGMyNGVhOTgxYmMxNjJlMGYz
+    ZTAwYjg5MjgxYzYxYTA2MmNmNTMzMzQxMzk1MDNjOTkzNTU4Zjg=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    excon (0.38.0)
+    excon (0.39.0)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -85,6 +85,9 @@ Both one-off and persistent connections support many other options. The final op
 Here are a few common examples:
 
 ```ruby
+# Output debug info, similar to ENV['EXCON_DEBUG']
+connection = Excon.new('http://geemus.com/', :debug => true)
+
 # Custom headers
 Excon.get('http://geemus.com', :headers => {'Authorization' => 'Basic 0123456789ABCDEF'})
 connection.get(:headers => {'Authorization' => 'Basic 0123456789ABCDEF'})

data/changelog.txt

@@ -1,3 +1,26 @@
+0.39.0 08/01/2014
+=================
+
+revert to a blocking readline, for performance
+simplify status lookup
+consolidate proxy code
+store defaults as a constant
+avoid setting nil user/pass vs just no setting keys
+move idempotent warnings in to middleware
+simplify validations
+use constants in utils
+group non-chunk response paring
+optimize/simplify socket local lookup
+simplify to pro-actively build downcased headers instead of lazily do so
+add version to options (so it will appear in debug)
+add OS/Ruby version info to options/version for debugging
+more consistent output styling for errors
+remove TE stuff to simplify
+shorten timeout/sleep in streaming tests
+remove transfer-encoding altogether if it only includes chunked
+only rescue http status errors in relevant tests
+use case-insensitive headers in stubs also
+
 0.38.0 07/09/2014
 =================
 

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.38.0'
-  s.date              = '2014-07-09'
+  s.version           = '0.39.0'
+  s.date              = '2014-08-01'
   s.rubyforge_project = 'excon'
 
   ## Make sure your summary is short. The description may be as long
@@ -110,6 +110,7 @@ Gem::Specification.new do |s|
     lib/excon/middlewares/mock.rb
     lib/excon/middlewares/redirect_follower.rb
     lib/excon/middlewares/response_parser.rb
+    lib/excon/pretty_printer.rb
     lib/excon/response.rb
     lib/excon/socket.rb
     lib/excon/ssl_socket.rb

data/lib/excon.rb

@@ -11,75 +11,44 @@ require 'uri'
 require 'zlib'
 require 'stringio'
 
-# Define defaults first so they will be available to other files
-module Excon
-  class << self
-
-    # @return [Hash] defaults for Excon connections
-    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,
-        :headers            => {
-          'User-Agent' => USER_AGENT
-        },
-        :idempotent         => false,
-        :instrumentor_name  => 'excon',
-        :middlewares        => [
-          Excon::Middleware::ResponseParser,
-          Excon::Middleware::Expects,
-          Excon::Middleware::Idempotent,
-          Excon::Middleware::Instrumentor,
-          Excon::Middleware::Mock
-        ],
-        :mock               => false,
-        :nonblock           => true,
-        :omit_default_port  => false,
-        :persistent         => false,
-        :read_timeout       => 60,
-        :retry_limit        => DEFAULT_RETRY_LIMIT,
-        :ssl_verify_peer    => true,
-        :tcp_nodelay        => false,
-        :uri_parser         => URI,
-        :write_timeout      => 60
-      }
-    end
-
-    # Change defaults for Excon connections
-    # @return [Hash] defaults for Excon connections
-    def defaults=(new_defaults)
-      @defaults = new_defaults
-    end
-
-  end
-end
-
-require 'excon/utils'
-require 'excon/constants'
-require 'excon/connection'
-require 'excon/errors'
 require 'excon/middlewares/base'
-require 'excon/middlewares/decompress'
-require 'excon/middlewares/escape_path'
 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/constants'
+require 'excon/utils'
+
+require 'excon/connection'
+require 'excon/errors'
 require 'excon/headers'
+require 'excon/response'
+require 'excon/middlewares/decompress'
+require 'excon/middlewares/escape_path'
+require 'excon/middlewares/redirect_follower'
+require 'excon/pretty_printer'
 require 'excon/socket'
 require 'excon/ssl_socket'
-require 'excon/unix_socket'
 require 'excon/standard_instrumentor'
+require 'excon/unix_socket'
 
+# Define defaults first so they will be available to other files
 module Excon
   class << self
 
+    # @return [Hash] defaults for Excon connections
+    def defaults
+      @defaults ||= DEFAULTS
+    end
+
+    # Change defaults for Excon connections
+    # @return [Hash] defaults for Excon connections
+    def defaults=(new_defaults)
+      @defaults = new_defaults
+    end
+
     def display_warning(warning)
       # Respect Ruby's $VERBOSE setting, unless EXCON_DEBUG is set
       if !$VERBOSE.nil? || ENV['EXCON_DEBUG']
@@ -135,16 +104,22 @@ module Excon
     def new(url, params = {})
       uri_parser = params[:uri_parser] || Excon.defaults[:uri_parser]
       uri = uri_parser.parse(url)
-      raise ArgumentError.new("Invalid URI: #{uri}") unless uri.scheme
+      unless uri.scheme
+        raise ArgumentError.new("Invalid URI: #{uri}")
+      end
       params = {
         :host       => uri.host,
         :path       => uri.path,
         :port       => uri.port,
         :query      => uri.query,
-        :scheme     => uri.scheme,
-        :user       => (Utils.unescape_uri(uri.user) if uri.user),
-        :password   => (Utils.unescape_uri(uri.password) if uri.password)
+        :scheme     => uri.scheme
       }.merge!(params)
+      if uri.password
+        params[:password] = Utils.unescape_uri(uri.password)
+      end
+      if uri.user
+        params[:user] = Utils.unescape_uri(uri.user)
+      end
       Excon::Connection.new(params)
     end
 
@@ -170,6 +145,13 @@ module Excon
           request_params[:headers]['Authorization'] ||= 'Basic ' << ['' << user << ':' << pass].pack('m').delete(Excon::CR_NL)
         end
       end
+      if request_params.has_key?(:headers)
+        headers = Excon::Headers.new
+        request_params[:headers].each do |key, value|
+          headers[key] = value
+        end
+        request_params[:headers] = headers
+      end
       if block_given?
         if response_params
           raise(ArgumentError.new("stub requires either response_params OR a block"))

data/lib/excon/connection.rb

@@ -57,40 +57,19 @@ module Excon
       params = validate_params(:connection, params)
       @data.merge!(params)
 
-      unless @data[:scheme] == UNIX
-        no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"] || ""
-        no_proxy_list = no_proxy_env.scan(/\*?\.?([^\s,:]+)(?::(\d+))?/i).map { |s| [s[0], s[1]] }
-        unless no_proxy_list.index { |h| /(^|\.)#{h[0]}$/.match(@data[:host]) && (h[1].nil? || h[1].to_i == @data[:port]) }
-          if @data[:scheme] == HTTPS && (ENV.has_key?('https_proxy') || ENV.has_key?('HTTPS_PROXY'))
-            @data[:proxy] = setup_proxy(ENV['https_proxy'] || ENV['HTTPS_PROXY'])
-          elsif (ENV.has_key?('http_proxy') || ENV.has_key?('HTTP_PROXY'))
-            @data[:proxy] = setup_proxy(ENV['http_proxy'] || ENV['HTTP_PROXY'])
-          elsif @data.has_key?(:proxy)
-            @data[:proxy] = setup_proxy(@data[:proxy])
-          end
-        end
-      end
+      setup_proxy
 
-      if @data[:proxy] && @data[:scheme] == 'http'
-        @data[:headers]['Proxy-Connection'] ||= 'Keep-Alive'
-        # https credentials happen in handshake
-        if @data[:proxy][:user] || @data[:proxy][:password]
-          user, pass = Utils.unescape_form(@data[:proxy][:user].to_s), Utils.unescape_form(@data[:proxy][:password].to_s)
-          auth = ['' << user.to_s << ':' << pass.to_s].pack('m').delete(Excon::CR_NL)
-          @data[:headers]['Proxy-Authorization'] = 'Basic ' << auth
-        end
+      if  ENV.has_key?('EXCON_STANDARD_INSTRUMENTOR')
+        @data[:instrumentor] = Excon::StandardInstrumentor
       end
 
-      if ENV.has_key?('EXCON_DEBUG') || ENV.has_key?('EXCON_STANDARD_INSTRUMENTOR')
+      if @data[:debug] != false && @data[:debug] || ENV.has_key?('EXCON_DEBUG')
+        @data[:debug_request] = @data[:debug_response] = true
         @data[:instrumentor] = Excon::StandardInstrumentor
-
-        if ENV.has_key?('EXCON_DEBUG')
-          @data[:debug_request] = @data[:debug_response] = true
-        end
       end
 
       # Use Basic Auth if url contains a login
-      if @data[:user] || @data[:password]
+      if @data.has_key?(:user) || @data.has_key?(:password)
         user, pass = Utils.unescape_form(@data[:user].to_s), Utils.unescape_form(@data[:password].to_s)
         @data[:headers]['Authorization'] ||= 'Basic ' << ['' << user.to_s << ':' << pass.to_s].pack('m').delete(Excon::CR_NL)
       end
@@ -151,13 +130,6 @@ module Excon
             end
           end
 
-          if datum[:response_block]
-            datum[:headers]['TE'] = 'trailers'
-          else
-            datum[:headers]['TE'] = 'trailers, deflate, gzip'
-          end
-          datum[:headers]['Connection'] = datum[:persistent] ? 'TE' : 'TE, close'
-
           # add headers to request
           datum[:headers].each do |key, values|
             [values].flatten.each do |value|
@@ -248,17 +220,6 @@ module Excon
         datum[:response_block] = Proc.new
       end
 
-      if datum[:idempotent]
-        if datum[:request_block]
-          Excon.display_warning('Excon requests with a :request_block can not be :idempotent.')
-          datum[:idempotent] = false
-        end
-        if datum[:pipeline]
-          Excon.display_warning("Excon requests can not be :idempotent when pipelining.")
-          datum[:idempotent] = false
-        end
-      end
-
       datum[:connection] = self
 
       datum[:stack] = datum[:middlewares].map do |middleware|
@@ -273,7 +234,7 @@ module Excon
 
         if datum[:persistent]
           if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
-            if split_header_value(datum[:response][:headers][key]).any? {|t| t.casecmp('close') == 0 }
+            if datum[:response][:headers][key].casecmp('close') == 0
               reset
             end
           end
@@ -309,7 +270,7 @@ module Excon
 
       if @data[:persistent]
         if key = responses.last[:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
-          if split_header_value(responses.last[:headers][key]).any? {|t| t.casecmp('close') == 0 }
+          if responses.last[:headers][key].casecmp('close') == 0
             reset
           end
         end
@@ -384,9 +345,9 @@ module Excon
     def validate_params(validation, params)
       valid_keys = case validation
       when :connection
-        valid_connection_keys(params)
+        Excon::VALID_CONNECTION_KEYS
       when :request
-        valid_request_keys(params)
+        Excon::VALID_REQUEST_KEYS
       end
       invalid_keys = params.keys - valid_keys
       unless invalid_keys.empty?
@@ -423,22 +384,48 @@ module Excon
       Thread.current[:_excon_sockets] ||= {}
     end
 
-    def setup_proxy(proxy)
-      case proxy
-      when String
-        uri = URI.parse(proxy)
-        unless uri.host and uri.port and uri.scheme
-          raise Excon::Errors::ProxyParseError, "Proxy is invalid"
+    def setup_proxy
+      unless @data[:scheme] == UNIX
+        if no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"]
+          no_proxy_list = no_proxy_env.scan(/\*?\.?([^\s,:]+)(?::(\d+))?/i).map { |s| [s[0], s[1]] }
+        end
+
+        unless no_proxy_env && no_proxy_list.index { |h| /(^|\.)#{h[0]}$/.match(@data[:host]) && (h[1].nil? || h[1].to_i == @data[:port]) }
+          if @data[:scheme] == HTTPS && (ENV.has_key?('https_proxy') || ENV.has_key?('HTTPS_PROXY'))
+            @data[:proxy] = ENV['https_proxy'] || ENV['HTTPS_PROXY']
+          elsif (ENV.has_key?('http_proxy') || ENV.has_key?('HTTP_PROXY'))
+            @data[:proxy] = ENV['http_proxy'] || ENV['HTTP_PROXY']
+          end
+        end
+
+        case @data[:proxy]
+        when String
+          uri = URI.parse(@data[:proxy])
+          unless uri.host && uri.port && uri.scheme
+            raise Excon::Errors::ProxyParseError, "Proxy is invalid"
+          end
+          @data[:proxy] = {
+            :host       => uri.host,
+            :port       => uri.port,
+            :scheme     => uri.scheme,
+          }
+          if uri.password
+            @data[:proxy][:password] = uri.password
+          end
+          if uri.user
+            @data[:proxy][:user] = uri.user
+          end
+        end
+
+        if @data.has_key?(:proxy) && @data[:scheme] == 'http'
+          @data[:headers]['Proxy-Connection'] ||= 'Keep-Alive'
+          # https credentials happen in handshake
+          if @data[:proxy].has_key?(:user) || @data[:proxy].has_key?(:password)
+            user, pass = Utils.unescape_form(@data[:proxy][:user].to_s), Utils.unescape_form(@data[:proxy][:password].to_s)
+            auth = ['' << user << ':' << pass].pack('m').delete(Excon::CR_NL)
+            @data[:headers]['Proxy-Authorization'] = 'Basic ' << auth
+          end
         end
-        {
-          :host       => uri.host,
-          :password   => uri.password,
-          :port       => uri.port,
-          :scheme     => uri.scheme,
-          :user       => uri.user
-        }
-      else
-        proxy
       end
     end
   end

data/lib/excon/constants.rb

@@ -1,6 +1,6 @@
 module Excon
 
-  VERSION = '0.38.0'
+  VERSION = '0.39.0'
 
   CR_NL = "\r\n"
 
@@ -31,6 +31,8 @@ module Excon
 
   USER_AGENT = 'excon/' << VERSION
 
+  VERSIONS = USER_AGENT + ' (' << RUBY_PLATFORM << ') ruby/' << RUBY_VERSION
+
   VALID_REQUEST_KEYS = [
     :body,
     :captures,
@@ -54,6 +56,7 @@ module Excon
     :response_block,
     :retries_remaining, # used internally
     :retry_limit,
+    :versions,
     :write_timeout
   ]
 
@@ -96,5 +99,36 @@ module Excon
       module WaitWritable; end
     end
   end
+  # these come last as they rely on the above
+  DEFAULTS = {
+    :chunk_size         => CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
+    :ciphers            => 'HIGH:!SSLv2:!aNULL:!eNULL:!3DES',
+    :connect_timeout    => 60,
+    :debug_request      => false,
+    :debug_response     => false,
+    :headers            => {
+      'User-Agent' => USER_AGENT
+    },
+    :idempotent         => false,
+    :instrumentor_name  => 'excon',
+    :middlewares        => [
+      Excon::Middleware::ResponseParser,
+      Excon::Middleware::Expects,
+      Excon::Middleware::Idempotent,
+      Excon::Middleware::Instrumentor,
+      Excon::Middleware::Mock
+    ],
+    :mock               => false,
+    :nonblock           => true,
+    :omit_default_port  => false,
+    :persistent         => false,
+    :read_timeout       => 60,
+    :retry_limit        => DEFAULT_RETRY_LIMIT,
+    :ssl_verify_peer    => true,
+    :tcp_nodelay        => false,
+    :uri_parser         => URI,
+    :versions           => VERSIONS,
+    :write_timeout      => 60
+  }
 
 end

data/lib/excon/errors.rb

@@ -36,7 +36,7 @@ module Excon
         @response = response
       end
     end
-    
+
     # HTTP Error classes
     class Informational < HTTPStatusError; end
     class Success < HTTPStatusError; end
@@ -130,24 +130,23 @@ module Excon
         504 => [Excon::Errors::GatewayTimeout, 'Gateway Timeout']
       }
 
-      error, message = @errors[response[:status]] || [Excon::Errors::HTTPStatusError, 'Unknown']
+      error_class, error_message = @errors[response[:status]] || [Excon::Errors::HTTPStatusError, 'Unknown']
 
-      message = "Expected(#{request[:expects].inspect}) <=> Actual(#{response[:status]} #{message})"
+      message = StringIO.new
+      message.puts("Expected(#{request[:expects].inspect}) <=> Actual(#{response[:status]} #{error_message})")
 
       if request[:debug_request]
-        # scrub authorization
-        req = request.dup
-        req.reject! {|key, value| [:connection, :stack].include?(key)}
-        if req.has_key?(:headers) && req[:headers].has_key?('Authorization')
-          req[:headers] = req[:headers].dup
-          req[:headers]['Authorization'] = REDACTED
-        end
-        message << "\n  request => #{req.inspect}"
+        message.puts('excon.error.request')
+        Excon::PrettyPrinter.pp(message, request)
       end
 
-      message << "\n  response => #{response.inspect}" if request[:debug_response]
+      if request[:debug_response]
+        message.puts('excon.error.response')
+        Excon::PrettyPrinter.pp(message, response.data)
+      end
 
-      error.new(message, request, response)
+      message.rewind
+      error_class.new(message.read, request, response)
     end
 
   end

data/lib/excon/headers.rb

@@ -18,99 +18,52 @@ module Excon
     alias_method :raw_store, :store
     alias_method :raw_values_at, :values_at
 
+    def initialize
+      @downcased = {}
+    end
+
     def [](key)
-      if should_delegate?(key)
-        @downcased[key.downcase]
-      else
-        raw_reader(key)
-      end
+      @downcased[key.downcase]
     end
 
     alias_method :[]=, :store
     def []=(key, value)
       raw_writer(key, value)
-      unless @downcased.nil?
-        @downcased[key.downcase] = value
-      end
+      @downcased[key.downcase] = value
     end
 
     if SENTINEL.respond_to? :assoc
       def assoc(obj)
-        if should_delegate?(obj)
-          @downcased.assoc(obj.downcase)
-        else
-          raw_assoc(obj)
-        end
+        @downcased.assoc(obj.downcase)
       end
     end
 
     def delete(key, &proc)
-      if should_delegate?(key)
-        @downcased.delete(key.downcase, &proc)
-      else
-        raw_delete(key, &proc)
-      end
+      raw_delete(key, &proc)
+      @downcased.delete(key.downcase, &proc)
     end
 
     def fetch(key, default = nil, &proc)
-      if should_delegate?(key)
-        if proc
-          @downcased.fetch(key.downcase, &proc)
-        else
-          @downcased.fetch(key.downcase, default)
-        end
+      if proc
+        @downcased.fetch(key.downcase, &proc)
       else
-        if proc
-          raw_fetch(key, &proc)
-        else
-          raw_fetch(key, default)
-        end
+        @downcased.fetch(key.downcase, default)
       end
     end
 
     alias_method :has_key?, :key?
     alias_method :has_key?, :member?
     def has_key?(key)
-      raw_has_key?(key) || begin
-        index_case_insensitive
-        @downcased.has_key?(key.downcase)
-      end
+      raw_key?(key) || @downcased.has_key?(key.downcase)
     end
 
     def rehash
       raw_rehash
-      if @downcased
-        @downcased.rehash
-      end
+      @downcased.rehash
     end
 
     def values_at(*keys)
-      raw_values_at(*keys).zip(keys).map do |v, k|
-        if v.nil?
-          index_case_insensitive
-          @downcased[k.downcase]
-        end
-      end
-    end
-
-    private
-
-    def should_delegate?(key)
-      if raw_has_key?(key)
-        false
-      else
-        index_case_insensitive
-        true
-      end
-    end
-
-    def index_case_insensitive
-      if @downcased.nil?
-        @downcased = {}
-        each_pair do |key, value|
-          @downcased[key.downcase] = value
-        end
-      end
+      @downcased.values_at(*keys.map {|key| key.downcase})
     end
 
   end

data/lib/excon/middlewares/idempotent.rb

@@ -2,13 +2,23 @@ module Excon
   module Middleware
     class Idempotent < Excon::Middleware::Base
       def error_call(datum)
+        if datum[:idempotent]
+          if datum.has_key?(:request_block)
+            Excon.display_warning('Excon requests with a :request_block can not be :idempotent.')
+            datum[:idempotent] = false
+          end
+          if datum.has_key?(:pipeline)
+            Excon.display_warning("Excon requests can not be :idempotent when pipelining.")
+            datum[:idempotent] = false
+          end
+        end
+
         if datum[:idempotent] && [Excon::Errors::Timeout, Excon::Errors::SocketError,
             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
           connection = datum.delete(:connection)
-          request_keys = Utils.valid_request_keys(datum)
-          datum.reject! {|key, _| !request_keys.include?(key) }
+          datum.reject! {|key, _| !Excon::VALID_REQUEST_KEYS.include?(key) }
           connection.request(datum)
         else
           @stack.error_call(datum)

data/lib/excon/middlewares/response_parser.rb

@@ -4,24 +4,6 @@ module Excon
       def response_call(datum)
         unless datum.has_key?(:response)
           datum = Excon::Response.parse(datum[:connection].send(:socket), datum)
-
-          # only requests without a :response_block add 'deflate, gzip' to the TE header.
-          unless datum[:response_block]
-            if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Transfer-Encoding') == 0 }
-              encodings = Utils.split_header_value(datum[:response][:headers][key])
-              if encoding = encodings.last
-                if encoding.casecmp('deflate') == 0
-                  # assume inflate omits header
-                  datum[:response][:body] = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(datum[:response][:body])
-                  encodings.pop
-                elsif encoding.casecmp('gzip') == 0 || encoding.casecmp('x-gzip') == 0
-                  datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(datum[:response][:body])).read
-                  encodings.pop
-                end
-                datum[:response][:headers][key] = encodings.join(', ')
-              end
-            end
-          end
         end
         @stack.response_call(datum)
       end

data/lib/excon/pretty_printer.rb

@@ -0,0 +1,45 @@
+module Excon
+  class PrettyPrinter
+    def self.pp(io, datum, indent=0)
+      datum = datum.dup
+
+      # reduce duplication/noise of output
+      unless datum.is_a?(Excon::Headers)
+        datum.delete(:connection)
+        datum.delete(:stack)
+
+        if datum.has_key?(:headers) && datum[:headers].has_key?('Authorization')
+          datum[:headers] = datum[:headers].dup
+          datum[:headers]['Authorization'] = REDACTED
+        end
+
+        if datum.has_key?(:password)
+          datum[:password] = REDACTED
+        end
+      end
+
+      indent += 2
+      max_key_length = datum.keys.map {|key| key.inspect.length}.max
+      datum.keys.sort_by {|key| key.to_s}.each do |key|
+        value = datum[key]
+        io.write("#{' ' * indent}#{key.inspect.ljust(max_key_length)} => ")
+        case value
+        when Array
+          io.puts("[")
+          value.each do |v|
+            io.puts("#{' ' * indent}  #{v.inspect}")
+          end
+          io.write("#{' ' * indent}]")
+        when Hash
+          io.puts("{")
+          self.pp(io, value, indent)
+          io.write("#{' ' * indent}}")
+        else
+          io.write("#{value.inspect}")
+        end
+        io.puts
+      end
+      indent -= 2
+    end
+  end
+end

data/lib/excon/response.rb

@@ -37,18 +37,23 @@ module Excon
 
     def self.parse(socket, datum)
       # this will discard any trailing lines from the previous response if any.
-      until match = /^HTTP\/\d+\.\d+\s(\d{3})\s/.match(socket.readline); end
-      status = match[1].to_i
+      until status = socket.readline[9,11].to_i
+      end
 
       datum[:response] = {
         :body          => '',
         :headers       => Excon::Headers.new,
-        :status        => status,
-        :remote_ip     => socket.respond_to?(:remote_ip) && socket.remote_ip,
-        :local_port    => socket.respond_to?(:local_port) && socket.local_port,
-        :local_address => socket.respond_to?(:local_address) && socket.local_address
+        :status        => status
       }
 
+      unless datum[:scheme] == UNIX
+        datum[:response].merge!(
+          :remote_ip     => socket.remote_ip,
+          :local_port    => socket.local_port,
+          :local_address => socket.local_address
+        )
+      end
+
       parse_headers(socket, datum)
 
       unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(datum[:response][:status])
@@ -57,13 +62,11 @@ module Excon
           encodings = Utils.split_header_value(datum[:response][:headers][key])
           if (encoding = encodings.last) && encoding.casecmp('chunked') == 0
             transfer_encoding_chunked = true
-            encodings.pop
-            datum[:response][:headers][key] = encodings.join(', ')
-          end
-        end
-        unless transfer_encoding_chunked
-          if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Length') == 0 }
-            content_length = datum[:response][:headers][key].to_i
+            if encodings.length == 1
+              datum[:response][:headers].delete(key)
+            else
+              datum[:response][:headers][key] = encodings[0...-1].join(', ')
+            end
           end
         end
 
@@ -102,28 +105,34 @@ module Excon
             end
           end
           parse_headers(socket, datum) # merge trailers into headers
-        elsif remaining = content_length
-          if response_block
-            while remaining > 0
-              chunk = socket.read([datum[:chunk_size], remaining].min)
-              response_block.call(chunk, [remaining - chunk.bytesize, 0].max, content_length)
-              remaining -= chunk.bytesize
-            end
-          else
-            while remaining > 0
-              chunk = socket.read([datum[:chunk_size], remaining].min)
-              datum[:response][:body] << chunk
-              remaining -= chunk.bytesize
-            end
-          end
         else
-          if response_block
-            while chunk = socket.read(datum[:chunk_size])
-              response_block.call(chunk, nil, nil)
+          if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Length') == 0 }
+            content_length = datum[:response][:headers][key].to_i
+          end
+
+          if remaining = content_length
+            if response_block
+              while remaining > 0
+                chunk = socket.read([datum[:chunk_size], remaining].min)
+                response_block.call(chunk, [remaining - chunk.bytesize, 0].max, content_length)
+                remaining -= chunk.bytesize
+              end
+            else
+              while remaining > 0
+                chunk = socket.read([datum[:chunk_size], remaining].min)
+                datum[:response][:body] << chunk
+                remaining -= chunk.bytesize
+              end
             end
           else
-            while chunk = socket.read(datum[:chunk_size])
-              datum[:response][:body] << chunk
+            if response_block
+              while chunk = socket.read(datum[:chunk_size])
+                response_block.call(chunk, nil, nil)
+              end
+            else
+              while chunk = socket.read(datum[:chunk_size])
+                datum[:response][:body] << chunk
+              end
             end
           end
         end
@@ -170,6 +179,10 @@ module Excon
       data
     end
 
+    def pp
+      Excon::PrettyPrinter.pp($stdout, @data)
+    end
+
     # Retrieve a specific header value. Header names are treated case-insensitively.
     #   @param [String] name Header name
     def get_header(name)

data/lib/excon/socket.rb

@@ -87,26 +87,12 @@ module Excon
     end
 
     def readline
-      if @eof
-        raise EOFError, 'end of file reached'
-      else
-        line = ''
-        if @nonblock
-          while char = read(1)
-            line << char
-            break if char == $/
-          end
-          raise EOFError, 'end of file reached' if line.empty?
-        else
-          begin
-            Timeout.timeout(@data[:read_timeout]) do
-              line = @socket.readline
-            end
-          rescue Timeout::Error
-            raise Excon::Errors::Timeout.new('read timeout reached')
-          end
+      begin
+        Timeout.timeout(@data[:read_timeout]) do
+          @socket.readline
         end
-        line
+      rescue Timeout::Error
+        raise Excon::Errors::Timeout.new('read timeout reached')
       end
     end
 
@@ -153,16 +139,12 @@ module Excon
       end
     end
 
-    def local_port
-      ::Socket.unpack_sockaddr_in(@socket.to_io.getsockname)[0]
-    rescue ArgumentError => e
-      raise unless e.message == 'not an AF_INET/AF_INET6 sockaddr'
+    def local_address
+      unpacked_sockaddr[1]
     end
 
-    def local_address
-      ::Socket.unpack_sockaddr_in(@socket.to_io.getsockname)[1]
-    rescue ArgumentError => e
-      raise unless e.message == 'not an AF_INET/AF_INET6 sockaddr'
+    def local_port
+      unpacked_sockaddr[0]
     end
 
     private
@@ -247,5 +229,13 @@ module Excon
       end
     end
 
+    def unpacked_sockaddr
+      @unpacked_sockaddr ||= ::Socket.unpack_sockaddr_in(@socket.to_io.getsockname)
+    rescue ArgumentError => e
+      unless e.message == 'not an AF_INET/AF_INET6 sockaddr'
+        raise
+      end
+    end
+
   end
 end

data/lib/excon/standard_instrumentor.rb

@@ -17,32 +17,7 @@ module Excon
       end
 
       $stderr.puts(name)
-      indent = 0
-      pretty_printer = lambda do |hash|
-        indent += 2
-        max_key_length = hash.keys.map {|key| key.inspect.length}.max
-        hash.keys.sort_by {|key| key.to_s}.each do |key|
-          value = hash[key]
-          $stderr.write("#{' ' * indent}#{key.inspect.ljust(max_key_length)} => ")
-          case value
-          when Array
-            $stderr.puts("[")
-            value.each do |v|
-              $stderr.puts("#{' ' * indent}  #{v.inspect}")
-            end
-            $stderr.write("#{' ' * indent}]")
-          when Hash
-            $stderr.puts("{")
-            pretty_printer.call(value)
-            $stderr.write("#{' ' * indent}}")
-          else
-            $stderr.write("#{value.inspect}")
-          end
-          $stderr.puts
-        end
-        indent -= 2
-      end
-      pretty_printer.call(params)
+      Excon::PrettyPrinter.pp($stderr, params)
 
       if block_given?
         yield

data/lib/excon/utils.rb

@@ -2,21 +2,13 @@ module Excon
   module Utils
     extend self
 
-    control   = (0x0..0x1f).map {|c| c.chr }.join + "\x7f"
-    delims    = '<>#%"'
-    unwise    = '{}|\\^[]`'
-    nonascii  = (0x80..0xff).map {|c| c.chr }.join
-    UNESCAPED = /([#{ Regexp.escape(control + ' ' + delims + unwise + nonascii) }])/
+    CONTROL   = (0x0..0x1f).map {|c| c.chr }.join + "\x7f"
+    DELIMS    = '<>#%"'
+    UNWISE    = '{}|\\^[]`'
+    NONASCII  = (0x80..0xff).map {|c| c.chr }.join
+    UNESCAPED = /([#{ Regexp.escape(CONTROL + ' ' + DELIMS + UNWISE + NONASCII) }])/
     ESCAPED   = /%([0-9a-fA-F]{2})/
 
-    def valid_connection_keys(params = {})
-      Excon::VALID_CONNECTION_KEYS
-    end
-
-    def valid_request_keys(params = {})
-      Excon::VALID_REQUEST_KEYS
-    end
-
     def connection_uri(datum = @data)
       unless datum
         raise ArgumentError, '`datum` must be given unless called on a Connection'

data/tests/basic_tests.rb

@@ -23,7 +23,7 @@ Shindo.tests('Excon streaming basics') do
   with_unicorn('streaming.ru') do
     # expected values: the response, in pieces, and a timeout after each piece
     res = %w{Hello streamy world}
-    timeout = 1
+    timeout = 0.1
 
     # expect the full response as a string
     # and expect it to take a (timeout * pieces) seconds

data/tests/errors_tests.rb

@@ -14,32 +14,32 @@ Shindo.tests('HTTPStatusError request/response debugging') do
     tests('message does not include response or response info').returns(true) do
       begin
         Excon.get('http://127.0.0.1:9292/error/not_found', :expects => 200)
-      rescue => err
+      rescue Excon::Errors::HTTPStatusError => err
         err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-        !err.message.include?('request =>') &&
-        !err.message.include?('response =>')
+          !err.message.include?('excon.error.request') &&
+          !err.message.include?('excon.error.response')
       end
     end
 
-    tests('message includes only response info').returns(true) do
+    tests('message includes only request info').returns(true) do
       begin
         Excon.get('http://127.0.0.1:9292/error/not_found', :expects => 200,
-                  :debug_response => true)
-      rescue => err
+                  :debug_request => true)
+      rescue Excon::Errors::HTTPStatusError => err
         err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-        !err.message.include?('request =>') &&
-        !!(err.message =~ /response =>(.*)server says not found/)
+          err.message.include?('excon.error.request') &&
+          !err.message.include?('excon.error.response')
       end
     end
 
-    tests('message includes only request info').returns(true) do
+    tests('message includes only response info').returns(true) do
       begin
         Excon.get('http://127.0.0.1:9292/error/not_found', :expects => 200,
-                  :debug_request => true)
-      rescue => err
+                  :debug_response => true)
+      rescue Excon::Errors::HTTPStatusError => err
         err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-        !!(err.message =~ /request =>(.*)error\/not_found/) &&
-        !err.message.include?('response =>')
+          !err.message.include?('excon.error.request') &&
+          err.message.include?('excon.error.response')
       end
     end
 
@@ -47,10 +47,10 @@ Shindo.tests('HTTPStatusError request/response debugging') do
       begin
         Excon.get('http://127.0.0.1:9292/error/not_found', :expects => 200,
                   :debug_request => true, :debug_response => true)
-      rescue => err
+      rescue Excon::Errors::HTTPStatusError => err
         err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-        !!(err.message =~ /request =>(.*)not_found/) &&
-        !!(err.message =~ /response =>(.*)server says not found/)
+          err.message.include?('excon.error.request') &&
+          err.message.include?('excon.error.response')
       end
     end
 

data/tests/rackups/streaming.ru

@@ -16,7 +16,7 @@ app = lambda do |env|
     begin
       # return the response in pieces
       pieces.each do |x|
-        sleep 1
+        sleep(0.1)
         io.write(x)
         io.flush
       end

data/tests/request_tests.rb

@@ -1,45 +1,6 @@
 Shindo.tests('Request Tests') do
   with_server('good') do
 
-    tests('sets transfer-coding and connection options') do
-
-      tests('without a :response_block') do
-        request = nil
-
-        returns('trailers, deflate, gzip', 'sets encoding options') do
-          request = Marshal.load(
-            Excon.get('http://127.0.0.1:9292/echo/request').body
-          )
-
-          request[:headers]['TE']
-        end
-
-        returns(true, 'TE added to Connection header') do
-          request[:headers]['Connection'].include?('TE')
-        end
-      end
-
-      tests('with a :response_block') do
-        request = nil
-
-        returns('trailers', 'does not set encoding options') do
-          captures = capture_response_block do |block|
-            Excon.get('http://127.0.0.1:9292/echo/request',
-                      :response_block => block)
-          end
-          data = captures.map {|capture| capture[0] }.join
-          request = Marshal.load(data)
-
-          request[:headers]['TE']
-        end
-
-        returns(true, 'TE added to Connection header') do
-          request[:headers]['Connection'].include?('TE')
-        end
-      end
-
-    end
-
     tests('persistent connections') do
 
       tests('with default :persistent => true') do
@@ -89,24 +50,6 @@ Shindo.tests('Request Tests') do
         end
       end
 
-      tests('sends `Connection: close`') do
-        returns(true, 'when :persistent => false') do
-          request = Marshal.load(
-            Excon.get('http://127.0.0.1:9292/echo/request',
-                      :persistent => false).body
-          )
-          request[:headers]['Connection'].include?('close')
-        end
-
-        returns(false, 'not when :persistent => true') do
-          request = Marshal.load(
-            Excon.get('http://127.0.0.1:9292/echo/request',
-                      :persistent => true).body
-          )
-          request[:headers]['Connection'].include?('close')
-        end
-      end
-
     end
 
   end

data/tests/response_tests.rb

@@ -46,7 +46,7 @@ Shindo.tests('Excon Response Parsing') do
         Excon.get('http://127.0.0.1:9292/chunked/trailers').headers['Test-Header']
       end
 
-      tests("removes 'chunked' from Transfer-Encoding").returns('') do
+      tests("removes 'chunked' from Transfer-Encoding").returns(nil) do
         Excon.get('http://127.0.0.1:9292/chunked/simple').headers['Transfer-Encoding']
       end
 
@@ -153,73 +153,6 @@ Shindo.tests('Excon Response Parsing') do
 
     end
 
-    tests('Transfer-Encoding') do
-
-      tests('used with chunked response') do
-        resp = nil
-
-        tests('server sent transfer-encoding').returns('gzip, chunked') do
-          resp = Excon.post(
-            'http://127.0.0.1:9292/echo/transfer-encoded/chunked',
-            :body => 'hello world'
-          )
-
-          resp[:headers]['Transfer-Encoding-Sent']
-        end
-
-        tests('processed encodings removed from header').returns('') do
-          resp[:headers]['Transfer-Encoding']
-        end
-
-        tests('response body decompressed').returns('hello world') do
-          resp[:body]
-        end
-      end
-
-      tests('used with non-chunked response') do
-        resp = nil
-
-        tests('server sent transfer-encoding').returns('gzip') do
-          resp = Excon.post(
-            'http://127.0.0.1:9292/echo/transfer-encoded',
-            :body => 'hello world'
-          )
-
-          resp[:headers]['Transfer-Encoding-Sent']
-        end
-
-        tests('processed encoding removed from header').returns('') do
-          resp[:headers]['Transfer-Encoding']
-        end
-
-        tests('response body decompressed').returns('hello world') do
-          resp[:body]
-        end
-      end
-
-      # sends TE header without gzip/deflate accepted (see requests_tests)
-      tests('with a :response_block') do
-        captures = nil
-
-        tests('server does not compress').returns('chunked') do
-          resp = nil
-          captures = capture_response_block do |block|
-            resp = Excon.post('http://127.0.0.1:9292/echo/transfer-encoded/chunked',
-                              :body => 'hello world',
-                              :response_block => block)
-          end
-
-          resp[:headers]['Transfer-Encoding-Sent']
-        end
-
-        tests('block receives uncompressed response').returns('hello world') do
-          captures.map {|capture| capture[0] }.join
-        end
-
-      end
-
-    end
-
   end
 
   env_restore

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excon
 version: !ruby/object:Gem::Version
-  version: 0.38.0
+  version: 0.39.0
 platform: ruby
 authors:
 - dpiddy (Dan Peterson)
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -173,6 +173,7 @@ files:
 - lib/excon/middlewares/mock.rb
 - lib/excon/middlewares/redirect_follower.rb
 - lib/excon/middlewares/response_parser.rb
+- lib/excon/pretty_printer.rb
 - lib/excon/response.rb
 - lib/excon/socket.rb
 - lib/excon/ssl_socket.rb
@@ -245,7 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: excon
-rubygems_version: 2.2.2
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 2
 summary: speed, persistence, http(s)