simple_cacheable 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--format nested
+--color

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm_gemset_create_on_use_flag=1
+rvm gemset use cacheable

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cacheable.gemspec
+gemspec

data/README.md

@@ -0,0 +1,51 @@
+cacheable
+=========
+
+cacheable is a simple cache implementation based on activerecord, it is
+extracted from [rails-bestpractices.com][1].
+
+it supports activerecord >= 3.0.0
+
+Usage
+-----
+
+    class User < ActiveRecord::Base
+      include Cacheable
+
+      has_many :posts
+
+      model_cache do
+        with_key                   # User.find_cached(1)
+        with_attribute :login      # User.find_by_login('flyerhzm')
+        with_method :last_post     # user.cached_last_post
+      end
+
+      def last_post
+        posts.last
+      end
+    end
+
+    class Post < ActiveRecord::Base
+      include Cacheable
+
+      belongs_to :user
+      has_many :comments, :as => :commentable
+
+      model_cache do
+        with_key                   # post.find_cached(1)
+        with_association :user     # post.cached_user
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      include Cacheable
+
+      belongs_to :commentable, :polymorphic => true
+
+      model_cache do
+        with_association :commentable  # comment.cached_commentable
+      end
+    end
+
+
+[1]:https://github.com/flyerhzm/rails-bestpractices.com

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/cacheable.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cacheable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_cacheable"
+  s.version     = Cacheable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Richard Huang"]
+  s.email       = ["flyerhzm@gmail.com"]
+  s.homepage    = "https://github.com/flyerhzm/simple-cacheable"
+  s.summary     = %q{a simple cache implementation based on activerecord}
+  s.description = %q{a simple cache implementation based on activerecord}
+
+  s.add_dependency("rails", ">= 3.0.0")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("mocha")
+  s.add_development_dependency("sqlite3-ruby")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/cacheable/version.rb

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

data/lib/cacheable.rb

