faraday 1.3.0 → 1.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f907e999805c78e8c2e77cb4d6b29a0a6f8fd8fe1a7df9930f02be7ec113a630
-  data.tar.gz: 1ceac7f2b44d41d11d1ad3f7642daea9198ba3ac2f71a4932cf7d6b7b867f704
+  metadata.gz: 54fc3007a99cab5f45291408bfb7e2b1f6d243abcae060f5d485731328acb031
+  data.tar.gz: 0fc0eb9ab470bca83b7b6fbc8cafcd9d141dd97eda575f63cf4b2bc6dcb36a65
 SHA512:
-  metadata.gz: 2eaf54d743ed3d7554fb2be17003e81b08c060582f140b06fb55e8aceb7dfcf2428e898f47f3760eddcdb4ad64aeaacc93916672b9ed10fa4a004d0ea1a20e1a
-  data.tar.gz: a700f0bc8999e9a0152843bbfbd23001fa23931614ae9573b13ff839e7af01f38ca2adbb01c82e4b387688496b3caff87357e3946d7500595a2f807313e177d7
+  metadata.gz: ed9fee068b4cbbe13bacfa7eb01d02b919c0ffd72345a4449127f9ad11c7a7e585fa891c8d7791861fa91c8ebe47b9d7e78f760680eaf856db3c029c5f5cc1e0
+  data.tar.gz: 47d4550ed834bdd5938312aafd9ea9ca4be061a12cd564fa83d08e7c67a44445a8870d12ef0030b6d9d84796813e97ff7ca859722ca786e449cfc25c66ebdb23

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Faraday Changelog
 
