Rename *WithCacheBehavior to *::Cached

lib/http/cache.rb

@@ -1,7 +1,5 @@
 require "time"
 require "http/cache/cache_control"
-require "http/cache/response_with_cache_behavior"
-require "http/cache/request_with_cache_behavior"
 
 module HTTP
   class Cache
@@ -20,7 +18,7 @@ def perform(request, options)
     # @yield [request, options] on cache miss so that an actual
     # request can be made
     def perform(request, options, &request_performer)
-      req = RequestWithCacheBehavior.coerce(request)
+      req = request.cached
 
       invalidate_cache(req) if req.invalidates_cache?
 
@@ -64,26 +62,22 @@ def handle_response(cached_resp, actual_resp, req)
       end
     end
 
-    # @return [ResponseWithCacheBehavior] the actual response returned
+    # @return [HTTP::Response::Cached] the actual response returned
     # by request_performer
     def make_request(req, options, request_performer)
       req.sent_at = Time.now
-      ResponseWithCacheBehavior.coerce(request_performer.call(req, options)).tap do |resp|
-        resp.received_at  = Time.now
-        resp.requested_at = req.sent_at
+
+      request_performer.call(req, options).cached.tap do |res|
+        res.received_at  = Time.now
+        res.requested_at = req.sent_at
       end
     end
 
-    # @return [ResponseWithCacheBehavior] the cached response for the
-    # request or nil if there isn't one
+    # @return [HTTP::Response::Cached, nil] the cached response for the request
     def cache_lookup(request)
       return nil if request.skips_cache?
       c = @cache_adapter.lookup(request)
-      if c
-        ResponseWithCacheBehavior.coerce(c)
-      else
-        nil
-      end
+      c && c.cached
     end
 
     # Store response in cache

lib/http/request.rb

@@ -1,5 +1,6 @@
 require "http/errors"
 require "http/headers"
+require "http/request/cached"
 require "http/request/writer"
 require "http/version"
 require "base64"
@@ -130,6 +131,11 @@ def socket_port
       using_proxy? ? proxy[:proxy_port] : uri.port
     end
 
+    # @return [HTTP::Request::Cached]
+    def cached
+      Cached.new self
+    end
+
     private
 
     def path_for_request_header

lib/http/cache/request_with_cache_behavior.rb → lib/http/request/cached.rb

@@ -1,35 +1,31 @@
-require "http/request"
+require "http/cache/cache_control"
 
 module HTTP
-  class Cache
+  class Request
     # Decorator class for requests to provide convenience methods
-    # related to caching. Instantiate using the `.coerce` method.
-    class RequestWithCacheBehavior < DelegateClass(HTTP::Request)
+    # related to caching.
+    class Cached < DelegateClass(HTTP::Request)
       INVALIDATING_METHODS = [:post, :put, :delete, :patch].freeze
       CACHEABLE_METHODS    = [:get, :head].freeze
 
-      class << self
-        protected :new
-
-        # @return [RequestWithCacheBehavior]] a instance of self by
-        # wrapping `another` a new instance of self or by just
-        # returning it
-        #
-        # @api public
-        def coerce(another)
-          if another.respond_to? :cacheable?
-            another
-          else
-            new(another)
-          end
-        end
-      end
-
       # 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::Cached]
+      def cached
+        self
+      end
+
       # @return [Boolean] true iff request demands the resources cache entry be invalidated
       #
       # @api public
@@ -38,7 +34,7 @@ def invalidates_cache?
           cache_control.no_store?
       end
 
-      # @return [Boolean] true iff request is cacheable
+      # @return [Boolean] true if request is cacheable
       #
       # @api public
       def cacheable?
@@ -57,26 +53,24 @@ def skips_cache?
           cache_control.no_cache?
       end
 
-      # @return [RequestWithCacheBehavior] new request based on this
+      # @return [HTTP::Request::Cached] 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)
-        raw_cond_req = HTTP::Request.new(verb, uri,
-                                         headers.merge(conditional_headers_for(cached_response)),
-                                         proxy, body, version)
-
-        self.class.coerce(raw_cond_req)
+        self.class.new HTTP::Request.new(
+          verb, uri, headers.merge(conditional_headers_for(cached_response)),
+          proxy, body, version)
       end
 
-      # @return [CacheControl] cache control helper for this request
+      # @return [HTTP::Cache::CacheControl] cache control helper for this request
       # @api public
       def cache_control
-        @cache_control ||= CacheControl.new(self)
+        @cache_control ||= HTTP::Cache::CacheControl.new(self)
       end
 
-      protected
+      private
 
       # @return [Headers] conditional request headers
       # @api private
@@ -93,14 +87,6 @@ def conditional_headers_for(cached_response)
 
         headers
       end
-
-      # Inits a new instance
-      # @api private
-      def initialize(obj)
-        super
-        @requested_at = nil
-        @received_at  = nil
-      end
     end
   end
 end

lib/http/response.rb

@@ -3,6 +3,7 @@
 require "http/headers"
 require "http/content_type"
 require "http/mime_type"
+require "http/response/cached"
 require "http/response/status"
 require "time"
 
@@ -106,5 +107,10 @@ def parse(as = nil)
     def inspect
       "#<#{self.class}/#{@version} #{code} #{reason} #{headers.to_h.inspect}>"
     end
+
+    # @return [HTTP::Response::Cached]
+    def cached
+      Cached.new self
+    end
   end
 end

lib/http/cache/response_with_cache_behavior.rb → lib/http/response/cached.rb

@@ -1,24 +1,21 @@
-require "http/response"
+require "http/cache/cache_control"
 
 module HTTP
-  class Cache
+  class Response
     # Decorator class for responses to provide convenience methods
-    # related to caching. Instantiate using the `.coerce` method.
-    class ResponseWithCacheBehavior < DelegateClass(HTTP::Response)
+    # related to caching.
+    class Cached < DelegateClass(HTTP::Response)
       CACHEABLE_RESPONSE_CODES = [200, 203, 300, 301, 410].freeze
 
-      class << self
-        protected :new
+      def initialize(obj)
+        super
+        @requested_at = nil
+        @received_at  = nil
+      end
 
-        # @return [Boolean] a instance of self by wrapping `another` a new
-        #  instance of self or by just returning it
-        def coerce(another)
-          if another.respond_to? :cacheable?
-            another
-          else
-            new(another)
-          end
-        end
+      # @return [HTTP::Response::Cached]
+      def cached
+        self
       end
 
       # @return [Boolean] true iff this response is stale
@@ -40,10 +37,10 @@ def expired?
       def cacheable?
         @cacheable ||=
           begin
-            CACHEABLE_RESPONSE_CODES.include?(code) &&
-              !(cache_control.vary_star? ||
-                cache_control.no_store?  ||
-                cache_control.no_cache?)
+            CACHEABLE_RESPONSE_CODES.include?(code) \
+              && !(cache_control.vary_star? ||
+                   cache_control.no_store?  ||
+                   cache_control.no_cache?)
           end
       end
 
@@ -84,9 +81,9 @@ def validated!(validating_response)
         self.authoritative = true
       end
 
-      # @return [CacheControl] cache control helper object.
+      # @return [HTTP::Cache::CacheControl] cache control helper object.
       def cache_control
-        @cache_control ||= CacheControl.new(self)
+        @cache_control ||= HTTP::Cache::CacheControl.new(self)
       end
 
       protected
@@ -107,12 +104,6 @@ def to_time_or_epoch(t_str)
       rescue ArgumentError
         Time.at(0)
       end
-
-      def initialize(obj)
-        super
-        @requested_at = nil
-        @received_at  = nil
-      end
     end
   end
 end

spec/lib/http/cache_spec.rb

