faraday 0.5.7 → 0.6.0

data/lib/faraday/adapter/net_http.rb

@@ -1,7 +1,7 @@
 begin
   require 'net/https'
 rescue LoadError
-  puts "no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
+  warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
   require 'net/http'
 end
 
@@ -10,53 +10,55 @@ module Faraday
     class NetHttp < Faraday::Adapter
       def call(env)
         super
+        url = env[:url]
+        req = env[:request]
 
-        is_ssl = env[:url].scheme == 'https'
+        http = net_http_class(env).new(url.host, url.inferred_port)
 
-        http = net_http_class(env).new(env[:url].host, env[:url].port || (is_ssl ? 443 : 80))
-        if http.use_ssl = is_ssl
+        if http.use_ssl = (url.scheme == 'https' && env[:ssl])
           ssl = env[:ssl]
-          if ssl[:verify] == false
-            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          else
-            http.verify_mode = ssl[:verify]
-          end
-          http.cert    = ssl[:client_cert] if ssl[:client_cert]
-          http.key     = ssl[:client_key]  if ssl[:client_key]
-          http.ca_file = ssl[:ca_file]     if ssl[:ca_file]
+          http.verify_mode = ssl[:verify_mode] || ssl.fetch(:verify, true) ?
+                               OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+          http.cert        = ssl[:client_cert] if ssl[:client_cert]
+          http.key         = ssl[:client_key]  if ssl[:client_key]
+          http.ca_file     = ssl[:ca_file]     if ssl[:ca_file]
+          http.cert_store  = ssl[:cert_store]  if ssl[:cert_store]
         end
-        req = env[:request]
+
         http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-        http.open_timeout = req[:open_timeout]               if req[:open_timeout]
+        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
 
-        full_path = full_path_for(env[:url].path, env[:url].query, env[:url].fragment)
-        http_req  = Net::HTTPGenericRequest.new(
-          env[:method].to_s.upcase,    # request method
-          (env[:body] ? true : false), # is there data
-          true,                        # does net/http love you, true or false?
-          full_path,                   # request uri path
-          env[:request_headers])       # request headers
+        if :get != env[:method]
+          http_request = Net::HTTPGenericRequest.new \
+            env[:method].to_s.upcase,    # request method
+            !!env[:body],                # is there data
+            true,                        # does net/http love you, true or false?
+            url.request_uri,             # request uri path
+            env[:request_headers]        # request headers
 
-        if env[:body].respond_to?(:read)
-          http_req.body_stream = env[:body]
-          env[:body] = nil
+          if env[:body].respond_to?(:read)
+            http_request.body_stream = env[:body]
+            env[:body] = nil
+          end
         end
 
-        http_resp = http.request http_req, env[:body]
-
-        resp_headers = {}
-        http_resp.each_header do |key, value|
-          resp_headers[key] = value
+        begin
+          http_response = if :get == env[:method]
+            # prefer `get` to `request` because the former handles gzip (ruby 1.9)
+            http.get url.request_uri, env[:request_headers]
+          else
+            http.request http_request, env[:body]
+          end
+        rescue Errno::ECONNREFUSED
+          raise Error::ConnectionFailed, $!
         end
 
-        env.update \
-          :status           => http_resp.code.to_i,
-          :response_headers => resp_headers,
-          :body             => http_resp.body
+        http_response.each_header do |key, value|
+          response_headers(env)[key] = value
+        end
+        env.update :status => http_response.code.to_i, :body => http_response.body
 
         @app.call env
-      rescue Errno::ECONNREFUSED => e
-        raise Error::ConnectionFailed.new(e)
       end
 
       def net_http_class(env)

data/lib/faraday/adapter/patron.rb

@@ -1,37 +1,30 @@
 module Faraday
   class Adapter
     class Patron < Faraday::Adapter
-      begin
-        require 'patron'
-      rescue LoadError, NameError => e
-        self.load_error = e
-      end
+      dependency 'patron'
 
       def call(env)
         super
 
-        sess = ::Patron::Session.new
-        args = [env[:method], env[:url].to_s, env[:request_headers]]
-        if Faraday::Connection::METHODS_WITH_BODIES.include?(env[:method])
-          args.insert(2, env[:body].to_s)
+        # TODO: support streaming requests
+        env[:body] = env[:body].read if env[:body].respond_to? :read
+
+        session = ::Patron::Session.new
+
+        response = begin
+          if Connection::METHODS_WITH_BODIES.include? env[:method]
+            session.send(env[:method], env[:url].to_s, env[:body].to_s, env[:request_headers])
+          else
+            session.send(env[:method], env[:url].to_s, env[:request_headers])
+          end
+        rescue Errno::ECONNREFUSED
+          raise Error::ConnectionFailed, $!
         end
-        resp = sess.send *args
 
