active_model_cachers 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7cf82e0fa5854ee62fee1f65d40b847f56776487
-  data.tar.gz: 9be2536f67e4f748ee13ed00655403c3dbfc79cd
+SHA256:
+  metadata.gz: bb3fef2b82bccaa79965f493c0e8daa2e1f943fba503858bc950fb69fc81360a
+  data.tar.gz: 25ea760393d9412968a8473ab2fe876c82d2389d21154b22e9db5a58ffe0cc88
 SHA512:
-  metadata.gz: 0e6e221037b749a572c29784475ab1ec9f97531ac88b3f001c88a4fd04a2177aca0037a1365ff2368a3a4701895cd86b90fe62bf5cd12266e46fa309cd70b754
-  data.tar.gz: 3e522c636f1e1e20af67fff9a20c842f22457ec7a8ba5d2c718a2dfc87616ceba00491412246abbaec66b00c6321b5cfb8bd83ba5755a8a65289f73ee2713a6a
+  metadata.gz: 314aee638ef81c03e9f6188ee5dd5b7ae022befd232e2e4e0d667bee310d2375dd81f679093b76b2e0416600a2cc3c045f035d734ca8b9dbff91dd4e20caebf2
+  data.tar.gz: 85df0799d1e2731e3518ce310a3e10fce24776eba0b6a7802fb76ef389994d9db75cfbc8166211f1bc08c5bce3e1854b905160aef43321e5bd22b467eccf3f51

data/README.md

