cache_crispies 0.3.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4293fff1dfa2e9239dcb22ff05222a6069291a17c512ed18ad63c4ca57296a2
-  data.tar.gz: ea9057daf8b48b06c9def5ab704929088e465c3946ba8facde27c879dc49085b
+  metadata.gz: 7be596f4546279c27b355a83a6c87b5d986cbcc65779def4310df106c3017557
+  data.tar.gz: e7b5ceb4ac6c68d7149bb45246bdba99864c5fbd289277d054b22c5c622f748d
 SHA512:
-  metadata.gz: 519e4d11e56c056ca76dbf60c5d195096206f4ce9756440c94503556701daf6195ac7fdbe3acca33351831997eeb95941a8c72db31d685ae9b996facad6a7760
-  data.tar.gz: 7280a38a08e92907d64f3bc50a83a0d1d2dfc0b2cccfc03c21fa6e9b49612cc1246d68a20f93e612829fa687fe2b2c2a3b1b6972a3243bc5cf5563d8f92905ce
+  metadata.gz: ac4fe247753da8c9afa3e2d5a27d8f673c780b6bbb0d71a8777e736e9b9761be4791c33e5370a3f6a1ade8df2ff65befd648c9004908f1d4ebaafb3ce3678aa1
+  data.tar.gz: 823e1a06a9a007e74cb148751f765cf506e96849b5947e5132b2fffadfbaaa447a3c379cbd805d72fb03ceffd2bb8daf12a8649e282020d1d91b98656af97e82

data/lib/cache_crispies.rb

@@ -15,12 +15,25 @@ module CacheCrispies
   require 'cache_crispies/version'
 
   # Use autoload for better Rails development
-  autoload :Attribute,    'cache_crispies/attribute'
-  autoload :Base,         'cache_crispies/base'
-  autoload :Collection,   'cache_crispies/collection'
-  autoload :Condition,    'cache_crispies/condition'
-  autoload :HashBuilder,  'cache_crispies/hash_builder'
-  autoload :Memoizer,     'cache_crispies/memoizer'
-  autoload :Controller,   'cache_crispies/controller'
-  autoload :Plan,         'cache_crispies/plan'
+  autoload :Attribute,      'cache_crispies/attribute'
+  autoload :Base,           'cache_crispies/base'
+  autoload :Collection,     'cache_crispies/collection'
+  autoload :Condition,      'cache_crispies/condition'
+  autoload :Configuration,  'cache_crispies/configuration'
+  autoload :HashBuilder,    'cache_crispies/hash_builder'
+  autoload :Memoizer,       'cache_crispies/memoizer'
+  autoload :Controller,     'cache_crispies/controller'
+  autoload :Plan,           'cache_crispies/plan'
+
+  def self.configure
+    yield config
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.cache
+    config.cache_store
+  end
 end

data/lib/cache_crispies/attribute.rb

@@ -22,44 +22,68 @@ module CacheCrispies
     #   argument's value
     def initialize(
       key,
-      from: nil, with: nil, to: nil, nesting: [], conditions: []
+      from: nil, with: nil, through: nil, to: nil, nesting: [], conditions: [],
+      &block
     )
       @key = key
       @method_name = from || key || :itself
       @serializer = with
+      @through = through
       @coerce_to = to
       @nesting = Array(nesting)
       @conditions = Array(conditions)
+      @block = block
     end
 
     attr_reader(
       :method_name,
       :key,
       :serializer,
+      :through,
       :coerce_to,
       :nesting,
-      :conditions
+      :conditions,
+      :block
     )
 
-    # Gets the value of the attribute for the given model and options
+    # Gets the value of the attribute for the given target object and options
     #
-    # @param model [Object] typically ActiveRecord::Base, but could be anything
+    # @param target [Object] typically ActiveRecord::Base, but could be anything
     # @param options [Hash] any optional values from the serializer instance
     # @return the value for the attribute for the given model and options
     # @raise [InvalidCoercionType] when an invalid argument is passed in the
     #   to: argument
