faraday 1.10.6 → 2.0.0.alpha.pre.1

data/lib/faraday/middleware_registry.rb

@@ -6,59 +6,26 @@ module Faraday
   # Adds the ability for other modules to register and lookup
   # middleware classes.
   module MiddlewareRegistry
+    def registered_middleware
+      @registered_middleware ||= {}
+    end
+
     # Register middleware class(es) on the current module.
     #
-    # @param autoload_path [String] Middleware autoload path
-    # @param mapping [Hash{
-    #          Symbol => Module,
-    #          Symbol => Array<Module, Symbol, String>,
-    #        }] Middleware mapping from a lookup symbol to a reference to the
-    #        middleware.
-    #        Classes can be expressed as:
-    #          - a fully qualified constant
-    #          - a Symbol
-    #          - a Proc that will be lazily called to return the former
-    #          - an array is given, its first element is the constant or symbol,
-    #            and its second is a file to `require`.
+    # @param mappings [Hash] Middleware mappings from a lookup symbol to a middleware class.
     # @return [void]
     #
     # @example Lookup by a constant
     #
     #   module Faraday
-    #     class Whatever
+    #     class Whatever < Middleware
     #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
-    #       register_middleware foo: Foo
-    #     end
-    #   end
-    #
-    # @example Lookup by a symbol
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :bar returns
-    #       # Faraday::Whatever.const_get(:Bar)
-    #       register_middleware bar: :Bar
-    #     end
-    #   end
-    #
-    # @example Lookup by a symbol and string in an array
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :baz requires 'baz' and returns
-    #       # Faraday::Whatever.const_get(:Baz)
-    #       register_middleware baz: [:Baz, 'baz']
+    #       register_middleware(foo: Whatever)
     #     end
     #   end
-    #
-    def register_middleware(autoload_path = nil, mapping = nil)
-      if mapping.nil?
-        mapping = autoload_path
-        autoload_path = nil
-      end
+    def register_middleware(**mappings)
       middleware_mutex do
-        @middleware_autoload_path = autoload_path if autoload_path
-        (@registered_middleware ||= {}).update(mapping)
+        registered_middleware.update(mappings)
       end
     end
 
@@ -66,7 +33,7 @@ module Faraday
     #
     # @param key [Symbol] key for the registered middleware.
     def unregister_middleware(key)
-      @registered_middleware.delete(key)
+      registered_middleware.delete(key)
     end
 
     # Lookup middleware class with a registered Symbol shortcut.
@@ -78,16 +45,15 @@ module Faraday
     # @example
     #
     #   module Faraday
-    #     class Whatever
-    #       register_middleware foo: Foo
+    #     class Whatever < Middleware
+    #       register_middleware(foo: Whatever)
     #     end
     #   end
     #
-    #   Faraday::Whatever.lookup_middleware(:foo)
-    #   # => Faraday::Whatever::Foo
-    #
+    #   Faraday::Middleware.lookup_middleware(:foo)
+    #   # => Faraday::Whatever
     def lookup_middleware(key)
-      load_middleware(key) ||
+      registered_middleware[key] ||
         raise(Faraday::Error, "#{key.inspect} is not registered on #{self}")
     end
 
@@ -95,35 +61,5 @@ module Faraday
       @middleware_mutex ||= Monitor.new
       @middleware_mutex.synchronize(&block)
     end
-
-    def fetch_middleware(key)
-      defined?(@registered_middleware) && @registered_middleware[key]
-    end
-
-    def load_middleware(key)
-      value = fetch_middleware(key)
-      case value
-      when Module
-        value
-      when Symbol, String
-        middleware_mutex do
-          @registered_middleware[key] = const_get(value)
-        end
-      when Proc
-        middleware_mutex do
-          @registered_middleware[key] = value.call
-        end
-      when Array
-        middleware_mutex do
-          const, path = value
-          if (root = @middleware_autoload_path)
-            path = "#{root}/#{path}"
-          end
-          require(path)
-          @registered_middleware[key] = const
-        end
-        load_middleware(key)
-      end
-    end
   end
 end

data/lib/faraday/options.rb

@@ -104,7 +104,7 @@ module Faraday
 
     # Public
     def each_key(&block)
-      return to_enum(:each_key) unless block_given?
+      return to_enum(:each_key) unless block
 
       keys.each(&block)
     end
@@ -118,7 +118,7 @@ module Faraday
 
     # Public
     def each_value(&block)
-      return to_enum(:each_value) unless block_given?
+      return to_enum(:each_value) unless block
 
       values.each(&block)
     end
@@ -168,7 +168,7 @@ module Faraday
     end
 
     def self.memoized(key, &block)
-      unless block_given?
+      unless block
         raise ArgumentError, '#memoized must be called with a block'
       end
 

data/lib/faraday/param_part.rb

@@ -0,0 +1,53 @@
+# 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/rack_builder.rb

