faraday 0.16.0 → 0.17.4

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 (90) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +232 -0
  3. data/LICENSE.md +1 -1
  4. data/README.md +358 -18
  5. data/Rakefile +13 -0
  6. data/lib/faraday/adapter/em_http.rb +97 -140
  7. data/lib/faraday/adapter/em_http_ssl_patch.rb +17 -23
  8. data/lib/faraday/adapter/em_synchrony/parallel_manager.rb +15 -18
  9. data/lib/faraday/adapter/em_synchrony.rb +60 -104
  10. data/lib/faraday/adapter/excon.rb +55 -100
  11. data/lib/faraday/adapter/httpclient.rb +39 -61
  12. data/lib/faraday/adapter/net_http.rb +51 -103
  13. data/lib/faraday/adapter/net_http_persistent.rb +28 -49
  14. data/lib/faraday/adapter/patron.rb +35 -54
  15. data/lib/faraday/adapter/rack.rb +12 -28
  16. data/lib/faraday/adapter/test.rb +53 -86
  17. data/lib/faraday/adapter/typhoeus.rb +1 -4
  18. data/lib/faraday/adapter.rb +22 -36
  19. data/lib/faraday/autoload.rb +36 -47
  20. data/lib/faraday/connection.rb +179 -321
  21. data/lib/faraday/deprecate.rb +109 -0
  22. data/lib/faraday/error.rb +79 -21
  23. data/lib/faraday/middleware.rb +28 -4
  24. data/lib/faraday/options.rb +183 -32
  25. data/lib/faraday/parameters.rb +197 -4
  26. data/lib/faraday/rack_builder.rb +55 -66
  27. data/lib/faraday/request/authorization.rb +30 -42
  28. data/lib/faraday/request/basic_authentication.rb +7 -14
  29. data/lib/faraday/request/instrumentation.rb +27 -45
  30. data/lib/faraday/request/multipart.rb +48 -79
  31. data/lib/faraday/request/retry.rb +171 -197
  32. data/lib/faraday/request/token_authentication.rb +10 -15
  33. data/lib/faraday/request/url_encoded.rb +23 -41
  34. data/lib/faraday/request.rb +36 -68
  35. data/lib/faraday/response/logger.rb +69 -22
  36. data/lib/faraday/response/raise_error.rb +18 -36
  37. data/lib/faraday/response.rb +13 -20
  38. data/lib/faraday/upload_io.rb +67 -0
  39. data/lib/faraday/utils.rb +245 -28
  40. data/lib/faraday.rb +174 -93
  41. data/spec/faraday/deprecate_spec.rb +147 -0
  42. data/spec/faraday/error_spec.rb +102 -0
  43. data/spec/faraday/response/raise_error_spec.rb +106 -0
  44. data/spec/spec_helper.rb +105 -0
  45. data/test/adapters/default_test.rb +14 -0
  46. data/test/adapters/em_http_test.rb +30 -0
  47. data/test/adapters/em_synchrony_test.rb +32 -0
  48. data/test/adapters/excon_test.rb +30 -0
  49. data/test/adapters/httpclient_test.rb +34 -0
  50. data/test/adapters/integration.rb +263 -0
  51. data/test/adapters/logger_test.rb +136 -0
  52. data/test/adapters/net_http_persistent_test.rb +114 -0
  53. data/test/adapters/net_http_test.rb +79 -0
  54. data/test/adapters/patron_test.rb +40 -0
  55. data/test/adapters/rack_test.rb +38 -0
  56. data/test/adapters/test_middleware_test.rb +157 -0
  57. data/test/adapters/typhoeus_test.rb +38 -0
  58. data/test/authentication_middleware_test.rb +65 -0
  59. data/test/composite_read_io_test.rb +109 -0
  60. data/test/connection_test.rb +738 -0
  61. data/test/env_test.rb +268 -0
  62. data/test/helper.rb +75 -0
  63. data/test/live_server.rb +67 -0
  64. data/test/middleware/instrumentation_test.rb +88 -0
  65. data/test/middleware/retry_test.rb +282 -0
  66. data/test/middleware_stack_test.rb +260 -0
  67. data/test/multibyte.txt +1 -0
  68. data/test/options_test.rb +333 -0
  69. data/test/parameters_test.rb +157 -0
  70. data/test/request_middleware_test.rb +126 -0
  71. data/test/response_middleware_test.rb +72 -0
  72. data/test/strawberry.rb +2 -0
  73. data/test/utils_test.rb +98 -0
  74. metadata +50 -25
  75. data/lib/faraday/adapter_registry.rb +0 -28
  76. data/lib/faraday/dependency_loader.rb +0 -37
  77. data/lib/faraday/encoders/flat_params_encoder.rb +0 -94
  78. data/lib/faraday/encoders/nested_params_encoder.rb +0 -171
  79. data/lib/faraday/file_part.rb +0 -128
  80. data/lib/faraday/logging/formatter.rb +0 -92
  81. data/lib/faraday/middleware_registry.rb +0 -129
  82. data/lib/faraday/options/connection_options.rb +0 -22
  83. data/lib/faraday/options/env.rb +0 -181
  84. data/lib/faraday/options/proxy_options.rb +0 -28
  85. data/lib/faraday/options/request_options.rb +0 -21
  86. data/lib/faraday/options/ssl_options.rb +0 -59
  87. data/lib/faraday/param_part.rb +0 -53
  88. data/lib/faraday/utils/headers.rb +0 -139
  89. data/lib/faraday/utils/params_hash.rb +0 -61
  90. data/spec/external_adapters/faraday_specs_setup.rb +0 -14