@@ -30,12 +30,10 @@
 
     context "cache hit" do
       let(:cached_response) do
-        HTTP::Cache::ResponseWithCacheBehavior.coerce(
-          HTTP::Response.new(200,
-                             "http/1.1",
-                             {"Cache-Control" => "private", "test" => "foo"},
-                             "")
-        ).tap { |r| r.requested_at = r.received_at = Time.now }
+        headers = {"Cache-Control" => "private", "test" => "foo"}
+        HTTP::Response.new(200, "http/1.1", headers, "").cached.tap do |r|
+          r.requested_at = r.received_at = Time.now
+        end
       end
 
       it "does not call request_performer block" do
@@ -244,7 +242,7 @@
   let(:cached_response) { nil } # cold cache by default
 
   def build_cached_response(*args)
-    r = HTTP::Cache::ResponseWithCacheBehavior.coerce(HTTP::Response.new(*args))
+    r = HTTP::Response.new(*args).cached
     r.requested_at = r.received_at = Time.now
 
     yield r if block_given?

spec/lib/http/client_spec.rb

@@ -73,7 +73,7 @@ def simple_response(body, status = 200)
 
   describe "caching" do
     it "returns cached responses if they exist" do
-      cached_response = HTTP::Cache::ResponseWithCacheBehavior.coerce(simple_response("OK"))
+      cached_response = simple_response("OK").cached
       adapter = double("persistance_adapter", :lookup => cached_response)
       client = StubbedClient.new(:cache => HTTP::Cache.new(adapter)).stub(
         "http://example.com/" => simple_response("OK")

spec/lib/http/cache/request_with_cache_behavior_spec.rb → spec/lib/http/request/cached_spec.rb

@@ -1,16 +1,5 @@
-RSpec.describe HTTP::Cache::RequestWithCacheBehavior do
-  describe ".coerce" do
-    it "should accept a base request" do
-      expect(described_class.coerce(request)).to be_kind_of described_class
-    end
-
-    it "should accept an already decorated request" do
-      decorated_req = described_class.coerce(request)
-      expect(decorated_req).to be_kind_of described_class
-    end
-  end
-
-  subject { described_class.coerce(request) }
+RSpec.describe HTTP::Request::Cached do
+  subject { described_class.new request }
 
   it "provides access to it's cache control object" do
     expect(subject.cache_control).to be_kind_of HTTP::Cache::CacheControl
@@ -30,11 +19,11 @@
     end
 
     it "can construct a new conditional version of itself based on a cached response" do
-      mod_date = Time.now.httpdate
+      mod_date    = Time.now.httpdate
       cached_resp = HTTP::Response.new(200, "http/1.1",
                                        {"Etag" => "foo",
                                         "Last-Modified" => mod_date},
-                                       "")
+                                        "")
       cond_req = subject.conditional_on_changes_to(cached_resp)
 
       expect(cond_req.headers["If-None-Match"]).to eq "foo"
@@ -66,7 +55,7 @@
       cached_resp = HTTP::Response.new(200, "http/1.1",
                                        {"Etag" => "foo",
                                         "Last-Modified" => mod_date},
-                                       "")
+                                        "")
       cond_req = subject.conditional_on_changes_to(cached_resp)
       expect(cond_req.headers["If-None-Match"]).to eq "foo"
       expect(cond_req.headers["If-Modified-Since"]).to eq mod_date
@@ -140,4 +129,9 @@
 
   # Background
   let(:request) { HTTP::Request.new(:get, "http://example.com/") }
+
+  describe "#cached" do
+    subject(:cached_request) { request.cached }
+    it { is_expected.to be cached_request }
+  end
 end

spec/lib/http/request_spec.rb

@@ -138,4 +138,9 @@
       its(:verb) { is_expected.to be :get }
     end
   end
+
+  describe "#cached" do
+    subject { request.cached }
+    it { is_expected.to be_a HTTP::Request::Cached }
+  end
 end