faraday 0.9.1 → 0.15.0

data/lib/faraday/adapter/patron.rb

@@ -3,18 +3,13 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
-      def initialize(app, &block)
-        super(app)
-        @block = block
-      end
-
       def call(env)
         super
-
         # TODO: support streaming requests
         env[:body] = env[:body].read if env[:body].respond_to? :read
 
         session = @session ||= create_session
+        configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
 
         if req = env[:request]
           session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
@@ -35,11 +30,14 @@ module Faraday
           raise Error::ConnectionFailed, $!
         end
 
-        save_response(env, response.status, response.body, response.headers)
+        # Remove the "HTTP/1.1 200", leaving just the reason phrase
+        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
+
+        save_response(env, response.status, response.body, response.headers, reason_phrase)
 
         @app.call env
       rescue ::Patron::TimeoutError => err
-        if err.message == "Connection time-out"
+        if connection_timed_out_message?(err.message)
           raise Faraday::Error::ConnectionFailed, err
         else
           raise Faraday::Error::TimeoutError, err
@@ -56,17 +54,47 @@ module Faraday
         # HAX: helps but doesn't work completely
         # https://github.com/toland/patron/issues/34
         ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          actions << :patch unless actions.include? :patch
-          actions << :options unless actions.include? :options
+          if actions[0].is_a?(Symbol)
+            actions << :patch unless actions.include? :patch
+            actions << :options unless actions.include? :options
+          else
+            # Patron 0.4.20 and up
+            actions << "PATCH" unless actions.include? "PATCH"
+            actions << "OPTIONS" unless actions.include? "OPTIONS"
+          end
         end
       end
 
       def create_session
         session = ::Patron::Session.new
-        session.insecure = true
-        @block.call(session) if @block
+        @config_block.call(session) if @config_block
         session
       end
+
+      def configure_ssl(session, ssl)
+        if ssl.fetch(:verify, true)
+          session.cacert = ssl[:ca_file]
+        else
+          session.insecure = true
+        end
+      end
+
+      private
+
+      CURL_TIMEOUT_MESSAGES = [ "Connection time-out",
+          "Connection timed out",
+          "Timed out before name resolve",
+          "server connect has timed out",
+          "Resolving timed out",
+          "name lookup timed out",
+          "timed out before SSL",
+          "connect() timed out"
+        ].freeze
+
+      def connection_timed_out_message?(message)
+        CURL_TIMEOUT_MESSAGES.any? { |curl_message| message.include?(curl_message) }
+      end
+
     end
   end
 end

data/lib/faraday/adapter/test.rb

@@ -1,16 +1,41 @@
 module Faraday
   class Adapter
-    # test = Faraday::Connection.new do
-    #   use Faraday::Adapter::Test do |stub|
-    #     stub.get '/nigiri/sake.json' do
-    #       [200, {}, 'hi world']
+    # Examples
+    #
+    #   test = Faraday::Connection.new do
+    #     use Faraday::Adapter::Test do |stub|
+    #       # simply define matcher to match the request
+    #       stub.get '/resource.json' do
+    #         # return static content
+    #         [200, {'Content-Type' => 'application/json'}, 'hi world']
+    #       end
+    #       
+    #       # response with content generated based on request
+    #       stub.get '/showget' do |env|
+    #         [200, {'Content-Type' => 'text/plain'}, env[:method].to_s]
+    #       end
+    #       
+    #       # regular expression can be used as matching filter
+    #       stub.get /\A\/items\/(\d+)\z/ do |env, meta|
+    #         # in case regular expression is used an instance of MatchData can be received
+    #         [200, {'Content-Type' => 'text/plain'}, "showing item: #{meta[:match_data][1]}"]
+    #       end
     #     end
     #   end
-    # end
-    #
-    # resp = test.get '/nigiri/sake.json'
-    # resp.body # => 'hi world'
+    #   
+    #   resp = test.get '/resource.json'
+    #   resp.body # => 'hi world'
+    #   
+    #   resp = test.get '/showget'
+    #   resp.body # => 'get'
+    #   
+    #   resp = test.get '/items/1'
+    #   resp.body # => 'showing item: 1'
+    #   
+    #   resp = test.get '/items/2'
+    #   resp.body # => 'showing item: 2'
     #