@@ -1,19 +1,15 @@
1
- # frozen_string_literal: true
2
-
3
1
  begin
4
2
  require 'net/https'
5
3
  rescue LoadError
6
- warn 'Warning: no such file to load -- net/https. ' \
7
- 'Make sure openssl is installed if you want ssl support'
4
+ warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
8
5
  require 'net/http'
9
6
  end
10
7
  require 'zlib'
11
8
 
12
9
  module Faraday
13
10
  class Adapter
14
- # Net::HTTP adapter.
15
11
  class NetHttp < Faraday::Adapter
16
- exceptions = [
12
+ NET_HTTP_EXCEPTIONS = [
17
13
  IOError,
18
14
  Errno::EADDRNOTAVAIL,
19
15
  Errno::ECONNABORTED,
@@ -27,40 +23,34 @@ module Faraday
27
23
  Net::HTTPHeaderSyntaxError,
28
24
  Net::ProtocolError,
29
25
  SocketError,
30
- Zlib::GzipFile::Error
26
+ Zlib::GzipFile::Error,
31
27
  ]
32
28
 
33
- exceptions << OpenSSL::SSL::SSLError if defined?(OpenSSL)
34
- exceptions << Net::OpenTimeout if defined?(Net::OpenTimeout)
35
-
36
- NET_HTTP_EXCEPTIONS = exceptions.freeze
29
+ NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
30
+ NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
37
31
 
38
32
  def initialize(app = nil, opts = {}, &block)
39
- @ssl_cert_store = nil
33
+ @cert_store = nil
40
34
  super(app, opts, &block)
41
35
  end
42
36
 
43
37
  def call(env)
44
38
  super
45
39
  with_net_http_connection(env) do |http|
46
- if (env[:url].scheme == 'https') && env[:ssl]
47
- configure_ssl(http, env[:ssl])
48
- end
40
+ configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
49
41
  configure_request(http, env[:request])
50
42
 
51
43
  begin
52
44
  http_response = perform_request(http, env)
53
- rescue *NET_HTTP_EXCEPTIONS => e
54
- if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
55
- raise Faraday::SSLError, e
45
+ rescue *NET_HTTP_EXCEPTIONS => err
46
+ if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
47
+ raise Faraday::SSLError, err
48
+ else
49
+ raise Faraday::ConnectionFailed, err
56
50
  end
57
-
58
- raise Faraday::ConnectionFailed, e
59
51
  end
60
52
 
61
- save_response(env, http_response.code.to_i,
62
- http_response.body || '', nil,
63
- http_response.message) do |response_headers|
53
+ save_response(env, http_response.code.to_i, http_response.body || '', nil, http_response.message) do |response_headers|
64
54
  http_response.each_header do |key, value|
65
55
  response_headers[key] = value
66
56
  end
@@ -68,19 +58,19 @@ module Faraday
68
58
  end
69
59
 
70
60
  @app.call env
71
- rescue Timeout::Error, Errno::ETIMEDOUT => e
72
- raise Faraday::TimeoutError, e
61
+ rescue Timeout::Error, Errno::ETIMEDOUT => err
62
+ raise Faraday::TimeoutError, err
73
63
  end
74
64
 
75
65
  private
76
66
 
77
67
  def create_request(env)
78
68
  request = Net::HTTPGenericRequest.new \
79
- env[:method].to_s.upcase, # request method
80
- !!env[:body], # is there request body
81
- env[:method] != :head, # is there response body
82
- env[:url].request_uri, # request uri path
83
- env[:request_headers] # request headers
69
+ env[:method].to_s.upcase, # request method
70
+ !!env[:body], # is there request body
71
+ :head != env[:method], # is there response body
72
+ env[:url].request_uri, # request uri path
73
+ env[:request_headers] # request headers
84
74
 
85
75
  if env[:body].respond_to?(:read)
86
76
  request.body_stream = env[:body]
@@ -91,44 +81,9 @@ module Faraday
91
81
  end
92
82
 
93
83
  def perform_request(http, env)
94
- if env[:request].stream_response?
95
- size = 0
96
- yielded = false
97
- http_response = request_with_wrapped_block(http, env) do |chunk|
98
- if chunk.bytesize.positive? || size.positive?
99
- yielded = true
100
- size += chunk.bytesize
101
- env[:request].on_data.call(chunk, size)
102
- end
103
- end
104
- env[:request].on_data.call('', 0) unless yielded
105
- # Net::HTTP returns something,
106
- # but it's not meaningful according to the docs.
107
- http_response.body = nil
108
- http_response
109
- else
110
- request_with_wrapped_block(http, env)
111
- end
112
- end
113
-
114
- def request_with_wrapped_block(http, env, &block)
115
- if (env[:method] == :get) && !env[:body]
84
+ if :get == env[:method] and !env[:body]
116
85
  # prefer `get` to `request` because the former handles gzip (ruby 1.9)
117
- request_via_get_method(http, env, &block)
118
- else
119
- request_via_request_method(http, env, &block)
120
- end
121
- end
122
-
123
- def request_via_get_method(http, env, &block)
124
- http.get env[:url].request_uri, env[:request_headers], &block
125
- end
126
-
127
- def request_via_request_method(http, env, &block)
128
- if block_given?
129
- http.request create_request(env) do |response|
130
- response.read_body(&block)
131
- end
86
+ http.get env[:url].request_uri, env[:request_headers]
132
87
  else
133
88
  http.request create_request(env)
134
89
  end
@@ -139,56 +94,49 @@ module Faraday
139
94
  end
140
95
 
141
96
  def net_http_connection(env)
142
- klass = if (proxy = env[:request][:proxy])
143
- Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port,
144
- proxy[:user], proxy[:password])
145
- else
146
- Net::HTTP
147
- end
148
- port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
149
- klass.new(env[:url].hostname, port)
97
+ if proxy = env[:request][:proxy]
98
+ Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
99
+ else
100
+ Net::HTTP
101
+ end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
150
102
  end
