faraday 1.1.0 → 2.7.4

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Net::HTTP::Persistent 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 == %i[key name]
-            options = { name: 'Faraday' }
-            if @connection_options.key?(:pool_size)
-              options[:pool_size] = @connection_options[:pool_size]
-            end
-            Net::HTTP::Persistent.new(**options)
-          else
-            Net::HTTP::Persistent.new('Faraday')
-          end
-
-        proxy_uri = proxy_uri(env)
-        if @cached_connection.proxy_uri != proxy_uri
-          @cached_connection.proxy = proxy_uri
-        end
-        @cached_connection
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        if (proxy = env[:request][:proxy])
-          proxy_uri = if proxy[:uri].is_a?(::URI::HTTP)
-                        proxy[:uri].dup
-                      else
-                        ::URI.parse(proxy[:uri].to_s)
-                      end
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8
-          # not unescaping user/password
-          if proxy[:user]
-            (class << proxy_uri; self; end).class_eval do
-              define_method(:user) { proxy[:user] }
-              define_method(:password) { proxy[:password] }
-            end
-          end
-        end
-        proxy_uri
-      end
-
-      def perform_request(http, env)
-        http.request env[:url], create_request(env)
-      rescue Errno::ETIMEDOUT => e
-        raise Faraday::TimeoutError, e
-      rescue Net::HTTP::Persistent::Error => e
-        raise Faraday::TimeoutError, e if e.message.include? 'Timeout'
-
-        if e.message.include? 'connection refused'
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise
-      end
-
-      SSL_CONFIGURATIONS = {
-        certificate: :client_cert,
-        private_key: :client_key,
-        ca_file: :ca_file,
-        ssl_version: :version,
-        min_version: :min_version,
-        max_version: :max_version
-      }.freeze
-
-      def configure_ssl(http, ssl)
-        return unless ssl
-
-        http_set(http, :verify_mode, ssl_verify_mode(ssl))
-        http_set(http, :cert_store, ssl_cert_store(ssl))
-
-        SSL_CONFIGURATIONS
-          .select { |_, key| ssl[key] }
-          .each { |target, key| http_set(http, target, ssl[key]) }
-      end
-
-      def http_set(http, attr, value)
-        http.send("#{attr}=", value) if http.send(attr) != value
-      end
-    end
-  end
-end

data/lib/faraday/adapter/patron.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Patron adapter.
-    class Patron < Faraday::Adapter
-      dependency 'patron'
-
-      def build_connection(env)
-        session = ::Patron::Session.new
-        @config_block&.call(session)
-        if (env[:url].scheme == 'https') && env[:ssl]
-          configure_ssl(session, env[:ssl])
-        end
-
-        if (req = env[:request])
-          configure_timeouts(session, req)
-          configure_proxy(session, req[:proxy])
-        end
-
-        session
-      end
-
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        response = connection(env) do |session|
-          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, $ERROR_INFO
-          end
-        end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        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 => e
-        if connection_timed_out_message?(e.message)
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise Faraday::TimeoutError, e
-      rescue ::Patron::Error => e
-        if e.message.include?('code 407')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required ")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      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
-
-      def configure_timeouts(session, req)
-        return unless req
-
-        if (sec = request_timeout(:read, req))
-          session.timeout = sec
-        end
-
-        return unless (sec = request_timeout(:open, req))
-
-        session.connect_timeout = sec
-      end
-
-      def configure_proxy(session, proxy)
-        return unless 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
-
-      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? do |curl_message|
-          message.include?(curl_message)
-        end
-      end
-    end
-  end
-end

data/lib/faraday/adapter/rack.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Sends requests to a Rack app.
-    #
-    # @example
-    #
-    #   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].freeze
-
-      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 = build_rack_env(env)
-
-        env[:request_headers]&.each do |name, value|
-          name = name.upcase.tr('-', '_')
-          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
-          rack_env[name] = value
-        end
-
-        timeout = request_timeout(:open, env[:request])
-        timeout ||= request_timeout(:read, env[:request])
-        response = if timeout
-                     Timer.timeout(timeout, Faraday::TimeoutError) do
-                       execute_request(env, rack_env)
-                     end
-                   else
-                     execute_request(env, rack_env)
-                   end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        end
-
-        save_response(env, response.status, response.body, response.headers)
-        @app.call env
-      end
-
-      private
-
-      def execute_request(env, rack_env)
-        @session.request(env[:url].to_s, rack_env)
-      end
-
-      def build_rack_env(env)
-        {
-          method: env[:method],
-          input: env[:body].respond_to?(:read) ? env[:body].read : env[:body],
-          'rack.url_scheme' => env[:url].scheme
-        }
-      end
-    end
-  end
-end

