faraday 0.6.0 → 0.9.0

data/lib/faraday/response/raise_error.rb

@@ -1,16 +1,21 @@
 module Faraday
   class Response::RaiseError < Response::Middleware
+    ClientErrorStatuses = 400...600
+
     def on_complete(env)
       case env[:status]
       when 404
         raise Faraday::Error::ResourceNotFound, response_values(env)
-      when 400...600
+      when 407
+        # mimic the behavior that we get with proxy requests with HTTPS
+        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+      when ClientErrorStatuses
         raise Faraday::Error::ClientError, response_values(env)
       end
     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}
     end
   end
 end

data/lib/faraday/response.rb

@@ -5,50 +5,45 @@ module Faraday
     # 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
       def on_complete(env)
-        if respond_to? :parse
-          env[:body] = parse(env[:body])
-        end
+        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
       end
     end
 
     extend Forwardable
-    extend AutoloadHelper
-
-    autoload_all 'faraday/response',
-      :RaiseError => 'raise_error',
-      :Logger     => 'logger'
+    extend MiddlewareRegistry
 
-    register_lookup_modules \
-      :raise_error => :RaiseError,
-      :logger      => :Logger
+    register_middleware File.expand_path('../response', __FILE__),
+      :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_delegators :env, :to_hash
 
     def status
-      finished? ? env[:status] : nil
+      finished? ? env.status : 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?
@@ -59,39 +54,39 @@ module Faraday
       if not finished?
         @on_complete_callbacks << Proc.new
       else
-        yield env
+        yield(env)
       end
       return self
     end
 
     def finish(env)
       raise "response already finished" if finished?
-      @env = env
+      @env = Env.from(env)
       @on_complete_callbacks.each { |callback| callback.call(env) }
       return self
     end
 
     def success?
-      status == 200
+      finished? && env.success?
     end
 
     # because @on_complete_callbacks cannot be marshalled
     def marshal_dump
       !finished? ? nil : {
-        :status => @env[:status], :body => @env[:body],
-        :response_headers => @env[:response_headers]
+        :status => @env.status, :body => @env.body,
+        :response_headers => @env.response_headers
       }
     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
+      @env = Env.from(request_env).update(@env)
       return self
     end
   end

data/lib/faraday/upload_io.rb

@@ -8,13 +8,57 @@ rescue LoadError
 end
 
 module Faraday
-  class CompositeReadIO < ::CompositeReadIO
-    attr_reader :length
-    
-    def initialize(parts)
-      @length = parts.inject(0) { |sum, part| sum + part.length }
-      ios = parts.map{ |part| part.to_io }
-      super(*ios)
+  # Similar but not compatible with ::CompositeReadIO provided by multipart-post.
+  class CompositeReadIO
+    def initialize(*parts)
+      @parts = parts.flatten
+      @ios = @parts.map { |part| part.to_io }
+      @index = 0
+    end
+
+    def length
+      @parts.inject(0) { |sum, part| sum + part.length }
+    end
+
+    def rewind
+      @ios.each { |io| io.rewind }
+      @index = 0
+    end
+
+    # Read from IOs in order until `length` bytes have been received.
+    def read(length = nil, outbuf = nil)
+      got_result = false
+      outbuf = outbuf ? outbuf.replace("") : ""
+
+      while io = current_io
+        if result = io.read(length)
+          got_result ||= !result.nil?
+          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
+          outbuf << result
+          length -= result.length if length
+          break if length == 0
+        end
+        advance_io
+      end
+      (!got_result && length) ? nil : outbuf
+    end
+
+    def close
+      @ios.each { |io| io.close }
+    end
+
+    def ensure_open_and_readable
+      # Rubinius compatibility
+    end
+
+    private
+
+    def current_io
+      @ios[@index]
+    end
+
+    def advance_io
+      @index += 1
     end
   end
 

data/lib/faraday/utils.rb

@@ -1,97 +1,293 @@
-require 'rack/utils'
+require 'thread'
+Faraday.require_libs 'parameters'
+
 module Faraday
   module Utils
-    include Rack::Utils
-
-    extend Rack::Utils
     extend self
 
-    class Headers < HeaderHash
+    # Adapted from Rack::Utils::HeaderHash
+    class Headers < ::Hash
+      def self.from(value)
+        new(value)
+      end
+
+      def initialize(hash = nil)
+        super()
+        @names = {}
+        self.update(hash || {})
+      end
+
+      # need to synchronize concurrent writes to the shared KeyMap
+      keymap_mutex = Mutex.new
+
       # symbol -> string mapper + cache
       KeyMap = Hash.new do |map, key|
-        map[key] = if key.respond_to?(:to_str) then key
+        value = if key.respond_to?(:to_str)
+          key
         else
           key.to_s.split('_').            # :user_agent => %w(user agent)
             each { |w| w.capitalize! }.   # => %w(User Agent)
             join('-')                     # => "User-Agent"
         end
+        keymap_mutex.synchronize { map[key] = value }
       end
       KeyMap[:etag] = "ETag"
-      
+
       def [](k)
-        super(KeyMap[k])
+        k = KeyMap[k]
+        super(k) || super(@names[k.downcase])
       end
 
       def []=(k, v)
+        k = KeyMap[k]
+        k = (@names[k.downcase] ||= k)
         # join multiple values with a comma
         v = v.to_ary.join(', ') if v.respond_to? :to_ary
-        super(KeyMap[k], v)
+        super(k, v)
+      end
+
+      def fetch(k, *args, &block)
+        k = KeyMap[k]
+        key = @names.fetch(k.downcase, k)
+        super(key, *args, &block)
+      end
+
+      def delete(k)
+        k = KeyMap[k]
+        if k = @names[k.downcase]
+          @names.delete k.downcase
+          super(k)
+        end
+      end
+
+      def include?(k)
+        @names.include? k.downcase
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
       end
-      
       alias_method :update, :merge!
-      
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        self.update other
+        self
+      end
+
+      def to_hash() ::Hash.new.update(self) end
+
       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
+          map  { |h| h.split(/:\s+/, 2) }.reject { |p| p[0].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
+            if self[key]
+              self[key] << ', ' << value
+            else
+              self[key] = value
             end
           }
       end
     end
 
-    # Make Rack::Utils build_query method public.
-    public :build_query
+    # hash with stringified keys
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
 
-    # 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
-      else
-        raise ArgumentError, "value must be a Hash" if prefix.nil?
-        "#{prefix}=#{escape(value)}"
+      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_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query, encoder = nil)
+        if query && !query.empty?
+          update((encoder || Utils.default_params_encoder).decode(query))
+        end
+        self
+      end
+
+      def to_query(encoder = nil)
+        (encoder || Utils.default_params_encoder).encode(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+
+    def build_query(params)
+      FlatParamsEncoder.encode(params)
     end
 
-    # Be sure to URI escape '+' symbols to %2B. Otherwise, they get interpreted
-    # as spaces.
+    def build_nested_query(params)
+      NestedParamsEncoder.encode(params)
+    end
+
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
+
     def escape(s)
-      s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) do
-        '%' << $1.unpack('H2'*bytesize($1)).join('%').tap { |c| c.upcase! }
+      s.to_s.gsub(ESCAPE_RE) {|match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      }.tr(' ', '+')
+    end
+
+    def unescape(s) CGI.unescape s.to_s end
+
+    DEFAULT_SEP = /[&;] */n
+
+    # Adapted from Rack
+    def parse_query(query)
+      FlatParamsEncoder.decode(query)
+    end
+
+    def parse_nested_query(query)
+      NestedParamsEncoder.decode(query)
+    end
+
+    def default_params_encoder
+      @default_params_encoder ||= NestedParamsEncoder
+    end
+
+    class << self
+      attr_writer :default_params_encoder
+    end
+
+    # Stolen from Rack
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        if params[k]
+          params[k] = Array[params[k]] unless params[k].kind_of?(Array)
+          params[k] << v
+        else
+          params[k] = v
+        end
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
+    end
+
+    # Normalize URI() behavior across Ruby versions
+    #
+    # url - A String or URI.
+    #
+    # Returns a parsed URI.
+    def URI(url)
+      if url.respond_to?(:host)
+        url
+      elsif url.respond_to?(:to_str)
+        default_uri_parser.call(url)
+      else
+        raise ArgumentError, "bad argument (expected URI object or URI string)"
       end
     end
 
-    # Turns param keys into strings
-    def merge_params(existing_params, new_params)
-      new_params.each do |key, value|
-        existing_params[key.to_s] = value
+    def default_uri_parser
+      @default_uri_parser ||= begin
+        require 'uri'
+        Kernel.method(:URI)
       end
     end
 
-    # Turns headers keys and values into strings
-    def merge_headers(existing_headers, new_headers)
-      new_headers.each do |key, value|
-        existing_headers[key] = value.to_s
+    def default_uri_parser=(parser)
+      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
+        parser
+      else
+        parser.method(:parse)
       end
     end
 
-    # Receives a URL and returns just the path with the query string sorted.
+    # Receives a String or URI and returns just the path with the query string sorted.
     def normalize_path(url)
-      (url.path != "" ? url.path : "/") +
+      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
+      end
+      target
+    end
+
+    # Recursive hash merge
+    def deep_merge(source, hash)
+      deep_merge!(source.dup, hash)
+    end
+
     protected
 
     def sort_query_params(query)