httpi 1.1.1 → 2.0.0.rc1

data/lib/httpi.rb

@@ -1,7 +1,12 @@
 require "logger"
+
 require "httpi/version"
 require "httpi/request"
-require "httpi/adapter"
+
+require "httpi/adapter/httpclient"
+require "httpi/adapter/curb"
+require "httpi/adapter/net_http"
+require "httpi/adapter/em_http"
 
 # = HTTPI
 #
@@ -12,12 +17,12 @@ require "httpi/adapter"
 #
 # == GET
 #
-#   request = HTTPI::Request.new :url => "http://example.com"
-#   HTTPI.get request, :httpclient
+#   request = HTTPI::Request.new("http://example.com")
+#   HTTPI.get(request, :httpclient)
 #
 # === Shortcuts
 #
-#   HTTPI.get "http://example.com", :curb
+#   HTTPI.get("http://example.com", :curb)
 #
 # == POST
 #
@@ -25,20 +30,20 @@ require "httpi/adapter"
 #   request.url = "http://example.com"
 #   request.body = "<some>xml</some>"
 #
-#   HTTPI.post request, :httpclient
+#   HTTPI.post(request, :httpclient)
 #
 # === Shortcuts
 #
-#   HTTPI.post "http://example.com", "<some>xml</some>", :curb
+#   HTTPI.post("http://example.com", "<some>xml</some>", :curb)
 #
 # == HEAD
 #
-#   request = HTTPI::Request.new :url => "http://example.com"
-#   HTTPI.head request, :httpclient
+#   request = HTTPI::Request.new("http://example.com")
+#   HTTPI.head(request, :httpclient)
 #
 # === Shortcuts
 #
-#   HTTPI.head "http://example.com", :curb
+#   HTTPI.head("http://example.com", :curb)
 #
 # == PUT
 #
@@ -46,20 +51,20 @@ require "httpi/adapter"
 #   request.url = "http://example.com"
 #   request.body = "<some>xml</some>"
 #
-#   HTTPI.put request, :httpclient
+#   HTTPI.put(request, :httpclient)
 #
 # === Shortcuts
 #
-#   HTTPI.put "http://example.com", "<some>xml</some>", :curb
+#   HTTPI.put("http://example.com", "<some>xml</some>", :curb)
 #
 # == DELETE
 #
-#   request = HTTPI::Request.new :url => "http://example.com"
-#   HTTPI.delete request, :httpclient
+#   request = HTTPI::Request.new("http://example.com")
+#   HTTPI.delete(request, :httpclient)
 #
 # === Shortcuts
 #
-#   HTTPI.delete "http://example.com", :curb
+#   HTTPI.delete("http://example.com", :curb)
 #
 # == More control
 #
@@ -73,64 +78,61 @@ module HTTPI
 
   REQUEST_METHODS = [:get, :post, :head, :put, :delete]
 
-  DEFAULT_LOG_LEVEL = :warn
+  DEFAULT_LOG_LEVEL = :debug
+
+  class Error < StandardError; end
+  class TimeoutError < Error; end
+  class NotSupportedError < Error; end
+  class NotImplementedError < Error; end
+
+  class SSLError < Error
+    def initialize(message = nil, original = $!)
+      super(message)
+      @original = original
+    end
+    attr_reader :original
+  end
 
   class << self
 
     # Executes an HTTP GET request.
     def get(request, adapter = nil)
-      request = Request.new :url => request if request.kind_of? String
-
-      with_adapter :get, request, adapter do |adapter|
-        yield adapter.client if block_given?
-        adapter.get request
-      end
+      request = Request.new(request) if request.kind_of? String
+      request(:get, request, adapter)
     end
 
     # Executes an HTTP POST request.
     def post(*args)
       request, adapter = request_and_adapter_from(args)
-
-      with_adapter :post, request, adapter do |adapter|
-        yield adapter.client if block_given?
-        adapter.post request
-      end
+      request(:post, request, adapter)
     end
 
     # Executes an HTTP HEAD request.
     def head(request, adapter = nil)
-      request = Request.new :url => request if request.kind_of? String
-
-      with_adapter :head, request, adapter do |adapter|
-        yield adapter.client if block_given?
-        adapter.head request
-      end
+      request = Request.new(request) if request.kind_of? String
+      request(:head, request, adapter)
     end
 
     # Executes an HTTP PUT request.
     def put(*args)
       request, adapter = request_and_adapter_from(args)
-
-      with_adapter :put, request, adapter do |adapter|
-        yield adapter.client if block_given?
-        adapter.put request
-      end
+      request(:put, request, adapter)
     end
 
     # Executes an HTTP DELETE request.
     def delete(request, adapter = nil)
-      request = Request.new :url => request if request.kind_of? String
-
-      with_adapter :delete, request, adapter do |adapter|
-        yield adapter.client if block_given?
-        adapter.delete request
-      end
+      request = Request.new(request) if request.kind_of? String
+      request(:delete, request, adapter)
     end
 
     # Executes an HTTP request for the given +method+.
     def request(method, request, adapter = nil)
-      raise ArgumentError, "Invalid request method: #{method}" unless REQUEST_METHODS.include? method
-      send method, request, adapter
+      adapter_class = load_adapter(adapter, request)
+
+      yield adapter_class.client if block_given?
+      log_request(method, request, Adapter.identify(adapter_class.class))
+
+      adapter_class.request(method)
     end
 
     # Shortcut for setting the default adapter to use.
@@ -151,7 +153,7 @@ module HTTPI
 
     # Returns the logger. Defaults to an instance of +Logger+ writing to STDOUT.
     def logger
-      @logger ||= ::Logger.new STDOUT
+      @logger ||= ::Logger.new($stdout)
     end
 
     # Sets the log level.
@@ -174,23 +176,19 @@ module HTTPI
       @log_level = nil
     end
 
-  private
+    private
 
-    # Checks whether +args+ contains of an <tt>HTTPI::Request</tt> or a URL
-    # and a request body plus an optional adapter and returns an Array with
-    # an <tt>HTTPI::Request</tt> and (if given) an adapter.
     def request_and_adapter_from(args)
       return args if args[0].kind_of? Request
       [Request.new(:url => args[0], :body => args[1]), args[2]]
     end
 
-    # Expects a request +method+, a +request+ and an +adapter+ (defaults to
-    # <tt>Adapter.use</tt>) and yields an instance of the adapter to a given block.
-    def with_adapter(method, request, adapter)
-      adapter, adapter_class = Adapter.load adapter
+    def load_adapter(adapter, request)
+      Adapter.load(adapter).new(request)
+    end
 
-      log "HTTPI executes HTTP #{method.to_s.upcase} using the #{adapter} adapter"
-      yield adapter_class.new(request)
+    def log_request(method, request, adapter)
+      log("HTTPI #{method.to_s.upcase} request to #{request.url.host} (#{adapter})")
     end
 
   end

data/lib/httpi/adapter.rb

@@ -1,7 +1,3 @@
-require "httpi/adapter/httpclient"
-require "httpi/adapter/curb"
-require "httpi/adapter/net_http"
-
 module HTTPI
 
   # = HTTPI::Adapter
@@ -10,19 +6,22 @@ module HTTPI
   #
   # * httpclient
   # * curb
+  # * em_http
   # * net/http
   module Adapter
 
-    ADAPTERS = {
-      :httpclient => { :class => HTTPClient, :require => "httpclient" },
-      :curb       => { :class => Curb,       :require => "curb" },
-      :net_http   => { :class => NetHTTP,    :require => "net/https" }
-    }
+    ADAPTERS = {}
+    ADAPTER_CLASS_MAP = {}
 
-    LOAD_ORDER = [:httpclient, :curb, :net_http]
+    LOAD_ORDER = [:httpclient, :curb, :em_http, :net_http]
 
     class << self
 
+      def register(name, adapter_class, deps)
+        ADAPTERS[name] = { :class => adapter_class, :deps => deps }
+        ADAPTER_CLASS_MAP[adapter_class] = name
+      end
+
       def use=(adapter)
         return @adapter = nil if adapter.nil?
 
@@ -35,16 +34,28 @@ module HTTPI
         @adapter ||= default_adapter
       end
 
+      def identify(adapter_class)
+        ADAPTER_CLASS_MAP[adapter_class]
+      end
+
       def load(adapter)
-        adapter = adapter ? validate_adapter!(adapter) : use
-        [adapter, ADAPTERS[adapter][:class]]
+        adapter ||= use
+
+        validate_adapter!(adapter)
+        load_adapter(adapter)
+        ADAPTERS[adapter][:class]
       end
 
-    private
+      def load_adapter(adapter)
+        ADAPTERS[adapter][:deps].each do |dep|
+          require dep
+        end
+      end
+
+      private
 
       def validate_adapter!(adapter)
         raise ArgumentError, "Invalid HTTPI adapter: #{adapter}" unless ADAPTERS[adapter]
-        adapter
       end
 
       def default_adapter
@@ -58,10 +69,6 @@ module HTTPI
         end
       end
 
-      def load_adapter(adapter)
-        require ADAPTERS[adapter][:require]
-      end
-
     end
   end
 end

data/lib/httpi/adapter/base.rb

@@ -0,0 +1,35 @@
+require "httpi"
+require "httpi/adapter"
+
+module HTTPI
+  module Adapter
+
+    # HTTPI::Adapter::Base
+    #
+    # Allows you to build your own adapter by implementing all public instance methods.
+    # Register your adapter by calling the base class' .register method.
+    class Base
+
+      # Registers an adapter.
+      def self.register(name, options = {})
+        deps = options.fetch(:deps, [])
+        Adapter.register(name, self, deps)
+      end
+
+      def initialize(request)
+      end
+
+      # Returns a client instance.
+      def client
+        raise NotImplementedError, "Adapters need to implement a #client method"
+      end
+
+      # Executes arbitrary HTTP requests.
+      # @see HTTPI.request
+      def request(method)
+        raise NotImplementedError, "Adapters need to implement a #request method"
+      end
+
+    end
+  end
+end

