faraday 0.7.6 → 0.8.0.rc2

data/faraday.gemspec

@@ -1,47 +1,22 @@
-## This is the rakegem gemspec template. Make sure you read and understand
-## all of the comments. Some sections require modification, and others can
-## be deleted if you don't need them. Once you understand the contents of
-## this file, feel free to delete any comments that begin with two hash marks.
-## You can find comprehensive Gem::Specification documentation, at
-## http://docs.rubygems.org/read/chapter/20
 Gem::Specification.new do |s|
   s.specification_version = 2 if s.respond_to? :specification_version=
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.5") if s.respond_to? :required_rubygems_version=
 
-  ## Leave these as is they will be modified for you by the rake gemspec task.
-  ## If your rubyforge_project name is different, then edit it and comment out
-  ## the sub! line in the Rakefile
-  s.name              = 'faraday'
-  s.version           = '0.7.6'
-  s.date              = '2012-01-21'
-  s.rubyforge_project = 'faraday'
+  s.name    = 'faraday'
+  s.version = '0.8.0.rc2'
 
-  ## Make sure your summary is short. The description may be as long
-  ## as you like.
   s.summary     = "HTTP/REST API client library."
-  s.description = "HTTP/REST API client library."
+  # TODO: s.description
 
-  ## List the primary authors. If there are a bunch of authors, it's probably
-  ## better to set the email to an email list or something. If you don't have
-  ## a custom homepage, consider using your GitHub URL or the like.
   s.authors  = ["Rick Olson"]
   s.email    = 'technoweenie@gmail.com'
-  s.homepage = 'http://github.com/technoweenie/faraday'
+  s.homepage = 'https://github.com/technoweenie/faraday'
 
-  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
-  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
-  s.require_paths = %w[lib]
-
-  s.add_dependency 'addressable', '~> 2.2'
   s.add_dependency 'multipart-post', '~> 1.1'
-  s.add_dependency 'rack', '~> 1.1'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'test-unit'
   s.add_development_dependency 'webmock'
 
-  ## Leave this section as-is. It will be automatically generated from the
-  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
-  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
   # = MANIFEST =
   s.files = %w[
     Gemfile
@@ -53,7 +28,9 @@ Gem::Specification.new do |s|
     lib/faraday.rb
     lib/faraday/adapter.rb
     lib/faraday/adapter/action_dispatch.rb
+    lib/faraday/adapter/em_http.rb
     lib/faraday/adapter/em_synchrony.rb
+    lib/faraday/adapter/em_synchrony/parallel_manager.rb
     lib/faraday/adapter/excon.rb
     lib/faraday/adapter/net_http.rb
     lib/faraday/adapter/patron.rb
@@ -64,8 +41,10 @@ Gem::Specification.new do |s|
     lib/faraday/error.rb
     lib/faraday/middleware.rb
     lib/faraday/request.rb
-    lib/faraday/request/json.rb
+    lib/faraday/request/basic_authentication.rb
     lib/faraday/request/multipart.rb
+    lib/faraday/request/retry.rb
+    lib/faraday/request/token_authentication.rb
     lib/faraday/request/url_encoded.rb
     lib/faraday/response.rb
     lib/faraday/response/logger.rb
@@ -77,17 +56,17 @@ Gem::Specification.new do |s|
     test/adapters/net_http_test.rb
     test/adapters/test_middleware_test.rb
     test/adapters/typhoeus_test.rb
+    test/authentication_middleware_test.rb
     test/connection_test.rb
     test/env_test.rb
     test/helper.rb
     test/live_server.rb
+    test/middleware/retry_test.rb
     test/middleware_stack_test.rb
     test/request_middleware_test.rb
     test/response_middleware_test.rb
   ]
   # = MANIFEST =
 
