http 0.8.14 → 0.9.0.pre

data/lib/http/cache/null_cache.rb

@@ -1,13 +0,0 @@
-module HTTP
-  class Cache
-    # NoOp cache. Always makes the request. Allows avoiding
-    # conditionals in the request flow.
-    class NullCache
-      # @return [Response] the result of the provided block
-      # @yield [request, options] so that the request can actually be made
-      def perform(request, options)
-        yield(request, options)
-      end
-    end
-  end
-end

data/lib/http/request/caching.rb

@@ -1,95 +0,0 @@
-require "http/headers"
-require "http/cache/headers"
-
-module HTTP
-  class Request
-    # Decorator for requests to provide convenience methods related to caching.
-    class Caching < DelegateClass(HTTP::Request)
-      INVALIDATING_METHODS = [:post, :put, :delete, :patch].freeze
-      CACHEABLE_METHODS    = [:get, :head].freeze
-
-      # When was this request sent to the server
-      #
-      # @api public
-      attr_accessor :sent_at
-
-      # Inits a new instance
-      # @api private
-      def initialize(obj)
-        super
-        @requested_at = nil
-        @received_at  = nil
-      end
-
-      # @return [HTTP::Request::Caching]
-      def caching
-        self
-      end
-
-      # @return [Boolean] true iff request demands the resources cache entry be invalidated
-      #
-      # @api public
-      def invalidates_cache?
-        INVALIDATING_METHODS.include?(verb) ||
-          cache_headers.no_store?
-      end
-
-      # @return [Boolean] true if request is cacheable
-      #
-      # @api public
-      def cacheable?
-        CACHEABLE_METHODS.include?(verb) &&
-          !cache_headers.no_store?
-      end
-
-      # @return [Boolean] true iff the cache control info of this
-      # request demands that the response be revalidated by the origin
-      # server.
-      #
-      # @api public
-      def skips_cache?
-        0 == cache_headers.max_age       ||
-          cache_headers.must_revalidate? ||
-          cache_headers.no_cache?
-      end
-
-      # @return [HTTP::Request::Caching] new request based on this
-      # one but conditional on the resource having changed since
-      # `cached_response`
-      #
-      # @api public
-      def conditional_on_changes_to(cached_response)
-        self.class.new HTTP::Request.new(
-          verb, uri, headers.merge(conditional_headers_for(cached_response)),
-          proxy, body, version).caching
-      end
-
-      # @return [HTTP::Cache::Headers] cache control helper for this request
-      # @api public
-      def cache_headers
-        @cache_headers ||= HTTP::Cache::Headers.new headers
-      end
-
-      def env
-        {"rack-cache.cache_key" => lambda { |r| r.uri.to_s }}
-      end
-
-      private
-
-      # @return [Headers] conditional request headers
-      def conditional_headers_for(cached_response)
-        headers = HTTP::Headers.new
-
-        cached_response.headers.get(HTTP::Headers::ETAG).
-          each { |etag| headers.add(HTTP::Headers::IF_NONE_MATCH, etag) }
-
-        cached_response.headers.get(HTTP::Headers::LAST_MODIFIED).
-          each { |last_mod| headers.add(HTTP::Headers::IF_MODIFIED_SINCE, last_mod) }
-
-        headers.add(HTTP::Headers::CACHE_CONTROL, "max-age=0") if cache_headers.forces_revalidation?
-
-        headers
-      end
-    end
-  end
-end

data/lib/http/response/caching.rb

@@ -1,143 +0,0 @@
-require "http/headers"
-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
-
-      # @return [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(HTTP::Headers::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(HTTP::Headers::VARY).first
-      end
-
-      protected
-
-      # @return [Time] the time at which the server generated this response.
-      def server_response_time
-        headers.get(HTTP::Headers::DATE).
-          map(&method(:to_time_or_epoch)).
-          max || begin
-                    # set it if it is not already set
-                    headers[HTTP::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

@@ -1,63 +0,0 @@
-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/string_body.rb

@@ -1,53 +0,0 @@
-module HTTP
-  class Response
-    # A Body class that wraps a String, rather than a the client
-    # object.
-    class StringBody
-      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 = @contents.length)
-        stream!
-        return nil if @streaming_offset >= @contents.length
-
-        @contents[@streaming_offset, size].tap do |part|
-          @streaming_offset += (part.length + 1)
-        end
-      end
-
-      # Iterate over the body, allowing it to be enumerable
-      def each
-        yield @contents
-      end
-
-      # @return [String] eagerly consume the entire body as a string
-      def to_s
-        @contents
-      end
-      alias_method :to_str, :to_s
-
-      def_delegator :@contents, :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)}>"
-      end
-
-      protected
-
-      def initialize(contents)
-        @contents = contents
-        @streaming = nil
-        @streaming_offset = 0
-      end
-    end
-  end
-end

data/spec/lib/http/cache/headers_spec.rb

@@ -1,77 +0,0 @@
-RSpec.describe HTTP::Cache::Headers do
-  subject(:cache_headers) { described_class.new headers }
-
-  describe ".new" do
-    it "accepts instance of HTTP::Headers" do
-      expect { described_class.new HTTP::Headers.new }.not_to raise_error
-    end
-
-    it "it rejects any object that does not respond to #headers" do
-      expect { described_class.new double }.to raise_error HTTP::Error
-    end
-  end
-
-  context "with <Cache-Control: private>" do
-    let(:headers) { {"Cache-Control" => "private"} }
-    it { is_expected.to be_private }
-  end
-
-  context "with <Cache-Control: public>" do
-    let(:headers) { {"Cache-Control" => "public"} }
-    it { is_expected.to be_public }
-  end
-
-  context "with <Cache-Control: no-cache>" do
-    let(:headers) { {"Cache-Control" => "no-cache"} }
-    it { is_expected.to be_no_cache }
-  end
-
-  context "with <Cache-Control: no-store>" do
-    let(:headers) { {"Cache-Control" => "no-store"} }
-    it { is_expected.to be_no_store }
-  end
-
-  describe "#max_age" do
-    subject { cache_headers.max_age }
-
-    context "with <Cache-Control: max-age=100>" do
-      let(:headers) { {"Cache-Control" => "max-age=100"} }
-      it { is_expected.to eq 100 }
-    end
-
-    context "with <Expires: {100 seconds from now}>" do
-      let(:headers) { {"Expires" => (Time.now + 100).httpdate} }
-      it { is_expected.to be_within(1).of(100) }
-    end
-
-    context "with <Expires: {100 seconds before now}>" do
-      let(:headers) { {"Expires" => (Time.now - 100).httpdate} }
-      it { is_expected.to eq 0 }
-    end
-
-    context "with <Expires: -1>" do
-      let(:headers) { {"Expires" => "-1"} }
-      it { is_expected.to eq 0 }
-    end
-  end
-
-  context "with <Vary: *>" do
-    let(:headers) { {"Vary" => "*"} }
-    it { is_expected.to be_vary_star }
-  end
-
-  context "with no cache related headers" do
-    let(:headers) { {} }
-
-    it { is_expected.not_to be_private }
-    it { is_expected.not_to be_public }
-    it { is_expected.not_to be_no_cache }
-    it { is_expected.not_to be_no_store }
-    it { is_expected.not_to be_vary_star }
-
-    describe "#max_age" do
-      subject { cache_headers.max_age }
-      it { is_expected.to eq Float::INFINITY }
-    end
-  end
-end