faraday 0.16.0 → 0.17.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Rick Olson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-27 00:00:00.000000000 Z
+date: 2019-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -52,24 +52,11 @@ files:
 - lib/faraday/adapter/rack.rb
 - lib/faraday/adapter/test.rb
 - lib/faraday/adapter/typhoeus.rb
-- lib/faraday/adapter_registry.rb
 - lib/faraday/autoload.rb
 - lib/faraday/connection.rb
-- lib/faraday/dependency_loader.rb
-- lib/faraday/encoders/flat_params_encoder.rb
-- lib/faraday/encoders/nested_params_encoder.rb
 - lib/faraday/error.rb
-- lib/faraday/file_part.rb
-- lib/faraday/logging/formatter.rb
 - lib/faraday/middleware.rb
-- lib/faraday/middleware_registry.rb
 - lib/faraday/options.rb
-- lib/faraday/options/connection_options.rb
-- lib/faraday/options/env.rb
-- lib/faraday/options/proxy_options.rb
-- lib/faraday/options/request_options.rb
-- lib/faraday/options/ssl_options.rb
-- lib/faraday/param_part.rb
 - lib/faraday/parameters.rb
 - lib/faraday/rack_builder.rb
 - lib/faraday/request.rb
@@ -83,10 +70,8 @@ files:
 - lib/faraday/response.rb
 - lib/faraday/response/logger.rb
 - lib/faraday/response/raise_error.rb
+- lib/faraday/upload_io.rb
 - lib/faraday/utils.rb
-- lib/faraday/utils/headers.rb
-- lib/faraday/utils/params_hash.rb
-- spec/external_adapters/faraday_specs_setup.rb
 homepage: https://github.com/lostisland/faraday
 licenses:
 - MIT
@@ -95,20 +80,18 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- spec/external_adapters
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: HTTP/REST API client library.

data/lib/faraday/adapter_registry.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'monitor'
-
-module Faraday
-  # AdapterRegistry registers adapter class names so they can be looked up by a
-  # String or Symbol name.
-  class AdapterRegistry
-    def initialize
-      @lock = Monitor.new
-      @constants = {}
-    end
-
-    def get(name)
-      klass = @constants[name]
-      return klass if klass
-
-      Object.const_get(name).tap { |c| set(c, name) }
-    end
-
-    def set(klass, name = nil)
-      name ||= klass.to_s
-      @lock.synchronize do
-        @constants[name] = klass
-      end
-    end
-  end
-end

data/lib/faraday/dependency_loader.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-    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/encoders/flat_params_encoder.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # FlatParamsEncoder manages URI params as a flat hash. Any Array values repeat
-  # the parameter multiple times.
-  module FlatParamsEncoder
-    class << self
-      extend Forwardable
-      def_delegators :'Faraday::Utils', :escape, :unescape
-    end
-
-    # Encode converts the given param into a URI querystring. Keys and values
-    # will converted to strings and appropriately escaped for the URI.
-    #
-    # @param params [Hash] query arguments to convert.
-    #
-    # @example
-    #
-    #   encode({a: %w[one two three], b: true, c: "C"})
-    #   # => 'a=one&a=two&a=three&b=true&c=C'
-    #
-    # @return [String] the URI querystring (without the leading '?')
-    def self.encode(params)
-      return nil if params.nil?
-
-      unless params.is_a?(Array)
-        unless params.respond_to?(:to_hash)
-          raise TypeError,
-                "Can't convert #{params.class} into Hash."
-        end
-        params = params.to_hash
-        params = params.map do |key, value|
-          key = key.to_s if key.is_a?(Symbol)
-          [key, value]
-        end
-        # Useful default for OAuth and caching.
-        # Only to be used for non-Array inputs. Arrays should preserve order.
-        params.sort!
-      end
-
-      # The params have form [['key1', 'value1'], ['key2', 'value2']].
-      buffer = +''
-      params.each do |key, value|
-        encoded_key = escape(key)
-        if value.nil?
-          buffer << "#{encoded_key}&"
-        elsif value.is_a?(Array)
-          value.each do |sub_value|
-            encoded_value = escape(sub_value)
-            buffer << "#{encoded_key}=#{encoded_value}&"
-          end
-        else
-          encoded_value = escape(value)
-          buffer << "#{encoded_key}=#{encoded_value}&"
-        end
-      end
-      buffer.chop
-    end
-
-    # Decode converts the given URI querystring into a hash.
-    #
-    # @param query [String] query arguments to parse.
-    #
-    # @example
-    #
-    #   decode('a=one&a=two&a=three&b=true&c=C')
-    #   # => {"a"=>["one", "two", "three"], "b"=>"true", "c"=>"C"}
-    #
-    # @return [Hash] parsed keys and value strings from the querystring.
-    def self.decode(query)
-      return nil if query.nil?
-
-      empty_accumulator = {}
-
-      split_query = (query.split('&').map do |pair|
-        pair.split('=', 2) if pair && !pair.empty?
-      end).compact
-      split_query.each_with_object(empty_accumulator.dup) do |pair, accu|
-        pair[0] = unescape(pair[0])
-        pair[1] = true if pair[1].nil?
-        if pair[1].respond_to?(:to_str)
-          pair[1] = unescape(pair[1].to_str.tr('+', ' '))
-        end
-        if accu[pair[0]].is_a?(Array)
-          accu[pair[0]] << pair[1]
-        elsif accu[pair[0]]
-          accu[pair[0]] = [accu[pair[0]], pair[1]]
-        else
-          accu[pair[0]] = pair[1]
-        end
-      end
-    end
-  end
-end

data/lib/faraday/encoders/nested_params_encoder.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Sub-module for encoding parameters into query-string.
-  module EncodeMethods
-    # @param params [nil, Array, #to_hash] parameters to be encoded
-    #
-    # @return [String] the encoded params
-    #
-    # @raise [TypeError] if params can not be converted to a Hash
-    def encode(params)
-      return nil if params.nil?
-
-      unless params.is_a?(Array)
-        unless params.respond_to?(:to_hash)
-          raise TypeError, "Can't convert #{params.class} into Hash."
-        end
-
-        params = params.to_hash
-        params = params.map do |key, value|
-          key = key.to_s if key.is_a?(Symbol)
-          [key, value]
-        end
-        # Useful default for OAuth and caching.
-        # Only to be used for non-Array inputs. Arrays should preserve order.
-        params.sort!
-      end
-
-      # The params have form [['key1', 'value1'], ['key2', 'value2']].
-      buffer = +''
-      params.each do |parent, value|
-        encoded_parent = escape(parent)
-        buffer << "#{encode_pair(encoded_parent, value)}&"
-      end
-      buffer.chop
-    end
-
-    protected
-
-    def encode_pair(parent, value)
-      if value.is_a?(Hash)
-        encode_hash(parent, value)
-      elsif value.is_a?(Array)
-        encode_array(parent, value)
-      elsif value.nil?
-        parent
-      else
-        encoded_value = escape(value)
-        "#{parent}=#{encoded_value}"
-      end
-    end
-
-    def encode_hash(parent, value)
-      value = value.map { |key, val| [escape(key), val] }.sort
-
-      buffer = +''
-      value.each do |key, val|
-        new_parent = "#{parent}%5B#{key}%5D"
-        buffer << "#{encode_pair(new_parent, val)}&"
-      end
-      buffer.chop
-    end
-
-    def encode_array(parent, value)
-      new_parent = "#{parent}%5B%5D"
-      return new_parent if value.empty?
-
-      buffer = +''
-      value.each { |val| buffer << "#{encode_pair(new_parent, val)}&" }
-      buffer.chop
-    end
-  end
-
-  # Sub-module for decoding query-string into parameters.
-  module DecodeMethods
-    # @param query [nil, String]
-    #
-    # @return [Array<Array, String>] the decoded params
-    #
-    # @raise [TypeError] if the nesting is incorrect
-    def decode(query)
-      return nil if query.nil?
-
-      params = {}
-      query.split('&').each do |pair|
-        next if pair.empty?
-
-        key, value = pair.split('=', 2)
-        key = unescape(key)
-        value = unescape(value.tr('+', ' ')) if value
-        decode_pair(key, value, params)
-      end
-
-      dehash(params, 0)
-    end
-
-    protected
-
-    SUBKEYS_REGEX = /[^\[\]]+(?:\]?\[\])?/.freeze
-
-    def decode_pair(key, value, context)
-      subkeys = key.scan(SUBKEYS_REGEX)
-      subkeys.each_with_index do |subkey, i|
-        is_array = subkey =~ /[\[\]]+\Z/
-        subkey = $` if is_array
-        last_subkey = i == subkeys.length - 1
-
-        context = prepare_context(context, subkey, is_array, last_subkey)
-        add_to_context(is_array, context, value, subkey) if last_subkey
-      end
-    end
-
-    def prepare_context(context, subkey, is_array, last_subkey)
-      if !last_subkey || is_array
-        context = new_context(subkey, is_array, context)
-      end
-      if context.is_a?(Array) && !is_array
-        context = match_context(context, subkey)
-      end
-      context
-    end
-
-    def new_context(subkey, is_array, context)
-      value_type = is_array ? Array : Hash
-      if context[subkey] && !context[subkey].is_a?(value_type)
-        raise TypeError, "expected #{value_type.name} " \
-          "(got #{context[subkey].class.name}) for param `#{subkey}'"
-      end
-
-      context[subkey] ||= value_type.new
-    end
-
-    def match_context(context, subkey)
-      context << {} if !context.last.is_a?(Hash) || context.last.key?(subkey)
-      context.last
-    end
-
-    def add_to_context(is_array, context, value, subkey)
-      is_array ? context << value : context[subkey] = value
-    end
-
-    # Internal: convert a nested hash with purely numeric keys into an array.
-    # FIXME: this is not compatible with Rack::Utils.parse_nested_query
-    # @!visibility private
-    def dehash(hash, depth)
-      hash.each do |key, value|
-        hash[key] = dehash(value, depth + 1) if value.is_a?(Hash)
-      end
-
-      if depth.positive? && !hash.empty? && hash.keys.all? { |k| k =~ /^\d+$/ }
-        hash.sort.map(&:last)
-      else
-        hash
-      end
-    end
-  end
-
-  # This is the default encoder for Faraday requests.
-  # Using this encoder, parameters will be encoded respecting their structure,
-  # so you can send objects such as Arrays or Hashes as parameters
-  # for your requests.
-  module NestedParamsEncoder
-    class << self
-      extend Forwardable
-      def_delegators :'Faraday::Utils', :escape, :unescape
-    end
-
-    extend EncodeMethods
-    extend DecodeMethods
-  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/logging/formatter.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-module Faraday
-  module Logging
-    # Serves as an integration point to customize logging
-    class Formatter
-      extend Forwardable
-
-      DEFAULT_OPTIONS = { headers: true, bodies: false }.freeze
-
-      def initialize(logger:, options:)
-        @logger = logger
-        @filter = []
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def_delegators :@logger, :debug, :info, :warn, :error, :fatal
-
-      def request(env)
-        info('request') do
-          "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
-        end
-        if log_headers?(:request)
-          debug('request') { apply_filters(dump_headers(env.request_headers)) }
-        end
-        return unless env[:body] && log_body?(:request)
-
-        debug('request') { apply_filters(dump_body(env[:body])) }
-      end
-
-      def response(env)
-        info('response') { "Status #{env.status}" }
-        if log_headers?(:response)
-          debug('response') do
-            apply_filters(dump_headers(env.response_headers))
-          end
-        end
-        return unless env[:body] && log_body?(:response)
-
-        debug('response') { apply_filters(dump_body(env[:body])) }
-      end
-
-      def filter(filter_word, filter_replacement)
-        @filter.push([filter_word, filter_replacement])
-      end
-
-      private
-
-      def dump_headers(headers)
-        headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
-      end
-
-      def dump_body(body)
-        if body.respond_to?(:to_str)
-          body.to_str
-        else
-          pretty_inspect(body)
-        end
-      end
-
-      def pretty_inspect(body)
-        body.pretty_inspect
-      end
-
-      def log_headers?(type)
-        case @options[:headers]
-        when Hash
-          @options[:headers][type]
-        else
-          @options[:headers]
-        end
-      end
-
-      def log_body?(type)
-        case @options[:bodies]
-        when Hash
-          @options[:bodies][type]
-        else
-          @options[:bodies]
-        end
-      end
-
-      def apply_filters(output)
-        @filter.each do |pattern, replacement|
-          output = output.to_s.gsub(pattern, replacement)
-        end
-        output
-      end
-    end
-  end
-end