@@ -0,0 +1,125 @@
+module Cacheable
+  def self.included(base)
+    base.class_eval do
+      class <<self
+        def model_cache(&block)
+          instance_exec &block
+        end
+
+        def with_key
+          class_eval <<-EOF
+            after_update :expire_key_cache
+
+            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)
+          class_eval <<-EOF
+            after_update :expire_attribute_cache
+          EOF
+
+          write_inheritable_attribute :cached_indices, attributes.inject({}) { |indices, attribute| indices[attribute] = {} }
+          attributes.each do |attribute|
+            class_eval <<-EOF
+              def self.find_cached_by_#{attribute}(value)
+                indices = read_inheritable_attribute :cached_indices
+                indices["#{attribute}"] ||= []
+                indices["#{attribute}"] << value
+                write_inheritable_attribute :cached_indices, indices
+                Rails.cache.fetch attribute_cache_key("#{attribute}", value) do
+                  self.find_by_#{attribute}(value)
+                end
+              end
+            EOF
+          end
+        end
+
+        def with_method(*methods)
+          class_eval <<-EOF
+            after_update :expire_method_cache
+          EOF
+
+          write_inheritable_attribute :cached_methods, methods
+          methods.each do |meth|
+            class_eval <<-EOF
+              def cached_#{meth}
+                Rails.cache.fetch method_cache_key("#{meth}") do
+                  #{meth}
+                end
+              end
+            EOF
+          end
+        end
+
+        def with_association(*association_names)
+          association_names.each do |association_name|
+            association = reflect_on_association(association_name)
+            if :belongs_to == association.macro
+              polymorphic = association.options[:polymorphic]
+              class_eval <<-EOF
+                def cached_#{association_name}
+                  Rails.cache.fetch association_cache_key("#{association_name}", #{polymorphic}) do
+                    #{association_name}
+                  end
+                end
+              EOF
+            end
+          end
+        end
+
+        def attribute_cache_key(attribute, value)
+          "#{name.tableize}/attribute/#{attribute}/#{value}"
+        end
+      end
+    end
+  end
+
+  def expire_model_cache
+    expire_key_cache
+    expire_attribute_cache
+    expire_method_cache
+  end
+
+  def expire_key_cache
+    Rails.cache.delete model_cache_key
+  end
+
+  def expire_attribute_cache
+    if indices = self.class.read_inheritable_attribute(:cached_indices)
+      indices.each do |attribute, values|
+        values.each do |value|
+          Rails.cache.delete self.class.attribute_cache_key(attribute, value)
+        end
+      end
+    end
+  end
+
+  def expire_method_cache
+    if meths = self.class.read_inheritable_attribute(:cached_methods)
+      meths.each do |meth|
+        Rails.cache.delete method_cache_key(meth)
+      end
+    end
+  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 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
+end

data/spec/cacheable_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Cacheable do
+  let(:cache) { Rails.cache }
+
+  before :all do
+    @user = User.create(:login => 'flyerhzm')
+    @post1 = @user.posts.create(:title => 'post1')
+    @post2 = @user.posts.create(:title => 'post2')
+    @comment1 = @post1.comments.create
+    @comment2 = @post2.comments.create
+  end
+
+  after :each do
+    cache.clear
+  end
+
+  context "with_key" do
+    it "should not cache key" do
+      cache.data["users/#{@user.id}"].should be_nil
+    end
+
+    it "should cache by User#id" do
+      User.find_cached(@user.id).should == @user
+      cache.data["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
+
+  context "with_attribute" do
+    it "should not cache User.find_by_login" do
+      cache.data["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
+      cache.data["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
+  end
+
+  context "with_method" do
+    it "should not cache User.last_post" do
+      cache.data["users/#{@user.id}/method/last_post"].should be_nil
+    end
+
+    it "should cache User#last_post" do
+      @user.cached_last_post.should == @user.last_post
+      cache.data["users/#{@user.id}/method/last_post"].should == @user.last_post
+    end
+
+    it "should cache User#last_post multiple times" do
+      @user.cached_last_post
+      @user.cached_last_post.should == @user.last_post
+    end
+  end
+
+  context "with_association" do
+    it "should not cache association" do
+      cache.data["users/#{@user.id}"].should be_nil
+    end
+
+    it "should cache Post#user" do
+      @post1.cached_user.should == @user
+      cache.data["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
+      cache.data["posts/#{@post1.id}"].should be_nil
+      @comment1.cached_commentable.should == @post1
+      cache.data["posts/#{@post1.id}"].should == @post1
+    end
+  end
+
+  context "expire_model_cache" do
+    it "should delete with_key cache" do
+      user = User.find_cached(@user.id)
+      cache.data["users/#{user.id}"].should_not be_nil
+      user.expire_model_cache
+      cache.data["users/#{user.id}"].should be_nil
+    end
+
+    it "should delete with_attribute cache" do
+      user = User.find_cached_by_login("flyerhzm")
+      cache.data["users/attribute/login/flyerhzm"].should == @user
+      @user.expire_model_cache
+      cache.data["users/attribute/login/flyerhzm"].should be_nil
+    end
+
+    it "should delete with_method cache" do
+      @user.cached_last_post
+      cache.data["users/#{@user.id}/method/last_post"].should_not be_nil
+      @user.expire_model_cache
+      cache.data["users/#{@user.id}/method/last_post"].should be_nil
+    end
+  end
+end

data/spec/models/comment.rb

@@ -0,0 +1,9 @@
+class Comment < ActiveRecord::Base
+  include Cacheable
+
+  belongs_to :commentable, :polymorphic => true
+
+  model_cache do
+    with_association :commentable
+  end
+end

data/spec/models/post.rb

@@ -0,0 +1,11 @@
+class Post < ActiveRecord::Base
+  include Cacheable
+
+  belongs_to :user
+  has_many :comments, :as => :commentable
+
+  model_cache do
+    with_key
+    with_association :user
+  end
+end

data/spec/models/user.rb

@@ -0,0 +1,15 @@
+class User < ActiveRecord::Base
+  include Cacheable
+
+  has_many :posts
+
+  model_cache do
+    with_key
+    with_attribute :login
+    with_method :last_post
+  end
+
+  def last_post
+    posts.last
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,85 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'rails'
+require 'active_record'
+require 'rspec'
+require 'mocha'
+
+require 'cacheable'
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+MODELS = File.join(File.dirname(__FILE__), "models")
+$LOAD_PATH.unshift(MODELS)
+
+Dir[ File.join(MODELS, "*.rb") ].sort.each { |file| require File.basename(file) }
+
+class TestCache
+  attr_reader :data
+
+  def initialize
+    @data = {}
+  end
+
+  def fetch(key, &block)
+    if read(key)
+      read(key)
+    else
+      write(key, block.call)
+    end
+  end
+
+  def read(key)
+    @data[key]
+  end
+
+  def write(key, value)
+    @data[key] = value
+  end
+
+  def delete(key)
+    @data.delete key
+  end
+
+  def clear
+    @data.clear
+  end
+end
+
+module Rails
+  class <<self
+    def cache
+      @cache ||= TestCache.new
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  config.before :all do
+    ::ActiveRecord::Schema.define(:version => 1) do
+      create_table :users do |t|
+        t.string :login
+      end
+
+      create_table :posts do |t|
+        t.integer :user_id
+        t.string :title
+      end
+
+      create_table :comments do |t|
+        t.integer :commentable_id
+        t.string :commentable_type
+      end
+    end
+  end
+
+  config.after :all do
+    ::ActiveRecord::Base.connection.tables.each do |table|
+      ::ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: simple_cacheable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Richard Huang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-05 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: a simple cache implementation based on activerecord
+email: 
+- flyerhzm@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- cacheable.gemspec
+- lib/cacheable.rb
+- lib/cacheable/version.rb
+- spec/cacheable_spec.rb
+- spec/models/comment.rb
+- spec/models/post.rb
+- spec/models/user.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/flyerhzm/simple-cacheable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: a simple cache implementation based on activerecord
+test_files: 
+- spec/cacheable_spec.rb
+- spec/models/comment.rb
+- spec/models/post.rb
+- spec/models/user.rb
+- spec/spec_helper.rb