http 0.5.0.pre → 0.5.0.pre2

data/lib/http/response.rb

@@ -1,7 +1,10 @@
 require 'delegate'
+require 'http/header'
 
 module HTTP
   class Response
+    include HTTP::Header
+
     STATUS_CODES = {
       100 => 'Continue',
       101 => 'Switching Protocols',
@@ -73,7 +76,7 @@ module HTTP
 
       @headers = {}
       headers.each do |field, value|
-        @headers[Http.canonicalize_header(field)] = value
+        @headers[canonicalize_header(field)] = value
       end
     end
 
@@ -83,7 +86,7 @@ module HTTP
       key = name[CANONICAL_HEADER]
 
       # Convert to canonical capitalization
-      key ||= Http.canonicalize_header(name)
+      key ||= canonicalize_header(name)
 
       # Check if the header has already been set and group
       old_value = @headers[key]
@@ -102,7 +105,7 @@ module HTTP
 
     # Get a header value
     def [](name)
-      @headers[name] || @headers[Http.canonicalize_header(name)]
+      @headers[name] || @headers[canonicalize_header(name)]
     end
 
     # Obtain the response body

data/lib/http/response_parser.rb

@@ -4,7 +4,7 @@ module HTTP
       attr_reader :headers
 
       def initialize
-        @parser = Http::Parser.new(self)
+        @parser = HTTP::Parser.new(self)
         reset
       end
 
@@ -26,7 +26,7 @@ module HTTP
       end
 
       #
-      # Http::Parser callbacks
+      # HTTP::Parser callbacks
       #
 
       def on_headers_complete(headers)

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module HTTP
-  VERSION = "0.5.0.pre"
+  VERSION = "0.5.0.pre2" unless defined?(HTTP::VERSION)
 end

data/spec/http/options/body_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe Http::Options, "body" do
+describe HTTP::Options, "body" do
 
-  let(:opts){ Http::Options.new }
+  let(:opts){ HTTP::Options.new }
 
   it 'defaults to nil' do
-    opts.body.should be_nil
+    expect(opts.body).to 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")
+    expect(opts.body).to be_nil
+    expect(opts2.body).to eq("foo")
   end
 
 end

data/spec/http/options/callbacks_spec.rb

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
-describe Http::Options, "callbacks" do
+describe HTTP::Options, "callbacks" do
 
-  let(:opts){ Http::Options.new }
+  let(:opts){ HTTP::Options.new }
   let(:callback){ Proc.new{|r| nil } }
 
   it 'recognizes invalid events' do
-    lambda{
+    expect {
       opts.with_callback(:notacallback, callback)
-    }.should raise_error(ArgumentError, /notacallback/)
+    }.to raise_error(ArgumentError, /notacallback/)
   end
 
   it 'recognizes invalid callbacks' do
-    lambda{
+    expect {
       opts.with_callback(:request, Object.new)
-    }.should raise_error(ArgumentError, /invalid callback/)
-    lambda{
+    }.to raise_error(ArgumentError, /invalid callback/)
+    expect {
       opts.with_callback(:request, Proc.new{|a,b| nil})
-    }.should raise_error(ArgumentError, /only one argument/)
+    }.to raise_error(ArgumentError, /only one argument/)
   end
 
   describe "request" do
 
     it 'defaults to []' do
-      opts.callbacks[:request].should eq([])
+      expect(opts.callbacks[:request]).to eq([])
     end
 
     it 'may be specified with with_callback(:request, ...)' do
 
       opts2 = opts.with_callback(:request, callback)
-      opts.callbacks[:request].should eq([])
-      opts2.callbacks[:request].should eq([callback])
+      expect(opts.callbacks[:request]).to eq([])
+      expect(opts2.callbacks[:request]).to eq([callback])
 
       opts3 = opts2.with_callback(:request, callback)
-      opts2.callbacks[:request].should eq([callback])
-      opts3.callbacks[:request].should eq([callback, callback])
+      expect(opts2.callbacks[:request]).to eq([callback])
+      expect(opts3.callbacks[:request]).to eq([callback, callback])
     end
 
   end
@@ -42,18 +42,18 @@ describe Http::Options, "callbacks" do
   describe "response" do
 
     it 'defaults to []' do
-      opts.callbacks[:response].should eq([])
+      expect(opts.callbacks[:response]).to eq([])
     end
 
     it 'may be specified with with_callback(:response, ...)' do
 
       opts2 = opts.with_callback(:response, callback)
-      opts.callbacks[:response].should eq([])
-      opts2.callbacks[:response].should eq([callback])
+      expect(opts.callbacks[:response]).to eq([])
+      expect(opts2.callbacks[:response]).to eq([callback])
 
       opts3 = opts2.with_callback(:response, callback)
-      opts2.callbacks[:response].should eq([callback])
-      opts3.callbacks[:response].should eq([callback, callback])
+      expect(opts2.callbacks[:response]).to eq([callback])
+      expect(opts3.callbacks[:response]).to eq([callback, callback])
     end
 
   end

data/spec/http/options/form_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe Http::Options, "form" do
+describe HTTP::Options, "form" do
 
-  let(:opts){ Http::Options.new }
+  let(:opts){ HTTP::Options.new }
 
   it 'defaults to nil' do
-    opts.form.should be_nil
+    expect(opts.form).to be_nil
   end
 
   it 'may be specified with with_form_data' do
     opts2 = opts.with_form(:foo => 42)
-    opts.form.should be_nil
-    opts2.form.should eq(:foo => 42)
+    expect(opts.form).to be_nil
+    expect(opts2.form).to eq(:foo => 42)
   end
 
 end

data/spec/http/options/headers_spec.rb

@@ -1,29 +1,29 @@
 require 'spec_helper'
 
-describe Http::Options, "headers" do
+describe HTTP::Options, "headers" do
 
-  let(:opts)       { Http::Options.new }
-  let(:user_agent) { "RubyHttpGem/#{Http::VERSION}" }
+  let(:opts)       { HTTP::Options.new }
+  let(:user_agent) { "RubyHTTPGem/#{HTTP::VERSION}" }
 
   it 'defaults to just the user agent' do
-    opts.headers.should eq("User-Agent" => user_agent)
+    expect(opts.headers).to eq("User-Agent" => user_agent)
   end
 
   it 'may be specified with with_headers' do
     opts2 = opts.with_headers("accept" => "json")
-    opts.headers.should eq("User-Agent" => user_agent)
-    opts2.headers.should eq("accept" => "json", "User-Agent" => user_agent)
+    expect(opts.headers).to eq("User-Agent" => user_agent)
+    expect(opts2.headers).to eq("accept" => "json", "User-Agent" => user_agent)
   end
 
   it 'accepts any object that respond to :to_hash' do
     x = Struct.new(:to_hash).new("accept" => "json")
-    opts.with_headers(x).headers["accept"].should eq("json")
+    expect(opts.with_headers(x).headers["accept"]).to eq("json")
   end
 
   it 'recognizes invalid headers' do
-    lambda{
+    expect {
       opts.with_headers(self)
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
 end

data/spec/http/options/merge_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
-describe Http::Options, "merge" do
+describe HTTP::Options, "merge" do
 
-  let(:opts)       { Http::Options.new }
-  let(:user_agent) { "RubyHttpGem/#{Http::VERSION}" }
+  let(:opts)       { HTTP::Options.new }
+  let(:user_agent) { "RubyHTTPGem/#{HTTP::VERSION}" }
 
   it 'supports a Hash' do
     old_response = opts.response
-    opts.merge(:response => :body).response.should eq(:body)
-    opts.response.should eq(old_response)
+    expect(opts.merge(:response => :body).response).to eq(:body)
+    expect(opts.response).to eq(old_response)
   end
 
   it 'supports another Options' do
-    merged = opts.merge(Http::Options.new(:response => :body))
-    merged.response.should eq(:body)
+    merged = opts.merge(HTTP::Options.new(:response => :body))
+    expect(merged.response).to eq(:body)
   end
 
   it 'merges as excepted in complex cases' do
     # FIXME: yuck :(
 
-    foo = Http::Options.new(
+    foo = HTTP::Options.new(
       :response  => :body,
       :params      => {:baz => 'bar'},
       :form      => {:foo => 'foo'},
@@ -27,7 +27,7 @@ describe Http::Options, "merge" do
       :headers   => {:accept  => "json",  :foo => 'foo'},
       :proxy     => {},
       :callbacks => {:request => ["common"], :response => ["foo"]})
-    bar = Http::Options.new(
+    bar = HTTP::Options.new(
       :response  => :parsed_body,
       :params      => {:plop => 'plip'},
       :form      => {:bar => 'bar'},
@@ -35,9 +35,9 @@ describe Http::Options, "merge" do
       :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(
+    expect(foo.merge(bar).to_hash).to eq(
       :response  => :parsed_body,
-      :params=>{:plop=>"plip"}, 
+      :params=>{:plop=>"plip"},
       :form      => {:bar => 'bar'},
       :body      => "body-bar",
       :headers   => {:accept  => "xml", :foo => "foo", :bar => 'bar', "User-Agent" => user_agent},

data/spec/http/options/new_spec.rb

@@ -1,39 +1,39 @@
 require 'spec_helper'
 
-describe Http::Options, "new" do
-  let(:user_agent) { "RubyHttpGem/#{Http::VERSION}" }
+describe HTTP::Options, "new" do
+  let(:user_agent) { "RubyHTTPGem/#{HTTP::VERSION}" }
 
   it 'supports a Options instance' do
-    opts = Http::Options.new
-    Http::Options.new(opts).should eq(opts)
+    opts = HTTP::Options.new
+    expect(HTTP::Options.new(opts)).to eq(opts)
   end
 
   context 'with a Hash' do
     it 'coerces :response correctly' do
-      opts = Http::Options.new(:response => :object)
-      opts.response.should eq(:object)
+      opts = HTTP::Options.new(:response => :object)
+      expect(opts.response).to eq(:object)
     end
 
     it 'coerces :headers correctly' do
-      opts = Http::Options.new(:headers => {:accept => "json"})
-      opts.headers.should eq(:accept => "json", "User-Agent" => user_agent)
+      opts = HTTP::Options.new(:headers => {:accept => "json"})
+      expect(opts.headers).to eq(:accept => "json", "User-Agent" => user_agent)
     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)
+      opts = HTTP::Options.new(:proxy => {:proxy_address => "127.0.0.1", :proxy_port => 8080})
+      expect(opts.proxy).to eq(:proxy_address => "127.0.0.1", :proxy_port => 8080)
     end
 
     it 'coerces :form correctly' do
-      opts = Http::Options.new(:form => {:foo => 42})
-      opts.form.should eq(:foo => 42)
+      opts = HTTP::Options.new(:form => {:foo => 42})
+      expect(opts.form).to eq(:foo => 42)
     end
 
     it 'coerces :callbacks correctly' do
       before, after = Proc.new{|r| :before}, Proc.new{|r| :after}
       callbacks = {:request => [before], :response => [after]}
-      opts = Http::Options.new(:callbacks => callbacks)
-      opts.callbacks.should eq({
+      opts = HTTP::Options.new(:callbacks => callbacks)
+      expect(opts.callbacks).to eq({
         :request  => [before],
         :response => [after]
       })

data/spec/http/options/proxy_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe Http::Options, "proxy" do
+describe HTTP::Options, "proxy" do
 
-  let(:opts){ Http::Options.new }
+  let(:opts){ HTTP::Options.new }
 
   it 'defaults to {}' do
-    opts.proxy.should eq({})
+    expect(opts.proxy).to 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)
+    expect(opts.proxy).to eq({})
+    expect(opts2.proxy).to 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")
+    expect(opts2.proxy).to eq(:proxy_address => "127.0.0.1", :proxy_port => 8080, :proxy_username => "username", :proxy_password => "password")
   end
 end

data/spec/http/options/response_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
-describe Http::Options, "response" do
+describe HTTP::Options, "response" do
 
-  let(:opts){ Http::Options.new }
+  let(:opts){ HTTP::Options.new }
 
   it 'defaults to :auto' do
-    opts.response.should eq(:auto)
+    expect(opts.response).to eq(:auto)
   end
 
   it 'may be specified with with_response' do
     opts2 = opts.with_response(:body)
-    opts.response.should eq(:auto)
-    opts2.response.should eq(:body)
+    expect(opts.response).to eq(:auto)
+    expect(opts2.response).to eq(:body)
   end
 
   it 'recognizes invalid responses' do
-    lambda{
+    expect {
       opts.with_response(:not_a_valid_response)
-    }.should raise_error(ArgumentError, /not_a_valid_response/)
+    }.to raise_error(ArgumentError, /not_a_valid_response/)
   end
 
 end

data/spec/http/options_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe Http::Options do
+describe HTTP::Options do
   subject { described_class.new(:response => :body) }
 
   it "behaves like a Hash for reading" do
-    subject[:response].should eq(:body)
-    subject[:nosuchone].should be_nil
+    expect(subject[:response]).to eq(:body)
+    expect(subject[:nosuchone]).to be_nil
   end
 
   it "it's gois able to coerce to a Hash" do
-    subject.to_hash.should be_a(Hash)
-    subject.to_hash[:response].should eq(:body)
+    expect(subject.to_hash).to be_a(Hash)
+    expect(subject.to_hash[:response]).to eq(:body)
   end
 
   it "raises ArgumentError with invalid options" do

data/spec/http/request_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe HTTP::Request do
+  describe "headers" do
+    subject { HTTP::Request.new(:get, "http://example.com/", :accept => "text/html") }
+
+    it "sets explicit headers" do
+      expect(subject["Accept"]).to eq("text/html")
+    end
+
+    it "sets implicit headers" do
+      expect(subject["Host"]).to eq("example.com")
+    end
+
+    it "provides a #headers accessor" do
+      expect(subject.headers).to eq("Accept" => "text/html", "Host" => "example.com")
+    end
+  end
+end

data/spec/http/request_stream_spec.rb

@@ -1,26 +1,25 @@
 require 'spec_helper'
 
-describe Http::RequestStream do
+describe HTTP::RequestStream do
   describe "#initalize" do
     def construct(body)
-      Http::RequestStream.new(nil, body, [], "")
+      HTTP::RequestStream.new(nil, body, [], "")
     end
 
     it "doesn't throw on a nil body" do
-      expect {construct []}.to_not raise_error(ArgumentError)
+      expect {construct []}.not_to raise_error
     end
 
     it "doesn't throw on a String body" do
-      expect {construct "string body"}.to_not raise_error(ArgumentError)
+      expect {construct "string body"}.not_to raise_error
     end
 
     it "doesn't throw on an Enumerable body" do
-      expect {construct ["bees", "cows"]}.to_not raise_error(ArgumentError)
+      expect {construct ["bees", "cows"]}.not_to raise_error
     end
 
     it "does throw on a body that isn't string, enumerable or nil" do
-      expect {construct true}.to raise_error(ArgumentError)
-
+      expect {construct true}.to raise_error
     end
   end
 end