righttp 0.0.2 → 0.1.1

data/.gitignore

@@ -19,3 +19,5 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+
+*.gem

data/README.textile

@@ -0,0 +1,58 @@
+h1. righttp
+
+righttp is a lightweigt http client library which is intended to simplify http requests.
+
+It is in a very early stage and patches, suggestions and ideas how to improve it are highly appreciated.
+
+h2. Usage
+
+Currently there is only one way to perform a request:
+
+h3. Minimal version
+
+bc. request  = Rig::HTTP.new( :host => "ruby-lang.org" )
+response = request.send
+
+h3. More elaborate version
+
+bc. request  = Rig::HTTP.new(
+  :host   => "ruby-lang.org",
+  :path   => "/en/documentation/",
+  :params => {"love" => "true"}
+  :method => "GET",
+  :header => "x-CUSTOM-HEADER" => "Awesome"
+)
+response = request.send
+
+There will be wrapper methods for the different HTTP methods in the future.
+It is also possible to do multipart form POST/PUT requests with multiple
+files attached.
+
+h3. Multipart Post
+
+bc. request = Rig::HTTP.new(
+  :host   => "example.org",
+  :path   => "/posts",
+  :params => { "title" => "Oh Hai", "upload" => File.open("/path/to/file.jpg") }
+)
+response = request.send
+
+The file will be closed once the multipart is created.
+
+h3. Responses
+
+When a request is send it returns a Rig::HTTPResponse which has two attributes: header and body
+
+h2. Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+h2. Copyright
+
+Copyright (c) 2010 hukl. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.1

data/doc/mission.textile

@@ -0,0 +1,49 @@
+h1. righttp
+
+h2. What righttp wants to achieve
+
+righttp is intended to provide a simple and clean interface for HTTP requests while allowing to override almost every parameter of the request if it is neccessary.
+
+It is not just a wrapper of net/http
+
+Its philosophy is to get out of your way. You want to make a quick custom HTTP request? Then just do it like you think it should work.
+
+Below you can see the various ways to make a request:
+
+h2. Interface
+
+bc.. HTTP.get( 'http://foobar.com' )
+
+HTTP.get( 'http://foobar.com?foo=bar&baz=bang')
+
+HTTP.get( 'http://foobar.com:3000?foo=bar&baz=bang')
+
+HTTP.get( 'http://foobar.com', :params => {"foo" => "bar", :baz => "bang"} )
+
+HTTP.get(
+  'http://foobar.com',
+  :params => {"foo" => "bar", :baz => "bang"}
+)
+
+HTTP.get(
+  :host   => 'foobar.com',
+  :path   => "/posts",
+  :port   => 3000
+  :params => {"foo" => "bar", :baz => "bang"},
+)
+
+HTTP.post( 'foobar.com', :params => {"foo" => "bar"} )
+
+HTTP.post(
+  'foobar.com',
+  :params => {"foo" => "bar", :attachment => File.open("path/to/file.jpg")}
+)
+
+h2. Components
+
+* request preparation
+* sending the request
+* parsing the response
+
+
+{ uri = URI::Generic }

data/lib/rig/http.rb

@@ -1,178 +1,129 @@
 require 'socket'
+require 'uri'
+require 'rig/http_response'
+require 'rig/http_header'
+require 'rig/http_body'
+require 'rig/http_exceptions'
 
 module Rig
 
   CRLF = "\r\n"
+  HTTPMethods = %w(GET POST PUT DELETE)
 
   class HTTP
+    attr_reader :options, :header, :body
 
-    attr_reader :tcp_socket, :params, :method, :path
-
-    def initialize options
-      @host           = options[:host]    || raise(ArgumentError, "No host specified")
-      @port           = options[:port]    || 80
-      @params         = options[:params]  || {}
-      @method         = options[:method]  || "GET"
-      @path           = options[:path]    || "/"
-      @header         = HTTPHeader.new( "" => "#{@method} #{@path} HTTP/1.1" )
-      @custom_header  = HTTPHeader.new( options[:header]  || {} )
-      @body           = HTTPBody.new
-      @tcp_socket     = TCPSocket.new( @host, @port )
-    end
+    def initialize *options
+      @options      = normalize_options( options )
+      @body         = HTTPBody.new( @options )
 
