http 0.7.4 → 0.8.0.pre

data/lib/http/request/writer.rb

@@ -32,10 +32,10 @@ module HTTP
       # 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']
+        if @body.is_a?(String) && !@headers["Content-Length"]
           @request_header << "Content-Length: #{@body.bytesize}"
-        elsif @body.is_a?(Enumerable) && 'chunked' != @headers['Transfer-Encoding']
-          fail(RequestError, 'invalid transfer encoding')
+        elsif @body.is_a?(Enumerable) && "chunked" != @headers["Transfer-Encoding"]
+          fail(RequestError, "invalid transfer encoding")
         end
       end
 
@@ -64,11 +64,11 @@ module HTTP
             @socket << chunk << CRLF
           end
 
-          @socket << '0' << CRLF * 2
+          @socket << "0" << CRLF * 2
         end
       end
 
-    private
+      private
 
       def validate_body_type!
         return if VALID_BODY_TYPES.any? { |type| @body.is_a? type }

data/lib/http/response.rb

@@ -1,9 +1,11 @@
-require 'forwardable'
+require "forwardable"
 
-require 'http/headers'
-require 'http/content_type'
-require 'http/mime_type'
-require 'http/response/status'
+require "http/headers"
+require "http/content_type"
+require "http/mime_type"
+require "http/response/caching"
+require "http/response/status"
+require "time"
 
 module HTTP
   class Response
@@ -16,7 +18,7 @@ module HTTP
     STATUS_CODES = Status::REASONS
 
     # @deprecated Will be removed in 1.0.0
-    SYMBOL_TO_STATUS_CODE = Hash[STATUS_CODES.map { |k, v| [v.downcase.gsub(/\s|-/, '_').to_sym, k] }].freeze
+    SYMBOL_TO_STATUS_CODE = Hash[STATUS_CODES.map { |k, v| [v.downcase.gsub(/\s|-/, "_").to_sym, k] }].freeze
 
     # @return [Status]
     attr_reader :status
@@ -29,7 +31,6 @@ module HTTP
 
     def initialize(status, version, headers, body, uri = nil) # rubocop:disable ParameterLists
       @version, @body, @uri = version, body, uri
-
       @status  = HTTP::Response::Status.new status
       @headers = HTTP::Headers.coerce(headers || {})
     end
@@ -73,7 +74,7 @@ module HTTP
     #
     # @return [HTTP::ContentType]
     def content_type
-      @content_type ||= ContentType.parse headers['Content-Type']
+      @content_type ||= ContentType.parse headers["Content-Type"]
     end
 
     # MIME type of response (if any)
@@ -102,7 +103,12 @@ module HTTP
 
     # Inspect a response
     def inspect
-      "#<#{self.class}/#{@version} #{code} #{reason} #{headers.inspect}>"
+      "#<#{self.class}/#{@version} #{code} #{reason} #{headers.to_h.inspect}>"
+    end
+
+    # @return [HTTP::Response::Caching]
+    def caching
+      Caching.new self
     end
   end
 end

data/lib/http/response/body.rb

@@ -1,5 +1,5 @@
-require 'forwardable'
-require 'http/client'
+require "forwardable"
+require "http/client"
 
 module HTTP
   class Response
@@ -10,13 +10,16 @@ module HTTP
       def_delegator :to_s, :empty?
 
       def initialize(client)
-        @client    = client
-        @streaming = nil
-        @contents  = nil
+        @client       = client
+        @streaming    = nil
+        @contents     = nil
+        @active_seq   = client.sequence_id
       end
 
       # (see HTTP::Client#readpartial)
       def readpartial(*args)
+        check_sequence!
+
         stream!
         @client.readpartial(*args)
       end
@@ -31,11 +34,13 @@ module HTTP
       # @return [String] eagerly consume the entire body as a string
       def to_s
         return @contents if @contents
-        fail StateError, 'body is being streamed' unless @streaming.nil?
+
+        fail StateError, "body is being streamed" unless @streaming.nil?
+        check_sequence!
 
         begin
           @streaming = false
-          @contents = ''
+          @contents = ""
           while (chunk = @client.readpartial)
             @contents << chunk
           end
@@ -48,9 +53,17 @@ module HTTP
       end
       alias_method :to_str, :to_s
 
+      def check_sequence!
+        return unless @active_seq != @client.sequence_id
+
+        fail StateError, "Sequence ID #{@active_seq} does not match #{@client.sequence_id}. You must read the entire request off."
+      end
+
+      private :check_sequence!
+
       # Assert that the body is actively being streamed
       def stream!
-        fail StateError, 'body has already been consumed' if @streaming == false
+        fail StateError, "body has already been consumed" if @streaming == false
         @streaming = true
       end
 

data/lib/http/response/caching.rb

@@ -0,0 +1,142 @@
+require "http/cache/headers"
+require "http/response/string_body"
+require "http/response/io_body"
+
+module HTTP
+  class Response
+    # Decorator class for responses to provide convenience methods
+    # related to caching.
+    class Caching < DelegateClass(HTTP::Response)
+      CACHEABLE_RESPONSE_CODES = [200, 203, 300, 301, 410].freeze
+
+      def initialize(obj)
+        super
+        @requested_at = nil
+        @received_at  = nil
+      end
+
+      # @return [HTTP::Response::Caching]
+      def caching
+        self
+      end
+
+      # @return [Boolean] true iff this response is stale
+      def stale?
+        expired? || cache_headers.must_revalidate?
+      end
+
+      # @returns [Boolean] true iff this response has expired
+      def expired?
+        current_age >= cache_headers.max_age
+      end
+
+      # @return [Boolean] true iff this response is cacheable
+      #
+      # ---
+      # A Vary header field-value of "*" always fails to match and
+      # subsequent requests on that resource can only be properly
+      # interpreted by the
+      def cacheable?
+        @cacheable ||=
+          begin
+            CACHEABLE_RESPONSE_CODES.include?(code) \
+              && !(cache_headers.vary_star? ||
+                   cache_headers.no_store?  ||
+                   cache_headers.no_cache?)
+          end
+      end
+
+      # @return [Numeric] the current age (in seconds) of this response
+      #
+      # ---
+      # Algo from https://tools.ietf.org/html/rfc2616#section-13.2.3
+      def current_age
+        now = Time.now
+        age_value  = headers.get("Age").map(&:to_i).max || 0
+
+        apparent_age = [0, received_at - server_response_time].max
+        corrected_received_age = [apparent_age, age_value].max
+        response_delay = [0, received_at - requested_at].max
+        corrected_initial_age = corrected_received_age + response_delay
+        resident_time = [0, now - received_at].max
+
+        corrected_initial_age + resident_time
+      end
+
+      # @return [Time] the time at which this response was requested
+      def requested_at
+        @requested_at ||= received_at
+      end
+      attr_writer :requested_at
+
+      # @return [Time] the time at which this response was received
+      def received_at
+        @received_at ||= Time.now
+      end
+      attr_writer :received_at
+
+      # Update self based on this response being revalidated by the
+      # server.
+      def validated!(validating_response)
+        headers.merge!(validating_response.headers)
+        self.requested_at  = validating_response.requested_at
+        self.received_at   = validating_response.received_at
+      end
+
+      # @return [HTTP::Cache::Headers] cache control headers helper object.
+      def cache_headers
+        @cache_headers ||= HTTP::Cache::Headers.new headers
+      end
+
+      def body
+        @body ||= if __getobj__.body.respond_to? :each
+                    __getobj__.body
+                  else
+                    StringBody.new(__getobj__.body.to_s)
+                  end
+      end
+
+      def body=(new_body)
+        @body = if new_body.respond_to?(:readpartial) && new_body.respond_to?(:read)
+                  # IO-ish, probably a rack cache response body
+                  IoBody.new(new_body)
+
+                elsif new_body.respond_to? :join
+                  # probably an array of body parts (rack cache does this sometimes)
+                  StringBody.new(new_body.join(""))
+
+                elsif new_body.respond_to? :readpartial
+                  # normal body, just use it.
+                  new_body
+
+                else
+                  # backstop, just to_s it
+                  StringBody.new(new_body.to_s)
+                end
+      end
+
+      def vary
+        headers.get("Vary").first
+      end
+
+      protected
+
+      # @return [Time] the time at which the server generated this response.
+      def server_response_time
+        headers.get("Date")
+          .map(&method(:to_time_or_epoch))
+          .max || begin
+                    # set it if it is not already set
+                    headers["Date"] = received_at.httpdate
+                    received_at
+                  end
+      end
+
+      def to_time_or_epoch(t_str)
+        Time.httpdate(t_str)
+      rescue ArgumentError
+        Time.at(0)
+      end
+    end
+  end
+end

data/lib/http/response/io_body.rb

@@ -0,0 +1,63 @@
+module HTTP
+  class Response
+    # A Body class that wraps an IO, rather than a the client
+    # object.
+    class IoBody
+      include Enumerable
+      extend Forwardable
+
+      # @return [String,nil] the next `size` octets part of the
+      # body, or nil if whole body has already been read.
+      def readpartial(size = HTTP::Connection::BUFFER_SIZE)
+        stream!
+        return nil if stream.eof?
+
+        stream.readpartial(size)
+      end
+
+      # Iterate over the body, allowing it to be enumerable
+      def each
+        while (part = readpartial)
+          yield part
+        end
+      end
+
+      # @return [String] eagerly consume the entire body as a string
+      def to_s
+        @contents ||= readall
+      end
+      alias_method :to_str, :to_s
+
+      def_delegator :to_s, :empty?
+
+      # 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
+
+      protected
+
+      def initialize(an_io)
+        @streaming = nil
+        @stream = an_io
+      end
+
+      attr_reader :contents, :stream
+
+      def readall
+        fail StateError, "body is being streamed" unless @streaming.nil?
+
+        @streaming = false
+        "".tap do |buf|
+          buf << stream.read until stream.eof?
+        end
+      end
+    end
+  end
+end

data/lib/http/response/parser.rb

@@ -18,7 +18,7 @@ module HTTP
       end
 
       def http_version
-        @parser.http_version.join('.')
+        @parser.http_version.join(".")
       end
 
       def status_code

data/lib/http/response/status.rb

@@ -1,6 +1,6 @@
-require 'delegate'
+require "delegate"
 
-require 'http/response/status/reasons'
+require "http/response/status/reasons"
 
 module HTTP
   class Response
@@ -22,7 +22,6 @@ module HTTP
                  when object.is_a?(String)  then SYMBOL_CODES[symbolize object]
                  when object.is_a?(Symbol)  then SYMBOL_CODES[object]
                  when object.is_a?(Numeric) then object.to_i
-                 else                            nil
                  end
 
           return new code if code
@@ -31,7 +30,7 @@ module HTTP
         end
         alias_method :[], :coerce
 
-      private
+        private
 
         # Symbolizes given string
         #
@@ -44,7 +43,7 @@ module HTTP
         # @param [#to_s] str
         # @return [Symbol]
         def symbolize(str)
-          str.to_s.downcase.gsub(/-/, ' ').gsub(/[^a-z ]/, '').gsub(/\s+/, '_').to_sym
+          str.to_s.downcase.gsub(/-/, " ").gsub(/[^a-z ]/, "").gsub(/\s+/, "_").to_sym
         end
       end
 
@@ -73,13 +72,6 @@ module HTTP
       # @return [Fixnum] status code
       attr_reader :code
 
-      if RUBY_VERSION < '1.9.0'
-        # @param [#to_i] code
-        def initialize(code)
-          super __setobj__ code
-        end
-      end
-
       # @see REASONS
       # @return [String, nil] status message
       def reason

data/lib/http/response/status/reasons.rb

@@ -1,4 +1,4 @@
-require 'delegate'
+require "delegate"
 
 module HTTP
   class Response
@@ -13,59 +13,59 @@ module HTTP
       #
       # @return [Hash<Fixnum => String>]
       REASONS = {
-        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',
-        308 => 'Permanent 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',
+        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",
+        308 => "Permanent 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'
+        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"
       }.each { |_, v| v.freeze }.freeze
     end
   end