httpclient 2.1.5 → 2.8.3

data/lib/httpclient/http.rb

@@ -1,5 +1,7 @@
+# -*- encoding: utf-8 -*-
+
 # HTTPClient - HTTP client library.
-# Copyright (C) 2000-2009  NAKAMURA, Hiroshi  <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2015  NAKAMURA, Hiroshi  <nahi@ruby-lang.org>.
 #
 # This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
 # redistribute it and/or modify it under the same terms of Ruby's license;
@@ -7,6 +9,10 @@
 
 
 require 'time'
+if defined?(Encoding::ASCII_8BIT)
+  require 'open-uri' # for encoding
+end
+require 'httpclient/util'
 
 
 # A namespace module for HTTP Message definitions used by HTTPClient.
@@ -90,12 +96,13 @@ module HTTP
   #     p res.header['last-modified'].first
   #
   class Message
+    include HTTPClient::Util
 
     CRLF = "\r\n"
 
     # Represents HTTP message header.
     class Headers
-      # HTTP version in a HTTP header.  Float.
+      # HTTP version in a HTTP header.  String.
       attr_accessor :http_version
       # Size of body.  nil when size is unknown (e.g. chunked response).
       attr_reader :body_size
@@ -109,7 +116,7 @@ module HTTP
       # Request only.  Requested query.
       attr_accessor :request_query
       # Request only.  Requested via proxy or not.
-      attr_accessor :request_via_proxy
+      attr_accessor :request_absolute_uri
 
       # Response only.  HTTP status
       attr_reader :status_code
@@ -122,6 +129,8 @@ module HTTP
       attr_accessor :body_charset # :nodoc:
       # Used for dumping response.
       attr_accessor :body_date # :nodoc:
+      # Used for keeping content encoding.
+      attr_reader :body_encoding # :nodoc:
 
       # HTTP response status code to reason phrase mapping definition.
       STATUS_CODE_MAP = {
@@ -151,14 +160,14 @@ module HTTP
       # Creates a Message::Headers.  Use init_request, init_response, or
       # init_connect_request for acutual initialize.
       def initialize
-        @http_version = 1.1
+        @http_version = '1.1'
         @body_size = nil
         @chunked = false
 
         @request_method = nil
         @request_uri = nil
         @request_query = nil
-        @request_via_proxy = nil
+        @request_absolute_uri = nil
 
         @status_code = nil
         @reason_phrase = nil
@@ -166,6 +175,7 @@ module HTTP
         @body_type = nil
         @body_charset = nil
         @body_date = nil
+        @body_encoding = nil
 
         @is_request = nil
         @header_item = []
@@ -178,24 +188,31 @@ module HTTP
         @request_method = 'CONNECT'
         @request_uri = uri
         @request_query = nil
-        @http_version = 1.0
+        @http_version = '1.0'
       end
 
       # Placeholder URI object for nil uri.
-      NIL_URI = URI.parse('http://nil-uri-given/')
+      NIL_URI = HTTPClient::Util.urify('http://nil-uri-given/')
       # Initialize this instance as a general request.
       def init_request(method, uri, query = nil)
         @is_request = true
         @request_method = method
         @request_uri = uri || NIL_URI
         @request_query = query
-        @request_via_proxy = false
+        @request_absolute_uri = false
+        self
       end
 
       # Initialize this instance as a response.
-      def init_response(status_code)
+      def init_response(status_code, req = nil)
         @is_request = false
         self.status_code = status_code
+        if req
+          @request_method = req.request_method
+          @request_uri = req.request_uri
+          @request_query = req.request_query
+        end
+        self
       end
 
       # Sets status code and reason phrase.
@@ -205,14 +222,31 @@ module HTTP
       end
 
       # Returns 'Content-Type' header value.
-      def contenttype
+      def content_type
         self['Content-Type'][0]
       end
 
       # Sets 'Content-Type' header value.  Overrides if already exists.
-      def contenttype=(contenttype)
+      def content_type=(content_type)
         delete('Content-Type')
-        self['Content-Type'] = contenttype
+        self['Content-Type'] = content_type
+      end
+
+      alias contenttype content_type
+      alias contenttype= content_type=
+
+      if defined?(Encoding::ASCII_8BIT)
+        def set_body_encoding
+          if type = self.content_type
+            OpenURI::Meta.init(o = '')
+            o.meta_add_field('content-type', type)
+            @body_encoding = o.encoding
+          end
+        end
+      else
+        def set_body_encoding
+          @body_encoding = nil
+        end
       end
 
       # Sets byte size of message body.
@@ -235,6 +269,11 @@ module HTTP
         }.join
       end
 
