cached_resource 7.0.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 945dbe812b6e4fea58b155907076ea3821bf87a7b37312a7301f16f420ed9158
-  data.tar.gz: f07ca05471ba063bbe38d8ae7a29d6b16c4cd5132066f9c8d9f71d2d06a22c45
+  metadata.gz: d1c2150c2dc21cf091c9b26674b3e52a7bd43938318704f7c2f0739a0b9756aa
+  data.tar.gz: 2f7b9665c688f2a60b7def43cfafbe2701accded9fcf9aabc371fe91bf78362d
 SHA512:
-  metadata.gz: ab3c75b4c0384b7ea516159ce7526e7dcd62443951331302986483403887d7e498528fef972c1268fc9a2dce3fb2d0df56434617ea21db03a3adc3457534527d
-  data.tar.gz: 21a1220f34e5bb07b5da51648dcbdb521970c801d7aabdcc53a142b4ad5347c0e779c3bd7186891f5bb9e4b9b79bb74df5790b9524cd14f72358d875b293c9db
+  metadata.gz: c0c94c6b77f623a49a3259a69a4bb1b1d2d7fc219d590b740d5a86c71f3cfbf7eb783a2e8a2c06631c926bd2679b220341d8fbf03b77a3651d5219a70bb8d779
+  data.tar.gz: 207c37429a14511fb788d21bc69e86b01f8f59a303b20aebafb2f07e54aba48546c03a5ac7fa4b99da0bd9b7cd53d385ddb73306c643d9044d113ea638949e61

data/.github/workflows/ruby.yml

@@ -15,7 +15,7 @@ permissions:
 jobs:
   test:
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
 
     strategy:
       matrix:
@@ -106,4 +106,4 @@ jobs:
           TEST_RAILS_VERSION: ${{ matrix.rails-version }}
           DEBUG: true
       - name: Run tests
-        run: bundle exec rake
+        run: bundle exec rake

data/FUNDING.json

@@ -0,0 +1,7 @@
+{
+  "drips": {
+    "ethereum": {
+      "ownedBy": "0xe2E9b9B5d0757c26aB477A754788B19b60f2ed83"
+    }
+  }
+}

data/README.md

@@ -25,6 +25,13 @@ CachedResource is designed to be framework agnostic, but will hook into Rails fo
 | 💎 3.1   |     |     |     | ✅   | ✅   | ✅   |
 | 💎 3.2   |     |     |     | ✅   | ✅   | ✅   |
 
+## Limitations
+
+The following are limitations for ActiveResource/Rails versions
+
+| ActiveSupport Version |                             Limitation                                  |
+|---------------------- | ----------------------------------------------------------------------- |
+| 🛤️ 4.X                |  You cannot chain calls. Ie `Thing.where(fn: 'foo').where(ln: 'bar')`. <br> However, you can still access `original_params` and the `resource_class` and replicate it with <br>`call1 = Thing.where(fn: 'foo')`<br>`call1.resource_class.where(call1.original_params.merge(ln: 'bar'))`  |
 
 ## Configuration
 

data/lib/cached_resource/caching.rb

@@ -37,13 +37,14 @@ module CachedResource
         cache_read(key) || find_via_reload(key, *arguments)
       end
 
-      # Re/send the request to fetch the resource. Cache the response
-      # for the request.
+      # Re/send the request to fetch the resource
       def find_via_reload(key, *arguments)
         object = find_without_cache(*arguments)
+        return object unless should_cache?(object)
+
         cache_collection_synchronize(object, *arguments) if cached_resource.collection_synchronize
         return object if !cached_resource.cache_collections && is_any_collection?(*arguments)
-        cache_write(key, object)
+        cache_write(key, object, *arguments)
         cache_read(key)
       end
 
@@ -52,32 +53,38 @@ module CachedResource
       # otherwise update an existing collection if possible.
       def cache_collection_synchronize(object, *arguments)
         if object.is_a? Enumerable
-          update_singles_cache(object)
+          update_singles_cache(object, *arguments)
           # update the collection only if this is a subset of it
-          update_collection_cache(object) unless is_collection?(*arguments)
+          update_collection_cache(object, *arguments) unless is_collection?(*arguments)
         else
-          update_collection_cache(object)
+          update_collection_cache(object, *arguments)
         end
       end
 
       # Update the cache of singles with an array of updates.
-      def update_singles_cache(updates)
+      def update_singles_cache(updates, *arguments)
         updates = Array(updates)
-        updates.each { |object| cache_write(cache_key(object.send(primary_key)), object) }
+        updates.each { |object| cache_write(cache_key(object.send(primary_key)), object, *arguments) }
       end
 
       # Update the "mother" collection with an array of updates.
-      def update_collection_cache(updates)
+      def update_collection_cache(updates, *arguments)
         updates = Array(updates)
         collection = cache_read(cache_key(cached_resource.collection_arguments))
 
         if collection && !updates.empty?
           index = collection.inject({}) { |hash, object| hash[object.send(primary_key)] = object; hash }
           updates.each { |object| index[object.send(primary_key)] = object }
-          cache_write(cache_key(cached_resource.collection_arguments), index.values)
+          cache_write(cache_key(cached_resource.collection_arguments), index.values, *arguments)
         end
       end
 
+      # Avoid cache nil or [] objects
+      def should_cache?(object)
+        return false unless cached_resource.enabled
+        object.respond_to?(:empty?) ? !object.empty? : !!object
+      end
+
       # Determine if the given arguments represent
       # the entire collection of objects.
       def is_collection?(*arguments)
@@ -101,7 +108,10 @@ module CachedResource
             if cache.is_a? Enumerable
               restored = cache.map { |record| full_dup(record) }
               next restored unless respond_to?(:collection_parser)
-              collection_parser.new(restored)
+              collection_parser.new(restored).tap do |parser|
+                parser.resource_class = self
+                parser.original_params = json['original_params']
+              end
             else
               full_dup(cache)
             end
@@ -112,8 +122,12 @@ module CachedResource
       end
 
       # Write an entry to the cache for the given key and value.
-      def cache_write(key, object)
-        result = cached_resource.cache.write(key, object_to_json(object), :race_condition_ttl => cached_resource.race_condition_ttl, :expires_in => cached_resource.generate_ttl)
+      def cache_write(key, object, *arguments)
+        options = arguments[1] || {}
+        params = options[:params]
+        prefix_options, query_options = split_options(params)
+
+        result = cached_resource.cache.write(key, object_to_json(object, prefix_options, query_options), :race_condition_ttl => cached_resource.race_condition_ttl, :expires_in => cached_resource.generate_ttl)
         result && cached_resource.logger.info("#{CachedResource::Configuration::LOGGER_PREFIX} WRITE #{key}")
         result
       end
@@ -150,21 +164,34 @@ module CachedResource
       end
 
       def json_to_object(json)
-        if json.is_a? Array
-          json.map { |attrs|
-            self.new(attrs["object"], attrs["persistence"]) }
+        resource = json['resource']
+        if resource.is_a? Array
+          resource.map do |attrs|
+            self.new(attrs["object"], attrs["persistence"]).tap do |resource|
+              resource.prefix_options = json['prefix_options']
+            end
+          end
         else
-          self.new(json["object"], json["persistence"])
+          self.new(resource["object"], resource["persistence"]).tap do |resource|
+            resource.prefix_options = json['prefix_options']
+          end
         end
       end
 
-      def object_to_json(object)
+      def object_to_json(object, prefix_options, query_options)
         if object.is_a? Enumerable
-           object.map { |o| { :object => o, :persistence => o.persisted? } }.to_json
+          {
+            :resource => object.map { |o| { :object => o, :persistence => o.persisted? } },
+            :prefix_options => prefix_options,
+            :original_params => query_options
+          }.to_json
         elsif object.nil?
           nil.to_json
         else
-          { :object => object, :persistence => object.persisted? }.to_json
+          {
+            :resource => { :object => object, :persistence => object.persisted? },
+            :prefix_options => prefix_options
+          }.to_json
         end
       end
     end

data/lib/cached_resource/version.rb

@@ -1,3 +1,3 @@
 module CachedResource
-  VERSION = "7.0.0"
+  VERSION = "7.2.0"
 end

data/spec/cached_resource/caching_spec.rb

@@ -18,6 +18,8 @@ describe CachedResource do
     end
 
     @thing = {:thing => {:id => 1, :name => "Ada"}}
+    @thing_collection = [{:id => 1, :name => "Ada"}, {:id => 2, :name => "Ada", :major => 'CS'}]
+    @thing_collection2 = [{:id => 2, :name => "Ada", :major => 'CS'}]
     @other_thing = {:thing => {:id => 1, :name => "Ari"}}
     @thing2 = {:thing => {:id => 2, :name => "Joe"}}
     @other_thing2 = {:thing => {:id => 2, :name => "Jeb"}}
@@ -31,6 +33,7 @@ describe CachedResource do
     @other_string_thing_json = @other_string_thing.to_json
     @date_thing_json = @date_thing.to_json
     @nil_thing = nil.to_json
+    @empty_array_thing = [].to_json
     @not_the_thing = {:not_the_thing => {:id => 1, :name => "Not"}}
     @not_the_thing_json = @not_the_thing.to_json
   end
@@ -57,6 +60,7 @@ describe CachedResource do
         mock.get "/things/1.json?foo=bar", {}, @thing_json
         mock.get "/things/fded.json", {}, @string_thing_json
         mock.get "/things.json?name=42", {}, @nil_thing, 404
+        mock.get "/things.json?name=43", {}, @empty_array_thing
         mock.get "/things/4.json", {}, @date_thing_json
         mock.get "/not_the_things/1.json", {}, @not_the_thing_json
       end
@@ -64,15 +68,19 @@ describe CachedResource do
 
     it "should cache a response" do
       result = Thing.find(1)
-
       read_from_cache("thing/1").should == result
     end
 
-    it "should cache a nil response" do
-      result = Thing.find(:all, :params => { :name => '42' })
+    it "shouldn't cache nil response" do
+      Thing.find(:all, :params => { :name => '42' })
       read_from_cache("thing/all/name/42").should == nil
     end
 
+    it "shouldn't cache [] response" do
+      Thing.find(:all, :params => { :name => '43' })
+      read_from_cache("thing/all/name/43").should == nil
+    end
+
     it "should cache a response for a string primary key" do
       result = Thing.find("fded")
       read_from_cache("thing/fded").should == result
@@ -215,13 +223,39 @@ describe CachedResource do
           cached.should be_instance_of(ActiveResource::Collection)
         end
 
-        it "should return an instance of the collection_parser" do
+        it "should return a chainable instance of the collection_parser" do
           Thing.cached_resource.cache.clear
           class CustomCollection < ActiveResource::Collection; end
           Thing.collection_parser = CustomCollection
-          Thing.all
-          cached = read_from_cache("thing/all")
+
+          ActiveResource::HttpMock.respond_to do |mock|
+            mock.get "/things.json?name=ada", {}, @thing_collection.to_json
+            mock.get "/things.json?major=CS&name=ada", {}, @thing_collection2.to_json
+          end
+
+          non_cached = Thing.where(name: 'ada')
+          non_cached.original_params.should == { 'name' => 'ada' }
+          non_cached.map(&:id).should == @thing_collection.map { |h| h[:id]}
+
+          cached = read_from_cache('thing/all/{:params=>{:name=>"ada"}}')
           cached.should be_instance_of(CustomCollection)
+          cached.original_params.should == { 'name' => 'ada' }
+          cached.resource_class.should == Thing
+          cached.map(&:id).should == @thing_collection.map { |h| h[:id]}
+
+          if ActiveResource::VERSION::MAJOR < 5
+            non_cached = cached.resource_class.where(cached.original_params.merge(major: 'CS'))
+          else
+            non_cached = cached.where(major: 'CS')
+          end
+
+          non_cached.original_params.should == { 'name' => 'ada', 'major' => 'CS' }
+          non_cached.resource_class.should == Thing
+          non_cached.map(&:id).should == @thing_collection2.map { |h| h[:id]}
+          cached = read_from_cache('thing/all/{:params=>{"name"=>"ada",:major=>"cs"}}')
+          cached.original_params.should == { 'name' => 'ada', 'major' => 'CS' }
+          cached.resource_class.should == Thing
+          cached.map(&:id).should == @thing_collection2.map { |h| h[:id]}
         end
       else
         it "should return an Array" do
@@ -505,14 +539,9 @@ describe CachedResource do
       end
     end
 
-    it "should cache a response" do
+    it "should not cache a response" do
       result = Thing.find(1)
-      read_from_cache("thing/1").should == result
-    end
-
-    it "should cache a response for a string primary key" do
-      result = Thing.find("fded")
-      read_from_cache("thing/fded").should == result
+      read_from_cache("thing/1").should be_nil
     end
 
     it "should always remake the request" do
@@ -528,42 +557,6 @@ describe CachedResource do
       Thing.find("fded")
       ActiveResource::HttpMock.requests.length.should == 2
     end
-
-    it "should rewrite the cache for each request" do
-      Thing.find(1)
-      old_result = read_from_cache("thing/1")
-
-      # change the response
-      ActiveResource::HttpMock.reset!
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "/things/1.json", {}, @other_thing_json
-      end
-
-      Thing.find(1)
-      new_result = read_from_cache("thing/1")
-      # since active resources are equal if and only if they
-      # are the same object or an instance of the same class,
-      # not new?, and have the same id.
-      new_result.name.should_not == old_result.name
-    end
-
-    it "should rewrite the cache for each request for a string primary key" do
-      Thing.find("fded")
-      old_result = read_from_cache("thing/fded")
-
-      # change the response
-      ActiveResource::HttpMock.reset!
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "/things/fded.json", {}, @other_string_thing_json
-      end
-
-      Thing.find("fded")
-      new_result = read_from_cache("thing/fded")
-      # since active resources are equal if and only if they
-      # are the same object or an instance of the same class,
-      # not new?, and have the same id.
-      new_result.name.should_not == old_result.name
-    end
   end
 
   describe "when cache_collections is disabled" do

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'bundler/setup'
 require 'active_resource'
 require 'active_support'
+require 'active_support/time'
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'cached_resource'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cached_resource
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.2.0
 platform: ruby
 authors:
 - Morgan Brown
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-04 00:00:00.000000000 Z
+date: 2024-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeresource
@@ -89,6 +89,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- FUNDING.json
 - Gemfile
 - LICENSE
 - README.md
@@ -132,4 +133,8 @@ rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Caching for ActiveResource
-test_files: []
+test_files:
+- spec/cached_resource/cached_resource_spec.rb
+- spec/cached_resource/caching_spec.rb
+- spec/cached_resource/configuration_spec.rb
+- spec/spec_helper.rb