cached_resource 5.1.0 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 649cd7b534f3afc2628e4400f3b08e05769ed68b
-  data.tar.gz: 4e47e85d1ae399953ae9544bfe8b0ae0de9c99c7
+SHA256:
+  metadata.gz: f2b25cc83718d786c0441bc7cb082944ac7aa4fe3d379792cacb96e87df668eb
+  data.tar.gz: 8fa4f263faee071d9e7361f27b8927113bb36e76b1e5e765e993935cadad8c22
 SHA512:
-  metadata.gz: dabb024419aeb48a493fe0d4b1bdffdf7177b17a6c4fbcd573f8fbe99ee756acbbfb809daf8dd8a314843ab32bde126b9e5609b941864e5bc95f99949d6e00fe
-  data.tar.gz: 6008d2ed179cd97d1187cfe4a0f15922a48e1b5ae88af77f857643ac05e76eb8d2326675ecaeca2b78b4d3df75d6fb3c294a5492d65458a6d4bf0a7453fb36e5
+  metadata.gz: 0523763d1f6d1dd9eb1d68ddb2a196e8f737d5660c91bcb244374804b0ddc31f50037ebb19c0dc1a25b891586cf3b5025df60b16a11c209e03f0510147e78514
+  data.tar.gz: 8ae89f1cd8fcf8dccedc053c7acc15b76ea84853240b0998ee31b5a17f837d001696866262182787d315d4f432f67d87b1ef4d9ef918b530b4e884f4e2f88363

data/README.md

@@ -2,7 +2,10 @@
 CachedResource is a Ruby gem whose goal is to increase the performance of interacting with web services via ActiveResource by caching responses based on request parameters.  It can help reduce the lag created by making repeated requests across a network.
 
 ## Installation
-	gem install cached_resource
+
+```ruby
+gem install cached_resource
+```
 
 ## Compatibility
 CachedResource supports the following Ruby versions:
@@ -24,15 +27,19 @@ For previously supported versions, use 4.2.0 or below.
 ## Configuration
 **Set up CachedResource across all ActiveResources:**
 
-	class ActiveResource::Base
-		cached_resource
-	end
+```ruby
+class ActiveResource::Base
+  cached_resource
+end
+```
 
 Or set up CachedResource for a single class:
 
-	class MyActiveResource < ActiveResource::Base
-		cached_resource
-	end
+```ruby
+class MyActiveResource < ActiveResource::Base
+  cached_resource
+end
+```
 
 ### Options
 CachedResource accepts the following options:
@@ -49,81 +56,115 @@ CachedResource accepts the following options:
 
 You can set them like this:
 
-	cached_resource :cache => MyCacheStore.new, :ttl => 60, :collection_synchronize => true, :logger => MyLogger.new
+```ruby
+cached_resource :cache => MyCacheStore.new, :ttl => 60, :collection_synchronize => true, :logger => MyLogger.new
+```
 
 You can also change them on the fly.
 
 Turn CachedResource off.  This will cause all responses to be retrieved normally (i.e. via the network). All responses will still be cached.
 
-	MyActiveResource.cached_resource.off!
+```ruby
+  MyActiveResource.cached_resource.off!
+```
 
 Turn CachedResource on.
-
-	MyActiveResource.cached_resource.on!
+```ruby
+MyActiveResource.cached_resource.on!
+```
 
 Set the cache expiry time to 60 seconds.
 
-	MyActiveResource.cached_resource.ttl = 60
+```ruby
+MyActiveResource.cached_resource.ttl = 60
+```
 
 Enable cache expiry time randomization, allowing it to fall randomly between 60 and 120 seconds.
 
-	MyActiveResource.cached_resource.ttl_randomization = true
+```ruby
+MyActiveResource.cached_resource.ttl_randomization = true
+```
 
 Change the cache expiry time randomization scale so that the cache expiry time falls randomly between 30 and 180 seconds.
 
-	MyActiveResource.cached_resource.ttl_randomization_scale = 0.5..3
-
+```ruby
+MyActiveResource.cached_resource.ttl_randomization_scale = 0.5..3
+```
 Enable collection synchronization.  This will cause a call to `MyActiveResource.all` to also create cache entries for each of its members.  So, for example, a later call to `MyActiveResource.find(1)` will be read from the cache instead of requested from the remote service.
 
-	MyActiveResource.cached_resource.collection_synchronize = true
-
+```ruby
+MyActiveResource.cached_resource.collection_synchronize = true
+```
 Change the arguments that identify the principal collection request.  If for some reason you are concerned with a collection that is retrieved at a "non-standard" URL, you may specify the Ruby arguments that produce that URL.  When `collection_synchronize` is `true`, the collection returned from a request that matches these arguments will be cached and later updated when one of its members or a subset is retrieved.
 
-	MyActiveResource.cached_resource.collection_arguments = [:all, :params => {:name => "Bob"}]
-
+```ruby
+MyActiveResource.cached_resource.collection_arguments = [:all, :params => {:name => "Bob"}]
+```
 Set a different logger.
 
-	MyActiveResource.cached_resource.logger = MyLogger.new
-
+```ruby
+MyActiveResource.cached_resource.logger = MyLogger.new
+```
 Set a different cache store.
 
