cache_cow 0.0.1

data/lib/cache_cow/cacheable.rb

@@ -0,0 +1,76 @@
+module CacheCow
+  module Cacheable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def fetch_cache(*args, &block)
+        options = args.extract_options!
+        keys    = args.flatten
+
+        # raise "Doesn't support multiget" unless keys.size == 1
+        Rails.cache.fetch cache_key(keys.first), &block
+      end
+
+      def read_cache(cache_id = nil, options = {})
+        Rails.cache.read cache_key(cache_id), options
+      end
+
+      def write_cache(cache_id, value, options = {})
+        Rails.cache.write cache_key(cache_id), value, { :expires_in => 1500 }.merge(options)
+      end
+
+      def expire_cache(cache_id = nil, options = {})
+        Rails.cache.delete cache_key(cache_id), options
+      end
+
+      def cached?(cache_id = nil)
+        Rails.cache.exist?(cache_key(cache_id))
+      end
+
+      def cache_key(cache_id)
+        [cache_name, acts_as_cached_version, cache_id].compact.join(':').gsub(' ', '_')[0..(max_key_length - 1)]
+      end
+
+      def cache_name
+        @cache_name ||= respond_to?(:base_class) ? base_class.name : name
+      end
+
+      def max_key_length
+        200
+      end
+
+    end
+
+    module InstanceMethods
+
+      def fetch_cache(key = nil, options = {}, &block)
+        self.class.fetch_cache cache_id(key), options, &block
+      end
+
+      def write_cache(key = nil, options = {})
+        self.class.write_cache cache_id(key), options
+      end
+
+      def read_cache(key = nil, options = {})
+        self.class.read_cache cache_id(key), options
+      end
+
+      def expire_cache(key = nil, options = {})
+        self.class.expire_cache cache_id(key), options
+      end
+
+      def cache_key(key = nil)
+        self.class.cache_key cache_id(key)
+      end
+
+      protected
+
+      def cache_id(key = nil)
+        key.nil? ? id.to_s : "#{id}:#{key}"
+      end
+
+    end
+
+  end
+end

data/lib/cache_cow/cached_id_list.rb

@@ -0,0 +1,46 @@
+module CacheCow
+  module CachedIdList
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # For example:
+      #
+      #   cached_id_list :groups, :accessor => :member_of?
+      def cached_id_list(association_name, options = {})
+        accessor_name = options[:accessor]
+        cache_key     = cached_id_list_cache_key(association_name)
+
+        define_method(cache_key) do
+          fetch_cache cache_key, :expires_in => 1.month do
+            send(association_name).select("id").map(&:id)
+          end
+        end
+
+        # if accessor_name
+        #   self.class_eval <<-RUBY
+        #     def #{accessor_name}(model_or_id)
+        #       return false if model_or_id.nil?
+        #       model_id = model_or_id.is_a?(Fixnum) ? model_or_id : model_or_id.id
+        #       #{cache_key}.include?(model_id)
+        #     end
+        #   RUBY
+        # end
+      end
+
+      def cached_id_list_cache_key(association_name)
+        "cached_" + association_name.to_s.singularize + "_ids"
+      end
+
+    end
+
+    module InstanceMethods
+      def expire_cached_id_list(association_name)
+        cache_key = self.class.cached_id_list_cache_key(association_name)
+        expire_cache cache_key
+        # instance_variable_set("@#{cache_key}", nil)
+        # instance_variable_set("@cached_#{association_name}", nil)
+      end
+    end
+
+  end
+end

data/lib/cache_cow/version.rb

@@ -0,0 +1,3 @@
+module CacheCow
+  VERSION = "0.0.1"
+end

data/lib/tasks/cache_cow_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :cache_cow do
+#   # Task goes here
+# end

data/spec/cache_cow/acts_as_cached_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe CacheCow::ActsAsCached do
+
+  it "should be a module" do
+    CacheCow::ActsAsCached.should be_kind_of(Module)
+  end
+end

data/spec/cache_cow/cacheable_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe CacheCow::Cacheable do
+
+  let(:cache_key) { "post:1" }
+
+  describe ".fetch_cache" do
+
+    it "returns nil if no block given and cache miss" do
+      Post.fetch_cache(cache_key).should be_nil
+    end
+
+    it "writes through value from block on read" do
+      Post.fetch_cache(cache_key) { "great post" }
+      Post.fetch_cache(cache_key).should == "great post"
+    end
+
+    it "should be accessible from Rails.cache via class cache key" do
+      Rails.cache.read(Post.cache_key(cache_key)).should be_nil
+      Post.fetch_cache(cache_key) { "great post" }
+      Rails.cache.read(Post.cache_key(cache_key)).should == "great post"
+    end
+
+  end
+
+  describe ".read_cache" do
+    it "should read value if cache hit" do
+      Post.fetch_cache(cache_key) { "great post" }
+      Post.read_cache(cache_key).should == "great post"
+    end
+
+    it "should return nil if cache miss" do
+      Post.read_cache(cache_key).should be_nil
+    end
+  end
+
+  describe ".write_cache" do
+    it "should write value" do
+      Post.write_cache(cache_key, "great post")
+      Post.read_cache(cache_key).should == "great post"
+    end
+  end
+
+  describe ".expire_cache" do
+    it "should delete cached value" do
+      Post.write_cache(cache_key, "great post")
+      Post.expire_cache(cache_key)
+      Post.read_cache(cache_key).should be_nil
+    end
+  end
+
+  describe ".cached?" do
+    it "should return true if cache hit" do
+      Post.write_cache(cache_key, "great post")
+      Post.cached?(cache_key).should be_true
+    end
+
+    it "should return false if cache miss" do
+      Post.cached?(cache_key).should be_false
+    end
+  end
+
+  describe ".cache_key" do
+
+    it "should namespace cache_key to class:version:cache_key" do
+      Post.cache_key(cache_key).should == "Post:1:post:1"
+    end
+
+    it "should namespace subclass to base class name" do
+      BlogPost.cache_key(cache_key).should == "Post:1:post:1"
+    end
+
+  end
+
+  describe "instance_methods" do
+    let(:post) { stub_model(Post) }
+
+    describe "#fetch_cache" do
+
+      it "should write through value on read" do
+        post.fetch_cache(cache_key).should be_nil
+        post.fetch_cache(cache_key) { "great post" }
+        post.fetch_cache(cache_key).should == "great post"
+      end
+
+      it "should use id as default cache_key if none given" do
+        post.fetch_cache { "another great post" }
+        Rails.cache.read(Post.cache_key(post.id)).should == "another great post"
+      end
+
+      it "should store value under key namespaced by class and id" do
+        post.fetch_cache(cache_key) { "a third great post" }
+        Rails.cache.read(post.cache_key(cache_key)).should == "a third great post"
+      end
+
+      describe "options" do
+        it ":force => true forces cache miss" do
+          post.fetch_cache { "another great post" }
+          post.fetch_cache(cache_key, :force => true).should be_nil
+        end
+      end
+
+      # spec for :compress
+      # spec for :expires_in
+    end
+
+    describe "#write_cache" do
+      it "should write to key for instance" do
+        post.write_cache("foo", "bar")
+        post.read_cache("foo").should == "bar"
+      end
+
+      it "should not write to another instance key" do
+        post.write_cache("foo", "bar")
+        stub_model(Post).read_cache("foo").should be_nil
+      end
+    end
+
+    describe "#read_cache" do
+      it "should read key for instance" do
+        post.write_cache("foo", "bar")
+        post.read_cache("foo").should == "bar"
+      end
+
+      it "should not read key for another instance" do
+        stub_model(Post).write_cache("foo", "bar")
+        post.read_cache("foo").should be_nil
+      end
+    end
+
+    describe "#expire_cache" do
+      it "should expire key for instance" do
+        post.write_cache("foo", "bar")
+        post.read_cache("foo").should == "bar"
+        post.expire_cache("foo")
+        post.read_cache("foo").should be_nil
+      end
+    end
+
+    describe "#cache_key" do
+      it "should namespace key by its id" do
+        post.cache_key("cache_key").should == "Post:1:#{post.id}:cache_key"
+      end
+    end
+  end
+
+  # describe "get_multi" do
+  #   it "should do a rails multiget with all the keys" do
+  #     Rails.cache.should_receive(:read_multi).with(*[User.cache_key("a"), User.cache_key("b")])
+  #     User.get_multi(["a", "b"]) {}
+  #   end
+  #
+  #   it "should yield to a multiget object that passes along the appropriate options" do
+  #     Rails.cache.should_receive(:read).with(User.cache_key("a"), :expires_in => '500').and_return("")
+  #     User.get_multi(["a"]) do |multi|
+  #       multi.fetch_cache("a", :expires_in => '500')
+  #     end
+  #   end
+  # end
+
+end

data/spec/cache_cow/cached_id_list_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe CacheCow::CachedIdList do
+
+  let(:post) { Factory(:post) }
+  let(:comment) { Factory(:comment) }
+
+  describe ".cached_id_list" do
+
+    describe "comments" do
+      before(:each) do
+        post.comments << comment
+        post.save!
+      end
+
+      it "should return ids by association" do
+        post.cached_comment_ids.should == post.comment_ids
+      end
+
+      it "should write data to rails cache" do
+        post.cached_comment_ids # set cache
+        Rails.cache.read(post.cache_key("cached_comment_ids")).should == post.comment_ids
+      end
+
+      it "should return [] if no comments" do
+        Factory(:post).cached_comment_ids.should == []
+      end
+    end
+
+
+    describe "blog_comments" do
+      it "should return ids by subclass association" do
+        comment_1 = Factory(:blog_comment)
+        comment_2 = Factory(:blog_comment)
+        post      = Factory(:blog_post)
+        post.comments << comment_1
+        post.comments << comment_2
+        post.save!
+        post.cached_comment_ids.should == post.comment_ids
+      end
+    end
+  end
+
+  describe "#expire_cached_id_list" do
+    it "should expire list of cached ids from given association name" do
+      post.comments << comment
+      post.cached_comment_ids # set cache
+
+      post.expire_cached_id_list(:comments)
+
+      Rails.cache.read(post.cache_key("cached_comment_ids")).should be_nil
+    end
+  end
+end

data/spec/cache_cow_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe CacheCow do
+  
+  it "should be a module" do
+    CacheCow.should be_kind_of(Module)
+  end
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,9 @@
+// This is a manifest file that'll be compiled into including all the files listed below.
+// Add new JavaScript/Coffee code in separate files in this directory and they'll automatically
+// be included in the compiled file accessible from http://example.com/assets/application.js
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require_self
+ *= require_tree . 
+*/

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/models/blog_comment.rb

@@ -0,0 +1,2 @@
+class BlogComment < Comment
+end

data/spec/dummy/app/models/blog_post.rb

@@ -0,0 +1,2 @@
+class BlogPost < Post
+end

data/spec/dummy/app/models/comment.rb

@@ -0,0 +1,2 @@
+class Comment < ActiveRecord::Base
+end

data/spec/dummy/app/models/post.rb

@@ -0,0 +1,6 @@
+class Post < ActiveRecord::Base
+  acts_as_cached
+
+  has_many :comments
+  cached_id_list :comments
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>