-    def generate_header_and_body
-      if @method == "GET"
-        update_path_query_params
-      else
-        update_body
-      end
-      update_header
+      @options.merge!(
+        :content_type   => @body.content_type,
+        :content_length => @body.content_length
+      )
+
+      @header       = HTTPHeader.new( @options )
     end
 
     def send
       begin
-        generate_header_and_body
-        @tcp_socket.write( header + body )
-        response = @tcp_socket.read
+        tcp_socket = TCPSocket.new( @options[:host], @options[:port] )
+        tcp_socket.write( @header.to_s)# + @body.to_s )
+        response = tcp_socket.read
       rescue => exception
         puts exception.message
       ensure
-        @tcp_socket.close
+        tcp_socket.close
       end
 
-      response || exception.message
-    end
-
-    def update_header
-      @header.merge!(
-        "Host"            => @host,
-        "Origin"          => "localhost",
-        "Content-Length"  => @body.join.bytes.to_a.length,
-        "Content-Type"    => determine_content_type
-      ).merge!(
-        @custom_header
-      ).merge!(
-        "Connection"      => "close"
-      )
-    end
-
-    def update_path_query_params
-
-    end
-
-    def multipart?
-      if defined? @multipart
-        @multipart
-      else 
-        @multipart = @params.values.map(&:class).include?( File )
-      end
-    end
-
-    def update_body
-      if multipart?
-        create_multipart_body
+      HTTPResponse.new( response ) || exception.message
+    end
+
+    def with_body?
+      %w(POST PUT).include?( options[:http_method] ) && options[:body]
+    end
+
+    def http_method
+      @options[:http_method] || "GET"
+    end
+
+    def normalize_options options
+      options.flatten!
+
+      options = case HTTP.options_mode( options )
+      when :simple
+        uri = URI.parse( options.first )
+        {
+          :host   => uri.host,
+          :port   => uri.port,
+          :path   => uri.path,
+          :query  => uri.query
+        }
+      when :mixed
+        uri = URI.parse( options.first )
+        uri_options = {
+          :host   => uri.host,
+          :port   => uri.port,
+          :path   => uri.path,
+          :query  => uri.query
+        }
+        uri_options.merge( options.last )
+      when :advanced
+        {
+          :http_method  => options.first[:http_method]  || "GET",
+          :host         => options.first[:host],
+          :port         => options.first[:port]         || 80,
+          :path         => options.first[:path]         || "/",
+          :query        => options.first[:query]
+        }
       else
-        create_simple_body
+        raise ArgumentError
       end
-    end
-
-    def new_text_multipart field_name, text
-      part = ""
-      part += "--#{boundary}"
-      part += CRLF
-      part += "Content-Disposition: form-data; name=\"#{field_name}\""
-      part += CRLF
-      part += CRLF
-      part += text
-      part += CRLF
-    end
-
-    def new_file_multipart field_name, file
-      content_type = %x[file --mime-type -b #{file.path}].chomp
-
-      part = ""
-      part += "--#{boundary}"
-      part += CRLF
-      part += "Content-Disposition: form-data; name=\"#{field_name}\"; "
-      part += "filename=\"#{File.basename( file )}\""
-      part += CRLF
-      part += "Content-Type: #{content_type}"
-      part += CRLF
-      part += CRLF
-      part += file.read
-      file.close
-      part += CRLF
-    end
 
-    def create_multipart_body
-      @params.each do |key, value|
-        if value.is_a?( File )
-          @body << new_file_multipart( key, value )
-        elsif value.is_a?( String ) || value.responds_to?( :to_s )
-          @body << new_text_multipart( key, value )
-        else
-          raise ArgumentError, "Invalid Parameter Value"
-        end
+      if options[:path].nil? || options[:path].empty?
+        options[:path] = "/"
       end
 
-      @body << "--#{boundary}--\r\n"
-    end
-
-    def create_simple_body
-      @body << @params.map {|key, value| "#{key}=#{value}"}.join("&")
+      options
     end
 
-    def determine_content_type
-      if multipart?
-        "multipart/form-data; boundary=#{boundary}"
+    def method_missing name, *args, &block
+      if options[name]
+        return options[name]
       else
-        if @method == "POST"
-          "application/x-www-form-urlencoded; charset=UTF-8"
-        else
-          "text/plain"
-        end
+        super
       end
     end
 
-    def boundary
-      @boundary ||= "----rigHTTPmultipart#{rand(2**32)}XZWCFOOBAR"
-    end
-
-    def header
-      @header.to_s
-    end
-
-    def body
-      @body.to_s
+    def self.options_mode options
+      if    options.length == 1 && options.first.is_a?( String )
+        :simple
+      elsif options.length == 2 && options.map(&:class) == [String, Hash]
+        :mixed
+      elsif options.length == 1 && options.first.is_a?( Hash )
+        :advanced
+      else
+        :error
+      end
     end
-  end
 
-  class HTTPHeader < Hash
+    def self.method_missing name, *args, &block
+      name = name.to_s.upcase
 
-    def initialize options
-      super.merge! options
-    end
-
-    def to_s
-      header_string = map do |field_name, value|
-        if field_name == ""
-          value
-        else
-          "#{field_name}: #{value}"
+      if HTTPMethods.include?( name )
+        case options_mode( args )
+        when :simple
+          self.new( args.push( :http_method => name ) )
+        when :mixed
+          args.last.merge!( :http_method => name )
+          self.new( args )
+        when :advanced
+          self.new( args.first.merge( :http_method => name ) )
         end
+      else
+        super
       end
-
-      header_string.join(CRLF) + CRLF + CRLF
-    end
-
-  end
-
-  class HTTPBody < Array
-
-    def to_s
-      join
     end
-
   end
 
 end

data/lib/rig/http_body.rb

@@ -0,0 +1,98 @@
+module Rig
+  class HTTPBody < Array
+
+    def initialize options
+      @options      = options[:body] || {}
+      @http_method  = options[:http_method]
+
+      if multipart?
+        create_multipart_body
+      else
+        create_simple_body
+      end
+    end
+
+    def content_length
+      join.bytes.to_a.length
+    end
+
+    def content_type
+      if multipart?
+        "multipart/form-data; boundary=#{boundary}"
+      else
+        if %w(POST PUT).include?( @http_method )
+          "application/x-www-form-urlencoded; charset=UTF-8"
+        else
+          "text/plain"
+        end
+      end
+    end
+
+    def boundary
+      @boundary ||= "----rigHTTPmultipart#{rand(2**32)}XZWCFOOBAR"
+    end
+
+    def multipart?
+      if defined? @multipart
+        @multipart
+      elsif @options
+        @multipart = @options.values.any? do |element|
+          element.respond_to?( :read )
+        end
+      else
+        @multipart = false
+      end
+    end
+
+    def create_simple_body
+      push @options.map {|key, value| "#{key}=#{value}"}.join("&")
+    end
+
+    def create_multipart_body
+      @options.each do |key, value|
+        if value.respond_to?( :read )
+          push new_file_multipart( key, value )
+        elsif value.is_a?( String ) || value.respond_to?( :to_s )
+          push new_text_multipart( key, value )
+        else
+          raise ArgumentError, "Invalid Parameter Value"
+        end
+      end
+
+      push "--#{boundary}--\r\n"
+    end
+
+    def new_text_multipart field_name, text
+      part = ""
+      part += "--#{boundary}"
+      part += CRLF
+      part += "Content-Disposition: form-data; name=\"#{field_name}\""
+      part += CRLF
+      part += CRLF
+      part += text
+      part += CRLF
+    end
+
+    def new_file_multipart field_name, file
+      content_type = %x[file --mime-type -b #{file.path}].chomp
+
+      part = ""
+      part += "--#{boundary}"
+      part += CRLF
+      part += "Content-Disposition: form-data; name=\"#{field_name}\"; "
+      part += "filename=\"#{File.basename( file )}\""
+      part += CRLF
+      part += "Content-Type: #{content_type}"
+      part += CRLF
+      part += CRLF
+      part += file.read
+      file.close
+      part += CRLF
+    end
+
+    def to_s
+      join
+    end
+
+  end
+end

data/lib/rig/http_exceptions.rb

@@ -0,0 +1 @@
+class NoHostProvided < ArgumentError; end;

data/lib/rig/http_header.rb

@@ -0,0 +1,36 @@
+module Rig
+  class HTTPHeader < Hash
+
+    def initialize options
+      http_method = options[:http_method]
+      path        = options[:path]
+
+      header = {
+        ""                => "#{http_method} #{path} HTTP/1.1",
+        "Host"            => options[:host],
+        "Origin"          => "localhost",
+        "Content-Length"  => options[:content_length],
+        "Content-Type"    => options[:content_type]
+      }.merge(
+        (options[:custom_header] || {})
+      ).merge(
+        "Connection"      => "close"
+      )
+
+      merge!( header )
+    end
+
+    def to_s
+      header_string = map do |field_name, value|
+        if field_name == ""
+          value
+        else
+          "#{field_name}: #{value}"
+        end
+      end
+
+      header_string.join(CRLF) + CRLF + CRLF
+    end
+
+  end
+end

data/lib/rig/http_response.rb

@@ -0,0 +1,54 @@
+require 'ruby-debug'
+module Rig
+  class HTTPResponse
+
+    attr_reader :header, :body
+
+    def initialize response
+      parts = response.split(CRLF + CRLF)
+      @header = parts.delete_at( 0 )
+      @status = @header.match(/HTTP\/\d.\d\s(\d\d\d)/)[1]
+      @body   = parts.join
+
+      parse_header
+
+      if @header["Transfer-Encoding"] == "chunked"
+        parsed_body = ""
+        @body = StringIO.new( @body )
+        read_chunked( parsed_body )
+
+        @body = parsed_body
+      end
+    end
+
+    def status
+      @status ? @status.to_i : 666
+    end
+
+    def parse_header
+      status_line = @header[/HTTP\/\d\.\d\s\d\d\d.+\r\n/]
+      @header = @header.gsub(status_line, "Status: #{status_line}")
+      @header = @header.split(CRLF)
+      @header = @header.map { |element| element.split(": ") }
+      @header = @header.inject({}) do |result, element|
+        result[element.first] = element.last
+        result
+      end
+    end
+
+    def read_chunked(dest)
+      len = nil
+      total = 0
+      while true
+        line = @body.readline
+        hexlen = line.slice(/[0-9a-fA-F]+/) or
+          raise HTTPBadResponse, "wrong chunk size line: #{line}"
+        len = hexlen.hex
+        break if len == 0
+        @body.read len, dest; total += len
+        @body.read 2   # \r\n
+      end
+    end
+
+  end
+end

data/righttp.gemspec

@@ -5,27 +5,33 @@
 
 Gem::Specification.new do |s|
   s.name = %q{righttp}
-  s.version = "0.0.2"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["hukl"]
-  s.date = %q{2010-08-11}
+  s.date = %q{2010-08-15}
   s.description = %q{Why? Because it has to be done!}
   s.email = %q{contact@smyck.org}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.textile"
   ]
   s.files = [
     ".document",
      ".gitignore",
      "LICENSE",
-     "README.rdoc",
+     "README.textile",
      "Rakefile",
      "VERSION",
+     "doc/mission.textile",
      "lib/rig/http.rb",
+     "lib/rig/http_body.rb",
+     "lib/rig/http_exceptions.rb",
+     "lib/rig/http_header.rb",
+     "lib/rig/http_response.rb",
      "lib/righttp.rb",
      "righttp.gemspec",
+     "test/fixtures/yay.gif",
      "test/helper.rb",
      "test/test_http.rb"
   ]

data/test/test_http.rb

@@ -2,54 +2,195 @@ require 'helper'
 
 class TestHttp < Test::Unit::TestCase
 
-  test "create the simplest http get object" do
-    assert_not_nil get = HTTP.new( {:host => "localhost"} )
+  test "cannot create HTTP object without any parameters" do
+    assert_raise( ArgumentError) { HTTP.new }
   end
 
-  test "to create a http object at least the host must be specified" do
-    assert_raise(ArgumentError) { get = HTTP.new( {} ) }
+  test "request can be built with one argument" do
+    assert_not_nil HTTP.new( "http://foobar.com" )
   end
 
-  test "http objects have accessible socket object" do
-    get = HTTP.new( {:host => "localhost"} )
-    assert_not_nil get.tcp_socket
+  test "request can be built with two or more arguments" do
+    assert_not_nil HTTP.new( "http://fooobar.com", :params => { 1 => 2} )
   end
 
-  test "http object has accessible params" do
-    get = HTTP.new( {:host => "localhost", :params => {"foo" => "bar"}} )
-    assert_not_nil get.params
-    assert_equal ({"foo" => "bar"}), get.params
+  test "method get" do
+    assert_not_nil request = HTTP.get( "http://foobar.com" )
+    expected = {
+      :host=>"foobar.com",
+      :port=>80,
+      :path=>"/",
+      :http_method=>"GET",
+      :query => nil,
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
   end
 
-  test "http object without params specified returns empty params" do
-    get = HTTP.new( {:host => "localhost"} )
-    assert_not_nil get.params
-    assert_equal ({}), get.params
+  test "method post" do
+    assert_not_nil request = HTTP.post( "http://foobar.com" )
+    expected = {
+      :host=>"foobar.com",
+      :port=>80,
+      :path=>"/",
+      :http_method=>"POST",
+      :query => nil,
+      :content_type=>"application/x-www-form-urlencoded; charset=UTF-8",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end
+
+  test "method put" do
+    assert_not_nil request = HTTP.put( "http://foobar.com" )
+    expected = {
+      :host=>"foobar.com",
+      :port=>80,
+      :path=>"/",
+      :http_method=>"PUT",
+      :query => nil,
+      :content_type=>"application/x-www-form-urlencoded; charset=UTF-8",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end
+
+  test "method delete" do
+    assert_not_nil request = HTTP.delete( "http://foobar.com" )
+    expected = {
+      :host=>"foobar.com",
+      :port=>80,
+      :path=>"/",
+      :http_method=>"DELETE",
+      :query => nil,
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end
+
+  test "get request with advanced mode" do
+    assert_not_nil request = HTTP.new(:host => "foobar.com")
+    expected = {
+      :host=>"foobar.com",
+      :port=>80,
+      :path=>"/",
+      :http_method=>"GET",
+      :query => nil,
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+
+    assert_equal expected, request.options
+  end
+
+  test "other missing methods are delegated to super" do
+    assert_raise( ArgumentError ) { HTTP.foobar( "http://foobar.com" ) }
+  end
+
+  test "mixed mode get" do
+    request = HTTP.get("http://foobar.com", :port => 3000)
+    expected = {
+      :host=>"foobar.com",
+      :port=>3000,
+      :path=>"/",
+      :http_method=>"GET",
+      :query => nil,
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end
+
+  test "mixed mode get with query params" do
+    request = HTTP.get("http://foobar.com?foo=bar", :port => 3000)
+    expected = {
+      :host=>"foobar.com",
+      :port=>3000,
+      :path=>"/",
+      :http_method=>"GET",
+      :query => "foo=bar",
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end
+
+  test "mixed mode get with query paramsi and inline port" do
+    request = HTTP.get("http://foobar.com:3000?foo=bar")
+    expected = {
+      :host=>"foobar.com",
+      :port=>3000,
+      :path=>"/",
+      :http_method=>"GET",
+      :query => "foo=bar",
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end
+
+  test "mixed mode get with query params and overriding port" do
+    request = HTTP.get("http://foobar.com:2323?foo=bar", :port => 3000)
+    expected = {
+      :host=>"foobar.com",
+      :port=>3000,
+      :path=>"/",
+      :http_method=>"GET",
+      :query => "foo=bar",
+      :content_type=>"text/plain",
+      :content_length=>0
+    }
+    assert_equal expected, request.options
+  end 
+
+  test "if multipart" do
+    File.open(File.join(File.dirname(__FILE__), "fixtures", "yay.gif")) do |f|
+      request = HTTP.post(
+        "http://foo.com",
+        :body => {:upload => f}
+      )
+      assert request.body.multipart?, "Should be multipart"
+    end
+  end
+
+  test "if not multipart" do
+    request = HTTP.post(
+      "http://foo.com",
+      :body => {:abstract => "bla", :title => "foo"}
+    )
+    assert !request.body.multipart?, "Should not be multipart"
+  end
+
+  test "http object has accessible options" do
+    get = HTTP.new( {:host => "localhost", :query => {"foo" => "bar"}} )
+    assert_not_nil get.options
+    assert_equal ({"foo" => "bar"}), get.options[:query]
   end
 
   test "simple http object defaults to method GET" do
     get = HTTP.new( {:host => "localhost"} )
-    assert_equal "GET", get.method
+    assert_equal "GET", get.http_method
   end
 
   test "method of http object can be overridden" do
-    post = HTTP.new( {:host => "localhost", :method => "POST"} )
-    assert_equal "POST", post.method
+    post = HTTP.new( {:host => "localhost", :http_method => "POST"} )
+    assert_equal "POST", post.http_method
   end
 
   test "path of a http object defaults to index" do
     get = HTTP.new( {:host => "localhost"} )
-    assert_equal "/", get.path
+    assert_equal "/", get.options[:path]
   end
 
   test "path of http object can be set" do
     get = HTTP.new( {:host => "localhost", :path => "/posts"} )
-    assert_equal "/posts", get.path
+    assert_equal "/posts", get.options[:path]
   end
 
   test "generate_header_and_body" do
     get = HTTP.new( {:host => "localhost", :path => "/posts"} )
-    assert_not_nil get.generate_header_and_body
 
     expected = "GET /posts HTTP/1.1\r\n"      \
                "Host: localhost\r\n"          \
@@ -58,39 +199,45 @@ class TestHttp < Test::Unit::TestCase
                "Content-Type: text/plain\r\n" \
                "Connection: close\r\n\r\n"
 
-    assert_equal expected, get.header
+    assert_equal expected, get.header.to_s
   end
 
-  test "multipart body gets properly created" do
-    post = HTTP.new(
-      :host   => "localhost",
-      :path   => "/photos",
-      :method => "POST",
-      :params => {
-        "photo[title]"    => "Hello World",
-        "photo[image]"    => File.open("/Users/hukl/Desktop/file1.png"),
-        "photo[picture]"  => File.open("/Users/hukl/Desktop/file2.png")
-      }
-    )
-    post.generate_header_and_body
-
-    post.tcp_socket.write (post.header + post.body)
-    response = post.tcp_socket.recvfrom(2**16)
-    status = response.first.match(/HTTP\/1\.1\s(\d\d\d).+$/)[1]
-
-    assert_equal 302, status.to_i
+  test "actual get request" do
+    request = HTTP.get( "http://www.spiegel.de" )
+    response = request.send
+    assert_equal 200, response.status
   end
 
-  test "real get request" do
-    get = HTTP.new(
-      :host => "localhost",
-      :path => "/photos"
-    )
-
-    get.tcp_socket.write (get.header + get.body)
-    response = get.tcp_socket.recvfrom(2**16)
-    status = response.first.match(/HTTP\/1\.1\s(\d\d\d).+$/)[1]
-
-    assert_equal 200, status.to_i
-  end
+  #test "multipart body gets properly created" do
+  #  post = HTTP.new(
+  #    :host   => "localhost",
+  #    :path   => "/photos",
+  #    :http_method => "POST",
+  #    :params => {
+  #      "photo[title]"    => "Hello World",
+  #      "photo[image]"    => File.open("/Users/hukl/Desktop/file1.png"),
+  #      "photo[picture]"  => File.open("/Users/hukl/Desktop/file2.png")
+  #    }
+  #  )
+  #  post.generate_header_and_body
+
+  #  post.tcp_socket.write (post.header + post.body)
+  #  response = post.tcp_socket.recvfrom(2**16)
+  #  status = response.first.match(/HTTP\/1\.1\s(\d\d\d).+$/)[1]
+
+  #  assert_equal 302, status.to_i
+  #end
+
+  #test "real get request" do
+  #  get = HTTP.new(
+  #    :host => "localhost",
+  #    :path => "/photos"
+  #  )
+
+  #  get.tcp_socket.write (get.header + get.body)
+  #  response = get.tcp_socket.recvfrom(2**16)
+  #  status = response.first.match(/HTTP\/1\.1\s(\d\d\d).+$/)[1]
+
+  #  assert_equal 200, status.to_i
+  #end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 2
-  version: 0.0.2
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - hukl
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 +02:00
+date: 2010-08-15 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -26,17 +26,23 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.textile
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README.rdoc
+- README.textile
 - Rakefile
 - VERSION
+- doc/mission.textile
 - lib/rig/http.rb
+- lib/rig/http_body.rb
+- lib/rig/http_exceptions.rb
+- lib/rig/http_header.rb
+- lib/rig/http_response.rb
 - lib/righttp.rb
 - righttp.gemspec
+- test/fixtures/yay.gif
 - test/helper.rb
 - test/test_http.rb
 has_rdoc: true

data/README.rdoc

@@ -1,17 +0,0 @@
-= righttp
-
-Description goes here.
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 hukl. See LICENSE for details.