active_model_cachers 2.1.3 → 2.1.8

data/lib/active_model_cachers/cache_service.rb

@@ -1,134 +1,151 @@
-# frozen_string_literal: true
-require 'active_model_cachers/nil_object'
-require 'active_model_cachers/false_object'
-require 'active_model_cachers/column_value_cache'
-
-module ActiveModelCachers
-  class CacheService
-    class << self
-      attr_accessor :cache_key
-      attr_accessor :query
-
-      def instance(id)
-        hash = (RequestStore.store[self] ||= {})
-        return hash[id] ||= new(id)
-      end
-
-      def clean_at(id)
-        instance(id).clean_cache
-      end
-
-      @@column_value_cache = ActiveModelCachers::ColumnValueCache.new
-      def define_callback_for_cleaning_cache(class_name, column, foreign_key, with_id, on: nil)
-        return if @callbacks_defined
-        @callbacks_defined = true
-
-        clean = ->(id){ clean_at(with_id ? id : nil) }
-        clean_ids = []
-        fire_on = Array(on) if on
-
-        ActiveRecord::Extension.global_callbacks.instance_exec do
-          on_nullify(class_name) do |nullified_column, get_ids|
-            get_ids.call.each{|s| clean.call(s) } if nullified_column == column
-          end
-
-          after_touch(class_name) do
-            clean.call(send(foreign_key))
-          end
-
-          after_commit(class_name) do # TODO: on
-            next if fire_on and not transaction_include_any_action?(fire_on)
-            changed = column ? previous_changes.key?(column) : previous_changes.present?
-            clean.call(send(foreign_key)) if changed || destroyed?
-          end
-
-          pre_before_delete(class_name) do |id, model|
-            clean_ids << @@column_value_cache.add(self, class_name, id, foreign_key, model)
-          end
-
-          before_delete(class_name) do |_, model|
-            clean_ids.each{|s| clean.call(s.call) }
-            clean_ids = []
-          end
-
-          after_delete(class_name) do
-            @@column_value_cache.clean_cache
-          end
-        end
-      end
-    end
-
-    # ----------------------------------------------------------------
-    # ● instance methods
-    # ----------------------------------------------------------------
-    def initialize(id)
-      @id = id
-    end
-
-    def get(binding: nil)
-      @cached_data ||= fetch_from_cache(binding: binding)
-      return cache_to_raw_data(@cached_data)
-    end
-
-    def peek(binding: nil)
-      @cached_data ||= get_from_cache
-      return cache_to_raw_data(@cached_data)
-    end
-
-    def clean_cache(binding: nil)
-      @cached_data = nil
-      Rails.cache.delete(cache_key)
-      return nil
-    end
-
-    private
-
-    def cache_key
-      key = self.class.cache_key
-      return @id ? "#{key}_#{@id}" : key
-    end
-
-    def get_without_cache(binding)
-      query = self.class.query
-      return binding ? binding.instance_exec(@id, &query) : query.call(@id) if @id and query.parameters.size == 1
-      return binding ? binding.instance_exec(&query) : query.call
-    end
-
-    def raw_to_cache_data(raw)
-      return NilObject if raw == nil
-      return FalseObject if raw == false
-      clean_ar_cache(raw.is_a?(Array) ? raw : [raw])
-      return raw_without_singleton_methods(raw)
-    end
-
-    def cache_to_raw_data(cached_data)
-      return nil if cached_data == NilObject
-      return false if cached_data == FalseObject
-      return cached_data
-    end
-
-    def get_from_cache
-      ActiveModelCachers.config.store.read(cache_key)
-    end
-
-    def fetch_from_cache(binding: nil)
-      ActiveModelCachers.config.store.fetch(cache_key, expires_in: 30.minutes) do
-        raw_to_cache_data(get_without_cache(binding))
-      end
-    end
-
-    def clean_ar_cache(models)
-      return if not models.first.is_a?(::ActiveRecord::Base)
-      models.each_with_index do |model, index|
-        model.send(:clear_aggregation_cache)
-        model.send(:clear_association_cache)
-      end
-    end
-
-    def raw_without_singleton_methods(raw)
-      return raw if raw.singleton_methods.empty?
-      return raw.class.find_by(id: raw.id) if raw.is_a?(::ActiveRecord::Base) # cannot marshal singleton, so load a new record instead.
-      return raw # not sure what to do with other cases
-    end
-  end
-end
+# frozen_string_literal: true
+require 'active_model_cachers/nil_object'
+require 'active_model_cachers/false_object'
+require 'active_model_cachers/column_value_cache'
+
+module ActiveModelCachers
+  class CacheService
+    class << self
+      attr_accessor :cache_key
+      attr_accessor :query_mapping
+
+      def instance(id)
+        hash = (RequestStore.store[self] ||= {})
+        return hash[id] ||= new(id)
+      end
+
+      def clean_at(id)
+        instance(id).clean_cache
+      end
+
+      @@column_value_cache = ActiveModelCachers::ColumnValueCache.new
+      def define_callback_for_cleaning_cache(class_name, column, foreign_key, with_id, on: nil)
+        return if @callbacks_defined
+        @callbacks_defined = true
+
+        clean = ->(id){ clean_at(with_id ? id : nil) }
+        clean_ids = []
+        fire_on = Array(on) if on
+
+        ActiveRecord::Extension.global_callbacks.instance_exec do
+          on_nullify(class_name) do |nullified_column, get_ids|
+            get_ids.call.each{|s| clean.call(s) } if nullified_column == column
+          end
+
+          after_touch1(class_name) do
+            clean.call(@@column_value_cache.add(self.class, class_name, id, foreign_key, self).call)
+          end
+
+          after_touch2(class_name) do
+            @@column_value_cache.clean_cache
+          end
+
+          after_commit1(class_name) do
+            next if fire_on and not transaction_include_any_action?(fire_on)
+            changed = column ? previous_changes.key?(column) : previous_changes.present?
+             if changed || destroyed?
+               clean.call(@@column_value_cache.add(self.class, class_name, id, foreign_key, self).call)
+             end
+          end
+
+          after_commit2(class_name) do
+            @@column_value_cache.clean_cache
+          end
+
+          before_delete1(class_name) do |id, model|
+            clean_ids << @@column_value_cache.add(self, class_name, id, foreign_key, model)
+          end
+
+          before_delete2(class_name) do |_, model|
+            clean_ids.each{|s| clean.call(s.call) }
+            clean_ids = []
+          end
+
+          after_delete(class_name) do
+            @@column_value_cache.clean_cache
+          end
+        end
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # ● instance methods
+    # ----------------------------------------------------------------
+    def initialize(id)
+      @id = id
+    end
+
+    def get(binding: nil, reflect: nil)
+      @cached_data ||= fetch_from_cache(binding: binding, reflect: reflect)
+      return cache_to_raw_data(@cached_data)
+    end
+
+    def peek(binding: nil, reflect: nil)
+      @cached_data ||= get_from_cache
+      return cache_to_raw_data(@cached_data)
+    end
+
+    def clean_cache(binding: nil, reflect: nil)
+      @cached_data = nil
+      Rails.cache.delete(cache_key)
+      return nil
+    end
+
+    private
+
+    def cache_key
+      key = self.class.cache_key
+      return @id ? "#{key}_#{@id}" : key
+    end
+
+    def get_query(binding, reflect)
+      self.class.query_mapping[reflect] || begin
+        puts "Warning: cannot find query. possible reflects: #{self.class.query_mapping.keys}, reflect: #{reflect}"
+        self.class.query_mapping.values.first
+      end
+    end
+
+    def get_without_cache(binding, attr)
+      query = get_query(binding, attr)
+      return binding ? binding.instance_exec(@id, &query) : query.call(@id) if @id and query.parameters.size == 1
+      return binding ? binding.instance_exec(&query) : query.call
+    end
+
+    def raw_to_cache_data(raw)
+      return NilObject if raw == nil
+      return FalseObject if raw == false
+      clean_ar_cache(raw.is_a?(Array) ? raw : [raw])
+      return raw_without_singleton_methods(raw)
+    end
+
+    def cache_to_raw_data(cached_data)
+      return nil if cached_data == NilObject
+      return false if cached_data == FalseObject
+      return cached_data
+    end
+
+    def get_from_cache
+      ActiveModelCachers.config.store.read(cache_key)
+    end
+
+    def fetch_from_cache(binding: nil, reflect: nil)
+      ActiveModelCachers.config.store.fetch(cache_key, expires_in: 30.minutes) do
+        raw_to_cache_data(get_without_cache(binding, reflect))
+      end
+    end
+
+    def clean_ar_cache(models)
+      return if not models.first.is_a?(::ActiveRecord::Base)
+      models.each do |model|
+        model.send(:clear_aggregation_cache) if model.respond_to?(:clear_aggregation_cache, true)
+        model.send(:clear_association_cache)
+      end
+    end
+
+    def raw_without_singleton_methods(raw)
+      return raw if raw.singleton_methods.empty?
+      return raw.class.find_by(id: raw.id) if raw.is_a?(::ActiveRecord::Base) # cannot marshal singleton, so load a new record instead.
+      return raw # not sure what to do with other cases
+    end
+  end
+end

