active_model_cachers 2.1.3 → 2.1.8

data/lib/active_model_cachers/active_record/cacher.rb

@@ -1,96 +1,97 @@
-# frozen_string_literal: true
-module ActiveModelCachers
-  module ActiveRecord
-    class Cacher
-      @defined_map = {}
-
-      class << self
-        def get_cacher_klass(klass)
-          @defined_map[klass] ||= create_cacher_klass_at(klass)
-        end
-
-        def define_cacher_method(attr, primary_key, service_klasses)
-          cacher_klass = get_cacher_klass(attr.klass)
-          method = attr.column
-          return cacher_klass.define_find_by(attr, primary_key, service_klasses) if method == nil
-          cacher_klass.send(:define_methods, method, {
-            method            => ->{ exec_by(attr, primary_key, service_klasses, :get) },
-            "peek_#{method}"  => ->{ exec_by(attr, primary_key, service_klasses, :peek) },
-            "clean_#{method}" => ->{ exec_by(attr, primary_key, service_klasses, :clean_cache) },
-          })
-        end
-
-        def define_find_by(attr, primary_key, service_klasses)
-          if @find_by_mapping == nil
-            @find_by_mapping = {}
-            define_methods(:find_by, {
-              :find_by   => ->(args){ exec_find_by(args, :get) },
-              :peek_by   => ->(args){ exec_find_by(args, :peek) },
-              :clean_by  => ->(args){ exec_find_by(args, :clean_cache) },
-            })
-          end
-          @find_by_mapping[primary_key] = [attr, service_klasses]
-        end
-
-        private
-
-        def define_methods(attribute, methods_mapping)
-          if attributes.include?(attribute)
-            methods_mapping.keys.each{|s| undef_method(s) }
-          else
-            attributes << attribute
-          end
-          methods_mapping.each{|method, block| define_method(method, &block) }
-        end
-
-        def get_data_from_find_by_mapping(primary_key)
-          return if @find_by_mapping == nil
-          return @find_by_mapping[primary_key]
-        end
-
-        def create_cacher_klass_at(target)
-          cacher_klass = Class.new(self)
-          cacher_klass.instance_variable_set(:@find_by_mapping, nil) # to remove warning: instance variable @find_by_mapping not initialized
-          cacher_klass.define_singleton_method(:attributes){ @attributes ||= [] }
-          cacher_klass.send(:define_method, 'peek'){|column| send("peek_#{column}") }
-          cacher_klass.send(:define_method, 'clean'){|column| send("clean_#{column}") }
-
-          target.define_singleton_method(:cacher_at){|id| cacher_klass.new(id: id) }
-          target.define_singleton_method(:cacher){ cacher_klass.new }
-          target.send(:define_method, :cacher){ cacher_klass.new(model: self) }
-          return cacher_klass
-        end
-      end
-
-      def initialize(id: nil, model: nil)
-        @id = id
-        @model = model
-      end
-
-      private
-
-      def exec_find_by(args, method) # e.g. args = {course_id: xx}
-        primary_key = args.keys.sort.first # Support only one key now.
-        attr, service_klasses = self.class.send(:get_data_from_find_by_mapping, primary_key)
-        return if service_klasses == nil
-        return exec_by(attr, primary_key, service_klasses, method, data: args[primary_key])
-      end
-
-      def exec_by(attr, primary_key, service_klasses, method, data: nil)
-        bindings = [@model]
-        if @model and attr.association?
-          if attr.belongs_to? and method != :clean_cache # no need to load binding when just cleaning cache
-            association = @model.association(attr.column)
-            bindings << association.load_target if association.loaded?
-          end
-        end
-        data ||= (@model ? @model.send(primary_key) : nil) || @id
-        service_klasses.each_with_index do |service_klass, index|
-          data = service_klass.instance(data).send(method, binding: bindings[index])
-          return if data == nil
-        end
-        return data
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module ActiveModelCachers
+  module ActiveRecord
+    class Cacher
+      @defined_map = {}
+
+      class << self
+        def get_cacher_klass(klass)
+          @defined_map[klass] ||= create_cacher_klass_at(klass)
+        end
+
+        def define_cacher_method(attr, primary_key, service_klasses)
+          cacher_klass = get_cacher_klass(attr.klass)
+          method = attr.column
+          return cacher_klass.define_find_by(attr, primary_key, service_klasses) if method == nil
+          cacher_klass.send(:define_methods, method, {
+            method            => ->{ exec_by(attr, primary_key, service_klasses, :get) },
+            "peek_#{method}"  => ->{ exec_by(attr, primary_key, service_klasses, :peek) },
+            "clean_#{method}" => ->{ exec_by(attr, primary_key, service_klasses, :clean_cache) },
+          })
+        end
+
+        def define_find_by(attr, primary_key, service_klasses)
+          if @find_by_mapping == nil
+            @find_by_mapping = {}
+            define_methods(:find_by, {
+              :find_by   => ->(args){ exec_find_by(args, :get) },
+              :peek_by   => ->(args){ exec_find_by(args, :peek) },
+              :clean_by  => ->(args){ exec_find_by(args, :clean_cache) },
+            })
+          end
+          @find_by_mapping[primary_key] = [attr, service_klasses]
+        end
+
+        private
+
+        def define_methods(attribute, methods_mapping)
+          if attributes.include?(attribute)
+            methods_mapping.keys.each{|s| undef_method(s) }
+          else
+            attributes << attribute
+          end
+          methods_mapping.each{|method, block| define_method(method, &block) }
+        end
+
+        def get_data_from_find_by_mapping(primary_key)
+          return if @find_by_mapping == nil
+          return @find_by_mapping[primary_key]
+        end
+
+        def create_cacher_klass_at(target)
+          cacher_klass = Class.new(self)
+          cacher_klass.instance_variable_set(:@find_by_mapping, nil) # to remove warning: instance variable @find_by_mapping not initialized
+          cacher_klass.define_singleton_method(:attributes){ @attributes ||= [] }
+          cacher_klass.send(:define_method, 'peek'){|column| send("peek_#{column}") }
+          cacher_klass.send(:define_method, 'clean'){|column| send("clean_#{column}") }
+
+          target.define_singleton_method(:cacher_at){|id| cacher_klass.new(id: id) }
+          target.define_singleton_method(:cacher){ cacher_klass.new }
+          target.send(:define_method, :cacher){ cacher_klass.new(model: self) }
+          return cacher_klass
+        end
+      end
+
+      def initialize(id: nil, model: nil)
+        @id = id
+        @model = model
+      end
+
+      private
+
+      def exec_find_by(args, method) # e.g. args = {course_id: xx}
+        primary_key = args.keys.sort.first # Support only one key now.
+        attr, service_klasses = self.class.send(:get_data_from_find_by_mapping, primary_key)
+        return if service_klasses == nil
+        return exec_by(attr, primary_key, service_klasses, method, data: args[primary_key])
+      end
+
+      def exec_by(attr, primary_key, service_klasses, method, data: nil)
+        bindings = [@model]
+        reflects = (attr.belongs_to? ? [] : [attr.reflect])
+        if @model and attr.association?
+          if attr.belongs_to? and method != :clean_cache # no need to load binding when just cleaning cache
+            association = @model.association(attr.column)
+            bindings << association.load_target if association.loaded?
+          end
+        end
+        data ||= (@model ? @model.send(primary_key) : nil) || @id
+        service_klasses.each_with_index do |service_klass, index|
+          data = service_klass.instance(data).send(method, binding: bindings[index], reflect: reflects[index])
+          return if data == nil
+        end
+        return data
+      end
+    end
+  end
+end

data/lib/active_model_cachers/active_record/extension.rb

@@ -1,106 +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)
-          expire_by = get_expire_by_from(expire_attr)
-        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
-
-      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 = GlobalCallbacks.new
-      def self.global_callbacks
-        @global_callbacks
-      end
-
-      def self.extended(base)
-        global_callbacks = @global_callbacks
-        base.instance_exec do
-          after_commit ->{ global_callbacks.after_commit.exec(self, self.class) }
-          after_touch ->{ global_callbacks.after_touch.exec(self, self.class) }
-        end
-      end
-    end
-  end
-end
-
-if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new('4')
-  require 'active_model_cachers/active_record/patch_rails_3'
-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,59 +1,67 @@
-module ActiveModelCachers
-  module ActiveRecord
-    class GlobalCallbacks
-      def initialize
-        @type_callbacks = {}
-      end
-
-      def pre_before_delete(class_name = nil, &block)
-        define_callbacks(:pre_before_delete, class_name, &block)
-      end
-
-      def before_delete(class_name = nil, &block)
-        define_callbacks(:before_delete, 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_commit(class_name = nil, &block)
-        define_callbacks(:after_commit, class_name, &block)
-      end
-
-      def after_touch(class_name = nil, &block)
-        define_callbacks(:after_touch, 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