@@ -1 +1,252 @@
-# active_model_cachers
+# ActiveModelCachers
+
+[![Gem Version](https://img.shields.io/gem/v/active_model_cachers.svg?style=flat)](http://rubygems.org/gems/active_model_cachers)
+[![Build Status](https://travis-ci.org/khiav223577/active_model_cachers.svg?branch=master)](https://travis-ci.org/khiav223577/active_model_cachers)
+[![RubyGems](http://img.shields.io/gem/dt/active_model_cachers.svg?style=flat)](http://rubygems.org/gems/active_model_cachers)
+[![Code Climate](https://codeclimate.com/github/khiav223577/active_model_cachers/badges/gpa.svg)](https://codeclimate.com/github/khiav223577/active_model_cachers)
+[![Test Coverage](https://codeclimate.com/github/khiav223577/active_model_cachers/badges/coverage.svg)](https://codeclimate.com/github/khiav223577/active_model_cachers/coverage)
+
+Provide cachers to the model so that you could specify which you want to cache. Data will be cached at `Rails.cache` and also at application level via `RequestStore` to cache values between requests. Cachers will maintain cached objects and expire them when they are changed (by create, update, destroy, and even delete).
+
+- [Multi-level Cache](#multi-level-cache)
+- Do not pollute original ActiveModel API.
+- Support ActiveRecord 3, 4, 5.
+- High test coverage
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_model_cachers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_model_cachers
+
+### Specify where the cache will be stored
+
+Add the following to your environment files (production.rb, development.rb, test.rb):
+```rb
+ActiveModelCachers.config do |config|
+  config.store = Rails.cache
+end
+```
+
+## Usage
+
+`cache_at(name, query = nil, options = {})`
+
+Specifie a cache on the model.
+ - name: the attribute name.
+ - query: how to get data on cache miss. It will be set automatically if the name match an association or an attribute.
+ - options: see [here](#options)
+
+## Cache whatever you want
+
+### Example 1: Cache the number of active user
+
+After specifying the name as `active_count` and how to get data when cache miss by lambda `User.active.count`.
+You could access the cached data by calling `active_count` method on the cacher, `User.cacher`.
+
+```rb
+class User < ActiveRecord::Base
+  scope :active, ->{ where('last_login_at > ?', 7.days.ago) }
+  cache_at :active_count, ->{ User.active.count }, expire_by: 'User#last_login_at'
+end
+
+@count = User.cacher.active_count
+```
+
+You may want to flush cache on the number of active user changed. It can be done by simply setting [`expire_by`](#expire_by). In this case, `User#last_login_at` means flushing the cache when a user's `last_login_at` is changed (whenever by save, update, create, destroy or delete).
+
+### Example 2: Cache the number of user
+
+In this example, the cache should be cleaned on user `destroyed`, or new user `created`, but not on user `updated`. You could specify the cleaning callback to only fire on certain events by [`on`](#on).
+
+```rb
+class User < ActiveRecord::Base
+  cache_at :count, ->{ User.count }, expire_by: 'User', on: [:create, :destroy]
+end
+
+@count = User.cacher.count
+```
+
+### Example 3: Access the cacher from a model instance
+
+You could use the cacher from instance scope, e.g. `user.cacher`, instead of `User.cacher`. The difference is that the `binding` of query lambda is changed. In this example, you could write the query as `posts.exists?` in that it's in instance scope, and the binding of the lambda is `user`, not `User`. So that it accesses `posts` method of `user`.
+
+```rb
+class User < ActiveRecord::Base
+  has_many :posts
+  cache_at :has_post?, ->{ posts.exists? }, expire_by: :posts
+end
+
+do_something if current_user.cacher.has_post?
+```
+
+In this example, the cache should be cleaned when the `posts` of the user changed. You could just set `expire_by` to the association: `:posts`, and then it will do all the works for you magically. (If you want know more details, it actually set [`expire_by`](#expire_by) to `Post#user_id` and [`foreign_key`](#foreign_key), which is needed for backtracing the user id from post, to `:user_id`)
+
+
+### Example 4: Pass an argument to the query lambda.
+
+You could cache not only the query result of database but also the result of outer service. Becasue `email_valid?` doesn't match an association or an attribute, by default, the cache will not be cleaned by any changes.
+
+```rb
+class User < ActiveRecord::Base
+  cache_at :email_valid?, ->(email){ ValidEmail2::Address.new(email).valid_mx? }
+end
+
+render_error if not User.cacher_at('pearl@example.com').email_valid?
+```
+
+The query lambda can have one parameter, you could pass variable to it by using `cacher_at`. For example, `User.cacher_at(email)`.
+
+```rb
+class User < ActiveRecord::Base
+  cache_at :email_valid?, ->(email){ ValidEmail2::Address.new(email).valid_mx? }, primary_key: :email
+end
+
+render_error if not current_user.cacher.email_valid?
+```
+
+It can also be accessed from instance cacher. But you have to set [`primary_key`](#primary_key), which is needed to know which attribute should be passed to the parameter.
+
+### Example 5: Clean the cache manually
+
+Sometimes it needs to maintain the cache manually. For example, after calling `update_all`, `delete_all` or `import` records without calling callbacks.
+
+```rb
+class User < ActiveRecord::Base
+  has_one :profile
+  cache_at :profile
+end
+
+# clean the cache by name
+current_user.cacher.clean(:profile)
+
+# Or calling the clean_* method
+current_user.cacher.clean_profile
+```
+
+## Smart Caching
+
+### Multi-level Cache
+There is multi-level cache in order to make the speed of data access go faster.
+
+1. RequestStore
+2. Rails.cache
+3. Association Cache
+4. Database
+
+`RequestStore` is used to make sure same object will not loaded from cache twice, since the data transfer between `Cache` and `Application` still consumes time.
+
+`Association Cache` will be used to prevent preloaded objects being loaded again.
+
+For example:
+```rb
+user = User.includes(:posts).take
+user.cacher.posts # => no query will be made even on cache miss.
+```
+
+## Convenient syntax sugar for caching ActiveRecord
+
+### Caching Associations
+```rb
+class User < ActiveRecord::Base
+  has_one :profile
+  cache_at :profile
+end
+
+@profile = current_user.cacher.profile
+
+# directly get profile without loading user.
+@profile = User.cacher_at(profile_id).profile
+```
+
+### Caching Polymorphic Associations
+
+TODO
+
+### Caching Self
+
+Cache self by id.
+```rb
+class User < ActiveRecord::Base
+  cache_self
+end
+
+@user = User.cacher_at(user_id).self
+```
+
+Also support caching self by other columns.
+```rb
+class User < ActiveRecord::Base
+  cache_self, by: :account
+end
+
+@user = User.cacher_at('khiav').self_by_account
+```
+
+### Caching Attributes
+
+```rb
+class Profile < ActiveRecord::Base
+  cache_at :point
+end
+
+@point = Profile.cacher_at(profile_id).point
+```
+
+## Options
+
+### :expire_by
+
+Monitor on the specific model. Clean the cached objects if target are changed.
+
+  - if empty, e.g. `nil` or `''`: Monitoring nothing.
+
+  - if string, e.g. `User`: Monitoring all attributes of `User`.
+
+  - if string with keyword `#`, e.g. `User#last_login_in_at`: Monitoring only the specific attribute.
+
+  - if symbol, e.g. `:posts`: Monitoring on the association. It will trying to do all the things for you, including monitoring all attributes of `Post` and set the `foreign_key`.
+
+  - Default value depends on the `name`. If is an association, monitoring the association klass. If is an attribute, monitoring current klass and the attrribute name. If others, monitoring nothing.
+
+### :on
+
+ Fire changes only by a certain action with the `on` option. Like the same option of [after_commit](https://apidock.com/rails/ActiveRecord/Transactions/ClassMethods/after_commit).
+
+  - if `:create`: Clean the cache only on new record is created, e.g. `Model.create`.
+
+  - if `:update`: Clean the cache only on the record is updated, e.g. `model.update`.
+
+  - if `:destroy`: Clean the cache only on the record id destroyed, e.g. `model.destroy`, `model.delete`.
+
+  - if `array`, e.g. `[:create, :update]`: Clean the cache by any of specified actions.
+
+  - Default value is `[:create, :update, :destroy]`
+
+### :foreign_key
+
+This option is needed only for caching assoication and need not to set if [`expire_by`](#expire_by) is set to monitor association. Used for backtracing the cache key from cached objects. For examle, if `user` has_many `posts`, and cached the `posts` by user.id. When a post is changed, it needs to know which column to use (in this example, `user_id`) to clean the cache at user.
+
+  - Default value is `:id`
+
+  - Will be automatically determined if [`expire_by`](#expire_by) is symbol.
+
+### :primary_key
+
+This option is needed to know which attribute should be passed to the parameter when you are using instance cacher. For example, if a query, named `email_valid?`, uses `user.email` as parameter, and you call it from instance: `user.cacher.email_valid?`. You need to tell it to pass `user.email` instead of `user.id` as the argument.
+
+  - Default value is `:id`
+
+
+

data/active_model_cachers.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["khiav reoy"]
   spec.email         = ["mrtmrt15xn@yahoo.com.tw"]
 
-  spec.summary       = %q{}
-  spec.description   = %q{}
+  spec.summary       = %q{Let you cache whatever you want with ease by providing cachers to active model. Support Rails 3, 4, 5.}
+  spec.description   = %q{Let you cache whatever you want with ease by providing cachers to active model. Cachers will maintain cached objects and expire them when they are changed (by create, update, destroy, and even delete). Support Rails 3, 4, 5.}
   spec.homepage      = "https://github.com/khiav223577/active_model_cachers"
   spec.license       = "MIT"
 

data/lib/active_model_cachers/active_record/attr_model.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+module ActiveModelCachers
+  module ActiveRecord
+    class AttrModel
+      attr_reader :klass, :column, :reflect
+
+      def initialize(klass, column, primary_key: nil)
+        @klass = klass
+        @column = column
+        @primary_key = primary_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 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 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
+
+      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.send(@column) if binding.is_a?(::ActiveRecord::Base)
+        id = @reflect.active_record.where(id: id).limit(1).pluck(foreign_key).first if foreign_key != 'id'
+        if @reflect.collection?
+          return id ? @reflect.klass.where(@reflect.foreign_key => id).to_a : []
+        else
+          return id ? @reflect.klass.find_by(primary_key => id) : nil
+        end
+      end
+    end
+  end
+end

data/lib/active_model_cachers/active_record/cacher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module ActiveModelCachers
+  module ActiveRecord
+    class Cacher
+      @defined_map = {}
+
+      class << self
+        def define_cacher_method(attr, primary_key, service_klasses)
+          method = attr.column || (primary_key == :id ? :self : :"self_by_#{primary_key}")
+          cacher_klass = get_cacher_klass(attr.klass)
+          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)
+        end
+
+        private
+
+        def create_cacher_klass_at(target)
+          cacher_klass = Class.new(self)
+          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_by(attr, primary_key, service_klasses, method)
+        bindings = [@model]
+        if @model and attr.association?
+          if attr.has_one?
+            data = @model.send(attr.column).try(primary_key)
+          else
+            bindings << @model.send(attr.column) if @model.is_a?(::ActiveRecord::Base)
+          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

data/lib/active_model_cachers/active_record/extension.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require 'active_model_cachers/column_value_cache'
+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, primary_key: primary_key)
+        return cache_belongs_to(attr) if attr.belongs_to?
+
+        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])
+
+        with_id = true if expire_by.is_a?(Symbol) or query.parameters.size == 1
+        expire_class, expire_column, foreign_key = get_expire_infos(attr, expire_by, foreign_key)
+        if expire_class
+          define_callback_for_cleaning_cache(expire_class, expire_column, foreign_key, on: on) do |id|
+            service_klass.clean_at(with_id ? id : nil)
+          end
+        end
+        return service_klass
+      end
+
+      def has_cacher?(column = nil)
+        attr = AttrModel.new(self, column)
+        return CacheServiceFactory.has_cacher?(attr)
+      end
+
+      private
+
+      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
+
+      def get_column_value_from_id(id, column, model)
+        return id if column == 'id'
+        model ||= cacher_at(id).peek_self if has_cacher?
+        return model.send(column) if model
+        return where(id: id).limit(1).pluck(column).first
+      end
+
+      @@column_value_cache = ActiveModelCachers::ColumnValueCache.new
+      def define_callback_for_cleaning_cache(class_name, column, foreign_key, on: nil, &clean)
+        ActiveSupport::Dependencies.onload(class_name) do
+          clean_ids = []
+
+          prepend_before_delete do |id, model|
+            clean_ids << @@column_value_cache.add(self, class_name, id, foreign_key, model)
+          end
+
+          before_delete do |_, model|
+            clean_ids.each{|s| clean.call(s.call) }
+            clean_ids = []
+          end
+
+          after_delete do
+            @@column_value_cache.clean_cache()
+          end
+
+          on_nullify(column){|ids| ids.each{|s| clean.call(s) }}
+
+          after_commit ->{
+            changed = column ? previous_changes.key?(column) : previous_changes.present?
+            clean.call(send(foreign_key)) if changed || destroyed?
+          }, on: on
+        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

data/lib/active_model_cachers/active_record/patch_rails_3.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module ActiveModelCachers
+  module ActiveRecord
+    module Extension
+      # define #find_by for Rails 3
+      def find_by(*args)
+        where(*args).order('').first
+      end
+
+      # after_commit in Rails 3 cannot specify multiple :on
+      # EX:
+      #   after_commit ->{ ... }, on: [:create, :destroy]
+      #
+      # Should rewrite it as:
+      #   after_commit ->{ ... }, on: :create
+      #   after_commit ->{ ... }, on: :destroy
+
+      def after_commit(*args, &block) # mass-assign protected attributes `id` In Rails 3
+        if args.last.is_a?(Hash)
+          if (on = args.last[:on]).is_a?(Array)
+            return on.each{|s| after_commit(*[*args[0...-1], { **args[-1], on: s }], &block) }
+          end
+        end
+        super
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    class Association #:nodoc:
+      alias_method :scope, :scoped
+    end
+  end
+end
+
+class ActiveModelCachers::ColumnValueCache
+  def pluck_columns(object, relation, columns)
+    object.connection.select_all(relation.select(columns)).map(&:values)
+  end
+end

data/lib/active_model_cachers/cache_service.rb

@@ -1,30 +1,79 @@
+# frozen_string_literal: true
+require 'active_model_cachers/nil_object'
+require 'active_model_cachers/false_object'
+
 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
+    end
+
+    # ----------------------------------------------------------------
+    # ● instance methods
+    # ----------------------------------------------------------------
     def initialize(id)
       @id = id
     end
 
-    def get
+    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
+    def clean_cache(binding: nil)
       @cached_data = nil
       Rails.cache.delete(cache_key)
+      return nil
     end
 
     private
 
     def cache_key
-      fail 'not implement'
+      key = self.class.cache_key
+      return @id ? "#{key}_#{@id}" : key
     end
 
-    def get_without_cache
-      fail 'not implement'
+    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
+      return 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.fetch(cache_key, expires_in: 30.minutes){ get_without_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
   end
 end

data/lib/active_model_cachers/cache_service_factory.rb

@@ -1,26 +1,38 @@
+# frozen_string_literal: true
 require 'request_store'
 require 'active_model_cachers/cache_service'
 
 module ActiveModelCachers
   class CacheServiceFactory
+    @key_class_mapping = {}
+
     class << self
-      def create(reflect, cache_key, &query)
-        klass = Class.new(CacheService)
+      def has_cacher?(attr)
+        return (@key_class_mapping[get_cache_key(attr)] != nil)
+      end
 
-        class << klass
-          def instance(id)
-            hash = (RequestStore.store[self] ||= {})
-            return hash[id] ||= new(id)
-          end
+      def create_for_active_model(attr, query)
+        cache_key = get_cache_key(attr)
+        service_klass = create(cache_key, query)
+        return service_klass
+      end
+
+      def create(cache_key, query)
+        @key_class_mapping[cache_key] ||= ->{
+          klass = Class.new(CacheService)
+          klass.cache_key = cache_key
+          klass.query = query
+          next klass
+        }[]
+      end
 
-          def [](id)
-            instance(id)
-          end
-        end
+      private
 
-        klass.send(:define_method, :cache_key){ "#{cache_key}_#{@id}" }
-        klass.send(:define_method, :get_without_cache){ query.call(@id) }
-        return klass
+      def get_cache_key(attr)
+        class_name, column = (attr.single_association? ? [attr.class_name, nil] : [attr.klass, attr.column])
+        return "active_model_cachers_#{class_name}_at_#{column}" if column
+        return "active_model_cachers_#{class_name}_by_#{attr.primary_key}" if attr.primary_key and attr.primary_key.to_s != 'id'
+        return "active_model_cachers_#{class_name}"
       end
     end
   end

data/lib/active_model_cachers/column_value_cache.rb

@@ -0,0 +1,45 @@
+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_at(id).peek_self if object.has_cacher?
+    return model.send(column) if model
+    return :not_set
+  end
+end

data/lib/active_model_cachers/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveModelCachers
   class Config
     attr_accessor :store

data/lib/active_model_cachers/false_object.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module ActiveModelCachers
+  class FalseObject
+  end
+end

data/lib/active_model_cachers/hook/associations.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'active_record'
+require 'active_record/associations/has_many_association'
+require 'active_model_cachers/hook/on_model_delete'
+
+module ActiveModelCachers::Hook
+  module Associations
+    def delete_count(method, scope)
+      if method == :delete_all
+        # TODO:
+      else # nullify
+        call_hooks{ scope.pluck(:id) }
+      end
+      super
+    end
+
+    def delete_records(records, method)
+      case method
+      when :destroy
+      when :delete_all
+        # TODO:
+      else
+        call_hooks{ records.map(&:id) }
+      end
+      super
+    end
+
+    private
+
+    def call_hooks
+      return if (hooks = reflection.klass.nullify_hooks_at(reflection.foreign_key)).blank?
+      ids = yield
+      hooks.each{|s| s.call(ids) }
+    end
+  end
+end
+
+ActiveRecord::Associations::HasManyAssociation.send(:prepend, ActiveModelCachers::Hook::Associations)

data/lib/active_model_cachers/hook/dependencies.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'active_support/dependencies'
+
+module ActiveModelCachers::Hook
+  module Depdenencies
+    def onload(const_name, &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)
+      end
+    end
+
+    def load_hooks
+      @load_hooks ||= Hash.new{|h, k| h[k] = [] }
+    end
+
+    def new_constants_in(*)
+      new_constants = super.each{|s| load_hooks[s].each{|hook| s.constantize.instance_exec(&hook) } }
+      return new_constants
+    end
+  end
+end
+
+ActiveSupport::Dependencies.send(:extend, ActiveModelCachers::Hook::Depdenencies)

data/lib/active_model_cachers/hook/on_model_delete.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require 'active_record'
+
+module ActiveModelCachers::Hook
+  module OnModelDelete
+    module InstanceMethods
+      def delete
+        self.class.delete(id, self) if persisted?
+        @destroyed = true
+        freeze
+      end
+    end
+
+    module ClassMethods
+      def prepend_before_delete(&callback)
+        before_delete_hooks.unshift(callback)
+      end
+
+      def before_delete(&callback)
+        before_delete_hooks << callback
+      end
+
+      def after_delete(&callback)
+        after_delete_hooks << callback
+      end
+
+      def before_delete_hooks
+        @before_delete_hooks ||= []
+      end
+
+      def after_delete_hooks
+        @after_delete_hooks ||= []
+      end
+
+      def delete(id, model = nil)
+        before_delete_hooks.each{|s| s.call(id, model) }
+        result = super(id)
+        after_delete_hooks.each{|s| s.call(id, model) }
+        return result
+      end
+
+      def nullify_hooks_at(column)
+        @nullify_hooks ||= Hash.new{|h, k| h[k] = [] }
+        return @nullify_hooks[column]
+      end
+
+      def on_nullify(column, &callback)
+        nullify_hooks_at(column) << callback
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActiveModelCachers::Hook::OnModelDelete::InstanceMethods)
+ActiveRecord::Base.send(:extend, ActiveModelCachers::Hook::OnModelDelete::ClassMethods)

data/lib/active_model_cachers/nil_object.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module ActiveModelCachers
+  class NilObject
+  end
+end

data/lib/active_model_cachers/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveModelCachers
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/lib/active_model_cachers.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 require 'active_model_cachers/version'
 require 'active_model_cachers/config'
 require 'active_model_cachers/cache_service_factory'
 require 'active_record'
 require 'active_record/relation'
+require 'active_model_cachers/active_record/extension'
 
 module ActiveModelCachers
   def self.config
@@ -12,26 +14,4 @@ module ActiveModelCachers
   end
 end
 
-class << ActiveRecord::Base
-  def cache_at(column, query = nil)
-    reflect = reflect_on_association(column)
-    if reflect
-      query ||= ->(id){ (reflect.belongs_to? ? reflect.active_record : reflect.klass).find_by(id: id) }
-    else
-      query ||= ->(id){ where(id: id).limit(1).pluck(column).first }
-    end
-
-    service_klass = ActiveModelCachers::CacheServiceFactory.create(reflect, "cacher_key_of_#{self}_at_#{column}", &query)
-    after_commit ->{ service_klass.instance(id).clean_cache if previous_changes.key?(column) || destroyed? }
-
-    define_singleton_method(:"#{column}_cachers") do
-      service_klass
-    end
-  end
-
-  if not method_defined?(:find_by) # define #find_by for Rails 3
-    def find_by(*args)
-      where(*args).order('').first
-    end
-  end
-end
+ActiveRecord::Base.send(:extend, ActiveModelCachers::ActiveRecord::Extension)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_cachers
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - khiav reoy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-28 00:00:00.000000000 Z
+date: 2018-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,7 +94,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3'
-description: ''
+description: Let you cache whatever you want with ease by providing cachers to active
+  model. Cachers will maintain cached objects and expire them when they are changed
+  (by create, update, destroy, and even delete). Support Rails 3, 4, 5.
 email:
 - mrtmrt15xn@yahoo.com.tw
 executables: []
@@ -115,9 +117,19 @@ files:
 - gemfiles/5.0.gemfile
 - gemfiles/5.1.gemfile
 - lib/active_model_cachers.rb
+- lib/active_model_cachers/active_record/attr_model.rb
+- lib/active_model_cachers/active_record/cacher.rb
+- lib/active_model_cachers/active_record/extension.rb
+- lib/active_model_cachers/active_record/patch_rails_3.rb
 - lib/active_model_cachers/cache_service.rb
 - lib/active_model_cachers/cache_service_factory.rb
+- lib/active_model_cachers/column_value_cache.rb
 - lib/active_model_cachers/config.rb
+- lib/active_model_cachers/false_object.rb
+- lib/active_model_cachers/hook/associations.rb
+- lib/active_model_cachers/hook/dependencies.rb
+- lib/active_model_cachers/hook/on_model_delete.rb
+- lib/active_model_cachers/nil_object.rb
 - lib/active_model_cachers/version.rb
 homepage: https://github.com/khiav223577/active_model_cachers
 licenses:
@@ -139,8 +151,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: ''
+summary: Let you cache whatever you want with ease by providing cachers to active
+  model. Support Rails 3, 4, 5.
 test_files: []