generation_cacheable 1.0.0

data/lib/gen_cache/cache_types/class_method_cache.rb

@@ -0,0 +1,23 @@
+module GenCache
+  module ClassMethodCache
+    # Cached class method
+    # Should expire on any instance save
+    def with_class_method(*methods)
+      self.cached_class_methods ||= []
+      self.cached_class_methods += methods
+
+      methods.each do |meth|
+        define_singleton_method("cached_#{meth}") do |*args|
+          cache_key = GenCache.class_method_key(self, meth)
+          GenCache.fetch(cache_key, args: args) do
+            unless args.empty?
+              self.send(meth, *args)
+            else
+              self.send(meth)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gen_cache/cache_types/key_cache.rb

@@ -0,0 +1,14 @@
+module GenCache
+  module KeyCache
+    def with_key
+      self.cached_key = true
+
+      define_singleton_method("find_cached") do |id|
+        cache_key = GenCache.instance_key(self, id)
+        GenCache.fetch(cache_key) do
+          self.find(id)
+        end
+      end
+    end
+  end
+end

data/lib/gen_cache/cache_types/method_cache.rb

@@ -0,0 +1,28 @@
+module GenCache
+  module MethodCache
+    def with_method(*methods)
+      self.cached_methods ||= []
+      self.cached_methods += methods
+
+      methods.each do |meth|
+        method_name = "cached_#{meth}"
+        define_method("cached_#{meth}") do |*args|
+          args ||= []
+          cache_key = GenCache.method_key(self, meth)
+          memoized_name = GenCache.escape_punctuation("@#{method_name}")
+          if instance_variable_get(memoized_name).nil?
+            result = GenCache.fetch(cache_key, args: args) do
+              unless args.empty? 
+                self.send(meth, *args)
+              else
+                self.send(meth)
+              end
+            end
+            instance_variable_set(memoized_name, result)
+          end
+          instance_variable_get(memoized_name)
+        end
+      end
+    end
+  end
+end

data/lib/gen_cache/caches.rb

@@ -0,0 +1,15 @@
+require "gen_cache/cache_types/key_cache"
+require "gen_cache/cache_types/attribute_cache"
+require "gen_cache/cache_types/method_cache"
+require "gen_cache/cache_types/class_method_cache"
+require "gen_cache/cache_types/association_cache"
+
+module GenCache
+  module Caches
+    include GenCache::KeyCache
+    include GenCache::AttributeCache
+    include GenCache::MethodCache
+    include GenCache::ClassMethodCache
+    include GenCache::AssocationCache
+  end
+end

data/lib/gen_cache/expiry.rb

@@ -0,0 +1,37 @@
+module GenCache
+
+  def expire_all
+    GenCache.expire(self)
+  end
+
+  # Manual expiry initiated by an object after commit
+  # only has to worry about key_cache, attribute_cache, and class_method_cache
+  def self.expire(object)
+    expire_instance_key(object)
+    expire_class_method_keys(object)
+    expire_attribute_keys(object)
+  end
+
+  def self.expire_instance_key(object)
+    key = instance_key(object.class, object.id)
+    Rails.cache.delete(key[:key])
+  end
+
+  def self.expire_class_method_keys(object)
+    object.class.cached_class_methods.map do |class_method|
+      key = class_method_key(object.class, class_method)
+    end.each do |method_key|
+      Rails.cache.delete(method_key[:key])
+    end
+  end
+
+  # cached attributes are stored like:
+  # { attribute => [value1, value2] }
+  def self.expire_attribute_keys(object)
+    object.class.cached_indices.map do |index, values|
+      values.map { |v| attribute_key(object.class, index, v) }
+    end.flatten.each do |attribute_key|
+      Rails.cache.delete(attribute_key[:key])
+    end
+  end
+end

data/lib/gen_cache/keys.rb