data/lib/faraday/adapter/typhoeus.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Typhoeus adapter. This class is just a stub, the real adapter is in
-    # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
-    class Typhoeus < Faraday::Adapter
-      # Needs to define this method in order to support Typhoeus <= 1.3.0
-      def call; end
-
-      dependency 'typhoeus'
-      dependency 'typhoeus/adapters/faraday'
-    end
-  end
-end

data/lib/faraday/autoload.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Adds the ability for other modules to manage autoloadable
-  # constants.
-  #
-  # @api private
-  module AutoloadHelper
-    # Registers the constants to be auto loaded.
-    #
-    # @param prefix [String] The require prefix. If the path is inside Faraday,
-    #           then it will be prefixed with the root path of this loaded
-    #           Faraday version.
-    # @param options [{ Symbol => String }] library names.
-    #
-    # @example
-    #
-    #   Faraday.autoload_all 'faraday/foo',
-    #     Bar: 'bar'
-    #
-    #   # requires faraday/foo/bar to load Faraday::Bar.
-    #   Faraday::Bar
-    #
-    # @return [void]
-    def autoload_all(prefix, options)
-      if prefix.match? %r{^faraday(/|$)}i
-        prefix = File.join(Faraday.root_path, prefix)
-      end
-
-      options.each do |const_name, path|
-        autoload const_name, File.join(prefix, path)
-      end
-    end
-
-    # Loads each autoloaded constant.  If thread safety is a concern,
-    # wrap this in a Mutex.
-    #
-    # @return [void]
-    def load_autoloaded_constants
-      constants.each do |const|
-        const_get(const) if autoload?(const)
-      end
-    end
-
-    # Filters the module's contents with those that have been already
-    # autoloaded.
-    #
-    # @return [Array<Class, Module>]
-    def all_loaded_constants
-      constants
-        .map { |c| const_get(c) }
-        .select { |a| a.respond_to?(:loaded?) && a.loaded? }
-    end
-  end
-
-  # Adapter is the base class for all Faraday adapters.
-  # @see lib/faraday/adapter.rb Original class location
-  class Adapter
-    extend AutoloadHelper
-    autoload_all 'faraday/adapter',
-                 NetHttp: 'net_http',
-                 NetHttpPersistent: 'net_http_persistent',
-                 EMSynchrony: 'em_synchrony',
-                 EMHttp: 'em_http',
-                 Typhoeus: 'typhoeus',
-                 Patron: 'patron',
-                 Excon: 'excon',
-                 Test: 'test',
-                 Rack: 'rack',
-                 HTTPClient: 'httpclient'
-  end
-
-  # Request represents a single HTTP request for a Faraday adapter to make.
-  # @see lib/faraday/request.rb Original class location
-  class Request
-    extend AutoloadHelper
-    autoload_all 'faraday/request',
-                 UrlEncoded: 'url_encoded',
-                 Multipart: 'multipart',
-                 Retry: 'retry',
-                 Authorization: 'authorization',
-                 BasicAuthentication: 'basic_authentication',
-                 TokenAuthentication: 'token_authentication',
-                 Instrumentation: 'instrumentation'
-  end
-
-  # Response represents the returned value of a sent Faraday request.
-  # @see lib/faraday/response.rb Original class location
-  class Response
-    extend AutoloadHelper
-    autoload_all 'faraday/response',
-                 RaiseError: 'raise_error',
-                 Logger: 'logger'
-  end
-end

data/lib/faraday/dependency_loader.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby2_keywords'
-
-module Faraday
-  # DependencyLoader helps Faraday adapters and middleware load dependencies.
-  module DependencyLoader
-    attr_reader :load_error
-
-    # Executes a block which should try to require and reference dependent
-    # libraries
-    def dependency(lib = nil)
-      lib ? require(lib) : yield
-    rescue LoadError, NameError => e
-      self.load_error = e
-    end
-
-    ruby2_keywords def new(*)
-      unless loaded?
-        raise "missing dependency for #{self}: #{load_error.message}"
-      end
-
-      super
-    end
-
-    def loaded?
-      load_error.nil?
-    end
-
-    def inherited(subclass)
-      super
-      subclass.send(:load_error=, load_error)
-    end
-
-    private
-
-    attr_writer :load_error
-  end
-end

data/lib/faraday/file_part.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-# multipart-post gem
-require 'composite_io'
-require 'parts'
-
-module Faraday
-  # Multipart value used to POST a binary data from a file or
-  #
-  # @example
-  #   payload = { file: Faraday::FilePart.new("file_name.ext", "content/type") }
-  #   http.post("/upload", payload)
-  #
-
-  # @!method initialize(filename_or_io, content_type, filename = nil, opts = {})
-  #
-  #   @param filename_or_io [String, IO] Either a String filename to a local
-  #     file or an open IO object.
-  #   @param content_type [String] String content type of the file data.
-  #   @param filename [String] Optional String filename, usually to add context
-  #     to a given IO object.
-  #   @param opts [Hash] Optional Hash of String key/value pairs to describethis
-  #     this uploaded file. Expected Header keys include:
-  #     * Content-Transfer-Encoding - Defaults to "binary"
-  #     * Content-Disposition - Defaults to "form-data"
-  #     * Content-Type - Defaults to the content_type argument.
-  #     * Content-ID - Optional.
-  #
-  # @return [Faraday::FilePart]
-  #
-  # @!attribute [r] content_type
-  # The uploaded binary data's content type.
-  #
-  # @return [String]
-  #
-  # @!attribute [r] original_filename
-  # The base filename, taken either from the filename_or_io or filename
-  # arguments in #initialize.
-  #
-  # @return [String]
-  #
-  # @!attribute [r] opts
-  # Extra String key/value pairs to make up the header for this uploaded file.
-  #
-  # @return [Hash]
-  #
-  # @!attribute [r] io
-  # The open IO object for the uploaded file.
-  #
-  # @return [IO]
-  FilePart = ::UploadIO
-
-  # Multipart value used to POST a file.
-  #
-  # @deprecated Use FilePart instead of this class. It behaves identically, with
-  #   a matching name to ParamPart.
-  UploadIO = ::UploadIO
-
-  Parts = ::Parts
-
-  # Similar to, but not compatible with CompositeReadIO provided by the
-  # multipart-post gem.
-  # https://github.com/nicksieger/multipart-post/blob/master/lib/composite_io.rb
-  class CompositeReadIO
-    def initialize(*parts)
-      @parts = parts.flatten
-      @ios = @parts.map(&:to_io)
-      @index = 0
-    end
-
-    # @return [Integer] sum of the lengths of all the parts
-    def length
-      @parts.inject(0) { |sum, part| sum + part.length }
-    end
-
-    # Rewind each of the IOs and reset the index to 0.
-    #
-    # @return [void]
-    def rewind
-      @ios.each(&:rewind)
-      @index = 0
-    end
-
-    # Read from IOs in order until `length` bytes have been received.
-    #
-    # @param length [Integer, nil]
-    # @param outbuf [String, nil]
-    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&.zero?
-        end
-        advance_io
-      end
-      !got_result && length ? nil : outbuf
-    end
-
-    # Close each of the IOs.
-    #
-    # @return [void]
-    def close
-      @ios.each(&:close)
-    end
-
-    def ensure_open_and_readable
-      # Rubinius compatibility
-    end
-
-    private
-
-    def current_io
-      @ios[@index]
-    end
-
-    def advance_io
-      @index += 1
-    end
-  end
-end

data/lib/faraday/param_part.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Multipart value used to POST data with a content type.
-  class ParamPart
-    # @param value [String] Uploaded content as a String.
-    # @param content_type [String] String content type of the value.
-    # @param content_id [String] Optional String of this value's Content-ID.
-    #
-    # @return [Faraday::ParamPart]
-    def initialize(value, content_type, content_id = nil)
-      @value = value
-      @content_type = content_type
-      @content_id = content_id
-    end
-
-    # Converts this value to a form part.
-    #
-    # @param boundary [String] String multipart boundary that must not exist in
-    #   the content exactly.
-    # @param key [String] String key name for this value.
-    #
-    # @return [Faraday::Parts::Part]
-    def to_part(boundary, key)
-      Faraday::Parts::Part.new(boundary, key, value, headers)
-    end
-
-    # Returns a Hash of String key/value pairs.
-    #
-    # @return [Hash]
-    def headers
-      {
-        'Content-Type' => content_type,
-        'Content-ID' => content_id
-      }
-    end
-
-    # The content to upload.
-    #
-    # @return [String]
-    attr_reader :value
-
-    # The value's content type.
-    #
-    # @return [String]
-    attr_reader :content_type
-
-    # The value's content ID, if given.
-    #
-    # @return [String, nil]
-    attr_reader :content_id
-  end
-end

data/lib/faraday/request/basic_authentication.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module Faraday
-  class Request
-    # Authorization middleware for Basic Authentication.
-    class BasicAuthentication < load_middleware(:authorization)
-      # @param login [String]
-      # @param pass [String]
-      #
-      # @return [String] a Basic Authentication header line
-      def self.header(login, pass)
-        value = Base64.encode64([login, pass].join(':'))
-        value.delete!("\n")
-        super(:Basic, value)
-      end
-    end
-  end
-end