faraday 0.15.4 → 0.17.6

data/lib/faraday/error.rb

@@ -1,22 +1,17 @@
-module Faraday
-  class Error < StandardError; end
+# frozen_string_literal: true
 
-  class ClientError < Error
-    attr_reader :response, :wrapped_exception
+require 'faraday/deprecate'
 
-    def initialize(ex, response = nil)
-      @wrapped_exception = nil
-      @response = response
+# Faraday namespace.
+module Faraday
+  # Faraday error base class.
+  class Error < StandardError
+    attr_reader :response, :wrapped_exception
 
-      if ex.respond_to?(:backtrace)
-        super(ex.message)
-        @wrapped_exception = ex
-      elsif ex.respond_to?(:each_key)
-        super("the server responded with status #{ex[:status]}")
-        @response = ex
-      else
-        super(ex.to_s)
-      end
+    def initialize(exc, response = nil)
+      @wrapped_exception = nil unless defined?(@wrapped_exception)
+      @response = nil unless defined?(@response)
+      super(exc_msg_and_response!(exc, response))
     end
 
     def backtrace
@@ -29,38 +24,135 @@ module Faraday
 
     def inspect
       inner = ''
-      if @wrapped_exception
-        inner << " wrapped=#{@wrapped_exception.inspect}"
-      end
-      if @response
-        inner << " response=#{@response.inspect}"
-      end
-      if inner.empty?
-        inner << " #{super}"
-      end
+      inner += " wrapped=#{@wrapped_exception.inspect}" if @wrapped_exception
+      inner += " response=#{@response.inspect}" if @response
+      inner += " #{super}" if inner.empty?
       %(#<#{self.class}#{inner}>)
     end
+
+    protected
+
+    # Pulls out potential parent exception and response hash, storing them in
+    # instance variables.
+    # exc      - Either an Exception, a string message, or a response hash.
+    # response - Hash
+    #              :status  - Optional integer HTTP response status
+    #              :headers - String key/value hash of HTTP response header
+    #                         values.
+    #              :body    - Optional string HTTP response body.
+    #
+    # If a subclass has to call this, then it should pass a string message
+    # to `super`. See NilStatusError.
+    def exc_msg_and_response!(exc, response = nil)
+      if @response.nil? && @wrapped_exception.nil?
+        @wrapped_exception, msg, @response = exc_msg_and_response(exc, response)
+        return msg
+      end
+
+      exc.to_s
+    end
+
+    # Pulls out potential parent exception and response hash.
+    def exc_msg_and_response(exc, response = nil)
+      return [exc, exc.message, response] if exc.respond_to?(:backtrace)
+
+      return [nil, "the server responded with status #{exc[:status]}", exc] \
+        if exc.respond_to?(:each_key)
+
+      [nil, exc.to_s, response]
+    end
+  end
+
+  # Faraday client error class. Represents 4xx status responses.
+  class ClientError < Error
+  end
+
+  # Raised by Faraday::Response::RaiseError in case of a 400 response.
+  class BadRequestError < ClientError
   end
 
-  class ConnectionFailed < ClientError;   end
-  class ResourceNotFound < ClientError;   end
-  class ParsingError     < ClientError;   end
+  # Raised by Faraday::Response::RaiseError in case of a 401 response.
+  class UnauthorizedError < ClientError
+  end
+
+  # Raised by Faraday::Response::RaiseError in case of a 403 response.
+  class ForbiddenError < ClientError
+  end
 
+  # Raised by Faraday::Response::RaiseError in case of a 404 response.
+  class ResourceNotFound < ClientError
+  end
+
+  # Raised by Faraday::Response::RaiseError in case of a 407 response.
+  class ProxyAuthError < ClientError
+  end
+
+  # Raised by Faraday::Response::RaiseError in case of a 409 response.
+  class ConflictError < ClientError
+  end
+
+  # Raised by Faraday::Response::RaiseError in case of a 422 response.
+  class UnprocessableEntityError < ClientError
+  end
+
+  # Faraday server error class. Represents 5xx status responses.
+  class ServerError < Error
+  end
+
+  # A unified client error for timeouts.
   class TimeoutError < ClientError
-    def initialize(ex = nil)
-      super(ex || "timeout")
+    def initialize(exc = 'timeout', response = nil)
+      super(exc, response)
     end
   end
 
-  class SSLError < ClientError
+  # Raised by Faraday::Response::RaiseError in case of a nil status in response.
+  class NilStatusError < ServerError
+    def initialize(exc, response = nil)
+      exc_msg_and_response!(exc, response)
+      @response = unwrap_resp!(@response)
+      super('http status could not be derived from the server response')
+    end
+
+    private
+
+    extend Faraday::Deprecate
+
+    def unwrap_resp(resp)
+      if inner = (resp.keys.size == 1 && resp[:response])
+        return unwrap_resp(inner)
+      end
+
+      resp
+    end
+
+    alias_method :unwrap_resp!, :unwrap_resp
+    deprecate('unwrap_resp', nil, '1.0')
   end
 
-  class RetriableResponse < ClientError; end
+  # A unified error for failed connections.
+  class ConnectionFailed < ClientError
+  end
 
-  [:ClientError, :ConnectionFailed, :ResourceNotFound,
-   :ParsingError, :TimeoutError, :SSLError, :RetriableResponse].each do |const|
-    Error.const_set(const, Faraday.const_get(const))
+  # A unified client error for SSL errors.
+  class SSLError < ClientError
+  end
+
+  # Raised by FaradayMiddleware::ResponseMiddleware
+  class ParsingError < ClientError
   end
 
+  # Exception used to control the Retry middleware.
+  #
+  # @see Faraday::Request::Retry
+  class RetriableResponse < ClientError
+  end
 
+  [:ClientError, :ConnectionFailed, :ResourceNotFound,
+    :ParsingError, :TimeoutError, :SSLError, :RetriableResponse].each do |const|
+    Error.const_set(
+      const,
+      DeprecatedClass.proxy_class(Faraday.const_get(const))
+    )
+  end
 end

data/lib/faraday/options.rb

@@ -72,7 +72,7 @@ module Faraday
         if args.size > 0
           send(key_setter, args.first)
         elsif block_given?
-          send(key_setter, Proc.new.call(key))
+          send(key_setter, yield(key))
         else
           raise self.class.fetch_error_class, "key not found: #{key.inspect}"
         end
@@ -162,8 +162,8 @@ module Faraday
       @attribute_options ||= {}
     end
 
-    def self.memoized(key)
-      memoized_attributes[key.to_sym] = Proc.new
+    def self.memoized(key, &block)
+      memoized_attributes[key.to_sym] = block
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{key}() self[:#{key}]; end
       RUBY

data/lib/faraday/rack_builder.rb

@@ -49,10 +49,10 @@ module Faraday
       end
     end
 
-    def initialize(handlers = [])
+    def initialize(handlers = [], &block)
       @handlers = handlers
       if block_given?
-        build(&Proc.new)
+        build(&block)
       elsif @handlers.empty?
         # default stack, if nothing else is configured
         self.request :url_encoded

data/lib/faraday/request/retry.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 module Faraday
   # Catches exceptions and retries each request a limited number of times.
   #
@@ -19,8 +21,9 @@ module Faraday
   # interval that is random between 0.1 and 0.15
   #
   class Request::Retry < Faraday::Middleware
-
-    DEFAULT_EXCEPTIONS = [Errno::ETIMEDOUT, 'Timeout::Error', Error::TimeoutError, Faraday::Error::RetriableResponse].freeze
+    DEFAULT_EXCEPTIONS = [Errno::ETIMEDOUT, 'Timeout::Error',
+                          Faraday::TimeoutError, Faraday::RetriableResponse
+                         ].freeze
     IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
 
     class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
@@ -93,7 +96,7 @@ module Faraday
     # exceptions          - The list of exceptions to handle. Exceptions can be
     #                       given as Class, Module, or String. (default:
     #                       [Errno::ETIMEDOUT, 'Timeout::Error',
-    #                       Error::TimeoutError, Faraday::Error::RetriableResponse])
+    #                       Faraday::TimeoutError, Faraday::RetriableResponse])
     # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
     #                       an empty Array to call retry_if for all exceptions.
     #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
@@ -126,7 +129,7 @@ module Faraday
       begin
         env[:body] = request_body # after failure env[:body] is set to the response body
         @app.call(env).tap do |resp|
-          raise Faraday::Error::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
+          raise Faraday::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
         end
       rescue @errmatch => exception
         if retries > 0 && retry_request?(env, exception)
@@ -139,7 +142,7 @@ module Faraday
           end
         end
 
-        if exception.is_a?(Faraday::Error::RetriableResponse)
+        if exception.is_a?(Faraday::RetriableResponse)
           exception.response
         else
           raise

data/lib/faraday/request.rb

@@ -12,6 +12,8 @@ module Faraday
   class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
     extend MiddlewareRegistry
 
+    alias_method :http_method, :method
+
     register_middleware File.expand_path('../request', __FILE__),
       :url_encoded => [:UrlEncoded, 'url_encoded'],
       :multipart => [:Multipart, 'multipart'],

data/lib/faraday/response/raise_error.rb

@@ -5,12 +5,16 @@ module Faraday
     def on_complete(env)
       case env[:status]
       when 404
-        raise Faraday::Error::ResourceNotFound, response_values(env)
+        raise Faraday::ResourceNotFound, response_values(env)
       when 407
         # mimic the behavior that we get with proxy requests with HTTPS
-        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        raise Faraday::ConnectionFailed.new(
+                %{407 "Proxy Authentication Required "},
+                response_values(env))
       when ClientErrorStatuses
-        raise Faraday::Error::ClientError, response_values(env)
+        raise Faraday::ClientError, response_values(env)
+      when nil
+        raise Faraday::NilStatusError, response_values(env)
       end
     end
 

data/lib/faraday/response.rb

@@ -54,9 +54,9 @@ module Faraday
       !!env
     end
 
-    def on_complete
-      if not finished?
-        @on_complete_callbacks << Proc.new
+    def on_complete(&block)
+      if !finished?
+        @on_complete_callbacks << block
       else
         yield(env)
       end

data/lib/faraday/upload_io.rb

@@ -1,10 +1,15 @@
 begin
-  require 'composite_io'
-  require 'parts'
+  require 'multipart/post'
   require 'stringio'
 rescue LoadError
-  $stderr.puts "Install the multipart-post gem."
-  raise
+  begin
+    require 'composite_io'
+    require 'parts'
+    require 'stringio'
+  rescue LoadError
+    $stderr.puts "Install the multipart-post gem."
+    raise
+  end
 end
 
 module Faraday
@@ -62,6 +67,11 @@ module Faraday
     end
   end
 
-  UploadIO = ::UploadIO
-  Parts = ::Parts
+  if defined?(::Multipart::Post::UploadIO)
+    UploadIO = ::Multipart::Post::UploadIO
+    Parts = ::Multipart::Post::Parts
+  else
+    UploadIO = ::UploadIO
+    Parts = ::Parts
+  end
 end

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.15.4"
+  VERSION = "0.17.6"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.
@@ -64,8 +64,7 @@ module Faraday
     #     :params => {:page => 1}
     #
     # Returns a Faraday::Connection.
-    def new(url = nil, options = nil)
-      block = block_given? ? Proc.new : nil
+    def new(url = nil, options = nil, &block)
       options = options ? default_connection_options.merge(options) : default_connection_options
       Faraday::Connection.new(url, options, &block)
     end

data/spec/faraday/deprecate_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::DeprecatedClass do
+  class SampleClass < StandardError
+    attr_accessor :foo
+
+    def initialize(foo = nil)
+      @foo = foo || :foo
+    end
+  end
+
+  SampleDeprecatedClass = Faraday::DeprecatedClass.proxy_class(SampleClass)
+
+  it 'does not raise error for deprecated classes but prints an error message' do
+    error_message, foobar = with_warn_squelching { SampleDeprecatedClass.new(:foo_bar) }
+    expect(foobar).to be_a(SampleClass)
+    expect(foobar.foo).to eq(:foo_bar)
+    expect(error_message).to match(
+      Regexp.new(
+        'NOTE: SampleDeprecatedClass.new is deprecated; '\
+        'use SampleClass.new instead. It will be removed in or after version 1.0'
+      )
+    )
+  end
+
+  it 'does not raise an error for inherited error-namespaced classes but prints an error message' do
+    error_message, = with_warn_squelching { Class.new(SampleDeprecatedClass) }
+
+    expect(error_message).to match(
+      Regexp.new(
+        'NOTE: Inheriting SampleDeprecatedClass is deprecated; '\
+        'use SampleClass instead. It will be removed in or after version 1.0'
+      )
+    )
+  end
+
+  it 'allows backward-compatible class to be subclassed' do
+    expect {
+      with_warn_squelching { Class.new(SampleDeprecatedClass) }
+    }.not_to raise_error
+  end
+
+  it 'allows rescuing of a current error with a deprecated error' do
+    expect { raise SampleClass, nil }.to raise_error(SampleDeprecatedClass)
+  end
+
+  it 'allows rescuing of a current error with a current error' do
+    expect { raise SampleClass, nil }.to raise_error(SampleClass)
+  end
+
+  it 'allows rescuing of a deprecated error with a deprecated error' do
+    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleDeprecatedClass)
+  end
+
+  it 'allows rescuing of a deprecated error with a current error' do
+    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleClass)
+  end
+
+  describe 'match behavior' do
+    class SampleDeprecatedClassA < SampleDeprecatedClass; end
+    class SampleDeprecatedClassB < SampleDeprecatedClass; end
+
+    class SampleDeprecatedClassAX < SampleDeprecatedClassA; end
+
+    class SampleClassA < SampleClass; end
+
+    describe 'undeprecated class' do
+      it 'is === to instance of deprecated class' do
+        expect(SampleClass === SampleDeprecatedClass.new).to be true
+      end
+
+      it 'is === to instance of subclass of deprecated class' do
+        expect(SampleClass === SampleDeprecatedClassA.new).to be true
+      end
+
+      it 'is === to instance of subclass of subclass of deprecated class' do
+        expect(SampleClass === SampleDeprecatedClassAX.new).to be true
+      end
+    end
+
+    describe 'subclass of undeprecated class' do
+      it 'is not === to instance of undeprecated class' do
+        expect(SampleClassA === SampleClass.new).to be false
+      end
+
+      it 'is not === to instance of deprecated class' do
+        expect(SampleClassA === SampleDeprecatedClass.new).to be false
+      end
+    end
+
+    describe 'deprecated class' do
+      it 'is === to instance of undeprecated class' do
+        expect(SampleDeprecatedClass === SampleClass.new).to be true
+      end
+
+      it 'is === to instance of subclass of undeprecated class' do
+        expect(SampleDeprecatedClass === SampleClassA.new).to be true
+      end
+
+      it 'is === to instance of subclass of deprecated class' do
+        expect(SampleDeprecatedClass === SampleDeprecatedClassA.new).to be true
+      end
+
+      it 'is === to instance of subclass of subclass of deprecated class' do
+        expect(SampleDeprecatedClass === SampleDeprecatedClassAX.new).to be true
+      end
+    end
+
+    describe 'subclass of deprecated class' do
+      it 'is not === to instance of subclass of undeprecated class' do
+        expect(SampleDeprecatedClassA === SampleClass.new).to be false
+      end
+
+      it 'is not === to instance of another subclass of deprecated class' do
+        expect(SampleDeprecatedClassA === SampleDeprecatedClassB.new).to be false
+      end
+
+      it 'is === to instance of its subclass' do
+        expect(SampleDeprecatedClassA === SampleDeprecatedClassAX.new).to be true
+      end
+
+      it 'is === to instance of deprecated class' do
+        expect(SampleDeprecatedClass === SampleDeprecatedClassB.new).to be true
+      end
+    end
+
+    describe 'subclass of subclass of deprecated class' do
+      it 'is not === to instance of subclass of another subclass of deprecated class' do
+        expect(SampleDeprecatedClassAX === SampleDeprecatedClassB.new).to be false
+      end
+
+      it 'is not === to instance of its superclass' do
+        expect(SampleDeprecatedClassA === SampleDeprecatedClass.new).to be false
+      end
+    end
+  end
+
+  def with_warn_squelching
+    stderr_catcher = StringIO.new
+    original_stderr = $stderr
+    $stderr = stderr_catcher
+    result = yield if block_given?
+    [stderr_catcher.tap(&:rewind).string, result]
+  ensure
+    $stderr = original_stderr
+  end
+end

data/spec/faraday/error_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::ClientError do
+  describe '.initialize' do
+    subject { described_class.new(exception, response) }
+    let(:response) { nil }
+
+    context 'with exception only' do
+      let(:exception) { RuntimeError.new('test') }
+
+      it { expect(subject.wrapped_exception).to eq(exception) }
+      it { expect(subject.response).to be_nil }
+      it { expect(subject.message).to eq(exception.message) }
+      it { expect(subject.backtrace).to eq(exception.backtrace) }
+      it { expect(subject.inspect).to eq('#<Faraday::ClientError wrapped=#<RuntimeError: test>>') }
+    end
+
+    context 'with response hash' do
+      let(:exception) { { status: 400 } }
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status 400') }
+      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+    end
+
+    context 'with string' do
+      let(:exception) { 'custom message' }
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to be_nil }
+      it { expect(subject.message).to eq('custom message') }
+      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: custom message>>') }
+    end
+
+    context 'with anything else #to_s' do
+      let(:exception) { %w[error1 error2] }
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to be_nil }
+      it { expect(subject.message).to eq('["error1", "error2"]') }
+      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: ["error1", "error2"]>>') }
+    end
+
+    context 'maintains backward-compatibility until 1.0' do
+      it 'does not raise an error for error-namespaced classes but prints an error message' do
+        error_message, error = with_warn_squelching { Faraday::Error::ClientError.new('foo') }
+
+        expect(error).to be_a Faraday::ClientError
+        expect(error_message).to match(
+          Regexp.new(
+            'NOTE: Faraday::Error::ClientError.new is deprecated; '\
+            'use Faraday::ClientError.new instead. It will be removed in or after version 1.0'
+          )
+        )
+      end
+
+      it 'does not raise an error for inherited error-namespaced classes but prints an error message' do
+        error_message, = with_warn_squelching { Class.new(Faraday::Error::ClientError) }
+
+        expect(error_message).to match(
+          Regexp.new(
+            'NOTE: Inheriting Faraday::Error::ClientError is deprecated; '\
+            'use Faraday::ClientError instead. It will be removed in or after version 1.0'
+          )
+        )
+      end
+
+      it 'allows backward-compatible class to be subclassed' do
+        expect {
+          with_warn_squelching { Class.new(Faraday::Error::ClientError) }
+        }.not_to raise_error
+      end
+
+      it 'allows rescuing of a current error with a deprecated error' do
+        expect { raise Faraday::ClientError, nil }.to raise_error(Faraday::Error::ClientError)
+      end
+
+      it 'allows rescuing of a current error with a current error' do
+        expect { raise Faraday::ClientError, nil }.to raise_error(Faraday::ClientError)
+      end
+
+      it 'allows rescuing of a deprecated error with a deprecated error' do
+        expect { raise Faraday::Error::ClientError, nil }.to raise_error(Faraday::Error::ClientError)
+      end
+
+      it 'allows rescuing of a deprecated error with a current error' do
+        expect { raise Faraday::Error::ClientError, nil }.to raise_error(Faraday::ClientError)
+      end
+    end
+
+    def with_warn_squelching
+      stderr_catcher = StringIO.new
+      original_stderr = $stderr
+      $stderr = stderr_catcher
+      result = yield if block_given?
+      [stderr_catcher.tap(&:rewind).string, result]
+    ensure
+      $stderr = original_stderr
+    end
+  end
+end