151
103
 
152
104
  def configure_ssl(http, ssl)
153
- http.use_ssl = true
154
- http.verify_mode = ssl_verify_mode(ssl)
155
- http.cert_store = ssl_cert_store(ssl)
156
-
157
- http.cert = ssl[:client_cert] if ssl[:client_cert]
158
- http.key = ssl[:client_key] if ssl[:client_key]
159
- http.ca_file = ssl[:ca_file] if ssl[:ca_file]
160
- http.ca_path = ssl[:ca_path] if ssl[:ca_path]
105
+ http.use_ssl = true
106
+ http.verify_mode = ssl_verify_mode(ssl)
107
+ http.cert_store = ssl_cert_store(ssl)
108
+
109
+ http.cert = ssl[:client_cert] if ssl[:client_cert]
110
+ http.key = ssl[:client_key] if ssl[:client_key]
111
+ http.ca_file = ssl[:ca_file] if ssl[:ca_file]
112
+ http.ca_path = ssl[:ca_path] if ssl[:ca_path]
161
113
  http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
162
- http.ssl_version = ssl[:version] if ssl[:version]
163
- http.min_version = ssl[:min_version] if ssl[:min_version]
164
- http.max_version = ssl[:max_version] if ssl[:max_version]
114
+ http.ssl_version = ssl[:version] if ssl[:version]
115
+ http.min_version = ssl[:min_version] if ssl[:min_version]
116
+ http.max_version = ssl[:max_version] if ssl[:max_version]
165
117
  end
