cache_json 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d55f2663e89b29cd7a1722791d2df406c474801ba2fdcb1fc3345b1ef09ec02
-  data.tar.gz: 3622185a6fd8bb95afa5a1aee4db627e85e6ac9655f74ac01b1f0e69147ef6f9
+  metadata.gz: d97faf1cadc565cb04a69dee9bd89df23574d72e9b8b412c2e55dffe201d88db
+  data.tar.gz: 69e444bf0badc19dc320d644ca4929712d23552537d6493845aab0cb682dff59
 SHA512:
-  metadata.gz: a6e7121140320e4bc2bcf592a5917a8493043f639611d91e765a669c236f035ab2eab2a6566b1e23451dffb1327fecb0e8b6ad6948b6940e313f8f951d627276
-  data.tar.gz: 50bf2925a8d95546d7c21547e283ac85a4e642cbf98cb198384a3baa4ba8a1b4abc9c2aeb021437022a3ad72557f63f390613ad0b5bb582c3592c3e79d0318bd
+  metadata.gz: 2eaae958e037c974bcc9b7042d35b75165c331976989dad8837aee846e60d176a81c4595971f174e5ba25d78f8af9c5fd2035743e0f2ebbbe49118cfbd741e8d
+  data.tar.gz: b6cd26c9c6e4318844be79eb4193af22318feabed40054e5d0b4b28c2cf705d3abd6c32927f5e6b4853eda4838c16ff07a6377b90ffbfd005eef94f378e0858f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cache_json (1.2.2)
+    cache_json (1.2.3)
       redis (>= 3.3.5, < 5)
 
 GEM
@@ -15,7 +15,7 @@ GEM
     parallel (1.19.1)
     parser (2.7.0.3)
       ast (~> 2.4.0)
-    rack (2.2.2)
+    rack (2.2.3)
     rack-protection (2.0.8.1)
       rack
     rainbow (3.0.0)

data/README.md

@@ -54,6 +54,43 @@ CacheJSON.configure do |config|
 end
 ```
 
+## Automatic refreshing (Sidekiq)
+
+There is a simple Sidekiq job that lets you pre-compute selected classes with specified ranges of arguments. All you have to do is add a `refresh` option:
+
+```ruby
+class ExpensiveJob
+
+  include CacheJSON::Base
+
+
+  cache_json_options(
+    time_to_expire: 1.hour,
+    refresh: {
+      arguments: {
+        first: (5..10),
+        second: ['one option', 'another option'],
+        third: 'the only option',
+        fourth: -> { ['proc result'] }
+      }
+    }
+  )
+  ...
+end
+```
+
+The Sidekiq job will take the Cartesian product of all the argument ranges/arrays (all the combinations).
+
+We leave it to you to schedule the job. If you're using https://github.com/moove-it/sidekiq-scheduler, you can do something like this:
+
+```yml
+cache_json_worker:
+  every: "20s"
+  class: CacheJSON::Worker
+```
+
+Whenever the worker runs, it checks which results have expired, and refreshes only those.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/cache_json/base.rb

@@ -8,7 +8,7 @@ module CacheJSON
       base.extend(ClassMethods)
     end
 
-    def results(args)
+    def results(args = {})
       raise ArgumentError, 'Must use keyword arguments' unless args.is_a?(Hash)
 
       options = self.class.cache_json_full_options

data/lib/cache_json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CacheJSON
-  VERSION = '1.2.2'
+  VERSION = '1.2.3'
 end

data/lib/cache_json/worker.rb

@@ -22,62 +22,71 @@ module CacheJSON
       if klass
         klass.new.refresh_cache!(args: args)
       else
-        generate_workers
+        AllPermutations.new.results.each do |perm|
+          if should_refresh?(perm[:klass], perm[:args])
+            CacheJSON::Worker.new.perform(klass: perm[:klass], args: perm[:args])
+          end
+        end
       end
     end
 
     private
 
-    def generate_workers
-      all_cache_classes.each do |klass|
-        all_argument_permutations(klass).each do |args|
-          CacheJSON::Worker.new.perform(klass: klass, args: args) if should_refresh?(klass, args)
-        end
-      end
+    def should_refresh?(klass, args)
+      !klass.new.check_cache(args: args)
     end
 
-    def all_cache_classes
-      # TODO: make this more efficient
-      ObjectSpace.each_object(Class).select do |klass|
-        klass.included_modules.include? CacheJSON::Base
+    class AllPermutations
+      def results
+        all_cache_classes.flat_map do |klass|
+          all_argument_permutations(klass).map do |args|
+            {
+              klass: klass,
+              args: args
+            }
+          end
+        end
       end
-    end
 
-    def all_argument_permutations(klass)
-      refresh_options = klass.cache_json_full_options[:refresh]
-      if refresh_options
-        all_combinations_with_fixed_points({}, refresh_options[:arguments])
-      else
-        []
+      def all_cache_classes
+        # TODO: make this more efficient
+        ObjectSpace.each_object(Class).select do |klass|
+          klass.included_modules.include? CacheJSON::Base
+        end
       end
-    end
 
-    def all_combinations_with_fixed_points(fixed_points, full_hash)
-      non_fixed_points = full_hash.dup.delete_if { |k, _| fixed_points.key?(k) }
-      if non_fixed_points.empty?
-        [fixed_points]
-      else
-        pivot_key = non_fixed_points.keys.first
-        values_for_key(non_fixed_points, pivot_key).flat_map do |pivot_key_value|
-          new_fixed_points = fixed_points.merge(Hash[pivot_key, pivot_key_value])
-          all_combinations_with_fixed_points(new_fixed_points, full_hash)
+      def all_argument_permutations(klass)
+        refresh_options = klass.cache_json_full_options[:refresh]
+        if refresh_options
+          all_combinations_with_fixed_points({}, refresh_options[:arguments])
+        else
+          []
         end
       end
-    end
 
-    def values_for_key(hsh, key)
-      pivot_key_values = hsh[key]
-      if pivot_key_values.is_a?(Proc)
-        pivot_key_values.call
-      elsif pivot_key_values.is_a?(Range) || pivot_key_values.is_a?(Array)
-        pivot_key_values
-      else
-        [pivot_key_values]
+      def all_combinations_with_fixed_points(fixed_points, full_hash)
+        non_fixed_points = full_hash.dup.delete_if { |k, _| fixed_points.key?(k) }
+        if non_fixed_points.empty?
+          [fixed_points]
+        else
+          pivot_key = non_fixed_points.keys.first
+          values_for_key(non_fixed_points, pivot_key).flat_map do |pivot_key_value|
+            new_fixed_points = fixed_points.merge(Hash[pivot_key, pivot_key_value])
+            all_combinations_with_fixed_points(new_fixed_points, full_hash)
+          end
+        end
       end
-    end
 
-    def should_refresh?(klass, args)
-      !klass.new.check_cache(args: args)
+      def values_for_key(hsh, key)
+        pivot_key_values = hsh[key]
+        if pivot_key_values.is_a?(Proc)
+          pivot_key_values.call
+        elsif pivot_key_values.is_a?(Range) || pivot_key_values.is_a?(Array)
+          pivot_key_values
+        else
+          [pivot_key_values]
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_json
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Paul Gut
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-14 00:00:00.000000000 Z
+date: 2020-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis