http 0.2.0 → 0.3.0

data/.travis.yml

@@ -3,9 +3,9 @@ rvm:
   - 1.9.2
   - 1.9.3
   - ree
-  - ruby-head
+#  - ruby-head
   - jruby-18mode
   - jruby-19mode
-  - jruby-head
+#  - jruby-head
   - rbx-18mode
   - rbx-19mode

data/CHANGES.md

@@ -1,8 +1,16 @@
+0.3.0
+-----
+* New implementation based on tmm1's http_parser.rb instead of Net::HTTP
+* Support for following redirects
+* Support for request body through {:body => ...} option
+* Http#with_response (through Chainable)
+
 0.2.0
 -----
 * Request and response objects
 * Callback system
 * Internal refactoring ensuring true chainability
+* Use the certified gem to ensure SSL certificate verification
 
 0.1.0
 -----

data/Gemfile

@@ -1,4 +1,6 @@
 source 'http://rubygems.org'
 
+gem 'jruby-openssl' if defined? JRUBY_VERSION
+
 # Specify your gem's dependencies in http.gemspec
 gemspec

data/README.md

@@ -1,6 +1,6 @@
 Http
 ====
-[![Build Status](http://travis-ci.org/tarcieri/http.png)](http://travis-ci.org/tarcieri/http)
+[![Build Status](https://secure.travis-ci.org/tarcieri/http.png?branch=master)](http://travis-ci.org/tarcieri/http)
 
 HTTP should be simple and easy! It should be so straightforward it makes
 you happy every time you use it.
@@ -24,6 +24,11 @@ Making POST requests is simple too. Want to POST a form?
 Http.post "http://example.com/resource", :form => {:foo => "42"}
 ```
 
+Want to POST with a specific body, JSON for instance?
+```ruby
+Http.post "http://example.com/resource", :body => JSON.dump(:foo => "42")
+```
+
 It's easy!
 
 Adding Headers
@@ -53,11 +58,14 @@ request and returns a response with Content-Type: application/json. If you
 happen to have a library loaded which defines the JSON constant and implements
 JSON.parse, the Http library will attempt to parse the JSON response.
 
-A shorter alias exists for HTTP.with_headers:
+Shorter aliases exists for HTTP.with_headers:
 
 ```ruby
 Http.with(:accept => 'application/json').
   get("https://github.com/tarcieri/http/commit/HEAD")
+
+Http[:accept => 'application/json'].
+  get("https://github.com/tarcieri/http/commit/HEAD")
 ```
 
 Content Negotiation

data/http.gemspec

@@ -15,7 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Http::VERSION
 
-  gem.add_dependency 'certified'
+  gem.add_runtime_dependency 'http_parser.rb'
+  gem.add_runtime_dependency 'certified'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'

data/lib/http.rb

@@ -1,3 +1,6 @@
+require 'uri'
+require 'certified'
+require 'http/parser'
 require 'http/version'
 
 require 'http/chainable'
@@ -6,14 +9,10 @@ require 'http/mime_type'
 require 'http/options'
 require 'http/request'
 require 'http/response'
+require 'http/response_parser'
 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!
+# HTTP should be easy
 module Http
   extend Chainable
 
@@ -26,8 +25,16 @@ module Http
   # 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('-')
+  # CRLF is the universal HTTP delimiter
+  CRLF = "\r\n"
+
+  class << self
+    # Http[:accept => 'text/html'].get(...)
+    alias_method :[], :with_headers
+
+    # Transform to canonical HTTP header capitalization
+    def canonicalize_header(header)
+      header.to_s.split(/[\-_]/).map(&:capitalize).join('-')
+    end
   end
 end

data/lib/http/chainable.rb

@@ -54,6 +54,31 @@ module Http
     def on(event, &block)
       branch default_options.with_callback(event, block)
     end
+    
+    # Make a request through an HTTP proxy
+    def via(*proxy)
+      proxy_hash = {}    
+      proxy_hash[:proxy_address] = proxy[0] if proxy[0].is_a? String
+      proxy_hash[:proxy_port]    = proxy[1] if proxy[1].is_a? Integer
+      proxy_hash[:proxy_username]= proxy[2] if proxy[2].is_a? String
+      proxy_hash[:proxy_password]= proxy[3] if proxy[3].is_a? String
+      
+      if proxy_hash.keys.size >=2
+        branch default_options.with_proxy(proxy_hash)
+      else
+        raise ArgumentError, "invalid HTTP proxy: #{proxy_hash}"
+      end
+    end
+    alias_method :through, :via
+
+    # Specify the kind of response to return (:auto, :object, :body, :parsed_body)
+    def with_response(response_type)
+      branch default_options.with_response(response_type)
+    end
+
+    def with_follow(follow)
+      branch default_options.with_follow(follow)
+    end
 
     # Make a request with the given headers
     def with_headers(headers)
@@ -105,6 +130,5 @@ module Http
     def branch(options)
       Client.new(options)
     end
-
   end
 end

data/lib/http/client.rb

@@ -5,45 +5,89 @@ module Http
   class Client
     include Chainable
 
+    BUFFER_SIZE = 4096 # Input buffer size
+
     attr_reader :default_options
 
     def initialize(default_options = {})
       @default_options = Options.new(default_options)
     end
 
+    def body(opts,headers)
+      if opts.body
+        body = opts.body
+      elsif opts.form
+        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
+        body = URI.encode_www_form(opts.form)
+      end
+    end
+
     # Make an HTTP request
     def request(method, uri, options = {})
       opts = @default_options.merge(options)
       headers = opts.headers
+      proxy = opts.proxy
 
-      if opts.form
-        body = URI.encode_www_form(opts.form)
-        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
-      end
+      method_body = body(opts, headers)
+      puts method_body
+      request = Request.new method, uri, headers, proxy, method_body
 
-      request = Request.new method, uri, headers, body
+      if opts.follow
+        code = 302
+        while code == 302 or code == 301
+          puts uri
+          method_body = body(opts, headers)
+          request = Request.new method, uri, headers, proxy, method_body
+          response = perform request, opts
+          code = response.code
+          uri = response.headers["Location"]
+        end
+      end
 
       opts.callbacks[:request].each { |c| c.call(request) }
-      response = perform request
+      response = perform request, opts
       opts.callbacks[:response].each { |c| c.call(response) }
 
       format_response method, response, opts.response
     end
 
-    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
+    def perform(request, options)
+      parser = Http::Response::Parser.new
+      uri, proxy = request.uri, request.proxy
+      socket = options[:socket_class].open(uri.host, uri.port) # TODO: proxy support
 
-      Http::Response.new.tap do |res|
-        response.each_header do |header, value|
-          res[header] = value
-        end
+      if uri.is_a?(URI::HTTPS)
+        socket = options[:ssl_socket_class].open(socket, options[:ssl_context])
+        socket.connect
+      end
+
+      request.stream socket
+
+      begin
+        parser << socket.readpartial(BUFFER_SIZE) until parser.headers
+      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+        # TODO: handle errors
+        raise "zomg IO troubles: #{$!.message}"
+      end
+
+      response = Http::Response.new(parser.status_code, parser.http_version, parser.headers) do
+        if @body_remaining and @body_remaining > 0
+          chunk = parser.chunk
+          unless chunk
+            parser << socket.readpartial(BUFFER_SIZE)
+            chunk = parser.chunk
+            return unless chunk
+          end
+
+          @body_remaining -= chunk.length
+          @body_remaining = nil if @body_remaining < 1
 
-        res.status = Integer(response.code)
-        res.body   = response.body
+          chunk
+        end
       end
+
+      @body_remaining = Integer(response['Content-Length']) if response['Content-Length']
+      response
     end
 
     def format_response(method, response, option)

data/lib/http/options.rb

@@ -1,7 +1,10 @@
+require 'socket'
+require 'openssl'
+
 module Http
   class Options
 
-    # How to format the response [:object, :body, :parse_body] 
+    # How to format the response [:object, :body, :parse_body]
     attr_accessor :response
 
     # Http headers to include in the request
@@ -10,28 +13,57 @@ module Http
     # Form data to embed in the request
     attr_accessor :form
 
-    # Before callbacks 
+    # Explicit request body of the request
+    attr_accessor :body
+
+    # Http proxy to route request
+    attr_accessor :proxy
+
+    # Before callbacks
     attr_accessor :callbacks
 
-    protected :response=, :headers=, :form=, :callbacks=
+    # Socket classes
+    attr_accessor :socket_class, :ssl_socket_class
+
+    # SSL context
+    attr_accessor :ssl_context
+
+    # Follow redirects
+    attr_accessor :follow
+
+    protected :response=, :headers=, :proxy=, :form=,  :callbacks=, :follow=
 
-    def self.new(default = {})
-      return default if default.is_a?(Options)
-      super
+    @default_socket_class     = TCPSocket
+    @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
+
+    class << self
+      attr_accessor :default_socket_class, :default_ssl_socket_class
+
+      def new(options = {})
+        return options if options.is_a?(Options)
+        super
+      end
     end
 
-    def initialize(default = {})
-      @response  = default[:response]  || :auto
-      @headers   = default[:headers]   || {}
-      @form      = default[:form]      || nil
-      @callbacks = default[:callbacks] || {:request => [], :response => []}
+    def initialize(options = {})
+      @response  = options[:response]  || :auto
+      @headers   = options[:headers]   || {}
+      @proxy     = options[:proxy]     || {}
+      @callbacks = options[:callbacks] || {:request => [], :response => []}
+      @body      = options[:body]
+      @form      = options[:form]
+      @follow    = options[:follow]
+
+      @socket_class     = options[:socket_class]     || self.class.default_socket_class
+      @ssl_socket_class = options[:ssl_socket_class] || self.class.default_ssl_socket_class
+      @ssl_context      = options[:ssl_context]
     end
 
     def with_response(response)
       unless [:auto, :object, :body, :parsed_body].include?(response)
         argument_error! "invalid response type: #{response}"
       end
-      dup do |opts| 
+      dup do |opts|
         opts.response = response
       end
     end
@@ -45,12 +77,30 @@ module Http
       end
     end
 
+    def with_proxy(proxy_hash)
+      dup do |opts|
+        opts.proxy = proxy_hash
+      end
+    end
+
     def with_form(form)
       dup do |opts|
         opts.form = form
       end
     end
 
+    def with_body(body)
+      dup do |opts|
+        opts.body = body
+      end
+    end
+
+    def with_follow(follow)
+      dup do |opts|
+        opts.follow = follow
+      end
+    end
+
     def with_callback(event, callback)
       unless callback.respond_to?(:call)
         argument_error! "invalid callback: #{callback}"
@@ -89,8 +139,11 @@ module Http
     def to_hash
       {:response  => response,
        :headers   => headers,
+       :proxy     => proxy,
        :form      => form,
-       :callbacks => callbacks}
+       :body      => body,
+       :callbacks => callbacks,
+       :follow    => follow}
     end
 
     def dup

data/lib/http/request.rb

@@ -6,10 +6,10 @@ module Http
     # "Request URI" as per RFC 2616
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
     attr_reader :uri
-    attr_reader :headers, :body, :version
+    attr_reader :headers, :proxy, :body, :version
 
     # :nodoc:
-    def initialize(method, uri, headers = {}, body = nil, version = "1.1")
+    def initialize(method, uri, headers = {}, proxy = {}, body = nil, version = "1.1")
       @method = method.to_s.downcase.to_sym
       raise UnsupportedMethodError, "unknown method: #{method}" unless METHODS.include? @method
 
@@ -23,7 +23,7 @@ module Http
         @headers[key] = value
       end
 
-      @body, @version = body, version
+      @proxy, @body, @version = proxy, body, version
     end
 
     # Obtain the given header
@@ -31,12 +31,40 @@ module Http
       @headers[Http.canonicalize_header(header)]
     end
 
-    # Create a Net::HTTP request from this request
-    def to_net_http_request
-      request_class = Net::HTTP.const_get(@method.to_s.capitalize)
-      request = request_class.new(@uri.request_uri, @headers)
-      request.body = @body
-      request
+    # Stream the request to a socket
+    def stream(socket)
+      request_header = "#{method.to_s.upcase} #{uri.path} HTTP/#{version}#{CRLF}"
+      @headers.each do |field, value|
+        request_header << "#{field}: #{value}#{CRLF}"
+      end
+
+      case body
+      when NilClass
+        socket << request_header << CRLF
+        return
+      when String
+        request_header << "Content-Length: #{body.length}#{CRLF}" unless @headers['Content-Length']
+        request_header << CRLF
+
+        socket << request_header
+        socket << body.to_s
+      when Enumerable
+        if encoding = @headers['Transfer-Encoding']
+          raise ArgumentError, "invalid transfer encoding" unless encoding == "chunked"
+          request_header << CRLF
+        else
+          request_header << "Transfer-Encoding: chunked#{CRLF * 2}"
+        end
+
+        socket << request_header
+        body.each do |chunk|
+          socket << chunk.bytesize.to_s(16) << CRLF
+          socket << chunk
+        end
+
+        socket << "0" << CRLF * 2
+      else raise TypeError, "invalid body type: #{body.class}"
+      end
     end
   end
 end

data/lib/http/response.rb

@@ -54,22 +54,25 @@ module Http
       507 => 'Insufficient Storage',
       510 => 'Not Extended'
     }
+    STATUS_CODES.freeze
 
     SYMBOL_TO_STATUS_CODE = Hash[STATUS_CODES.map { |code, msg| [msg.downcase.gsub(/\s|-/, '_').to_sym, code] }]
+    SYMBOL_TO_STATUS_CODE.freeze
 
-    attr_accessor :status
-    attr_accessor :headers
-    attr_accessor :body
+    attr_reader :status
+    attr_reader :headers
 
     # Status aliases! TIMTOWTDI!!! (Want to be idiomatic? Just use status :)
-    alias_method :code,  :status
-    alias_method :code=, :status=
+    alias_method :code,        :status
+    alias_method :status_code, :status
 
-    alias_method :status_code,  :status
-    alias_method :status_code=, :status
+    def initialize(status = nil, version = "1.1", headers = {}, body = nil, &body_proc)
+      @status, @version, @body, @body_proc = status, version, body, body_proc
 
-    def initialize
       @headers = {}
+      headers.each do |field, value|
+        @headers[Http.canonicalize_header(field)] = value
+      end
     end
 
     # Set a header
@@ -94,14 +97,31 @@ module Http
       @headers[name] || @headers[Http.canonicalize_header(name)]
     end
 
+    # Obtain the response body
+    def body
+      @body ||= begin
+        raise "no body available for this response" unless @body_proc
+
+        body = "" unless block_given?
+        while (chunk = @body_proc.call)
+          if block_given?
+            yield chunk
+          else
+            body << chunk
+          end
+        end
+        body unless block_given?
+      end
+    end
+
     # Parse the response body according to its content type
     def parse_body
       if @headers['Content-Type']
         mime_type = MimeType[@headers['Content-Type'].split(/;\s*/).first]
-        return mime_type.parse(@body) if mime_type
+        return mime_type.parse(body) if mime_type
       end
 
-      @body
+      body
     end
 
     # Returns an Array ala Rack: `[status, headers, body]`

data/lib/http/response_parser.rb

@@ -0,0 +1,62 @@
+module Http
+  class Response
+    class Parser
+      attr_reader :headers
+
+      def initialize
+        @parser = Http::Parser.new(self)
+        reset
+      end
+
+      def add(data)
+        @parser << data
+      end
+      alias_method :<<, :add
+
+      def headers?
+        !!@headers
+      end
+
+      def http_version
+        @parser.http_version.join(".")
+      end
+
+      def status_code
+        @parser.status_code
+      end
+
+      #
+      # Http::Parser callbacks
+      #
+
+      def on_headers_complete(headers)
+        @headers = headers
+      end
+
+      def on_body(chunk)
+        if @chunk
+          @chunk << chunk
+        else
+          @chunk = chunk
+        end
+      end
+
+      def chunk
+        if (chunk = @chunk)
+          @chunk = nil
+          chunk
+        end
+      end
+
+      def on_message_complete
+        @finished = true
+      end
+
+      def reset
+        @finished = false
+        @headers  = nil
+        @chunk    = nil
+      end
+    end
+  end
+end

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module Http
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/http/options/body_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Http::Options, "body" do
+
+  let(:opts){ Http::Options.new }
+
+  it 'defaults to nil' do
+    opts.body.should be_nil
+  end
+
+  it 'may be specified with with_body' do
+    opts2 = opts.with_body("foo")
+    opts.body.should be_nil
+    opts2.body.should eq("foo")
+  end
+
+end
+

data/spec/http/options/merge_spec.rb

@@ -19,18 +19,25 @@ describe Http::Options, "merge" do
     foo = Http::Options.new(
       :response  => :body,
       :form      => {:foo => 'foo'},
+      :body      => "body-foo",
       :headers   => {:accept  => "json",  :foo => 'foo'},
+      :proxy     => {},
       :callbacks => {:request => ["common"], :response => ["foo"]})
     bar = Http::Options.new(
       :response  => :parsed_body,
       :form      => {:bar => 'bar'},
+      :body      => "body-bar",
       :headers   => {:accept  => "xml", :bar => 'bar'},
+      :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
       :callbacks => {:request => ["common"], :response => ["bar"]})
     foo.merge(bar).to_hash.should eq(
       :response  => :parsed_body,
       :form      => {:bar => 'bar'},
+      :body      => "body-bar",
       :headers   => {:accept  => "xml", :foo => "foo", :bar => 'bar'},
-      :callbacks => {:request => ["common"], :response => ["foo", "bar"]}
+      :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
+      :callbacks => {:request => ["common"], :response => ["foo", "bar"]},
+      :follow => nil
     )
   end
 

data/spec/http/options/new_spec.rb

@@ -18,6 +18,11 @@ describe Http::Options, "new" do
       opts = Http::Options.new(:headers => {:accept => "json"})
       opts.headers.should eq(:accept => "json")
     end
+    
+    it 'coerces :proxy correctly' do
+      opts = Http::Options.new(:proxy => {:proxy_address => "127.0.0.1", :proxy_port => 8080})
+      opts.proxy.should eq(:proxy_address => "127.0.0.1", :proxy_port => 8080)
+    end
 
     it 'coerces :form correctly' do
       opts = Http::Options.new(:form => {:foo => 42})

data/spec/http/options/proxy_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Http::Options, "proxy" do
+
+  let(:opts){ Http::Options.new }
+
+  it 'defaults to {}' do
+    opts.proxy.should eq({})
+  end
+
+  it 'may be specified with with_proxy' do
+    opts2 = opts.with_proxy(:proxy_address => "127.0.0.1", :proxy_port => 8080)
+    opts.proxy.should eq({})
+    opts2.proxy.should eq(:proxy_address => "127.0.0.1", :proxy_port => 8080)
+  end
+
+  it 'accepts proxy address, port, username, and password' do
+    opts2 = opts.with_proxy(:proxy_address => "127.0.0.1", :proxy_port => 8080, :proxy_username => "username", :proxy_password => "password")
+    opts2.proxy.should eq(:proxy_address => "127.0.0.1", :proxy_port => 8080, :proxy_username => "username", :proxy_password => "password")
+  end
+end

data/spec/http/response_spec.rb

@@ -1,69 +1,57 @@
 require 'spec_helper'
 
 describe Http::Response do
+  describe "headers" do
+    subject { Http::Response.new(200, "1.1", "Content-Type" => "text/plain") }
 
-  let(:subject){ Http::Response.new }
-
-  describe "the response headers" do
-
-    it 'are available through Hash-like methods' do
-      subject["Content-Type"] = "text/plain"
+    it "exposes header fields for easy access" do
       subject["Content-Type"].should eq("text/plain")
     end
 
-    it 'are available through a `headers` accessor' do
-      subject["Content-Type"] = "text/plain"
+    it "provides a #headers accessor too" do
       subject.headers.should eq("Content-Type" => "text/plain")
     end
-
   end
 
-  describe "parse_body" do
+  describe "#parse_body" do
+    context "on a registered MIME type" do
+      let(:body) { ::JSON.dump("Hello" => "World") }
+      subject { Http::Response.new(200, "1.1", {"Content-Type" => "application/json"}, body) }
 
-    it 'works on a registered mime-type' do
-      subject["Content-Type"] = "application/json"
-      subject.body = ::JSON.dump("hello" => "World")
-      subject.parse_body.should eq("hello" => "World")
+      it "returns a parsed response body" do
+        subject.parse_body.should eq ::JSON.parse(body)
+      end
     end
 
-    it 'returns the body on an unregistered mime-type' do
-      subject["Content-Type"] = "text/plain"
-      subject.body = "Hello world"
-      subject.parse_body.should eq("Hello world")
-    end
+    context "on an unregistered MIME type" do
+      let(:body) { "Hello world" }
+      subject { Http::Response.new(200, "1.1", {"Content-Type" => "text/plain"}, body) }
 
+      it "returns the raw body as a String" do
+        subject.parse_body.should eq(body)
+      end
+    end
   end
 
   describe "to_a" do
+    context "on a registered MIME type" do
+      let(:body) { ::JSON.dump("Hello" => "World") }
+      let(:content_type) { "application/json" }
+      subject { Http::Response.new(200, "1.1", {"Content-Type" => content_type}, body) }
 
-    it 'mimics Rack' do
-      subject.tap do |r|
-        r.status  = 200
-        r.headers = {"Content-Type" => "text/plain"}
-        r.body    = "Hello world"
+      it "retuns a Rack-like array with a parsed response body" do
+        subject.to_a.should eq([200, {"Content-Type" => content_type}, ::JSON.parse(body)])
       end
-      expected = [
-        200,
-        {"Content-Type" => "text/plain"},
-        "Hello world"
-      ]
-      subject.to_a.should eq(expected)
     end
 
-    it 'uses parse_body if known mime-type' do
-      subject.tap do |r|
-        r.status  = 200
-        r.headers = {"Content-Type" => "application/json"}
-        r.body    = ::JSON.dump("hello" => "World")
+    context "on an unregistered MIME type" do
+      let(:body)         { "Hello world" }
+      let(:content_type) { "text/plain" }
+      subject { Http::Response.new(200, "1.1", {"Content-Type" => content_type}, body) }
+
+      it "returns a Rack-like array" do
+        subject.to_a.should eq([200, {"Content-Type" => content_type}, body])
       end
-      expected = [
-        200,
-        {"Content-Type" => "application/json"},
-        {"hello" => "World"}
-      ]
-      subject.to_a.should eq(expected)
     end
-
   end
-
 end

data/spec/http_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 require 'json'
 
 describe Http do
-  let(:test_endpoint) { "http://127.0.0.1:#{ExampleService::PORT}/" }
+  let(:test_endpoint)  { "http://127.0.0.1:#{ExampleService::PORT}/" }
+  let(:proxy_endpoint) { "#{test_endpoint}proxy" }
 
   context "getting resources" do
     it "should be easy" do
@@ -10,6 +11,13 @@ describe Http do
       response.should match(/<!doctype html>/)
     end
 
+    context "with_response" do
+      it 'allows specifying :object' do
+        res = Http.with_response(:object).get test_endpoint
+        res.should be_a(Http::Response)
+      end
+    end
+
     context "with headers" do
       it "should be easy" do
         response = Http.accept(:json).get test_endpoint
@@ -32,15 +40,72 @@ describe Http do
         response.should be_a Http::Response
       end
     end
+
+    it "should not mess with the returned status" do
+      client = Http.with_response(:object)
+      res = client.get test_endpoint
+      res.status.should == 200
+      res = client.get "#{test_endpoint}not-found"
+      res.status.should == 404
+    end
+  end
+
+  context "with http proxy address and port" do
+    it "should proxy the request" do
+      response = Http.via("127.0.0.1", 8080).get proxy_endpoint
+      response.should match(/Proxy!/)
+    end
+  end
+
+  context "with http proxy address, port username and password" do
+    it "should proxy the request" do
+      response = Http.via("127.0.0.1", 8081, "username", "password").get proxy_endpoint
+      response.should match(/Proxy!/)
+    end
+  end
+
+  context "with http proxy address, port, with wrong username and password" do
+    it "should proxy the request" do
+      pending "fixing proxy support"
+
+      response = Http.via("127.0.0.1", 8081, "user", "pass").get proxy_endpoint
+      response.should match(/Proxy Authentication Required/)
+    end
+  end
+
+  context "without proxy port" do
+    it "should raise an argument error" do
+      expect { Http.via("127.0.0.1") }.to raise_error ArgumentError
+    end
   end
 
   context "posting to resources" do
-    it "should be easy" do
-      response = Http.post test_endpoint, :form => {:example => 'testing'}
+    it "should be easy to post forms" do
+      response = Http.post "#{test_endpoint}form", :form => {:example => 'testing-form'}
+      response.should == "passed :)"
+    end
+  end
+
+  context "posting with an explicit body" do
+    it "should be easy to post" do
+      response = Http.post "#{test_endpoint}body", :body => "testing-body"
       response.should == "passed :)"
     end
   end
 
+  context "with redirects" do
+    it "should be easy for 301" do
+      response = Http.with_follow(true).get("#{test_endpoint}redirect-301")
+      response.should match(/<!doctype html>/)
+    end
+
+    it "should be easy for 302" do
+      response = Http.with_follow(true).get("#{test_endpoint}redirect-302")
+      response.should match(/<!doctype html>/)
+    end
+
+  end
+
   context "head requests" do
     it "should be easy" do
       response = Http.head test_endpoint

data/spec/spec_helper.rb

@@ -1,2 +1,3 @@
 require 'http'
-require 'support/example_server'
+require 'support/example_server'
+require 'support/proxy_server'

data/spec/support/example_server.rb

@@ -16,6 +16,18 @@ class ExampleService < WEBrick::HTTPServlet::AbstractServlet
         response['Content-Type'] = 'text/html'
         response.body   = "<!doctype html>"
       end
+    when "/proxy"
+      response.status = 200
+      response.body     = "Proxy!"
+    when "/not-found"
+      response.body   = "not found"
+      response.status = 404
+    when "/redirect-301"
+      response.status = 301
+      response["Location"] = "http://127.0.0.1:#{PORT}/"
+    when "/redirect-302"
+      response.status = 302
+      response["Location"] = "http://127.0.0.1:#{PORT}/"
     else
       response.status = 404
     end
@@ -23,8 +35,16 @@ class ExampleService < WEBrick::HTTPServlet::AbstractServlet
 
   def do_POST(request, response)
     case request.path
-    when "/"
-      if request.query['example'] == 'testing'
+    when "/form"
+      if request.query['example'] == 'testing-form'
+        response.status = 200
+        response.body   = "passed :)"
+      else
+        response.status = 400
+        response.body   = "invalid! >:E"
+      end
+    when "/body"
+      if request.body == 'testing-body'
         response.status = 200
         response.body   = "passed :)"
       else
@@ -54,3 +74,5 @@ t = Thread.new { ExampleServer.start }
 trap("INT")    { ExampleServer.shutdown; exit }
 
 Thread.pass while t.status and t.status != "sleep"
+
+

data/spec/support/proxy_server.rb

@@ -0,0 +1,17 @@
+require 'webrick/httpproxy'
+ 
+ProxyServer     = WEBrick::HTTPProxyServer.new(:Port => 8080, :AccessLog => [])
+  
+t = Thread.new { ProxyServer.start }
+trap("INT")    { ProxyServer.shutdown; exit }
+
+AuthenticatedProxyServer = WEBrick::HTTPProxyServer.new(:Port => 8081, 
+                  :ProxyAuthProc => Proc.new do | req, res |
+                    WEBrick::HTTPAuth.proxy_basic_auth(req, res, 'proxy') do | user, pass |
+                      user == 'username' and pass == 'password'
+                    end
+                  end)
+                  
+
+t = Thread.new { AuthenticatedProxyServer.start }
+trap("INT")    { AuthenticatedProxyServer.shutdown; exit }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-05 00:00:00.000000000 Z
+date: 2012-09-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: &70356765427900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70356765427900
 - !ruby/object:Gem::Dependency
   name: certified
-  requirement: &70273361267740 !ruby/object:Gem::Requirement
+  requirement: &70356765427240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70273361267740
+  version_requirements: *70356765427240
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70273361267320 !ruby/object:Gem::Requirement
+  requirement: &70356765442460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70273361267320
+  version_requirements: *70356765442460
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70273361266900 !ruby/object:Gem::Requirement
+  requirement: &70356765441700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70273361266900
+  version_requirements: *70356765441700
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70273361266480 !ruby/object:Gem::Requirement
+  requirement: &70356765441120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70273361266480
+  version_requirements: *70356765441120
 description: HTTP so awesome it will lure Catherine Zeta Jones into your unicorn petting
   zoo
 email:
@@ -81,20 +92,25 @@ files:
 - lib/http/options.rb
 - lib/http/request.rb
 - lib/http/response.rb
+- lib/http/response_parser.rb
+- lib/http/streaming_body.rb
 - lib/http/uri_backport.rb
 - lib/http/version.rb
 - spec/http/compat/curb_spec.rb
+- spec/http/options/body_spec.rb
 - spec/http/options/callbacks_spec.rb
 - spec/http/options/form_spec.rb
 - spec/http/options/headers_spec.rb
 - spec/http/options/merge_spec.rb
 - spec/http/options/new_spec.rb
+- spec/http/options/proxy_spec.rb
 - spec/http/options/response_spec.rb
 - spec/http/options_spec.rb
 - spec/http/response_spec.rb
 - spec/http_spec.rb
 - spec/spec_helper.rb
 - spec/support/example_server.rb
+- spec/support/proxy_server.rb
 homepage: https://github.com/tarcieri/http
 licenses: []
 post_install_message: 
@@ -115,20 +131,24 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: HTTP should be easy
 test_files:
 - spec/http/compat/curb_spec.rb
+- spec/http/options/body_spec.rb
 - spec/http/options/callbacks_spec.rb
 - spec/http/options/form_spec.rb
 - spec/http/options/headers_spec.rb
 - spec/http/options/merge_spec.rb
 - spec/http/options/new_spec.rb
+- spec/http/options/proxy_spec.rb
 - spec/http/options/response_spec.rb
 - spec/http/options_spec.rb
 - spec/http/response_spec.rb
 - spec/http_spec.rb
 - spec/spec_helper.rb
 - spec/support/example_server.rb
+- spec/support/proxy_server.rb
+has_rdoc: