faraday 0.15.4 → 0.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE.md +1 -1
  3. data/README.md +18 -344
  4. data/lib/faraday.rb +93 -175
  5. data/lib/faraday/adapter.rb +36 -22
  6. data/lib/faraday/adapter/em_http.rb +142 -99
  7. data/lib/faraday/adapter/em_http_ssl_patch.rb +23 -17
  8. data/lib/faraday/adapter/em_synchrony.rb +104 -60
  9. data/lib/faraday/adapter/em_synchrony/parallel_manager.rb +18 -15
  10. data/lib/faraday/adapter/excon.rb +100 -55
  11. data/lib/faraday/adapter/httpclient.rb +61 -39
  12. data/lib/faraday/adapter/net_http.rb +104 -51
  13. data/lib/faraday/adapter/net_http_persistent.rb +48 -27
  14. data/lib/faraday/adapter/patron.rb +54 -35
  15. data/lib/faraday/adapter/rack.rb +28 -12
  16. data/lib/faraday/adapter/test.rb +86 -53
  17. data/lib/faraday/adapter/typhoeus.rb +4 -1
  18. data/lib/faraday/adapter_registry.rb +28 -0
  19. data/lib/faraday/autoload.rb +47 -36
  20. data/lib/faraday/connection.rb +321 -179
  21. data/lib/faraday/dependency_loader.rb +37 -0
  22. data/lib/faraday/encoders/flat_params_encoder.rb +94 -0
  23. data/lib/faraday/encoders/nested_params_encoder.rb +171 -0
  24. data/lib/faraday/error.rb +67 -33
  25. data/lib/faraday/file_part.rb +128 -0
  26. data/lib/faraday/logging/formatter.rb +92 -0
  27. data/lib/faraday/middleware.rb +4 -28
  28. data/lib/faraday/middleware_registry.rb +129 -0
  29. data/lib/faraday/options.rb +35 -186
  30. data/lib/faraday/options/connection_options.rb +22 -0
  31. data/lib/faraday/options/env.rb +181 -0
  32. data/lib/faraday/options/proxy_options.rb +28 -0
  33. data/lib/faraday/options/request_options.rb +21 -0
  34. data/lib/faraday/options/ssl_options.rb +59 -0
  35. data/lib/faraday/param_part.rb +53 -0
  36. data/lib/faraday/parameters.rb +4 -197
  37. data/lib/faraday/rack_builder.rb +67 -56
  38. data/lib/faraday/request.rb +68 -36
  39. data/lib/faraday/request/authorization.rb +42 -30
  40. data/lib/faraday/request/basic_authentication.rb +14 -7
  41. data/lib/faraday/request/instrumentation.rb +45 -27
  42. data/lib/faraday/request/multipart.rb +79 -48
  43. data/lib/faraday/request/retry.rb +198 -169
  44. data/lib/faraday/request/token_authentication.rb +15 -10
  45. data/lib/faraday/request/url_encoded.rb +41 -23
  46. data/lib/faraday/response.rb +23 -16
  47. data/lib/faraday/response/logger.rb +22 -69
  48. data/lib/faraday/response/raise_error.rb +36 -14
  49. data/lib/faraday/utils.rb +28 -245
  50. data/lib/faraday/utils/headers.rb +139 -0
  51. data/lib/faraday/utils/params_hash.rb +61 -0
  52. data/spec/external_adapters/faraday_specs_setup.rb +14 -0
  53. metadata +21 -5
  54. data/lib/faraday/upload_io.rb +0 -67
@@ -1,13 +1,20 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require 'base64'
2
4
 
3
5
  module Faraday
4
- class Request::BasicAuthentication < Request.load_middleware(:authorization)
5
- # Public
6
- def self.header(login, pass)
7
- value = Base64.encode64([login, pass].join(':'))
8
- value.gsub!("\n", '')
9
- super(:Basic, value)
6
+ class Request
7
+ # Authorization middleware for Basic Authentication.
8
+ class BasicAuthentication < load_middleware(:authorization)
9
+ # @param login [String]
10
+ # @param pass [String]
11
+ #
12
+ # @return [String] a Basic Authentication header line
13
+ def self.header(login, pass)
14
+ value = Base64.encode64([login, pass].join(':'))
15
+ value.delete!("\n")
16
+ super(:Basic, value)
17
+ end
10
18
  end
11
19
  end
12
20
  end
13
-
@@ -1,35 +1,53 @@
1
+ # frozen_string_literal: true
2
+
1
3
  module Faraday
2
- class Request::Instrumentation < Faraday::Middleware
3
- class Options < Faraday::Options.new(:name, :instrumenter)
4
- def name
5
- self[:name] ||= 'request.faraday'
6
- end
4
+ class Request
5
+ # Middleware for instrumenting Requests.
6
+ class Instrumentation < Faraday::Middleware
7
+ # Options class used in Request::Instrumentation class.
8
+ class Options < Faraday::Options.new(:name, :instrumenter)
9
+ # @return [String]
10
+ def name
11
+ self[:name] ||= 'request.faraday'
12
+ end
7
13
 
8
- def instrumenter
9
- self[:instrumenter] ||= ActiveSupport::Notifications
14
+ # @return [Class]
15
+ def instrumenter
16
+ self[:instrumenter] ||= ActiveSupport::Notifications
17
+ end
10
18
  end
11
- end
12
19
 
13
- # Public: Instruments requests using Active Support.
14
- #
15
- # Measures time spent only for synchronous requests.
16
- #
17
- # Examples
18
- #
19
- # ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
20
- # url = env[:url]
21
- # http_method = env[:method].to_s.upcase
22
- # duration = ends - starts
23
- # $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
24
- # end
25
- def initialize(app, options = nil)
26
- super(app)
27
- @name, @instrumenter = Options.from(options).values_at(:name, :instrumenter)
28
- end
20
+ # Instruments requests using Active Support.
21
+ #
22
+ # Measures time spent only for synchronous requests.
23
+ #
24
+ # @example Using ActiveSupport::Notifications to measure time spent
25
+ # for Faraday requests.
26
+ # ActiveSupport::Notifications
27
+ # .subscribe('request.faraday') do |name, starts, ends, _, env|
28
+ # url = env[:url]
29
+ # http_method = env[:method].to_s.upcase
30
+ # duration = ends - starts
31
+ # $stderr.puts '[%s] %s %s (%.3f s)' %
32
+ # [url.host, http_method, url.request_uri, duration]
33
+ # end
34
+ # @param app [#call]
35
+ # @param options [nil, Hash] Options hash
36
+ # @option options [String] :name ('request.faraday')
37
+ # Name of the instrumenter
38
+ # @option options [Class] :instrumenter (ActiveSupport::Notifications)
39
+ # Active Support instrumenter class.
40
+ def initialize(app, options = nil)
41
+ super(app)
42
+ @name, @instrumenter = Options.from(options)
43
+ .values_at(:name, :instrumenter)
44
+ end
29
45
 
30
- def call(env)
31
- @instrumenter.instrument(@name, env) do
32
- @app.call(env)
46
+ # @param env [Faraday::Env]
47
+ def call(env)
48
+ @instrumenter.instrument(@name, env) do
49
+ @app.call(env)
50
+ end
33
51
  end
34
52
  end
35
53
  end
@@ -1,66 +1,97 @@
1
- require File.expand_path("../url_encoded", __FILE__)
1
+ # frozen_string_literal: true
2
+
3
+ require File.expand_path('url_encoded', __dir__)
2
4
  require 'securerandom'
3
5
 
4
6
  module Faraday
5
- class Request::Multipart < Request::UrlEncoded
6
- self.mime_type = 'multipart/form-data'.freeze
7
- DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
7
+ class Request
8
+ # Middleware for supporting multi-part requests.
9
+ class Multipart < UrlEncoded
10
+ self.mime_type = 'multipart/form-data'
11
+ unless defined? DEFAULT_BOUNDARY_PREFIX
12
+ DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
13
+ end
8
14
 
