active_model_cachers 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21afadb49c4f398b05f590e42e2d68dc972c4156601327aba48b218b5bfce70f
-  data.tar.gz: c25d240a1b3c891ee31a191f72d8540e282724cc0638e79c3089cc17ada31dfc
+  metadata.gz: 26cbc738077c571fd681dba6f83be1faf69672e52f6d21ef242ff1bec6d7b8d1
+  data.tar.gz: efa2374d6689b0c2fc1c2738293053ecfcc67720840f53ec7ef789c6a84543b3
 SHA512:
-  metadata.gz: 75634a849304a07c250dae3d82d9ff9eb579873b976482de1987e01b28f5cf95878edf53e3b83bc5eb794e7e1f31bf537018299a4d93bf4ba083dc74b4063403
-  data.tar.gz: 1b05f797d94393b3d95a3b172a3276808f5bd6f3088d168698e2aa4ce55588aa6c1d58a62afbd29ab45ad9bb2c12d08c472aae0f718f549a5470d2a8e7af9256
+  metadata.gz: 179179ebf0b2b926963bdfc64392b65c952c5246cfdf4475196bfb9f5af6d2e8996f2c686bc33d031b3ef579c3736a68055e558363df991bb9708275f129f187
+  data.tar.gz: 21bac3df913b18a496c926816d2553c6fb84248d912b6a7861e41f03a37a82059ae86e14264f3f67fbc6bb23894e8bfd3514021d3b14d4d1d1af03c28907eafd

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## Change Log
 
+### [v2.1.1](https://github.com/khiav223577/active_model_cachers/compare/v2.1.0...v2.1.1) 2018/05/25
+- [#35](https://github.com/khiav223577/active_model_cachers/pull/35) Preventing registering same callbacks in some cases (@khiav223577)
+- [#34](https://github.com/khiav223577/active_model_cachers/pull/34) Enhance - automatically clean cache when `#touch` (@ff2248)
+- [#33](https://github.com/khiav223577/active_model_cachers/pull/33) [Enhance] Code Climate Gem Deprecation (@berniechiu)
+
 ### [v2.1.0](https://github.com/khiav223577/active_model_cachers/compare/v2.0.3...v2.1.0) 2018/05/18
 - [#32](https://github.com/khiav223577/active_model_cachers/pull/32) Add test cases to test "store all data in hash" (@khiav223577)
 - [#31](https://github.com/khiav223577/active_model_cachers/pull/31) Change the syntax of getting self from cache (@khiav223577)

data/lib/active_model_cachers/active_record/attr_model.rb

@@ -72,6 +72,11 @@ module ActiveModelCachers
         return query_attribute(binding, id)
       end
 
+      def extract_class_and_column
+        return [class_name, nil] if single_association?
+        return [@klass.to_s, @column]
+      end
+
       private
 
       def query_self(binding, id)

data/lib/active_model_cachers/active_record/cacher.rb

@@ -5,38 +5,49 @@ module ActiveModelCachers
       @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.attributes << method
-          cacher_klass.send(:define_method, method){ exec_by(attr, primary_key, service_klasses, :get) }
-          cacher_klass.send(:define_method, "peek_#{method}"){ exec_by(attr, primary_key, service_klasses, :peek) }
-          cacher_klass.send(:define_method, "clean_#{method}"){ exec_by(attr, primary_key, service_klasses, :clean_cache) }
-        end
-
-        def get_cacher_klass(klass)
-          @defined_map[klass] ||= create_cacher_klass_at(klass)
+          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 = {}
-            attributes << :find_by
-            define_method(:find_by){|args| exec_find_by(args, :get) }
-            define_method(:peek_by){|args| exec_find_by(args, :peek) }
-            define_method(:clean_by){|args| exec_find_by(args, :clean_cache) }
+            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
 
-        private
-
         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
@@ -60,7 +71,7 @@ module ActiveModelCachers
 
       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.get_data_from_find_by_mapping(primary_key)
+        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

data/lib/active_model_cachers/active_record/extension.rb

@@ -16,13 +16,21 @@ module ActiveModelCachers
         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 (infos = get_expire_infos(attr, expire_by, foreign_key))
+        if class_name
           with_id = (expire_by.is_a?(Symbol) || query.parameters.size == 1)
-          service_klass.define_callback_for_cleaning_cache(*infos, with_id, on: on)
+          service_klass.define_callback_for_cleaning_cache(class_name, *infos, with_id, on: on)
         end
 
         return service_klass
@@ -35,6 +43,12 @@ module ActiveModelCachers
 
       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)

data/lib/active_model_cachers/cache_service_factory.rb

@@ -5,6 +5,7 @@ require 'active_model_cachers/cache_service'
 module ActiveModelCachers
   class CacheServiceFactory
     @key_class_mapping = {}
+    @cache_key_klass_mapping = {}
 
     class << self
       def has_cacher?(attr)
@@ -12,9 +13,7 @@ module ActiveModelCachers
       end
 
       def create_for_active_model(attr, query)
-        cache_key = get_cache_key(attr)
-        service_klass = create(cache_key, query)
-        return service_klass
+        create(get_cache_key(attr), query)
       end
 
       def create(cache_key, query)
@@ -27,15 +26,30 @@ module ActiveModelCachers
         }[]
       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.single_association? ? [attr.class_name, nil] : [attr.klass, attr.column])
+        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/hook/dependencies.rb

@@ -3,12 +3,12 @@ require 'active_support/dependencies'
 
 module ActiveModelCachers::Hook
   module Depdenencies
-    def onload(const_name, &block)
+    def onload(const_name, times: 1, &block)
       const = const_name if not const_name.is_a?(String)
       if const or Module.const_defined?(const_name)
         (const || const_name.constantize).instance_exec(&block)
       else
-        load_hooks[const_name].push(block)
+        load_hooks[const_name].push(block: block, times: times)
       end
     end
 
@@ -17,7 +17,19 @@ module ActiveModelCachers::Hook
     end
 
     def new_constants_in(*)
-      new_constants = super.each{|s| load_hooks[s].each{|hook| s.constantize.instance_exec(&hook) } }
+      new_constants = super.each do |const_name|
+        hooks = load_hooks[const_name]
+        need_compact = false
+        hooks.each_with_index do |hook, idx|
+          if (hook[:times] -= 1) < 0
+            hooks[idx] = nil
+            need_compact = true
+            next
+          end
+          const_name.constantize.instance_exec(&hook[:block])
+        end
+        hooks.compact! if need_compact
+      end
       return new_constants
     end
   end

data/lib/active_model_cachers/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ActiveModelCachers
-  VERSION = '2.1.1'
+  VERSION = '2.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_cachers
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - khiav reoy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-25 00:00:00.000000000 Z
+date: 2018-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler