active_model_cachers 2.1.6 → 2.1.7

data/gemfiles/5.0.gemfile

@@ -1,11 +1,11 @@
-source 'https://rubygems.org'
-
-gem "activerecord", "~> 5.0.0"
-gem "request_store", "~> 1.4.0"
-
-group :test do
-  gem "simplecov"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 5.0.0'
+gem 'request_store', '~> 1.4.0'
+
+group :test do
+  gem 'simplecov'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/5.1.gemfile

@@ -1,11 +1,11 @@
-source 'https://rubygems.org'
-
-gem "activerecord", "~> 5.1.0"
-gem "request_store", "~> 1.4.0"
-
-group :test do
-  gem "simplecov"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 5.1.0'
+gem 'request_store', '~> 1.4.0'
+
+group :test do
+  gem 'simplecov'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/5.2.gemfile

@@ -1,11 +1,11 @@
-source 'https://rubygems.org'
-
-gem "activerecord", "~> 5.2.0"
-gem "request_store", "~> 1.4.0"
-
-group :test do
-  gem "simplecov"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 5.2.0'
+gem 'request_store', '~> 1.4.0'
+
+group :test do
+  gem 'simplecov'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/6.0.gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 6.0.0'
+gem 'request_store', '~> 1.4.1'
+
+group :test do
+  gem 'simplecov'
+  gem 'sqlite3', '~> 1.4.1'
+end
+
+gemspec path: '../'

data/lib/active_model_cachers/active_record/attr_model.rb

