excon 0.49.0 → 0.88.0

data/lib/excon/constants.rb

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 module Excon
 
-  VERSION = '0.49.0'
-
   CR_NL = "\r\n"
 
   DEFAULT_CA_FILE = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "data", "cacert.pem"))
@@ -13,8 +12,16 @@ module Excon
     CHUNK_SIZE = DEFAULT_CHUNK_SIZE
   end
 
+  DEFAULT_REDIRECT_LIMIT = 10
+
   DEFAULT_RETRY_LIMIT = 4
 
+  DEFAULT_RETRY_ERRORS = [
+    Excon::Error::Timeout,
+    Excon::Error::Socket,
+    Excon::Error::HTTPStatus
+  ]
+
   FORCE_ENC = CR_NL.respond_to?(:force_encoding)
 
   HTTP_1_1 = " HTTP/1.1\r\n"
@@ -29,24 +36,22 @@ module Excon
 
   UNIX = 'unix'
 
-  USER_AGENT = 'excon/' << VERSION
+  USER_AGENT = "excon/#{VERSION}"
 
-  VERSIONS = USER_AGENT + ' (' << RUBY_PLATFORM << ') ruby/' << RUBY_VERSION
+  VERSIONS = "#{USER_AGENT} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
 
   VALID_REQUEST_KEYS = [
+    :allow_unstubbed_requests,
     :body,
-    :captures,
     :chunk_size,
     :debug_request,
     :debug_response,
-    :expects,
     :headers,
-    :idempotent,
-    :instrumentor,
-    :instrumentor_name,
+    :instrumentor, # Used for setting logging within Connection
+    :logger,
     :method,
     :middlewares,
-    :mock,
+    :password,
     :path,
     :persistent,
     :pipeline,
@@ -54,8 +59,8 @@ module Excon
     :read_timeout,
     :request_block,
     :response_block,
-    :retries_remaining, # used internally
-    :retry_limit,
+    :stubs,
+    :user,
     :versions,
     :write_timeout
   ]
@@ -63,8 +68,10 @@ module Excon
   VALID_CONNECTION_KEYS = VALID_REQUEST_KEYS + [
     :ciphers,
     :client_key,
+    :client_key_data,
     :client_key_pass,
     :client_cert,
+    :client_cert_data,
     :certificate,
     :certificate_path,
     :disable_proxy,
@@ -72,12 +79,12 @@ module Excon
     :private_key_path,
     :connect_timeout,
     :family,
+    :keepalive,
     :host,
     :hostname,
     :omit_default_port,
     :nonblock,
     :reuseaddr,
-    :password,
     :port,
     :proxy,
     :scheme,
@@ -88,13 +95,30 @@ module Excon
     :ssl_verify_callback,
     :ssl_verify_peer,
     :ssl_verify_peer_host,
+    :ssl_verify_hostname,
     :ssl_version,
+    :ssl_min_version,
+    :ssl_max_version,
+    :ssl_security_level,
+    :ssl_proxy_headers,
+    :ssl_uri_schemes,
     :tcp_nodelay,
     :thread_safe_sockets,
     :uri_parser,
-    :user
   ]
 
+  DEPRECATED_VALID_REQUEST_KEYS = {
+    :captures => 'Mock',
+    :expects => 'Expects',
+    :idempotent => 'Idempotent',
+    :instrumentor_name => 'Instrumentor',
+    :mock => 'Mock',
+    :retries_remaining => 'Idempotent', # referenced in Instrumentor, but only relevant with Idempotent
+    :retry_errors => 'Idempotent',
+    :retry_interval => 'Idempotent',
+    :retry_limit => 'Idempotent' # referenced in Instrumentor, but only relevant with Idempotent
+  }
+
   unless ::IO.const_defined?(:WaitReadable)
     class ::IO
       module WaitReadable; end
@@ -109,12 +133,15 @@ module Excon
   # these come last as they rely on the above
   DEFAULTS = {
     :chunk_size           => CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
-    :ciphers              => 'HIGH:!SSLv2:!aNULL:!eNULL:!3DES',
+    # see https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28default.29
+    # list provided then had DES related things sorted to the end
+    :ciphers              => 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:DES-CBC3-SHA:!DSS',
     :connect_timeout      => 60,
     :debug_request        => false,
     :debug_response       => false,
     :headers              => {
-      'User-Agent' => USER_AGENT
+      'User-Agent' => USER_AGENT,
+      'Accept'     =>  '*/*'
     },
     :idempotent           => false,
     :instrumentor_name    => 'excon',
@@ -130,6 +157,7 @@ module Excon
     :omit_default_port    => false,
     :persistent           => false,
     :read_timeout         => 60,
+    :retry_errors         => DEFAULT_RETRY_ERRORS,
     :retry_limit          => DEFAULT_RETRY_LIMIT,
     :ssl_verify_peer      => true,
     :ssl_uri_schemes      => [HTTPS],

data/lib/excon/error.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+module Excon
+  # Excon exception classes
+  class Error < StandardError
+    @default_status_error = :HTTPStatus
+
+    class StubNotFound < Error; end
+    class InvalidStub < Error; end
+    class Warning < Error; end
+
+    # Socket related errors
+    class Socket < Error
+      attr_reader :socket_error
+
+      def initialize(socket_error = Excon::Error.new)
+        if is_a?(Certificate) || is_a?(Excon::Errors::CertificateError)
+          super
+        else
+          super("#{socket_error.message} (#{socket_error.class})")
+          set_backtrace(socket_error.backtrace)
+          @socket_error = socket_error
+        end
+      end
+    end
+
+    # Certificate related errors
+    class Certificate < Socket
+      def initialize(socket_error = Excon::Error.new)
+        msg = <<-EOL
+Unable to verify certificate. This may be an issue with the remote host or with Excon. Excon has certificates bundled, but these can be customized:
+
+            `Excon.defaults[:ssl_ca_path] = path_to_certs`
+            `ENV['SSL_CERT_DIR'] = path_to_certs`
+            `Excon.defaults[:ssl_ca_file] = path_to_file`
+            `ENV['SSL_CERT_FILE'] = path_to_file`
+            `Excon.defaults[:ssl_verify_callback] = callback`
+                (see OpenSSL::SSL::SSLContext#verify_callback)
+or:
+            `Excon.defaults[:ssl_verify_peer] = false` (less secure).
+        EOL
+        full_message = "#{socket_error.message} (#{socket_error.class})" +
+                       ' ' + msg
+        super(full_message)
+        set_backtrace(socket_error.backtrace)
+        @socket_error = socket_error
+      end
+    end
+
+    class InvalidHeaderKey < Error; end
+    class InvalidHeaderValue < Error; end
+    class Timeout < Error; end
+    class ResponseParse < Error; end
+
+    class ProxyConnectionError < Error
+      attr_reader :request, :response
+
+      def initialize(msg, request = nil, response = nil)
+        super(msg)
+        @request = request
+        @response = response
+      end
+    end
+
+    class ProxyParse < Error; end
+    class TooManyRedirects < Error; end
+
+    # Base class for HTTP Error classes
+    class HTTPStatus < Error
+      attr_reader :request, :response
+
+      def initialize(msg, request = nil, response = nil)
+        super(msg)
+        @request = request
+        @response = response
+      end
+    end
+
+    # HTTP Error classes
+    class Informational < HTTPStatus; end
+    class Success < HTTPStatus; end
+    class Redirection < HTTPStatus; end
+    class Client < HTTPStatus; end
+    class Server < HTTPStatus; end
+
+    class Continue < Informational; end                  # 100
+    class SwitchingProtocols < Informational; end        # 101
+    class OK < Success; end                              # 200
+    class Created < Success; end                         # 201
+    class Accepted < Success; end                        # 202
+    class NonAuthoritativeInformation < Success; end     # 203
+    class NoContent < Success; end                       # 204
+    class ResetContent < Success; end                    # 205
+    class PartialContent < Success; end                  # 206
+    class MultipleChoices < Redirection; end             # 300
+    class MovedPermanently < Redirection; end            # 301
+    class Found < Redirection; end                       # 302
+    class SeeOther < Redirection; end                    # 303
+    class NotModified < Redirection; end                 # 304
+    class UseProxy < Redirection; end                    # 305
+    class TemporaryRedirect < Redirection; end           # 307
+    class BadRequest < Client; end                       # 400
+    class Unauthorized < Client; end                     # 401
+    class PaymentRequired < Client; end                  # 402
+    class Forbidden < Client; end                        # 403
+    class NotFound < Client; end                         # 404
+    class MethodNotAllowed < Client; end                 # 405
+    class NotAcceptable < Client; end                    # 406
+    class ProxyAuthenticationRequired < Client; end      # 407
+    class RequestTimeout < Client; end                   # 408
+    class Conflict < Client; end                         # 409
+    class Gone < Client; end                             # 410
+    class LengthRequired < Client; end                   # 411
+    class PreconditionFailed < Client; end               # 412
+    class RequestEntityTooLarge < Client; end            # 413
+    class RequestURITooLong < Client; end                # 414
+    class UnsupportedMediaType < Client; end             # 415
+    class RequestedRangeNotSatisfiable < Client; end     # 416
+    class ExpectationFailed < Client; end                # 417
+    class UnprocessableEntity < Client; end              # 422
+    class TooManyRequests < Client; end                  # 429
+    class InternalServerError < Server; end              # 500
+    class NotImplemented < Server; end                   # 501
+    class BadGateway < Server; end                       # 502
+    class ServiceUnavailable < Server; end               # 503
+    class GatewayTimeout < Server; end                   # 504
+
+    def self.status_errors
+      @status_errors ||= {
+        100 => [Excon::Error::Continue, 'Continue'],
+        101 => [Excon::Error::SwitchingProtocols, 'Switching Protocols'],
+        200 => [Excon::Error::OK, 'OK'],
+        201 => [Excon::Error::Created, 'Created'],
+        202 => [Excon::Error::Accepted, 'Accepted'],
+        203 => [Excon::Error::NonAuthoritativeInformation, 'Non-Authoritative Information'],
+        204 => [Excon::Error::NoContent, 'No Content'],
+        205 => [Excon::Error::ResetContent, 'Reset Content'],
+        206 => [Excon::Error::PartialContent, 'Partial Content'],
+        300 => [Excon::Error::MultipleChoices, 'Multiple Choices'],
+        301 => [Excon::Error::MovedPermanently, 'Moved Permanently'],
+        302 => [Excon::Error::Found, 'Found'],
+        303 => [Excon::Error::SeeOther, 'See Other'],
+        304 => [Excon::Error::NotModified, 'Not Modified'],
+        305 => [Excon::Error::UseProxy, 'Use Proxy'],
+        307 => [Excon::Error::TemporaryRedirect, 'Temporary Redirect'],
+        400 => [Excon::Error::BadRequest, 'Bad Request'],
+        401 => [Excon::Error::Unauthorized, 'Unauthorized'],
+        402 => [Excon::Error::PaymentRequired, 'Payment Required'],
+        403 => [Excon::Error::Forbidden, 'Forbidden'],
+        404 => [Excon::Error::NotFound, 'Not Found'],
+        405 => [Excon::Error::MethodNotAllowed, 'Method Not Allowed'],
+        406 => [Excon::Error::NotAcceptable, 'Not Acceptable'],
+        407 => [Excon::Error::ProxyAuthenticationRequired, 'Proxy Authentication Required'],
+        408 => [Excon::Error::RequestTimeout, 'Request Timeout'],
+        409 => [Excon::Error::Conflict, 'Conflict'],
+        410 => [Excon::Error::Gone, 'Gone'],
+        411 => [Excon::Error::LengthRequired, 'Length Required'],
+        412 => [Excon::Error::PreconditionFailed, 'Precondition Failed'],
+        413 => [Excon::Error::RequestEntityTooLarge, 'Request Entity Too Large'],
+        414 => [Excon::Error::RequestURITooLong, 'Request-URI Too Long'],
+        415 => [Excon::Error::UnsupportedMediaType, 'Unsupported Media Type'],
+        416 => [Excon::Error::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
+        417 => [Excon::Error::ExpectationFailed, 'Expectation Failed'],
+        422 => [Excon::Error::UnprocessableEntity, 'Unprocessable Entity'],
+        429 => [Excon::Error::TooManyRequests, 'Too Many Requests'],
+        500 => [Excon::Error::InternalServerError, 'InternalServerError'],
+        501 => [Excon::Error::NotImplemented, 'Not Implemented'],
+        502 => [Excon::Error::BadGateway, 'Bad Gateway'],
+        503 => [Excon::Error::ServiceUnavailable, 'Service Unavailable'],
+        504 => [Excon::Error::GatewayTimeout, 'Gateway Timeout']
+      }
+    end
+
+    # Messages for nicer exceptions, from rfc2616
+    def self.status_error(request, response)
+      error_class, error_message = status_errors[response[:status]]
+      if error_class.nil?
+        default_class = Excon::Error.const_get(@default_status_error)
+        error_class, error_message = [default_class, 'Unknown']
+      end
+      message = StringIO.new
+      str = "Expected(#{request[:expects].inspect}) <=>" +
+            " Actual(#{response[:status]} #{error_message})"
+      message.puts(str)
+      if request[:debug_request]
+        message.puts('excon.error.request')
+        Excon::PrettyPrinter.pp(message, request)
+      end
+
+      if request[:debug_response]
+        message.puts('excon.error.response')
+        Excon::PrettyPrinter.pp(message, response.data)
+      end
+      message.rewind
+      error_class.new(message.read, request, response)
+    end
+  end
+
+  # Legacy
+  module Errors
+    Excon::Errors::Error = Excon::Error
+
+    legacy_re = /
+      \A
+      Client
+      |Server
+      |Socket
+      |Certificate
+      |HTTPStatus
+      |InternalServer
+      \Z
+    /x
+
+    klasses = Excon::Error.constants.select do |c|
+      Excon::Error.const_get(c).is_a? Class
+    end
+
+    klasses.each do |klass|
+      class_name = klass.to_s
+      unless class_name =~ /Error\Z/
+        class_name = klass.to_s + 'Error' if class_name =~ legacy_re
+      end
+      Excon::Errors.const_set(class_name, Excon::Error.const_get(klass))
+    end
+
+    def self.status_error(request, response)
+      Excon::Error.status_error(request, response)
+    end
+  end
+end

data/lib/excon/extensions/uri.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # 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.

data/lib/excon/headers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Excon
   class Headers < Hash
 
@@ -21,6 +22,7 @@ module Excon
     alias_method :raw_values_at, :values_at
 
     def initialize
+      super
       @downcased = {}
     end
 
@@ -28,11 +30,11 @@ module Excon
       @downcased[key.to_s.downcase]
     end
 
-    alias_method :[]=, :store
     def []=(key, value)
       raw_writer(key, value)
       @downcased[key.to_s.downcase] = value
     end
+    alias_method :store, :[]=
 
     if SENTINEL.respond_to? :assoc
       def assoc(obj)
@@ -53,11 +55,11 @@ module Excon
       end
     end
 
-    alias_method :has_key?, :key?
-    alias_method :has_key?, :member?
     def has_key?(key)
       raw_key?(key) || @downcased.has_key?(key.to_s.downcase)
     end
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
 
     def merge(other_hash)
       self.dup.merge!(other_hash)

data/lib/excon/instrumentors/logging_instrumentor.rb

@@ -0,0 +1,48 @@
+require 'logger'
+
+module Excon
+  class LoggingInstrumentor
+
+    def self.instrument(name, params = {})
+      params = params.dup
+
+      logger = params[:logger] || Logger.new($stderr)
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      if params.has_key?(:headers) && params[:headers].has_key?('Authorization')
+        params[:headers] = params[:headers].dup
+        params[:headers]['Authorization'] = "REDACTED"
+      end
+
+      if params.has_key?(:password)
+        params[:password] = "REDACTED"
+      end
+
+      if name.include?('request')
+        info = "request: " + params[:scheme] + "://" + File.join(params[:host], params[:path])
+
+        if params[:query]
+          info << "?"
+
+          if params[:query].is_a?(Hash)
+            info << params[:query].to_a.map { |key,value| "#{key}=#{value}" }.join('&')
+          else
+            info << params[:query]
+          end
+        end
+      else
+        response_type = name.split('.').last
+        if params[:body]
+          info = "#{response_type}: " + params[:body]
+        end
+      end
+
+      logger.info(info) if info
+
+      yield if block_given?
+    end
+  end
+end

data/lib/excon/instrumentors/standard_instrumentor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Excon
+  class StandardInstrumentor
+    def self.instrument(name, params = {})
+      params = params.dup
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      params = Utils.redact(params)
+
+      $stderr.puts(name)
+      Excon::PrettyPrinter.pp($stderr, params)
+
+      if block_given?
+        yield
+      end
+    end
+  end
+end

data/lib/excon/middlewares/base.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class Base
+      # Returns the list of parameters that this middleware uses that are valid
+      # as arguments to `Connection#request` or `Connection#new`.
+      def self.valid_parameter_keys
+        []
+      end
+
       def initialize(stack)
         @stack = stack
       end

data/lib/excon/middlewares/capture_cookies.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class CaptureCookies < Excon::Middleware::Base
@@ -7,7 +8,7 @@ module Excon
       end
 
       def get_header(datum, header)
-        _, header_value = datum[:response][:headers].detect do |key, value|
+        _, header_value = datum[:response][:headers].detect do |key, _|
           key.casecmp(header) == 0
         end
         header_value

data/lib/excon/middlewares/decompress.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class Decompress < Excon::Middleware::Base
@@ -14,9 +15,9 @@ module Excon
       def response_call(datum)
         body = datum[:response][:body]
         unless datum.has_key?(:response_block) || body.nil? || body.empty?
-          if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Encoding') == 0 }
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Encoding') == 0 })
             encodings = Utils.split_header_value(datum[:response][:headers][key])
-            if encoding = encodings.last
+            if (encoding = encodings.last)
               if encoding.casecmp('deflate') == 0
                 # assume inflate omits header
                 datum[:response][:body] = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(body)

data/lib/excon/middlewares/escape_path.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class EscapePath < Excon::Middleware::Base

data/lib/excon/middlewares/expects.rb

@@ -1,11 +1,18 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class Expects < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :expects
+        ]
+      end
+
       def response_call(datum)
         if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
           raise(
             Excon::Errors.status_error(
-              datum.reject {|key,value| key == :response},
+              datum.reject {|key,_| key == :response},
               Excon::Response.new(datum[:response])
             )
           )

data/lib/excon/middlewares/idempotent.rb

@@ -1,6 +1,24 @@
+# frozen_string_literal: true
+require 'set'
+
 module Excon
   module Middleware
     class Idempotent < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :idempotent,
+          :retries_remaining,
+          :retry_errors,
+          :retry_interval,
+          :retry_limit
+        ]
+      end
+
+      def request_call(datum)
+        datum[:retries_remaining] ||= datum[:retry_limit]
+        @stack.request_call(datum)
+      end
+
       def error_call(datum)
         if datum[:idempotent]
           if datum.has_key?(:request_block)
@@ -11,18 +29,24 @@ module Excon
               datum[:idempotent] = false
             end
           end
+          if datum.has_key?(:response_block) && datum[:response_block].respond_to?(:rewind)
+            datum[:response_block].rewind
+          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
+        if datum[:idempotent] && datum[:retry_errors].any? {|ex| datum[:error].kind_of?(ex) } && datum[:retries_remaining] > 1
+
+          sleep(datum[:retry_interval]) if datum[:retry_interval]
+
           # reduces remaining retries, reset connection, and restart request_call
           datum[:retries_remaining] -= 1
           connection = datum.delete(:connection)
-          datum.reject! {|key, _| !Excon::VALID_REQUEST_KEYS.include?(key) }
+          valid_keys = Set.new(connection.valid_request_keys(datum[:middlewares]))
+          datum.select! {|key, _| valid_keys.include?(key) }
           connection.request(datum)
         else
           @stack.error_call(datum)

data/lib/excon/middlewares/instrumentor.rb

@@ -1,6 +1,15 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class Instrumentor < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :logger,
+          :instrumentor,
+          :instrumentor_name
+        ]
+      end
+
       def error_call(datum)
         if datum.has_key?(:instrumentor)
           datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => datum[:error]) do

