faraday 1.0.0 → 2.0.0

data/lib/faraday/rack_builder.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'ruby2_keywords'
 require 'faraday/adapter_registry'
 
 module Faraday
@@ -27,7 +28,7 @@ module Faraday
 
       attr_reader :name
 
-      def initialize(klass, *args, &block)
+      ruby2_keywords def initialize(klass, *args, &block)
         @name = klass.to_s
         REGISTRY.set(klass) if klass.respond_to?(:name)
         @args = args
@@ -57,22 +58,21 @@ module Faraday
       end
     end
 
-    def initialize(handlers = [], adapter = nil, &block)
-      @adapter = adapter
-      @handlers = handlers
-      if block_given?
-        build(&block)
-      elsif @handlers.empty?
-        # default stack, if nothing else is configured
-        request :url_encoded
-        self.adapter Faraday.default_adapter
-      end
+    def initialize(&block)
+      @adapter = nil
+      @handlers = []
+      build(&block)
+    end
+
+    def initialize_dup(original)
+      super
+      @adapter = original.adapter
+      @handlers = original.handlers.dup
     end
 
-    def build(options = {})
+    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) unless @adapter
     end
 
@@ -89,7 +89,7 @@ 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
@@ -99,16 +99,16 @@ module Faraday
       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(klass = NO_ARGUMENT, *args, &block)
-      return @adapter if klass == NO_ARGUMENT
+    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)
@@ -116,7 +116,7 @@ module Faraday
 
     ## 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)
       handler = self.class::Handler.new(*args, &block)
@@ -125,12 +125,12 @@ module Faraday
 
     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)
@@ -163,6 +163,7 @@ module Faraday
     def app
       @app ||= begin
         lock!
+        ensure_adapter!
         to_app
       end
     end
@@ -181,12 +182,8 @@ module Faraday
         @adapter == other.adapter
     end
 
-    def dup
-      self.class.new(@handlers.dup, @adapter.dup)
-    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
@@ -207,7 +204,7 @@ module Faraday
         request.options.params_encoder
       )
 
-      Env.new(request.method, request.body, exclusive_url,
+      Env.new(request.http_method, request.body, exclusive_url,
               request.options, request.headers, connection.ssl,
               connection.parallel_manager)
     end
@@ -215,6 +212,9 @@ module Faraday
     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, LOCK_ERR if locked?
@@ -226,15 +226,19 @@ module Faraday
       raise 'Adapter should be set using the `adapter` method, not `use`'
     end
 
+    def ensure_adapter!
+      raise MISSING_ADAPTER_ERROR unless @adapter
+    end
+
     def adapter_set?
       !@adapter.nil?
     end
 
     def is_adapter?(klass) # rubocop:disable Naming/PredicateName
-      klass.ancestors.include?(Faraday::Adapter)
+      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
 

data/lib/faraday/request/authorization.rb

@@ -4,50 +4,46 @@ module Faraday
   class Request
     # Request middleware for the Authorization HTTP header
     class Authorization < Faraday::Middleware
-      KEY = 'Authorization' 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
-      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}"
-      end
+      KEY = 'Authorization'
 
       # @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 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
 
       # @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] = header_from(@type, *@params)
+      end
+
+      private
+
+      # @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
     end
   end
 end
+
+Faraday::Request.register_middleware(authorization: Faraday::Request::Authorization)

data/lib/faraday/request/instrumentation.rb

@@ -52,3 +52,5 @@ module Faraday
     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

@@ -4,7 +4,9 @@ module Faraday
   class Request
     # Middleware for supporting urlencoded requests.
     class UrlEncoded < Faraday::Middleware
-      CONTENT_TYPE = 'Content-Type' unless defined? CONTENT_TYPE
+      unless defined?(::Faraday::Request::UrlEncoded::CONTENT_TYPE)
+        CONTENT_TYPE = 'Content-Type'
+      end
 
       class << self
         attr_accessor :mime_type
@@ -52,3 +54,5 @@ module Faraday
     end
   end
 end
+
+Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)

data/lib/faraday/request.rb

@@ -12,7 +12,7 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
-  # @!attribute method
+  # @!attribute http_method
   #   @return [Symbol] the HTTP method of the Request
   # @!attribute path
   #   @return [URI, String] the path