166
118
 
167
119
  def configure_request(http, req)
168
120
  if req[:timeout]
169
- http.read_timeout = req[:timeout]
170
- http.open_timeout = req[:timeout]
171
- if http.respond_to?(:write_timeout=)
172
- http.write_timeout = req[:timeout]
173
- end
174
- end
175
- http.open_timeout = req[:open_timeout] if req[:open_timeout]
176
- if req[:write_timeout] && http.respond_to?(:write_timeout=)
177
- http.write_timeout = req[:write_timeout]
121
+ http.read_timeout = req[:timeout]
122
+ http.open_timeout = req[:timeout]
123
+ http.write_timeout = req[:timeout] if http.respond_to?(:write_timeout=)
178
124
  end
179
- # Only set if Net::Http supports it, since Ruby 2.5.
180
- http.max_retries = 0 if http.respond_to?(:max_retries=)
125
+ http.open_timeout = req[:open_timeout] if req[:open_timeout]
126
+ http.write_timeout = req[:write_timeout] if req[:write_timeout] && http.respond_to?(:write_timeout=)
127
+ # Only set if Net::Http supports it, since Ruby 2.5.
128
+ http.max_retries = 0 if http.respond_to?(:max_retries=)
181
129
 
182
- @config_block&.call(http)
130
+ @config_block.call(http) if @config_block
183
131
  end
184
132
 
185
133
  def ssl_cert_store(ssl)
186
134
  return ssl[:cert_store] if ssl[:cert_store]
187
-
188
- @ssl_cert_store ||= begin
189
- # Use the default cert store by default, i.e. system ca certs
190
- OpenSSL::X509::Store.new.tap(&:set_default_paths)
191
- end
135
+ return @cert_store if @cert_store
136
+ # Use the default cert store by default, i.e. system ca certs
137
+ @cert_store = OpenSSL::X509::Store.new
138
+ @cert_store.set_default_paths
139
+ @cert_store
192
140
  end
193
141
 
194
142
  def ssl_verify_mode(ssl)
@@ -1,8 +1,5 @@
1
- # frozen_string_literal: true
2
-
3
1
  module Faraday
4
2
  class Adapter
5
- # Net::HTTP::Persistent adapter.
6
3
  class NetHttpPersistent < NetHttp
7
4
  dependency 'net/http/persistent'
8
5
 
@@ -10,79 +7,61 @@ module Faraday
10
7
 
11
8
  def net_http_connection(env)
12
9
  @cached_connection ||=
13
- if Net::HTTP::Persistent.instance_method(:initialize)
14
- .parameters.first == %i[key name]
15
- options = { name: 'Faraday' }
16
- if @connection_options.key?(:pool_size)
17
- options[:pool_size] = @connection_options[:pool_size]
18
- end
19
- Net::HTTP::Persistent.new(options)
10
+ if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
11
+ options = {name: 'Faraday'}
12
+ options[:pool_size] = @connection_options[:pool_size] if @connection_options.key?(:pool_size)
13
+ Net::HTTP::Persistent.new(**options)
20
14
  else