9
- def call(env)
10
- match_content_type(env) do |params|
11
- env.request.boundary ||= unique_boundary
12
- env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
13
- env.body = create_multipart(env, params)
15
+ # Checks for files in the payload, otherwise leaves everything untouched.
16
+ #
17
+ # @param env [Faraday::Env]
18
+ def call(env)
19
+ match_content_type(env) do |params|
20
+ env.request.boundary ||= unique_boundary
21
+ env.request_headers[CONTENT_TYPE] +=
22
+ "; boundary=#{env.request.boundary}"
23
+ env.body = create_multipart(env, params)
24
+ end
25
+ @app.call env
14
26
  end
15
- @app.call env
16
- end
17
27
 
18
- def process_request?(env)
19
- type = request_type(env)
20
- env.body.respond_to?(:each_key) and !env.body.empty? and (
21
- (type.empty? and has_multipart?(env.body)) or
22
- type == self.class.mime_type
23
- )
24
- end
28
+ # @param env [Faraday::Env]
29
+ def process_request?(env)
30
+ type = request_type(env)
31
+ env.body.respond_to?(:each_key) && !env.body.empty? && (
32
+ (type.empty? && has_multipart?(env.body)) ||
33
+ (type == self.class.mime_type)
34
+ )
35
+ end
25
36
 
26
- def has_multipart?(obj)
27
- # string is an enum in 1.8, returning list of itself
28
- if obj.respond_to?(:each) && !obj.is_a?(String)
29
- (obj.respond_to?(:values) ? obj.values : obj).each do |val|
30
- return true if (val.respond_to?(:content_type) || has_multipart?(val))
37
+ # Returns true if obj is an enumerable with values that are multipart.
38
+ #
39
+ # @param obj [Object]
40
+ # @return [Boolean]
41
+ def has_multipart?(obj) # rubocop:disable Naming/PredicateName
42
+ if obj.respond_to?(:each)
43
+ (obj.respond_to?(:values) ? obj.values : obj).each do |val|
44
+ return true if val.respond_to?(:content_type) || has_multipart?(val)
45
+ end
31
46
  end
47
+ false
32
48
  end
33
- false
34
- end
35
49
 
36
- def create_multipart(env, params)
37
- boundary = env.request.boundary
38
- parts = process_params(params) do |key, value|
39
- Faraday::Parts::Part.new(boundary, key, value)
50
+ # @param env [Faraday::Env]
51
+ # @param params [Hash]
52
+ def create_multipart(env, params)
53
+ boundary = env.request.boundary
54
+ parts = process_params(params) do |key, value|
55
+ part(boundary, key, value)
56
+ end
57
+ parts << Faraday::Parts::EpiloguePart.new(boundary)
58
+
59
+ body = Faraday::CompositeReadIO.new(parts)
60
+ env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
61
+ body
40
62
  end
41
- parts << Faraday::Parts::EpiloguePart.new(boundary)
42
63
 
43
- body = Faraday::CompositeReadIO.new(parts)
44
- env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
45
- return body
46
- end
64
+ def part(boundary, key, value)
65
+ if value.respond_to?(:to_part)
66
+ value.to_part(boundary, key)
67
+ else
68
+ Faraday::Parts::Part.new(boundary, key, value)
69
+ end
70
+ end
47
71
 
48
- def unique_boundary
49
- "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
50
- end
72
+ # @return [String]
73
+ def unique_boundary
74
+ "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
75
+ end
51
76
 
52
- def process_params(params, prefix = nil, pieces = nil, &block)
53
- params.inject(pieces || []) do |all, (key, value)|
54
- key = "#{prefix}[#{key}]" if prefix
77
+ # @param params [Hash]
78
+ # @param prefix [String]
79
+ # @param pieces [Array]
80
+ def process_params(params, prefix = nil, pieces = nil, &block)
81
+ params.inject(pieces || []) do |all, (key, value)|
82
+ key = "#{prefix}[#{key}]" if prefix
55
83
 