+      # Set Date header
+      def set_date_header
+        set('Date', Time.now.httpdate)
+      end
+
       # Adds a header.  Addition order is preserved.
       def add(key, value)
         if value.is_a?(Array)
@@ -285,11 +324,45 @@ module HTTP
         get(key).collect { |item| item[1] }
       end
 
+      def set_headers(headers)
+        headers.each do |key, value|
+          add(key, value)
+        end
+        set_body_encoding
+      end
+
+      def create_query_uri()
+        if @request_method == 'CONNECT'
+          return "#{@request_uri.host}:#{@request_uri.port}"
+        end
+        path = @request_uri.path
+        path = '/' if path.nil? or path.empty?
+        if query_str = create_query_part()
+          path += "?#{query_str}"
+        end
+        path
+      end
+
+      def create_query_part()
+        query_str = nil
+        if @request_uri.query
+          query_str = @request_uri.query
+        end
+        if @request_query
+          if query_str
+            query_str += "&#{Message.create_query_part_str(@request_query)}"
+          else
+            query_str = Message.create_query_part_str(@request_query)
+          end
+        end
+        query_str
+      end
+
     private
 
       def request_line
-        path = create_query_uri(@request_uri, @request_query)
-        if @request_via_proxy
+        path = create_query_uri()
+        if @request_absolute_uri
           path = "#{ @request_uri.scheme }://#{ @request_uri.host }:#{ @request_uri.port }#{ path }"
         end
         "#{ @request_method } #{ path } HTTP/#{ @http_version }#{ CRLF }"
@@ -323,12 +396,12 @@ module HTTP
         elsif @body_size and (keep_alive or @body_size != 0)
           set('Content-Length', @body_size.to_s)
         end
-        if @http_version >= 1.1
+        if @http_version >= '1.1' and get('Host').empty?
           if @request_uri.port == @request_uri.default_port
             # GFE/1.3 dislikes default port number (returns 404)
-            set('Host', "#{@request_uri.host}")
+            set('Host', "#{@request_uri.hostname}")
           else
-            set('Host', "#{@request_uri.host}:#{@request_uri.port}")
+            set('Host', "#{@request_uri.hostname}:#{@request_uri.port}")
           end
         end
       end
@@ -337,7 +410,7 @@ module HTTP
         return if @dumped
         @dumped = true
         if defined?(Apache) && self['Date'].empty?
-          set('Date', Time.now.httpdate)
+          set_date_header
         end
         keep_alive = Message.keep_alive_enabled?(@http_version)
         if @chunked
@@ -351,35 +424,17 @@ module HTTP
           set('Last-Modified', @body_date.httpdate)
         end
         if self['Content-Type'].empty?
-          set('Content-Type', "#{ @body_type || 'text/html' }; charset=#{ charset_label(@body_charset || $KCODE) }")
+          set('Content-Type', "#{ @body_type || 'text/html' }; charset=#{ charset_label }")
         end
       end
 
-      def charset_label(charset)
-        CHARSET_MAP[charset] || 'us-ascii'
-      end
-
-      def create_query_uri(uri, query)
-        if @request_method == 'CONNECT'
-          return "#{uri.host}:#{uri.port}"
-        end
-        path = uri.path
-        path = '/' if path.nil? or path.empty?
-        query_str = nil
-        if uri.query
-          query_str = uri.query
-        end
-        if query
-          if query_str
-            query_str += "&#{Message.create_query_part_str(query)}"
-          else
-            query_str = Message.create_query_part_str(query)
-          end
-        end
-        if query_str
-          path += "?#{query_str}"
+      def charset_label
+        # TODO: should handle response encoding for 1.9 correctly.
+        if RUBY_VERSION > "1.9"
+          CHARSET_MAP[@body_charset] || 'us-ascii'
+        else
+          CHARSET_MAP[@body_charset || $KCODE] || 'us-ascii'
         end
-        path
       end
     end
 