21
15
  Net::HTTP::Persistent.new('Faraday')
22
16
  end
23
17
 
24
18
  proxy_uri = proxy_uri(env)
25
- if @cached_connection.proxy_uri != proxy_uri
26
- @cached_connection.proxy = proxy_uri
27
- end
19
+ @cached_connection.proxy = proxy_uri if @cached_connection.proxy_uri != proxy_uri
28
20
  @cached_connection
29
21
  end
30
22
 
31
23
  def proxy_uri(env)
32
24
  proxy_uri = nil
33
25
  if (proxy = env[:request][:proxy])
34
- proxy_uri = if proxy[:uri].is_a?(::URI::HTTP)
35
- proxy[:uri].dup
36
- else
37
- ::URI.parse(proxy[:uri].to_s)
38
- end
26
+ proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
39
27
  proxy_uri.user = proxy_uri.password = nil
40
- # awful patch for net-http-persistent 2.8
41
- # not unescaping user/password
42
- if proxy[:user]
43
- (class << proxy_uri; self; end).class_eval do
44
- define_method(:user) { proxy[:user] }
45
- define_method(:password) { proxy[:password] }
46
- end
47
- end
28
+ # awful patch for net-http-persistent 2.8 not unescaping user/password
29
+ (class << proxy_uri; self; end).class_eval do
30
+ define_method(:user) { proxy[:user] }
31
+ define_method(:password) { proxy[:password] }
32
+ end if proxy[:user]
48
33
  end
49
34
  proxy_uri
50
35
  end
51
36
 
52
37
  def perform_request(http, env)
53
38
  http.request env[:url], create_request(env)
54
- rescue Errno::ETIMEDOUT => e
55
- raise Faraday::TimeoutError, e
56
- rescue Net::HTTP::Persistent::Error => e
57
- raise Faraday::TimeoutError, e if e.message.include? 'Timeout'
58
-
59
- if e.message.include? 'connection refused'
60
- raise Faraday::ConnectionFailed, e
39
+ rescue Errno::ETIMEDOUT => error
40
+ raise Faraday::TimeoutError, error
41
+ rescue Net::HTTP::Persistent::Error => error
42
+ if error.message.include? 'Timeout'
43
+ raise Faraday::TimeoutError, error
44
+ elsif error.message.include? 'connection refused'
45
+ raise Faraday::ConnectionFailed, error
46
+ else
47
+ raise
61
48
  end
62
-
63
- raise
64
49
  end
65
50
 
66
- SSL_CONFIGURATIONS = {
67
- certificate: :client_cert,
68
- private_key: :client_key,
69
- ca_file: :ca_file,
70
- ssl_version: :version,
71
- min_version: :min_version,
72
- max_version: :max_version
73
- }.freeze
74
-
75
51
  def configure_ssl(http, ssl)
76
52
  http_set(http, :verify_mode, ssl_verify_mode(ssl))
77
- http_set(http, :cert_store, ssl_cert_store(ssl))
53
+ http_set(http, :cert_store, ssl_cert_store(ssl))
78
54
 
79
- SSL_CONFIGURATIONS
80
- .select { |_, key| ssl[key] }
81
- .each { |target, key| http_set(http, target, ssl[key]) }
55
+ http_set(http, :certificate, ssl[:client_cert]) if ssl[:client_cert]
56
+ http_set(http, :private_key, ssl[:client_key]) if ssl[:client_key]
57
+ http_set(http, :ca_file, ssl[:ca_file]) if ssl[:ca_file]
58
+ http_set(http, :ssl_version, ssl[:version]) if ssl[:version]
82
59
  end
83
60
 
84
61
  def http_set(http, attr, value)
85
- http.send("#{attr}=", value) if http.send(attr) != value
62
+ if http.send(attr) != value
63
+ http.send("#{attr}=", value)
64
+ end
86
65
  end
87
66
  end
88
67
  end
@@ -1,8 +1,5 @@
1
- # frozen_string_literal: true
2
-
3
1
  module Faraday
4
2
  class Adapter