56
- case value
57
- when Array
58
- values = value.inject([]) { |a,v| a << [nil, v] }
59
- process_params(values, key, all, &block)
60
- when Hash
61
- process_params(value, key, all, &block)
62
- else
63
- all << block.call(key, value)
84
+ case value
85
+ when Array
86
+ values = value.inject([]) { |a, v| a << [nil, v] }
87
+ process_params(values, key, all, &block)
88
+ when Hash
89
+ process_params(value, key, all, &block)
90
+ else
91
+ # rubocop:disable Performance/RedundantBlockCall
92
+ all << block.call(key, value)
93
+ # rubocop:enable Performance/RedundantBlockCall
94
+ end
64
95
  end
65
96
  end
66
97
  end
@@ -1,210 +1,239 @@
1
+ # frozen_string_literal: true
2
+
1
3
  module Faraday
2
- # Catches exceptions and retries each request a limited number of times.
3
- #
4
- # By default, it retries 2 times and handles only timeout exceptions. It can
5
- # be configured with an arbitrary number of retries, a list of exceptions to
6
- # handle, a retry interval, a percentage of randomness to add to the retry
7
- # interval, and a backoff factor.
8
- #
9
- # Examples
10
- #
11
- # Faraday.new do |conn|
12
- # conn.request :retry, max: 2, interval: 0.05,
13
- # interval_randomness: 0.5, backoff_factor: 2,
14
- # exceptions: [CustomException, 'Timeout::Error']
15
- # conn.adapter ...
16
- # end
17
- #
18
- # This example will result in a first interval that is random between 0.05 and 0.075 and a second
19
- # interval that is random between 0.1 and 0.15
20
- #
21
- class Request::Retry < Faraday::Middleware
22
-
23
- DEFAULT_EXCEPTIONS = [Errno::ETIMEDOUT, 'Timeout::Error', Error::TimeoutError, Faraday::Error::RetriableResponse].freeze
24
- IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
25
-
26
- class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
27
- :backoff_factor, :exceptions, :methods, :retry_if, :retry_block,
28
- :retry_statuses)
29
-
30
- DEFAULT_CHECK = lambda { |env,exception| false }
31
-
32
- def self.from(value)
33
- if Integer === value
34
- new(value)
35
- else
36
- super(value)
4
+ class Request
5
+ # Catches exceptions and retries each request a limited number of times.
6
+ #
7
+ # By default, it retries 2 times and handles only timeout exceptions. It can
8
+ # be configured with an arbitrary number of retries, a list of exceptions to
9
+ # handle, a retry interval, a percentage of randomness to add to the retry
10
+ # interval, and a backoff factor.
11
+ #
12
+ # @example Configure Retry middleware using intervals
13
+ # Faraday.new do |conn|
14
+ # conn.request(:retry, max: 2,
15
+ # interval: 0.05,
16
+ # interval_randomness: 0.5,
17
+ # backoff_factor: 2,
18
+ # exceptions: [CustomException, 'Timeout::Error'])
19
+ #
20
+ # conn.adapter(:net_http) # NB: Last middleware must be the adapter
21
+ # end
22
+ #
23
+ # This example will result in a first interval that is random between 0.05
24
+ # and 0.075 and a second interval that is random between 0.1 and 0.15.
25
+ class Retry < Faraday::Middleware
26
+ DEFAULT_EXCEPTIONS = [
27
+ Errno::ETIMEDOUT, 'Timeout::Error',
28
+ Faraday::TimeoutError, Faraday::RetriableResponse
29
+ ].freeze
30
+ IDEMPOTENT_METHODS = %i[delete get head options put].freeze
31
+
32
+ # Options contains the configurable parameters for the Retry middleware.
33
+ class Options < Faraday::Options.new(:max, :interval, :max_interval,
34
+ :interval_randomness,
35
+ :backoff_factor, :exceptions,
36
+ :methods, :retry_if, :retry_block,
37
+ :retry_statuses)
38
+
39
+ DEFAULT_CHECK = ->(_env, _exception) { false }
40
+
41
+ def self.from(value)
42
+ if value.is_a?(Integer)
43
+ new(value)
44
+ else
45
+ super(value)
46
+ end
37
47
  end
38
- end
39
48
 
40
- def max
41
- (self[:max] ||= 2).to_i
42
- end
49
+ def max
50
+ (self[:max] ||= 2).to_i
51
+ end
43
52
 
44
- def interval
45
- (self[:interval] ||= 0).to_f
46
- end
53
+ def interval
54
+ (self[:interval] ||= 0).to_f
55
+ end
47
56
 
48
- def max_interval
49
- (self[:max_interval] ||= Float::MAX).to_f
50
- end
57
+ def max_interval
58
+ (self[:max_interval] ||= Float::MAX).to_f
59
+ end
51
60
 
52
- def interval_randomness
53
- (self[:interval_randomness] ||= 0).to_f
54
- end
61
+ def interval_randomness
62
+ (self[:interval_randomness] ||= 0).to_f
63
+ end
55
64
 
56
- def backoff_factor
57
- (self[:backoff_factor] ||= 1).to_f
58
- end
65
+ def backoff_factor
66
+ (self[:backoff_factor] ||= 1).to_f
67
+ end
59
68
 
60
- def exceptions
61
- Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
62
- end
69
+ def exceptions
70
+ Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
71
+ end
63
72
 
64
- def methods
65
- Array(self[:methods] ||= IDEMPOTENT_METHODS)
66
- end
73
+ def methods
74
+ Array(self[:methods] ||= IDEMPOTENT_METHODS)
75
+ end
67
76
 
68
- def retry_if
69
- self[:retry_if] ||= DEFAULT_CHECK
70
- end
77
+ def retry_if
78
+ self[:retry_if] ||= DEFAULT_CHECK
79
+ end
71
80
 
72
- def retry_block
73
- self[:retry_block] ||= Proc.new {}
74
- end
81
+ def retry_block
82
+ self[:retry_block] ||= proc {}
83
+ end
75
84
 
76
- def retry_statuses
77
- Array(self[:retry_statuses] ||= [])
85
+ def retry_statuses
86
+ Array(self[:retry_statuses] ||= [])
87
+ end
78
88
  end
79
- end
80
89
 
81
- # Public: Initialize middleware
82
- #
83
- # Options:
84
- # max - Maximum number of retries (default: 2)
85
- # interval - Pause in seconds between retries (default: 0)
86
- # interval_randomness - The maximum random interval amount expressed
87
- # as a float between 0 and 1 to use in addition to the
88
- # interval. (default: 0)
89
- # max_interval - An upper limit for the interval (default: Float::MAX)
90
- # backoff_factor - The amount to multiple each successive retry's
91
- # interval amount by in order to provide backoff
92
- # (default: 1)
93
- # exceptions - The list of exceptions to handle. Exceptions can be
94
- # given as Class, Module, or String. (default:
95
- # [Errno::ETIMEDOUT, 'Timeout::Error',
96
- # Error::TimeoutError, Faraday::Error::RetriableResponse])
97
- # methods - A list of HTTP methods to retry without calling retry_if. Pass
98
- # an empty Array to call retry_if for all exceptions.
99
- # (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
100
- # retry_if - block that will receive the env object and the exception raised
101
- # and should decide if the code should retry still the action or
102
- # not independent of the retry count. This would be useful
103
- # if the exception produced is non-recoverable or if the
104
- # the HTTP method called is not idempotent.
105
- # (defaults to return false)
106
- # retry_block - block that is executed after every retry. Request environment, middleware options,
107
- # current number of retries and the exception is passed to the block as parameters.
108
- def initialize(app, options = nil)
109
- super(app)
110
- @options = Options.from(options)
111
- @errmatch = build_exception_matcher(@options.exceptions)
112
- end
90
+ # @param app [#call]
91
+ # @param options [Hash]
92
+ # @option options [Integer] :max (2) Maximum number of retries
93
+ # @option options [Integer] :interval (0) Pause in seconds between retries
94
+ # @option options [Integer] :interval_randomness (0) The maximum random
95
+ # interval amount expressed as a float between
96
+ # 0 and 1 to use in addition to the interval.
97
+ # @option options [Integer] :max_interval (Float::MAX) An upper limit
98
+ # for the interval
99
+ # @option options [Integer] :backoff_factor (1) The amount to multiply
100
+ # each successive retry's interval amount by in order to provide backoff
101
+ # @option options [Array] :exceptions ([ Errno::ETIMEDOUT,
102
+ # 'Timeout::Error', Faraday::TimeoutError, Faraday::RetriableResponse])
103
+ # The list of exceptions to handle. Exceptions can be given as
104
+ # Class, Module, or String.
105
+ # @option options [Array] :methods (the idempotent HTTP methods
106
+ # in IDEMPOTENT_METHODS) A list of HTTP methods to retry without
107
+ # calling retry_if. Pass an empty Array to call retry_if
108
+ # for all exceptions.
109
+ # @option options [Block] :retry_if (false) block that will receive
110
+ # the env object and the exception raised
111
+ # and should decide if the code should retry still the action or
112
+ # not independent of the retry count. This would be useful
113
+ # if the exception produced is non-recoverable or if the
114
+ # the HTTP method called is not idempotent.
115
+ # @option options [Block] :retry_block block that is executed after
116
+ # every retry. Request environment, middleware options, current number
117
+ # of retries and the exception is passed to the block as parameters.
118
+ # @option options [Array] :retry_statuses Array of Integer HTTP status
119
+ # codes or a single Integer value that determines whether to raise
120
+ # a Faraday::RetriableResponse exception based on the HTTP status code
121
+ # of an HTTP response.
122
+ def initialize(app, options = nil)
123
+ super(app)
124
+ @options = Options.from(options)
125
+ @errmatch = build_exception_matcher(@options.exceptions)
126
+ end
113
127
 
