faraday 0.17.6 → 1.10.0

data/lib/faraday/adapter/rack.rb

@@ -1,58 +0,0 @@
-module Faraday
-  class Adapter
-    # Sends requests to a Rack app.
-    #
-    # Examples
-    #
-    #   class MyRackApp
-    #     def call(env)
-    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
-    #     end
-    #   end
-    #
-    #   Faraday.new do |conn|
-    #     conn.adapter :rack, MyRackApp.new
-    #   end
-    class Rack < Faraday::Adapter
-      dependency 'rack/test'
-
-      # not prefixed with "HTTP_"
-      SPECIAL_HEADERS = %w[ CONTENT_LENGTH CONTENT_TYPE ]
-
-      def initialize(faraday_app, rack_app)
-        super(faraday_app)
-        mock_session = ::Rack::MockSession.new(rack_app)
-        @session     = ::Rack::Test::Session.new(mock_session)
-      end
-
-      def call(env)
-        super
-        rack_env = {
-          :method => env[:method],
-          :input  => env[:body].respond_to?(:read) ? env[:body].read : env[:body],
-          'rack.url_scheme' => env[:url].scheme
-        }
-
-        env[:request_headers].each do |name, value|
-          name = name.upcase.tr('-', '_')
-          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
-          rack_env[name] = value
-        end if env[:request_headers]
-
-        timeout  = env[:request][:timeout] || env[:request][:open_timeout]
-        response = if timeout
-          Timer.timeout(timeout, Faraday::TimeoutError) { execute_request(env, rack_env) }
-        else
-          execute_request(env, rack_env)
-        end
-
-        save_response(env, response.status, response.body, response.headers)
-        @app.call env
-      end
-
-      def execute_request(env, rack_env)
-        @session.request(env[:url].to_s, rack_env)
-      end
-    end
-  end
-end

data/lib/faraday/deprecate.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # @param new_klass [Class] new Klass to use
-  #
-  # @return [Class] A modified version of new_klass that warns on
-  #   usage about deprecation.
-  # @see Faraday::Deprecate
-  module DeprecatedClass
-    def self.proxy_class(origclass, ver = '1.0')
-      proxy = Class.new(origclass) do
-        const_set("ORIG_CLASS", origclass)
-
-        class << self
-          extend Faraday::Deprecate
-
-          def ===(other)
-            (superclass == const_get("ORIG_CLASS") && other.is_a?(superclass)) || super
-          end
-        end
-      end
-      proxy.singleton_class.send(:deprecate, :new, "#{origclass}.new", ver)
-      proxy.singleton_class.send(:deprecate, :inherited, origclass.name, ver)
-      proxy
-    end
-  end
-
-  # Deprecation using semver instead of date, based on Gem::Deprecate
-  # Provides a single method +deprecate+ to be used to declare when
-  # something is going away.
-  #
-  #     class Legacy
-  #       def self.klass_method
-  #         # ...
-  #       end
-  #
-  #       def instance_method
-  #         # ...
-  #       end
-  #
-  #       extend Faraday::Deprecate
-  #       deprecate :instance_method, "X.z", '1.0'
-  #
-  #       class << self
-  #         extend Faraday::Deprecate
-  #         deprecate :klass_method, :none, '1.0'
-  #       end
-  #     end
-  module Deprecate
-    def self.skip # :nodoc:
-      @skip ||= begin
-        case ENV['FARADAY_DEPRECATE'].to_s.downcase
-        when '1', 'warn' then :warn
-        else :skip
-        end
-      end
-      @skip == :skip
-    end
-
-    def self.skip=(value) # :nodoc:
-      @skip = value ? :skip : :warn
-    end
-
-    # Temporarily turn off warnings. Intended for tests only.
-    def skip_during
-      original = Faraday::Deprecate.skip
-      Faraday::Deprecate.skip, = true
-      yield
-    ensure
-      Faraday::Deprecate.skip = original
-    end
-
-    # Simple deprecation method that deprecates +name+ by wrapping it up
-    # in a dummy method. It warns on each call to the dummy method
-    # telling the user of +repl+ (unless +repl+ is :none) and the
-    # semver that it is planned to go away.
-    # @param name [Symbol] the method symbol to deprecate
-    # @param repl [#to_s, :none] the replacement to use, when `:none` it will
-    #   alert the user that no replacemtent is present.
-    # @param ver [String] the semver the method will be removed.
-    def deprecate(name, repl, ver)
-      class_eval do
-        gem_ver = Gem::Version.new(ver)
-        old = "_deprecated_#{name}"
-        alias_method old, name
-        define_method name do |*args, &block|
-          mod = is_a? Module
-          target = mod ? "#{self}." : "#{self.class}#"
-          target_message = if name == :inherited
-                             "Inheriting #{self}"
-                           else
-                             "#{target}#{name}"
-                           end
-
-          msg = [
-            "NOTE: #{target_message} is deprecated",
-            repl == :none ? ' with no replacement' : "; use #{repl} instead. ",
-            "It will be removed in or after version #{gem_ver}",
-            "\n#{target}#{name} called from #{Gem.location_of_caller.join(':')}"
-          ]
-          warn "#{msg.join}." unless Faraday::Deprecate.skip
-          send old, *args, &block
-        end
-      end
-    end
-
-    module_function :deprecate, :skip_during
-  end
-end

data/lib/faraday/request/multipart.rb

@@ -1,68 +0,0 @@
-require File.expand_path("../url_encoded", __FILE__)
-require 'securerandom'
-
-module Faraday
-  class Request::Multipart < Request::UrlEncoded
-    self.mime_type = 'multipart/form-data'.freeze
-    DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
-
-    def call(env)
-      match_content_type(env) do |params|
-        env.request.boundary ||= unique_boundary
-        env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
-        env.body = create_multipart(env, params)
-      end
-      @app.call env
-    end
-
-    def process_request?(env)
-      type = request_type(env)
-      env.body.respond_to?(:each_key) and !env.body.empty? and (
-        (type.empty? and has_multipart?(env.body)) or
-        type == self.class.mime_type
-      )
-    end
-
-    def has_multipart?(obj)
-      # string is an enum in 1.8, returning list of itself
-      if obj.respond_to?(:each) && !obj.is_a?(String)
-        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
-          return true if (val.respond_to?(:content_type) || has_multipart?(val))
-        end
-      end
-      false
-    end
-
-    def create_multipart(env, params)
-      boundary = env.request.boundary
-      parts = process_params(params) do |key, value|
-        Faraday::Parts::Part.new(boundary, key, value)
-      end
-      parts << Faraday::Parts::EpiloguePart.new(boundary)
-
-      body = Faraday::CompositeReadIO.new(parts)
-      env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
-      return body
-    end
-
-    def unique_boundary
-      "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
-    end
-
-    def process_params(params, prefix = nil, pieces = nil, &block)
-      params.inject(pieces || []) do |all, (key, value)|
-        key = "#{prefix}[#{key}]" if prefix
-
-        case value
-        when Array
-          values = value.inject([]) { |a,v| a << [nil, v] }
-          process_params(values, key, all, &block)
-        when Hash
-          process_params(value, key, all, &block)
-        else
-          all << block.call(key, value)
-        end
-      end
-    end
-  end
-end

data/lib/faraday/request/retry.rb

@@ -1,213 +0,0 @@
-require 'date'
-
-module Faraday
-  # Catches exceptions and retries each request a limited number of times.
-  #
-  # By default, it retries 2 times and handles only timeout exceptions. It can
-  # be configured with an arbitrary number of retries, a list of exceptions to
-  # handle, a retry interval, a percentage of randomness to add to the retry
-  # interval, and a backoff factor.
-  #
-  # Examples
-  #
-  #   Faraday.new do |conn|
-  #     conn.request :retry, max: 2, interval: 0.05,
-  #                          interval_randomness: 0.5, backoff_factor: 2,
-  #                          exceptions: [CustomException, 'Timeout::Error']
-  #     conn.adapter ...
-  #   end
-  #
-  # This example will result in a first interval that is random between 0.05 and 0.075 and a second
-  # interval that is random between 0.1 and 0.15
-  #
-  class Request::Retry < Faraday::Middleware
-    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,
-                                         :backoff_factor, :exceptions, :methods, :retry_if, :retry_block,
-                                         :retry_statuses)
-
-      DEFAULT_CHECK = lambda { |env,exception| false }
-
-      def self.from(value)
-        if Integer === value
-          new(value)
-        else
-          super(value)
-        end
-      end
-
-      def max
-        (self[:max] ||= 2).to_i
-      end
-
-      def interval
-        (self[:interval] ||= 0).to_f
-      end
-
-      def max_interval
-        (self[:max_interval] ||= Float::MAX).to_f
-      end
-
-      def interval_randomness
-        (self[:interval_randomness] ||= 0).to_f
-      end
-
-      def backoff_factor
-        (self[:backoff_factor] ||= 1).to_f
-      end
-
-      def exceptions
-        Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
-      end
-
-      def methods
-        Array(self[:methods] ||= IDEMPOTENT_METHODS)
-      end
-
-      def retry_if
-        self[:retry_if] ||= DEFAULT_CHECK
-      end
-
-      def retry_block
-        self[:retry_block] ||= Proc.new {}
-      end
-
-      def retry_statuses
-        Array(self[:retry_statuses] ||= [])
-      end
-    end
-
-    # Public: Initialize middleware
-    #
-    # Options:
-    # max                 - Maximum number of retries (default: 2)
-    # interval            - Pause in seconds between retries (default: 0)
-    # interval_randomness - The maximum random interval amount expressed
-    #                       as a float between 0 and 1 to use in addition to the
-    #                       interval. (default: 0)
-    # max_interval        - An upper limit for the interval (default: Float::MAX)
-    # backoff_factor      - The amount to multiple each successive retry's
-    #                       interval amount by in order to provide backoff
-    #                       (default: 1)
-    # exceptions          - The list of exceptions to handle. Exceptions can be
-    #                       given as Class, Module, or String. (default:
-    #                       [Errno::ETIMEDOUT, 'Timeout::Error',
-    #                       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)
-    # retry_if            - block that will receive the env object and the exception raised
-    #                       and should decide if the code should retry still the action or
-    #                       not independent of the retry count. This would be useful
-    #                       if the exception produced is non-recoverable or if the
-    #                       the HTTP method called is not idempotent.
-    #                       (defaults to return false)
-    # retry_block         - block that is executed after every retry. Request environment, middleware options,
-    #                       current number of retries and the exception is passed to the block as parameters.
-    def initialize(app, options = nil)
-      super(app)
-      @options = Options.from(options)
-      @errmatch = build_exception_matcher(@options.exceptions)
-    end
-
-    def calculate_sleep_amount(retries, env)
-      retry_after     = calculate_retry_after(env)
-      retry_interval  = calculate_retry_interval(retries)
-
-      return if retry_after && retry_after > @options.max_interval
-
-      retry_after && retry_after >= retry_interval ? retry_after : retry_interval
-    end
-
-    def call(env)
-      retries = @options.max
-      request_body = env[:body]
-      begin
-        env[:body] = request_body # after failure env[:body] is set to the response body
-        @app.call(env).tap do |resp|
-          raise Faraday::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
-        end
-      rescue @errmatch => exception
-        if retries > 0 && retry_request?(env, exception)
-          retries -= 1
-          rewind_files(request_body)
-          @options.retry_block.call(env, @options, retries, exception)
-          if (sleep_amount = calculate_sleep_amount(retries + 1, env))
-            sleep sleep_amount
-            retry
-          end
-        end
-
-        if exception.is_a?(Faraday::RetriableResponse)
-          exception.response
-        else
-          raise
-        end
-      end
-    end
-
-    # Private: construct an exception matcher object.
-    #
-    # An exception matcher for the rescue clause can usually be any object that
-    # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
-    def build_exception_matcher(exceptions)
-      matcher = Module.new
-      (class << matcher; self; end).class_eval do
-        define_method(:===) do |error|
-          exceptions.any? do |ex|
-            if ex.is_a? Module
-              error.is_a? ex
-            else
-              error.class.to_s == ex.to_s
-            end
-          end
-        end
-      end
-      matcher
-    end
-
-    private
-
-    def retry_request?(env, exception)
-      @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
-    end
-
-    def rewind_files(body)
-      return unless body.is_a?(Hash)
-      body.each do |_, value|
-        if value.is_a? UploadIO
-          value.rewind
-        end
-      end
-    end
-
-    # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
-    def calculate_retry_after(env)
-      response_headers = env[:response_headers]
-      return unless response_headers
-
-      retry_after_value = env[:response_headers]["Retry-After"]
-
-      # Try to parse date from the header value
-      begin
-        datetime = DateTime.rfc2822(retry_after_value)
-        datetime.to_time - Time.now.utc
-      rescue ArgumentError
-        retry_after_value.to_f
-      end
-    end
-
-    def calculate_retry_interval(retries)
-      retry_index = @options.max - retries
-      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
-      current_interval = [current_interval, @options.max_interval].min
-      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
-
-      current_interval + random_interval
-    end
-  end
-end

