faraday 0.17.4 → 1.8.0

data/lib/faraday/adapter/net_http.rb

@@ -1,153 +0,0 @@
-begin
-  require 'net/https'
-rescue LoadError
-  warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
-  require 'net/http'
-end
-require 'zlib'
-
-module Faraday
-  class Adapter
-    class NetHttp < Faraday::Adapter
-      NET_HTTP_EXCEPTIONS = [
-        IOError,
-        Errno::EADDRNOTAVAIL,
-        Errno::ECONNABORTED,
-        Errno::ECONNREFUSED,
-        Errno::ECONNRESET,
-        Errno::EHOSTUNREACH,
-        Errno::EINVAL,
-        Errno::ENETUNREACH,
-        Errno::EPIPE,
-        Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError,
-        SocketError,
-        Zlib::GzipFile::Error,
-      ]
-
-      NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
-      NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
-
-      def initialize(app = nil, opts = {}, &block)
-        @cert_store = nil
-        super(app, opts, &block)
-      end
-
-      def call(env)
-        super
-        with_net_http_connection(env) do |http|
-          configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-          configure_request(http, env[:request])
-
-          begin
-            http_response = perform_request(http, env)
-          rescue *NET_HTTP_EXCEPTIONS => err
-            if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-              raise Faraday::SSLError, err
-            else
-              raise Faraday::ConnectionFailed, err
-            end
-          end
-
-          save_response(env, http_response.code.to_i, http_response.body || '', nil, http_response.message) do |response_headers|
-            http_response.each_header do |key, value|
-              response_headers[key] = value
-            end
-          end
-        end
-
-        @app.call env
-      rescue Timeout::Error, Errno::ETIMEDOUT => err
-        raise Faraday::TimeoutError, err
-      end
-
-      private
-
-      def create_request(env)
-        request = Net::HTTPGenericRequest.new \
-          env[:method].to_s.upcase,    # request method
-          !!env[:body],                # is there request body
-          :head != env[:method],       # is there response body
-          env[:url].request_uri,       # request uri path
-          env[:request_headers]        # request headers
-
-        if env[:body].respond_to?(:read)
-          request.body_stream = env[:body]
-        else
-          request.body = env[:body]
-        end
-        request
-      end
-
-      def perform_request(http, env)
-        if :get == env[:method] and !env[:body]
-          # prefer `get` to `request` because the former handles gzip (ruby 1.9)
-          http.get env[:url].request_uri, env[:request_headers]
-        else
-          http.request create_request(env)
-        end
-      end
-
-      def with_net_http_connection(env)
-        yield net_http_connection(env)
-      end
-
-      def net_http_connection(env)
-        if proxy = env[:request][:proxy]
-          Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
-        else
-          Net::HTTP
-        end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
-      end
-
-      def configure_ssl(http, ssl)
-        http.use_ssl      = true
-        http.verify_mode  = ssl_verify_mode(ssl)
-        http.cert_store   = ssl_cert_store(ssl)
-
-        http.cert         = ssl[:client_cert]  if ssl[:client_cert]
-        http.key          = ssl[:client_key]   if ssl[:client_key]
-        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
-        http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
-        http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        http.ssl_version  = ssl[:version]      if ssl[:version]
-        http.min_version  = ssl[:min_version]  if ssl[:min_version]
-        http.max_version  = ssl[:max_version]  if ssl[:max_version]
-      end
-
-      def configure_request(http, req)
-        if req[:timeout]
-          http.read_timeout  = req[:timeout]
-          http.open_timeout  = req[:timeout]
-          http.write_timeout = req[:timeout] if http.respond_to?(:write_timeout=)
-        end
-        http.open_timeout  = req[:open_timeout]  if req[:open_timeout]
-        http.write_timeout = req[:write_timeout] if req[:write_timeout] && http.respond_to?(:write_timeout=)
-          # Only set if Net::Http supports it, since Ruby 2.5.
-        http.max_retries  = 0                    if http.respond_to?(:max_retries=)
-
-        @config_block.call(http) if @config_block
-      end
-
-      def ssl_cert_store(ssl)
-        return ssl[:cert_store] if ssl[:cert_store]
-        return @cert_store if @cert_store
-        # Use the default cert store by default, i.e. system ca certs
-        @cert_store = OpenSSL::X509::Store.new
-        @cert_store.set_default_paths
-        @cert_store
-      end
-
-      def ssl_verify_mode(ssl)
-        ssl[:verify_mode] || begin
-          if ssl.fetch(:verify, true)
-            OpenSSL::SSL::VERIFY_PEER
-          else
-            OpenSSL::SSL::VERIFY_NONE
-          end
-        end
-      end
-    end
-  end
-end

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,68 +0,0 @@
-module Faraday
-  class Adapter
-    class NetHttpPersistent < NetHttp
-      dependency 'net/http/persistent'
-
-      private
-
-      def net_http_connection(env)
-        @cached_connection ||=
-          if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
-            options = {name: 'Faraday'}
-            options[:pool_size] = @connection_options[:pool_size] if @connection_options.key?(:pool_size)
-            Net::HTTP::Persistent.new(**options)
-          else
-            Net::HTTP::Persistent.new('Faraday')
-          end
-
-        proxy_uri = proxy_uri(env)
-        @cached_connection.proxy = proxy_uri if @cached_connection.proxy_uri != proxy_uri
-        @cached_connection
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        if (proxy = env[:request][:proxy])
-          proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8 not unescaping user/password
-          (class << proxy_uri; self; end).class_eval do
-            define_method(:user) { proxy[:user] }
-            define_method(:password) { proxy[:password] }
-          end if proxy[:user]
-        end
-        proxy_uri
-      end
-
-      def perform_request(http, env)
-        http.request env[:url], create_request(env)
-      rescue Errno::ETIMEDOUT => error
-        raise Faraday::TimeoutError, error
-      rescue Net::HTTP::Persistent::Error => error
-        if error.message.include? 'Timeout'
-          raise Faraday::TimeoutError, error
-        elsif error.message.include? 'connection refused'
-          raise Faraday::ConnectionFailed, error
-        else
-          raise
-        end
-      end
-
-      def configure_ssl(http, ssl)
-        http_set(http, :verify_mode, ssl_verify_mode(ssl))
-        http_set(http, :cert_store,  ssl_cert_store(ssl))
-
-        http_set(http, :certificate, ssl[:client_cert]) if ssl[:client_cert]
-        http_set(http, :private_key, ssl[:client_key])  if ssl[:client_key]
-        http_set(http, :ca_file,     ssl[:ca_file])     if ssl[:ca_file]
-        http_set(http, :ssl_version, ssl[:version])     if ssl[:version]
-      end
-
-      def http_set(http, attr, value)
-        if http.send(attr) != value
-          http.send("#{attr}=", value)
-        end
-      end
-    end
-  end
-end

data/lib/faraday/adapter/patron.rb

@@ -1,95 +0,0 @@
-module Faraday
-  class Adapter
-    class Patron < Faraday::Adapter
-      dependency 'patron'
-
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        session = ::Patron::Session.new
-        @config_block.call(session) if @config_block
-        configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-        if req = env[:request]
-          session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
-          session.connect_timeout = req[:open_timeout]              if req[:open_timeout]
-
-          if proxy = req[:proxy]
-            proxy_uri = proxy[:uri].dup
-            proxy_uri.user = proxy[:user] && Utils.escape(proxy[:user]).gsub('+', '%20')
-            proxy_uri.password = proxy[:password] && Utils.escape(proxy[:password]).gsub('+', '%20')
-            session.proxy = proxy_uri.to_s
-          end
-        end
-
-        response = begin
-          data = env[:body] ? env[:body].to_s : nil
-          session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
-        rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-          raise Faraday::ConnectionFailed, $!
-        end
-
-        # Remove the "HTTP/1.1 200", leaving just the reason phrase
-        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
-
-        save_response(env, response.status, response.body, response.headers, reason_phrase)
-
-        @app.call env
-      rescue ::Patron::TimeoutError => err
-        if connection_timed_out_message?(err.message)
-          raise Faraday::ConnectionFailed, err
-        else
-          raise Faraday::TimeoutError, err
-        end
-      rescue ::Patron::Error => err
-        if err.message.include?("code 407")
-          raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Faraday::ConnectionFailed, err
-        end
-      end
-
-      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
-        # HAX: helps but doesn't work completely
-        # https://github.com/toland/patron/issues/34
-        ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          if actions[0].is_a?(Symbol)
-            actions << :patch unless actions.include? :patch
-            actions << :options unless actions.include? :options
-          else
-            # Patron 0.4.20 and up
-            actions << "PATCH" unless actions.include? "PATCH"
-            actions << "OPTIONS" unless actions.include? "OPTIONS"
-          end
-        end
-      end
-
-      def configure_ssl(session, ssl)
-        if ssl.fetch(:verify, true)
-          session.cacert = ssl[:ca_file]
-        else
-          session.insecure = true
-        end
-      end
-
-      private
-
-      CURL_TIMEOUT_MESSAGES = [ "Connection time-out",
-          "Connection timed out",
-          "Timed out before name resolve",
-          "server connect has timed out",
-          "Resolving timed out",
-          "name lookup timed out",
-          "timed out before SSL",
-          "connect() timed out"
-        ].freeze
-
-      def connection_timed_out_message?(message)
-        CURL_TIMEOUT_MESSAGES.any? { |curl_message| message.include?(curl_message) }
-      end
-
-    end
-  end
-end

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/upload_io.rb

@@ -1,67 +0,0 @@
-begin
-  require 'composite_io'
-  require 'parts'
-  require 'stringio'
-rescue LoadError
-  $stderr.puts "Install the multipart-post gem."
-  raise
-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
-
-  UploadIO = ::UploadIO
-  Parts = ::Parts
-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