@@ -0,0 +1,70 @@
+module GenCache
+
+  # Keys generated in hashes called Key blobs => { type: :key_type, key: 'key' }
+  # The type is used by the fetcher so it doesn't have to parse
+  # the key to figure out what kind it is and how to handle its contents.
+
+  ## CLASS KEYS      
+
+  # HASH generated from SCHEMA to indicate MODEL GENERATIONS
+  # => "users/5821759535148822589"
+  def self.model_prefix(klass)
+    columns = klass.try(:columns)
+    return if columns.nil?
+    schema_string = columns.sort_by(&:name).map{|c| "#{c.name}:#{c.type}"}.join(',')
+    generation = CityHash.hash64(schema_string)
+    [klass.name.tableize, generation].join("/")
+  end
+
+  # => "users/5821759535148822589/64"
+  def self.instance_key(klass, id)
+    {type: :object,
+     key: [model_prefix(klass), id].join("/") }
+  end
+
+  # => "users/5821759535148822589/attribute/value"
+  # => "users/5821759535148822589/all/attribute/value"
+  def self.attribute_key(klass, attribute, args, options={})
+    att_args = [attribute, symbolize_args([args])].join("/")
+    unless options[:all]
+      { type: :object,
+        key: [model_prefix(klass), att_args].join("/") }
+    else
+      { type: :object,
+        key: [model_prefix(klass), "all", att_args].join("/") }
+    end
+  end
+
+  # => "users/5821759535148822589/method"
+  def self.class_method_key(klass, method)
+    { type: :method, 
+      key: [model_prefix(klass), method].join("/") }
+  end
+
+  def self.all_class_method_keys(klass)
+    klass.cached_class_methods.map { |c_method| class_method_key(klass, c_method) }
+  end
+
+  ## INSTANCE KEYS
+
+  # HASH generated from ATTRIBUTES to indicate INSTANCE GENERATIONS
+  # => "users/5821759535148822589/64/12126514016877773284"
+  def self.instance_prefix(instance)
+    atts = instance.attributes
+    att_string = atts.sort.map { |k, v| [k,v].join(":") }.join(",")
+    generation = CityHash.hash64(att_string)
+    [model_prefix(instance.class), instance.id, generation].join("/")
+  end
+ 
+  # => "users/5821759535148822589/64/12126514016877773284/method"
+  def self.method_key(instance, method)
+    { type: :method,
+      key: [instance_prefix(instance), method].join("/") }
+  end
+
+  # => "users/5821759535148822589/64/12126514016877773284/association"
+  def self.association_key(instance, association)
+    { type: :association,
+      key: [instance_prefix(instance), association].join("/") }
+  end 
+end

data/lib/gen_cache/version.rb

@@ -0,0 +1,3 @@
+module GenerationCacheable
+  VERSION = "1.0.0"
+end

data/spec/gen_cache/cache_io/fetching_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe GenCache do
+	let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+  let(:user2) { User.create(:login => 'pathouse') }
+
+	describe "read" do 
+
+		it "should successfully read one key" do
+			user.cached_bad_iv_name!
+			key = GenCache.method_key(user, :bad_iv_name!)
+			GenCache.read_from_cache(key).should == 42
+		end
+
+		it "should successfully read multiple keys" do
+			User.find_cached(user.id)
+			User.find_cached(user2.id)
+
+			key_blobs = [GenCache.instance_key(user.class, user.id), 
+									 GenCache.instance_key(user2.class, user2.id)]
+			GenCache.read_multi_from_cache(key_blobs).should == {key_blobs[0][:key] => user, 
+																														key_blobs[1][:key] => user2}
+		end
+
+		it "should successfully write one key" do
+			key = GenCache.instance_key(user.class, user.id)
+			GenCache.write_to_cache(key, user)
+			Rails.cache.read(key[:key]).should == {:class => User, 'attributes' => user.attributes}
+		end
+
+		it "should successfully write multiple keys" do
+			keys = []
+			keys << GenCache.instance_key(user.class, user.id)
+			keys << GenCache.instance_key(user2.class, user2.id)
+			GenCache.write_multi_to_cache({keys[0] => user, keys[1] => user2})
+			Rails.cache.read_multi(*keys.map {|k| k[:key]}).should == {keys[0][:key] => {:class => User, 'attributes' => user.attributes},
+																																 keys[1][:key] => {:class => User, 'attributes' => user2.attributes}}
+		end
+	end
+end

data/spec/gen_cache/cache_io/formatting_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe GenCache do
+  let(:object)  { User.create(:login => 'flyerhzm') }
+  let(:fixnum) { 11 }
+  let(:string) { "string cheese" }
+  let(:hash) { {a: 1, b: 2, c: 3} }
+  let(:array) { ['a','b','c']}
+  let(:bool) { true }
+
+	context "methods" do
+
+		it "should symbolize args correctly" do
+			argsym = GenCache.symbolize_args([fixnum, string, hash, array])
+			argsym.should == "11+string_cheese+a:1,b:2,c:3+a,b,c".to_sym
+		end
+
+		it "should escape method name punctuation correctly" do
+			GenCache.escape_punctuation("holy_crap?").should == "holy_crap_query"
+			GenCache.escape_punctuation("holy_crap!").should == "holy_crap_bang"
+		end
+
+		it "should format objects correctly" do
+			GenCache.format_with_key(object, :object).should == { :class => object.class, 'attributes' => object.attributes}
+		end
+
+		it "should format multiple object correctly" do
+			coder = { :class => object.class, 'attributes' => object.attributes}
+			GenCache.format_with_key([object, object], :object).should == [coder, coder]
+		end
+
+		it "should format methods without arguments correctly" do
+			GenCache.format_with_key(fixnum, :method).should == 11
+		end
+
+		it "should format method with arguments correctly" do
+			arg1 = GenCache.symbolize_args([fixnum,string,hash])
+			arg2 = GenCache.symbolize_args([string,hash,fixnum])
+			to_be_formatted = { arg1 => object, 
+													arg2 => object}
+			formatted = GenCache.format_with_key(to_be_formatted, :method)
+			formatted[arg1].should == {:class => object.class, 'attributes' => object.attributes }
+			formatted[arg2].should == {:class => object.class, 'attributes' => object.attributes }
+			formatted[arg1].should_not == object
+			formatted[arg2].should_not == object
+		end
+
+		it "should format object correctly when returned from a method" do
+			arg1 = GenCache.symbolize_args([fixnum,string])
+			method_result = { arg1 => object }
+			GenCache.format_with_key(method_result, :method).should == { arg1 => {:class => object.class, 'attributes' => object.attributes} }
+		end
+	end
+end
+
+
+
+
+

data/spec/gen_cache/cache_io/parsing_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe GenCache do
+	let(:object)  { User.create(:login => 'flyerhzm') }
+	let(:coder) { {:class => object.class, 'attributes' => object.attributes} }
+  let(:fixnum) { 11 }
+  let(:string) { "string cheese" }
+  let(:hash) { {a: 1, b: 2, c: 3} }
+  let(:array) { ['a','b','c'] }
+  let(:bool) { true }
+
+  context "methods" do
+
+  	it "should correctly determine if a Hash is a coder" do
+  		GenCache.hash_inspect(hash).should be_false
+  		GenCache.hash_inspect(coder).should be_true
+  	end
+
+    it "should detect coders and coders in arrays" do
+      GenCache.detect_coder(coder).should be_true
+      GenCache.detect_coder([coder]).should be_true
+    end
+
+  	it "should correctly rebuild objects from coders" do
+  		GenCache.parse_with_key(coder, :object).should == object
+  	end
+
+  	it "should rebuild multiple objects" do
+      GenCache.parse_with_key([coder, coder], :object).should == [object, object]
+  	end
+
+  	it "should parse only the values of method results" do
+  		arg1 = GenCache.symbolize_args([string,hash])
+  		arg2 = GenCache.symbolize_args([array,bool])
+  		method_result = { arg1 => [coder],
+  											arg2 => string }
+      parsed = GenCache.parse_with_key(method_result, :method)
+      parsed[arg1].should == [object]
+      parsed[arg2].should == string
+  	end
+
+  	it "should correctly parse methods without arguments" do
+  		method_result = {"regular" => "hash"}
+      GenCache.parse_with_key(method_result, :method).should == method_result
+  	end
+  end
+end