data/lib/active_model_cachers/cache_service_factory.rb

@@ -1,55 +1,55 @@
-# frozen_string_literal: true
-require 'request_store'
-require 'active_model_cachers/cache_service'
-
-module ActiveModelCachers
-  class CacheServiceFactory
-    @key_class_mapping = {}
-    @cache_key_klass_mapping = {}
-
-    class << self
-      def has_cacher?(attr)
-        return (@key_class_mapping[get_cache_key(attr)] != nil)
-      end
-
-      def create_for_active_model(attr, query)
-        create(get_cache_key(attr), query)
-      end
-
-      def create(cache_key, query)
-        @key_class_mapping[cache_key] ||= ->{
-          klass = Class.new(CacheService)
-          klass.cache_key = cache_key
-          klass.query = query
-          klass.instance_variable_set(:@callbacks_defined, false) # to remove warning: instance variable @callbacks_defined not initialized
-          next klass
-        }[]
-      end
-
-      def set_klass_to_mapping(attr, current_klass)
-        cache_key = get_cache_key(attr)
-        reflect = attr.klass.reflect_on_association(:posts)
-        changed = clean_klass_cache_if_reloaded!(cache_key, current_klass, attr)
-        @cache_key_klass_mapping[cache_key] = current_klass
-        return changed
-      end
-
-      private
-
-      def get_cache_key(attr)
-        class_name, column = attr.extract_class_and_column
-        return "active_model_cachers_#{class_name}_at_#{column}" if column
-        foreign_key = attr.foreign_key(reverse: true)
-        return "active_model_cachers_#{class_name}_by_#{foreign_key}" if foreign_key and foreign_key.to_s != 'id'
-        return "active_model_cachers_#{class_name}"
-      end
-
-      def clean_klass_cache_if_reloaded!(cache_key, current_klass, attr)
-        origin_klass, @cache_key_klass_mapping[cache_key] = @cache_key_klass_mapping[cache_key], current_klass
-        return false if origin_klass == nil or origin_klass == current_klass # when code reloaded in development.
-        @key_class_mapping[cache_key] = nil
-        return true
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require 'request_store'
+require 'active_model_cachers/cache_service'
+
+module ActiveModelCachers
+  class CacheServiceFactory
+    @key_class_mapping = {}
+    @cache_key_klass_mapping = {}
+
+    class << self
+      def has_cacher?(attr)
+        return (@key_class_mapping[get_cache_key(attr)] != nil)
+      end
+
+      def create_for_active_model(attr, query)
+        cache_key = get_cache_key(attr)
+
+        klass = @key_class_mapping[cache_key] ||= ->{
+          klass = Class.new(CacheService)
+          klass.cache_key = cache_key
+          klass.query_mapping = {}
+          klass.instance_variable_set(:@callbacks_defined, false) # to remove warning: instance variable @callbacks_defined not initialized
+          next klass
+        }[]
+
+        klass.query_mapping[attr.reflect] = query
+        return klass
+      end
+
+      def set_klass_to_mapping(attr, current_klass)
+        cache_key = get_cache_key(attr)
+        changed = clean_klass_cache_if_reloaded!(cache_key, current_klass, attr)
+        @cache_key_klass_mapping[cache_key] = current_klass
+        return changed
+      end
+
+      private
+
+      def get_cache_key(attr)
+        class_name, column = attr.extract_class_and_column
+        return "active_model_cachers_#{class_name}_at_#{column}" if column
+        foreign_key = attr.foreign_key(reverse: true)
+        return "active_model_cachers_#{class_name}_by_#{foreign_key}" if foreign_key and foreign_key.to_s != 'id'
+        return "active_model_cachers_#{class_name}"
+      end
+
+      def clean_klass_cache_if_reloaded!(cache_key, current_klass, attr)
+        origin_klass, @cache_key_klass_mapping[cache_key] = @cache_key_klass_mapping[cache_key], current_klass
+        return false if origin_klass == nil or origin_klass == current_klass # when code reloaded in development.
+        @key_class_mapping[cache_key] = nil
+        return true
+      end
+    end
+  end
+end

data/lib/active_model_cachers/column_value_cache.rb

@@ -1,46 +1,47 @@
-# frozen_string_literal: true
-class ActiveModelCachers::ColumnValueCache
-  def initialize
-    @cache1 = Hash.new{|h, k| h[k] = {} }
-    @cache2 = Hash.new{|h, k| h[k] = {} }
-  end
-
-  def add(object, class_name, id, foreign_key, model)
-    value = (@cache1[class_name][[id, foreign_key]] ||= get_id_from(object, id, foreign_key, model))
-    return ->{ (value == :not_set ? query_value(object, class_name, id, foreign_key) : value)}
-  end
-
-  def query_value(object, class_name, id, foreign_key)
-    cache = @cache2[class_name]
-    if cache.empty?
-      no_data_keys = @cache1[class_name].select{|k, v| v == :not_set }.keys
-      ids = no_data_keys.map(&:first).uniq
-      columns = ['id', *no_data_keys.map(&:second)].uniq
-      pluck_columns(object, object.where(id: ids).limit(ids.size), columns).each do |columns_data|
-        model_id = columns_data.first
-        columns.each_with_index do |column, index|
-          cache[[model_id, column]] = columns_data[index]
-        end
-      end
-    end
-    return cache[[id, foreign_key]]
-  end
-
-  def clean_cache
-    @cache1.clear
-    @cache2.clear
-  end
-
-  private
-
-  def pluck_columns(_, relation, columns)
-    relation.pluck(*columns)
-  end
-
-  def get_id_from(object, id, column, model)
-    return id if column == 'id'
-    model ||= object.cacher.peek_by(id: id) if object.has_cacher?
-    return model.send(column) if model
-    return :not_set
-  end
-end
+# frozen_string_literal: true
+
+class ActiveModelCachers::ColumnValueCache
+  def initialize
+    @cache1 = Hash.new{|h, k| h[k] = {} }
+    @cache2 = Hash.new{|h, k| h[k] = {} }
+  end
+
+  def add(object, class_name, id, foreign_key, model)
+    value = (@cache1[class_name][[id, foreign_key]] ||= get_id_from(object, id, foreign_key, model))
+    return ->{ (value == :not_set ? query_value(object, class_name, id, foreign_key) : value)}
+  end
+
+  def query_value(object, class_name, id, foreign_key)
+    cache = @cache2[class_name]
+    if cache.empty?
+      no_data_keys = @cache1[class_name].select{|k, v| v == :not_set }.keys
+      ids = no_data_keys.map(&:first).uniq
+      columns = ['id', *no_data_keys.map(&:second)].uniq
+      pluck_columns(object, object.where(id: ids).limit(ids.size), columns).each do |columns_data|
+        model_id = columns_data.first
+        columns.each_with_index do |column, index|
+          cache[[model_id, column]] = columns_data[index]
+        end
+      end
+    end
+    return cache[[id, foreign_key]]
+  end
+
+  def clean_cache
+    @cache1.clear
+    @cache2.clear
+  end
+
+  private
+
+  def pluck_columns(_, relation, columns)
+    relation.pluck(*columns)
+  end
+
+  def get_id_from(object, id, column, model)
+    return id if column == 'id'
+    model ||= object.cacher.peek_by(id: id) if object.has_cacher?
+    return model.send(column) if model and model.has_attribute?(column)
+    return :not_set
+  end
+end