+## [v1.3.0](https://github.com/lostisland/faraday/releases/tag/v1.3.0) (2020-12-31)
+
+### Highlights
+Faraday v1.3.0 is the first release to officially support Ruby 3.0 in the CI pipeline 🎉 🍾! 
+
+This is also the first release with a previously "included" adapter (Net::HTTP) being isolated into a [separate gem](https://github.com/lostisland/faraday-net_http) 🎊!
+The new adapter is added to Faraday as a dependency for now, so that means full backwards-compatibility, but just to be safe be careful when upgrading!
+
+This is a huge step towards are Faraday v2.0 objective of pushing adapters and middleware into separate gems.
+Many thanks to the Faraday Team, @JanDintel and everyone who attended the [ROSS Conf remote event](https://www.rossconf.io/event/remote/)
+
+### Features
+
+* Improves consistency with Faraday::Error and Faraday::RaiseError (#1229, @qsona, @iMacTia)
+
+### Fixes
+
+* Don't assign to global ::Timer (#1227, @bpo)
+
+### Documentation
+
+* CHANGELOG: add releases after 1.0 (#1225, @olleolleolle)
+* Improves retry middleware documentation. (#1228, @iMacTia)
+
+### Misc
+
+* Move out Net::HTTP adapter (#1222, @JanDintel, @iMacTia)
+* Adds Ruby 3.0 to CI Matrix (#1226, @iMacTia)
+
+
 ## [v1.2.0](https://github.com/lostisland/faraday/releases/tag/v1.2.0) (2020-12-23)
 
 ### Features

data/README.md

@@ -2,7 +2,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
 [![GitHub Actions CI](https://github.com/lostisland/faraday/workflows/CI/badge.svg)](https://github.com/lostisland/faraday/actions?query=workflow%3ACI)
-[![Maintainability](https://api.codeclimate.com/v1/badges/f869daab091ceef1da73/maintainability)](https://codeclimate.com/github/lostisland/faraday/maintainability)
 [![Gitter](https://badges.gitter.im/lostisland/faraday.svg)](https://gitter.im/lostisland/faraday?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 
@@ -47,7 +46,7 @@ But before you start coding, please read our [Contributing Guide][contributing]
 [website]:      https://lostisland.github.io/faraday
 [faraday_team]: https://lostisland.github.io/faraday/team
 [contributing]: https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md
-[apidoc]:       http://www.rubydoc.info/gems/faraday
+[apidoc]:       https://www.rubydoc.info/github/lostisland/faraday
 [actions]:      https://github.com/lostisland/faraday/actions
 [jruby]:        http://jruby.org/
 [rubinius]:     http://rubini.us/

data/examples/client_spec.rb

@@ -12,8 +12,8 @@ class Client
     @conn = conn
   end
 
-  def sushi(jname)
-    res = @conn.get("/#{jname}")
+  def sushi(jname, params: {})
+    res = @conn.get("/#{jname}", params)
     data = JSON.parse(res.body)
     data['name']
   end
@@ -62,4 +62,36 @@ RSpec.describe Client do
     expect { client.sushi('ebi') }.to raise_error(Faraday::ConnectionFailed)
     stubs.verify_stubbed_calls
   end
+
+  context 'When the test stub is run in strict_mode' do
+    let(:stubs) { Faraday::Adapter::Test::Stubs.new(strict_mode: true) }
+
+    it 'verifies the all parameter values are identical' do
+      stubs.get('/ebi?abc=123') do
+        [
+          200,
+          { 'Content-Type': 'application/javascript' },
+          '{"name": "shrimp"}'
+        ]
+      end
+
+      # uncomment to raise Stubs::NotFound
+      # expect(client.sushi('ebi', params: { abc: 123, foo: 'Kappa' })).to eq('shrimp')
+      expect(client.sushi('ebi', params: { abc: 123 })).to eq('shrimp')
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  context 'When the Faraday connection is configured with FlatParamsEncoder' do
+    let(:conn) { Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) { |b| b.adapter(:test, stubs) } }
+
+    it 'handles the same multiple URL parameters' do
+      stubs.get('/ebi?a=x&a=y&a=z') { [200, { 'Content-Type' => 'application/json' }, '{"name": "shrimp"}'] }
+
+      # uncomment to raise Stubs::NotFound
+      # expect(client.sushi('ebi', params: { a: %w[x y] })).to eq('shrimp')
+      expect(client.sushi('ebi', params: { a: %w[x y z] })).to eq('shrimp')
+      stubs.verify_stubbed_calls
+    end
+  end
 end

data/examples/client_test.rb

@@ -13,8 +13,8 @@ class Client
     @conn = conn
   end
 
-  def sushi(jname)
-    res = @conn.get("/#{jname}")
+  def sushi(jname, params: {})
+    res = @conn.get("/#{jname}", params)
     data = JSON.parse(res.body)
     data['name']
   end
@@ -70,6 +70,45 @@ class ClientTest < Test::Unit::TestCase
     stubs.verify_stubbed_calls
   end
 
+  def test_strict_mode
+    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
+    stubs.get('/ebi?abc=123') do
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+
+    cli = client(stubs)
+    assert_equal 'shrimp', cli.sushi('ebi', params: { abc: 123 })
+
+    # uncomment to raise Stubs::NotFound
+    # assert_equal 'shrimp', cli.sushi('ebi', params: { abc: 123, foo: 'Kappa' })
+    stubs.verify_stubbed_calls
+  end
+
+  def test_non_default_params_encoder
+    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
+    stubs.get('/ebi?a=x&a=y&a=z') do
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+    conn = Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
+      builder.adapter :test, stubs
+    end
+
+    cli = Client.new(conn)
+    assert_equal 'shrimp', cli.sushi('ebi', params: { a: %w[x y z] })
+
+    # uncomment to raise Stubs::NotFound
+    # assert_equal 'shrimp', cli.sushi('ebi', params: { a: %w[x y] })
+    stubs.verify_stubbed_calls
+  end
+
   def client(stubs)
     conn = Faraday.new do |builder|
       builder.adapter :test, stubs

data/lib/faraday/adapter/test.rb

@@ -25,6 +25,9 @@ module Faraday
     #          "showing item: #{meta[:match_data][1]}"
     #         ]
     #       end
+    #
+    #       # You can set strict_mode to exactly match the stubbed requests.
+    #       stub.strict_mode = true
     #     end
     #   end
     #
@@ -47,10 +50,11 @@ module Faraday
         class NotFound < StandardError
         end
 
-        def initialize
+        def initialize(strict_mode: false)
           # { get: [Stub, Stub] }
           @stack = {}
           @consumed = {}
+          @strict_mode = strict_mode
           yield(self) if block_given?
         end
 
@@ -58,18 +62,20 @@ module Faraday
           @stack.empty?
         end
 
-        def match(request_method, host, path, headers, body)
+        # @param env [Faraday::Env]
+        def match(env)
+          request_method = env[:method]
           return false unless @stack.key?(request_method)
 
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
 
-          stub, meta = matches?(stack, host, path, headers, body)
+          stub, meta = matches?(stack, env)
           if stub
             consumed << stack.delete(stub)
             return stub, meta
           end
-          matches?(consumed, host, path, headers, body)
+          matches?(consumed, env)
         end
 
         def get(path, headers = {}, &block)
@@ -115,6 +121,17 @@ module Faraday
           raise failed_stubs.join(' ') unless failed_stubs.empty?
         end
 
+        # Set strict_mode. If the value is true, this adapter tries to find matched requests strictly,
+        # which means that all of a path, parameters, and headers must be the same as an actual request.
+        def strict_mode=(value)
+          @strict_mode = value
+          @stack.each do |_method, stubs|
+            stubs.each do |stub|
+              stub.strict_mode = value
+            end
+          end
+        end
+
         protected
 
         def new_stub(request_method, path, headers = {}, body = nil, &block)
@@ -127,14 +144,18 @@ module Faraday
                 Faraday::Utils.URI(path).host
               ]
             end
+          path, query = normalized_path.respond_to?(:split) ? normalized_path.split('?') : normalized_path
+          headers = Utils::Headers.new(headers)
 
-          stub = Stub.new(host, normalized_path, headers, body, block)
+          stub = Stub.new(host, path, query, headers, body, @strict_mode, block)
           (@stack[request_method] ||= []) << stub
         end
 
-        def matches?(stack, host, path, headers, body)
+        # @param stack [Hash]
+        # @param env [Faraday::Env]
+        def matches?(stack, env)
           stack.each do |stub|
-            match_result, meta = stub.matches?(host, path, headers, body)
+            match_result, meta = stub.matches?(env)
             return stub, meta if match_result
           end
           nil
@@ -142,35 +163,20 @@ module Faraday
       end
 
       # Stub request
-      # rubocop:disable Style/StructInheritance
-      class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
-        # rubocop:enable Style/StructInheritance
-        def initialize(host, full, headers, body, block)
-          path, query = full.respond_to?(:split) ? full.split('?') : full
-          params =
-            if query
-              Faraday::Utils.parse_nested_query(query)
-            else
-              {}
-            end
-
-          super(host, path, params, headers, body, block)
-        end
+      class Stub < Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) # rubocop:disable Style/StructInheritance
+        # @param env [Faraday::Env]
+        def matches?(env)
+          request_host = env[:url].host
+          request_path = Faraday::Utils.normalize_path(env[:url].path)
+          request_headers = env.request_headers
+          request_body = env[:body]
 
-        def matches?(request_host, request_uri, request_headers, request_body)
-          request_path, request_query = request_uri.split('?')
-          request_params =
-            if request_query
-              Faraday::Utils.parse_nested_query(request_query)
-            else
-              {}
-            end
           # meta is a hash used as carrier
           # that will be yielded to consumer block
           meta = {}
           [(host.nil? || host == request_host) &&
             path_match?(request_path, meta) &&
-            params_match?(request_params) &&
+            params_match?(env) &&
             (body.to_s.size.zero? || request_body == body) &&
             headers_match?(request_headers), meta]
         end
@@ -183,13 +189,30 @@ module Faraday
           end
         end
 
-        def params_match?(request_params)
+        # @param env [Faraday::Env]
+        def params_match?(env)
+          request_params = env[:params]
+          params = env.params_encoder.decode(query) || {}
+
+          if strict_mode
+            return Set.new(params) == Set.new(request_params)
+          end
+
           params.keys.all? do |key|
             request_params[key] == params[key]
           end
         end
 
         def headers_match?(request_headers)
+          if strict_mode
+            headers_with_user_agent = headers.dup.tap do |hs|
+              # NOTE: Set User-Agent in case it's not set when creating Stubs.
+              #       Users would not want to set Faraday's User-Agent explicitly.
+              hs[:user_agent] ||= Connection::USER_AGENT
+            end
+            return Set.new(headers_with_user_agent) == Set.new(request_headers)
+          end
+
           headers.keys.all? do |key|
             request_headers[key] == headers[key]
           end
@@ -210,26 +233,19 @@ module Faraday
         yield(stubs)
       end
 
+      # @param env [Faraday::Env]
       def call(env)
         super
-        host = env[:url].host
-        normalized_path = Faraday::Utils.normalize_path(env[:url])
-        params_encoder = env.request.params_encoder ||
-                         Faraday::Utils.default_params_encoder
 
-        stub, meta = stubs.match(env[:method], host, normalized_path,
-                                 env.request_headers, env[:body])
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env[:params] = env.params_encoder.decode(env[:url].query) || {}
+        stub, meta = stubs.match(env)
 
         unless stub
           raise Stubs::NotFound, "no stubbed request for #{env[:method]} "\
-                                 "#{normalized_path} #{env[:body]}"
+                                 "#{env[:url]} #{env[:body]}"
         end
 
-        env[:params] = if (query = env[:url].query)
-                         params_encoder.decode(query)
-                       else
-                         {}
-                       end
         block_arity = stub.block.arity
         status, headers, body =
           if block_arity >= 0

data/lib/faraday/adapter.rb

@@ -11,17 +11,7 @@ module Faraday
 
     register_middleware File.expand_path('adapter', __dir__),
                         test: [:Test, 'test'],
-                        net_http_persistent: [
-                          :NetHttpPersistent,
-                          'net_http_persistent'
-                        ],
-                        typhoeus: [:Typhoeus, 'typhoeus'],
-                        patron: [:Patron, 'patron'],
-                        em_synchrony: [:EMSynchrony, 'em_synchrony'],
-                        em_http: [:EMHttp, 'em_http'],
-                        excon: [:Excon, 'excon'],
-                        rack: [:Rack, 'rack'],
-                        httpclient: [:HTTPClient, 'httpclient']
+                        typhoeus: [:Typhoeus, 'typhoeus']
 
     # This module marks an Adapter as supporting parallel requests.
     module Parallelism

data/lib/faraday/autoload.rb

@@ -58,15 +58,8 @@ module Faraday
   class Adapter
     extend AutoloadHelper
     autoload_all 'faraday/adapter',
-                 NetHttpPersistent: 'net_http_persistent',
-                 EMSynchrony: 'em_synchrony',
-                 EMHttp: 'em_http',
                  Typhoeus: 'typhoeus',
-                 Patron: 'patron',
-                 Excon: 'excon',
-                 Test: 'test',
-                 Rack: 'rack',
-                 HTTPClient: 'httpclient'
+                 Test: 'test'
   end
 
   # Request represents a single HTTP request for a Faraday adapter to make.

data/lib/faraday/connection.rb

@@ -15,6 +15,7 @@ module Faraday
   class Connection
     # A Set of allowed HTTP verbs.
     METHODS = Set.new %i[get post put delete head patch options trace]
+    USER_AGENT = "Faraday v#{VERSION}"
 
     # @return [Hash] URI query unencoded key/value pairs.
     attr_reader :params
@@ -26,7 +27,7 @@ module Faraday
     #   Connection. This includes a default host name, scheme, port, and path.
     attr_reader :url_prefix
 
-    # @return [Faraday::Builder] Builder for this Connection.
+    # @return [Faraday::RackBuilder] Builder for this Connection.
     attr_reader :builder
 
     # @return [Hash] SSL options.
@@ -73,6 +74,7 @@ module Faraday
       @options = options.request
       @ssl = options.ssl
       @default_parallel_manager = options.parallel_manager
+      @manual_proxy = nil
 
       @builder = options.builder || begin
         # pass an empty block to Builder so it doesn't assume default middleware
@@ -88,7 +90,7 @@ module Faraday
 
       yield(self) if block_given?
 
-      @headers[:user_agent] ||= "Faraday v#{VERSION}"
+      @headers[:user_agent] ||= USER_AGENT
     end
 
     def initialize_proxy(url, options)
@@ -295,6 +297,11 @@ module Faraday
     #
     # @return [void]
     def basic_auth(login, pass)
+      warn <<~TEXT
+        WARNING: `Faraday::Connection#basic_auth` is deprecated; it will be removed in version 2.0.
+        While initializing your connection, use `#request(:basic_auth, ...)` instead.
+        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
+      TEXT
       set_authorization_header(:basic_auth, login, pass)
     end
 
@@ -312,6 +319,11 @@ module Faraday
     #
     # @return [void]
     def token_auth(token, options = nil)
+      warn <<~TEXT
+        WARNING: `Faraday::Connection#token_auth` is deprecated; it will be removed in version 2.0.
+        While initializing your connection, use `#request(:token_auth, ...)` instead.
+        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
+      TEXT
       set_authorization_header(:token_auth, token, options)
     end
 
@@ -334,6 +346,11 @@ module Faraday
     #
     # @return [void]
     def authorization(type, token)
+      warn <<~TEXT
+        WARNING: `Faraday::Connection#authorization` is deprecated; it will be removed in version 2.0.
+        While initializing your connection, use `#request(:authorization, ...)` instead.
+        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
+      TEXT
       set_authorization_header(:authorization, type, token)
     end
 
@@ -416,9 +433,16 @@ module Faraday
       uri.query = nil
 
       with_uri_credentials(uri) do |user, password|
-        basic_auth user, password
+        set_basic_auth(user, password)
         uri.user = uri.password = nil
       end
+
+      @proxy = proxy_from_env(url) unless @manual_proxy
+    end
+
+    def set_basic_auth(user, password)
+      header = Faraday::Request::BasicAuthentication.header(user, password)
+      headers[Faraday::Request::Authorization::KEY] = header
     end
 
     # Sets the path prefix and ensures that it always has a leading
@@ -517,11 +541,11 @@ module Faraday
     # @return [URI]
     def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
       url = nil if url.respond_to?(:empty?) && url.empty?
-      base = url_prefix
+      base = url_prefix.dup
       if url && base.path && base.path !~ %r{/$}
-        base = base.dup
         base.path = "#{base.path}/" # ensure trailing slash
       end
+      url = url && URI.parse(url.to_s).opaque ? url.to_s.gsub(':', '%3A') : url
       uri = url ? base + url : base
       if params
         uri.query = params.to_query(params_encoder || options.params_encoder)
@@ -576,7 +600,11 @@ module Faraday
         case url
         when String
           uri = Utils.URI(url)
-          uri = URI.parse("#{uri.scheme}://#{uri.hostname}").find_proxy
+          uri = if uri.host.nil?
+                  find_default_proxy
+                else
+                  URI.parse("#{uri.scheme}://#{uri.host}").find_proxy
+                end
         when URI
           uri = url.find_proxy
         when nil

data/lib/faraday/error.rb

@@ -143,10 +143,4 @@ module Faraday
   # Raised by FaradayMiddleware::ResponseMiddleware
   class ParsingError < Error
   end
-
-  # Exception used to control the Retry middleware.
-  #
-  # @see Faraday::Request::Retry
-  class RetriableResponse < Error
-  end
 end

data/lib/faraday/options/proxy_options.rb

@@ -11,6 +11,9 @@ module Faraday
     def self.from(value)
       case value
       when String
+        # URIs without a scheme should default to http (like 'example:123').
+        # This fixes #1282 and prevents a silent failure in some adapters.
+        value = "http://#{value}" unless value.include?('://')
         value = { uri: Utils.URI(value) }
       when URI
         value = { uri: value }
@@ -19,6 +22,7 @@ module Faraday
           value[:uri] = Utils.URI(uri)
         end
       end
+
       super(value)
     end
 

data/lib/faraday/request/authorization.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'base64'
+
 module Faraday
   class Request
     # Request middleware for the Authorization HTTP header
@@ -13,7 +15,8 @@ module Faraday
       # @return [String] a header value
       def self.header(type, token)
         case token
-        when String, Symbol
+        when String, Symbol, Proc
+          token = token.call if token.is_a?(Proc)
           "#{type} #{token}"
         when Hash
           build_hash(type.to_s, token)
@@ -32,6 +35,7 @@ module Faraday
         comma = ', '
         values = []
         hash.each do |key, value|
+          value = value.call if value.is_a?(Proc)
           values << "#{key}=#{value.to_s.inspect}"
         end
         "#{type} #{values * comma}"
@@ -39,16 +43,19 @@ module Faraday
 
       # @param app [#call]
       # @param type [String, Symbol] Type of Authorization
-      # @param token [String, Symbol, Hash] Token value for the Authorization
-      def initialize(app, type, token)
-        @header_value = self.class.header(type, token)
+      # @param param [String, Symbol, Hash, Proc] parameter to build the Authorization header.
+      #   This value can be a proc, in which case it will be invoked on each request.
+      def initialize(app, type, param)
+        @type = type
+        @param = param
         super(app)
       end
 
       # @param env [Faraday::Env]
-      def call(env)
-        env.request_headers[KEY] = @header_value unless env.request_headers[KEY]
-        @app.call(env)
+      def on_request(env)
+        return if env.request_headers[KEY]
+
+        env.request_headers[KEY] = self.class.header(@type, @param)
       end
     end
   end

data/lib/faraday/request.rb

@@ -35,8 +35,6 @@ module Faraday
 
     register_middleware File.expand_path('request', __dir__),
                         url_encoded: [:UrlEncoded, 'url_encoded'],
-                        multipart: [:Multipart, 'multipart'],
-                        retry: [:Retry, 'retry'],
                         authorization: [:Authorization, 'authorization'],
                         basic_auth: [
                           :BasicAuthentication,

data/lib/faraday/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '1.3.0'
+  VERSION = '1.9.3'
 end

data/lib/faraday.rb

@@ -24,10 +24,25 @@ require 'faraday/adapter'
 require 'faraday/request'
 require 'faraday/response'
 require 'faraday/error'
-require 'faraday/file_part'
-require 'faraday/param_part'
-
+require 'faraday/request/url_encoded' # needed by multipart
+
+# External Middleware gems and their aliases
+require 'faraday/multipart'
+require 'faraday/retry'
+Faraday::Request::Multipart = Faraday::Multipart::Middleware
+Faraday::Request::Retry = Faraday::Retry::Middleware
+
+# External Adapters gems
+unless defined?(JRUBY_VERSION)
+  require 'faraday/em_http'
+  require 'faraday/em_synchrony'
+end
+require 'faraday/excon'
+require 'faraday/httpclient'
 require 'faraday/net_http'
+require 'faraday/net_http_persistent'
+require 'faraday/patron'
+require 'faraday/rack'
 
 # This is the main namespace for Faraday.
 #