http 0.1.0 → 0.2.0

data/.travis.yml

@@ -1,5 +1,11 @@
 rvm:
   - 1.8.7
   - 1.9.2
-  - rbx
-  - jruby
+  - 1.9.3
+  - ree
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+  - rbx-18mode
+  - rbx-19mode

data/CHANGES.md

@@ -1,3 +1,9 @@
+0.2.0
+-----
+* Request and response objects
+* Callback system
+* Internal refactoring ensuring true chainability
+
 0.1.0
 -----
 * Testing against WEBrick

data/README.md

@@ -2,16 +2,10 @@ Http
 ====
 [![Build Status](http://travis-ci.org/tarcieri/http.png)](http://travis-ci.org/tarcieri/http)
 
-Ruby has always been this extremely web-focused language, and yet despite the
-selection of HTTP libraries out there, I always find myself falling back on
-Net::HTTP, and Net::HTTP sucks.
-
-Ruby should be simple and elegant and beautiful. Net::HTTP is not. I've often
-found myself falling back on the Perlish horrors of open-uri just because I
-found Net::HTTP to be too much of a pain. This shouldn't be!
-
 HTTP should be simple and easy! It should be so straightforward it makes
-you happy with how delightful it is to use!
+you happy every time you use it.
+
+The Http library makes it easy to construct requests using a simple chaining system.
 
 Making Requests
 ---------------
@@ -98,7 +92,8 @@ Contributing to Http
 
 * Fork Http on github
 * Make your changes and send me a pull request
-* If I like them I'll merge them and give you commit access to my repository
+* If I like them I'll merge them
+* If I've accepted a patch, feel free to ask for a commit bit!
 
 Copyright
 ---------

data/http.gemspec

@@ -2,10 +2,10 @@
 require File.expand_path('../lib/http/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Tony Arcieri", "Carl Lerche"]
+  gem.authors       = ["Tony Arcieri"]
   gem.email         = ["tony.arcieri@gmail.com"]
   gem.description   = "HTTP so awesome it will lure Catherine Zeta Jones into your unicorn petting zoo"
-  gem.summary       = "Made entirely of Ruby (and Ragel and C and Java)"
+  gem.summary       = "HTTP should be easy"
   gem.homepage      = "https://github.com/tarcieri/http"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
@@ -15,7 +15,9 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Http::VERSION
 
+  gem.add_dependency 'certified'
+
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '>= 2.6.0'
+  gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'json'
 end

data/lib/http.rb

@@ -1,15 +1,33 @@
 require 'http/version'
+
 require 'http/chainable'
 require 'http/client'
 require 'http/mime_type'
-require 'http/parameters'
+require 'http/options'
+require 'http/request'
 require 'http/response'
+require 'http/uri_backport' if RUBY_VERSION < "1.9.0"
 
 # THIS IS ENTIRELY TEMPORARY, I ASSURE YOU
 require 'net/https'
 require 'uri'
+require 'certified'
 
 # Http, it can be simple!
 module Http
   extend Chainable
+
+  # The method given was not understood
+  class UnsupportedMethodError < ArgumentError; end
+
+  # Valid HTTP methods
+  METHODS = [:get, :head, :post, :put, :delete, :trace, :options, :connect, :patch]
+
+  # Matches HTTP header names when in "Canonical-Http-Format"
+  CANONICAL_HEADER = /^[A-Z][a-z]*(-[A-Z][a-z]*)*$/
+
+  # Transform to canonical HTTP header capitalization
+  def self.canonicalize_header(header)
+    header.to_s.split('-').map(&:capitalize).join('-')
+  end
 end

data/lib/http/chainable.rb

@@ -2,7 +2,7 @@ module Http
   module Chainable
     # Request a get sans response body
     def head(uri, options = {})
-      request :head, uri, {:response => :object}.merge(options)
+      request :head, uri, options
     end
 
     # Get a resource
@@ -47,20 +47,17 @@ module Http
 
     # Make an HTTP request with the given verb
     def request(verb, uri, options = {})
-      options[:response] ||= :parsed_body
-
-      if options[:headers]
-        headers = default_headers.merge options[:headers]
-      else
-        headers = default_headers
-      end
+      branch(options).request verb, uri
+    end
 
-      Client.new(uri).request verb, options.merge(:headers => headers)
+    # Make a request invoking the given event callbacks
+    def on(event, &block)
+      branch default_options.with_callback(event, block)
     end
 
     # Make a request with the given headers
     def with_headers(headers)
-      Parameters.new default_headers.merge(headers)
+      branch default_options.with_headers(headers)
     end
     alias_method :with, :with_headers
 
@@ -75,12 +72,39 @@ module Http
       end
     end
 
+    def default_options
+      @default_options ||= Options.new
+    end
+
+    def default_options=(opts)
+      @default_options = Options.new(opts)
+    end
+
     def default_headers
-      @default_headers ||= {}
+      default_options.headers
     end
 
     def default_headers=(headers)
-      @default_headers = headers
+      @default_options = default_options.dup do |opts|
+        opts.headers = headers
+      end
     end
+
+    def default_callbacks
+      default_options.callbacks
+    end
+
+    def default_callbacks=(callbacks)
+      @default_options = default_options.dup do |opts|
+        opts.callbacks = callbacks
+      end
+    end
+
+    private
+
+    def branch(options)
+      Client.new(options)
+    end
+
   end
 end

data/lib/http/client.rb

@@ -1,99 +1,62 @@
+require 'uri'
+
 module Http
-  # We all know what HTTP clients are, right?
+  # Clients make requests and receive responses
   class Client
-    # I swear I'll document that nebulous options hash
-    def initialize(uri, options = {})
-      if uri.is_a? URI
-        @uri = uri
-      else
-        # Why the FUCK can't Net::HTTP do this?
-        @uri = URI(uri.to_s)
-      end
-
-      @options = {:response => :object}.merge(options)
-    end
+    include Chainable
 
-    # Request a get sans response body
-    def head(options = {})
-      request :head, options
-    end
+    attr_reader :default_options
 
-    # Get a resource
-    def get(options = {})
-      request :get, options
+    def initialize(default_options = {})
+      @default_options = Options.new(default_options)
     end
 
-    # Post to a resource
-    def post(options = {})
-      request :post, options
-    end
-
-    # Put to a resource
-    def put(options = {})
-      request :put, options
-    end
-
-    # Delete a resource
-    def delete(options = {})
-      request :delete, options
-    end
+    # Make an HTTP request
+    def request(method, uri, options = {})
+      opts = @default_options.merge(options)
+      headers = opts.headers
 
-    # Echo the request back to the client
-    def trace(options = {})
-      request :trace, options
-    end
+      if opts.form
+        body = URI.encode_www_form(opts.form)
+        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
+      end
 
-    # Return the methods supported on the given URI
-    def options(options = {})
-      request :options, options
-    end
+      request = Request.new method, uri, headers, body
 
-    # Convert to a transparent TCP/IP tunnel
-    def connect(options = {})
-      request :connect, options
-    end
+      opts.callbacks[:request].each { |c| c.call(request) }
+      response = perform request
+      opts.callbacks[:response].each { |c| c.call(response) }
 
-    # Apply partial modifications to a resource
-    def patch(options = {})
-      request :patch, options
+      format_response method, response, opts.response
     end
 
-    # Make an HTTP request
-    def request(verb, options = {})
-      # Red, green, refactor tomorrow :/
-      options = @options.merge(options)
-      raw_headers = options[:headers] || {}
-
-      # Stringify keys :/
-      headers = {}
-      raw_headers.each { |k,v| headers[k.to_s] = v }
-
-      http = Net::HTTP.new(@uri.host, @uri.port)
-
-      # Why the FUCK can't Net::HTTP do this either?!
-      http.use_ssl = true if @uri.is_a? URI::HTTPS
+    def perform(request)
+      uri = request.uri
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.is_a? URI::HTTPS
+      response = http.request request.to_net_http_request
 
-      request_class = Net::HTTP.const_get(verb.to_s.capitalize)
-      request = request_class.new(@uri.request_uri, headers)
-      request.set_form_data(options[:form]) if options[:form]
+      Http::Response.new.tap do |res|
+        response.each_header do |header, value|
+          res[header] = value
+        end
 
-      net_http_response = http.request(request)
-
-      response = Http::Response.new
-      net_http_response.each_header do |header, value|
-        response[header] = value
+        res.status = Integer(response.code)
+        res.body   = response.body
       end
-      response.status = Integer(net_http_response.code) # WTF again Net::HTTP
-      response.body   = net_http_response.body
+    end
 
-      case options[:response]
+    def format_response(method, response, option)
+      case option
+      when :auto, NilClass
+        method == :head ? response : response.parse_body
       when :object
         response
       when :parsed_body
         response.parse_body
       when :body
         response.body
-      else raise ArgumentError, "invalid response type: #{options[:response]}"
+      else raise ArgumentError, "invalid response type: #{option}"
       end
     end
   end

data/lib/http/compat/curb.rb

@@ -29,8 +29,9 @@ module Curl
     end
 
     def perform
-      client = Http::Client.new @url, :headers => @headers
-      response = client.send @method
+      client   = Http::Client.new
+      options  = {:response => :object, :headers => @headers}
+      response = client.request @method, @url, options
       @response_code, @body_str = response.code, response.body
       true
     rescue SocketError => ex

data/lib/http/options.rb

@@ -0,0 +1,109 @@
+module Http
+  class Options
+
+    # How to format the response [:object, :body, :parse_body] 
+    attr_accessor :response
+
+    # Http headers to include in the request
+    attr_accessor :headers
+
+    # Form data to embed in the request
+    attr_accessor :form
+
+    # Before callbacks 
+    attr_accessor :callbacks
+
+    protected :response=, :headers=, :form=, :callbacks=
+
+    def self.new(default = {})
+      return default if default.is_a?(Options)
+      super
+    end
+
+    def initialize(default = {})
+      @response  = default[:response]  || :auto
+      @headers   = default[:headers]   || {}
+      @form      = default[:form]      || nil
+      @callbacks = default[:callbacks] || {:request => [], :response => []}
+    end
+
+    def with_response(response)
+      unless [:auto, :object, :body, :parsed_body].include?(response)
+        argument_error! "invalid response type: #{response}"
+      end
+      dup do |opts| 
+        opts.response = response
+      end
+    end
+
+    def with_headers(headers)
+      unless headers.respond_to?(:to_hash)
+        argument_error! "invalid headers: #{headers}"
+      end
+      dup do |opts|
+        opts.headers = self.headers.merge(headers.to_hash)
+      end
+    end
+
+    def with_form(form)
+      dup do |opts|
+        opts.form = form
+      end
+    end
+
+    def with_callback(event, callback)
+      unless callback.respond_to?(:call)
+        argument_error! "invalid callback: #{callback}"
+      end
+      unless callback.respond_to?(:arity) and callback.arity == 1
+        argument_error! "callback must accept only one argument"
+      end
+      unless [:request, :response].include?(event)
+        argument_error! "invalid callback event: #{event}"
+      end
+      dup do |opts|
+        opts.callbacks = callbacks.dup
+        opts.callbacks[event] = (callbacks[event].dup << callback)
+      end
+    end
+
+    def [](option)
+      send(option) rescue nil
+    end
+
+    def merge(other)
+      h1, h2 = to_hash, other.to_hash
+      merged = h1.merge(h2) do |k,v1,v2|
+        case k
+        when :headers
+          v1.merge(v2)
+        when :callbacks
+          v1.merge(v2){|event,l,r| (l+r).uniq}
+        else
+          v2
+        end
+      end
+      Options.new(merged)
+    end
+
+    def to_hash
+      {:response  => response,
+       :headers   => headers,
+       :form      => form,
+       :callbacks => callbacks}
+    end
+
+    def dup
+      dupped = super
+      yield(dupped) if block_given?
+      dupped
+    end
+
+    private
+
+    def argument_error!(message)
+      raise ArgumentError, message, caller[1..-1]
+    end
+
+  end
+end