faraday 0.15.0 → 2.2.0

data/lib/faraday/rack_builder.rb

@@ -1,12 +1,21 @@
+# frozen_string_literal: true
+
+require 'ruby2_keywords'
+require 'faraday/adapter_registry'
+
 module Faraday
   # A Builder that processes requests into responses by passing through an inner
   # middleware stack (heavily inspired by Rack).
   #
-  #   Faraday::Connection.new(:url => 'http://sushi.com') do |builder|
+  # @example
+  #   Faraday::Connection.new(url: 'http://httpbingo.org') do |builder|
   #     builder.request  :url_encoded  # Faraday::Request::UrlEncoded
   #     builder.adapter  :net_http     # Faraday::Adapter::NetHttp
   #   end
   class RackBuilder
+    # Used to detect missing arguments
+    NO_ARGUMENT = Object.new
+
     attr_accessor :handlers
 
     # Error raised when trying to modify the stack after calling `lock!`
@@ -15,28 +24,28 @@ module Faraday
     # borrowed from ActiveSupport::Dependencies::Reference &
     # ActionDispatch::MiddlewareStack::Middleware
     class Handler
-      @@constants_mutex = Mutex.new
-      @@constants = Hash.new { |h, k|
-        value = k.respond_to?(:constantize) ? k.constantize : Object.const_get(k)
-        @@constants_mutex.synchronize { h[k] = value }
-      }
+      REGISTRY = Faraday::AdapterRegistry.new
 
       attr_reader :name
 
-      def initialize(klass, *args, &block)
+      ruby2_keywords def initialize(klass, *args, &block)
         @name = klass.to_s
-        if klass.respond_to?(:name)
-          @@constants_mutex.synchronize { @@constants[@name] = klass }
-        end
-        @args, @block = args, block
+        REGISTRY.set(klass) if klass.respond_to?(:name)
+        @args = args
+        @block = block
       end
 
-      def klass() @@constants[@name] end
-      def inspect() @name end
+      def klass
+        REGISTRY.get(@name)
+      end
+
+      def inspect
+        @name
+      end
 
       def ==(other)
         if other.is_a? Handler
-          self.name == other.name
+          name == other.name
         elsif other.respond_to? :name
           klass == other
         else
@@ -44,33 +53,34 @@ module Faraday
         end
       end
 
-      def build(app)
+      def build(app = nil)
         klass.new(app, *@args, &@block)
       end
     end
 
-    def initialize(handlers = [])
-      @handlers = handlers
-      if block_given?
-        build(&Proc.new)
-      elsif @handlers.empty?
-        # default stack, if nothing else is configured
-        self.request :url_encoded
-        self.adapter Faraday.default_adapter
-      end
+    def initialize(&block)
+      @adapter = nil
+      @handlers = []
+      build(&block)
     end
 
-    def build(options = {})
+    def initialize_dup(original)
+      super
+      @adapter = original.adapter
+      @handlers = original.handlers.dup
+    end
+
+    def build
       raise_if_locked
-      @handlers.clear unless options[:keep]
-      yield(self) if block_given?
+      block_given? ? yield(self) : request(:url_encoded)
+      adapter(Faraday.default_adapter, **Faraday.default_adapter_options) unless @adapter
     end
 
     def [](idx)
       @handlers[idx]
     end
 
-    # Locks the middleware stack to ensure no further modifications are possible.
+    # Locks the middleware stack to ensure no further modifications are made.
     def lock!
       @handlers.freeze
     end
@@ -79,46 +89,48 @@ module Faraday
       @handlers.frozen?
     end
 
-    def use(klass, *args, &block)
+    ruby2_keywords def use(klass, *args, &block)
       if klass.is_a? Symbol
         use_symbol(Faraday::Middleware, klass, *args, &block)
       else
         raise_if_locked
-        warn_middleware_after_adapter if adapter_set?
+        raise_if_adapter(klass)
         @handlers << self.class::Handler.new(klass, *args, &block)
       end
     end
 
-    def request(key, *args, &block)
+    ruby2_keywords def request(key, *args, &block)
       use_symbol(Faraday::Request, key, *args, &block)
     end
 
-    def response(key, *args, &block)
+    ruby2_keywords def response(key, *args, &block)
       use_symbol(Faraday::Response, key, *args, &block)
     end
 
-    def adapter(key, *args, &block)
-      use_symbol(Faraday::Adapter, key, *args, &block)
+    ruby2_keywords def adapter(klass = NO_ARGUMENT, *args, &block)
+      return @adapter if klass == NO_ARGUMENT || klass.nil?
+
+      klass = Faraday::Adapter.lookup_middleware(klass) if klass.is_a?(Symbol)
+      @adapter = self.class::Handler.new(klass, *args, &block)
     end
 
     ## methods to push onto the various positions in the stack:
 
-    def insert(index, *args, &block)
+    ruby2_keywords def insert(index, *args, &block)
       raise_if_locked
       index = assert_index(index)
-      warn_middleware_after_adapter if inserting_after_adapter?(index)
       handler = self.class::Handler.new(*args, &block)
       @handlers.insert(index, handler)
     end
 
-    alias_method :insert_before, :insert
+    alias insert_before insert
 
-    def insert_after(index, *args, &block)
+    ruby2_keywords def insert_after(index, *args, &block)
       index = assert_index(index)
       insert(index + 1, *args, &block)
     end
 
-    def swap(index, *args, &block)
+    ruby2_keywords def swap(index, *args, &block)
       raise_if_locked
       index = assert_index(index)
       @handlers.delete_at(index)
@@ -133,13 +145,11 @@ module Faraday
     # Processes a Request into a Response by passing it through this Builder's
     # middleware stack.
     #
-    # connection - Faraday::Connection
-    # request    - Faraday::Request
+    # @param connection [Faraday::Connection]
+    # @param request [Faraday::Request]
     #
-    # Returns a Faraday::Response.
+    # @return [Faraday::Response]
     def build_response(connection, request)
-      warn 'WARNING: No adapter was configured for this request' unless adapter_set?
-
       app.call(build_env(connection, request))
     end
 
@@ -153,30 +163,27 @@ module Faraday
     def app
       @app ||= begin
         lock!
-        to_app(lambda { |env|
-          response = Response.new
-          env.response = response
-          response.finish(env) unless env.parallel?
-          response
-        })
+        ensure_adapter!
+        to_app
       end
     end
 
-    def to_app(inner_app)
+    def to_app
       # last added handler is the deepest and thus closest to the inner app
-      @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
+      # adapter is always the last one
+      @handlers.reverse.inject(@adapter.build) do |app, handler|
+        handler.build(app)
+      end
     end
 
     def ==(other)
-      other.is_a?(self.class) && @handlers == other.handlers
-    end
-
-    def dup
-      self.class.new(@handlers.dup)
+      other.is_a?(self.class) &&
+        @handlers == other.handlers &&
+        @adapter == other.adapter
     end
 
     # ENV Keys
-    # :method - a symbolized request method (:get, :post)
+    # :http_method - a symbolized request HTTP method (:get, :post)
     # :body   - the request body that will eventually be converted to a string.
     # :url    - URI instance for the current request.
     # :status           - HTTP response status code
@@ -192,45 +199,53 @@ module Faraday
     #     :password   - Proxy server password
     # :ssl - Hash of options for configuring SSL requests.
     def build_env(connection, request)
-      Env.new(request.method, request.body,
-        connection.build_exclusive_url(request.path, request.params, request.options.params_encoder),
-        request.options, request.headers, connection.ssl,
-        connection.parallel_manager)
+      exclusive_url = connection.build_exclusive_url(
+        request.path, request.params,
+        request.options.params_encoder
+      )
+
+      Env.new(request.http_method, request.body, exclusive_url,
+              request.options, request.headers, connection.ssl,
+              connection.parallel_manager)
     end
 
     private
 
+    LOCK_ERR = "can't modify middleware stack after making a request"
+    MISSING_ADAPTER_ERROR = "An attempt to run a request with a Faraday::Connection without adapter has been made.\n" \
+                            "Please set Faraday.default_adapter or provide one when initializing the connection.\n" \
+                            'For more info, check https://lostisland.github.io/faraday/usage/.'
+
     def raise_if_locked
-      raise StackLocked, "can't modify middleware stack after making a request" if locked?
+      raise StackLocked, LOCK_ERR if locked?
     end
 
-    def warn_middleware_after_adapter
-      warn "WARNING: Unexpected middleware set after the adapter. " \
-        "This won't be supported from Faraday 1.0."
-    end
+    def raise_if_adapter(klass)
+      return unless is_adapter?(klass)
 
-    def adapter_set?
-      @handlers.any? { |handler| is_adapter?(handler) }
+      raise 'Adapter should be set using the `adapter` method, not `use`'
     end
 
-    def inserting_after_adapter?(index)
-      adapter_index = @handlers.find_index { |handler| is_adapter?(handler) }
-      return false if adapter_index.nil?
+    def ensure_adapter!
+      raise MISSING_ADAPTER_ERROR unless @adapter
+    end
 
-      index > adapter_index
+    def adapter_set?
+      !@adapter.nil?
     end
 
-    def is_adapter?(handler)
-      handler.klass.ancestors.include? Faraday::Adapter
+    def is_adapter?(klass) # rubocop:disable Naming/PredicateName
+      klass <= Faraday::Adapter
     end
 
-    def use_symbol(mod, key, *args, &block)
+    ruby2_keywords def use_symbol(mod, key, *args, &block)
       use(mod.lookup_middleware(key), *args, &block)
     end
 
     def assert_index(index)
       idx = index.is_a?(Integer) ? index : @handlers.index(index)
       raise "No such handler: #{index.inspect}" unless idx
+
       idx
     end
   end

data/lib/faraday/request/authorization.rb

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

data/lib/faraday/request/instrumentation.rb

@@ -1,36 +1,56 @@
+# frozen_string_literal: true
+
 module Faraday