-        env.update \
-          :status           => resp.status,
-          :response_headers => resp.headers.
-            inject({}) { |memo, (k, v)| memo.update(k.downcase => v) },
-          :body             => resp.body
+        env.update :status => response.status, :body => response.body
+        response_headers(env).update response.headers
 
         @app.call env
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed.new(Errno::ECONNREFUSED)
-      end
-
-      # TODO: build in support for multipart streaming if patron supports it.
-      def create_multipart(env, params, boundary = nil)
-        stream = super
-        stream.read
       end
     end
   end

data/lib/faraday/adapter/test.rb

@@ -11,7 +11,7 @@ module Faraday
     # resp = test.get '/nigiri/sake.json'
     # resp.body # => 'hi world'
     #
-    class Test < Middleware
+    class Test < Faraday::Adapter
       attr_accessor :stubs
 
       def self.loaded?() false end
@@ -105,24 +105,18 @@ module Faraday
       end
 
       def call(env)
+        super
         normalized_path = Faraday::Utils.normalize_path(env[:url])
 
         if stub = stubs.match(env[:method], normalized_path, env[:body])
           status, headers, body = stub.block.call(env)
-          env.update \
-            :status           => status,
-            :response_headers => headers,
-            :body             => body
+          env.update :status => status, :body => body
+          response_headers(env).update headers
         else
           raise "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"
         end
         @app.call(env)
       end
-
-      def create_multipart(env, params, boundary = nil)
-        stream = super
-        stream.read
-      end
     end
   end
 end

data/lib/faraday/adapter/typhoeus.rb

@@ -7,20 +7,19 @@ module Faraday
         options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
       end
 
-      begin
-        require 'typhoeus'
-      rescue LoadError, NameError => e
-        self.load_error = e
-      end
+      dependency 'typhoeus'
 
       def call(env)
         super
 
-        req   = ::Typhoeus::Request.new env[:url].to_s,
+        # TODO: support streaming requests
+        env[:body] = env[:body].read if env[:body].respond_to? :read
+
+        req = ::Typhoeus::Request.new env[:url].to_s,
           :method  => env[:method],
           :body    => env[:body],
           :headers => env[:request_headers],
-          :disable_ssl_peer_verification => (env[:ssl][:verify] == false)
+          :disable_ssl_peer_verification => (env[:ssl] && !env[:ssl].fetch(:verify, true))
 
         env_req = env[:request]
         req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
@@ -28,45 +27,18 @@ module Faraday
 
         is_parallel = !!env[:parallel_manager]
         req.on_complete do |resp|
-          env.update \
-            :status           => resp.code,
-            :response_headers => parse_response_headers(resp.headers),
-            :body             => resp.body
-          env[:response].finish(env) if !is_parallel
+          env.update :status => resp.code, :body => resp.body
+          response_headers(env).parse resp.headers
+          env[:response].finish(env) if is_parallel
         end
 
         hydra = env[:parallel_manager] || self.class.setup_parallel_manager
         hydra.queue req
-
-        if !is_parallel
-          hydra.run
-        end
+        hydra.run unless is_parallel
 
         @app.call env
       rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed.new(Errno::ECONNREFUSED)
-      end
-
-      def in_parallel(options = {})
-        @hydra = ::Typhoeus::Hydra.new(options)
-        yield
-        @hydra.run
-        @hydra = nil
-      end
-
-      def parse_response_headers(header_string)
-        return {} unless header_string && !header_string.empty?
-        Hash[*header_string.split(/\r\n/).
-          tap    { |a|      a.shift           }. # drop the HTTP status line
-          map    { |h|      h.split(/:\s+/,2) }. # split key and value
-          reject { |(k, v)| k.nil?            }. # Ignore blank lines
-          map    { |(k, v)| [k.downcase, v]   }.flatten]
-      end
-
-      # TODO: build in support for multipart streaming if typhoeus supports it.
-      def create_multipart(env, params, boundary = nil)
-        stream = super
-        stream.read
+        raise Error::ConnectionFailed, $!
       end
     end
   end

data/lib/faraday/builder.rb

@@ -1,60 +1,84 @@
 module Faraday
   # Possibly going to extend this a bit.
   #
-  # Faraday::Connection.new(:url => 'http://sushi.com') do |b|
-  #   b.request  :yajl     # Faraday::Request::Yajl
-  #   b.adapter  :logger   # Faraday::Adapter::Logger
-  #   b.response :yajl     # Faraday::Response::Yajl
+  # Faraday::Connection.new(:url => 'http://sushi.com') do |builder|
+  #   builder.request  :url_encoded  # Faraday::Request::UrlEncoded
+  #   builder.adapter  :net_http     # Faraday::Adapter::NetHttp
   # end
   class Builder
     attr_accessor :handlers
 
     def self.create
-      block = block_given? ? Proc.new : nil
-      Builder.new(&block)
+      new { |builder| yield builder }
     end
 