data/lib/faraday/upload_io.rb

@@ -1,77 +0,0 @@
-begin
-  require 'multipart/post'
-  require 'stringio'
-rescue LoadError
-  begin
-    require 'composite_io'
-    require 'parts'
-    require 'stringio'
-  rescue LoadError
-    $stderr.puts "Install the multipart-post gem."
-    raise
-  end
-end
-
-module Faraday
-  # Similar but not compatible with ::CompositeReadIO provided by multipart-post.
-  class CompositeReadIO
-    def initialize(*parts)
-      @parts = parts.flatten
-      @ios = @parts.map { |part| part.to_io }
-      @index = 0
-    end
-
-    def length
-      @parts.inject(0) { |sum, part| sum + part.length }
-    end
-
-    def rewind
-      @ios.each { |io| io.rewind }
-      @index = 0
-    end
-
-    # Read from IOs in order until `length` bytes have been received.
-    def read(length = nil, outbuf = nil)
-      got_result = false
-      outbuf = outbuf ? outbuf.replace("") : ""
-
-      while io = current_io
-        if result = io.read(length)
-          got_result ||= !result.nil?
-          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
-          outbuf << result
-          length -= result.length if length
-          break if length == 0
-        end
-        advance_io
-      end
-      (!got_result && length) ? nil : outbuf
-    end
-
-    def close
-      @ios.each { |io| io.close }
-    end
-
-    def ensure_open_and_readable
-      # Rubinius compatibility
-    end
-
-    private
-
-    def current_io
-      @ios[@index]
-    end
-
-    def advance_io
-      @index += 1
-    end
-  end
-
-  if defined?(::Multipart::Post::UploadIO)
-    UploadIO = ::Multipart::Post::UploadIO
-    Parts = ::Multipart::Post::Parts
-  else
-    UploadIO = ::UploadIO
-    Parts = ::Parts
-  end
-end

data/spec/faraday/deprecate_spec.rb

@@ -1,147 +0,0 @@
-# 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/test/adapters/default_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path('../integration', __FILE__)
-
-module Adapters
-  class DefaultTest < Faraday::TestCase
-
-    def adapter() :default end
-
-    Integration.apply(self, :NonParallel) do
-      # default stack is not configured with Multipart
-      undef :test_POST_sends_files
-    end
-
-  end
-end