@@ -1,124 +1,124 @@
-# frozen_string_literal: true
-module ActiveModelCachers
-  module ActiveRecord
-    class AttrModel
-      attr_reader :klass, :column, :reflect
-
-      def initialize(klass, column, primary_key: nil, foreign_key: nil)
-        @klass = klass
-        @column = column
-        @primary_key = primary_key
-        @foreign_key = foreign_key
-        @reflect = klass.reflect_on_association(column)
-      end
-
-      def association?
-        return (@reflect != nil)
-      end
-
-      def class_name
-        return if not association?
-        return @reflect.class_name
-      end
-
-      def join_table
-        return nil if @reflect == nil
-        options = @reflect.options
-        return options[:through] if options[:through]
-        return (options[:join_table] || @reflect.send(:derive_join_table)) if @reflect.macro == :has_and_belongs_to_many
-        return nil
-      end
-
-      def join_table_class_name
-        join_table.try{|table_name| @klass.reflect_on_association(table_name).try(:class_name)  || through_klass.name }
-      end
-
-      def through_reflection
-        @klass.new.association(@column).reflection.through_reflection
-      end
-
-      def through_klass
-        through_reflection.try(:klass) || through_klass_for_rails_3
-      end
-
-      def belongs_to?
-        return false if not association?
-        return @reflect.belongs_to?
-      end
-
-      def has_one?
-        return false if not association?
-        #return @reflect.has_one? # Rails 3 doesn't have this method
-        return false if @reflect.collection?
-        return false if @reflect.belongs_to?
-        return true
-      end
-
-      def primary_key
-        return @primary_key if @primary_key
-        return if not association?
-        return (@reflect.belongs_to? ? @reflect.klass : @reflect.active_record).primary_key
-      end
-
-      def foreign_key(reverse: false)
-        return @foreign_key if @foreign_key
-        return if not association?
-        # key may be symbol if specify foreign_key in association options
-        return @reflect.chain.last.foreign_key.to_s if reverse and join_table
-        return (@reflect.belongs_to? == reverse ? primary_key : @reflect.foreign_key).to_s
-      end
-
-      def single_association?
-        return false if not association?
-        return !collection?
-      end
-
-      def collection?
-        return false if not association?
-        return @reflect.collection?
-      end
-
-      def query_model(binding, id)
-        return query_self(binding, id) if @column == nil
-        return query_association(binding, id) if association?
-        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)
-        return binding if binding.is_a?(::ActiveRecord::Base)
-        return @klass.find_by(primary_key => id)
-      end
-
-      def query_attribute(binding, id)
-        return binding.send(@column) if binding.is_a?(::ActiveRecord::Base) and binding.has_attribute?(@column)
-        return @klass.where(id: id).limit(1).pluck(@column).first
-      end
-
-      def query_association(binding, id)
-        return binding.association(@column).load_target if binding.is_a?(::ActiveRecord::Base)
-        id = @reflect.active_record.where(id: id).limit(1).pluck(foreign_key).first if foreign_key != 'id'
-        case
-        when collection? ; return id ? @reflect.klass.where(@reflect.foreign_key => id).to_a : []
-        when has_one?    ; return id ? @reflect.klass.find_by(foreign_key(reverse: true) => id) : nil
-        else             ; return id ? @reflect.klass.find_by(primary_key => id) : nil
-        end
-      end
-
-      def through_klass_for_rails_3
-        const_name = "HABTM_#{@reflect.klass.name.pluralize}"
-        @klass.const_defined?(const_name) ? @klass.const_get(const_name) : @klass.const_set(const_name, create_through_klass_for_rails_3)
-      end
-
-      def create_through_klass_for_rails_3
-        Class.new(::ActiveRecord::Base).tap{|s| s.table_name = join_table }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module ActiveModelCachers
+  module ActiveRecord
+    class AttrModel
+      attr_reader :klass, :column, :reflect
+
+      def initialize(klass, column, primary_key: nil, foreign_key: nil)
+        @klass = klass
+        @column = column
+        @primary_key = primary_key
+        @foreign_key = foreign_key
+        @reflect = klass.reflect_on_association(column)
+      end
+
+      def association?
+        return (@reflect != nil)
+      end
+
+      def class_name
+        return if not association?
+        return @reflect.class_name
+      end
+
+      def join_table
+        return nil if @reflect == nil
+        options = @reflect.options
+        return options[:through] if options[:through]
+        return (options[:join_table] || @reflect.send(:derive_join_table)) if @reflect.macro == :has_and_belongs_to_many
+        return nil
+      end
+
+      def join_table_class_name
+        join_table.try{|table_name| @klass.reflect_on_association(table_name).try(:class_name)  || through_klass.name }
+      end
+
+      def through_reflection
+        @klass.new.association(@column).reflection.through_reflection
+      end
+
+      def through_klass
+        through_reflection.try(:klass) || through_klass_for_rails_3
+      end
+
+      def belongs_to?
+        return false if not association?
+        return @reflect.belongs_to?
+      end
+
+      def has_one?
+        return false if not association?
+        #return @reflect.has_one? # Rails 3 doesn't have this method
+        return false if @reflect.collection?
+        return false if @reflect.belongs_to?
+        return true
+      end
+
+      def primary_key
+        return @primary_key if @primary_key
+        return if not association?
+        return (@reflect.belongs_to? ? @reflect.klass : @reflect.active_record).primary_key
+      end
+
+      def foreign_key(reverse: false)
+        return @foreign_key if @foreign_key
+        return if not association?
+        # key may be symbol if specify foreign_key in association options
+        return @reflect.chain.last.foreign_key.to_s if reverse and join_table
+        return (@reflect.belongs_to? == reverse ? primary_key : @reflect.foreign_key).to_s
+      end
+
+      def single_association?
+        return false if not association?
+        return !collection?
+      end
+
+      def collection?
+        return false if not association?
+        return @reflect.collection?
+      end
+
+      def query_model(binding, id)
+        return query_self(binding, id) if @column == nil
+        return query_association(binding, id) if association?
+        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)
+        return binding if binding.is_a?(::ActiveRecord::Base)
+        return @klass.find_by(primary_key => id)
+      end
+
+      def query_attribute(binding, id)
+        return binding.send(@column) if binding.is_a?(::ActiveRecord::Base) and binding.has_attribute?(@column)
+        return @klass.where(id: id).limit(1).pluck(@column).first
+      end
+
+      def query_association(binding, id)
+        return binding.association(@column).load_target if binding.is_a?(::ActiveRecord::Base)
+        id = @reflect.active_record.where(id: id).limit(1).pluck(foreign_key).first if foreign_key != 'id'
+        case
+        when collection? ; return id ? @reflect.klass.where(@reflect.foreign_key => id).to_a : []
+        when has_one?    ; return id ? @reflect.klass.find_by(foreign_key(reverse: true) => id) : nil
+        else             ; return id ? @reflect.klass.find_by(primary_key => id) : nil
+        end
+      end
+
+      def through_klass_for_rails_3
+        const_name = "HABTM_#{@reflect.klass.name.pluralize}"
+        @klass.const_defined?(const_name) ? @klass.const_get(const_name) : @klass.const_set(const_name, create_through_klass_for_rails_3)
+      end
+
+      def create_through_klass_for_rails_3
+        Class.new(::ActiveRecord::Base).tap{|s| s.table_name = join_table }
+      end
+    end
+  end
+end

data/lib/active_model_cachers/active_record/cacher.rb

@@ -1,97 +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]
-        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
+# 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