@@ -26,26 +26,11 @@ module Faraday
   #   @return [RequestOptions] options
   #
   # rubocop:disable Style/StructInheritance
-  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
+  class Request < Struct.new(:http_method, :path, :params, :headers, :body, :options)
     # rubocop:enable Style/StructInheritance
 
     extend MiddlewareRegistry
 
-    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]
@@ -116,7 +101,7 @@ module Faraday
     # @return [Hash] the hash ready to be serialized in Marshal.
     def marshal_dump
       {
-        method: method,
+        http_method: http_method,
         body: body,
         headers: headers,
         path: path,
@@ -129,18 +114,23 @@ module Faraday
     # 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]
+      self.http_method = serialised[:http_method]
+      self.body = serialised[:body]
       self.headers = serialised[:headers]
-      self.path    = serialised[:path]
-      self.params  = serialised[:params]
+      self.path = serialised[:path]
+      self.params = serialised[:params]
       self.options = serialised[:options]
     end
 
     # @return [Env] the Env for this Request
     def to_env(connection)
-      Env.new(method, body, connection.build_exclusive_url(path, params),
+      Env.new(http_method, body, connection.build_exclusive_url(path, params),
               options, headers, connection.ssl, connection.parallel_manager)
     end
   end
 end
+
+require 'faraday/request/authorization'
+require 'faraday/request/instrumentation'
+require 'faraday/request/json'
+require 'faraday/request/url_encoded'

data/lib/faraday/response/json.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Response
+    # Parse response bodies as JSON.
+    class Json < Middleware
+      def initialize(app = nil, parser_options: nil, content_type: /\bjson$/, preserve_raw: false)
+        super(app)
+        @parser_options = parser_options
+        @content_types = Array(content_type)
+        @preserve_raw = preserve_raw
+      end
+
+      def on_complete(env)
+        process_response(env) if parse_response?(env)
+      end
+
+      private
+
+      def process_response(env)
+        env[:raw_body] = env[:body] if @preserve_raw
+        env[:body] = parse(env[:body])
+      rescue StandardError, SyntaxError => e
+        raise Faraday::ParsingError.new(e, env[:response])
+      end
+
+      def parse(body)
+        ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+      end
+
+      def parse_response?(env)
+        process_response_type?(env) &&
+          env[:body].respond_to?(:to_str)
+      end
+
+      def process_response_type?(env)
+        type = response_type(env)
+        @content_types.empty? || @content_types.any? do |pattern|
+          pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
+        end
+      end
+
+      def response_type(env)
+        type = env[:response_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Faraday::Response::Json)

data/lib/faraday/response/logger.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'logger'
 require 'faraday/logging/formatter'
 
 module Faraday
@@ -11,10 +12,7 @@ module Faraday
     class Logger < Middleware
       def initialize(app, logger = nil, options = {})
         super(app)
-        logger ||= begin
-          require 'logger'
-          ::Logger.new($stdout)
-        end
+        logger ||= ::Logger.new($stdout)
         formatter_class = options.delete(:formatter) || Logging::Formatter
         @formatter = formatter_class.new(logger: logger, options: options)
         yield @formatter if block_given?
@@ -31,3 +29,5 @@ module Faraday
     end
   end
 end
+
+Faraday::Response.register_middleware(logger: Faraday::Response::Logger)

data/lib/faraday/response/raise_error.rb

@@ -38,8 +38,27 @@ module Faraday
       end
 
       def response_values(env)
-        { status: env.status, headers: env.response_headers, body: env.body }
+        {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body,
+          request: {
+            method: env.method,
+            url: env.url,
+            url_path: env.url.path,
+            params: query_params(env),
+            headers: env.request_headers,
+            body: env.request_body
+          }
+        }
+      end
+
+      def query_params(env)
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env.params_encoder.decode(env.url.query)
       end
     end
   end
 end
+
+Faraday::Response.register_middleware(raise_error: Faraday::Response::RaiseError)

data/lib/faraday/response.rb

@@ -5,28 +5,9 @@ require 'forwardable'
 module Faraday
   # Response represents an HTTP response from making an HTTP request.
   class Response
-    # Used for simple response middleware.
-    class Middleware < Faraday::Middleware
-      def call(env)
-        @app.call(env).on_complete do |environment|
-          on_complete(environment)
-        end
-      end
-
-      # Override this to modify the environment after the response has finished.
-      # Calls the `parse` method if defined
-      def on_complete(env)
-        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
-      end
-    end
-
     extend Forwardable
     extend MiddlewareRegistry
 
-    register_middleware File.expand_path('response', __dir__),
-                        raise_error: [:RaiseError, 'raise_error'],
-                        logger: [:Logger, 'logger']
-
     def initialize(env = nil)
       @env = Env.from(env) if env
       @on_complete_callbacks = []
@@ -45,6 +26,7 @@ module Faraday
     def headers
       finished? ? env.response_headers : {}
     end
+
     def_delegator :headers, :[]
 
     def body
@@ -56,10 +38,10 @@ module Faraday
     end
 
     def on_complete(&block)
-      if !finished?
-        @on_complete_callbacks << block
-      else
+      if finished?
         yield(env)
+      else
+        @on_complete_callbacks << block
       end
       self
     end
@@ -102,3 +84,7 @@ module Faraday
     end
   end
 end
+
+require 'faraday/response/json'
+require 'faraday/response/logger'
+require 'faraday/response/raise_error'

data/lib/faraday/utils/headers.rb

@@ -105,16 +105,16 @@ module Faraday
       end
 
       def to_hash
-        ::Hash.new.update(self)
+        {}.update(self)
       end
 
       def parse(header_string)
         return unless header_string && !header_string.empty?
 
-        headers = header_string.split(/\r\n/)
+        headers = header_string.split("\r\n")
 
         # Find the last set of response headers.
-        start_index = headers.rindex { |x| x.match(%r{^HTTP/}) } || 0
+        start_index = headers.rindex { |x| x.start_with?('HTTP/') } || 0
         last_response = headers.slice(start_index, headers.size)
 
         last_response

data/lib/faraday/utils.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'base64'
+require 'uri'
 require 'faraday/utils/headers'
 require 'faraday/utils/params_hash'
 
@@ -16,12 +18,20 @@ module Faraday
       NestedParamsEncoder.encode(params)
     end
 
+    def default_space_encoding
+      @default_space_encoding ||= '+'
+    end
+
+    class << self
+      attr_writer :default_space_encoding
+    end
+
     ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
 
     def escape(str)
       str.to_s.gsub(ESCAPE_RE) do |match|
-        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
-      end.tr(' ', '+')
+        "%#{match.unpack('H2' * match.bytesize).join('%').upcase}"
+      end.gsub(' ', default_space_encoding)
     end
 
     def unescape(str)
@@ -43,6 +53,12 @@ module Faraday
       @default_params_encoder ||= NestedParamsEncoder
     end
 
+    def basic_header_from(login, pass)
+      value = Base64.encode64("#{login}:#{pass}")
+      value.delete!("\n")
+      "Basic #{value}"
+    end
+
     class << self
       attr_writer :default_params_encoder
     end
@@ -63,10 +79,7 @@ module Faraday
     end
 
     def default_uri_parser
-      @default_uri_parser ||= begin
-        require 'uri'
-        Kernel.method(:URI)
-      end
+      @default_uri_parser ||= Kernel.method(:URI)
     end
 
     def default_uri_parser=(parser)
@@ -81,14 +94,14 @@ module Faraday
     # the path with the query string sorted.
     def normalize_path(url)
       url = URI(url)
-      (url.path.start_with?('/') ? url.path : '/' + url.path) +
+      (url.path.start_with?('/') ? url.path : "/#{url.path}") +
         (url.query ? "?#{sort_query_params(url.query)}" : '')
     end
 
     # Recursive hash update
     def deep_merge!(target, hash)
       hash.each do |key, value|
-        target[key] = if value.is_a?(Hash) && target[key].is_a?(Hash)
+        target[key] = if value.is_a?(Hash) && (target[key].is_a?(Hash) || target[key].is_a?(Options))
                         deep_merge(target[key], value)
                       else
                         value

data/lib/faraday/version.rb

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