simple_cacheable 1.4.1 → 1.5.0

data/lib/cacheable.rb

@@ -2,13 +2,17 @@ require 'uri'
 require "cacheable/caches"
 require "cacheable/keys"
 require "cacheable/expiry"
+require "cacheable/model_fetch"
 
 module Cacheable
+  extend ModelFetch
+
   def self.included(base)
     base.extend(Cacheable::Caches)
     base.send :include, Cacheable::Keys
     base.send :include, Cacheable::Expiry
     base.send :extend,  ClassMethods
+
     base.class_eval do
       class_attribute   :cached_key,
                         :cached_indices,
@@ -16,7 +20,14 @@ module Cacheable
                         :cached_class_methods,
                         :cached_associations
     end
+  end
+
+  def self.escape_punctuation(string)
+    string.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')
+  end
 
+  def self.rails4?
+    ActiveRecord::VERSION::MAJOR >= 4
   end
 
   module ClassMethods

data/lib/cacheable/expiry.rb

@@ -15,7 +15,9 @@ module Cacheable
     end
 
     def expire_key_cache
-      Rails.cache.delete model_cache_key
+      model_cache_keys.each do |key|
+        Rails.cache.delete key
+      end
     end
 
     def expire_attribute_cache

data/lib/cacheable/keys.rb

@@ -9,38 +9,49 @@ module Cacheable
     module ClassKeys
 
       def attribute_cache_key(attribute, value)
-        "#{name.tableize}/attribute/#{attribute}/#{URI.escape(value.to_s)}"
+        "#{self.base_class.name.tableize}/attribute/#{attribute}/#{URI.escape(value.to_s)}"
       end
 
       def all_attribute_cache_key(attribute, value)
-        "#{name.tableize}/attribute/#{attribute}/all/#{URI.escape(value.to_s)}"
+        "#{self.base_class.name.tableize}/attribute/#{attribute}/all/#{URI.escape(value.to_s)}"
       end
 
       def class_method_cache_key(meth, *args)
-        key = "#{name.tableize}/class_method/#{meth}"
+        key = "#{self.base_class.name.tableize}/class_method/#{meth}"
         args.flatten!
         key += "/#{args.join('+')}" if args.any?
         return key
       end
 
+      def instance_cache_key(param)
+        "#{self.base_class.name.tableize}/#{param}"
+      end
+
     end
 
     module InstanceKeys
 
+      def model_cache_keys
+        ["#{self.class.base_class.name.tableize}/#{self.id.to_i}", "#{self.class.base_class.name.tableize}/#{self.to_param}"]
+      end
+
       def model_cache_key
-        "#{self.class.name.tableize}/#{self.id.to_i}"
+        "#{self.class.base_class.name.tableize}/#{self.id.to_i}"
       end
 
       def method_cache_key(meth)
         "#{model_cache_key}/method/#{meth}"
       end
 
+      # Returns nil if association cannot be qualified
       def belong_association_cache_key(name, polymorphic=nil)
         name = name.to_s if name.is_a?(Symbol)
-        if polymorphic
-          "#{self.send("#{name}_type").tableize}/#{self.send("#{name}_id")}"
+
+        if polymorphic && self.respond_to?(:"#{name}_type")
+          return nil unless self.send(:"#{name}_type").present?
+          "#{base_class_or_name(self.send(:"#{name}_type"))}/#{self.send(:"#{name}_id")}"
         else
-          "#{name.tableize}/#{self.send(name + "_id")}"
+          "#{base_class_or_name(name)}/#{self.send(:"#{name}_id")}"
         end
       end
 
@@ -48,6 +59,17 @@ module Cacheable
         "#{model_cache_key}/association/#{name}"
       end
 
+      # If it isa class.  It should be the base_class name
+      # else it should just be a name tableized
+      def base_class_or_name(name)
+        name = begin
+          name.capitalize.constantize.base_class.name
+        rescue NameError # uninitialized constant
+          name
+        end
+        name.tableize
+      end
+
     end
 
   end

data/lib/cacheable/model_fetch.rb

@@ -0,0 +1,59 @@
+module Cacheable
+  module ModelFetch
+    def fetch(key, options=nil)
+      unless result = read(key, options)
+        if block_given?
+          result = yield
+          write(key, result, options) unless result.nil?
+        end
+      end
+      result
+    end
+
+    private
+
+    def write(key, value, options=nil)
+      options ||= {}
+
+      coder = if !value.is_a?(Hash) && value.respond_to?(:to_a)
+        value.to_a.map {|obj| coder_from_record(obj) }
+      else
+        coder_from_record(value)
+      end
+
+      Rails.cache.write(key, coder, options)
+      coder
+    end
+
+    def read(key, options=nil)
+      options ||= {}
+      value = Rails.cache.read(key, options)
+      return nil if value.nil?
+
+      if !coder?(value) && value.respond_to?(:to_a)
+        value.to_a.map { |obj| record_from_coder(obj) }
+      else
+        record_from_coder(value)
+      end
+    end
+
+    def coder_from_record(record)
+      return if record.nil?
+      return record unless record.is_a?(ActiveRecord::Base)
+
+      coder = { :class => record.class }
+      record.encode_with(coder)
+      coder
+    end
+
+    def record_from_coder(coder)
+      return coder unless coder?(coder)
+      record = coder[:class].allocate
+      record.init_with(coder)
+    end
+
+    def coder?(value)
+      value.is_a?(Hash) && value[:class].present?
+    end
+  end
+end

data/lib/cacheable/types/association_cache.rb

@@ -9,92 +9,147 @@ module Cacheable
         association = reflect_on_association(association_name)
 
         if :belongs_to == association.macro
-          polymorphic = association.options[:polymorphic]
-          polymorphic ||= false
-
-          define_method("cached_#{association_name}") do
-            Rails.cache.fetch belong_association_cache_key(association_name, polymorphic) do
-              send(association_name)
-            end
-          end
+          build_cache_belongs_to(association, association_name)
         else
+
           if through_reflection_name = association.options[:through]
-            through_association = self.reflect_on_association(through_reflection_name)
+            build_cache_has_through(association, association_name, through_reflection_name)
+          elsif :has_and_belongs_to_many == association.macro
+            build_cache_has_and_belongs_to_many(association, association_name)
+          else
+            build_cache_has_many(association, association_name)
+          end
 
-            reverse_through_association = through_association.klass.reflect_on_all_associations(:belongs_to).detect do |assoc|
-              assoc.klass.ancestors.include?(Cacheable) && assoc.klass.reflect_on_association(association.name)
+          method_name = :"cached_#{association_name}"
+          define_method(method_name) do
+            if instance_variable_get("@#{method_name}").nil?
+              association_cache.delete(association_name)
+              cache_key = have_association_cache_key(association_name)
+              result = Cacheable.fetch(cache_key) do
+                send(association_name)
+              end
+              instance_variable_set("@#{method_name}", result)
             end
+            instance_variable_get("@#{method_name}")
+          end
 
-            # In a through association it doesn't have to be a belongs_to
-            reverse_association = association.klass.reflect_on_all_associations(:belongs_to).find { |reverse_association|
-              reverse_association.options[:polymorphic] ? reverse_association.name == association.source_reflection.options[:as] : reverse_association.klass == self
-            }
-            if reverse_association
-              association.klass.class_eval do
-                after_commit "expire_#{association_name}_cache".to_sym
-
-                define_method("expire_#{association_name}_cache") do
-
-                  if respond_to? "expire_#{reverse_association.name}_cache".to_sym
-                    unless send("cached_#{reverse_association.name}").nil?
-                      send("cached_#{reverse_association.name}").expire_association_cache(association_name)
-                    end
-                  elsif !send(reverse_association.name).nil?
-                    if send(reverse_association.name).respond_to?(reverse_through_association.name) && !send(reverse_association.name).send(reverse_through_association.name).nil?
-                      send(reverse_association.name).send(reverse_through_association.name).expire_association_cache(association_name)
-                    end
-                  end
-                end
-              end
+        end
+
+      end
+    end
+
+    # No expiring callback
+    def build_cache_belongs_to(association, association_name)
+      polymorphic = association.options[:polymorphic]
+      polymorphic ||= false
+
+      method_name         = association_name
+      cached_method_name = :"cached_#{association_name}"
+
+      define_method(cached_method_name) do
+        if instance_variable_get("@#{cached_method_name}").nil?
+          cache_key = belong_association_cache_key(association_name, polymorphic)
+          result = if cache_key
+            association_cache.delete(association_name)
+            Cacheable.fetch(cache_key) do
+              send(association_name)
             end
-          elsif :has_and_belongs_to_many == association.macro
-              # No such thing as a polymorphic has_and_belongs_to_many
-              reverse_association = association.klass.reflect_on_all_associations(:has_and_belongs_to_many).find { |reverse_association|
-                reverse_association.klass == self
-              }
-
-              association.klass.class_eval do
-                after_commit "expire_#{association_name}_cache".to_sym
-
-                define_method "expire_#{association_name}_cache" do
-                  if respond_to? "cached_#{reverse_association.name}".to_sym
-                    unless send("cached_#{reverse_association.name}").nil?
-                      # cached_viewable.expire_association_cache
-                      send("cached_#{reverse_association.name}").expire_association_cache(association_name)
-                    end
-                  elsif !send("#{reverse_association.name}").nil?
-                    send("#{reverse_association.name}").each do |assoc|
-                      next if assoc.nil?
-                      assoc.expire_association_cache(association_name)
-                    end
-                  end
-                end
-              end
           else
-            reverse_association = association.klass.reflect_on_all_associations(:belongs_to).find { |reverse_association|
-              reverse_association.options[:polymorphic] ? reverse_association.name == association.options[:as] : reverse_association.klass == self
-            }
-
-            association.klass.class_eval do
-              after_commit "expire_#{association_name}_cache".to_sym
-
-              define_method "expire_#{association_name}_cache" do
-                if respond_to? "cached_#{reverse_association.name}".to_sym
-                  unless send("cached_#{reverse_association.name}").nil?
-                    send("cached_#{reverse_association.name}").expire_association_cache(association_name)
-                  end
-                elsif !send("#{reverse_association.name}").nil?
-                  send("#{reverse_association.name}").expire_association_cache(association_name)
-                end
+            # Should be nil, but preserve functionality
+            send(association_name)
+          end
+          instance_variable_set("@#{cached_method_name}", result)
+        end
+        instance_variable_get("@#{cached_method_name}")
+      end
+    end
+
+    def build_cache_has_through(association, association_name, through_reflection_name)
+      through_association = self.reflect_on_association(through_reflection_name)
+
+      reverse_through_association = through_association.klass.reflect_on_all_associations(:belongs_to).detect do |assoc|
+        assoc.klass.ancestors.include?(Cacheable) && assoc.klass.reflect_on_association(association.name)
+      end
+
+      # In a through association it doesn't have to be a belongs_to
+      reverse_association = association.klass.reflect_on_all_associations(:belongs_to).find { |reverse_association|
+        reverse_association.options[:polymorphic] ? reverse_association.name == association.source_reflection.options[:as] : reverse_association.klass == self
+      }
+      if reverse_association
+        association.klass.class_eval do
+          after_commit :"expire_#{association_name}_cache"
+
+          define_method(:"expire_#{association_name}_cache") do
+
+            method_name = reverse_association.name
+            cached_method_name = :"cached_#{reverse_association.name}"
+
+            if respond_to? cached_method_name
+              unless send(cached_method_name).nil?
+                send(cached_method_name).expire_association_cache(association_name)
+              end
+            elsif !send(method_name).nil?
+              if send(method_name).respond_to?(reverse_through_association.name) && !send(method_name).send(reverse_through_association.name).nil?
+                send(method_name).send(reverse_through_association.name).expire_association_cache(association_name)
               end
             end
+
           end
+        end
+      end
+    end
+
+    def build_cache_has_and_belongs_to_many(association, association_name)
+      # No such thing as a polymorphic has_and_belongs_to_many
+      reverse_association = association.klass.reflect_on_all_associations(:has_and_belongs_to_many).find { |reverse_association|
+        reverse_association.klass == self
+      }
+
+      association.klass.class_eval do
+        after_commit :"expire_#{association_name}_cache"
+
+        define_method :"expire_#{association_name}_cache" do
+
+          method_name = :"#{reverse_association.name}"
+          cached_method_name = :"cached_#{reverse_association.name}"
 
-          define_method("cached_#{association_name}") do
-            Rails.cache.fetch have_association_cache_key(association_name) do
-              send(association_name).respond_to?(:to_a) ? send(association_name).to_a : send(association_name)
+          if respond_to? cached_method_name
+            unless send(cached_method_name).nil?
+              # cached_viewable.expire_association_cache
+              send(cached_method_name).expire_association_cache(association_name)
+            end
+          elsif !send(method_name).nil?
+            send(method_name).each do |assoc|
+              next if assoc.nil?
+              assoc.expire_association_cache(association_name)
             end
           end
+
+        end
+      end
+    end
+
+    def build_cache_has_many(association, association_name)
+      reverse_association = association.klass.reflect_on_all_associations(:belongs_to).find { |reverse_association|
+        reverse_association.options[:polymorphic] ? reverse_association.name == association.options[:as] : reverse_association.klass == self
+      }
+
+      association.klass.class_eval do
+        after_commit :"expire_#{association_name}_cache"
+
+        define_method :"expire_#{association_name}_cache" do
+
+          cached_method_name = :"cached_#{reverse_association.name}"
+          method_name = :"#{reverse_association.name}"
+
+          if respond_to? cached_method_name
+            unless send(cached_method_name).nil?
+              send(cached_method_name).expire_association_cache(association_name)
+            end
+          elsif !send(method_name).nil?
+            send(method_name).expire_association_cache(association_name)
+          end
+
         end
       end
     end

data/lib/cacheable/types/attribute_cache.rb

@@ -15,7 +15,7 @@ module Cacheable
         define_singleton_method("find_cached_by_#{attribute}") do |value|
           self.cached_indices["#{attribute}"] ||= []
           self.cached_indices["#{attribute}"] << value
-          Rails.cache.fetch attribute_cache_key("#{attribute}", value) do
+          Cacheable.fetch(attribute_cache_key("#{attribute}", value)) do
             self.send("find_by_#{attribute}", value)
           end
         end
@@ -23,8 +23,12 @@ module Cacheable
         define_singleton_method("find_cached_all_by_#{attribute}") do |value|
           self.cached_indices["#{attribute}"] ||= []
           self.cached_indices["#{attribute}"] << value
-          Rails.cache.fetch all_attribute_cache_key("#{attribute}", value) do
-            self.send("find_all_by_#{attribute}", value)
+          Cacheable.fetch(all_attribute_cache_key("#{attribute}", value)) do
+            if Cacheable.rails4?
+              self.where("#{attribute}" => value).load
+            else
+              self.send("find_all_by_#{attribute}", value)
+            end
           end
         end
       end

data/lib/cacheable/types/class_method_cache.rb

@@ -3,7 +3,7 @@ module Cacheable
     # Cached class method
     # Should expire on any instance save
     def with_class_method(*methods)
-      self.cached_class_methods = methods.each_with_object({}) { |meth, indices| indices[meth] = {} }
+      self.cached_class_methods = methods.each_with_object({}) { |meth, indices| indices[meth] = [] }
 
       class_eval do
         after_commit :expire_class_method_cache, on: :update
@@ -13,7 +13,7 @@ module Cacheable
         define_singleton_method("cached_#{meth}") do |*args|
           self.cached_class_methods["#{meth}"] ||= []
           self.cached_class_methods["#{meth}"] << args
-          Rails.cache.fetch class_method_cache_key(meth, args) do
+          Cacheable.fetch class_method_cache_key(meth, args) do
             self.method(meth).arity == 0 ? send(meth) : send(meth, *args)
           end
         end

data/lib/cacheable/types/key_cache.rb

@@ -8,7 +8,8 @@ module Cacheable
       end
 
       define_singleton_method("find_cached") do |id|
-        Rails.cache.fetch "#{name.tableize}/" + id.to_i.to_s do
+        cache_key = self.instance_cache_key(id)
+        Cacheable.fetch(cache_key) do
           self.find(id)
         end
       end