5
- # Patron adapter.
6
3
  class Patron < Faraday::Adapter
7
4
  dependency 'patron'
8
5
 
@@ -12,60 +9,46 @@ module Faraday
12
9
  env[:body] = env[:body].read if env[:body].respond_to? :read
13
10
 
14
11
  session = ::Patron::Session.new
15
- @config_block&.call(session)
16
- if (env[:url].scheme == 'https') && env[:ssl]
17
- configure_ssl(session, env[:ssl])
18
- end
12
+ @config_block.call(session) if @config_block
13
+ configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
19
14
 
20
- if (req = env[:request])
21
- if req[:timeout]
22
- session.timeout = session.connect_timeout = req[:timeout]
23
- end
24
- session.connect_timeout = req[:open_timeout] if req[:open_timeout]
15
+ if req = env[:request]
16
+ session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
17
+ session.connect_timeout = req[:open_timeout] if req[:open_timeout]
25
18
 
26
- if (proxy = req[:proxy])
19
+ if proxy = req[:proxy]
27
20
  proxy_uri = proxy[:uri].dup
28
- proxy_uri.user = proxy[:user] &&
29
- Utils.escape(proxy[:user]).gsub('+', '%20')
30
- proxy_uri.password = proxy[:password] &&
31
- Utils.escape(proxy[:password]).gsub('+', '%20')
21
+ proxy_uri.user = proxy[:user] && Utils.escape(proxy[:user]).gsub('+', '%20')
22
+ proxy_uri.password = proxy[:password] && Utils.escape(proxy[:password]).gsub('+', '%20')
32
23
  session.proxy = proxy_uri.to_s
33
24
  end
34
25
  end
35
26
 
36
27
  response = begin
37
28
  data = env[:body] ? env[:body].to_s : nil
38
- session.request(env[:method], env[:url].to_s,
39
- env[:request_headers], data: data)
40
- rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
41
- raise Faraday::ConnectionFailed, $ERROR_INFO
29
+ session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
30
+ rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
31
+ raise Faraday::ConnectionFailed, $!
42
32
  end
43
33
 
44
- if (req = env[:request]).stream_response?
45
- warn "Streaming downloads for #{self.class.name} " \
46
- 'are not yet implemented.'
47
- req.on_data.call(response.body, response.body.bytesize)
48
- end
49
34
  # Remove the "HTTP/1.1 200", leaving just the reason phrase
50
35
  reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
51
36
 
52
- save_response(env, response.status, response.body,
53
- response.headers, reason_phrase)
37
+ save_response(env, response.status, response.body, response.headers, reason_phrase)
54
38
 
55
39
  @app.call env
56
- rescue ::Patron::TimeoutError => e
57
- if connection_timed_out_message?(e.message)
58
- raise Faraday::ConnectionFailed, e
40
+ rescue ::Patron::TimeoutError => err
41
+ if connection_timed_out_message?(err.message)
42
+ raise Faraday::ConnectionFailed, err
43
+ else
44
+ raise Faraday::TimeoutError, err
59
45
  end
60
-
61
- raise Faraday::TimeoutError, e
62
- rescue ::Patron::Error => e
63
- if e.message.include?('code 407')
64
- raise Faraday::ConnectionFailed,
65
- %(407 "Proxy Authentication Required ")
46
+ rescue ::Patron::Error => err
47
+ if err.message.include?("code 407")
48
+ raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
49
+ else
50
+ raise Faraday::ConnectionFailed, err
66
51
  end
67
-
68
- raise Faraday::ConnectionFailed, e
69
52
  end
70
53
 
71
54
  if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
@@ -77,8 +60,8 @@ module Faraday
77
60
  actions << :options unless actions.include? :options
78
61
  else
79
62
  # Patron 0.4.20 and up
80
- actions << 'PATCH' unless actions.include? 'PATCH'
81
- actions << 'OPTIONS' unless actions.include? 'OPTIONS'
63
+ actions << "PATCH" unless actions.include? "PATCH"
64
+ actions << "OPTIONS" unless actions.include? "OPTIONS"
82
65
  end