data/spec/gen_cache/cache_types/association_cache_spec.rb

@@ -0,0 +1,313 @@
+require 'spec_helper'
+
+describe GenCache do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+  let(:user2)  { User.create(:login => 'ScotterC') }
+
+
+  before :all do
+    @post1 = user.posts.create(:title => 'post1')
+    @post2 = user.posts.create(:title => 'post2')
+    @post3 = Post.create
+    @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)
+    @location = @post1.create_location(city: "New York")
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "with_association" do
+    before :each do
+      @post1.instance_variable_set("@cached_user", nil)
+      @comment1.instance_variable_set("@cached_commentable", nil)
+    end
+
+    context "belongs_to" do
+      it "should not cache association" do
+        key = GenCache.association_key(@post1, :user)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache Post#user" do
+        @post1.cached_user.should == user
+        key = GenCache.association_key(@post1, :user)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(User, user.id)]
+      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
+        key = GenCache.association_key(@comment1, :commentable)
+        Rails.cache.read(key[:key]).should be_nil
+        @comment1.cached_commentable.should == @post1
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Post, @post1.id)]
+      end
+
+      it "should return nil if there are none" do
+        @post3.cached_user.should be_nil
+      end
+    end
+
+    context "has_many" do
+      it "should not cache associations" do
+        key = GenCache.association_key(user, :posts)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache User#posts" do
+        user.cached_posts.should == [@post1, @post2]
+        key = GenCache.association_key(user, :posts)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Post, @post1.id), 
+                                               GenCache.instance_key(Post, @post2.id)]
+      end
+
+      it "should cache User#posts multiple times" do
+        user.cached_posts
+        user.cached_posts.should == [@post1, @post2]
+      end
+
+      it "should return empty if there are none" do
+        user2.cached_posts.should == []
+      end
+    end
+
+    context "has_many with polymorphic" do
+      it "should not cache associations" do
+        key = GenCache.association_key(@post1, :comments)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache Post#comments" do
+        @post1.cached_comments.should == [@comment1, @comment2]
+        key = GenCache.association_key(@post1, :comments)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Comment, @comment1.id), 
+                                               GenCache.instance_key(Comment, @comment2.id)]
+      end
+
+      it "should cache Post#comments multiple times" do
+        @post1.cached_comments
+        @post1.cached_comments.should == [@comment1, @comment2]
+      end
+
+      it "should return empty if there are none" do
+        @post3.cached_comments.should == []
+      end
+    end
+
+    context "has_one" do
+      it "should not cache associations" do
+        key = GenCache.association_key(user, :account)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache User#posts" do
+        user.cached_account.should == @account
+        key = GenCache.association_key(user, :account)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Account, @account.id)]
+      end
+
+      it "should cache User#posts multiple times" do
+        user.cached_account
+        user.cached_account.should == @account
+      end
+
+      it "should return nil if there are none" do
+        user2.cached_account.should be_nil
+      end
+    end
+
+    context "has_many through" do
+      it "should not cache associations" do
+        key = GenCache.association_key(user, :images)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache User#images" do
+        user.cached_images.should == [@image1, @image2]
+        key = GenCache.association_key(user, :images)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Image, @image1.id), 
+                                               GenCache.instance_key(Image, @image2.id)]
+      end
+
+      it "should cache User#images multiple times" do
+        user.cached_images
+        user.cached_images.should == [@image1, @image2]
+      end
+
+      context "expiry" do
+        before :each do
+          user.instance_variable_set("@cached_images", nil)
+        end
+
+        it "should have the correct collection" do
+          @image3 = @post1.images.create
+          key = GenCache.association_key(user, :images)
+          Rails.cache.read(key[:key]).should be_nil
+          user.cached_images.should == [@image1, @image2, @image3]
+          Rails.cache.read(key[:key]).should == [GenCache.instance_key(Image, @image1.id), 
+                                                 GenCache.instance_key(Image, @image2.id), 
+                                                 GenCache.instance_key(Image, @image3.id)]
+        end
+      end
+
+      it "should return empty if there are none" do
+        user2.cached_images.should == []
+      end
+    end
+
+    context "has_one through belongs_to" do
+      it "should not cache associations" do
+        key = GenCache.association_key(user, :group)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache User#group" do
+        user.cached_group.should == @group1
+        key = GenCache.association_key(user, :group)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Group, @group1.id)]
+      end
+
+      it "should cache User#group multiple times" do
+        user.cached_group
+        user.cached_group.should == @group1
+      end
+
+      it "should return nil if there are none" do
+        user2.cached_group.should be_nil
+      end
+
+    end
+
+    context "has_and_belongs_to_many" do
+
+      it "should not cache associations off the bat" do
+        key = GenCache.association_key(@post1, :tags)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache Post#tags" do
+        @post1.cached_tags.should == [@tag1, @tag2]
+        key = GenCache.association_key(@post1, :tags)
+        Rails.cache.read(key[:key]).should == [GenCache.instance_key(Tag, @tag1.id),
+                                               GenCache.instance_key(Tag, @tag2.id)]
+      end
+
+      it "should handle multiple requests" do
+        @post1.cached_tags
+        @post1.cached_tags.should == [@tag1, @tag2]
+      end
+
+      it "should return empty if there are none" do
+        @post3.cached_tags.should == []
+      end
+
+      context "expiry" do
+        before :each do
+          @post1.instance_variable_set("@cached_tags", nil)
+        end
+
+        it "should have the correct collection" do
+          @tag3 = @post1.tags.create!(title: "Invalidation is hard")
+          key = GenCache.association_key(@post1, :tags)
+          Rails.cache.read(key[:key]).should be_nil
+          @post1.cached_tags.should == [@tag1, @tag2, @tag3]
+          Rails.cache.read(key[:key]).should == [GenCache.instance_key(Tag, @tag1.id),
+                                                 GenCache.instance_key(Tag, @tag2.id), 
+                                                 GenCache.instance_key(Tag, @tag3.id)]
+        end
+      end
+    end
+  end
+
+  describe "memoization" do
+    describe "belongs to" do
+      before :each do
+        @post1.instance_variable_set("@cached_user", nil)
+        @post1.update_attribute(:title, rand(10000).to_s)
+      end
+
+      it "memoizes cache calls" do
+        @post1.instance_variable_get("@cached_user").should be_nil
+        @post1.cached_user.should == @post1.user
+        @post1.instance_variable_get("@cached_user").should == @post1.user
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read).once
+        @post1.cached_user.should == @post1.user
+        @post1.cached_user.should == @post1.user
+      end
+    end
+
+    describe "has through" do
+      before :each do
+        user.instance_variable_set("@cached_images", nil)
+        user.update_attribute(:login, rand(10000).to_s)
+      end
+
+      it "memoizes cache calls" do
+        user.instance_variable_get("@cached_images").should be_nil
+        user.cached_images.should == user.images
+        user.instance_variable_get("@cached_images").should == user.images
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read)
+        user.cached_images.should == user.images
+        user.cached_images.should == user.images
+      end
+    end
+
+    describe "has and belongs to many" do
+      before :each do
+        @post1.instance_variable_set("@cached_tags", nil)
+        @post1.update_attribute(:title, rand(10000).to_s)
+      end
+
+      it "memoizes cache calls" do
+        @post1.instance_variable_get("@cached_tags").should be_nil
+        @post1.cached_tags.should == @post1.tags
+        @post1.instance_variable_get("@cached_tags").should == @post1.tags
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read)
+        @post1.cached_tags.should == @post1.tags
+        @post1.cached_tags.should == @post1.tags
+      end
+    end
+
+    describe "one to many" do
+      before :each do
+        user.instance_variable_set("@cached_posts", nil)
+        user.update_attribute(:login, rand(10000).to_s)
+      end
+
+      it "memoizes cache calls" do
+        user.instance_variable_get("@cached_posts").should be_nil
+        user.cached_posts.should == user.posts
+        user.instance_variable_get("@cached_posts").should == user.posts
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read)
+        user.cached_posts.should == user.posts
+        user.cached_posts.should == user.posts
+      end
+    end
+  end
+
+end