active_model_cachers 2.0.3 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c49c9bc175d4ab55f5507cc4a6c4db006a099c90819e71788ced4b799d510f9
-  data.tar.gz: bb19f0043d46963c75b4ef71d30945c35156acb778b19d3f72e874b6c6dbdd15
+  metadata.gz: 7e51a19a8c47a1ea8bbdede0389a5768463081518ae322dba25155e1ce99eda9
+  data.tar.gz: 43c82003bf164a54f45ac022db12842e22da7eac45022e2f61a6a66779c243b3
 SHA512:
-  metadata.gz: 478355a8ee8fed5b1a25fcb6c2ef258888f6507c8e6bc74e98b9c559470b9475b750e69c7e03a7f77b05324cfc7927076e3c6173e08d0dbe4e4247283ab87011
-  data.tar.gz: c2029fb1379a12f03669b9a7dfa09858ab96a3cba755074ed1483e5a5239a890cd1c33dc9bfaf2973e7b76f5d1f42b166bb9a51b27e4c958d727d137d27437e4
+  metadata.gz: 6e79837432ad52125b04f80761068dc366764e6ea944729f45bc2e2231629991645c6798369964f2adf27646c315e24190e31189cb349d3cad7fbb48813e3fbc
+  data.tar.gz: 2788c31af2ded6965ab755a72d8e0160421e7c4057d6c221d7b39485cc768a53ae1192ab4329e503b576de205e07ac4be6c546d628da993e54bbcf341a1adade

data/README.md

@@ -40,14 +40,31 @@ end
 
 ## Usage
 
+### Cache whatever you want by `cache_at` method
+
 `cache_at(name, query = nil, options = {})`
 
-Specifie a cache on the model.
+Specify 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
+### Asscess the cached attributes
+
+The `cacher` is defined as `class method` and `instance method` of Model. You could call the method and get the cacher instance, e.g. `User.cacher` or `user.cacher`. An attribute will define a method on cacher, cached attributes are asscessable via it, e.g. `user.cacher.the_attribute_name`.
+
+
+### Basic Example
+```rb
+class User < ActiveRecord::Base
+  cache_at :something_you_want_to_cache, ->{ get_the_data_on_cache_miss }
+end
+
+user.cacher.something_you_want_to_cache
+```
+
+
+## Examples
 
 ### Example 1: Cache the number of active user
 
@@ -117,7 +134,31 @@ 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
+### Example 5: Store all data in hash
+
+Sometimes you may need to query multiple objects. Although the query results will be cached, the application still needs to query the cache server multiple times. If one communication take 0.1 ms, 1000 communications will take 100ms! For example:
+
+```rb
+class Skill < ActiveRecord::Base
+  cache_at :atk_power
+end
+
+# This will retrieve the data from cache servers multiple times.
+@attack = skill_ids.inject(0){|sum, id| sum + Skill.cacher_at(id).atk_power }
+```
+
+One of the solution is that you could store a lookup table into cache, so that only one cache object is stored and you can retrieve all of the needed data in one query.
+
+```rb
+class Skill < ActiveRecord::Base
+  cache_at :atk_powers, ->{ Skill.pluck(:id, :atk_power).to_h }, expire_by: 'Skill#atk_power'
+end
+
+# This will retrieve the data from cache servers only 1 times.
+@attack = skill_ids.inject(0){|sum, id| sum + Skill.cacher.atk_powers[id] }
+```
+
+### Example 6: 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.
 
@@ -130,13 +171,34 @@ end
 # clean the cache by name
 current_user.cacher.clean(:profile)
 
-# Or calling the clean_* method
+# or calling the clean_* method
 current_user.cacher.clean_profile
 
 # clean the cache without loading model
 User.cacher_at(user_id).clean_profile
 ```
 
+### Example 7: Peek the data stored in cache
+
+If you just want to check the cached objects, but don't want it to load from database automatically when there is no cache. You could use `peek` method on `cacher`.
+
+```rb
+class User < ActiveRecord::Base
+  has_one :profile
+  cache_at :profile
+end
+
+# peek the cache by name
+current_user.cacher.peek(:profile)
+
+# or calling the peek_* method
+current_user.cacher.peek_profile
+
+# peek the cache without loading model
+User.cacher_at(user_id).peek_profile
+```
+
+
 ## Smart Caching
 
 ### Multi-level Cache
@@ -184,16 +246,28 @@ class User < ActiveRecord::Base
   cache_self
 end
 
-@user = User.cacher_at(user_id).self
+@user = User.cacher.find_by(id: user_id)
+
+# peek cache
+User.cacher.peek_by(id: user_id)
+
+# clean cache
+User.cacher.clean_by(id: user_id)
 ```
 
 Also support caching self by other columns.
 ```rb
 class User < ActiveRecord::Base
-  cache_self, by: :account
+  cache_self by: :account
 end
 
-@user = User.cacher_at('khiav').self_by_account
+@user = User.cacher.find_by(account: 'khiav')
+
+# peek cache
+User.cacher.peek_by(account: 'khiav')
+
+# clean cache
+User.cacher.clean_by(account: 'khiav')
 ```
 
 ### Caching Attributes
@@ -250,5 +324,17 @@ This option is needed to know which attribute should be passed to the parameter
 
   - Default value is `:id`
 
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/khiav223577/active_model_cachers. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
 
+## License
 
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/active_model_cachers/active_record/cacher.rb

@@ -6,8 +6,9 @@ module ActiveModelCachers
 
       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)
+          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) }
@@ -18,10 +19,27 @@ module ActiveModelCachers
           @defined_map[klass] ||= create_cacher_klass_at(klass)
         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) }
+          end
+          @find_by_mapping[primary_key] = [attr, service_klasses]
+        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
           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}") }
@@ -40,7 +58,14 @@ module ActiveModelCachers
 
       private
 
-      def exec_by(attr, primary_key, service_klasses, method)
+      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)
+        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

data/lib/active_model_cachers/column_value_cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class ActiveModelCachers::ColumnValueCache
   def initialize
     @cache1 = Hash.new{|h, k| h[k] = {} }
@@ -38,7 +39,7 @@ class ActiveModelCachers::ColumnValueCache
 
   def get_id_from(object, id, column, model)
     return id if column == 'id'
-    model ||= object.cacher_at(id).peek_self if object.has_cacher?
+    model ||= object.cacher.peek_by(id: id) if object.has_cacher?
     return model.send(column) if model
     return :not_set
   end

data/lib/active_model_cachers/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ActiveModelCachers
-  VERSION = "2.0.3"
+  VERSION = "2.1.0"
 end

metadata

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