cached_resource 7.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 945dbe812b6e4fea58b155907076ea3821bf87a7b37312a7301f16f420ed9158
-  data.tar.gz: f07ca05471ba063bbe38d8ae7a29d6b16c4cd5132066f9c8d9f71d2d06a22c45
+  metadata.gz: '0895f45566dd7c4ee2f394be6dda1c7a86aed9ad4e7c6a470d9a59d584c529c1'
+  data.tar.gz: 16106c7680c3cd6708b8171aa5db5f3993f3a77368685876e3e125b03e2d8e85
 SHA512:
-  metadata.gz: ab3c75b4c0384b7ea516159ce7526e7dcd62443951331302986483403887d7e498528fef972c1268fc9a2dce3fb2d0df56434617ea21db03a3adc3457534527d
-  data.tar.gz: 21a1220f34e5bb07b5da51648dcbdb521970c801d7aabdcc53a142b4ad5347c0e779c3bd7186891f5bb9e4b9b79bb74df5790b9524cd14f72358d875b293c9db
+  metadata.gz: 0dbb4bc9fc1019dbf38dce7553b1ad15a964ca3699a461d551b892a26608b53ab0dbe4d8dbcce3878977f4b00debd88affa6494ad52d4fb2fb739a3ca6d239c3
+  data.tar.gz: 689a7edad73b7de5cff68c17d34135422d7166b1ae2745ae3be398cc77399e1ccd2d09a8423a3c7fda00f647216834e4b93c0a82287c39dd5ea5177d3fc7072f

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 cached_resource.enabled
+
         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,29 +53,29 @@ 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
 
@@ -101,7 +102,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 +116,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 +158,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.1.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"}}
@@ -215,13 +217,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 +533,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 +551,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.1.0
 platform: ruby
 authors:
 - Morgan Brown
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-04 00:00:00.000000000 Z
+date: 2024-01-18 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