faraday 0.7.4 → 1.0.1

data/lib/faraday/response.rb

@@ -1,98 +1,107 @@
+# frozen_string_literal: true
+
 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 |env|
-          on_complete(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
+      # `parse` method can be defined as private, public and protected
       def on_complete(env)
-        if respond_to? :parse
-          env[:body] = parse(env[:body]) unless [204,304].index env[:status]
-        end
+        return unless respond_to?(:parse, true) && env.parse_body?
+
+        env.body = parse(env.body)
       end
     end
 
     extend Forwardable
-    extend AutoloadHelper
+    extend MiddlewareRegistry
 
-    autoload_all 'faraday/response',
-      :RaiseError => 'raise_error',
-      :Logger     => 'logger'
-
-    register_lookup_modules \
-      :raise_error => :RaiseError,
-      :logger      => :Logger
+    register_middleware File.expand_path('response', __dir__),
+                        raise_error: [:RaiseError, 'raise_error'],
+                        logger: [:Logger, 'logger']
 
     def initialize(env = nil)
-      @env = env
+      @env = Env.from(env) if env
       @on_complete_callbacks = []
     end
 
     attr_reader :env
-    alias_method :to_hash, :env
 
     def status
-      finished? ? env[:status] : nil
+      finished? ? env.status : nil
+    end
+
+    def reason_phrase
+      finished? ? env.reason_phrase : nil
     end
 
     def headers
-      finished? ? env[:response_headers] : {}
+      finished? ? env.response_headers : {}
     end
     def_delegator :headers, :[]
 
     def body
-      finished? ? env[:body] : nil
+      finished? ? env.body : nil
     end
 
     def finished?
       !!env
     end
 
-    def on_complete
-      if not finished?
-        @on_complete_callbacks << Proc.new
+    def on_complete(&block)
+      if !finished?
+        @on_complete_callbacks << block
       else
-        yield env
+        yield(env)
       end
-      return self
+      self
     end
 
     def finish(env)
-      raise "response already finished" if finished?
-      @env = env
-      @on_complete_callbacks.each { |callback| callback.call(env) }
-      return self
+      raise 'response already finished' if finished?
+
+      @env = env.is_a?(Env) ? env : Env.from(env)
+      @on_complete_callbacks.each { |callback| callback.call(@env) }
+      self
     end
 
     def success?
-      (200..299).include?(status)
+      finished? && env.success?
+    end
+
+    def to_hash
+      {
+        status: env.status, body: env.body,
+        response_headers: env.response_headers
+      }
     end
 
     # because @on_complete_callbacks cannot be marshalled
     def marshal_dump
-      !finished? ? nil : {
-        :status => @env[:status], :body => @env[:body],
-        :response_headers => @env[:response_headers]
-      }
+      finished? ? to_hash : nil
     end
 
     def marshal_load(env)
-      @env = env
+      @env = Env.from(env)
     end
 
     # Expand the env with more properties, without overriding existing ones.
     # Useful for applying request params after restoring a marshalled Response.
     def apply_request(request_env)
       raise "response didn't finish yet" unless finished?
-      @env = request_env.merge @env
-      return self
+
+      @env = Env.from(request_env).update(@env)
+      self
     end
   end
 end

data/lib/faraday/utils/headers.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Utils
+    # A case-insensitive Hash that preserves the original case of a header
+    # when set.
+    #
+    # Adapted from Rack::Utils::HeaderHash
+    class Headers < ::Hash
+      def self.from(value)
+        new(value)
+      end
+
+      def self.allocate
+        new_self = super
+        new_self.initialize_names
+        new_self
+      end
+
+      def initialize(hash = nil)
+        super()
+        @names = {}
+        update(hash || {})
+      end
+
+      def initialize_names
+        @names = {}
+      end
+
+      # on dup/clone, we need to duplicate @names hash
+      def initialize_copy(other)
+        super
+        @names = other.names.dup
+      end
+
+      # need to synchronize concurrent writes to the shared KeyMap
+      keymap_mutex = Mutex.new
+
+      # symbol -> string mapper + cache
+      KeyMap = Hash.new do |map, key|
+        value = if key.respond_to?(:to_str)
+                  key
+                else
+                  key.to_s.split('_') # user_agent: %w(user agent)
+                     .each(&:capitalize!) # => %w(User Agent)
+                     .join('-') # => "User-Agent"
+                end
+        keymap_mutex.synchronize { map[key] = value }
+      end
+      KeyMap[:etag] = 'ETag'
+
+      def [](key)
+        key = KeyMap[key]
+        super(key) || super(@names[key.downcase])
+      end
+
+      def []=(key, val)
+        key = KeyMap[key]
+        key = (@names[key.downcase] ||= key)
+        # join multiple values with a comma
+        val = val.to_ary.join(', ') if val.respond_to?(:to_ary)
+        super(key, val)
+      end
+
+      def fetch(key, *args, &block)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *args, &block)
+      end
+
+      def delete(key)
+        key = KeyMap[key]
+        key = @names[key.downcase]
+        return unless key
+
+        @names.delete key.downcase
+        super(key)
+      end
+
+      def include?(key)
+        @names.include? key.downcase
+      end
+
+      alias has_key? include?
+      alias member? include?
+      alias key? include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+
+      alias update merge!
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        @names.clear
+        update other
+        self
+      end
+
+      def to_hash
+        ::Hash.new.update(self)
+      end
+
+      def parse(header_string)
+        return unless header_string && !header_string.empty?
+
+        headers = header_string.split(/\r\n/)
+
+        # Find the last set of response headers.
+        start_index = headers.rindex { |x| x.match(%r{^HTTP/}) } || 0
+        last_response = headers.slice(start_index, headers.size)
+
+        last_response
+          .tap { |a| a.shift if a.first.start_with?('HTTP/') }
+          .map { |h| h.split(/:\s*/, 2) } # split key and value
+          .reject { |p| p[0].nil? } # ignore blank lines
+          .each { |key, value| add_parsed(key, value) }
+      end
+
+      protected
+
+      attr_reader :names
+
+      private
+
+      # Join multiple values with a comma.
+      def add_parsed(key, value)
+        self[key] ? self[key] << ', ' << value : self[key] = value
+      end
+    end
+  end
+end

