active_cash 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfe51a8a1ee9db01686a85f20fe6645be5a7197f
-  data.tar.gz: 9b496a458a78e3bb25e6e19dd9a317306cce4fd2
+  metadata.gz: 2ce7a48da4376ed48bcaf90d9b56d270cad0d646
+  data.tar.gz: 689beea4558ef5b39f18d3cf0c1d12585085028d
 SHA512:
-  metadata.gz: f920abb9e8575cda8f24ac9b1cda4a158e724d9f095409c5c720f60ed297ff409047bdbd55ccf663678c74ef910d5558eee1ce750005f4be07de0b1f4fd199ad
-  data.tar.gz: bc10988ccc150437efa698fc1f79b717acbed4bf10946e1072452cdbbb1ca170d2aadcf1aae21d06982cb8784fd5f4321948f56ee2c998cb9b23ea84a1f6b890
+  metadata.gz: 2fc6f6e25239b5facaafc71341cda2e89a0a3e94b29adff8b3119b5835d09ea28412e9e00e27e2334570e2d1ec05fc6c7bbfa925af969da53c0722579383d835
+  data.tar.gz: 049e2153e2fbd3ed201924af45d0bf85794abcfd01f0458204ba5c273936e26ad4110a4958a7f7dac604cce306052fa60652522004925bc48537c3cef9937193

data/README.md

@@ -30,7 +30,7 @@ class Like < ActiveRecord::Base
 
          # type      # matched conditions                     # cache name (default is strategy name)
   caches :existence, find_by: [:user_id, :video_id]
-  caches :existence, find_by: [:user_id, :video_id, :hidden], name: :hidden
+  caches :existence, find_by: [:user_id, :video_id, :hidden], as: :hidden #also name: :hidden is supported
 end
 
 # Check if Like exists for specific :user_id, :video_id.
@@ -45,7 +45,11 @@ end
 I am open for better naming conventions :)
 
 Cache will be created and updated on every object creation, update and deletion
-using an `after_commit` callback. If you want to have a read-driven cache (which could
+using an `after_commit` callback. Only a string value is saved (true or false)
+in Redis (using [redis-objects](https://github.com/nateware/redis-objects) underneath)
+making it extremely efficient.
+
+If you want to have a read-driven cache (which could
 enhance your hit ratio depending on your read/writes ratio) you can provide an
 empty `update_on` array (by default it includes `[:create, :update, :destroy]`):
 
@@ -68,13 +72,32 @@ end
 
 Now cache will be created and updated ONLY IF there is a reference to Redis.
 
+You can also specify the return value (the symbol must be a method defined in the class instance):
+``` ruby
+class Like < ActiveRecord::Base
+  include ActiveCash
+
+  caches :existence, find_by: [:user_id, :video_id, :state], as: :state, returns: :state
+end
+
+# Check if Like exists for specific :user_id, :video_id.
+# returns the state
+# returns false if state.nil?
+@like = Like.cached_existence_by(user_id: 1, video_id: 2)
+```
+
+Not though that cache will return false if state is nil.
+
+
 ## Todo
 Only existence strategy is supported at the moment but the code is designed to
 support other kind of caching strategies as well, like caching the whole object
 or some parts of it. Also:
 
+* Refactor a bit :(
 * We should provide named callbacks
 * It's super easy to extend for Mongoid
+* Add memcached adapter
 
 ## Relevant projects
 There is [identity_cache](https://github.com/Shopify/identity_cache) built by Shopify.

data/lib/active_cash.rb

@@ -13,7 +13,7 @@ module ActiveCash
   end
   module ClassMethods
     def caches(type, opts = {})
-      name = opts[:name] || type.to_sym
+      name = opts[:name] || opts[:as] || type.to_sym
       @cache_opts = Utils.build_cache_opts(type, opts, @cache_opts, self.to_s)
       Utils.set_callbacks(self, @cache_opts[name])
       Utils.create_methods(self, @cache_opts[name])

data/lib/active_cash/adapter.rb

@@ -2,22 +2,38 @@ module ActiveCash::Adapter #fix boolean and make it generic
   extend self
 
   def get_value(key_name)
-    boolean(Redis::Value.new(key_name).value)
+    value = Redis::Value.new(key_name).value
+    is_boolean?(value) ? boolean(value) : value
   end
 
   def set_value(key_name, value)
     Redis::Value.new(key_name).value = value
 
-    boolean(value)
+    is_boolean?(value) ? boolean(value) : value
   end
 
   def delete_value(key_name)
     Redis::Value.new(key_name).delete
   end
 
+  def set_value_with_return(key_name, exists, returns)
+    if exists
+      returns.nil? ? set_value(key_name, true) : set_value(key_name, returns)
+    else
+      set_value(key_name, false)
+    end
+  end
+
   def boolean(value)
     return nil if value.nil?
 
     [true, 1, '1', 't', 'T', 'true', 'TRUE'].include? value
   end
+
+  def is_boolean?(value)
+    [
+      true, false, 1, 0, 'true', 'false', '1', '0', 't', 'f', 'TRUE', 'FALSE',
+      'T', 'F'
+    ].include? value
+  end
 end

data/lib/active_cash/cache.rb

@@ -1,74 +1,86 @@
 module ActiveCash::Cache
   extend self
 
-  def exists?(find_by:, method_name:, return: nil, klass:)
+  def exists?(find_by:, method_name:, returns:, klass:)
     key_name = get_key_name(klass, method_name, find_by)
     cached_value = adapter.get_value(key_name)
     return cached_value unless cached_value.nil?
 
-    adapter.set_value(key_name, klass.to_s.constantize.exists?(find_by))
+    instance = klass.to_s.constantize.find_by(find_by)
+    adapter.set_value_with_return(
+      key_name, !instance.nil?, instance.try(returns)
+    )
   end
 
-  def instance_exists?(find_by:, method_name:, instance:, return: nil)
+  def instance_exists?(find_by:, method_name:, instance:, returns:)
     key_name = get_key_name(instance.class, method_name, find_by)
     cached_value = adapter.get_value(key_name)
     return cached_value unless cached_value.nil?
 
-    instance_update(find_by: find_by, method_name: method_name, instance: instance)
+    instance_update(
+      find_by: find_by, method_name: method_name, instance: instance,
+      returns: returns
+    )
   end
 
-  def instance_update(find_by:, method_name:, return_value: nil, instance:)
+  def instance_update(find_by:, method_name:, returns:, instance:)
     key_name = get_key_name(instance.class, method_name, find_by)
 
     find_by.keys.each_with_index do |key, i|
       if instance.send(key) != find_by.values[i]
-        return adapter.set_value(key_name, false)
+        return adapter.set_value_with_return(key_name, false, returns)
       end
     end
 
-    adapter.set_value(key_name, true)
+    adapter.set_value_with_return(key_name, true, returns)#instance.try(returns))
   end
 
-  def instance_updated?(find_by:, instance:)
+  def instance_updated?(find_by:, instance:, returns:)
+    changes = OpenStruct.new(instance.previous_changes)
+    return true if changes.send(returns) != nil
+
     find_by.keys.each_with_index do |key, i|
-      if instance.send(key) != instance.send("#{key}_was")
+      if changes.send(key) != nil
         return true
       end
     end
   end
 
-  def old_instance_update(find_by:, method_name:, return_value: nil, instance:)
+  def old_instance_update(find_by:, method_name:, returns:, instance:)
     #old values
     instance_update_if_exists(
       find_by: Hash[find_by.map {|k, v| ["#{k}_was", v] }],
       method_name: method_name,
-      return: return_value,
+      returns: returns,
       instance: instance
     )
   end
 
-  def instance_update_if_exists(find_by:, method_name:, return: nil, instance:)
+  def instance_update_if_exists(find_by:, method_name:, returns:, instance:)
     key_name = get_key_name(instance.class, method_name, find_by)
 
     cached_value = adapter.get_value(key_name)
     return true if cached_value.nil?
 
-    instance_update(find_by: find_by, method_name: method_name, instance: instance)
+    instance_update(
+      find_by: find_by, method_name: method_name, instance: instance,
+      returns: returns
+    )
   end
 
-  def delete(find_by:, method_name:, return: nil, klass:)
+  def delete(find_by:, method_name:, returns:, klass:)
     key_name = get_key_name(klass, method_name, find_by)
     adapter.delete_value(key_name)
   end
 
-  def set_false(find_by:, method_name:, return: nil, klass:)
+  def set_false(find_by:, method_name:, returns:, klass:)
     key_name = get_key_name(klass, method_name, find_by)
-    adapter.set_value(key_name, false)
+    adapter.set_value_with_return(key_name, false, returns)
   end
 
-  def set_true(find_by:, method_name:, return: nil, klass:)
+  def set_true(find_by:, method_name:, returns:, klass:)
     key_name = get_key_name(klass, method_name, find_by)
-    adapter.set_value(key_name, true)
+    adapter.set_value_with_return(key_name, true, returns)
   end
 
   def get_key_name(klass, method_name, hash_params)

data/lib/active_cash/errors.rb

@@ -6,3 +6,6 @@ end
 
 class UnknownCacheTypeError < ActiveCashError
 end
+
+class FindByOptionsMismatchError < ActiveCashError
+end

data/lib/active_cash/utils.rb

@@ -5,32 +5,52 @@ module ActiveCash::Utils
     if (opts[:update_on] & [:create]).blank?
       model.send(:after_commit, on: [:create]) do
         ActiveCash::Cache.instance_update_if_exists(
-          ActiveCash::Utils.extract_instance_args(opts, self)
+          ActiveCash::Utils.extract_instance_args(opts, self).merge(
+            returns: self.try(opts[:returns])
+          )
         )
       end
     else
       model.send(:after_commit, on: [:create]) do
         ActiveCash::Cache.instance_update(
-          ActiveCash::Utils.extract_instance_args(opts, self)
+          ActiveCash::Utils.extract_instance_args(opts, self).merge(
+            returns: self.try(opts[:returns])
+          )
         )
       end
     end
 
     if (opts[:update_on] & [:update]).blank?
       model.send(:after_commit, on: [:update]) do
-        if instance_updated?(opts[:find_by], self)
-          ActiveCash::Cache.delete(extract_old_instance_args(opts, self))
+        if ActiveCash::Cache.instance_updated?(
+            find_by: opts[:find_by], instance: self, returns: opts[:returns]
+        )
+          ActiveCash::Cache.delete(
+            ActiveCash::Utils.extract_instance_old_args(opts, self).merge(
+              returns: self.try(opts[:returns])
+            )
+          )
           ActiveCash::Cache.instance_update_if_exists(
-            ActiveCash::Utils.extract_instance_args(opts, self)
+            ActiveCash::Utils.extract_instance_args(opts, self).merge(
+              returns: self.try(opts[:returns])
+            )
           )
         end
       end
     else
       model.send(:after_commit, on: [:update]) do
-        if instance_updated?(opts[:find_by], self)
-          ActiveCash::Cache.delete(extract_old_instance_args(opts, self))
+        if ActiveCash::Cache.instance_updated?(
+            find_by: opts[:find_by], instance: self, returns: opts[:returns]
+        )
+          ActiveCash::Cache.delete(
+            ActiveCash::Utils.extract_instance_old_args(opts, self).merge(
+              returns: self.try(opts[:returns])
+            )
+          )
           ActiveCash::Cache.instance_update(
-            ActiveCash::Utils.extract_instance_args(opts, self)
+            ActiveCash::Utils.extract_instance_args(opts, self).merge(
+              returns: self.try(opts[:returns])
+            )
           )
         end
       end
@@ -39,13 +59,17 @@ module ActiveCash::Utils
     if (opts[:update_on] & [:destroy]).blank?
       model.send(:after_commit, on: [:destroy]) do
         ActiveCash::Cache.delete(
-          ActiveCash::Utils.extract_args(opts, self)
+          ActiveCash::Utils.extract_args(opts, self).merge(
+            returns: self.try(opts[:returns])
+          )
         )
       end
     else
       model.send(:after_commit, on: [:destroy]) do
         ActiveCash::Cache.set_false(
-          ActiveCash::Utils.extract_args(opts, self)
+          ActiveCash::Utils.extract_args(opts, self).merge(
+            returns: self.try(opts[:returns])
+          )
         )
       end
     end
@@ -53,7 +77,21 @@ module ActiveCash::Utils
 
   def create_methods(model, opts) #raise error when arg not given
     model.send(:define_singleton_method, "cached_#{opts[:name]}_by") do |args = {}|
-      return ActiveCash::Cache.exists?(
+      xor_array = ((args.keys | opts[:find_by]) - (args.keys & opts[:find_by]))
+      if xor_array.empty?
+        return ActiveCash::Cache.exists?(
+          find_by: opts[:find_by].inject({}) {|h, arg| h[arg] = args[arg]; h},
+          method_name: opts[:name],
+          klass: opts[:klass],
+          returns: opts[:returns]
+        )
+      else
+        ActiveCash::Utils.raise_find_by_options_mismatch(xor_array, opts[:find_by])
+      end
+    end
+
+    model.send(:define_singleton_method, "delete_cached_#{opts[:name]}_by") do |args = {}|
+      return ActiveCash::Cache.delete(
         find_by: opts[:find_by].inject({}) {|h, arg| h[arg] = args[arg]; h},
         method_name: opts[:name],
         klass: opts[:klass]
@@ -61,6 +99,15 @@ module ActiveCash::Utils
     end
   end
 
+  def raise_find_by_options_mismatch(invalid, valid)
+    if (invalid & valid).any?
+      raise(FindByOptionsMismatchError, "Missing find_by options: #{invalid}")
+    else
+      raise(FindByOptionsMismatchError, "Not registerd find_by options: #{invalid}")
+    end
+  end
+
+
   def raise_unknown_cache_type(type)
     raise(
       UnknownCacheTypeError,
@@ -98,13 +145,20 @@ module ActiveCash::Utils
   end
 
   #and this
-  def extract_instance_args(opts, instance)
+  def extract_instance_old_args(opts, instance)
+    changes = OpenStruct.new(instance.previous_changes)
+
     {
       find_by: opts[:find_by].inject({}){|h, arg|
-        h[arg] = instance.send("#{arg}_was"); h
+        if changes.arg != nil
+          h[arg] = changes.send(arg).first
+        else
+          h[arg] = instance.send(arg)
+        end
+        h
       },
       method_name: opts[:name],
-      instance: instance
+      klass: instance.class
     }
   end
 
@@ -112,13 +166,13 @@ module ActiveCash::Utils
     #add procs/lambdas for better finds
     raise_unknown_cache_type(type) unless type.to_sym == :existence
     cache_opts ||= {}
-    name = opts[:name] || type.to_sym
+    name = opts[:name] || opts[:as] || type.to_sym
     raise_redefined_cache_error(name) unless cache_opts[name].nil?
     cache_opts[name] = {}
     cache_opts[name][:name] = name
     cache_opts[name][:type] = type.to_sym
     cache_opts[name][:find_by] = opts[:find_by]
-    cache_opts[name][:return] = opts[:return]
+    cache_opts[name][:returns] = opts[:returns] || :nil
     cache_opts[name][:update_on] = opts[:update_on] || [:create, :update, :destroy]
     cache_opts[name][:klass] = klass
 

data/lib/active_cash/version.rb

@@ -1,3 +1,3 @@
 module ActiveCash
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_cash
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Filippos Vasilakis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-04 00:00:00.000000000 Z
+date: 2016-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-objects