faraday_middleware 0.13.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 759c9264c036da4dc2e7347541d09d1afee816769b06930f40517fde2a816ab4
-  data.tar.gz: b603e5501f0cab2e9d065cb86c71cc46b7c5260f7ef136bd13d791b19d650c3d
+  metadata.gz: b9533a5d53e299a95e8b2aa19d277ac32ed800930c0abd4d92c67f025c98101d
+  data.tar.gz: 7261d4f25c4e0edeaaba0718947af74439d2fef8a114278a74f8de63f0f6c575
 SHA512:
-  metadata.gz: 696314d36aa007d70c27e07c918878803c36778ce69d8192c73f32b04cbb28ac20fba0a64d7b2fbb87e2ad167cb99363a7648808f27d402d7130a5a36fd5e9b6
-  data.tar.gz: 5d479f6be7386844f4b699c06773fcfdc0ae22530904b95220c8433a1d2f6237072dc95dbaf4fd0929b6f098132c400bc5fbd11e3354f83ea23d7fccd0dc1d76
+  metadata.gz: 9ae2e4ea996bb4a2ad2762a7c0812c8734879205adb05eb88aed062f0be24b26fa18de82e6cc33c7c86dfc8f7c4fa8694522732c457643c8a4d3991e50ac095a
+  data.tar.gz: 512f5e9888e8adf5ac0d93c501470028079b463e407697353d55ef603b3a2590f46b9a6530a0a688a54e391fe9033302551f133b6d216281bf01c451e1a73f85

data/README.md

@@ -1,5 +1,7 @@
 Faraday Middleware
 ==================
+[![Gem Version](https://badge.fury.io/rb/faraday_middleware.svg)](https://rubygems.org/gems/faraday_middleware)
+![GitHub Actions CI](https://github.com/lostisland/faraday_middleware/workflows/CI/badge.svg)
 
 A collection of useful [Faraday][] middleware. [See the documentation][docs].
 
@@ -8,16 +10,20 @@ A collection of useful [Faraday][] middleware. [See the documentation][docs].
 Dependencies
 ------------
 
+Ruby >= 2.3.0
+
+#### As of v0.16.0, `faraday` and `faraday_middleware` no longer officially support JRuby or Rubinius.
+
 Some dependent libraries are needed only when using specific middleware:
 
 | Middleware                  | Library        | Notes |
 | --------------------------- | -------------- | ----- |
-| [FaradayMiddleware::Instrumentation](https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/instrumentation.rb) | [`activesupport`](https://rubygems.org/gems/activesupport) |       |
-| [FaradayMiddleware::OAuth](https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/request/oauth.rb)    | [`simple_oauth`](https://rubygems.org/gems/simple_oauth) |       |
-| [FaradayMiddleware::ParseXml](https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/response/parse_xml.rb) | [`multi_xml`](https://rubygems.org/gems/multi_xml)    |       |
-| [FaradayMiddleware::ParseYaml](https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/response/parse_yaml.rb)  | [`safe_yaml`](https://rubygems.org/gems/safe_yaml)     | Not backwards compatible with versions of this middleware prior to `faraday_middleware` v0.12. See code comments for alternatives. |
-| [FaradayMiddleware::Mashify](https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/response/mashify.rb)  | [`hashie`](https://rubygems.org/gems/hashie)       |       |
-| [FaradayMiddleware::Rashify](https://github.com/lostisland/faraday_middleware/blob/master/lib/faraday_middleware/response/rashify.rb)  | [`rash_alt`](https://rubygems.org/gems/rash_alt)     | Make sure to uninstall original `rash` gem to avoid conflict. |
+| [FaradayMiddleware::Instrumentation](https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/instrumentation.rb) | [`activesupport`](https://rubygems.org/gems/activesupport) |       |
+| [FaradayMiddleware::OAuth](https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/request/oauth.rb)    | [`simple_oauth`](https://rubygems.org/gems/simple_oauth) |       |
+| [FaradayMiddleware::ParseXml](https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/response/parse_xml.rb) | [`multi_xml`](https://rubygems.org/gems/multi_xml)    |       |
+| [FaradayMiddleware::ParseYaml](https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/response/parse_yaml.rb)  | [`safe_yaml`](https://rubygems.org/gems/safe_yaml)     | Not backwards compatible with versions of this middleware prior to `faraday_middleware` v0.12. See code comments for alternatives. |
+| [FaradayMiddleware::Mashify](https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/response/mashify.rb)  | [`hashie`](https://rubygems.org/gems/hashie)       |       |
+| [FaradayMiddleware::Rashify](https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/response/rashify.rb)  | [`rash_alt`](https://rubygems.org/gems/rash_alt)     | Make sure to uninstall original `rash` gem to avoid conflict. |
 
 Examples
 --------
@@ -25,29 +31,16 @@ Examples
 ``` rb
 require 'faraday_middleware'
 
-## in Faraday 0.8 or above:
 connection = Faraday.new 'http://example.com/api' do |conn|
   conn.request :oauth2, 'TOKEN'
   conn.request :json
 
-  conn.response :xml,  :content_type => /\bxml$/
-  conn.response :json, :content_type => /\bjson$/
+  conn.response :xml,  content_type: /\bxml$/
+  conn.response :json, content_type: /\bjson$/
 
   conn.use :instrumentation
   conn.adapter Faraday.default_adapter
 end
-
-## with Faraday 0.7:
-connection = Faraday.new 'http://example.com/api' do |builder|
-  builder.use FaradayMiddleware::OAuth2, 'TOKEN'
-  builder.use FaradayMiddleware::EncodeJson
-
-  builder.use FaradayMiddleware::ParseXml,  :content_type => /\bxml$/
-  builder.use FaradayMiddleware::ParseJson, :content_type => /\bjson$/
-
-  builder.use FaradayMiddleware::Instrumentation
-  builder.adapter Faraday.default_adapter
-end
 ```
 
 

data/lib/faraday_middleware/backwards_compatibility.rb

@@ -1,11 +1,13 @@
-# deprecated constants
+# frozen_string_literal: true
 
 module Faraday
+  # Autoload classes for Faraday::Request.
   class Request
     autoload :OAuth,        'faraday_middleware/request/oauth'
     autoload :OAuth2,       'faraday_middleware/request/oauth2'
   end
 
+  # Autoload classes for Faraday::Request.
   class Response
     autoload :Mashify,      'faraday_middleware/response/mashify'
     autoload :Rashify,      'faraday_middleware/response/rashify'
@@ -15,4 +17,3 @@ module Faraday
     autoload :ParseYaml,    'faraday_middleware/response/parse_yaml'
   end
 end
-

data/lib/faraday_middleware/gzip.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
 module FaradayMiddleware
@@ -28,22 +30,25 @@ module FaradayMiddleware
       encodings
     end
 
-    ACCEPT_ENCODING = 'Accept-Encoding'.freeze
-    CONTENT_ENCODING = 'Content-Encoding'.freeze
-    CONTENT_LENGTH = 'Content-Length'.freeze
+    ACCEPT_ENCODING = 'Accept-Encoding'
+    CONTENT_ENCODING = 'Content-Encoding'
+    CONTENT_LENGTH = 'Content-Length'
     SUPPORTED_ENCODINGS = supported_encodings.join(',').freeze
-    RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
 
     def call(env)
       env[:request_headers][ACCEPT_ENCODING] ||= SUPPORTED_ENCODINGS
       @app.call(env).on_complete do |response_env|
-        case response_env[:response_headers][CONTENT_ENCODING]
-        when 'gzip'
-          reset_body(response_env, &method(:uncompress_gzip))
-        when 'deflate'
-          reset_body(response_env, &method(:inflate))
-        when 'br'
-          reset_body(response_env, &method(:brotli_inflate))
+        if response_env[:body].empty?
+          reset_body(response_env, &method(:raw_body))
+        else
+          case response_env[:response_headers][CONTENT_ENCODING]
+          when 'gzip'
+            reset_body(response_env, &method(:uncompress_gzip))
+          when 'deflate'
+            reset_body(response_env, &method(:inflate))
+          when 'br'
+            reset_body(response_env, &method(:brotli_inflate))
+          end
         end
       end
     end
@@ -56,11 +61,7 @@ module FaradayMiddleware
 
     def uncompress_gzip(body)
       io = StringIO.new(body)
-      gzip_reader = if RUBY_ENCODING
-        Zlib::GzipReader.new(io, :encoding => 'ASCII-8BIT')
-      else
-        Zlib::GzipReader.new(io)
-      end
+      gzip_reader = Zlib::GzipReader.new(io, encoding: 'ASCII-8BIT')
       gzip_reader.read
     end
 
@@ -81,5 +82,9 @@ module FaradayMiddleware
     def brotli_inflate(body)
       Brotli.inflate(body)
     end
+
+    def raw_body(body)
+      body
+    end
   end
 end

data/lib/faraday_middleware/instrumentation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
 module FaradayMiddleware
@@ -7,11 +9,15 @@ module FaradayMiddleware
   #
   # Examples
   #
-  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
+  #   ActiveSupport::Notifications.
+  #     subscribe('request.faraday') do |name, starts, ends, _, env|
   #     url = env[:url]
   #     http_method = env[:method].to_s.upcase
   #     duration = ends - starts
-  #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
+  #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host,
+  #                                           http_method,
+  #                                           url.request_uri,
+  #                                           duration]
   #   end
   class Instrumentation < Faraday::Middleware
     dependency 'active_support/notifications'

data/lib/faraday_middleware/rack_compatible.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'stringio'
 
 module FaradayMiddleware
-  # Wraps a handler originally written for Rack to make it compatible with Faraday.
+  # Wraps a handler originally written for Rack for Faraday compatibility.
   #
   # Experimental. Only handles changes in request headers.
   class RackCompatible
@@ -22,7 +24,7 @@ module FaradayMiddleware
       finalize_response(env, rack_response)
     end
 
-    NonPrefixedHeaders = %w[CONTENT_LENGTH CONTENT_TYPE]
+    NON_PREFIXED_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE].freeze
 
     # faraday to rack-compatible
     def prepare_env(faraday_env)
@@ -31,7 +33,11 @@ module FaradayMiddleware
       url = faraday_env[:url]
       env['rack.url_scheme'] = url.scheme
       env['PATH_INFO'] = url.path
-      env['SERVER_PORT'] = url.respond_to?(:inferred_port) ? url.inferred_port : url.port
+      env['SERVER_PORT'] = if url.respond_to?(:inferred_port)
+                             url.inferred_port
+                           else
+                             url.port
+                           end
       env['QUERY_STRING'] = url.query
       env['REQUEST_METHOD'] = faraday_env[:method].to_s.upcase
 
@@ -45,7 +51,7 @@ module FaradayMiddleware
       rack_env = {}
       env[:request_headers].each do |name, value|
         name = name.upcase.tr('-', '_')
-        name = "HTTP_#{name}" unless NonPrefixedHeaders.include? name
+        name = "HTTP_#{name}" unless NON_PREFIXED_HEADERS.include? name
         rack_env[name] = value
       end
       rack_env
@@ -58,8 +64,9 @@ module FaradayMiddleware
       headers.clear
 
       rack_env.each do |name, value|
-        next unless String === name && String === value
-        if NonPrefixedHeaders.include? name or name.index('HTTP_') == 0
+        next unless name.is_a?(String) && value.is_a?(String)
+
+        if NON_PREFIXED_HEADERS.include?(name) || name.start_with?('HTTP_')
           name = name.sub(/^HTTP_/, '').downcase.tr('_', '-')
           headers[name] = value
         end
@@ -72,12 +79,12 @@ module FaradayMiddleware
 
     def finalize_response(env, rack_response)
       status, headers, body = rack_response
-      body = body.inject() { |str, part| str << part }
-      headers = Faraday::Utils::Headers.new(headers) unless Faraday::Utils::Headers === headers
+      body = body.inject { |str, part| str << part }
+      headers = Faraday::Utils::Headers.new(headers) unless headers.is_a?(Faraday::Utils::Headers)
 
-      env.update :status => status.to_i,
-                 :body => body,
-                 :response_headers => headers
+      env.update status: status.to_i,
+                 body: body,
+                 response_headers: headers
 
       env[:response] ||= Faraday::Response.new(env)
       env[:response]

data/lib/faraday_middleware/redirect_limit_reached.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module FaradayMiddleware
+  # Exception thrown when the maximum amount of requests is
+  # exceeded.
+  class RedirectLimitReached < Faraday::ClientError
+    attr_reader :response
+
+    def initialize(response)
+      super "too many redirects; last one to: #{response['location']}"
+      @response = response
+    end
+  end
+end

data/lib/faraday_middleware/request/encode_json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
 module FaradayMiddleware
@@ -9,9 +11,9 @@ module FaradayMiddleware
   #
   # Doesn't try to encode bodies that already are in string form.
   class EncodeJson < Faraday::Middleware
-    CONTENT_TYPE    = 'Content-Type'.freeze
-    MIME_TYPE       = 'application/json'.freeze
-    MIME_TYPE_REGEX = /^application\/(vnd\..+\+)?json$/
+    CONTENT_TYPE    = 'Content-Type'
+    MIME_TYPE       = 'application/json'
+    MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
 
     dependency do
       require 'json' unless defined?(::JSON)
@@ -25,23 +27,23 @@ module FaradayMiddleware
     end
 
     def encode(data)
-      ::JSON.dump data
+      ::JSON.generate data
     end
 
     def match_content_type(env)
-      if process_request?(env)
-        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
-        yield env[:body] unless env[:body].respond_to?(:to_str)
-      end
+      return unless process_request?(env)
+
+      env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+      yield env[:body] unless env[:body].respond_to?(:to_str)
     end
 
     def process_request?(env)
       type = request_type(env)
-      has_body?(env) and (type.empty? or MIME_TYPE_REGEX =~ type)
+      has_body?(env) && (type.empty? || MIME_TYPE_REGEX =~ type)
     end
 
     def has_body?(env)
-      body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
+      (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
     end
 
     def request_type(env)

data/lib/faraday_middleware/request/method_override.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
 module FaradayMiddleware
@@ -11,8 +13,7 @@ module FaradayMiddleware
   # Rack::MethodOverride module. See
   # http://rack.rubyforge.org/doc/classes/Rack/MethodOverride.html
   class MethodOverride < Faraday::Middleware
-
-    HEADER = "X-Http-Method-Override".freeze
+    HEADER = 'X-Http-Method-Override'
 
     # Public: Initialize the middleware.
     #
@@ -22,10 +23,10 @@ module FaradayMiddleware
     #                      (default: all but GET and POST)
     def initialize(app, options = nil)
       super(app)
-      @methods = options && options.fetch(:rewrite).map { |method|
+      @methods = options&.fetch(:rewrite)&.map do |method|
         method = method.downcase if method.respond_to? :downcase
         method.to_sym
-      }
+      end
     end
 
     def call(env)
@@ -35,8 +36,8 @@ module FaradayMiddleware
     end
 
     def rewrite_request?(method)
-      if @methods.nil? or @methods.empty?
-        method != :get and method != :post
+      if @methods.nil? || @methods.empty?
+        (method != :get) && (method != :post)
       else
         @methods.include? method
       end

data/lib/faraday_middleware/request/oauth.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'forwardable'
 
@@ -23,14 +25,12 @@ module FaradayMiddleware
   class OAuth < Faraday::Middleware
     dependency 'simple_oauth'
 
-    AUTH_HEADER = 'Authorization'.freeze
-    CONTENT_TYPE = 'Content-Type'.freeze
-    TYPE_URLENCODED = 'application/x-www-form-urlencoded'.freeze
+    AUTH_HEADER = 'Authorization'
+    CONTENT_TYPE = 'Content-Type'
+    TYPE_URLENCODED = 'application/x-www-form-urlencoded'
 
     extend Forwardable
-    parser_method = :parse_nested_query
-    parser_module = ::Faraday::Utils.respond_to?(parser_method) ? 'Faraday::Utils' : 'Rack::Utils'
-    def_delegator parser_module, parser_method
+    def_delegator :'Faraday::Utils', :parse_nested_query
 
     def initialize(app, options)
       super(app)
@@ -54,7 +54,7 @@ module FaradayMiddleware
     end
 
     def oauth_options(env)
-      if extra = env[:request][:oauth] and extra.is_a? Hash and !extra.empty?
+      if (extra = env[:request][:oauth]) && extra.is_a?(Hash) && !extra.empty?
         @options.merge extra
       else
         @options
@@ -73,12 +73,15 @@ module FaradayMiddleware
 
     def include_body_params?(env)
       # see RFC 5849, section 3.4.1.3.1 for details
-      !(type = env[:request_headers][CONTENT_TYPE]) or type == TYPE_URLENCODED
+      !(type = env[:request_headers][CONTENT_TYPE]) || (type == TYPE_URLENCODED)
     end
 
     def signature_params(params)
-      params.empty? ? params :
-        params.reject {|k,v| v.respond_to?(:content_type) }
+      if params.empty?
+        params
+      else
+        params.reject { |_k, v| v.respond_to?(:content_type) }
+      end
     end
   end
 end

data/lib/faraday_middleware/request/oauth2.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'forwardable'
 
 module FaradayMiddleware
   # Public: A simple middleware that adds an access token to each request.
   #
-  # By default, the token is added as both "access_token" query parameter and the
-  # "Authorization" HTTP request header. It can alternatively be added exclusively
-  # as a bearer token "Authorization" header by specifying a "token_type" option
-  # of "bearer". However, an explicit "access_token" parameter or "Authorization"
-  # header for the current request are not overriden.
+  # By default, the token is added as both "access_token" query parameter
+  # and the "Authorization" HTTP request header. It can alternatively be
+  # added exclusively as a bearer token "Authorization" header by specifying
+  # a "token_type" option of "bearer". However, an explicit "access_token"
+  # parameter or "Authorization" header for the current request are not
+  # overriden.
   #
   # Examples
   #
@@ -24,10 +27,9 @@ module FaradayMiddleware
   #   # default token value is optional:
   #   OAuth2.new(app, :param_name => 'my_oauth_token')
   class OAuth2 < Faraday::Middleware
-
-    PARAM_NAME  = 'access_token'.freeze
-    TOKEN_TYPE  = 'param'.freeze
-    AUTH_HEADER = 'Authorization'.freeze
+    PARAM_NAME  = 'access_token'
+    TOKEN_TYPE  = 'param'
+    AUTH_HEADER = 'Authorization'
 
     attr_reader :param_name, :token_type
 
@@ -53,26 +55,27 @@ module FaradayMiddleware
 
     def initialize(app, token = nil, options = {})
       super(app)
-      options, token = token, nil if token.is_a? Hash
-      @token = token && token.to_s
+      if token.is_a? Hash
+        options = token
+        token = nil
+      end
+      @token = token&.to_s
       @param_name = options.fetch(:param_name, PARAM_NAME).to_s
       @token_type = options.fetch(:token_type, TOKEN_TYPE).to_s
 
-      if @token_type == 'param' && @param_name.empty?
-        raise ArgumentError, ":param_name can't be blank"
-      end
+      raise ArgumentError, ":param_name can't be blank" if @token_type == 'param' && @param_name.empty?
 
-      if options[:token_type].nil?
-        warn "\nWarning: FaradayMiddleware::OAuth2 initialized with default "\
-             "token_type - token will be added as both a query string parameter "\
-             "and an Authorization header. In the next major release, tokens will "\
-             "be added exclusively as an Authorization header by default. Please "\
-             "visit https://github.com/lostisland/faraday_middleware/wiki for more information."
-      end
+      return unless options[:token_type].nil?
+
+      warn "\nWarning: FaradayMiddleware::OAuth2 initialized with default "\
+        'token_type - token will be added as both a query string parameter '\
+        'and an Authorization header. In the next major release, tokens will '\
+        'be added exclusively as an Authorization header by default. Please '\
+        'see https://github.com/lostisland/faraday_middleware/wiki.'
     end
 
     def query_params(url)
-      if url.query.nil? or url.query.empty?
+      if url.query.nil? || url.query.empty?
         {}
       else
         parse_query url.query

data/lib/faraday_middleware/response/caching.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'forwardable'
 require 'digest/sha1'
@@ -6,6 +8,7 @@ module FaradayMiddleware
   # Public: Caches GET responses and pulls subsequent ones from the cache.
   class Caching < Faraday::Middleware
     attr_reader :cache
+
     # Internal: List of status codes that can be cached:
     # * 200 - 'OK'
     # * 203 - 'Non-Authoritative Information'
@@ -14,7 +17,7 @@ module FaradayMiddleware
     # * 302 - 'Found'
     # * 404 - 'Not Found'
     # * 410 - 'Gone'
-    CACHEABLE_STATUS_CODES = [200, 203, 300, 301, 302, 404, 410]
+    CACHEABLE_STATUS_CODES = [200, 203, 300, 301, 302, 404, 410].freeze
 
     extend Forwardable
     def_delegators :'Faraday::Utils', :parse_query, :build_query
@@ -23,30 +26,38 @@ module FaradayMiddleware
     #
     # cache   - An object that responds to read and write (default: nil).
     # options - An options Hash (default: {}):
-    #           :ignore_params - String name or Array names of query params
-    #                            that should be ignored when forming the cache
-    #                            key (default: []).
-    #           :write_options - Hash of settings that should be passed as the third
-    #                            options parameter to the cache's #write method. If not
-    #                            specified, no options parameter will be passed.
+    #           :ignore_params - String name or Array names of query
+    #                                    params that should be ignored when forming
+    #                                    the cache key (default: []).
+    #           :write_options - Hash of settings that should be passed as the
+    #                                    third options parameter to the cache's #write
+    #                                    method. If not specified, no options parameter
+    #                                    will be passed.
+    #           :full_key      - Boolean - use full URL as cache key:
+    #                                    (url.host + url.request_uri)
+    #           :status_codes  - Array of http status code to be cache
+    #                                    (default: CACHEABLE_STATUS_CODE)
     #
     # Yields if no cache is given. The block should return a cache object.
     def initialize(app, cache = nil, options = {})
       super(app)
-      options, cache = cache, nil if cache.is_a? Hash and block_given?
+      if cache.is_a?(Hash) && block_given?
+        options = cache
+        cache = nil
+      end
       @cache = cache || yield
       @options = options
     end
 
     def call(env)
-      if :get == env[:method]
+      if env[:method] == :get
         if env[:parallel_manager]
           # callback mode
           cache_on_complete(env)
         else
           # synchronous mode
           key = cache_key(env)
-          unless response = cache.read(key) and response
+          unless (response = cache.read(key)) && response
             response = @app.call(env)
             store_response_in_cache(key, response)
           end
@@ -61,24 +72,36 @@ module FaradayMiddleware
       url = env[:url].dup
       if url.query && params_to_ignore.any?
         params = parse_query url.query
-        params.reject! {|k,| params_to_ignore.include? k }
+        params.reject! { |k,| params_to_ignore.include? k }
         url.query = params.any? ? build_query(params) : nil
       end
       url.normalize!
-
-      Digest::SHA1.hexdigest(url.request_uri)
+      digest = full_key? ? url.host + url.request_uri : url.request_uri
+      Digest::SHA1.hexdigest(digest)
     end
 
     def params_to_ignore
-      @params_to_ignore ||= Array(@options[:ignore_params]).map { |p| p.to_s }
+      @params_to_ignore ||= Array(@options[:ignore_params]).map(&:to_s)
+    end
+
+    def full_key?
+      @full_key ||= @options[:full_key]
+    end
+
+    def custom_status_codes
+      @custom_status_codes ||= begin
+        codes = CACHEABLE_STATUS_CODES & Array(@options[:status_codes]).map(&:to_i)
+        codes.any? ? codes : CACHEABLE_STATUS_CODES
+      end
     end
 
     def cache_on_complete(env)
       key = cache_key(env)
-      if cached_response = cache.read(key)
+      if (cached_response = cache.read(key))
         finalize_response(cached_response, env)
       else
-        # response.status is nil at this point, any checks need to be done inside on_complete block
+        # response.status is nil at this point
+        # any checks need to be done inside on_complete block
         @app.call(env).on_complete do |response_env|
           store_response_in_cache(key, response_env.response)
           response_env
@@ -87,7 +110,7 @@ module FaradayMiddleware
     end
 
     def store_response_in_cache(key, response)
-      return unless CACHEABLE_STATUS_CODES.include?(response.status)
+      return unless custom_status_codes.include?(response.status)
 
       if @options[:write_options]
         cache.write(key, response, @options[:write_options])

data/lib/faraday_middleware/response/chunked.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware
-  # Public: Parse a Transfer-Encoding: Chunked response to just the original data
+  # Public: Parse a Transfer-Encoding. Chunks response to just the original data
   class Chunked < FaradayMiddleware::ResponseMiddleware
-    TRANSFER_ENCODING = 'transfer-encoding'.freeze
+    TRANSFER_ENCODING = 'transfer-encoding'
 
     define_parser do |raw_body|
       decoded_body = []
       until raw_body.empty?
         chunk_len, raw_body = raw_body.split("\r\n", 2)
-        chunk_len = chunk_len.split(';',2).first.hex
-        break if chunk_len == 0
+        chunk_len = chunk_len.split(';', 2).first.hex
+        break if chunk_len.zero?
+
         decoded_body << raw_body[0, chunk_len]
         # The 2 is to strip the extra CRLF at the end of the chunk
         raw_body = raw_body[chunk_len + 2, raw_body.length - chunk_len - 2]
@@ -19,11 +22,12 @@ module FaradayMiddleware
     end
 
     def parse_response?(env)
-      super and chunked_encoding?(env[:response_headers])
+      super && chunked_encoding?(env[:response_headers])
     end
 
     def chunked_encoding?(headers)
-      encoding = headers[TRANSFER_ENCODING] and encoding.split(',').include?('chunked')
+      (encoding = headers[TRANSFER_ENCODING]) &&
+        encoding.split(',').include?('chunked')
     end
   end
 end

data/lib/faraday_middleware/response/follow_redirects.rb

@@ -1,17 +1,9 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'set'
 
 module FaradayMiddleware
-  # Public: Exception thrown when the maximum amount of requests is exceeded.
-  class RedirectLimitReached < Faraday::Error::ClientError
-    attr_reader :response
-
-    def initialize(response)
-      super "too many redirects; last one to: #{response['location']}"
-      @response = response
-    end
-  end
-
   # Public: Follow HTTP 301, 302, 303, 307, and 308 redirects.
   #
   # For HTTP 301, 302, and 303, the original GET, POST, PUT, DELETE, or PATCH
@@ -32,20 +24,20 @@ module FaradayMiddleware
   #   end
   class FollowRedirects < Faraday::Middleware
     # HTTP methods for which 30x redirects can be followed
-    ALLOWED_METHODS = Set.new [:head, :options, :get, :post, :put, :patch, :delete]
+    ALLOWED_METHODS = Set.new %i[head options get post put patch delete]
     # HTTP redirect status codes that this middleware implements
     REDIRECT_CODES  = Set.new [301, 302, 303, 307, 308]
     # Keys in env hash which will get cleared between requests
-    ENV_TO_CLEAR    = Set.new [:status, :response, :response_headers]
+    ENV_TO_CLEAR    = Set.new %i[status response response_headers]
 
     # Default value for max redirects followed
     FOLLOW_LIMIT = 3
 
     # Regex that matches characters that need to be escaped in URLs, sans
     # the "%" character which we assume already represents an escaped sequence.
-    URI_UNSAFE = /[^\-_.!~*'()a-zA-Z\d;\/?:@&=+$,\[\]%]/
+    URI_UNSAFE = %r{[^\-_.!~*'()a-zA-Z\d;/?:@&=+$,\[\]%]}.freeze
 
-    AUTH_HEADER = 'Authorization'.freeze
+    AUTH_HEADER = 'Authorization'
 
     # Public: Initialize the middleware.
     #
@@ -54,7 +46,7 @@ module FaradayMiddleware
     #     :standards_compliant        - A Boolean indicating whether to respect
     #                                  the HTTP spec when following 301/302
     #                                  (default: false)
-    #     :callback                   - A callable that will be called on redirects
+    #     :callback                   - A callable used on redirects
     #                                  with the old and new envs
     #     :cookies                    - An Array of Strings (e.g.
     #                                  ['cookie1', 'cookie2']) to choose
@@ -78,7 +70,7 @@ module FaradayMiddleware
     private
 
     def convert_to_get?(response)
-      ![:head, :options].include?(response.env[:method]) &&
+      !%i[head options].include?(response.env[:method]) &&
         @convert_to_get.include?(response.status)
     end
 
@@ -89,8 +81,9 @@ module FaradayMiddleware
       response.on_complete do |response_env|
         if follow_redirect?(response_env, response)
           raise RedirectLimitReached, response if follows.zero?
+
           new_request_env = update_env(response_env.dup, request_body, response)
-          callback.call(response_env, new_request_env) if callback
+          callback&.call(response_env, new_request_env)
           response = perform_with_redirection(new_request_env, follows - 1)
         end
       end
@@ -102,6 +95,8 @@ module FaradayMiddleware
       redirect_to_url = safe_escape(response['location'] || '')
       env[:url] += redirect_to_url
 
+      ENV_TO_CLEAR.each { |key| env.delete key }
+
       if convert_to_get?(response)
         env[:method] = :get
         env[:body] = nil
@@ -111,14 +106,12 @@ module FaradayMiddleware
 
       clear_authorization_header(env, redirect_from_url, redirect_to_url)
 
-      ENV_TO_CLEAR.each {|key| env.delete key }
-
       env
     end
 
     def follow_redirect?(env, response)
-      ALLOWED_METHODS.include? env[:method] and
-        REDIRECT_CODES.include? response.status
+      ALLOWED_METHODS.include?(env[:method]) &&
+        REDIRECT_CODES.include?(response.status)
     end
 
     def follow_limit
@@ -139,9 +132,9 @@ module FaradayMiddleware
     # risk double-escaping.
     def safe_escape(uri)
       uri = uri.split('#')[0] # we want to remove the fragment if present
-      uri.to_s.gsub(URI_UNSAFE) { |match|
-        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
-      }
+      uri.to_s.gsub(URI_UNSAFE) do |match|
+        "%#{match.unpack('H2' * match.bytesize).join('%').upcase}"
+      end
     end
 
     def clear_authorization_header(env, from_url, to_url)
@@ -157,7 +150,8 @@ module FaradayMiddleware
       from_uri = URI.parse(from_url)
       to_uri = URI.parse(to_url)
 
-      [from_uri.scheme, from_uri.host, from_uri.port] == [to_uri.scheme, to_uri.host, to_uri.port]
+      [from_uri.scheme, from_uri.host, from_uri.port] ==
+        [to_uri.scheme, to_uri.host, to_uri.port]
     end
   end
 end

data/lib/faraday_middleware/response/mashify.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
 module FaradayMiddleware

data/lib/faraday_middleware/response/parse_dates.rb

@@ -1,10 +1,13 @@
-require "time"
-require "faraday"
+# frozen_string_literal: true
+
+require 'time'
+require 'faraday'
 
 module FaradayMiddleware
   # Parse dates from response body
   class ParseDates < ::Faraday::Response::Middleware
-    ISO_DATE_FORMAT = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|((\+|-)\d{2}:?\d{2}))\Z/m
+    ISO_DATE_FORMAT = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?
+    (Z|((\+|-)\d{2}:?\d{2}))\Z/xm.freeze
 
     def initialize(app, options = {})
       @regexp = options[:match] || ISO_DATE_FORMAT

data/lib/faraday_middleware/response/parse_json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware
@@ -18,7 +20,7 @@ module FaradayMiddleware
     # This is to fix responses from certain API providers that insist on serving
     # JSON with wrong MIME-types such as "text/javascript".
     class MimeTypeFix < ResponseMiddleware
-      MIME_TYPE = 'application/json'.freeze
+      MIME_TYPE = 'application/json'
 
       def process_response(env)
         old_type = env[:response_headers][CONTENT_TYPE].to_s
@@ -27,19 +29,17 @@ module FaradayMiddleware
         env[:response_headers][CONTENT_TYPE] = new_type
       end
 
-      BRACKETS = %w- [ { -
-      WHITESPACE = [ " ", "\n", "\r", "\t" ]
+      BRACKETS = %w-[ {-.freeze
+      WHITESPACE = [' ', "\n", "\r", "\t"].freeze
 
       def parse_response?(env)
-        super and BRACKETS.include? first_char(env[:body])
+        super && BRACKETS.include?(first_char(env[:body]))
       end
 
       def first_char(body)
         idx = -1
-        begin
-          char = body[idx += 1]
-          char = char.chr if char
-        end while char and WHITESPACE.include? char
+        char = body[idx += 1]
+        char = body[idx += 1] while char && WHITESPACE.include?(char)
         char
       end
     end

data/lib/faraday_middleware/response/parse_marshal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware

data/lib/faraday_middleware/response/parse_xml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware

data/lib/faraday_middleware/response/parse_yaml.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware
   # Public: Parse response bodies as YAML.
   #
-  # Warning: This is not backwards compatible with versions of this middleware prior to
-  # faraday_middleware v0.12 - prior to this version, we used YAML.load rather than
-  # YAMl.safe_load, which exposes serious remote code execution risks - see
-  # https://github.com/ruby/psych/issues/119 for details. If you're sure you can trust
-  # YAML you're passing, you can set up an unsafe version of this middleware as follows:
+  # Warning: This is not backwards compatible with versions of this middleware
+  # prior to faraday_middleware v0.12 - prior to this version, we used
+  # YAML.load rather than YAMl.safe_load, which exposes serious remote code
+  # execution risks - see https://github.com/ruby/psych/issues/119 for details.
+  # If you're sure you can trust YAML you're passing, you can set up an unsafe
+  # version of this middleware like this:
   #
   #     class UnsafelyParseYaml < FaradayMiddleware::ResponseMiddleware
   #       dependency do
@@ -27,11 +30,7 @@ module FaradayMiddleware
     dependency 'safe_yaml/load'
 
     define_parser do |body, parser_options|
-      if SafeYAML::YAML_ENGINE == 'psych'
-        SafeYAML.load(body, nil, parser_options || {})
-      else
-        SafeYAML.load(body, parser_options || {})
-      end
+      SafeYAML.load(body, nil, parser_options || {})
     end
   end
 end

data/lib/faraday_middleware/response/rashify.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday_middleware/response/mashify'
 
 module FaradayMiddleware

data/lib/faraday_middleware/response_middleware.rb

@@ -1,23 +1,28 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
+# Main FaradayMiddleware module.
 module FaradayMiddleware
   # Internal: The base class for middleware that parses responses.
   class ResponseMiddleware < Faraday::Middleware
-    CONTENT_TYPE = 'Content-Type'.freeze
+    CONTENT_TYPE = 'Content-Type'
 
     class << self
       attr_accessor :parser
     end
 
     # Store a Proc that receives the body and returns the parsed result.
-    def self.define_parser(parser = nil)
-      @parser = parser || Proc.new
+    def self.define_parser(parser = nil, &block)
+      @parser = parser ||
+                block  ||
+                raise(ArgumentError, 'Define parser with a block')
     end
 
     def self.inherited(subclass)
       super
-      subclass.load_error = self.load_error if subclass.respond_to? :load_error=
-      subclass.parser = self.parser
+      subclass.load_error = load_error if subclass.respond_to? :load_error=
+      subclass.parser = parser
     end
 
     def initialize(app = nil, options = {})
@@ -29,17 +34,15 @@ module FaradayMiddleware
 
     def call(environment)
       @app.call(environment).on_complete do |env|
-        if process_response_type?(response_type(env)) and parse_response?(env)
-          process_response(env)
-        end
+        process_response(env) if process_response_type?(response_type(env)) && parse_response?(env)
       end
     end
 
     def process_response(env)
       env[:raw_body] = env[:body] if preserve_raw?(env)
       env[:body] = parse(env[:body])
-    rescue Faraday::Error::ParsingError => err
-      raise Faraday::Error::ParsingError.new(err, env[:response])
+    rescue Faraday::ParsingError => e
+      raise Faraday::ParsingError.new(e.wrapped_exception, env[:response])
     end
 
     # Parse the response body.
@@ -49,9 +52,11 @@ module FaradayMiddleware
       if self.class.parser
         begin
           self.class.parser.call(body, @parser_options)
-        rescue StandardError, SyntaxError => err
-          raise err if err.is_a? SyntaxError and err.class.name != 'Psych::SyntaxError'
-          raise Faraday::Error::ParsingError, err
+        rescue StandardError, SyntaxError => e
+          raise e if e.is_a?(SyntaxError) &&
+                     e.class.name != 'Psych::SyntaxError'
+
+          raise Faraday::ParsingError, e
         end
       else
         body
@@ -65,9 +70,9 @@ module FaradayMiddleware
     end
 
     def process_response_type?(type)
-      @content_types.empty? or @content_types.any? { |pattern|
+      @content_types.empty? || @content_types.any? do |pattern|
         pattern.is_a?(Regexp) ? type =~ pattern : type == pattern
-      }
+      end
     end
 
     def parse_response?(env)
@@ -84,17 +89,18 @@ module FaradayMiddleware
     attr_accessor :preserve_raw
 
     def to_hash
-      super.update(:preserve_raw => preserve_raw)
+      super.update(preserve_raw: preserve_raw)
     end
 
     def each
       return to_enum(:each) unless block_given?
+
       super
       yield :preserve_raw, preserve_raw
     end
 
     def fetch(key, *args)
-      if :preserve_raw == key
+      if key == :preserve_raw
         value = __send__(key)
         value.nil? ? args.fetch(0) : value
       else
@@ -105,9 +111,9 @@ module FaradayMiddleware
 
   if defined?(Faraday::RequestOptions)
     begin
-      Faraday::RequestOptions.from(:preserve_raw => true)
+      Faraday::RequestOptions.from(preserve_raw: true)
     rescue NoMethodError
-      Faraday::RequestOptions.send(:include, OptionsExtension)
+      Faraday::RequestOptions.include OptionsExtension
     end
   end
 end

data/lib/faraday_middleware/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Main FaradayMiddleware module.
 module FaradayMiddleware
-  VERSION = '0.13.1' unless defined?(FaradayMiddleware::VERSION)
+  VERSION = '1.2.0' unless defined?(FaradayMiddleware::VERSION)
 end

data/lib/faraday_middleware.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'faraday'
 
+# Main FaradayMiddleware module.
 module FaradayMiddleware
   autoload :OAuth,           'faraday_middleware/request/oauth'
   autoload :OAuth2,          'faraday_middleware/request/oauth2'
@@ -15,33 +18,34 @@ module FaradayMiddleware
   autoload :Caching,         'faraday_middleware/response/caching'
   autoload :Chunked,         'faraday_middleware/response/chunked'
   autoload :RackCompatible,  'faraday_middleware/rack_compatible'
+  autoload :RedirectLimitReached, 'faraday_middleware/redirect_limit_reached'
   autoload :FollowRedirects, 'faraday_middleware/response/follow_redirects'
   autoload :Instrumentation, 'faraday_middleware/instrumentation'
   autoload :Gzip, 'faraday_middleware/gzip'
 
   if Faraday::Middleware.respond_to? :register_middleware
     Faraday::Request.register_middleware \
-      :oauth    => lambda { OAuth },
-      :oauth2   => lambda { OAuth2 },
-      :json     => lambda { EncodeJson },
-      :method_override => lambda { MethodOverride }
+      oauth: -> { OAuth },
+      oauth2: -> { OAuth2 },
+      json: -> { EncodeJson },
+      method_override: -> { MethodOverride }
 
     Faraday::Response.register_middleware \
-      :mashify  => lambda { Mashify },
-      :rashify  => lambda { Rashify },
-      :json     => lambda { ParseJson },
-      :json_fix => lambda { ParseJson::MimeTypeFix },
-      :xml      => lambda { ParseXml },
-      :marshal  => lambda { ParseMarshal },
-      :yaml     => lambda { ParseYaml },
-      :dates    => lambda { ParseDates },
-      :caching  => lambda { Caching },
-      :follow_redirects => lambda { FollowRedirects },
-      :chunked => lambda { Chunked }
+      mashify: -> { Mashify },
+      rashify: -> { Rashify },
+      json: -> { ParseJson },
+      json_fix: -> { ParseJson::MimeTypeFix },
+      xml: -> { ParseXml },
+      marshal: -> { ParseMarshal },
+      yaml: -> { ParseYaml },
+      dates: -> { ParseDates },
+      caching: -> { Caching },
+      follow_redirects: -> { FollowRedirects },
+      chunked: -> { Chunked }
 
     Faraday::Middleware.register_middleware \
-      :instrumentation  => lambda { Instrumentation },
-      :gzip => lambda { Gzip }
+      instrumentation: -> { Instrumentation },
+      gzip: -> { Gzip }
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday_middleware
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Erik Michaels-Ober
@@ -9,26 +9,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-04 00:00:00.000000000 Z
+date: 2021-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.7.4
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.7.4
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 description: 
@@ -46,6 +40,7 @@ files:
 - lib/faraday_middleware/gzip.rb
 - lib/faraday_middleware/instrumentation.rb
 - lib/faraday_middleware/rack_compatible.rb
+- lib/faraday_middleware/redirect_limit_reached.rb
 - lib/faraday_middleware/request/encode_json.rb
 - lib/faraday_middleware/request/method_override.rb
 - lib/faraday_middleware/request/oauth.rb
@@ -74,14 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Various middleware for Faraday