-    def self.inner_app
-      lambda do |env|
-        env[:parallel_manager] ? env[:response] : env[:response].finish(env)
+    # borrowed from ActiveSupport::Dependencies::Reference &
+    # ActionDispatch::MiddlewareStack::Middleware
+    class Handler
+      @@constants = Hash.new { |h, k|
+        h[k] = k.respond_to?(:constantize) ? k.constantize : Object.const_get(k)
+      }
+
+      attr_reader :name
+
+      def initialize(klass, *args, &block)
+        @name = klass.to_s
+        @@constants[@name] = klass if klass.respond_to?(:name)
+        @args, @block = args, block
+      end
+
+      def klass() @@constants[@name] end
+      def inspect() @name end
+
+      def ==(other)
+        if other.respond_to? :name
+          klass == other
+        else
+          @name == other.to_s
+        end
+      end
+
+      def build(app)
+        klass.new(app, *@args, &@block)
       end
     end
 
     def initialize(handlers = [])
       @handlers = handlers
-      build(Proc.new) if block_given?
+      if block_given?
+        build(&Proc.new)
+      elsif @handlers.empty?
+        # default stack, if nothing else is configured
+        self.request :url_encoded
+        self.adapter Faraday.default_adapter
+      end
     end
 
     def build(options = {})
-      inner = @handlers.shift
-      if !options[:keep]
-        @handlers.clear
-      end
+      @handlers.clear unless options[:keep]
       yield self if block_given?
-      run(inner || self.class.inner_app)
     end
 
-    def [](index)
-      # @handlers are stored in reverse order
-      @handlers[-(index+1)]
+    def [](idx)
+      @handlers[idx]
     end
 
-    def run(app)
-      @handlers.unshift app
+    def ==(other)
+      other.is_a?(self.class) && @handlers == other.handlers
     end
 
-    def to_app
-      if @handlers.empty?
-        build { |b| b.adapter Faraday.default_adapter }
-      end
+    def dup
+      self.class.new(@handlers.dup)
+    end
 
-      inner_app = @handlers.first
-      @handlers[1..-1].inject(inner_app) { |app, middleware| middleware.call(app) }
+    def to_app(inner_app)
+      # last added handler is the deepest and thus closest to the inner app
+      @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
     end
 
     def use(klass, *args)
       block = block_given? ? Proc.new : nil
-      run(lambda { |app| klass.new(app, *args, &block) })
+      @handlers << self.class::Handler.new(klass, *args, &block)
     end
 
     def request(key, *args)
@@ -72,17 +96,42 @@ module Faraday
       use_symbol(Faraday::Adapter, key, *args, &block)
     end
 
+    ## methods to push onto the various positions in the stack:
+
+    def insert(index, *args, &block)
+      index = assert_index(index)
+      handler = self.class::Handler.new(*args, &block)
+      @handlers.insert(index, handler)
+    end
+
+    alias_method :insert_before, :insert
+
+    def insert_after(index, *args, &block)
+      index = assert_index(index)
+      insert(index + 1, *args, &block)
+    end
+
+    def swap(index, *args, &block)
+      index = assert_index(index)
+      @handlers.delete_at(index)
+      insert(index, *args, &block)
+    end
+
+    def delete(handler)
+      @handlers.delete(handler)
+    end
+
+    private
+
     def use_symbol(mod, key, *args)
       block = block_given? ? Proc.new : nil
       use(mod.lookup_module(key), *args, &block)
     end
 
-    def ==(other)
-      other.is_a?(self.class) && @handlers == other.handlers
-    end
-
-    def dup
-      self.class.new(@handlers.dup)
+    def assert_index(index)
+      idx = index.is_a?(Integer) ? index : @handlers.index(index)
+      raise "No such handler: #{index.inspect}" unless idx
+      idx
     end
   end
 end

data/lib/faraday/connection.rb

@@ -22,7 +22,7 @@ module Faraday
         options = url
         url     = options[:url]
       end
-      @headers          = HeaderHash.new
+      @headers          = Headers.new
       @params           = {}
       @options          = options[:request] || {}
       @ssl              = options[:ssl]     || {}
@@ -33,9 +33,7 @@ module Faraday
       merge_headers @headers, options[:headers] if options[:headers]
 
       if block_given?
-        block    = Proc.new
-        @builder = Builder.new
-        @builder.build { block.call(self) }
+        @builder = Builder.create { |b| yield b }
       else
         @builder = options[:builder] || Builder.new
       end
@@ -121,7 +119,7 @@ module Faraday
         case arg
           when String then {:uri => proxy_arg_to_uri(arg)}
           when URI    then {:uri => arg}
-          when Hash   then arg
+          when Hash
             if arg[:uri] = proxy_arg_to_uri(arg[:uri])
               arg
             else
@@ -164,11 +162,6 @@ module Faraday
       @path_prefix = value
     end
 
-    # return the assembled Rack application for this instance.
-    def to_app
-      @builder.to_app
-    end
-
     def run_request(method, url, body, headers)
       if !METHODS.include?(method)
         raise ArgumentError, "unknown http method: #{method}"