faraday 0.16.0 → 0.17.0

data/lib/faraday/rack_builder.rb

@@ -1,20 +1,12 @@
-# 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).
   #
-  # @example
-  #   Faraday::Connection.new(url: 'http://sushi.com') do |builder|
+  #   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!`
@@ -23,28 +15,28 @@ module Faraday
     # borrowed from ActiveSupport::Dependencies::Reference &
     # ActionDispatch::MiddlewareStack::Middleware
     class Handler
-      REGISTRY = Faraday::AdapterRegistry.new
+      @@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 }
+      }
 
       attr_reader :name
 
       def initialize(klass, *args, &block)
         @name = klass.to_s
-        REGISTRY.set(klass) if klass.respond_to?(:name)
-        @args = args
-        @block = block
-      end
-
-      def klass
-        REGISTRY.get(@name)
+        if klass.respond_to?(:name)
+          @@constants_mutex.synchronize { @@constants[@name] = klass }
+        end
+        @args, @block = args, block
       end
 
-      def inspect
-        @name
-      end
+      def klass() @@constants[@name] end
+      def inspect() @name end
 
       def ==(other)
         if other.is_a? Handler
-          name == other.name
+          self.name == other.name
         elsif other.respond_to? :name
           klass == other
         else
@@ -52,19 +44,18 @@ module Faraday
         end
       end
 
-      def build(app = nil)
+      def build(app)
         klass.new(app, *@args, &@block)
       end
     end
 
-    def initialize(handlers = [], adapter = nil, &block)
-      @adapter = adapter
+    def initialize(handlers = [])
       @handlers = handlers
       if block_given?
-        build(&block)
+        build(&Proc.new)
       elsif @handlers.empty?
         # default stack, if nothing else is configured
-        request :url_encoded
+        self.request :url_encoded
         self.adapter Faraday.default_adapter
       end
     end
@@ -73,14 +64,13 @@ 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 made.
+    # Locks the middleware stack to ensure no further modifications are possible.
     def lock!
       @handlers.freeze
     end
@@ -94,7 +84,7 @@ module Faraday
         use_symbol(Faraday::Middleware, klass, *args, &block)
       else
         raise_if_locked
-        raise_if_adapter(klass)
+        warn_middleware_after_adapter if adapter_set?
         @handlers << self.class::Handler.new(klass, *args, &block)
       end
     end
@@ -107,11 +97,8 @@ module Faraday
       use_symbol(Faraday::Response, key, *args, &block)
     end
 
-    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)
+    def adapter(key, *args, &block)
+      use_symbol(Faraday::Adapter, key, *args, &block)
     end
 
     ## methods to push onto the various positions in the stack:
@@ -119,11 +106,12 @@ 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 insert_before insert
+    alias_method :insert_before, :insert
 
     def insert_after(index, *args, &block)
       index = assert_index(index)
@@ -145,11 +133,13 @@ module Faraday
     # Processes a Request into a Response by passing it through this Builder's
     # middleware stack.
     #
-    # @param connection [Faraday::Connection]
-    # @param request [Faraday::Request]
+    # connection - Faraday::Connection
+    # request    - Faraday::Request
     #
-    # @return [Faraday::Response]
+    # Returns a 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
 
@@ -163,26 +153,26 @@ module Faraday
     def app
       @app ||= begin
         lock!
-        to_app
+        to_app(lambda { |env|
+          response = Response.new
+          env.response = response
+          response.finish(env) unless env.parallel?
+          response
+        })
       end
     end
 
-    def to_app
+    def to_app(inner_app)
       # last added handler is the deepest and thus closest to the inner app
-      # adapter is always the last one
-      @handlers.reverse.inject(@adapter.build) do |app, handler|
-        handler.build(app)
-      end
+      @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
     end
 
     def ==(other)
-      other.is_a?(self.class) &&
-        @handlers == other.handlers &&
-        @adapter == other.adapter
+      other.is_a?(self.class) && @handlers == other.handlers
     end
 
     def dup
-      self.class.new(@handlers.dup, @adapter.dup)
+      self.class.new(@handlers.dup)
     end
 
     # ENV Keys
@@ -202,36 +192,36 @@ module Faraday
     #     :password   - Proxy server password
     # :ssl - Hash of options for configuring SSL requests.
     def build_env(connection, request)
-      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)
+      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)
     end
 
     private
 
-    LOCK_ERR = "can't modify middleware stack after making a request"
-
     def raise_if_locked
-      raise StackLocked, LOCK_ERR if locked?
+      raise StackLocked, "can't modify middleware stack after making a request" if locked?
     end
 
-    def raise_if_adapter(klass)
-      return unless is_adapter?(klass)
-
-      raise 'Adapter should be set using the `adapter` method, not `use`'
+    def warn_middleware_after_adapter
+      warn "WARNING: Unexpected middleware set after the adapter. " \
+        "This won't be supported from Faraday 1.0."
     end
 
     def adapter_set?
-      !@adapter.nil?
+      @handlers.any? { |handler| is_adapter?(handler) }
     end
 
-    def is_adapter?(klass) # rubocop:disable Naming/PredicateName
-      klass.ancestors.include?(Faraday::Adapter)
+    def inserting_after_adapter?(index)
+      adapter_index = @handlers.find_index { |handler| is_adapter?(handler) }
+      return false if adapter_index.nil?
+
+      index > adapter_index
+    end
+
+    def is_adapter?(handler)
+      handler.klass.ancestors.include? Faraday::Adapter
     end
 
     def use_symbol(mod, key, *args, &block)
@@ -241,7 +231,6 @@ 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/authorization.rb

@@ -1,53 +1,41 @@
-# frozen_string_literal: true
-
 module Faraday
-  class Request
-    # Request middleware for the Authorization HTTP header
-    class Authorization < Faraday::Middleware
-      KEY = 'Authorization' unless defined? KEY
+  class Request::Authorization < Faraday::Middleware
+    KEY = "Authorization".freeze unless defined? KEY
 
-      # @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
+    # 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}"
       end
+    end
 
-      # @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}"
+    # Internal
+    def self.build_hash(type, hash)
+      comma = ", "
+      values = []
+      hash.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
       end
+      "#{type} #{values * comma}"
+    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
+    def initialize(app, type, token)
+      @header_value = self.class.header(type, token)
+      super(app)
+    end
 
-      # @param env [Faraday::Env]
-      def call(env)
-        env.request_headers[KEY] = @header_value unless env.request_headers[KEY]
-        @app.call(env)
+    # Public
+    def call(env)
+      unless env.request_headers[KEY]
+        env.request_headers[KEY] = @header_value
       end
+      @app.call(env)
     end
   end
 end
+

data/lib/faraday/request/basic_authentication.rb

@@ -1,20 +1,13 @@
-# frozen_string_literal: true
-
 require 'base64'
 
 module Faraday
-  class Request
-    # Authorization middleware for Basic Authentication.
-    class BasicAuthentication < load_middleware(:authorization)
-      # @param login [String]
-      # @param pass [String]
-      #
-      # @return [String] a Basic Authentication header line
-      def self.header(login, pass)
-        value = Base64.encode64([login, pass].join(':'))
-        value.delete!("\n")
-        super(:Basic, value)
-      end
+  class Request::BasicAuthentication < Request.load_middleware(:authorization)
+    # Public
+    def self.header(login, pass)
+      value = Base64.encode64([login, pass].join(':'))
+      value.gsub!("\n", '')
+      super(:Basic, value)
     end
   end
 end
+

data/lib/faraday/request/instrumentation.rb

@@ -1,53 +1,35 @@
-# frozen_string_literal: true
-
 module Faraday
-  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
-
-        # @return [Class]
-        def instrumenter
-          self[:instrumenter] ||= ActiveSupport::Notifications
-        end
+  class Request::Instrumentation < Faraday::Middleware
+    class Options < Faraday::Options.new(:name, :instrumenter)
+      def name
+        self[:name] ||= 'request.faraday'
       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)
+      def instrumenter
+        self[:instrumenter] ||= ActiveSupport::Notifications
       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
 
-      # @param env [Faraday::Env]
-      def call(env)
-        @instrumenter.instrument(@name, env) do
-          @app.call(env)
-        end
+    def call(env)
+      @instrumenter.instrument(@name, env) do
+        @app.call(env)
       end
     end
   end

data/lib/faraday/request/multipart.rb

@@ -1,97 +1,66 @@
-# frozen_string_literal: true
-
-require File.expand_path('url_encoded', __dir__)
+require File.expand_path("../url_encoded", __FILE__)
 require 'securerandom'
 
 module Faraday
-  class Request
-    # Middleware for supporting multi-part requests.
-    class Multipart < UrlEncoded
-      self.mime_type = 'multipart/form-data'
-      unless defined? DEFAULT_BOUNDARY_PREFIX
-        DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
-      end
+  class Request::Multipart < Request::UrlEncoded
+    self.mime_type = 'multipart/form-data'.freeze
+    DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
 
-      # Checks for files in the payload, otherwise leaves everything untouched.
-      #
-      # @param env [Faraday::Env]
-      def call(env)
-        match_content_type(env) do |params|
-          env.request.boundary ||= unique_boundary
-          env.request_headers[CONTENT_TYPE] +=
-            "; boundary=#{env.request.boundary}"
-          env.body = create_multipart(env, params)
-        end
-        @app.call env
+    def call(env)
+      match_content_type(env) do |params|
+        env.request.boundary ||= unique_boundary
+        env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
+        env.body = create_multipart(env, params)
       end
+      @app.call env
+    end
 
-      # @param env [Faraday::Env]
-      def process_request?(env)
-        type = request_type(env)
-        env.body.respond_to?(:each_key) && !env.body.empty? && (
-          (type.empty? && has_multipart?(env.body)) ||
-          (type == self.class.mime_type)
-        )
-      end
+    def process_request?(env)
+      type = request_type(env)
+      env.body.respond_to?(:each_key) and !env.body.empty? and (
+        (type.empty? and has_multipart?(env.body)) or
+        type == self.class.mime_type
+      )
+    end
 
-      # Returns true if obj is an enumerable with values that are multipart.
-      #
-      # @param obj [Object]
-      # @return [Boolean]
-      def has_multipart?(obj) # rubocop:disable Naming/PredicateName
-        if obj.respond_to?(:each)
-          (obj.respond_to?(:values) ? obj.values : obj).each do |val|
-            return true if val.respond_to?(:content_type) || has_multipart?(val)
-          end
+    def has_multipart?(obj)
+      # string is an enum in 1.8, returning list of itself
+      if obj.respond_to?(:each) && !obj.is_a?(String)
+        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+          return true if (val.respond_to?(:content_type) || has_multipart?(val))
         end
-        false
       end
+      false
+    end
 
-      # @param env [Faraday::Env]
-      # @param params [Hash]
-      def create_multipart(env, params)
-        boundary = env.request.boundary
-        parts = process_params(params) do |key, value|
-          part(boundary, key, value)
-        end
-        parts << Faraday::Parts::EpiloguePart.new(boundary)
-
-        body = Faraday::CompositeReadIO.new(parts)
-        env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
-        body
+    def create_multipart(env, params)
+      boundary = env.request.boundary
+      parts = process_params(params) do |key, value|
+        Faraday::Parts::Part.new(boundary, key, value)
       end
+      parts << Faraday::Parts::EpiloguePart.new(boundary)
 
-      def part(boundary, key, value)
-        if value.respond_to?(:to_part)
-          value.to_part(boundary, key)
-        else
-          Faraday::Parts::Part.new(boundary, key, value)
-        end
-      end
+      body = Faraday::CompositeReadIO.new(parts)
+      env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
+      return body
+    end
 
-      # @return [String]
-      def unique_boundary
-        "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
-      end
+    def unique_boundary
+      "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
+    end
 
-      # @param params [Hash]
-      # @param prefix [String]
-      # @param pieces [Array]
-      def process_params(params, prefix = nil, pieces = nil, &block)
-        params.inject(pieces || []) do |all, (key, value)|
-          key = "#{prefix}[#{key}]" if prefix
+    def process_params(params, prefix = nil, pieces = nil, &block)
+      params.inject(pieces || []) do |all, (key, value)|
+        key = "#{prefix}[#{key}]" if prefix
 
-          case value
-          when Array
-            values = value.inject([]) { |a, v| a << [nil, v] }
-            process_params(values, key, all, &block)
-          when Hash
-            process_params(value, key, all, &block)
-          else
-            # rubocop:disable Performance/RedundantBlockCall
-            all << block.call(key, value)
-            # rubocop:enable Performance/RedundantBlockCall
-          end
+        case value
+        when Array
+          values = value.inject([]) { |a,v| a << [nil, v] }
+          process_params(values, key, all, &block)
+        when Hash
+          process_params(value, key, all, &block)
+        else
+          all << block.call(key, value)
         end
       end
     end