-    def value_for(model, options)
-      value = model.public_send(method_name)
+    def value_for(target, options)
+      value =
+        if block?
+          block.call(target, options)
+        elsif through?
+          target.public_send(through)&.public_send(method_name)
+        else
+          target.public_send(method_name)
+        end
 
       serializer ? serialize(value, options) : coerce(value)
     end
 
+
+
     private
 
+    def through?
+      !through.nil?
+    end
+
+    def block?
+      !block.nil?
+    end
+
+    # Here we'll render the attribute with a given serializer and attempt to
+    # cache the results for better cache reusability
     def serialize(value, options)
       plan = CacheCrispies::Plan.new(serializer, value, options)
 
-      if value.respond_to?(:each)
+      if plan.collection?
         plan.cache { Collection.new(value, serializer, options).as_json }
       else
         plan.cache { serializer.new(value, options).as_json }

data/lib/cache_crispies/base.rb

@@ -43,55 +43,118 @@ module CacheCrispies
       HashBuilder.new(self).call
     end
 
-    # Whether or not this serializer class should allow caching of results.
-    # It is set to false by default, but can be overridden in child classes.
+    # Get or set whether or not this serializer class should allow caching of
+    # results. It returns false by default, but can be overridden in child
+    # classes. Calling the method with an argument will set the value, calling
+    # it without any arguments will get the value.
     #
+    # @param value [Boolean] true to enable caching, false to disable
     # @return [Boolean]
-    def self.do_caching?
-      false
+    def self.do_caching(value = nil)
+      @do_caching ||= false
+
+      # method called with no args so act as a getter
+      return @do_caching if value.nil?
+
+      # method called with args so act as a setter
+      @do_caching = !!value
+    end
+
+    class << self
+      alias do_caching? do_caching
     end
 
-    # A JSON key to use as a root key on a non-collection serializable. by
-    # default it's the name of the class without the "Serializer" part. But it
-    # can be overridden in a subclass to be anything.
+    # Get or set a JSON key to use as a root key on a non-collection
+    # serializable. By default it's the name of the class without the
+    # "Serializer" part. But it can be overridden in a subclass to be anything.
+    # Calling the method with a key will set the key, calling it without any
+    # arguments will get the key.
     #
-    # @return [Symbol] a symbol to be used as a key for a JSON-ready Hash
-    def self.key
-      to_s.demodulize.chomp('Serializer').underscore.to_sym
+    # @param key [Symbol, nil] a symbol to be used as a key for a JSON-ready
+    # Hash, or nil for no key
+    # @return [Symbol, nil] a symbol to be used as a key for a JSON-ready Hash,
+    # or nil for no key
+    def self.key(*key)
+      @default_key ||= to_s.demodulize.chomp('Serializer').underscore.to_sym
+
+      # method called with no args so act as a getter
+      return defined?(@key) ? @key : @default_key if key.empty?
+
+      # method called with args so act as a setter
+      @key = key.first&.to_sym
     end
 
-    # A JSON key to use as a root key on a collection-type serializable. By
-    # deafult it's the plural version of .key, but it can be overridden in a
-    # subclass to be anything.
+    # Get or set a JSON key to use as a root key on a collection-type
+    # serializable. By deafult it's the plural version of .key, but it can be
+    # overridden in a subclass to be anything. Calling the method with a key
+    # will set the key, calling it without any arguments will get the key.
     #
     # @return [Symbol] a symbol to be used as a key for a JSON-ready Hash
-    def self.collection_key
-      return nil unless key
+    # @param key [Symbol, nil] a symbol to be used as a key for a JSON-ready
+    # Hash, or nil for no key
+    # @return [Symbol, nil] a symbol to be used as a key for a JSON-ready Hash,
+    # or nil for no key
+    def self.collection_key(*key)
+      @default_collection_key ||= self.key.to_s.pluralize.to_sym
+
+      # method called with no args so act as a getter
+      if key.empty?
+        if defined? @collection_key
+          return @collection_key
+        else
+          return @default_collection_key
+        end
+      end
 
-      key.to_s.pluralize.to_sym
+      # method called with args so act as a setter
+      @collection_key = key.first&.to_sym
     end
 
-    # An array of strings that should be added to the cache key for an instance
-    # of this serializer. Typically you'd add in the #cache_key or string value
-    # for any extra models or data passed in through the options hash here. But
-    # it could also contain any custom logic about how to construct a cache
-    # key. This method is meant to be overridden in subclasses.
+    # Call with a block returning an array of strings that should be added to
+    # the cache key for an instance of this serializer. Typically you'd add
+    # in string values to uniquely represent the values you're passing to
+    # the serializer so that they are cached separately. But it could also
+    # contain any custom logic about how to construct a cache key.
+    # Call without a block to act as a getter and return the value.
     #
     # @example cache based off models provided in options
-    #   def self.cache_key_addons(options)
-    #     [options[:current_user].cache_key]
-    #   end
+    #   cache_key_addons { |options| [options[:current_user].id] }
     #
     # @example time-based caching
-    #   def self.cache_key_addons(_options)
-    #     [Date.today.to_s]
-    #   end
+    #   cache_key_addons { |_options| [Date.today.to_s] }
     #
     # @param options [Hash] the options hash passed to the serializer, will be
     # passed in here as well so you can refernce it if needed.
+    # @yield [options] a block that takes options passed to the serializer and
+    # should return an array of strings to use in the cache key
     # @return [Array<String>]
-    def self.cache_key_addons(_options = {})
-      []
+    def self.cache_key_addons(options = {}, &block)
+      @cache_key_addons ||= nil
+
+      if block_given?
+        @cache_key_addons = block
+        nil
+      else
+        Array(@cache_key_addons&.call(options))
+      end
+    end
+
+    # Get or set a cache key that can be changed whenever an outside dependency
+    # of any kind changes in any way that could change the output of your
+    # serializer. For instance, if a mixin is changed. Or maybe an object
+    # you're serializing has changed it's #to_json method. This key should be
+    # changed accordingly, to bust the cache so that you're not serving stale
+    # data.
+    #
+    # @return [String] a version string in any form
+    def self.dependency_key(key = nil)
+      @dependency_key ||= nil
+
+      # method called with no args so act as a getter
+      return @dependency_key unless key
+
+      # method called with args so act as a setter
+      @dependency_key = key.to_s
     end
 
     # Return a cache key string for the serializer class to be included in the
@@ -155,7 +218,11 @@ module CacheCrispies
     end
     private_class_method :nested_serializers
 
-    def self.serialize(*attribute_names, from: nil, with: nil, to: nil)
+    def self.serialize(
+      *attribute_names,
+      from: nil, with: nil, through: nil, to: nil,
+      &block
+    )
       attribute_names.flatten.map { |att| att&.to_sym }.map do |attrib|
         current_nesting = Array(@nesting).dup
         current_conditions = Array(@conditions).dup
@@ -165,9 +232,11 @@ module CacheCrispies
             attrib,
             from: from,
             with: with,
+            through: through,
             to: to,
             nesting: current_nesting,
-            conditions: current_conditions
+            conditions: current_conditions,
+            &block
           )
       end
     end

data/lib/cache_crispies/collection.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rails'
-
 module CacheCrispies
   # Handles rendering and possibly caching a collection of models using a
   #   Serializer
@@ -48,11 +46,11 @@ module CacheCrispies
         hash[plan.cache_key] = model
       end
 
-      Rails.cache.fetch_multi(models_by_cache_key.keys) do |cache_key|
+      CacheCrispies.cache.fetch_multi(*models_by_cache_key.keys) do |cache_key|
         model = models_by_cache_key[cache_key]
 
         serializer.new(model, options).as_json
-      end
+      end.values
     end
   end
 end

data/lib/cache_crispies/configuration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module CacheCrispies
+  class Configuration
+    SETTINGS = [
+      :cache_store,
+      :etags
+    ].freeze
+
+    SETTINGS.each do |setting|
+      attr_accessor setting
+    end
+
+    def initialize
+      reset!
+    end
+
+    alias etags? etags
+
+    # Resets all values to their defaults. Useful for testing.
+    def reset!
+      @cache_store = Rails.cache || ActiveSupport::Cache::NullStore.new
+      @etags = false
+    end
+  end
+end

data/lib/cache_crispies/controller.rb

@@ -28,14 +28,16 @@ module CacheCrispies
     def cache_render(serializer, cacheable, options = {})
       plan = CacheCrispies::Plan.new(serializer, cacheable, options)
 
-      # TODO: It would probably be good to add configuration to etiher
-      # enable or disable this
-      response.weak_etag = plan.etag
+      if CacheCrispies.config.etags?
+        response.weak_etag = plan.etag
+      end
 
       serializer_json =
         if plan.collection?
-          cacheable.map do |one_cacheable|
-            plan.cache { serializer.new(one_cacheable, options).as_json }
+          plan.cache do
+            CacheCrispies::Collection.new(
+              cacheable, serializer, options
+            ).as_json
           end
         else
           plan.cache { serializer.new(cacheable, options).as_json }

data/lib/cache_crispies/plan.rb

@@ -57,6 +57,7 @@ module CacheCrispies
         [
           CACHE_KEY_PREFIX,
           serializer.cache_key_base,
+          serializer.dependency_key,
           addons_key,
           cacheable.cache_key
         ].flatten.compact.join(CACHE_KEY_SEPARATOR)
@@ -69,7 +70,7 @@ module CacheCrispies
     # @return whatever the provided block returns
     def cache
       if cache?
-        Rails.cache.fetch(cache_key) { yield }
+        CacheCrispies.cache.fetch(cache_key) { yield }
       else
         yield
       end

data/lib/cache_crispies/version.rb

@@ -2,5 +2,5 @@
 
 module CacheCrispies
   # The version of the gem
-  VERSION = '0.3.1'
+  VERSION = '1.0.1'
 end

data/spec/{attribute_spec.rb → cache_crispies/attribute_spec.rb}

@@ -14,6 +14,7 @@ describe CacheCrispies::Attribute do
   let(:key) { :name }
   let(:from) { nil }
   let(:with) { nil }
+  let(:through) { nil }
   let(:to) { nil }
   let(:nesting) { [] }
   let(:conditions) { [] }
@@ -22,6 +23,7 @@ describe CacheCrispies::Attribute do
       key,
       from: from,
       with: with,
+      through: through,
       to: to,
       nesting: nesting,
       conditions: conditions
@@ -60,6 +62,23 @@ describe CacheCrispies::Attribute do
       end
     end
 
+    context 'with a through: argument' do
+      let(:through) { :branding }
+      let(:model) { OpenStruct.new(branding: OpenStruct.new(name: name)) }
+
+      it 'returns the value from the "through" object' do
+        expect(subject).to eq name
+      end
+
+      context 'when the through method returns nil' do
+        let(:model) { OpenStruct.new(branding: nil) }
+
+        it 'returns nil' do
+          expect(subject).to be nil
+        end
+      end
+    end
+
     context 'with a to: argument' do
       context 'when corecing to a String' do
         let(:name) { 1138 }
@@ -155,5 +174,15 @@ describe CacheCrispies::Attribute do
         end
       end
     end
+
+    context 'with a block' do
+      let(:instance) {
+        described_class.new(key) { |model, _opt| model.name.upcase }
+      }
+
+      it 'uses the return value of the block' do
+        expect(subject).to eq "CAP'N CRUNCH"
+      end
+    end
   end
 end