faraday 0.9.0.rc5 → 0.9.0.rc6

data/lib/faraday/adapter/typhoeus.rb

@@ -56,6 +56,17 @@ module Faraday
             end
           end
 
+          case resp.curl_return_code
+          when 0
+            # everything OK
+          when 7
+            raise Error::ConnectionFailed, resp.curl_error_message
+          when 60
+            raise Faraday::SSLError, resp.curl_error_message
+          else
+            raise Error::ClientError, resp.curl_error_message
+          end
+
           save_response(env, resp.code, resp.body) do |response_headers|
             response_headers.parse resp.headers
           end

data/lib/faraday/autoload.rb

@@ -1,5 +1,3 @@
-require 'faraday'
-
 module Faraday
   # Internal: Adds the ability for other modules to manage autoloadable
   # constants.
@@ -74,7 +72,8 @@ module Faraday
       :Timeout => 'timeout',
       :Authorization => 'authorization',
       :BasicAuthentication => 'basic_authentication',
-      :TokenAuthentication => 'token_authentication'
+      :TokenAuthentication => 'token_authentication',
+      :Instrumentation => 'instrumentation'
   end
 
   class Response
@@ -84,4 +83,3 @@ module Faraday
       :Logger     => 'logger'
   end
 end
-

data/lib/faraday/connection.rb

@@ -79,7 +79,14 @@ module Faraday
       @params.update(options.params)   if options.params
       @headers.update(options.headers) if options.headers
 
-      proxy(options.fetch(:proxy) { ENV['http_proxy'] })
+      @proxy = nil
+      proxy(options.fetch(:proxy) {
+        uri = ENV['http_proxy']
+        if uri && !uri.empty?
+          uri = 'http://' + uri if uri !~ /^http/i
+          uri
+        end
+      })
 
       yield self if block_given?
 
@@ -312,7 +319,7 @@ module Faraday
     end
 
     # Public: Sets the path prefix and ensures that it always has a leading
-    # but no trailing slash.
+    # slash.
     #
     # value - A String.
     #
@@ -324,6 +331,27 @@ module Faraday
       end
     end
 
+    # Public: Takes a relative url for a request and combines it with the defaults
+    # set on the connection instance.
+    #
+    #   conn = Faraday::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api?token=abc"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
+    #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
+    #
+    def build_url(url = nil, extra_params = nil)
+      uri = build_exclusive_url(url)
+
+      query_values = params.dup.merge_query(uri.query, options.params_encoder)
+      query_values.update extra_params if extra_params
+      uri.query = query_values.empty? ? nil : query_values.to_query(options.params_encoder)
+
+      uri
+    end
+
     # Builds and runs the Faraday::Request.
     #
     # method  - The Symbol HTTP method.
@@ -400,4 +428,3 @@ module Faraday
     end
   end
 end
-

data/lib/faraday/error.rb

@@ -38,8 +38,11 @@ module Faraday
   class ParsingError     < ClientError;   end
   class TimeoutError < ClientError; end
 
+  class SSLError < ClientError
+  end
+
   [:MissingDependency, :ClientError, :ConnectionFailed, :ResourceNotFound,
-   :ParsingError, :TimeoutError].each do |const|
+   :ParsingError, :TimeoutError, :SSLError].each do |const|
     Error.const_set(const, Faraday.const_get(const))
   end
 end

data/lib/faraday/options.rb

@@ -18,7 +18,7 @@ module Faraday
     def update(obj)
       obj.each do |key, value|
         if sub_options = self.class.options_for(key)
-          value = sub_options.from(value)
+          value = sub_options.from(value) if value
         elsif Hash === value
           hash = {}
           value.each do |hash_key, hash_value|
@@ -27,7 +27,7 @@ module Faraday
           value = hash
         end
 
-        self.send("#{key}=", value)
+        self.send("#{key}=", value) unless value.nil?
       end
       self
     end
@@ -47,9 +47,20 @@ module Faraday
     end
 
     # Public
-    def fetch(key, default = nil)
-      send(key) || send("#{key}=", default ||
-        (block_given? ? Proc.new.call : nil))
+    def fetch(key, *args)
+      return send(key) if symbolized_key_set.include?(key.to_sym)
+
+      key_setter = "#{key}="
+
+      if args.size > 0
+        return send(key_setter, args.first)
+      end
+
+      if block_given?
+        return send(key_setter, Proc.new.call(key))
+      end
+
+      raise self.class.fetch_error_class, "key not found: #{key.inspect}"
     end
 
     # Public
@@ -98,6 +109,44 @@ module Faraday
     def self.attribute_options
       @attribute_options ||= {}
     end
+
+    def self.memoized(key)
+      memoized_attributes[key.to_sym] = Proc.new
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{key}() self[:#{key}]; end
+      RUBY
+    end
+
+    def self.memoized_attributes
+      @memoized_attributes ||= {}
+    end
+
+    def [](key)
+      key = key.to_sym
+      if method = self.class.memoized_attributes[key]
+        super(key) || (self[key] = instance_eval(&method))
+      else
+        super
+      end
+    end
+
+    def symbolized_key_set
+      @symbolized_key_set ||= Set.new(keys.map { |k| k.to_sym })
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.attribute_options.update(attribute_options)
+      subclass.memoized_attributes.update(memoized_attributes)
+    end
+
+    def self.fetch_error_class
+      @fetch_error_class ||= if Object.const_defined?(:KeyError)
+        ::KeyError
+      else
+        ::IndexError
+      end
+    end
   end
 
   class RequestOptions < Options.new(:params_encoder, :proxy, :bind,
@@ -114,7 +163,7 @@ module Faraday
   end
 
   class SSLOptions < Options.new(:verify, :ca_file, :ca_path, :verify_mode,
-    :cert_store, :client_cert, :client_key, :verify_depth, :version)
+    :cert_store, :client_cert, :client_key, :certificate, :private_key, :verify_depth, :version)
 
     def verify?
       verify != false
@@ -141,13 +190,8 @@ module Faraday
       super(value)
     end
 
-    def user
-      self[:user] ||= Utils.unescape(uri.user)
-    end
-
-    def password
-      self[:password] ||= Utils.unescape(uri.password)
-    end
+    memoized(:user) { uri.user && Utils.unescape(uri.user) }
+    memoized(:password) { uri.password && Utils.unescape(uri.password) }
   end
 
   class ConnectionOptions < Options.new(:request, :proxy, :ssl, :builder, :url,
@@ -155,17 +199,11 @@ module Faraday
 
     options :request => RequestOptions, :ssl => SSLOptions
 
-    def request
-      self[:request] ||= self.class.options_for(:request).new
-    end
+    memoized(:request) { self.class.options_for(:request).new }
 
-    def ssl
-      self[:ssl] ||= self.class.options_for(:ssl).new
-    end
+    memoized(:ssl) { self.class.options_for(:ssl).new }
 
-    def builder_class
-      self[:builder_class] ||= RackBuilder
-    end
+    memoized(:builder_class) { RackBuilder }
 
     def new_builder(block)
       builder_class.new(&block)
@@ -190,26 +228,82 @@ module Faraday
 
     def_delegators :request, :params_encoder
 
+    # Public
+    def [](key)
+      if in_member_set?(key)
+        super(key)
+      else
+        custom_members[key]
+      end
+    end
+
+    # Public
+    def []=(key, value)
+      if in_member_set?(key)
+        super(key, value)
+      else
+        custom_members[key] = value
+      end
+    end
+
+    # Public
     def success?
       SuccessfulStatuses.include?(status)
     end
 
+    # Public
     def needs_body?
       !body && MethodsWithBodies.include?(method)
     end
 
+    # Public
     def clear_body
       request_headers[ContentLength] = '0'
       self.body = ''
     end
 
+    # Public
     def parse_body?
       !StatusesWithoutBody.include?(status)
     end
 
+    # Public
     def parallel?
       !!parallel_manager
     end
+
+    def inspect
+      attrs = [nil]
+      members.each do |mem|
+        if value = send(mem)
+          attrs << "@#{mem}=#{value.inspect}"
+        end
+      end
+      if !custom_members.empty?
+        attrs << "@custom=#{custom_members.inspect}"
+      end
+      %(#<#{self.class}#{attrs.join(" ")}>)
+    end
+
+    # Internal
+    def custom_members
+      @custom_members ||= {}
+    end
+
+    # Internal
+    if members.first.is_a?(Symbol)
+      def in_member_set?(key)
+        self.class.member_set.include?(key.to_sym)
+      end
+    else
+      def in_member_set?(key)
+        self.class.member_set.include?(key.to_s)
+      end
+    end
+
+    # Internal
+    def self.member_set
+      @member_set ||= Set.new(members)
+    end
   end
 end
-

data/lib/faraday/request/instrumentation.rb

@@ -24,7 +24,7 @@ module Faraday
     #   end
     def initialize(app, options = nil)
       super(app)
-      @name, @instrumenter = Options.from(options).values
+      @name, @instrumenter = Options.from(options).values_at(:name, :instrumenter)
     end
 
     def call(env)
@@ -34,5 +34,3 @@ module Faraday
     end
   end
 end
-
-

data/lib/faraday/request/multipart.rb

@@ -8,7 +8,7 @@ module Faraday
     def call(env)
       match_content_type(env) do |params|
         env.request.boundary ||= DEFAULT_BOUNDARY
-        env.request_headers[CONTENT_TYPE] += ";boundary=#{env.request.boundary}"
+        env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
         env.body = create_multipart(env, params)
       end
       @app.call env

data/lib/faraday/request/retry.rb

@@ -3,17 +3,23 @@ module Faraday
   #
   # By default, it retries 2 times and handles only timeout exceptions. It can
   # be configured with an arbitrary number of retries, a list of exceptions to
-  # handle an a retry interval.
+  # handle, a retry interval, a percentage of randomness to add to the retry
+  # interval, and a backoff factor.
   #
   # Examples
   #
   #   Faraday.new do |conn|
   #     conn.request :retry, max: 2, interval: 0.05,
+  #                          interval_randomness: 0.5, backoff_factor: 2
   #                          exceptions: [CustomException, 'Timeout::Error']
   #     conn.adapter ...
   #   end
+  #
+  # This example will result in a first interval that is random between 0.05 and 0.075 and a second
+  # interval that is random between 0.1 and 0.15
+  #
   class Request::Retry < Faraday::Middleware
-    class Options < Faraday::Options.new(:max, :interval, :exceptions)
+    class Options < Faraday::Options.new(:max, :interval, :interval_randomness, :backoff_factor, :exceptions)
       def self.from(value)
         if Fixnum === value
           new(value)
@@ -30,6 +36,14 @@ module Faraday
         (self[:interval] ||= 0).to_f
       end
 
+      def interval_randomness
+        (self[:interval_randomness] ||= 0).to_i
+      end
+
+      def backoff_factor
+        (self[:backoff_factor] ||= 1).to_f
+      end
+
       def exceptions
         Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error',
                                      Error::TimeoutError])
@@ -40,25 +54,41 @@ module Faraday
     # Public: Initialize middleware
     #
     # Options:
-    # max        - Maximum number of retries (default: 2).
-    # interval   - Pause in seconds between retries (default: 0).
-    # exceptions - The list of exceptions to handle. Exceptions can be
-    #              given as Class, Module, or String. (default:
-    #              [Errno::ETIMEDOUT, Timeout::Error, Error::TimeoutError])
+    # max                 - Maximum number of retries (default: 2)
+    # interval            - Pause in seconds between retries (default: 0)
+    # interval_randomness - The maximum random interval amount expressed
+    #                       as a float between 0 and 1 to use in addition to the
+    #                       interval. (default: 0)
+    # backoff_factor      - The amount to multiple each successive retry's
+    #                       interval amount by in order to provide backoff
+    #                       (default: 1)
+    # exceptions          - The list of exceptions to handle. Exceptions can be
+    #                       given as Class, Module, or String. (default:
+    #                       [Errno::ETIMEDOUT, Timeout::Error,
+    #                       Error::TimeoutError])
     def initialize(app, options = nil)
       super(app)
       @options = Options.from(options)
       @errmatch = build_exception_matcher(@options.exceptions)
     end
 
+    def sleep_amount(retries)
+      retry_index = @options.max - retries
+      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
+      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
+      current_interval + random_interval
+    end
+
     def call(env)
       retries = @options.max
+      request_body = env[:body]
       begin
+        env[:body] = request_body # after failure env[:body] is set to the response body
         @app.call(env)
       rescue @errmatch
         if retries > 0
           retries -= 1
-          sleep @options.interval if @options.interval > 0
+          sleep sleep_amount(retries + 1)
           retry
         end
         raise
@@ -84,4 +114,3 @@ module Faraday
     end
   end
 end
-

data/lib/faraday/response.rb

@@ -86,9 +86,8 @@ module Faraday
     # Useful for applying request params after restoring a marshalled Response.
     def apply_request(request_env)
       raise "response didn't finish yet" unless finished?
-      @env = Env.from(request_env).merge(@env)
+      @env = Env.from(request_env).update(@env)
       return self
     end
   end
 end
-