data/lib/faraday/utils/params_hash.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Utils
+    # A hash with stringified keys.
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def include?(key)
+        super(convert_key(key))
+      end
+
+      alias has_key? include?
+      alias member? include?
+      alias key? include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias merge! update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query, encoder = nil)
+        return self unless query && !query.empty?
+
+        update((encoder || Utils.default_params_encoder).decode(query))
+      end
+
+      def to_query(encoder = nil)
+        (encoder || Utils.default_params_encoder).encode(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+  end
+end

data/lib/faraday/utils.rb

@@ -1,149 +1,106 @@
-require 'rack/utils'
+# frozen_string_literal: true
+
+require 'faraday/utils/headers'
+require 'faraday/utils/params_hash'
 
 module Faraday
+  # Utils contains various static helper methods.
   module Utils
-    include Rack::Utils
-
-    extend Rack::Utils
-    extend self
-
-    class Headers < HeaderHash
-      # symbol -> string mapper + cache
-      KeyMap = Hash.new do |map, key|
-        map[key] = if key.respond_to?(:to_str) then key
-        else
-          key.to_s.split('_').            # :user_agent => %w(user agent)
-            each { |w| w.capitalize! }.   # => %w(User Agent)
-            join('-')                     # => "User-Agent"
-        end
-      end
-      KeyMap[:etag] = "ETag"
-
-      def [](k)
-        super(KeyMap[k])
-      end
+    module_function
 
-      def []=(k, v)
-        # join multiple values with a comma
-        v = v.to_ary.join(', ') if v.respond_to? :to_ary
-        super(KeyMap[k], v)
-      end
-
-      alias_method :update, :merge!
-
-      def parse(header_string)
-        return unless header_string && !header_string.empty?
-        header_string.split(/\r\n/).
-          tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
-          map  { |h| h.split(/:\s+/, 2) }.reject { |(k, v)| k.nil? }. # split key and value, ignore blank lines
-          each { |key, value|
-            # join multiple values with a comma
-            if self[key] then self[key] << ', ' << value
-            else self[key] = value
-            end
-          }
-      end
+    def build_query(params)
+      FlatParamsEncoder.encode(params)
     end
 
-    # hash with stringified keys
-    class ParamsHash < Hash
-      def [](key)
-        super(convert_key(key))
-      end
-
-      def []=(key, value)
-        super(convert_key(key), value)
-      end
+    def build_nested_query(params)
+      NestedParamsEncoder.encode(params)
+    end
 
-      def delete(key)
-        super(convert_key(key))
-      end
+    def default_space_encoding
+      @default_space_encoding ||= '+'
+    end
 
-      def include?(key)
-        super(convert_key(key))
-      end
+    class << self
+      attr_writer :default_space_encoding
+    end
 
-      alias_method :has_key?, :include?
-      alias_method :member?, :include?
-      alias_method :key?, :include?
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
 
-      def update(params)
-        params.each do |key, value|
-          self[key] = value
-        end
-        self
-      end
-      alias_method :merge!, :update
+    def escape(str)
+      str.to_s.gsub(ESCAPE_RE) do |match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      end.gsub(' ', default_space_encoding)
+    end
 
-      def merge(params)
-        dup.update(params)
-      end
+    def unescape(str)
+      CGI.unescape str.to_s
+    end
 
-      def replace(other)
-        clear
-        update(other)
-      end
+    DEFAULT_SEP = /[&;] */n.freeze
 
-      def merge_query(query)
-        if query && !query.empty?
-          update Utils.parse_query(query)
-        end
-        self
-      end
+    # Adapted from Rack
+    def parse_query(query)
+      FlatParamsEncoder.decode(query)
+    end
 
-      def to_query
-        Utils.build_query(self)
-      end
+    def parse_nested_query(query)
+      NestedParamsEncoder.decode(query)
+    end
 
-      private
+    def default_params_encoder
+      @default_params_encoder ||= NestedParamsEncoder
+    end
 
-      def convert_key(key)
-        key.to_s
-      end
+    class << self
+      attr_writer :default_params_encoder
     end
 
-    # Make Rack::Utils methods public.
-    public :build_query, :parse_query
-
-    # Override Rack's version since it doesn't handle non-String values
-    def build_nested_query(value, prefix = nil)
-      case value
-      when Array
-        value.map { |v| build_nested_query(v, "#{prefix}[]") }.join("&")
-      when Hash
-        value.map { |k, v|
-          build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-        }.join("&")
-      when NilClass
-        prefix
+    # Normalize URI() behavior across Ruby versions
+    #
+    # url - A String or URI.
+    #
+    # Returns a parsed URI.
+    def URI(url) # rubocop:disable Naming/MethodName
+      if url.respond_to?(:host)
+        url
+      elsif url.respond_to?(:to_str)
+        default_uri_parser.call(url)
       else
-        raise ArgumentError, "value must be a Hash" if prefix.nil?
-        "#{prefix}=#{escape(value)}"
+        raise ArgumentError, 'bad argument (expected URI object or URI string)'
       end
     end
 
-    # Be sure to URI escape '+' symbols to %2B. Otherwise, they get interpreted
-    # as spaces.
-    def escape(s)
-      s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) do
-        '%' << $1.unpack('H2'*bytesize($1)).join('%').tap { |c| c.upcase! }
+    def default_uri_parser
+      @default_uri_parser ||= begin
+        require 'uri'
+        Kernel.method(:URI)
       end
     end
 
-    # Receives a URL and returns just the path with the query string sorted.
+    def default_uri_parser=(parser)
+      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
+                              parser
+                            else
+                              parser.method(:parse)
+                            end
+    end
+
+    # Receives a String or URI and returns just
+    # the path with the query string sorted.
     def normalize_path(url)
-      (url.path != "" ? url.path : "/") +
-      (url.query ? "?#{sort_query_params(url.query)}" : "")
+      url = URI(url)
+      (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|
-        if Hash === value and Hash === target[key]
-          target[key] = deep_merge(target[key], value)
-        else
-          target[key] = value
-        end
+        target[key] = if value.is_a?(Hash) && target[key].is_a?(Hash)
+                        deep_merge(target[key], value)
+                      else
+                        value
+                      end
       end
       target
     end
@@ -153,8 +110,6 @@ module Faraday
       deep_merge!(source.dup, hash)
     end
 
-    protected
-
     def sort_query_params(query)
       query.split('&').sort.join('&')
     end