@@ -390,6 +445,8 @@ module HTTP
       attr_reader :size
       # maxbytes of IO#read for streaming request.  See DEFAULT_CHUNK_SIZE.
       attr_accessor :chunk_size
+      # Hash that keeps IO positions
+      attr_accessor :positions
 
       # Default value for chunk_size
       DEFAULT_CHUNK_SIZE = 1024 * 16
@@ -409,16 +466,20 @@ module HTTP
         @positions = {}
         set_content(body, boundary)
         @chunk_size = DEFAULT_CHUNK_SIZE
+        self
       end
 
       # Initialize this instance as a response.
       def init_response(body = nil)
         @body = body
-        if @body.respond_to?(:size)
+        if @body.respond_to?(:bytesize)
+          @size = @body.bytesize
+        elsif @body.respond_to?(:size)
           @size = @body.size
         else
           @size = nil
         end
+        self
       end
 
       # Dumps message body to given dev.
@@ -428,20 +489,23 @@ module HTTP
       # reason. (header is dumped to dev, too)
       # If no dev (the second argument) given, this method returns a dumped
       # String.
+      #
+      # assert: @size is not nil
       def dump(header = '', dev = '')
         if @body.is_a?(Parts)
           dev << header
-          buf = ''
           @body.parts.each do |part|
             if Message.file?(part)
               reset_pos(part)
-              while !part.read(@chunk_size, buf).nil?
-                dev << buf
-              end
+              dump_file(part, dev, @body.sizes[part])
             else
               dev << part
             end
           end
+        elsif Message.file?(@body)
+          dev << header
+          reset_pos(@body)
+          dump_file(@body, dev, @size)
         elsif @body
           dev << header + @body
         else
@@ -485,30 +549,41 @@ module HTTP
     private
 
       def set_content(body, boundary = nil)
-        if body.respond_to?(:read)
-          # uses Transfer-Encoding: chunked.  bear in mind that server may not
-          # support it.  at least ruby's CGI doesn't.
+        if Message.file?(body)
+          # uses Transfer-Encoding: chunked if body does not respond to :size.
+          # bear in mind that server may not support it. at least ruby's CGI doesn't.
           @body = body
           remember_pos(@body)
-          @size = nil
+          @size = body.respond_to?(:size) ? body.size - body.pos : nil
         elsif boundary and Message.multiparam_query?(body)
           @body = build_query_multipart_str(body, boundary)
           @size = @body.size
         else
           @body = Message.create_query_part_str(body)
-          @size = @body.size
+          @size = @body.bytesize
         end
       end
 
       def remember_pos(io)
         # IO may not support it (ex. IO.pipe)
-        @positions[io] = io.pos rescue nil
+        @positions[io] = io.pos if io.respond_to?(:pos)
       end
 
       def reset_pos(io)
         io.pos = @positions[io] if @positions.key?(io)
       end
 
+      def dump_file(io, dev, sz)
+        buf = ''
+        rest = sz
+        while rest > 0
+          n = io.read([rest, @chunk_size].min, buf)
+          raise ArgumentError.new("Illegal size value: #size returns #{sz} but cannot read") if n.nil?
+          dev << buf
+          rest -= n.bytesize
+        end
+      end
+
       def dump_chunks(io, dev)
         buf = ''
         while !io.read(@chunk_size, buf).nil?
@@ -517,7 +592,7 @@ module HTTP
       end
 
       def dump_chunk(str)
-        dump_chunk_size(str.size) + (str + CRLF)
+        dump_chunk_size(str.bytesize) + (str + CRLF)
       end
 
       def dump_last_chunk
@@ -530,10 +605,12 @@ module HTTP
 
       class Parts
         attr_reader :size
+        attr_reader :sizes
 
         def initialize
           @body = []
-          @size = 0
+          @sizes = {}
+          @size = 0 # total
           @as_stream = false
         end
 
@@ -541,24 +618,27 @@ module HTTP
           if Message.file?(part)
             @as_stream = true
             @body << part
-            if part.respond_to?(:size)
+            if part.respond_to?(:lstat)
+              sz = part.lstat.size
+              add_size(part, sz)
+            elsif part.respond_to?(:size)
               if sz = part.size
-                @size += sz
+                add_size(part, sz)
               else
+                @sizes.clear
                 @size = nil
               end