-	MyActiveResource.cached_resource.cache = MyCacheStore.new
+```ruby
+MyActiveResource.cached_resource.cache = MyCacheStore.new
+```
 
 ### Caveats
 If you set up CachedResource across all ActiveResources or any subclass of ActiveResource that will be inherited by other classes and you want some of those others to have independent CachedResource configurations, then check out the example below:
 
-	class ActiveResource::Base
-		cached_resource
-	end
-
-	class MyActiveResource < ActiveResource::Base
-		self.cached_resource = CachedResource::Configuration.new(:collection_synchronize => true)
-	end
-
+```ruby
+class ActiveResource::Base
+  cached_resource
+end
+```
+
+```ruby
+class MyActiveResource < ActiveResource::Base
+  self.cached_resource = CachedResource::Configuration.new(:collection_synchronize => true)
+end
+```
 ## Usage
 Sit back and relax! If you need to reload a particular request you can pass `:reload => true` into the options hash like this:
 
-	MyActiveResource.find(:all, :reload => true)
-
+```ruby
+MyActiveResource.find(:all, :reload => true)
+```
 If you need to clear the entire cache just do the following:
 
-	MyActiveResource.clear_cache
-
+```ruby
+MyActiveResource.clear_cache
+```
 ---
 Sometimes you might have a case the resource pathing is non-unique per call. This can create a situation where your caching the same result for multiple calls:
 
-	MyActiveResource.find(:one, from: "/admin/shop.json")
+```ruby
+MyActiveResource.find(:one, from: "/admin/shop.json")
+```
 
 Since resources are cached with an argument based key, you may pass in extra data to be appended to the cache key:
 
-	MyActiveResource.find(:one, from: "/admin/shop.json", uid: "unique value")
-
+```ruby
+MyActiveResource.find(:one, from: "/admin/shop.json", uid: "unique value")
+```
 ## Testing
-	rake
 
-or to test all supported environments
+```ruby
+rake
+```
+
+or to test all supported environments, make sure appraisal is setup
+
+```ruby
+bundle exec appraisal install
+```
+
+and then run
 
-	bundle exec appraisal rake
+```ruby
+bundle exec appraisal rake
+```
 
 For more details, head over to the [appraisal](https://github.com/thoughtbot/appraisal) documentation.
 

data/gemfiles/4.2.gemfile.lock

@@ -1,5 +1,5 @@
 PATH
-  remote: ../
+  remote: ..
   specs:
     cached_resource (5.1.0)
       activeresource (>= 4.0)
@@ -137,4 +137,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.15.1
+   1.17.1

data/gemfiles/5.0.gemfile.lock

@@ -1,5 +1,5 @@
 PATH
-  remote: ../
+  remote: ..
   specs:
     cached_resource (5.1.0)
       activeresource (>= 4.0)
@@ -147,4 +147,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.15.1
+   1.17.1

data/gemfiles/5.1.gemfile.lock

@@ -1,5 +1,5 @@
 PATH
-  remote: ../
+  remote: ..
   specs:
     cached_resource (5.1.0)
       activeresource (>= 4.0)
@@ -147,4 +147,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.15.1
+   1.17.1

data/lib/cached_resource/caching.rb

@@ -85,7 +85,7 @@ module CachedResource
       # Read a entry from the cache for the given key.
       def cache_read(key)
         object = cached_resource.cache.read(key).try do |json_cache|
-          cache = json_to_object(JSON.parse(json_cache))
+          cache = json_to_object(JSON.parse(json_cache, :symbolize_names => true))
           if cache.is_a? Enumerable
             restored = cache.map { |record| full_dup(record) }
             next restored unless respond_to?(:collection_parser)
@@ -100,7 +100,7 @@ module CachedResource
 
       # 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, :race_condition_ttl => cached_resource.race_condition_ttl, :expires_in => cached_resource.generate_ttl)
+        result = cached_resource.cache.write(key, object_to_json(object), :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
@@ -127,12 +127,20 @@ module CachedResource
 
       def json_to_object(json)
         if json.is_a? Array
-          json.map { |attrs| self.new(attrs) }
+          json.map { |attrs|
+            self.new(attrs[:object], attrs[:persistence]) }
         else
-          self.new(json)
+          self.new(json[:object], json[:persistence])
         end
       end
 
+      def object_to_json(object)
+        if object.is_a? Enumerable
+           object.map { |o| { :object => o, :persistence => o.persisted? } }.to_json
+        else
+          { :object => object, :persistence => object.persisted? }.to_json
+        end
+      end
     end
   end
 end

data/lib/cached_resource/version.rb

@@ -1,3 +1,3 @@
 module CachedResource
-  VERSION = "5.1.0"
+  VERSION = "5.1.1"
 end

data/spec/cached_resource/caching_spec.rb

@@ -69,6 +69,7 @@ describe CachedResource do
 
     it "should cache a response with the same persistence" do
       result1 = Thing.find(1)
+      result1.persisted?.should be true
       result2 = Thing.find(1)
       result1.persisted?.should == result2.persisted?
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cached_resource
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.1.1
 platform: ruby
 authors:
 - Morgan Brown
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-09 00:00:00.000000000 Z
+date: 2018-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeresource
@@ -144,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Caching for ActiveResource