114
- def calculate_sleep_amount(retries, env)
115
- retry_after = calculate_retry_after(env)
116
- retry_interval = calculate_retry_interval(retries)
128
+ def calculate_sleep_amount(retries, env)
129
+ retry_after = calculate_retry_after(env)
130
+ retry_interval = calculate_retry_interval(retries)
117
131
 
118
- return if retry_after && retry_after > @options.max_interval
132
+ return if retry_after && retry_after > @options.max_interval
119
133
 
120
- retry_after && retry_after >= retry_interval ? retry_after : retry_interval
121
- end
134
+ if retry_after && retry_after >= retry_interval
135
+ retry_after
136
+ else
137
+ retry_interval
138
+ end
139
+ end
122
140
 
123
- def call(env)
124
- retries = @options.max
125
- request_body = env[:body]
126
- begin
127
- env[:body] = request_body # after failure env[:body] is set to the response body
128
- @app.call(env).tap do |resp|
129
- raise Faraday::Error::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
130
- end
131
- rescue @errmatch => exception
132
- if retries > 0 && retry_request?(env, exception)
133
- retries -= 1
134
- rewind_files(request_body)
135
- @options.retry_block.call(env, @options, retries, exception)
136
- if (sleep_amount = calculate_sleep_amount(retries + 1, env))
137
- sleep sleep_amount
138
- retry
141
+ # @param env [Faraday::Env]
142
+ def call(env)
143
+ retries = @options.max
144
+ request_body = env[:body]
145
+ begin
146
+ # after failure env[:body] is set to the response body
147
+ env[:body] = request_body
148
+ @app.call(env).tap do |resp|
149
+ if @options.retry_statuses.include?(resp.status)
150
+ raise Faraday::RetriableResponse.new(nil, resp)
151
+ end
152
+ end
153
+ rescue @errmatch => e
154
+ if retries.positive? && retry_request?(env, e)
155
+ retries -= 1
156
+ rewind_files(request_body)
157
+ @options.retry_block.call(env, @options, retries, e)
158
+ if (sleep_amount = calculate_sleep_amount(retries + 1, env))
159
+ sleep sleep_amount
160
+ retry
161
+ end
139
162
  end
140
- end
141
163
 