data/lib/httpi/adapter/curb.rb

@@ -1,3 +1,4 @@
+require "httpi/adapter/base"
 require "httpi/response"
 
 module HTTPI
@@ -7,89 +8,87 @@ module HTTPI
     #
     # Adapter for the Curb client.
     # http://rubygems.org/gems/curb
-    class Curb
+    class Curb < Base
 
-      def initialize(request = nil)
-      end
-
-      # Returns a memoized <tt>Curl::Easy</tt> instance.
-      def client
-        @client ||= Curl::Easy.new
-      end
+      register :curb, :deps => %w(curb)
 
-      # Executes an HTTP GET request.
-      # @see HTTPI.get
-      def get(request)
-        do_request(request) { |client| client.http_get }
+      def initialize(request)
+        @request = request
+        @client = Curl::Easy.new
       end
 
-      # Executes an HTTP POST request.
-      # @see HTTPI.post
-      def post(request)
-        do_request(request) { |client| client.http_post request.body }
-      end
+      attr_reader :client
 
-      # Executes an HTTP HEAD request.
-      # @see HTTPI.head
-      def head(request)
-        do_request(request) { |client| client.http_head }
-      end
+      def request(method)
+        unless REQUEST_METHODS.include? method
+          raise NotSupportedError, "Curb does not support custom HTTP methods"
+        end
 
-      # Executes an HTTP PUT request.
-      # @see HTTPI.put
-      def put(request)
-        do_request(request) { |client| client.http_put request.body }
-      end
+        arguments = ["http_#{method}"]
+        if [:put, :post].include? method
+          arguments << (@request.body || "")
+        end
 
-      # Executes an HTTP DELETE request.
-      # @see HTTPI.delete
-      def delete(request)
-        do_request(request) { |client| client.http_delete }
+        do_request { |client| client.send(*arguments) }
+      rescue Curl::Err::SSLCACertificateError
+        raise SSLError
+      rescue Curl::Err::SSLPeerCertificateError
+        raise SSLError
       end
 
-    private
+      private
 
-      def do_request(request)
-        setup_client request
-        yield client
-        respond_with client
+      def do_request
+        setup_client
+        yield @client
+        respond_with @client
       end
 
-      def setup_client(request)
-        basic_setup request
-        setup_http_auth request if request.auth.http?
-        setup_gssnegotiate_auth request if request.auth.gssnegotiate?
-        setup_ssl_auth request.auth.ssl if request.auth.ssl?
+      def setup_client
+        basic_setup
+        setup_http_auth if @request.auth.http?
+        setup_gssnegotiate_auth if @request.auth.gssnegotiate?
+        setup_ssl_auth if @request.auth.ssl?
       end
 
-      def basic_setup(request)
-        client.url = request.url.to_s
-        client.proxy_url = request.proxy.to_s if request.proxy
-        client.timeout = request.read_timeout if request.read_timeout
-        client.connect_timeout = request.open_timeout if request.open_timeout
-        client.headers = request.headers.to_hash
-        client.verbose = false
+      def basic_setup
+        @client.url = @request.url.to_s
+        @client.proxy_url = @request.proxy.to_s if @request.proxy
+        @client.timeout = @request.read_timeout if @request.read_timeout
+        @client.connect_timeout = @request.open_timeout if @request.open_timeout
+        @client.headers = @request.headers.to_hash
+        @client.verbose = false
       end
 
-      def setup_http_auth(request)
-        client.http_auth_types = request.auth.type
-        client.username, client.password = *request.auth.credentials
+      def setup_http_auth
+        @client.http_auth_types = @request.auth.type
+        @client.username, @client.password = *@request.auth.credentials
       end
 
-      def setup_gssnegotiate_auth(request)
-        client.http_auth_types = request.auth.type
+      def setup_gssnegotiate_auth
+        @client.http_auth_types = @request.auth.type
         # The curl man page (http://curl.haxx.se/docs/manpage.html) says that
         # you have to specify a fake username when using Negotiate auth, and
         # they use ':' in their example.
-        client.username = ':'
+        @client.username = ':'
       end
 
-      def setup_ssl_auth(ssl)
-        client.cert_key = ssl.cert_key_file
-        client.cert = ssl.cert_file
-        client.cacert = ssl.ca_cert_file if ssl.ca_cert_file
-        client.certtype = ssl.cert_type.to_s.upcase
-        client.ssl_verify_peer = ssl.verify_mode == :peer
+      def setup_ssl_auth
+        ssl = @request.auth.ssl
+
+        unless ssl.verify_mode == :none
+          @client.cert_key = ssl.cert_key_file
+          @client.cert = ssl.cert_file
+          @client.cacert = ssl.ca_cert_file if ssl.ca_cert_file
+          @client.certtype = ssl.cert_type.to_s.upcase
+        end
+
+        @client.ssl_verify_peer = ssl.verify_mode == :peer
+        @client.ssl_version = case ssl.ssl_version
+          when :TLSv1 then 1
+          when :SSLv2 then 2
+          when :SSLv3 then 3
+        end
       end
 
       def respond_with(client)