active_model_cachers 2.1.6 → 2.1.7

data/lib/active_model_cachers/active_record/extension.rb

@@ -1,119 +1,119 @@
-# frozen_string_literal: true
-require 'active_model_cachers/active_record/global_callbacks'
-require 'active_model_cachers/active_record/attr_model'
-require 'active_model_cachers/active_record/cacher'
-require 'active_model_cachers/hook/dependencies'
-require 'active_model_cachers/hook/associations'
-require 'active_model_cachers/hook/on_model_delete'
-
-module ActiveModelCachers
-  module ActiveRecord
-    module Extension
-      def cache_self(by: :id)
-        cache_at(nil, expire_by: self.name, primary_key: by, foreign_key: by)
-      end
-
-      def cache_at(column, query = nil, expire_by: nil, on: nil, foreign_key: nil, primary_key: nil)
-        attr = AttrModel.new(self, column, foreign_key: foreign_key, primary_key: primary_key)
-        return cache_belongs_to(attr) if attr.belongs_to?
-
-        loaded = false
-        class_name, *infos = get_expire_infos(attr, expire_by, foreign_key)
-        set_klass_to_mapping(attr, class_name) do
-          next if !loaded
-          cache_at(column, query, expire_by: expire_by, on: on, foreign_key: foreign_key, primary_key: primary_key)
-        end
-        loaded = true
-
-        query ||= ->(id){ attr.query_model(self, id) }
-        service_klass = CacheServiceFactory.create_for_active_model(attr, query)
-        Cacher.define_cacher_method(attr, attr.primary_key || :id, [service_klass])
-
-        if class_name
-          with_id = (expire_by.is_a?(Symbol) || query.parameters.size == 1)
-          service_klass.define_callback_for_cleaning_cache(class_name, *infos, with_id, on: on)
-        end
-
-        return service_klass
-      end
-
-      def has_cacher?(column = nil)
-        attr = AttrModel.new(self, column)
-        return CacheServiceFactory.has_cacher?(attr)
-      end
-
-      private
-
-      def set_klass_to_mapping(attr, class_name)
-        ActiveSupport::Dependencies.onload(class_name || self.to_s) do
-          yield if CacheServiceFactory.set_klass_to_mapping(attr, self)
-        end
-      end
-
-      def get_expire_infos(attr, expire_by, foreign_key)
-        if expire_by.is_a?(Symbol)
-          expire_attr = get_association_attr(expire_by)
-          if expire_attr.join_table_class_name
-            expire_attr.klass.send(:"after_add_for_#{expire_by}") << gen_has_many_through_callback(attr.column)
-            expire_attr.klass.send(:"after_remove_for_#{expire_by}") << gen_has_many_through_callback(attr.column)
-            expire_by = expire_attr.join_table_class_name
-          else
-            expire_by = get_expire_by_from(expire_attr)
-          end
-        else
-          expire_attr = attr
-          expire_by ||= get_expire_by_from(expire_attr)
-        end
-        return if expire_by == nil
-
-        class_name, column = expire_by.split('#', 2)
-        foreign_key ||= expire_attr.foreign_key(reverse: true) || 'id'
-
-        return class_name, column, foreign_key.to_s
-      end
-
-      NO_MACRO_FOR_AFTER_ADD = Gem::Version.new(::ActiveRecord::VERSION::STRING) < Gem::Version.new('4')
-      def gen_has_many_through_callback(column)
-        return ->(this, _that){ this.cacher.clean(column) } if NO_MACRO_FOR_AFTER_ADD
-        return ->(_, this, _that){ this.cacher.clean(column) }
-      end
-
-      def get_association_attr(column)
-        attr = AttrModel.new(self, column)
-        raise "#{column} is not an association" if not attr.association?
-        return attr
-      end
-
-      def get_expire_by_from(attr)
-        return attr.class_name if attr.association?
-        return "#{self}##{attr.column}" if column_names.include?(attr.column.to_s)
-      end
-
-      def cache_belongs_to(attr)
-        service_klasses = [cache_at(attr.foreign_key)]
-        Cacher.define_cacher_method(attr, attr.primary_key, service_klasses)
-        ActiveSupport::Dependencies.onload(attr.class_name) do
-          service_klasses << cache_self
-        end
-      end
-
-      @global_callbacks = nil
-      def self.global_callbacks
-        if @global_callbacks == nil
-          global_callbacks = @global_callbacks = GlobalCallbacks.new
-          ::ActiveRecord::Base.instance_exec do
-            after_commit ->{
-              global_callbacks.after_commit1.exec(self, self.class)
-              global_callbacks.after_commit2.exec(self, self.class)
-            }
-            after_touch ->{
-              global_callbacks.after_touch1.exec(self, self.class)
-              global_callbacks.after_touch2.exec(self, self.class)
-            }
-          end
-        end
-        return @global_callbacks
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require 'active_model_cachers/active_record/global_callbacks'
+require 'active_model_cachers/active_record/attr_model'
+require 'active_model_cachers/active_record/cacher'
+require 'active_model_cachers/hook/dependencies'
+require 'active_model_cachers/hook/associations'
+require 'active_model_cachers/hook/on_model_delete'
+
+module ActiveModelCachers
+  module ActiveRecord
+    module Extension
+      def cache_self(by: :id)
+        cache_at(nil, expire_by: self.name, primary_key: by, foreign_key: by)
+      end
+
+      def cache_at(column, query = nil, expire_by: nil, on: nil, foreign_key: nil, primary_key: nil)
+        attr = AttrModel.new(self, column, foreign_key: foreign_key, primary_key: primary_key)
+        return cache_belongs_to(attr) if attr.belongs_to?
+
+        loaded = false
+        class_name, *infos = get_expire_infos(attr, expire_by, foreign_key)
+        set_klass_to_mapping(attr, class_name) do
+          next if !loaded
+          cache_at(column, query, expire_by: expire_by, on: on, foreign_key: foreign_key, primary_key: primary_key)
+        end
+        loaded = true
+
+        query ||= ->(id){ attr.query_model(self, id) }
+        service_klass = CacheServiceFactory.create_for_active_model(attr, query)
+        Cacher.define_cacher_method(attr, attr.primary_key || :id, [service_klass])
+
+        if class_name
+          with_id = (expire_by.is_a?(Symbol) || query.parameters.size == 1)
+          service_klass.define_callback_for_cleaning_cache(class_name, *infos, with_id, on: on)
+        end
+
+        return service_klass
+      end
+
+      def has_cacher?(column = nil)
+        attr = AttrModel.new(self, column)
+        return CacheServiceFactory.has_cacher?(attr)
+      end
+
+      private
+
+      def set_klass_to_mapping(attr, class_name)
+        ActiveSupport::Dependencies.onload(class_name || self.to_s) do
+          yield if CacheServiceFactory.set_klass_to_mapping(attr, self)
+        end
+      end
+
+      def get_expire_infos(attr, expire_by, foreign_key)
+        if expire_by.is_a?(Symbol)
+          expire_attr = get_association_attr(expire_by)
+          if expire_attr.join_table_class_name
+            expire_attr.klass.send(:"after_add_for_#{expire_by}") << gen_has_many_through_callback(attr.column)
+            expire_attr.klass.send(:"after_remove_for_#{expire_by}") << gen_has_many_through_callback(attr.column)
+            expire_by = expire_attr.join_table_class_name
+          else
+            expire_by = get_expire_by_from(expire_attr)
+          end
+        else
+          expire_attr = attr
+          expire_by ||= get_expire_by_from(expire_attr)
+        end
+        return if expire_by == nil
+
+        class_name, column = expire_by.split('#', 2)
+        foreign_key ||= expire_attr.foreign_key(reverse: true) || 'id'
+
+        return class_name, column, foreign_key.to_s
+      end
+
+      NO_MACRO_FOR_AFTER_ADD = Gem::Version.new(::ActiveRecord::VERSION::STRING) < Gem::Version.new('4')
+      def gen_has_many_through_callback(column)
+        return ->(this, _that){ this.cacher.clean(column) } if NO_MACRO_FOR_AFTER_ADD
+        return ->(_, this, _that){ this.cacher.clean(column) }
+      end
+
+      def get_association_attr(column)
+        attr = AttrModel.new(self, column)
+        raise "#{column} is not an association" if not attr.association?
+        return attr
+      end
+
+      def get_expire_by_from(attr)
+        return attr.class_name if attr.association?
+        return "#{self}##{attr.column}" if column_names.include?(attr.column.to_s)
+      end
+
+      def cache_belongs_to(attr)
+        service_klasses = [cache_at(attr.foreign_key)]
+        Cacher.define_cacher_method(attr, attr.primary_key, service_klasses)
+        ActiveSupport::Dependencies.onload(attr.class_name) do
+          service_klasses << cache_self
+        end
+      end
+
+      @global_callbacks = nil
+      def self.global_callbacks
+        if @global_callbacks == nil
+          global_callbacks = @global_callbacks = GlobalCallbacks.new
+          ::ActiveRecord::Base.instance_exec do
+            after_commit ->{
+              global_callbacks.after_commit1.exec(self, self.class)
+              global_callbacks.after_commit2.exec(self, self.class)
+            }
+            after_touch ->{
+              global_callbacks.after_touch1.exec(self, self.class)
+              global_callbacks.after_touch2.exec(self, self.class)
+            }
+          end
+        end
+        return @global_callbacks
+      end
+    end
+  end
+end