+
     class Test < Faraday::Adapter
       attr_accessor :stubs
 
@@ -28,17 +53,17 @@ module Faraday
           @stack.empty?
         end
 
-        def match(request_method, path, headers, body)
+        def match(request_method, host, path, headers, body)
           return false if !@stack.key?(request_method)
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
 
-          if stub = matches?(stack, path, headers, body)
+          stub, meta = matches?(stack, host, path, headers, body)
+          if stub
             consumed << stack.delete(stub)
-            stub
-          else
-            matches?(consumed, path, headers, body)
+            return stub, meta
           end
+          matches?(consumed, host, path, headers, body)
         end
 
         def get(path, headers = {}, &block)
@@ -85,33 +110,55 @@ module Faraday
         protected
 
         def new_stub(request_method, path, headers = {}, body=nil, &block)
-          normalized_path = Faraday::Utils.normalize_path(path)
-          (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
+          normalized_path, host =
+            if path.is_a?(Regexp)
+              path
+            else
+              [Faraday::Utils.normalize_path(path), Faraday::Utils.URI(path).host]
+            end
+
+          (@stack[request_method] ||= []) << Stub.new(host, normalized_path, headers, body, block)
         end
 
-        def matches?(stack, path, headers, body)
-          stack.detect { |stub| stub.matches?(path, headers, body) }
+        def matches?(stack, host, path, headers, body)
+          stack.each do |stub|
+            match_result, meta = stub.matches?(host, path, headers, body)
+            return stub, meta if match_result
+          end
+          nil
         end
       end
 
-      class Stub < Struct.new(:path, :params, :headers, :body, :block)
-        def initialize(full, headers, body, block)
-          path, query = full.split('?')
+      class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
+        def initialize(host, full, headers, body, block)
+          path, query = full.respond_to?(:split) ? full.split("?") : full
           params = query ?
             Faraday::Utils.parse_nested_query(query) :
             {}
-          super(path, params, headers, body, block)
+          super(host, path, params, headers, body, block)
         end
 
-        def matches?(request_uri, request_headers, request_body)
+        def matches?(request_host, request_uri, request_headers, request_body)
           request_path, request_query = request_uri.split('?')
           request_params = request_query ?
             Faraday::Utils.parse_nested_query(request_query) :
             {}
-          request_path == path &&
+          # meta is a hash use as carrier
+          # that will be yielded to consumer block
+          meta = {}
+          return (host.nil? || host == request_host) &&
+            path_match?(request_path, meta) &&
             params_match?(request_params) &&
             (body.to_s.size.zero? || request_body == body) &&
-            headers_match?(request_headers)
+            headers_match?(request_headers), meta
+        end
+
+        def path_match?(request_path, meta)
+          if path.is_a? Regexp
+            !!(meta[:match_data] = path.match(request_path))
+          else
+            path == request_path
+          end
         end
 
         def params_match?(request_params)
@@ -143,14 +190,18 @@ module Faraday
 
       def call(env)
         super
+        host = env[:url].host
         normalized_path = Faraday::Utils.normalize_path(env[:url])
         params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
 
-        if stub = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+        stub, meta = stubs.match(env[:method], host, normalized_path, env.request_headers, env[:body])
+        if stub
           env[:params] = (query = env[:url].query) ?
-            params_encoder.decode(query)  :
-            {}
-          status, headers, body = stub.block.call(env)
+            params_encoder.decode(query) : {}
+          block_arity = stub.block.arity
+          status, headers, body = (block_arity >= 0) ?
+            stub.block.call(*[env, meta].take(block_arity)) :
+            stub.block.call(env, meta)
           save_response(env, status, body, headers)
         else
           raise Stubs::NotFound, "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"

data/lib/faraday/adapter/typhoeus.rb

@@ -1,123 +1,12 @@
 module Faraday
   class Adapter
+    # This class is just a stub, the real adapter is in https://github.com/philsturgeon/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
     class Typhoeus < Faraday::Adapter
-      self.supports_parallel = true
-
-      def self.setup_parallel_manager(options = {})
-        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
-      end
+      # Needs to define this method in order to support Typhoeus <= 1.3.0
+      def call; end
 
       dependency 'typhoeus'
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        read_body env
-
-        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
-        hydra.queue request(env)
-        hydra.run unless parallel?(env)
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
-      end
-
-      # TODO: support streaming requests
-      def read_body(env)
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-      end
-
-      def request(env)
-        method = env[:method]
-        # For some reason, prevents Typhoeus from using "100-continue".
-        # We want this because Webrick 1.3.1 can't seem to handle it w/ PUT.
-        method = method.to_s.upcase if method == :put
-
-        req = ::Typhoeus::Request.new env[:url].to_s,
-          :method  => method,
-          :body    => env[:body],
-          :headers => env[:request_headers],
-          :disable_ssl_peer_verification => (env[:ssl] && env[:ssl].disable?)
-
-        configure_ssl     req, env
-        configure_proxy   req, env
-        configure_timeout req, env
-        configure_socket  req, env
-
-        req.on_complete do |resp|
-          if resp.timed_out?
-            if parallel?(env)
-              # TODO: error callback in async mode
-            else
-              raise Faraday::Error::TimeoutError, "request timed out"
-            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
-          # in async mode, :response is initialized at this point
-          env[:response].finish(env) if parallel?(env)
-        end
-
-        req
-      end
-
-      def configure_ssl(req, env)
-        ssl = env[:ssl]
-
-        req.ssl_version = ssl[:version]          if ssl[:version]
-        req.ssl_cert    = ssl[:client_cert] if ssl[:client_cert]
-        req.ssl_key     = ssl[:client_key]  if ssl[:client_key]
-        req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
-        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
-      end
-
-      def configure_proxy(req, env)
-        proxy = request_options(env)[:proxy]
-        return unless proxy
-
-        req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
-
-        if proxy[:user] && proxy[:password]
-          req.proxy_username = proxy[:user]
-          req.proxy_password = proxy[:password]
-        end
-      end
-
-      def configure_timeout(req, env)
-        env_req = request_options(env)
-        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
-        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
-      end
-
-      def configure_socket(req, env)
-        if bind = request_options(env)[:bind]
-          req.interface = bind[:host]
-        end
-      end
-
-      def request_options(env)
-        env[:request]
-      end
-
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
+      dependency 'typhoeus/adapters/faraday'
     end
   end
 end

data/lib/faraday/adapter.rb

@@ -30,13 +30,22 @@ module Faraday
     extend Parallelism
     self.supports_parallel = false
 
+    def initialize(app = nil, opts = {}, &block)
+      super(app)
+      @connection_options = opts
+      @config_block = block
+    end
+
     def call(env)
       env.clear_body if env.needs_body?
     end
 
-    def save_response(env, status, body, headers = nil)
+    private
+
+    def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body
+      env.reason_phrase = reason_phrase && reason_phrase.to_s.strip
       env.response_headers = Utils::Headers.new.tap do |response_headers|
         response_headers.update headers unless headers.nil?
         yield(response_headers) if block_given?

data/lib/faraday/autoload.rb

@@ -53,9 +53,9 @@ module Faraday
     autoload_all 'faraday/adapter',
       :NetHttp           => 'net_http',
       :NetHttpPersistent => 'net_http_persistent',
-      :Typhoeus          => 'typhoeus',
       :EMSynchrony       => 'em_synchrony',
       :EMHttp            => 'em_http',
+      :Typhoeus          => 'typhoeus',
       :Patron            => 'patron',
       :Excon             => 'excon',
       :Test              => 'test',

data/lib/faraday/connection.rb

@@ -39,6 +39,9 @@ module Faraday
     # Public: Sets the default parallel manager for this connection.
     attr_writer :default_parallel_manager
 
+    # Public: Gets or Sets the Hash proxy options.
+    # attr_reader :proxy
+
     # Public: Initializes a new Faraday::Connection.
     #
     # url     - URI or String base URL to use as a prefix for all
@@ -55,11 +58,11 @@ module Faraday
     #                     :user     - String (optional)
     #                     :password - String (optional)
     def initialize(url = nil, options = nil)
-      if url.is_a?(Hash)
-        options = ConnectionOptions.from(url)
+      options = ConnectionOptions.from(options)
+
+      if url.is_a?(Hash) || url.is_a?(ConnectionOptions)
+        options = options.merge(url)
         url     = options.url
-      else
-        options = ConnectionOptions.from(options)
       end
 
       @parallel_manager = nil
@@ -79,14 +82,9 @@ module Faraday
       @params.update(options.params)   if options.params
       @headers.update(options.headers) if options.headers
 
-      @proxy = nil
-      proxy(options.fetch(:proxy) {
-        uri = ENV['http_proxy']
-        if uri && !uri.empty?
-          uri = 'http://' + uri if uri !~ /^http/i
-          uri
-        end
-      })
+      @manual_proxy = !!options.proxy
+      @proxy = options.proxy ? ProxyOptions.from(options.proxy) : proxy_from_env(url)
+      @temp_proxy = @proxy
 
       yield(self) if block_given?
 
@@ -126,7 +124,7 @@ module Faraday
     #     req.body = JSON.generate(:query => {...})
     #   end
     #
-    # Yields a Faraday::Response for further request customizations.
+    # Yields a Faraday::Request for further request customizations.
     # Returns a Faraday::Response.
     #
     # Signature
@@ -163,7 +161,7 @@ module Faraday
     #     req.body = JSON.generate(:user => 'kimchy', ...)
     #   end
     #
-    # Yields a Faraday::Response for further request customizations.
+    # Yields a Faraday::Request for further request customizations.
     # Returns a Faraday::Response.
     #
     # Signature
@@ -283,9 +281,17 @@ module Faraday
     # Public: Gets or Sets the Hash proxy options.
     def proxy(arg = nil)
       return @proxy if arg.nil?
+      warn 'Warning: use of proxy(new_value) to set connection proxy have been DEPRECATED and will be removed in Faraday 1.0'
+      @manual_proxy = true
       @proxy = ProxyOptions.from(arg)
     end
 
+    # Public: Sets the Hash proxy options.
+    def proxy=(new_value)
+      @manual_proxy = true
+      @proxy = new_value ? ProxyOptions.from(new_value) : nil
+    end
+
     def_delegators :url_prefix, :scheme, :scheme=, :host, :host=, :port, :port=
     def_delegator :url_prefix, :path, :path_prefix
 
@@ -304,7 +310,7 @@ module Faraday
     #
     #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
     #
-    # Returns the parsed URI from teh given input..
+    # Returns the parsed URI from the given input..
     def url_prefix=(url, encoder = nil)
       uri = @url_prefix = Utils.URI(url)
       self.path_prefix = uri.path
@@ -358,7 +364,7 @@ module Faraday
     #
     # method  - The Symbol HTTP method.
     # url     - The String or URI to access.
-    # body    - The String body
+    # body    - The request body that will eventually be converted to a string.
     # headers - Hash of unencoded HTTP header key/value pairs.
     #
     # Returns a Faraday::Response.
@@ -367,7 +373,11 @@ module Faraday
         raise ArgumentError, "unknown http method: #{method}"
       end
 
+      # Resets temp_proxy
+      @temp_proxy = proxy_for_request(url)
+
       request = build_request(method) do |req|
+        req.options = req.options.merge(:proxy => @temp_proxy)
         req.url(url)                if url
         req.headers.update(headers) if headers
         req.body = body             if body
@@ -384,7 +394,7 @@ module Faraday
       Request.create(method) do |req|
         req.params  = self.params.dup
         req.headers = self.headers.dup
-        req.options = self.options.merge(:proxy => self.proxy)
+        req.options = self.options
         yield(req) if block_given?
       end
     end
@@ -396,7 +406,7 @@ module Faraday
     #          of the resulting url (default: nil).
     #
     # Returns the resulting URI instance.
-    def build_exclusive_url(url = nil, params = nil)
+    def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
       url = nil if url.respond_to?(:empty?) and url.empty?
       base = url_prefix
       if url and base.path and base.path !~ /\/$/
@@ -404,7 +414,7 @@ module Faraday
         base.path = base.path + '/'  # ensure trailing slash
       end
       uri = url ? base + url : base
-      uri.query = params.to_query(options.params_encoder) if params
+      uri.query = params.to_query(params_encoder || options.params_encoder) if params
       uri.query = nil if uri.query and uri.query.empty?
       uri
     end
@@ -413,7 +423,12 @@ module Faraday
     #
     # Returns a Faraday::Connection.
     def dup
-      self.class.new(build_exclusive_url, :headers => headers.dup, :params => params.dup, :builder => builder.dup, :ssl => ssl.dup)
+      self.class.new(build_exclusive_url,
+                     :headers => headers.dup,
+                     :params => params.dup,
+                     :builder => builder.dup,
+                     :ssl => ssl.dup,
+                     :request => options.dup)
     end
 
     # Internal: Yields username and password extracted from a URI if they both exist.
@@ -428,5 +443,42 @@ module Faraday
         header(*args)
       headers[Faraday::Request::Authorization::KEY] = header
     end
+
+    def proxy_from_env(url)
+      return if Faraday.ignore_env_proxy
+      uri = nil
+      if URI.parse('').respond_to?(:find_proxy)
+        case url
+        when String
+            uri = Utils.URI(url)
+            uri = URI.parse("#{uri.scheme}://#{uri.hostname}").find_proxy
+          when URI
+            uri = url.find_proxy
+          when nil
+            uri = find_default_proxy
+        end
+      else
+        warn 'no_proxy is unsupported' if ENV['no_proxy'] || ENV['NO_PROXY']
+        uri = find_default_proxy
+      end
+      ProxyOptions.from(uri) if uri
+    end
+
+    def find_default_proxy
+      uri = ENV['http_proxy']
+      if uri && !uri.empty?
+        uri = 'http://' + uri if uri !~ /^http/i
+        uri
+      end
+    end
+
+    def proxy_for_request(url)
+      return self.proxy if @manual_proxy
+      if url && Utils.URI(url).absolute?
+        proxy_from_env(url)
+      else
+        self.proxy
+      end
+    end
   end
 end

data/lib/faraday/error.rb

@@ -1,9 +1,8 @@
 module Faraday
   class Error < StandardError; end
-  class MissingDependency < Error; end
 
   class ClientError < Error
-    attr_reader :response
+    attr_reader :response, :wrapped_exception
 
     def initialize(ex, response = nil)
       @wrapped_exception = nil
@@ -29,7 +28,17 @@ module Faraday
     end
 
     def inspect
-      %(#<#{self.class}>)
+      inner = ''
+      if @wrapped_exception
+        inner << " wrapped=#{@wrapped_exception.inspect}"
+      end
+      if @response
+        inner << " response=#{@response.inspect}"
+      end
+      if inner.empty?
+        inner << " #{super}"
+      end
+      %(#<#{self.class}#{inner}>)
     end
   end
 
@@ -46,8 +55,12 @@ module Faraday
   class SSLError < ClientError
   end
 
-  [:MissingDependency, :ClientError, :ConnectionFailed, :ResourceNotFound,
-   :ParsingError, :TimeoutError, :SSLError].each do |const|
+  class RetriableResponse < ClientError; end
+
+  [:ClientError, :ConnectionFailed, :ResourceNotFound,
+   :ParsingError, :TimeoutError, :SSLError, :RetriableResponse].each do |const|
     Error.const_set(const, Faraday.const_get(const))
   end
+
+
 end