http 0.5.1 → 0.6.0.pre

data/lib/http/redirector.rb

@@ -1,7 +1,7 @@
 module HTTP
   class Redirector
     # Notifies that we reached max allowed redirect hops
-    class TooManyRedirectsError < RuntimeError; end
+    class TooManyRedirectsError < ResponseError; end
 
     # Notifies that following redirects got into an endless loop
     class EndlessRedirectError < TooManyRedirectsError; end
@@ -10,8 +10,10 @@ module HTTP
     REDIRECT_CODES = [300, 301, 302, 303, 307, 308].freeze
 
     # :nodoc:
-    def initialize(max_redirects)
-      @max_redirects = max_redirects
+    def initialize(options = nil)
+      options   = {:max_hops => 5} unless options.respond_to?(:fetch)
+      @max_hops = options.fetch(:max_hops, 5)
+      @max_hops = false if @max_hops && 1 > @max_hops.to_i
     end
 
     # Follows redirects until non-redirect response found
@@ -39,7 +41,12 @@ module HTTP
         uri = @response.headers['Location']
         fail StateError, 'no Location header in redirect' unless uri
 
-        @request  = @request.redirect(uri)
+        if 303 == @response.code
+          @request = @request.redirect uri, :get
+        else
+          @request = @request.redirect uri
+        end
+
         @response = yield @request
       end
 
@@ -48,13 +55,11 @@ module HTTP
 
     # Check if we reached max amount of redirect hops
     def too_many_hops?
-      return false if @max_redirects.is_a?(TrueClass)
-      @max_redirects.to_i < @visited.count
+      @max_hops < @visited.count if @max_hops
     end
 
     # Check if we got into an endless loop
     def endless_loop?
-      # pretty naive condition
       2 < @visited.count(@visited.last)
     end
   end

data/lib/http/request.rb

@@ -1,13 +1,18 @@
-require 'http/header'
-require 'http/request_stream'
+require 'http/headers'
+require 'http/request/writer'
+require 'http/version'
 require 'uri'
+require 'base64'
 
 module HTTP
   class Request
-    include HTTP::Header
+    include HTTP::Headers::Mixin
 
     # The method given was not understood
-    class UnsupportedMethodError < ArgumentError; end
+    class UnsupportedMethodError < RequestError; end
+
+    # The scheme of given URI was not understood
+    class UnsupportedSchemeError < RequestError; end
 
     # RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
     METHODS = [:options, :get, :head, :post, :put, :delete, :trace, :connect]
@@ -27,53 +32,97 @@ module HTTP
     # draft-reschke-webdav-search: WebDAV Search
     METHODS.concat [:search]
 
+    # Allowed schemes
+    SCHEMES = [:http, :https, :ws, :wss]
+
     # Method is given as a lowercase symbol e.g. :get, :post
-    attr_reader :method
+    attr_reader :verb
+
+    # Scheme is normalized to be a lowercase symbol e.g. :http, :https
+    attr_reader :scheme
+
+    # The following alias may be removed in three minor versions (0.8.0) or one
+    # major version (1.0.0)
+    alias_method :__method__, :method
+
+    # The following method may be removed in two minor versions (0.7.0) or one
+    # major version (1.0.0)
+    def method(*args)
+      warn "#{Kernel.caller.first}: [DEPRECATION] HTTP::Request#method is deprecated. Use #verb instead. For Object#method, use #__method__."
+      @verb
+    end
 
     # "Request URI" as per RFC 2616
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
     attr_reader :uri
-    attr_reader :headers, :proxy, :body, :version
+    attr_reader :proxy, :body, :version
 
     # :nodoc:
-    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
-
-      @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 ||= canonicalize_header(name)
-        @headers[key] = value
-      end
-      @headers["Host"] ||= @uri.host
+    def initialize(verb, uri, headers = {}, proxy = {}, body = nil, version = '1.1') # rubocop:disable ParameterLists
+      @verb   = verb.to_s.downcase.to_sym
+      @uri    = uri.is_a?(URI) ? uri : URI(uri.to_s)
+      @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
+
+      fail(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
+      fail(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
 
       @proxy, @body, @version = proxy, body, version
+
+      @headers = HTTP::Headers.coerce(headers || {})
+
+      @headers['Host']        ||= @uri.host
+      @headers['User-Agent']  ||= "RubyHTTPGem/#{HTTP::VERSION}"
     end
 
     # Returns new Request with updated uri
-    def redirect(uri)
+    def redirect(uri, verb = @verb)
       uri = @uri.merge uri.to_s
-      req = self.class.new(method, uri, headers, proxy, body, version)
-      req.headers.merge!('Host' => req.uri.host)
+      req = self.class.new(verb, uri, headers, proxy, body, version)
+      req['Host'] = req.uri.host
       req
     end
 
-    # Obtain the given header
-    def [](header)
-      @headers[canonicalize_header(header)]
-    end
-
     # Stream the request to a socket
     def stream(socket)
-      path = uri.query ? "#{uri.path}?#{uri.query}" : uri.path
-      path = "/" if path.empty?
-      request_header = "#{method.to_s.upcase} #{path} HTTP/#{version}"
-      rs = HTTP::RequestStream.new socket, body, @headers, request_header
-      rs.stream
+      include_proxy_authorization_header if using_authenticated_proxy?
+      Request::Writer.new(socket, body, headers, request_header).stream
+    end
+
+    # Is this request using a proxy?
+    def using_proxy?
+      proxy && proxy.keys.size >= 2
+    end
+
+    # Is this request using an authenticated proxy?
+    def using_authenticated_proxy?
+      proxy && proxy.keys.size == 4
+    end
+
+    # Compute and add the Proxy-Authorization header
+    def include_proxy_authorization_header
+      digest = Base64.encode64("#{proxy[:proxy_username]}:#{proxy[:proxy_password]}").chomp
+      headers['Proxy-Authorization'] = "Basic #{digest}"
+    end
+
+    # Compute HTTP request header for direct or proxy request
+    def request_header
+      if using_proxy?
+        "#{verb.to_s.upcase} #{uri} HTTP/#{version}"
+      else
+        path = uri.query && !uri.query.empty? ? "#{uri.path}?#{uri.query}" : uri.path
+        path = '/' if path.empty?
+        "#{verb.to_s.upcase} #{path} HTTP/#{version}"
+      end
+    end
+
+    # Host for tcp socket
+    def socket_host
+      using_proxy? ? proxy[:proxy_address] : uri.host
+    end
+
+    # Port for tcp socket
+    def socket_port
+      using_proxy? ? proxy[:proxy_port] : uri.port
     end
   end
 end

data/lib/http/request/writer.rb

@@ -0,0 +1,79 @@
+module HTTP
+  class Request
+    class Writer
+      # CRLF is the universal HTTP delimiter
+      CRLF = "\r\n"
+
+      def initialize(socket, body, headers, headerstart) # rubocop:disable ParameterLists
+        @body           = body
+        fail(RequestError, 'body of wrong type') unless valid_body_type
+        @socket         = socket
+        @headers        = headers
+        @request_header = [headerstart]
+      end
+
+      def valid_body_type
+        valid_types = [String, NilClass, Enumerable]
+        checks = valid_types.map { |type| @body.is_a?(type) }
+        checks.any?
+      end
+
+      # Adds headers to the request header from the headers array
+      def add_headers
+        @headers.each do |field, value|
+          @request_header << "#{field}: #{value}"
+        end
+      end
+
+      # Stream the request to a socket
+      def stream
+        send_request_header
+        send_request_body
+      end
+
+      # Adds the headers to the header array for the given request body we are working
+      # with
+      def add_body_type_headers
+        if @body.is_a?(String) && !@headers['Content-Length']
+          @request_header << "Content-Length: #{@body.length}"
+        elsif @body.is_a?(Enumerable)
+          encoding = @headers['Transfer-Encoding']
+          if encoding == 'chunked'
+            @request_header << 'Transfer-Encoding: chunked'
+          else
+            fail(RequestError, 'invalid transfer encoding')
+          end
+        end
+      end
+
+      # Joins the headers specified in the request into a correctly formatted
+      # http request header string
+      def join_headers
+        # join the headers array with crlfs, stick two on the end because
+        # that ends the request header
+        @request_header.join(CRLF) + (CRLF) * 2
+      end
+
+      def send_request_header
+        add_headers
+        add_body_type_headers
+        header = join_headers
+
+        @socket << header
+      end
+
+      def send_request_body
+        if @body.is_a?(String)
+          @socket << @body
+        elsif @body.is_a?(Enumerable)
+          @body.each do |chunk|
+            @socket << chunk.bytesize.to_s(16) << CRLF
+            @socket << chunk
+          end
+
+          @socket << '0' << CRLF * 2
+        end
+      end
+    end
+  end
+end

data/lib/http/response.rb

@@ -1,9 +1,11 @@
 require 'delegate'
-require 'http/header'
+require 'http/headers'
+require 'http/content_type'
+require 'http/mime_type'
 
 module HTTP
   class Response
-    include HTTP::Header
+    include HTTP::Headers::Mixin
 
     STATUS_CODES = {
       100 => 'Continue',
@@ -65,96 +67,65 @@ module HTTP
     SYMBOL_TO_STATUS_CODE.freeze
 
     attr_reader :status
-    attr_reader :headers
+    attr_reader :body
+    attr_reader :uri
 
     # Status aliases! TIMTOWTDI!!! (Want to be idiomatic? Just use status :)
     alias_method :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
-
-      @headers = {}
-      headers.each do |field, value|
-        @headers[canonicalize_header(field)] = value
-      end
-    end
-
-    # Set a header
-    def []=(name, value)
-      # If we have a canonical header, we're done
-      key = name[CANONICAL_HEADER]
-
-      # Convert to canonical capitalization
-      key ||= canonicalize_header(name)
-
-      # Check if the header has already been set and group
-      old_value = @headers[key]
-      if old_value
-        @headers[key] = [old_value].flatten << key
-      else
-        @headers[key] = value
-      end
+    def initialize(status, version, headers, body, uri = nil) # rubocop:disable ParameterLists
+      @status, @version, @body, @uri = status, version, body, uri
+      @headers = HTTP::Headers.coerce(headers || {})
     end
 
     # Obtain the 'Reason-Phrase' for the response
     def reason
-      # FIXME: should get the real reason phrase from the parser
       STATUS_CODES[@status]
     end
 
-    # Get a header value
-    def [](name)
-      @headers[name] || @headers[canonicalize_header(name)]
+    # Returns an Array ala Rack: `[status, headers, body]`
+    def to_a
+      [status, headers.to_h, body.to_s]
     end
 
-    # Obtain the response body
-    def body
-      @body ||= begin
-        raise "no body available for this response" unless @body_proc
+    # Return the response body as a string
+    def to_s
+      body.to_s
+    end
+    alias_method :to_str, :to_s
 
-        body = "" unless block_given?
-        while (chunk = @body_proc.call)
-          if block_given?
-            yield chunk
-          else
-            body << chunk
-          end
-        end
-        body unless block_given?
-      end
+    # Parsed Content-Type header
+    # @return [HTTP::ContentType]
+    def content_type
+      @content_type ||= ContentType.parse headers['Content-Type']
     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
-      end
+    # MIME type of response (if any)
+    # @return [String, nil]
+    def mime_type
+      @mime_type ||= content_type.mime_type
+    end
 
-      body
+    # Charset of response (if any)
+    # @return [String, nil]
+    def charset
+      @charset ||= content_type.charset
     end
 
-    # Returns an Array ala Rack: `[status, headers, body]`
-    def to_a
-      [status, headers, parse_body]
+    # Parse response body with corresponding MIME type adapter.
+    #
+    # @param [#to_s] as Parse as given MIME type
+    #   instead of the one determined from headers
+    # @raise [Error] if adapter not found
+    # @return [Object]
+    def parse(as = nil)
+      MimeType[as || mime_type].decode to_s
     end
 
     # Inspect a response
     def inspect
-      "#<#{self.class}/#{@version} #{status} #{reason} @headers=#{@headers.inspect}>"
-    end
-
-    class BodyDelegator < ::Delegator
-      attr_reader :response
-
-      def initialize(response, body = response.body)
-        super(body)
-        @response, @body = response, body
-      end
-
-      def __getobj__; @body; end
-      def __setobj__(obj); @body = obj; end
+      "#<#{self.class}/#{@version} #{status} #{reason} headers=#{headers.inspect}>"
     end
   end
 end

data/lib/http/response/body.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module HTTP
+  class Response
+    # A streamable response body, also easily converted into a string
+    class Body
+      extend Forwardable
+      include Enumerable
+      def_delegator :to_s, :empty?
+
+      def initialize(client)
+        @client    = client
+        @streaming = nil
+        @contents  = nil
+      end
+
+      # Read up to length bytes, but return any data that's available
+      def readpartial(length = nil)
+        stream!
+        @client.readpartial(length)
+      end
+
+      # Iterate over the body, allowing it to be enumerable
+      def each
+        while (chunk = readpartial)
+          yield chunk
+        end
+      end
+
+      # Eagerly consume the entire body as a string
+      def to_s
+        return @contents if @contents
+        fail StateError, 'body is being streamed' unless @streaming.nil?
+
+        begin
+          @streaming = false
+          @contents = ''
+          while (chunk = @client.readpartial)
+            @contents << chunk
+          end
+        rescue
+          @contents = nil
+          raise
+        end
+
+        @contents
+      end
+      alias_method :to_str, :to_s
+
+      # Assert that the body is actively being streamed
+      def stream!
+        fail StateError, 'body has already been consumed' if @streaming == false
+        @streaming = true
+      end
+
+      # Easier to interpret string inspect
+      def inspect
+        "#<#{self.class}:#{object_id.to_s(16)} @streaming=#{!!@streaming}>"
+      end
+    end
+  end
+end