-  class Request::Instrumentation < Faraday::Middleware
-    class Options < Faraday::Options.new(:name, :instrumenter)
-      def name
-        self[:name] ||= 'request.faraday'
-      end
+  class Request
+    # Middleware for instrumenting Requests.
+    class Instrumentation < Faraday::Middleware
+      # Options class used in Request::Instrumentation class.
+      class Options < Faraday::Options.new(:name, :instrumenter)
+        # @return [String]
+        def name
+          self[:name] ||= 'request.faraday'
+        end
 
-      def instrumenter
-        self[:instrumenter] ||= ActiveSupport::Notifications
+        # @return [Class]
+        def instrumenter
+          self[:instrumenter] ||= ActiveSupport::Notifications
+        end
       end
-    end
 
-    # Public: Instruments requests using Active Support.
-    #
-    # Measures time spent only for synchronous requests.
-    #
-    # Examples
-    #
-    #   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]
-    #   end
-    def initialize(app, options = nil)
-      super(app)
-      @name, @instrumenter = Options.from(options).values_at(:name, :instrumenter)
-    end
+      # Instruments requests using Active Support.
+      #
+      # Measures time spent only for synchronous requests.
+      #
+      # @example Using ActiveSupport::Notifications to measure time spent
+      #   for Faraday requests.
+      #   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]
+      #   end
+      # @param app [#call]
+      # @param options [nil, Hash] Options hash
+      # @option options [String] :name ('request.faraday')
+      #   Name of the instrumenter
+      # @option options [Class] :instrumenter (ActiveSupport::Notifications)
+      #   Active Support instrumenter class.
+      def initialize(app, options = nil)
+        super(app)
+        @name, @instrumenter = Options.from(options)
+                                      .values_at(:name, :instrumenter)
+      end
 
-    def call(env)
-      @instrumenter.instrument(@name, env) do
-        @app.call(env)
+      # @param env [Faraday::Env]
+      def call(env)
+        @instrumenter.instrument(@name, env) do
+          @app.call(env)
+        end
       end
     end
   end
 end
+
+Faraday::Request.register_middleware(instrumentation: Faraday::Request::Instrumentation)

data/lib/faraday/request/json.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Request
+    # Request middleware that encodes the body as JSON.
+    #
+    # Processes only requests with matching Content-type or those without a type.
+    # If a request doesn't have a type but has a body, it sets the Content-type
+    # to JSON MIME-type.
+    #
+    # Doesn't try to encode bodies that already are in string form.
+    class Json < Middleware
+      MIME_TYPE = 'application/json'
+      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+
+      def on_request(env)
+        match_content_type(env) do |data|
+          env[:body] = encode(data)
+        end
+      end
+
+      private
+
+      def encode(data)
+        ::JSON.generate(data)
+      end
+
+      def match_content_type(env)
+        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)
+        body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
+      end
+
+      def body?(env)
+        (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+      end
+
+      def request_type(env)
+        type = env[:request_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware(json: Faraday::Request::Json)

data/lib/faraday/request/url_encoded.rb

@@ -1,36 +1,58 @@
+# frozen_string_literal: true
+
 module Faraday
-  class Request::UrlEncoded < Faraday::Middleware
-    CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
+  class Request
+    # Middleware for supporting urlencoded requests.
+    class UrlEncoded < Faraday::Middleware
+      unless defined?(::Faraday::Request::UrlEncoded::CONTENT_TYPE)
+        CONTENT_TYPE = 'Content-Type'
+      end
 
-    class << self
-      attr_accessor :mime_type
-    end
-    self.mime_type = 'application/x-www-form-urlencoded'.freeze
+      class << self
+        attr_accessor :mime_type
+      end
+      self.mime_type = 'application/x-www-form-urlencoded'
 
-    def call(env)
-      match_content_type(env) do |data|
-        params = Faraday::Utils::ParamsHash[data]
-        env.body = params.to_query(env.params_encoder)
+      # Encodes as "application/x-www-form-urlencoded" if not already encoded or
+      # of another type.
+      #
+      # @param env [Faraday::Env]
+      def call(env)
+        match_content_type(env) do |data|
+          params = Faraday::Utils::ParamsHash[data]
+          env.body = params.to_query(env.params_encoder)
+        end
+        @app.call env
       end
-      @app.call env
-    end
 
-    def match_content_type(env)
-      if process_request?(env)
+      # @param env [Faraday::Env]
+      # @yield [request_body] Body of the request
+      def match_content_type(env)
+        return unless process_request?(env)
+
         env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
         yield(env.body) unless env.body.respond_to?(:to_str)
       end
-    end
 
-    def process_request?(env)
-      type = request_type(env)
-      env.body and (type.empty? or type == self.class.mime_type)
-    end
+      # @param env [Faraday::Env]
+      #
+      # @return [Boolean] True if the request has a body and its Content-Type is
+      #                   urlencoded.
+      def process_request?(env)
+        type = request_type(env)
+        env.body && (type.empty? || (type == self.class.mime_type))
+      end
 
-    def request_type(env)
-      type = env.request_headers[CONTENT_TYPE].to_s
-      type = type.split(';', 2).first if type.index(';')
-      type
+      # @param env [Faraday::Env]
+      #
+      # @return [String]
+      def request_type(env)
+        type = env.request_headers[CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
     end
   end
 end
+
+Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)