data/lib/excon/middlewares/mock.rb

@@ -1,6 +1,15 @@
+# frozen_string_literal: true
 module Excon
   module Middleware
     class Mock < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :allow_unstubbed_requests,
+          :captures,
+          :mock
+        ]
+      end
+
       def request_call(datum)
         if datum[:mock]
           # convert File/Tempfile body to string before matching:
@@ -16,12 +25,13 @@ module Excon
             raise Excon::Errors::InvalidStub.new("Request body should be a string or an IO object. #{datum[:body].class} provided")
           end
 
-          if stub = Excon.stub_for(datum)
+          if (stub = Excon.stub_for(datum))
+            datum[:remote_ip] ||= '127.0.0.1'
             datum[:response] = {
               :body       => '',
               :headers    => {},
               :status     => 200,
-              :remote_ip  => '127.0.0.1'
+              :remote_ip  => datum[:remote_ip]
             }
 
             stub_datum = case stub.last
@@ -31,11 +41,11 @@ module Excon
               stub.last
             end
 
-            datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})
+            datum[:response].merge!(stub_datum.reject {|key,_| key == :headers})
             if stub_datum.has_key?(:headers)
               datum[:response][:headers].merge!(stub_datum[:headers])
             end
-          else
+          elsif datum[:allow_unstubbed_requests] != true
             # if we reach here no stubs matched
             message = StringIO.new
             message.puts('no stubs matched')