-  ## Test files will be grabbed from the file list. Make sure the path glob
-  ## matches what you actually use.
   s.test_files = s.files.select { |path| path =~ %r{^test/*/.+\.rb} }
 end

data/lib/faraday.rb

@@ -1,7 +1,8 @@
 module Faraday
-  VERSION = "0.7.6"
+  VERSION = "0.8.0.rc2"
 
   class << self
+    attr_accessor :root_path, :lib_path
     attr_accessor :default_adapter
     attr_writer   :default_connection
 
@@ -10,29 +11,54 @@ module Faraday
       Faraday::Connection.new(url, options, &block)
     end
 
+    def require_libs(*libs)
+      libs.each do |lib|
+        require "#{lib_path}/#{lib}"
+      end
+    end
+
+    alias require_lib require_libs
+
   private
     def method_missing(name, *args, &block)
       default_connection.send(name, *args, &block)
     end
   end
 
+  self.root_path = File.expand_path "..", __FILE__
+  self.lib_path = File.expand_path "../faraday", __FILE__
   self.default_adapter = :net_http
 
   def self.default_connection
     @default_connection ||= Connection.new
   end
 
-  module AutoloadHelper
-    def register_lookup_modules(mods)
-      (@lookup_module_index ||= {}).update(mods)
+  module MiddlewareRegistry
+    # Internal: Register middleware class(es) on the current module.
+    #
+    # mapping - A Hash mapping Symbol keys to classes. See
+    #           Faraday.register_middleware for more details.
+    def register_middleware(mapping)
+      (@registered_middleware ||= {}).update(mapping)
     end
 
-    def lookup_module(key)
-      return if !@lookup_module_index
-      const_get @lookup_module_index[key] || key
+    # Internal: Lookup middleware class with a registered Symbol shortcut.
+    #
+    # Returns a middleware Class.
+    def lookup_middleware(key)
+      unless defined? @registered_middleware and found = @registered_middleware[key]
+        raise "#{key.inspect} is not registered on #{self}"
+      end
+      found = @registered_middleware[key] = found.call if found.is_a? Proc
+      found.is_a?(Module) ? found : const_get(found)
     end
+  end
 
+  module AutoloadHelper
     def autoload_all(prefix, options)
+      if prefix =~ /^faraday(\/|$)/i
+        prefix = File.join(Faraday.root_path, prefix)
+      end
       options.each do |const_name, path|
         autoload const_name, File.join(prefix, path)
       end
@@ -54,7 +80,30 @@ module Faraday
 
   extend AutoloadHelper
 
-  autoload_all 'faraday',
+  # Public: register middleware classes under a short name.
+  #
+  # type    - A Symbol specifying the kind of middleware (default: :middleware)
+  # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
+  #           as fully qualified constant, or a Proc that will be lazily called
+  #           to return the former.
+  #
+  # Examples
+  #
+  #   Faraday.register_middleware :aloha => MyModule::Aloha
+  #   Faraday.register_middleware :response, :boom => MyModule::Boom
+  #
+  #   # shortcuts are now available in Builder:
+  #   builder.use :aloha
+  #   builder.response :boom
+  #
+  # Returns nothing.
+  def self.register_middleware type, mapping = nil
+    type, mapping = :middleware, type if mapping.nil?
+    component = self.const_get(type.to_s.capitalize)
+    component.register_middleware(mapping)
+  end
+
+  autoload_all "faraday",
     :Middleware      => 'middleware',
     :Builder         => 'builder',
     :Request         => 'request',
@@ -62,12 +111,10 @@ module Faraday
     :CompositeReadIO => 'upload_io',
     :UploadIO        => 'upload_io',
     :Parts           => 'upload_io'
+
+  require_libs "utils", "connection", "adapter", "error"
 end
 
-require 'faraday/utils'
-require 'faraday/connection'
-require 'faraday/adapter'
-require 'faraday/error'
 
 # not pulling in active-support JUST for this method.
 class Object

data/lib/faraday/adapter.rb

@@ -3,25 +3,41 @@ module Faraday
     CONTENT_LENGTH = 'Content-Length'.freeze
 
     extend AutoloadHelper
+    extend MiddlewareRegistry
 
     autoload_all 'faraday/adapter',
       :ActionDispatch => 'action_dispatch',
       :NetHttp        => 'net_http',
       :Typhoeus       => 'typhoeus',
       :EMSynchrony    => 'em_synchrony',
+      :EMHttp         => 'em_http',
       :Patron         => 'patron',
       :Excon          => 'excon',
       :Test           => 'test'
 
-    register_lookup_modules \
+    register_middleware \
       :action_dispatch => :ActionDispatch,
       :test            => :Test,
       :net_http        => :NetHttp,
       :typhoeus        => :Typhoeus,
       :patron          => :Patron,
       :em_synchrony    => :EMSynchrony,
+      :em_http         => :EMHttp,
       :excon           => :Excon
 
+    module Parallelism
+      attr_writer :supports_parallel
+      def supports_parallel?() @supports_parallel end
+
+      def inherited(subclass)
+        super
+        subclass.supports_parallel = self.supports_parallel?
+      end
+    end
+
+    extend Parallelism
+    self.supports_parallel = false
+
     def call(env)
       if !env[:body] and Connection::METHODS_WITH_BODIES.include? env[:method]
         # play nice and indicate we're sending an empty body

data/lib/faraday/adapter/em_http.rb

@@ -0,0 +1,204 @@
+module Faraday
+  class Adapter
+    # EventMachine adapter is useful for either asynchronous requests
+    # when in EM reactor loop or for making parallel requests in
+    # synchronous code.
+    class EMHttp < Faraday::Adapter
+
+      dependency 'em-http'
+
+      self.supports_parallel = true
+
+      def self.setup_parallel_manager(options = nil)
+        Manager.new
+      end
+
+      def call(env)
+        super
+        perform_request env
+        @app.call env
+      end
+
+      def perform_request(env)
+        if parallel?(env)
+          manager = env[:parallel_manager]
+          manager.add {
+            perform_single_request(env).
+              callback { env[:response].finish(env) }
+          }
+        else
+          unless EventMachine.reactor_running?
+            error = nil
+            # start EM, block until request is completed
+            EventMachine.run do
+              perform_single_request(env).
+                callback { EventMachine.stop }.
+                errback { |client|
+                  error = error_message(client)
+                  EventMachine.stop
+                }
+            end
+            raise_error(error) if error
+          else
+            # EM is running: instruct upstream that this is an async request
+            env[:parallel_manager] = true
+            perform_single_request(env).
+              callback { env[:response].finish(env) }.
+              errback {
+                # TODO: no way to communicate the error in async mode
+                raise NotImplementedError
+              }
+          end
+        end
+      end
+
+      # TODO: reuse the connection to support pipelining
+      def perform_single_request(env)
+        req = EventMachine::HttpRequest.new(env[:url], connection_config(env))
+        req.setup_request(env[:method], request_config(env)).callback { |client|
+          save_response(env, client.response_header.status, client.response) do |resp_headers|
+            client.response_header.each do |name, value|
+              resp_headers[name.to_sym] = value
+            end
+          end
+        }
+      end
+
+      def error_message(client)
+        client.error or "request failed"
+      end
+
+      def raise_error(msg)
+        errklass = Faraday::Error::ClientError
+        if msg == Errno::ETIMEDOUT
+          errklass = Faraday::Error::TimeoutError
+          msg = "request timed out"
+        elsif msg == Errno::ECONNREFUSED
+          errklass = Faraday::Error::ConnectionFailed
+          msg = "connection refused"
+        end
+        raise errklass, msg
+      end
+
+      def connection_config(env)
+        options = {}
+        configure_ssl(options, env)
+        configure_proxy(options, env)
+        configure_timeout(options, env)
+        options
+      end
+
+      def request_config(env)
+        options = {
+          :body => read_body(env),
+          :head => env[:request_headers],
+          # :keepalive => true,
+          # :file => 'path/to/file', # stream data off disk
+        }
+        configure_compression(options, env)
+        # configure_proxy_auth
+        # :proxy => {:authorization => [user, pass]}
+        # proxy[:username] && proxy[:password]
+        options
+      end
+
+      def read_body(env)
+        body = env[:body]
+        body.respond_to?(:read) ? body.read : body
+      end
+
+      def configure_ssl(options, env)
+        if ssl = env[:ssl]
+          # :ssl => {
+          #   :private_key_file => '/tmp/server.key',
+          #   :cert_chain_file => '/tmp/server.crt',
+          #   :verify_peer => false
+        end
+      end
+
+      def configure_proxy(options, env)
+        if proxy = request_options(env)[:proxy]
+          options[:proxy] = {
+            :host => proxy[:uri].host,
+            :port => proxy[:uri].port
+          }
+        end
+      end
+
+      def configure_timeout(options, env)
+        timeout, open_timeout = request_options(env).values_at(:timeout, :open_timeout)
+        options[:connect_timeout] = options[:inactivity_timeout] = timeout
+        options[:connect_timeout] = open_timeout if open_timeout
+      end
+
+      def configure_compression(options, env)
+        if env[:method] == :get and not options[:head].key? 'accept-encoding'
+          options[:head]['accept-encoding'] = 'gzip, compressed'
+        end
+      end
+
+      def request_options(env)
+        env[:request]
+      end
+
+      def parallel?(env)
+        !!env[:parallel_manager]
+      end
+
+      # The parallel manager is designed to start an EventMachine loop
+      # and block until all registered requests have been completed.
+      class Manager
+        def initialize
+          reset
+        end
+
+        def reset
+          @registered_procs = []
+          @num_registered = 0
+          @num_succeeded = 0
+          @errors = []
+          @running = false
+        end
+
+        def running?() @running end
+
+        def add
+          if running?
+            perform_request { yield }
+          else
+            @registered_procs << Proc.new
+          end
+          @num_registered += 1
+        end
+
+        def run
+          if @num_registered > 0
+            @running = true
+            EventMachine.run do
+              @registered_procs.each do |proc|
+                perform_request(&proc)
+              end
+            end
+            if @errors.size > 0
+              raise Faraday::Error::ClientError, @errors.first || "connection failed"
+            end
+          end
+        ensure
+          reset
+        end
+
+        def perform_request
+          client = yield
+          client.callback { @num_succeeded += 1; check_finished }
+          client.errback { @errors << client.error; check_finished }
+        end
+
+        def check_finished
+          if @num_succeeded + @errors.size == @num_registered
+            EventMachine.stop
+          end
+        end
+      end
+    end
+  end
+end