-            elsif part.respond_to?(:lstat)
-              @size += part.lstat.size
             else
               # use chunked upload
+              @sizes.clear
               @size = nil
             end
           elsif @body[-1].is_a?(String)
             @body[-1] += part.to_s
-            @size += part.to_s.size if @size
+            @size += part.to_s.bytesize if @size
           else
             @body << part.to_s
-            @size += part.to_s.size if @size
+            @size += part.to_s.bytesize if @size
           end
         end
 
@@ -569,12 +649,20 @@ module HTTP
             [@body.join]
           end
         end
+
+      private
+
+        def add_size(part, sz)
+          if @size
+            @sizes[part] = sz
+            @size += sz
+          end
+        end
       end
 
       def build_query_multipart_str(query, boundary)
         parts = Parts.new
         query.each do |attr, value|
-          value ||= ''
           headers = ["--#{boundary}"]
           if Message.file?(value)
             remember_pos(value)
@@ -583,13 +671,24 @@ module HTTP
             }.join("; ")
             if value.respond_to?(:mime_type)
               content_type = value.mime_type
+            elsif value.respond_to?(:content_type)
+              content_type = value.content_type
             else
-              content_type = Message.mime_type(value.path)
+              path = value.respond_to?(:path) ? value.path : nil
+              content_type = Message.mime_type(path)
             end
             headers << %{Content-Disposition: form-data; name="#{attr}"; #{param_str}}
             headers << %{Content-Type: #{content_type}}
+          elsif attr.is_a?(Hash)
+            h = attr
+            value = h[:content]
+            h.each do |h_key, h_val|
+              headers << %{#{h_key}: #{h_val}} if h_key != :content
+            end
+            remember_pos(value) if Message.file?(value)
           else
             headers << %{Content-Disposition: form-data; name="#{attr}"}
+            value = value.to_s
           end
           parts.add(headers.join(CRLF) + CRLF + CRLF)
           parts.add(value)
@@ -601,7 +700,9 @@ module HTTP
 
       def params_from_file(value)
         params = {}
-        params['filename'] = File.basename(value.path || '')
+        original_filename = value.respond_to?(:original_filename) ? value.original_filename : nil
+        path = value.respond_to?(:path) ? value.path : nil
+        params['filename'] = original_filename || File.basename(path || '')
         # Creation time is not available from File::Stat
         if value.respond_to?(:mtime)
           params['modification-date'] = value.mtime.rfc822
@@ -622,8 +723,8 @@ module HTTP
       # uri:: an URI that need to connect.  Only uri.host and uri.port are used.
       def new_connect_request(uri)
         m = new
-        m.header.init_connect_request(uri)
-        m.header.body_size = nil
+        m.http_header.init_connect_request(uri)
+        m.http_header.body_size = nil
         m
       end
 
@@ -642,26 +743,26 @@ module HTTP
       #            a multipart/form-data using this boundary String.
       def new_request(method, uri, query = nil, body = nil, boundary = nil)
         m = new
-        m.header.init_request(method, uri, query)
-        m.body = Body.new
-        m.body.init_request(body || '', boundary)
+        m.http_header.init_request(method, uri, query)
+        m.http_body = Body.new
+        m.http_body.init_request(body || '', boundary)
         if body
-          m.header.body_size = m.body.size
-          m.header.chunked = true if m.body.size.nil?
+          m.http_header.body_size = m.http_body.size
+          m.http_header.chunked = true if m.http_body.size.nil?
         else
-          m.header.body_size = nil
+          m.http_header.body_size = nil
         end
         m
       end
 
       # Creates a Message instance of response.
       # body:: a String or an IO of response message body.
-      def new_response(body)
+      def new_response(body, req = nil)
         m = new
-        m.header.init_response(Status::OK)
-        m.body = Body.new
-        m.body.init_response(body)
-        m.header.body_size = m.body.size || 0
+        m.http_header.init_response(Status::OK, req)
+        m.http_body = Body.new
+        m.http_body.init_response(body)
+        m.http_header.body_size = m.http_body.size || 0
         m
       end
 
@@ -708,6 +809,8 @@ module HTTP
         case path
         when /\.txt$/i
           'text/plain'
+        when /\.xml$/i
+          'text/xml'
         when /\.(htm|html)$/i
           'text/html'
         when /\.doc$/i
@@ -724,9 +827,9 @@ module HTTP
       end
 
       # Returns true if the given HTTP version allows keep alive connection.
-      # version:: Float
+      # version:: String
       def keep_alive_enabled?(version)
-        version >= 1.1
+        version >= '1.1'
       end
 
       # Returns true if the given query (or body) has a multiple parameter.
@@ -736,15 +839,14 @@ module HTTP
 
       # Returns true if the given object is a File.  In HTTPClient, a file is;
       # * must respond to :read for retrieving String chunks.
-      # * must respond to :path and returns a path for Content-Disposition.
       # * must respond to :pos and :pos= to rewind for reading.
       #   Rewinding is only needed for following HTTP redirect.  Some IO impl
       #   defines :pos= but raises an Exception for pos= such as StringIO
       #   but there's no problem as far as using it for non-following methods
       #   (get/post/etc.)
       def file?(obj)
-        obj.respond_to?(:read) and obj.respond_to?(:path) and
-          obj.respond_to?(:pos) and obj.respond_to?(:pos=)
+        obj.respond_to?(:read) and obj.respond_to?(:pos) and
+          obj.respond_to?(:pos=)
       end
 
       def create_query_part_str(query) # :nodoc:
@@ -757,50 +859,107 @@ module HTTP
         end
       end
 
+      def Array.try_convert(value)
+        return value if value.instance_of?(Array)
+        return nil if !value.respond_to?(:to_ary)
+        converted = value.to_ary
+        return converted if converted.instance_of?(Array)
+
+        cname = value.class.name
+        raise TypeError, "can't convert %s to %s (%s#%s gives %s)" %
+          [cname, Array.name, cname, :to_ary, converted.class.name]
+      end unless Array.respond_to?(:try_convert)
+
       def escape_query(query) # :nodoc:
-        query.collect { |attr, value|
-          if value.respond_to?(:read)
-            value = value.read
+        pairs = []
+        query.each { |attr, value|
+          left = escape(attr.to_s) << '='
+          if values = Array.try_convert(value)
+            values.each { |v|
+              if v.respond_to?(:read)
+                v = v.read
+              end
+              pairs.push(left + escape(v.to_s))
+            }
+          else
+            if value.respond_to?(:read)
+              value = value.read
+            end
+            pairs.push(left << escape(value.to_s))
           end
-          escape(attr.to_s) << '=' << escape(value.to_s)
-        }.join('&')
+        }
+        pairs.join('&')
       end
 
       # from CGI.escape
-      def escape(str) # :nodoc:
-        str.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-          '%' + $1.unpack('H2' * $1.size).join('%').upcase
-        }.tr(' ', '+')
+      if defined?(Encoding::ASCII_8BIT)
+        def escape(str) # :nodoc:
+          str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(/([^ a-zA-Z0-9_.-]+)/) {
+            '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+          }.tr(' ', '+')
+        end
+      else
+        def escape(str) # :nodoc:
+          str.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+            '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+          }.tr(' ', '+')
+        end
+      end
+
+      # from CGI.parse
+      def parse(query)
+        params = Hash.new([].freeze)
+        query.split(/[&;]/n).each do |pairs|
+          key, value = pairs.split('=',2).collect{|v| unescape(v) }
+          if params.has_key?(key)
+            params[key].push(value)
+          else
+            params[key] = [value]
+          end
+        end
+        params
+      end
+
+      # from CGI.unescape
+      def unescape(string)
+        string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+          [$1.delete('%')].pack('H*')
+        end
       end
     end
 
 
     # HTTP::Message::Headers:: message header.
-    attr_accessor :header
+    attr_accessor :http_header
 
     # HTTP::Message::Body:: message body.
-    attr_reader :body
+    attr_reader :http_body
 
     # OpenSSL::X509::Certificate:: response only.  server certificate which is
     #                              used for retrieving the response.
     attr_accessor :peer_cert
 
+    # The other Message object when this Message is generated instead of
+    # the Message because of redirection, negotiation, or format conversion.
+    attr_accessor :previous
+
     # Creates a Message.  This method should be used internally.
     # Use Message.new_connect_request, Message.new_request or
     # Message.new_response instead.
     def initialize # :nodoc:
-      @header = Headers.new
-      @body = @peer_cert = nil
+      @http_header = Headers.new
+      @http_body = @peer_cert = nil
+      @previous = nil
     end
 
     # Dumps message (header and body) to given dev.
     # dev needs to respond to <<.
     def dump(dev = '')
-      str = header.dump + CRLF
-      if header.chunked
-        dev = body.dump_chunked(str, dev)
-      elsif body
-        dev = body.dump(str, dev)
+      str = @http_header.dump + CRLF
+      if @http_header.chunked
+        dev = @http_body.dump_chunked(str, dev)
+      elsif @http_body
+        dev = @http_body.dump(str, dev)
       else
         dev << str
       end
@@ -808,24 +967,36 @@ module HTTP
     end
 
     # Sets a new body.  header.body_size is updated with new body.size.
-    def body=(body)
-      @body = body
-      @header.body_size = @body.size if @header
+    def http_body=(body)
+      @http_body = body
+      @http_header.body_size = @http_body.size if @http_header
+    end
+    alias body= http_body=
+
+    # Returns HTTP version in a HTTP header.  String.
+    def http_version
+      @http_header.http_version
+    end
+
+    # Sets HTTP version in a HTTP header.  String.
+    def http_version=(http_version)
+      @http_header.http_version = http_version
     end
 
-    # Returns HTTP version in a HTTP header.  Float.
+    VERSION_WARNING = 'Message#version (Float) is deprecated. Use Message#http_version (String) instead.'
     def version
-      @header.http_version
+      warning(VERSION_WARNING)
+      @http_header.http_version.to_f
     end
 
-    # Sets HTTP version in a HTTP header.  Float.
     def version=(version)
-      @header.http_version = version
+      warning(VERSION_WARNING)
+      @http_header.http_version = version
     end
 
     # Returns HTTP status code in response.  Integer.
     def status
-      @header.status_code
+      @http_header.status_code
     end
 
     alias code status
@@ -834,34 +1005,78 @@ module HTTP
     # Sets HTTP status code of response.  Integer.
     # Reason phrase is updated, too.
     def status=(status)
-      @header.status_code = status
+      @http_header.status_code = status
     end
 
     # Returns  HTTP status reason phrase in response.  String.
     def reason
-      @header.reason_phrase
+      @http_header.reason_phrase
     end
 
     # Sets  HTTP status reason phrase of response.  String.
     def reason=(reason)
-      @header.reason_phrase = reason
+      @http_header.reason_phrase = reason
+    end
+
+    # Returns 'Content-Type' header value.
+    def content_type
+      @http_header.content_type
     end
 
     # Sets 'Content-Type' header value.  Overrides if already exists.
-    def contenttype
-      @header.contenttype
+    def content_type=(content_type)
+      @http_header.content_type = content_type
     end
+    alias contenttype content_type
+    alias contenttype= content_type=
 
-    # Returns 'Content-Type' header value.
-    def contenttype=(contenttype)
-      @header.contenttype = contenttype
+    # Returns content encoding
+    def body_encoding
+      @http_header.body_encoding
     end
 
     # Returns a content of message body.  A String or an IO.
     def content
-      @body.content
+      @http_body.content
     end
-  end
 
+    alias header http_header
+    alias body content
+
+    # Returns Hash of header. key and value are both String. Each key has a
+    # single value so you can't extract exact value when a message has multiple
+    # headers like 'Set-Cookie'. Use header['Set-Cookie'] for that purpose.
+    # (It returns an Array always)
+    def headers
+      Hash[*http_header.all.flatten]
+    end
+
+    # Extracts cookies from 'Set-Cookie' header.
+    # Supports 'Set-Cookie' in response header only.
+    # Do we need 'Cookie' support in request header?
+    def cookies
+      set_cookies = http_header['set-cookie']
+      unless set_cookies.empty?
+        uri = http_header.request_uri
+        set_cookies.map { |str|
+          WebAgent::Cookie.parse(str, uri)
+        }.flatten
+      end
+    end
+
+    # Convenience method to return boolean of whether we had a successful request
+    def ok?
+      HTTP::Status.successful?(status)
+    end
+
+    def redirect?
+      HTTP::Status.redirect?(status)
+    end
+
+    # SEE_OTHER is a redirect, but it should sent as GET
+    def see_other?
+      status == HTTP::Status::SEE_OTHER
+    end
+  end
 
 end