@@ -61,7 +61,7 @@ module Faraday
     def initialize(handlers = [], adapter = nil, &block)
       @adapter = adapter
       @handlers = handlers
-      if block_given?
+      if block
         build(&block)
       elsif @handlers.empty?
         # default stack, if nothing else is configured

data/lib/faraday/request/authorization.rb

@@ -1,53 +1,20 @@
 # frozen_string_literal: true
 
-require 'base64'
-
 module Faraday
   class Request
     # Request middleware for the Authorization HTTP header
     class Authorization < Faraday::Middleware
-      unless defined?(::Faraday::Request::Authorization::KEY)
-        KEY = 'Authorization'
-      end
-
-      # @param type [String, Symbol]
-      # @param token [String, Symbol, Hash]
-      # @return [String] a header value
-      def self.header(type, token)
-        case token
-        when String, Symbol, Proc
-          token = token.call if token.is_a?(Proc)
-          "#{type} #{token}"
-        when Hash
-          build_hash(type.to_s, token)
-        else
-          raise ArgumentError,
-                "Can't build an Authorization #{type}" \
-                  "header from #{token.inspect}"
-        end
-      end
-
-      # @param type [String]
-      # @param hash [Hash]
-      # @return [String] type followed by comma-separated key=value pairs
-      # @api private
-      def self.build_hash(type, hash)
-        comma = ', '
-        values = []
-        hash.each do |key, value|
-          value = value.call if value.is_a?(Proc)
-          values << "#{key}=#{value.to_s.inspect}"
-        end
-        "#{type} #{values * comma}"
-      end
+      KEY = 'Authorization'
 
       # @param app [#call]
       # @param type [String, Symbol] Type of Authorization
-      # @param param [String, Symbol, Hash, Proc] parameter to build the Authorization header.
+      # @param params [Array<String, Proc>] parameters to build the Authorization header.
+      #   If the type is `:basic`, then these can be a login and password pair.
+      #   Otherwise, a single value is expected that will be appended after the type.
       #   This value can be a proc, in which case it will be invoked on each request.
-      def initialize(app, type, param)
+      def initialize(app, type, *params)
         @type = type
-        @param = param
+        @params = params
         super(app)
       end
 
@@ -55,8 +22,27 @@ module Faraday
       def on_request(env)
         return if env.request_headers[KEY]
 
-        env.request_headers[KEY] = self.class.header(@type, @param)
+        env.request_headers[KEY] = header_from(@type, *@params)
+      end
+
+      private
+
+      # @param type [String, Symbol]
+      # @param params [Array]
+      # @return [String] a header value
+      def header_from(type, *params)
+        if type.to_s.casecmp('basic').zero? && params.size == 2
+          Utils.basic_header_from(*params)
+        elsif params.size != 1
+          raise ArgumentError, "Unexpected params received (got #{params.size} instead of 1)"
+        else
+          value = params.first
+          value = value.call if value.is_a?(Proc)
+          "#{type} #{value}"
+        end
       end
     end
   end
 end
+
+Faraday::Request.register_middleware(authorization: Faraday::Request::Authorization)

data/lib/faraday/request/instrumentation.rb

@@ -52,3 +52,5 @@ module Faraday
     end
   end
 end
+
+Faraday::Request.register_middleware(instrumentation: Faraday::Request::Instrumentation)

data/lib/faraday/request/multipart.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require File.expand_path('url_encoded', __dir__)
+require 'securerandom'
+
+module Faraday
+  class Request
+    # Middleware for supporting multi-part requests.
+    class Multipart < UrlEncoded
+      self.mime_type = 'multipart/form-data'
+      unless defined?(::Faraday::Request::Multipart::DEFAULT_BOUNDARY_PREFIX)
+        DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
+      end
+
+      def initialize(app = nil, options = {})
+        super(app)
+        @options = options
+      end
+
+      # Checks for files in the payload, otherwise leaves everything untouched.
+      #
+      # @param env [Faraday::Env]
+      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
+
+      # @param env [Faraday::Env]
+      def process_request?(env)
+        type = request_type(env)
+        env.body.respond_to?(:each_key) && !env.body.empty? && (
+          (type.empty? && has_multipart?(env.body)) ||
+            (type == self.class.mime_type)
+        )
+      end
+
+      # Returns true if obj is an enumerable with values that are multipart.
+      #
+      # @param obj [Object]
+      # @return [Boolean]
+      def has_multipart?(obj) # rubocop:disable Naming/PredicateName
+        if obj.respond_to?(:each)
+          (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
+
+      # @param env [Faraday::Env]
+      # @param params [Hash]
+      def create_multipart(env, params)
+        boundary = env.request.boundary
+        parts = process_params(params) do |key, value|
+          part(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
+        body
+      end
+
+      def part(boundary, key, value)
+        if value.respond_to?(:to_part)
+          value.to_part(boundary, key)
+        else
+          Faraday::Parts::Part.new(boundary, key, value)
+        end
+      end
+
+      # @return [String]
+      def unique_boundary
+        "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
+      end
+
+      # @param params [Hash]
+      # @param prefix [String]
+      # @param pieces [Array]
+      def process_params(params, prefix = nil, pieces = nil, &block)
+        params.inject(pieces || []) do |all, (key, value)|
+          if prefix
+            key = @options[:flat_encode] ? prefix.to_s : "#{prefix}[#{key}]"
+          end
+
+          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
+            # rubocop:disable Performance/RedundantBlockCall
+            all << block.call(key, value)
+            # rubocop:enable Performance/RedundantBlockCall
+          end
+        end
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware(multipart: Faraday::Request::Multipart)

data/lib/faraday/request/retry.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Faraday
+  class Request
+    # 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.
+    #
+    # @example Configure Retry middleware using intervals
+    #   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(:net_http) # NB: Last middleware must be the 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.125.
+    class Retry < Faraday::Middleware
+      DEFAULT_EXCEPTIONS = [
+        Errno::ETIMEDOUT, 'Timeout::Error',
+        Faraday::TimeoutError, Faraday::RetriableResponse
+      ].freeze
+      IDEMPOTENT_METHODS = %i[delete get head options put].freeze
+
+      # Options contains the configurable parameters for the Retry middleware.
+      class Options < Faraday::Options.new(:max, :interval, :max_interval,
+                                           :interval_randomness,
+                                           :backoff_factor, :exceptions,
+                                           :methods, :retry_if, :retry_block,
+                                           :retry_statuses)
+
+        DEFAULT_CHECK = ->(_env, _exception) { false }
+
+        def self.from(value)
+          if value.is_a?(Integer)
+            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 {}
+        end
+
+        def retry_statuses
+          Array(self[:retry_statuses] ||= [])
+        end
+      end
+
+      # @param app [#call]
+      # @param options [Hash]
+      # @option options [Integer] :max (2) Maximum number of retries
+      # @option options [Integer] :interval (0) Pause in seconds between retries
+      # @option options [Integer] :interval_randomness (0) The maximum random
+      #   interval amount expressed as a float between
+      #   0 and 1 to use in addition to the interval.
+      # @option options [Integer] :max_interval (Float::MAX) An upper limit
+      #   for the interval
+      # @option options [Integer] :backoff_factor (1) The amount to multiply
+      #   each successive retry's interval amount by in order to provide backoff
+      # @option options [Array] :exceptions ([ Errno::ETIMEDOUT,
+      #   'Timeout::Error', Faraday::TimeoutError, Faraday::RetriableResponse])
+      #   The list of exceptions to handle. Exceptions can be given as
+      #   Class, Module, or String.
+      # @option options [Array] :methods (the idempotent HTTP methods
+      #   in IDEMPOTENT_METHODS) A list of HTTP methods to retry without
+      #   calling retry_if. Pass an empty Array to call retry_if
+      #   for all exceptions.
+      # @option options [Block] :retry_if (false) 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.
+      # @option options [Block] :retry_block block that is executed before
+      #   every retry. Request environment, middleware options, current number
+      #   of retries and the exception is passed to the block as parameters.
+      # @option options [Array] :retry_statuses Array of Integer HTTP status
+      #   codes or a single Integer value that determines whether to raise
+      #   a Faraday::RetriableResponse exception based on the HTTP status code
+      #   of an HTTP response.
+      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
+
+        if retry_after && retry_after >= retry_interval
+          retry_after
+        else
+          retry_interval
+        end
+      end
+
+      # @param env [Faraday::Env]
+      def call(env)
+        retries = @options.max
+        request_body = env[:body]
+        begin
+          # after failure env[:body] is set to the response body
+          env[:body] = request_body
+          @app.call(env).tap do |resp|
+            if @options.retry_statuses.include?(resp.status)
+              raise Faraday::RetriableResponse.new(nil, resp)
+            end
+          end
+        rescue @errmatch => e
+          if retries.positive? && retry_request?(env, e)
+            retries -= 1
+            rewind_files(request_body)
+            @options.retry_block.call(env, @options, retries, e)
+            if (sleep_amount = calculate_sleep_amount(retries + 1, env))
+              sleep sleep_amount
+              retry
+            end
+          end
+
+          raise unless e.is_a?(Faraday::RetriableResponse)
+
+          e.response
+        end
+      end
+
+      # 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.
+      #
+      # @param exceptions [Array]
+      # @api private
+      # @return [Module] an exception matcher
+      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
+                Object.const_defined?(ex.to_s) && error.is_a?(Object.const_get(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|
+          value.rewind if value.is_a?(UploadIO)
+        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
+end
+
+Faraday::Request.register_middleware(retry: Faraday::Request::Retry)

data/lib/faraday/request/url_encoded.rb

@@ -54,3 +54,5 @@ module Faraday
     end
   end
 end
+
+Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)