83
66
  end
84
67
  end
@@ -93,22 +76,20 @@ module Faraday
93
76
 
94
77
  private
95
78
 
96
- CURL_TIMEOUT_MESSAGES = [
97
- 'Connection time-out',
98
- 'Connection timed out',
99
- 'Timed out before name resolve',
100
- 'server connect has timed out',
101
- 'Resolving timed out',
102
- 'name lookup timed out',
103
- 'timed out before SSL',
104
- 'connect() timed out'
105
- ].freeze
79
+ CURL_TIMEOUT_MESSAGES = [ "Connection time-out",
80
+ "Connection timed out",
81
+ "Timed out before name resolve",
82
+ "server connect has timed out",
83
+ "Resolving timed out",
84
+ "name lookup timed out",
85
+ "timed out before SSL",
86
+ "connect() timed out"
87
+ ].freeze
106
88
 
107
89
  def connection_timed_out_message?(message)
108
- CURL_TIMEOUT_MESSAGES.any? do |curl_message|
109
- message.include?(curl_message)
110
- end
90
+ CURL_TIMEOUT_MESSAGES.any? { |curl_message| message.include?(curl_message) }
111
91
  end
92
+
112
93
  end
113
94
  end
114
95
  end
@@ -1,10 +1,8 @@
1
- # frozen_string_literal: true
2
-
3
1
  module Faraday
4
2
  class Adapter
5
3
  # Sends requests to a Rack app.
6
4
  #
7
- # @example
5
+ # Examples
8
6
  #
9
7
  # class MyRackApp
10
8
  # def call(env)
@@ -19,7 +17,7 @@ module Faraday
19
17
  dependency 'rack/test'
20
18
 
21
19
  # not prefixed with "HTTP_"
22
- SPECIAL_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE].freeze
20
+ SPECIAL_HEADERS = %w[ CONTENT_LENGTH CONTENT_TYPE ]
23
21
 
24
22
  def initialize(faraday_app, rack_app)
25
23
  super(faraday_app)
@@ -29,46 +27,32 @@ module Faraday
29
27
 
30
28
  def call(env)
31
29
  super
32
- rack_env = build_rack_env(env)
30
+ rack_env = {
31
+ :method => env[:method],
32
+ :input => env[:body].respond_to?(:read) ? env[:body].read : env[:body],
33
+ 'rack.url_scheme' => env[:url].scheme
34
+ }
33
35
 
34
- env[:request_headers]&.each do |name, value|
36
+ env[:request_headers].each do |name, value|
35
37
  name = name.upcase.tr('-', '_')
36
38
  name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
37
39
  rack_env[name] = value
38
- end
40
+ end if env[:request_headers]
39
41
 
40
42
  timeout = env[:request][:timeout] || env[:request][:open_timeout]
41
43
  response = if timeout
42
- Timer.timeout(timeout, Faraday::TimeoutError) do
43
- execute_request(env, rack_env)
44
- end
45
- else
46
- execute_request(env, rack_env)
47
- end
48
-
49
- if (req = env[:request]).stream_response?
50
- warn "Streaming downloads for #{self.class.name} " \
51
- 'are not yet implemented.'
52
- req.on_data.call(response.body, response.body.bytesize)
44
+ Timer.timeout(timeout, Faraday::TimeoutError) { execute_request(env, rack_env) }
45
+ else
46
+ execute_request(env, rack_env)
53
47
  end
54
48
 
55
49
  save_response(env, response.status, response.body, response.headers)
56
50
  @app.call env
57
51
  end
58
52
 
59
- private
60
-
61
53
  def execute_request(env, rack_env)
62
54
  @session.request(env[:url].to_s, rack_env)
63
55
  end
64
-
65
- def build_rack_env(env)
66
- {
67
- method: env[:method],
68
- input: env[:body].respond_to?(:read) ? env[:body].read : env[:body],
69
- 'rack.url_scheme' => env[:url].scheme
70
- }
71
- end
72
56
  end
73
57
  end
74
58
  end