simple_cacheable 1.3.2 → 1.3.3

data/lib/cacheable.rb

@@ -1,273 +1,24 @@
 require 'uri'
+require "cacheable/caches"
+require "cacheable/keys"
+require "cacheable/expiry"
 
 module Cacheable
   def self.included(base)
-    base.class_eval do
-      class << self
-        def model_cache(&block)
-          class_attribute :cached_key,
-                          :cached_indices,
-                          :cached_methods,
-                          :cached_class_methods,
-                          :cached_associations
-          instance_exec &block
-        end
-
-        def with_key
-          self.cached_key = true
-
-          class_eval <<-EOF
-            after_commit :expire_key_cache, :on => :update
-
-            def self.find_cached(id)
-              Rails.cache.fetch "#{name.tableize}/" + id.to_i.to_s do
-                self.find(id)
-              end
-            end
-          EOF
-        end
-
-        def with_attribute(*attributes)
-          self.cached_indices = attributes.inject({}) { |indices, attribute| indices[attribute] = {} }
-
-          class_eval <<-EOF
-            after_commit :expire_attribute_cache, :on => :update
-            after_commit :expire_all_attribute_cache, :on => :update
-          EOF
-
-          attributes.each do |attribute|
-            class_eval <<-EOF
-              def self.find_cached_by_#{attribute}(value)
-                self.cached_indices["#{attribute}"] ||= []
-                self.cached_indices["#{attribute}"] << value
-                Rails.cache.fetch attribute_cache_key("#{attribute}", value) do
-                  self.find_by_#{attribute}(value)
-                end
-              end
-
-              def self.find_cached_all_by_#{attribute}(value)
-                self.cached_indices["#{attribute}"] ||= []
-                self.cached_indices["#{attribute}"] << value
-                Rails.cache.fetch all_attribute_cache_key("#{attribute}", value) do
-                  self.find_all_by_#{attribute}(value)
-                end
-              end
-            EOF
-          end
-        end
-
-        def with_method(*methods)
-          self.cached_methods = methods
-
-          class_eval <<-EOF
-            after_commit :expire_method_cache, :on => :update
-          EOF
-
-          methods.each do |meth|
-            class_eval <<-EOF
-              def cached_#{meth}
-                Rails.cache.fetch method_cache_key("#{meth}") do
-                  #{meth}
-                end
-              end
-            EOF
-          end
-        end
-
-        # Cached class method
-        # Should expire on any instance save
-        def with_class_method(*methods)
-          self.cached_class_methods = methods
-
-          class_eval <<-EOF
-            after_commit :expire_class_method_cache, on: :update
-          EOF
-
-          methods.each do |meth|
-            class_eval <<-EOF
-              def self.cached_#{meth}
-                Rails.cache.fetch class_method_cache_key("#{meth}") do
-                  #{meth}
-                end
-              end
-            EOF
-          end
-
-        end
-
-        def with_association(*association_names)
-          self.cached_associations = association_names
-
-          association_names.each do |association_name|
-            association = reflect_on_association(association_name)
-
-            if :belongs_to == association.macro
-              polymorphic = association.options[:polymorphic]
-              polymorphic ||= false
-              class_eval <<-EOF
-                def cached_#{association_name}
-                  Rails.cache.fetch belong_association_cache_key("#{association_name}", #{polymorphic}) do
-                    #{association_name}
-                  end
-                end
-              EOF
-            else
-              if through_reflection_name = association.options[:through]
-                through_association = self.reflect_on_association(through_reflection_name)
-
-                # FIXME it should be the only reflection but I'm not 100% positive
-                reverse_through_association = through_association.klass.reflect_on_all_associations(:belongs_to).first
-
-                # 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 <<-EOF
-                    after_commit :expire_#{association_name}_cache
-
-                    def expire_#{association_name}_cache
-                      if respond_to? :cached_#{reverse_association.name}
-                        # cached_viewable.expire_association_cache
-                        cached_#{reverse_association.name}.expire_association_cache(:#{association_name})
-                      else
-                        #{reverse_association.name}.#{reverse_through_association.name}.expire_association_cache(:#{association_name})
-                      end
-                    end
-                  EOF
-                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 <<-EOF
-                    after_commit :expire_#{association_name}_cache
-
-                    def expire_#{association_name}_cache
-                      if respond_to? :cached_#{reverse_association.name}
-                        # cached_viewable.expire_association_cache
-                        cached_#{reverse_association.name}.expire_association_cache(:#{association_name})
-                      else
-                        #{reverse_association.name}.each do |assoc|
-                          assoc.expire_association_cache(:#{association_name})
-                        end
-                      end
-                    end
-                  EOF
-              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 <<-EOF
-                  after_commit :expire_#{association_name}_cache
-
-                  def expire_#{association_name}_cache
-                    if respond_to? :cached_#{reverse_association.name}
-                      cached_#{reverse_association.name}.expire_association_cache(:#{association_name})
-                    else
-                      #{reverse_association.name}.expire_association_cache(:#{association_name})
-                    end
-                  end
-                EOF
-              end
-              class_eval <<-EOF
-                def cached_#{association_name}
-                  Rails.cache.fetch have_association_cache_key("#{association_name}") do
-                    #{association_name}.respond_to?(:all) ? #{association_name}.all : #{association_name}
-                  end
-                end
-              EOF
-            end
-          end
-        end
-
-        def attribute_cache_key(attribute, value)
-          "#{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)}"
-        end
-
-        def class_method_cache_key(meth)
-          "#{name.tableize}/class_method/#{meth}"
-        end
-
-      end
+    base.extend(Cacheable::Caches)
+    base.send :include, Cacheable::Keys
+    base.send :include, Cacheable::Expiry
 
-    end
-
-  end
-
-  def expire_model_cache
-    expire_key_cache if self.class.cached_key
-    expire_attribute_cache if self.class.cached_indices.present?
-    expire_all_attribute_cache if self.class.cached_indices.present?
-    expire_method_cache if self.class.cached_methods.present?
-    expire_class_method_cache if self.class.cached_class_methods.present?
-
-    if self.class.cached_associations.present?
-      self.class.cached_associations.each do |assoc|
-        expire_association_cache(assoc)
+    base.class_eval do
+      def self.model_cache(&block)
+        class_attribute :cached_key,
+                        :cached_indices,
+                        :cached_methods,
+                        :cached_class_methods,
+                        :cached_associations
+        instance_exec &block
       end
     end
   end
 
-  def expire_key_cache
-    Rails.cache.delete model_cache_key
-  end
-
-  def expire_attribute_cache
-    self.class.cached_indices.each do |attribute, values|
-      value = self.send(attribute)
-      Rails.cache.delete self.class.attribute_cache_key(attribute, value)
-    end
-  end
-
-  def expire_all_attribute_cache
-    self.class.cached_indices.each do |attribute, values|
-      value = self.send(attribute)
-      Rails.cache.delete self.class.all_attribute_cache_key(attribute, value)
-    end
-  end
-
-  def expire_method_cache
-    self.class.cached_methods.each do |meth|
-      Rails.cache.delete method_cache_key(meth)
-    end
-  end
-
-  def expire_class_method_cache
-    self.class.cached_class_methods.each do |meth|
-      Rails.cache.delete self.class.class_method_cache_key(meth)
-    end
-  end
-
-  def expire_association_cache(name)
-    Rails.cache.delete have_association_cache_key(name)
-  end
-
-  def model_cache_key
-    "#{self.class.name.tableize}/#{self.id.to_i}"
-  end
-
-  def method_cache_key(meth)
-    "#{model_cache_key}/method/#{meth}"
-  end
-
-  def belong_association_cache_key(name, polymorphic=nil)
-    if polymorphic
-      "#{self.send("#{name}_type").tableize}/#{self.send("#{name}_id")}"
-    else
-      "#{name.tableize}/#{self.send(name + "_id")}"
-    end
-  end
-
-  def have_association_cache_key(name)
-    "#{model_cache_key}/association/#{name}"
-  end
 end

data/spec/cacheable/expiry_cache_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Cacheable do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :all do
+    @post1 = user.posts.create(:title => 'post1')
+    user2 = User.create(:login => 'PelegR')
+    user2.posts.create(:title => 'post3')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "expire_model_cache" do
+    it "should delete with_key cache" do
+      User.find_cached(user.id)
+      Rails.cache.read("users/#{user.id}").should_not be_nil
+      user.expire_model_cache
+      Rails.cache.read("users/#{user.id}").should be_nil
+    end
+
+    it "should delete with_attribute cache" do
+      user = User.find_cached_by_login("flyerhzm")
+      Rails.cache.read("users/attribute/login/flyerhzm").should == user
+      user.expire_model_cache
+      Rails.cache.read("users/attribute/login/flyerhzm").should be_nil
+    end
+
+    it "should delete with_method cache" do
+      user.cached_last_post
+      Rails.cache.read("users/#{user.id}/method/last_post").should_not be_nil
+      user.expire_model_cache
+      Rails.cache.read("users/#{user.id}/method/last_post").should be_nil
+    end
+
+    it "should delete with_class_method cache (default_post)" do
+      Post.cached_default_post
+      Rails.cache.read("posts/class_method/default_post").should_not be_nil
+      @post1.expire_model_cache
+      Rails.cache.read("posts/class_method/default_post").should be_nil
+    end
+
+    it "should delete with_class_method cache (retrieve_with_user_id)" do
+      Post.cached_retrieve_with_user_id(1)
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should_not be_nil
+      @post1.expire_model_cache
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should be_nil
+    end
+
+    it "should delete with_class_method cache (retrieve_with_user_id) with different arguments" do
+      Post.cached_retrieve_with_user_id(1)
+      Post.cached_retrieve_with_user_id(2)
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should_not be_nil
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/2").should_not be_nil
+      @post1.expire_model_cache
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should be_nil
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/2").should be_nil
+    end
+
+    it "should delete with_class_method cache (retrieve_with_both)" do
+      Post.cached_retrieve_with_both(1, 1)
+      Rails.cache.read("posts/class_method/retrieve_with_both/1+1").should_not be_nil
+      @post1.expire_model_cache
+      Rails.cache.read("posts/class_method/retrieve_with_both/1+1").should be_nil
+    end
+
+    # TODO: should we cache empty arrays?
+    it "should delete associations cache" do
+      user.cached_images
+      Rails.cache.read("users/#{user.id}/association/images").should_not be_nil
+      user.expire_model_cache
+      Rails.cache.read("users/#{user.id}/association/images").should be_nil
+    end
+
+  end
+
+end

data/spec/cacheable/types/association_cache_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Cacheable do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :all do
+    @post1 = user.posts.create(:title => 'post1')
+    @post2 = user.posts.create(:title => 'post2')
+    @image1 = @post1.images.create
+    @image2 = @post1.images.create
+    @comment1 = @post1.comments.create
+    @comment2 = @post1.comments.create
+    @tag1 = @post1.tags.create(title: "Rails")
+    @tag2 = @post1.tags.create(title: "Caching")
+    @group1 = Group.create(name: "Ruby On Rails")
+    @account = user.create_account(group: @group1)
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "with_association" do
+    context "belongs_to" do
+      it "should not cache association" do
+        Rails.cache.read("users/#{user.id}").should be_nil
+      end
+
+      it "should cache Post#user" do
+        @post1.cached_user.should == user
+        Rails.cache.read("users/#{user.id}").should == user
+      end
+
+      it "should cache Post#user multiple times" do
+        @post1.cached_user
+        @post1.cached_user.should == user
+      end
+
+      it "should cache Comment#commentable with polymorphic" do
+        Rails.cache.read("posts/#{@post1.id}").should be_nil
+        @comment1.cached_commentable.should == @post1
+        Rails.cache.read("posts/#{@post1.id}").should == @post1
+      end
+    end
+
+    context "has_many" do
+      it "should not cache associations" do
+        Rails.cache.read("users/#{user.id}/association/posts").should be_nil
+      end
+
+      it "should cache User#posts" do
+        user.cached_posts.should == [@post1, @post2]
+        Rails.cache.read("users/#{user.id}/association/posts").should == [@post1, @post2]
+      end
+
+      it "should cache User#posts multiple times" do
+        user.cached_posts
+        user.cached_posts.should == [@post1, @post2]
+      end
+    end
+
+    context "has_many with polymorphic" do
+      it "should not cache associations" do
+        Rails.cache.read("posts/#{@post1.id}/association/comments").should be_nil
+      end
+
+      it "should cache Post#comments" do
+        @post1.cached_comments.should == [@comment1, @comment2]
+        Rails.cache.read("posts/#{@post1.id}/association/comments").should == [@comment1, @comment2]
+      end
+
+      it "should cache Post#comments multiple times" do
+        @post1.cached_comments
+        @post1.cached_comments.should == [@comment1, @comment2]
+      end
+    end
+
+    context "has_one" do
+      it "should not cache associations" do
+        Rails.cache.read("users/#{user.id}/association/account").should be_nil
+      end
+
+      it "should cache User#posts" do
+        user.cached_account.should == @account
+        Rails.cache.read("users/#{user.id}/association/account").should == @account
+      end
+
+      it "should cache User#posts multiple times" do
+        user.cached_account
+        user.cached_account.should == @account
+      end
+    end
+
+    context "has_many through" do
+      it "should not cache associations" do
+        Rails.cache.read("users/#{user.id}/association/images").should be_nil
+      end
+
+      it "should cache User#images" do
+        user.cached_images.should == [@image1, @image2]
+        Rails.cache.read("users/#{user.id}/association/images").should == [@image1, @image2]
+      end
+
+      it "should cache User#images multiple times" do
+        user.cached_images
+        user.cached_images.should == [@image1, @image2]
+      end
+
+      context "expiry" do
+        it "should have the correct collection" do
+          @image3 = @post1.images.create
+          Rails.cache.read("users/#{user.id}/association/images").should be_nil
+          user.cached_images.should == [@image1, @image2, @image3]
+          Rails.cache.read("users/#{user.id}/association/images").should == [@image1, @image2, @image3]
+        end
+      end
+    end
+
+    context "has_one through belongs_to" do
+      it "should not cache associations" do
+        Rails.cache.read("users/#{user.id}/association/group").should be_nil
+      end
+
+      it "should cache User#group" do
+        user.cached_group.should == @group1
+        Rails.cache.read("users/#{user.id}/association/group").should == @group1
+      end
+
+      it "should cache User#group multiple times" do
+        user.cached_group
+        user.cached_group.should == @group1
+      end
+
+    end
+
+    context "has_and_belongs_to_many" do
+
+      it "should not cache associations off the bat" do
+        Rails.cache.read("posts/#{@post1.id}/association/tags").should be_nil
+      end
+
+      it "should cache Post#tags" do
+        @post1.cached_tags.should == [@tag1, @tag2]
+        Rails.cache.read("posts/#{@post1.id}/association/tags").should == [@tag1, @tag2]
+      end
+
+      it "should handle multiple requests" do
+        @post1.cached_tags
+        @post1.cached_tags.should == [@tag1, @tag2]
+      end
+
+      context "expiry" do
+        it "should have the correct collection" do
+          @tag3 = @post1.tags.create!(title: "Invalidation is hard")
+          Rails.cache.read("posts/#{@post1.id}/association/tags").should be_nil
+          @post1.cached_tags.should == [@tag1, @tag2, @tag3]
+          Rails.cache.read("posts/#{@post1.id}/association/tags").should == [@tag1, @tag2, @tag3]
+        end
+      end
+    end
+
+  end
+
+end

data/spec/cacheable/types/attribute_cache_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Cacheable do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :all do
+    @post1 = user.posts.create(:title => 'post1')
+    @post2 = user.posts.create(:title => 'post2')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "with_attribute" do
+    it "should not cache User.find_by_login" do
+      Rails.cache.read("users/attribute/login/flyerhzm").should be_nil
+    end
+
+    it "should cache by User.find_by_login" do
+      User.find_cached_by_login("flyerhzm").should == user
+      Rails.cache.read("users/attribute/login/flyerhzm").should == user
+    end
+
+    it "should get cached by User.find_by_login multiple times" do
+      User.find_cached_by_login("flyerhzm")
+      User.find_cached_by_login("flyerhzm").should == user
+    end
+
+    it "should escape whitespace" do
+      new_user = User.create(:login => "user space")
+      User.find_cached_by_login("user space").should == new_user
+    end
+
+    it "should handle fixed numbers" do
+      Post.find_cached_by_user_id(user.id).should == @post1
+      Rails.cache.read("posts/attribute/user_id/#{user.id}").should == @post1
+    end
+
+    context "find_all" do
+      it "should not cache Post.find_all_by_user_id" do
+        Rails.cache.read("posts/attribute/user_id/all/#{user.id}").should be_nil
+      end
+
+      it "should cache by Post.find_cached_all_by_user_id" do
+        Post.find_cached_all_by_user_id(user.id).should == [@post1, @post2]
+        Rails.cache.read("posts/attribute/user_id/all/#{user.id}").should == [@post1, @post2]
+      end
+
+      it "should get cached by Post.find_cached_all_by_user_id multiple times" do
+        Post.find_cached_all_by_user_id(user.id)
+        Post.find_cached_all_by_user_id(user.id).should == [@post1, @post2]
+      end
+
+    end
+  end
+
+end

data/spec/cacheable/types/class_method_cache_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Cacheable do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :all do
+    @post1 = user.posts.create(:title => 'post1')
+    @post2 = user.posts.create(:title => 'post2')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "with_class_method" do
+    it "should not cache Post.default_post" do
+      Rails.cache.read("posts/class_method/default_post").should be_nil
+    end
+
+    it "should cache Post.default_post" do
+      Post.cached_default_post.should == @post1
+      Rails.cache.read("posts/class_method/default_post").should == @post1
+    end
+
+    it "should cache Post.default_post multiple times" do
+      Post.cached_default_post
+      Post.cached_default_post.should == @post1
+    end
+
+    it "should cache Post.retrieve_with_user_id" do
+      Post.cached_retrieve_with_user_id(1).should == @post1
+      Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should == @post1
+    end
+
+    it "should cache Post.retrieve_with_both with multiple arguments" do
+      Post.cached_retrieve_with_both(1, 1).should be_true
+      Rails.cache.read("posts/class_method/retrieve_with_both/1+1").should be_true
+    end
+  end
+
+end

data/spec/cacheable/types/key_cache_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Cacheable do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "with_key" do
+    it "should not cache key" do
+      Rails.cache.read("users/#{user.id}").should be_nil
+    end
+
+    it "should cache by User#id" do
+      User.find_cached(user.id).should == user
+      Rails.cache.read("users/#{user.id}").should == user
+    end
+
+    it "should get cached by User#id multiple times" do
+      User.find_cached(user.id)
+      User.find_cached(user.id).should == user
+    end
+  end
+
+end