data/lib/active_model_cachers/active_record/global_callbacks.rb

@@ -1,67 +1,67 @@
-module ActiveModelCachers
-  module ActiveRecord
-    class GlobalCallbacks
-      def initialize
-        @type_callbacks = {}
-      end
-
-      def before_delete1(class_name = nil, &block)
-        define_callbacks(:before_delete1, class_name, &block)
-      end
-
-      def before_delete2(class_name = nil, &block)
-        define_callbacks(:before_delete2, class_name, &block)
-      end
-
-      def after_delete(class_name = nil, &block)
-        define_callbacks(:after_delete, class_name, &block)
-      end
-
-      def on_nullify(class_name = nil, &block)
-        define_callbacks(:on_nullify, class_name, &block)
-      end
-
-      def after_commit1(class_name = nil, &block)
-        define_callbacks(:after_commit1, class_name, &block)
-      end
-
-      def after_commit2(class_name = nil, &block)
-        define_callbacks(:after_commit2, class_name, &block)
-      end
-
-      def after_touch1(class_name = nil, &block)
-        define_callbacks(:after_touch1, class_name, &block)
-      end
-
-      def after_touch2(class_name = nil, &block)
-        define_callbacks(:after_touch2, class_name, &block)
-      end
-
-      private
-
-      def define_callbacks(type, class_name, &block)
-        (@type_callbacks[type] ||= ClassCallbacks.new).tap do |s|
-          s.add_callback(class_name, &block) if class_name
-        end
-      end
-    end
-
-    class ClassCallbacks
-      def initialize
-        @class_callbacks = Hash.new{|h, k| h[k] = [] }
-      end
-
-      def callbacks_at(class_name)
-        @class_callbacks[class_name]
-      end
-
-      def add_callback(class_name, &block)
-        callbacks_at(class_name) << block
-      end
-
-      def exec(scope, klass, *args)
-        callbacks_at(klass.name).each{|s| scope.instance_exec(*args, &s) }
-      end
-    end
-  end
-end
+module ActiveModelCachers
+  module ActiveRecord
+    class GlobalCallbacks
+      def initialize
+        @type_callbacks = {}
+      end
+
+      def before_delete1(class_name = nil, &block)
+        define_callbacks(:before_delete1, class_name, &block)
+      end
+
+      def before_delete2(class_name = nil, &block)
+        define_callbacks(:before_delete2, class_name, &block)
+      end
+
+      def after_delete(class_name = nil, &block)
+        define_callbacks(:after_delete, class_name, &block)
+      end
+
+      def on_nullify(class_name = nil, &block)
+        define_callbacks(:on_nullify, class_name, &block)
+      end
+
+      def after_commit1(class_name = nil, &block)
+        define_callbacks(:after_commit1, class_name, &block)
+      end
+
+      def after_commit2(class_name = nil, &block)
+        define_callbacks(:after_commit2, class_name, &block)
+      end
+
+      def after_touch1(class_name = nil, &block)
+        define_callbacks(:after_touch1, class_name, &block)
+      end
+
+      def after_touch2(class_name = nil, &block)
+        define_callbacks(:after_touch2, class_name, &block)
+      end
+
+      private
+
+      def define_callbacks(type, class_name, &block)
+        (@type_callbacks[type] ||= ClassCallbacks.new).tap do |s|
+          s.add_callback(class_name, &block) if class_name
+        end
+      end
+    end
+
+    class ClassCallbacks
+      def initialize
+        @class_callbacks = Hash.new{|h, k| h[k] = [] }
+      end
+
+      def callbacks_at(class_name)
+        @class_callbacks[class_name]
+      end
+
+      def add_callback(class_name, &block)
+        callbacks_at(class_name) << block
+      end
+
+      def exec(scope, klass, *args)
+        callbacks_at(klass.name).each{|s| scope.instance_exec(*args, &s) }
+      end
+    end
+  end
+end

data/lib/active_model_cachers/cache_service.rb

@@ -1,151 +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_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_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