faraday 0.15.4 → 0.16.0

data/lib/faraday/rack_builder.rb

@@ -1,12 +1,20 @@
+# frozen_string_literal: true
+
+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://sushi.com') 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 +23,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)
         @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,18 +52,19 @@ module Faraday
         end
       end
 
-      def build(app)
+      def build(app = nil)
         klass.new(app, *@args, &@block)
       end
     end
 
-    def initialize(handlers = [])
+    def initialize(handlers = [], adapter = nil, &block)
+      @adapter = adapter
       @handlers = handlers
       if block_given?
-        build(&Proc.new)
+        build(&block)
       elsif @handlers.empty?
         # default stack, if nothing else is configured
-        self.request :url_encoded
+        request :url_encoded
         self.adapter Faraday.default_adapter
       end
     end
@@ -64,13 +73,14 @@ module Faraday
       raise_if_locked
       @handlers.clear unless options[:keep]
       yield(self) if block_given?
+      adapter(Faraday.default_adapter) 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
@@ -84,7 +94,7 @@ module Faraday
         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
@@ -97,8 +107,11 @@ module Faraday
       use_symbol(Faraday::Response, key, *args, &block)
     end
 
-    def adapter(key, *args, &block)
-      use_symbol(Faraday::Adapter, key, *args, &block)
+    def adapter(klass = NO_ARGUMENT, *args, &block)
+      return @adapter if klass == NO_ARGUMENT
+
+      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:
@@ -106,12 +119,11 @@ module Faraday
     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)
       index = assert_index(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,26 +163,26 @@ module Faraday
     def app
       @app ||= begin
         lock!
-        to_app(lambda { |env|
-          response = Response.new
-          env.response = response
-          response.finish(env) unless env.parallel?
-          response
-        })
+        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
+      other.is_a?(self.class) &&
+        @handlers == other.handlers &&
+        @adapter == other.adapter
     end
 
     def dup
-      self.class.new(@handlers.dup)
+      self.class.new(@handlers.dup, @adapter.dup)
     end
 
     # ENV Keys
@@ -192,36 +202,36 @@ 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.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"
+
     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?
-
-      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.ancestors.include?(Faraday::Adapter)
     end
 
     def use_symbol(mod, key, *args, &block)
@@ -231,6 +241,7 @@ module Faraday
     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.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module Faraday
-  # Used to setup urls, params, headers, and the request body in a sane manner.
+  # Used to setup URLs, params, headers, and the request body in a sane manner.
   #
+  # @example
   #   @connection.post do |req|
   #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
   #     req.headers['b'] = '2' # Header
@@ -9,25 +12,53 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
+  # @!attribute method
+  #   @return [Symbol] the HTTP method of the Request
+  # @!attribute path
+  #   @return [URI, String] the path
+  # @!attribute params
+  #   @return [Hash] query parameters
+  # @!attribute headers
+  #   @return [Faraday::Utils::Headers] headers
+  # @!attribute body
+  #   @return [Hash] body
+  # @!attribute options
+  #   @return [RequestOptions] options
+  #
+  # rubocop:disable Style/StructInheritance
   class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
+    # rubocop:enable Style/StructInheritance
+
     extend MiddlewareRegistry
 
-    register_middleware File.expand_path('../request', __FILE__),
-      :url_encoded => [:UrlEncoded, 'url_encoded'],
-      :multipart => [:Multipart, 'multipart'],
-      :retry => [:Retry, 'retry'],
-      :authorization => [:Authorization, 'authorization'],
-      :basic_auth => [:BasicAuthentication, 'basic_authentication'],
-      :token_auth => [:TokenAuthentication, 'token_authentication'],
-      :instrumentation => [:Instrumentation, 'instrumentation']
+    register_middleware File.expand_path('request', __dir__),
+                        url_encoded: [:UrlEncoded, 'url_encoded'],
+                        multipart: [:Multipart, 'multipart'],
+                        retry: [:Retry, 'retry'],
+                        authorization: [:Authorization, 'authorization'],
+                        basic_auth: [
+                          :BasicAuthentication,
+                          'basic_authentication'
+                        ],
+                        token_auth: [
+                          :TokenAuthentication,
+                          'token_authentication'
+                        ],
+                        instrumentation: [:Instrumentation, 'instrumentation']
 
+    # @param request_method [String]
+    # @yield [request] for block customization, if block given
+    # @yieldparam request [Request]
+    # @return [Request]
     def self.create(request_method)
       new(request_method).tap do |request|
         yield(request) if block_given?
       end
     end
 
-    # Public: Replace params, preserving the existing hash type
+    # Replace params, preserving the existing hash type.
+    #
+    # @param hash [Hash] new params
     def params=(hash)
       if params
         params.replace hash
@@ -36,7 +67,9 @@ module Faraday
       end
     end
 
-    # Public: Replace request headers, preserving the existing hash type
+    # Replace request headers, preserving the existing hash type.
+    #
+    # @param hash [Hash] new headers
     def headers=(hash)
       if headers
         headers.replace hash
@@ -45,9 +78,14 @@ module Faraday
       end
     end
 
+    # Update path and params.
+    #
+    # @param path [URI, String]
+    # @param params [Hash, nil]
+    # @return [void]
     def url(path, params = nil)
       if path.respond_to? :query
-        if query = path.query
+        if (query = path.query)
           path = path.dup
           path.query = nil
         end
@@ -61,25 +99,35 @@ module Faraday
       self.params.update(params) if params
     end
 
+    # @param key [Object] key to look up in headers
+    # @return [Object] value of the given header name
     def [](key)
       headers[key]
     end
 
+    # @param key [Object] key of header to write
+    # @param value [Object] value of header
     def []=(key, value)
       headers[key] = value
     end
 
+    # Marshal serialization support.
+    #
+    # @return [Hash] the hash ready to be serialized in Marshal.
     def marshal_dump
       {
-        :method  => method,
-        :body    => body,
-        :headers => headers,
-        :path    => path,
-        :params  => params,
-        :options => options
+        method: method,
+        body: body,
+        headers: headers,
+        path: path,
+        params: params,
+        options: options
       }
     end
 
+    # Marshal serialization support.
+    # Restores the instance variables according to the +serialised+.
+    # @param serialised [Hash] the serialised object.
     def marshal_load(serialised)
       self.method  = serialised[:method]
       self.body    = serialised[:body]
@@ -89,26 +137,10 @@ module Faraday
       self.options = serialised[:options]
     end
 
-    # ENV Keys
-    # :method - a symbolized request 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
-    # :request_headers  - hash of HTTP Headers to be sent to the server
-    # :response_headers - Hash of HTTP headers from the server
-    # :parallel_manager - sent if the connection is in parallel mode
-    # :request - Hash of options for configuring the request.
-    #   :timeout      - open/read timeout Integer in seconds
-    #   :open_timeout - read timeout Integer in seconds
-    #   :proxy        - Hash of proxy options
-    #     :uri        - Proxy Server URI
-    #     :user       - Proxy server username
-    #     :password   - Proxy server password
-    # :ssl - Hash of options for configuring SSL requests.
+    # @return [Env] the Env for this Request
     def to_env(connection)
       Env.new(method, body, connection.build_exclusive_url(path, params),
-        options, headers, connection.ssl, connection.parallel_manager)
+              options, headers, connection.ssl, connection.parallel_manager)
     end
   end
 end
-

data/lib/faraday/request/authorization.rb

@@ -1,41 +1,53 @@
+# 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' unless defined? KEY
 
-    # 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 type [String, Symbol]
+      # @param token [String, Symbol, Hash]
+      # @return [String] a header value
+      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}"
+        end
       end
-    end
 
-    # Internal
-    def self.build_hash(type, hash)
-      comma = ", "
-      values = []
-      hash.each do |key, value|
-        values << "#{key}=#{value.to_s.inspect}"
+      # @param type [String]
+      # @param hash [Hash]
+      # @return [String] type followed by comma-separated key=value pairs
+      # @api private
+      def self.build_hash(type, hash)
+        comma = ', '
+        values = []
+        hash.each do |key, value|
+          values << "#{key}=#{value.to_s.inspect}"
+        end
+        "#{type} #{values * comma}"
       end
-      "#{type} #{values * comma}"
-    end
 
-    def initialize(app, type, token)
-      @header_value = self.class.header(type, token)
-      super(app)
-    end
+      # @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)
+        super(app)
+      end
 
-    # Public
-    def call(env)
-      unless env.request_headers[KEY]
-        env.request_headers[KEY] = @header_value
+      # @param env [Faraday::Env]
+      def call(env)
+        env.request_headers[KEY] = @header_value unless env.request_headers[KEY]
+        @app.call(env)
       end
-      @app.call(env)
     end
   end
 end
-