http 0.1.0 → 0.2.0

data/lib/http/request.rb

@@ -0,0 +1,42 @@
+module Http
+  class Request
+    # Method is given as a lowercase symbol e.g. :get, :post
+    attr_reader :method
+
+    # "Request URI" as per RFC 2616
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
+    attr_reader :uri
+    attr_reader :headers, :body, :version
+
+    # :nodoc:
+    def initialize(method, uri, headers = {}, body = nil, version = "1.1")
+      @method = method.to_s.downcase.to_sym
+      raise UnsupportedMethodError, "unknown method: #{method}" unless METHODS.include? @method
+
+      @uri = uri.is_a?(URI) ? uri : URI(uri.to_s)
+
+      @headers = {}
+      headers.each do |name, value|
+        name = name.to_s
+        key = name[CANONICAL_HEADER]
+        key ||= Http.canonicalize_header(name)
+        @headers[key] = value
+      end
+
+      @body, @version = body, version
+    end
+
+    # Obtain the given header
+    def [](header)
+      @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
+    end
+  end
+end

data/lib/http/response.rb

@@ -1,5 +1,62 @@
 module Http
   class Response
+    STATUS_CODES = {
+      100 => 'Continue',
+      101 => 'Switching Protocols',
+      102 => 'Processing',
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      203 => 'Non-Authoritative Information',
+      204 => 'No Content',
+      205 => 'Reset Content',
+      206 => 'Partial Content',
+      207 => 'Multi-Status',
+      226 => 'IM Used',
+      300 => 'Multiple Choices',
+      301 => 'Moved Permanently',
+      302 => 'Found',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      306 => 'Reserved',
+      307 => 'Temporary Redirect',
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Timeout',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request-URI Too Long',
+      415 => 'Unsupported Media Type',
+      416 => 'Requested Range Not Satisfiable',
+      417 => 'Expectation Failed',
+      418 => "I'm a Teapot",
+      422 => 'Unprocessable Entity',
+      423 => 'Locked',
+      424 => 'Failed Dependency',
+      426 => 'Upgrade Required',
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Timeout',
+      505 => 'HTTP Version Not Supported',
+      506 => 'Variant Also Negotiates',
+      507 => 'Insufficient Storage',
+      510 => 'Not Extended'
+    }
+
+    SYMBOL_TO_STATUS_CODE = Hash[STATUS_CODES.map { |code, msg| [msg.downcase.gsub(/\s|-/, '_').to_sym, code] }]
+
     attr_accessor :status
     attr_accessor :headers
     attr_accessor :body
@@ -15,9 +72,13 @@ module Http
       @headers = {}
     end
 
-    # Set a header value
-    def []=(header, value)
-      key = header.to_s.downcase
+    # Set a header
+    def []=(name, value)
+      # If we have a canonical header, we're done
+      key = name[CANONICAL_HEADER]
+
+      # Convert to canonical capitalization
+      key ||= Http.canonicalize_header(name)
 
       # Check if the header has already been set and group
       old_value = @headers[key]
@@ -29,18 +90,23 @@ module Http
     end
 
     # Get a header value
-    def [](header)
-      @headers[header.to_s.downcase]
+    def [](name)
+      @headers[name] || @headers[Http.canonicalize_header(name)]
     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]
+      if @headers['Content-Type']
+        mime_type = MimeType[@headers['Content-Type'].split(/;\s*/).first]
         return mime_type.parse(@body) if mime_type
       end
 
       @body
     end
+
+    # Returns an Array ala Rack: `[status, headers, body]`
+    def to_a
+      [status, headers, parse_body]
+    end
   end
 end

data/lib/http/uri_backport.rb

@@ -0,0 +1,131 @@
+# Taken from Ruby 1.9's uri/common.rb
+# By Akira Yamada <akira@ruby-lang.org>
+# License:
+#   You can redistribute it and/or modify it under the same term as Ruby.
+
+require 'uri'
+
+# Backport Ruby 1.9's form encoding/decoding functionality
+module URI
+  TBLENCWWWCOMP_ = {} # :nodoc:
+  256.times do |i|
+    TBLENCWWWCOMP_[i.chr] = '%%%02X' % i
+  end
+  TBLENCWWWCOMP_[' '] = '+'
+  TBLENCWWWCOMP_.freeze
+  TBLDECWWWCOMP_ = {} # :nodoc:
+  256.times do |i|
+    h, l = i>>4, i&15
+    TBLDECWWWCOMP_['%%%X%X' % [h, l]] = i.chr
+    TBLDECWWWCOMP_['%%%x%X' % [h, l]] = i.chr
+    TBLDECWWWCOMP_['%%%X%x' % [h, l]] = i.chr
+    TBLDECWWWCOMP_['%%%x%x' % [h, l]] = i.chr
+  end
+  TBLDECWWWCOMP_['+'] = ' '
+  TBLDECWWWCOMP_.freeze
+
+  # Encode given +str+ to URL-encoded form data.
+  #
+  # This method doesn't convert *, -, ., 0-9, A-Z, _, a-z, but does convert SP
+  # (ASCII space) to + and converts others to %XX.
+  #
+  # This is an implementation of
+  # http://www.w3.org/TR/html5/association-of-controls-and-forms.html#url-encoded-form-data
+  #
+  # See URI.decode_www_form_component, URI.encode_www_form
+  def self.encode_www_form_component(str)
+    str.to_s.gsub(/[^*\-.0-9A-Z_a-z]/) { |chr| TBLENCWWWCOMP_[chr] }
+  end
+
+  # Decode given +str+ of URL-encoded form data.
+  #
+  # This decods + to SP.
+  #
+  # See URI.encode_www_form_component, URI.decode_www_form
+  def self.decode_www_form_component(str)
+    raise ArgumentError, "invalid %-encoding (#{str})" unless /\A[^%]*(?:%\h\h[^%]*)*\z/ =~ str
+    str.gsub(/\+|%\h\h/) { |chr| TBLDECWWWCOMP_[chr] }
+  end
+
+  # Generate URL-encoded form data from given +enum+.
+  #
+  # This generates application/x-www-form-urlencoded data defined in HTML5
+  # from given an Enumerable object.
+  #
+  # This internally uses URI.encode_www_form_component(str).
+  #
+  # This method doesn't convert the encoding of given items, so convert them
+  # before call this method if you want to send data as other than original
+  # encoding or mixed encoding data. (Strings which are encoded in an HTML5
+  # ASCII incompatible encoding are converted to UTF-8.)
+  #
+  # This method doesn't handle files.  When you send a file, use
+  # multipart/form-data.
+  #
+  # This is an implementation of
+  # http://www.w3.org/TR/html5/forms.html#url-encoded-form-data
+  #
+  #    URI.encode_www_form([["q", "ruby"], ["lang", "en"]])
+  #    #=> "q=ruby&lang=en"
+  #    URI.encode_www_form("q" => "ruby", "lang" => "en")
+  #    #=> "q=ruby&lang=en"
+  #    URI.encode_www_form("q" => ["ruby", "perl"], "lang" => "en")
+  #    #=> "q=ruby&q=perl&lang=en"
+  #    URI.encode_www_form([["q", "ruby"], ["q", "perl"], ["lang", "en"]])
+  #    #=> "q=ruby&q=perl&lang=en"
+  #
+  # See URI.encode_www_form_component, URI.decode_www_form
+  def self.encode_www_form(enum)
+    enum.map do |k,v|
+      if v.nil?
+        encode_www_form_component(k)
+      elsif v.respond_to?(:to_ary)
+        v.to_ary.map do |w|
+          str = encode_www_form_component(k)
+          unless w.nil?
+            str << '='
+            str << encode_www_form_component(w)
+          end
+        end.join('&')
+      else
+        str = encode_www_form_component(k)
+        str << '='
+        str << encode_www_form_component(v)
+      end
+    end.join('&')
+  end
+
+  WFKV_ = '(?:[^%#=;&]*(?:%\h\h[^%#=;&]*)*)' # :nodoc:
+
+  # Decode URL-encoded form data from given +str+.
+  #
+  # This decodes application/x-www-form-urlencoded data
+  # and returns array of key-value array.
+  # This internally uses URI.decode_www_form_component.
+  #
+  # _charset_ hack is not supported now because the mapping from given charset
+  # to Ruby's encoding is not clear yet.
+  # see also http://www.w3.org/TR/html5/syntax.html#character-encodings-0
+  #
+  # This refers http://www.w3.org/TR/html5/forms.html#url-encoded-form-data
+  #
+  # ary = URI.decode_www_form("a=1&a=2&b=3")
+  # p ary                  #=> [['a', '1'], ['a', '2'], ['b', '3']]
+  # p ary.assoc('a').last  #=> '1'
+  # p ary.assoc('b').last  #=> '3'
+  # p ary.rassoc('a').last #=> '2'
+  # p Hash[ary]            # => {"a"=>"2", "b"=>"3"}
+  #
+  # See URI.decode_www_form_component, URI.encode_www_form
+  def self.decode_www_form(str)
+    return [] if str.empty?
+    unless /\A#{WFKV_}=#{WFKV_}(?:[;&]#{WFKV_}=#{WFKV_})*\z/o =~ str
+      raise ArgumentError, "invalid data of application/x-www-form-urlencoded (#{str})"
+    end
+    ary = []
+    $&.scan(/([^=;&]+)=([^;&]*)/) do
+      ary << [decode_www_form_component($1), decode_www_form_component($2)]
+    end
+    ary
+  end
+end

data/lib/http/version.rb

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

data/spec/http/compat/curb_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'http/compat/curb'
 
 describe Curl do
-  let(:test_endpoint)  { "http://127.0.0.1:#{TEST_SERVER_PORT}/" }
+  let(:test_endpoint)  { "http://127.0.0.1:#{ExampleService::PORT}/" }
 
   describe Curl::Easy do
     it "gets resources" do

data/spec/http/options/callbacks_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Http::Options, "callbacks" do
+
+  let(:opts){ Http::Options.new }
+  let(:callback){ Proc.new{|r| nil } }
+
+  it 'recognizes invalid events' do
+    lambda{
+      opts.with_callback(:notacallback, callback)
+    }.should raise_error(ArgumentError, /notacallback/)
+  end
+
+  it 'recognizes invalid callbacks' do
+    lambda{
+      opts.with_callback(:request, Object.new)
+    }.should raise_error(ArgumentError, /invalid callback/)
+    lambda{
+      opts.with_callback(:request, Proc.new{|a,b| nil})
+    }.should raise_error(ArgumentError, /only one argument/)
+  end
+
+  describe "request" do
+
+    it 'defaults to []' do
+      opts.callbacks[:request].should 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])
+
+      opts3 = opts2.with_callback(:request, callback)
+      opts2.callbacks[:request].should eq([callback])
+      opts3.callbacks[:request].should eq([callback, callback])
+    end
+
+  end
+
+  describe "response" do
+
+    it 'defaults to []' do
+      opts.callbacks[:response].should 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])
+
+      opts3 = opts2.with_callback(:response, callback)
+      opts2.callbacks[:response].should eq([callback])
+      opts3.callbacks[:response].should eq([callback, callback])
+    end
+
+  end
+
+end
+

data/spec/http/options/form_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Http::Options, "form" do
+
+  let(:opts){ Http::Options.new }
+
+  it 'defaults to nil' do
+    opts.form.should 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)
+  end
+
+end
+

data/spec/http/options/headers_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Http::Options, "headers" do
+
+  let(:opts){ Http::Options.new }
+
+  it 'defaults to {}' do
+    opts.headers.should eq({})
+  end
+
+  it 'may be specified with with_headers' do
+    opts2 = opts.with_headers("accept" => "json")
+    opts.headers.should eq({})
+    opts2.headers.should eq("accept" => "json")
+  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")
+  end
+
+  it 'recognizes invalid headers' do
+    lambda{
+      opts.with_headers(self)
+    }.should raise_error(ArgumentError)
+  end
+
+end
+

data/spec/http/options/merge_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Http::Options, "merge" do
+
+  let(:opts){ Http::Options.new }
+
+  it 'supports a Hash' do
+    old_response = opts.response
+    opts.merge(:response => :body).response.should eq(:body)
+    opts.response.should eq(old_response)
+  end
+
+  it 'supports another Options' do
+    merged = opts.merge(Http::Options.new(:response => :body))
+    merged.response.should eq(:body)
+  end
+
+  it 'merges as excepted in complex cases' do
+    foo = Http::Options.new(
+      :response  => :body,
+      :form      => {:foo => 'foo'},
+      :headers   => {:accept  => "json",  :foo => 'foo'},
+      :callbacks => {:request => ["common"], :response => ["foo"]})
+    bar = Http::Options.new(
+      :response  => :parsed_body,
+      :form      => {:bar => 'bar'},
+      :headers   => {:accept  => "xml", :bar => 'bar'},
+      :callbacks => {:request => ["common"], :response => ["bar"]})
+    foo.merge(bar).to_hash.should eq(
+      :response  => :parsed_body,
+      :form      => {:bar => 'bar'},
+      :headers   => {:accept  => "xml", :foo => "foo", :bar => 'bar'},
+      :callbacks => {:request => ["common"], :response => ["foo", "bar"]}
+    )
+  end
+
+end