142
- if exception.is_a?(Faraday::Error::RetriableResponse)
143
- exception.response
144
- else
145
- raise
164
+ raise unless e.is_a?(Faraday::RetriableResponse)
165
+
166
+ e.response
146
167
  end
147
168
  end
148
- end
149
169
 
150
- # Private: construct an exception matcher object.
151
- #
152
- # An exception matcher for the rescue clause can usually be any object that
153
- # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
154
- def build_exception_matcher(exceptions)
155
- matcher = Module.new
156
- (class << matcher; self; end).class_eval do
157
- define_method(:===) do |error|
158
- exceptions.any? do |ex|
159
- if ex.is_a? Module
160
- error.is_a? ex
161
- else
162
- error.class.to_s == ex.to_s
170
+ # An exception matcher for the rescue clause can usually be any object
171
+ # that responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
172
+ #
173
+ # @param exceptions [Array]
174
+ # @api private
175
+ # @return [Module] an exception matcher
176
+ def build_exception_matcher(exceptions)
177
+ matcher = Module.new
178
+ (
179
+ class << matcher
180
+ self
181
+ end).class_eval do
182
+ define_method(:===) do |error|
183
+ exceptions.any? do |ex|
184
+ if ex.is_a? Module
185
+ error.is_a? ex
186
+ else
187
+ error.class.to_s == ex.to_s
188
+ end
163
189
  end
164
190
  end
165
191
  end
192
+ matcher
166
193
  end
167
- matcher
168
- end
169
194
 
170
- private
195
+ private
171
196
 
172
- def retry_request?(env, exception)
173
- @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
174
- end
197
+ def retry_request?(env, exception)
198
+ @options.methods.include?(env[:method]) ||
199
+ @options.retry_if.call(env, exception)
200
+ end
201
+
202
+ def rewind_files(body)
203
+ return unless body.is_a?(Hash)
175
204
 
176
- def rewind_files(body)
177
- return unless body.is_a?(Hash)
178
- body.each do |_, value|
179
- if value.is_a? UploadIO
180
- value.rewind
205
+ body.each do |_, value|
206
+ value.rewind if value.is_a?(UploadIO)
181
207
  end
182
208
  end
183
- end
184
209
 
185
- # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
186
- def calculate_retry_after(env)
187
- response_headers = env[:response_headers]
188
- return unless response_headers
210
+ # MDN spec for Retry-After header:
211
+ # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
212
+ def calculate_retry_after(env)
213
+ response_headers = env[:response_headers]
214
+ return unless response_headers
189
215
 
190
- retry_after_value = env[:response_headers]["Retry-After"]
216
+ retry_after_value = env[:response_headers]['Retry-After']
191
217
 
192
- # Try to parse date from the header value
193
- begin
194
- datetime = DateTime.rfc2822(retry_after_value)
195
- datetime.to_time - Time.now.utc
196
- rescue ArgumentError
197
- retry_after_value.to_f
218
+ # Try to parse date from the header value
219
+ begin
220
+ datetime = DateTime.rfc2822(retry_after_value)
221
+ datetime.to_time - Time.now.utc
222
+ rescue ArgumentError
223
+ retry_after_value.to_f
224
+ end
198
225
  end
199
- end
200
226
 
201
- def calculate_retry_interval(retries)
202
- retry_index = @options.max - retries
203
- current_interval = @options.interval * (@options.backoff_factor ** retry_index)
204
- current_interval = [current_interval, @options.max_interval].min
205
- random_interval = rand * @options.interval_randomness.to_f * @options.interval
227
+ def calculate_retry_interval(retries)
228
+ retry_index = @options.max - retries
229
+ current_interval = @options.interval *
230
+ (@options.backoff_factor**retry_index)
231
+ current_interval = [current_interval, @options.max_interval].min
232
+ random_interval = rand * @options.interval_randomness.to_f *
233
+ @options.interval
206
234
 
207
- current_interval + random_interval
235
+ current_interval + random_interval
236
+ end
208
237
  end
209
238
  end
210
239
  end