second_level_cache 1.3.2

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle
+/nbproject/*
+/Gemfile.lock
+/.rvmrc
+/doc
+/pkg
+/tags
+/spec/log
+*.log
+*.gem
+*.sqlite3
+*.swp
+*.swo
+

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+1.2.0
+-----
+* [clear cache after update_counters](https://github.com/csdn-dev/second_level_cache/commit/240dde81199124092e0e8ad0500c167ac146e301)
+
+1.2.1
+-----
+* [fix polymorphic association bug]
+
+1.3.0
+-----
+* [clean cache after touch]
+
+1.3.1
+-----
+* [clean cache after update_column/increment!/decrement!]
+
+1.3.2
+-----
+* [fix has one assciation issue]

data/Gemfile

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

data/README.md

@@ -0,0 +1,71 @@
+# SecondLevelCache
+
+SecondLevelCache is a write-through and read-through caching library inspired by Cache Money and cache_fu, support only Rails3 and ActiveRecord.
+
+Read-Through: Queries by ID, like `current_user.articles.find(params[:id])`, will first look in cache store and then look in the database for the results of that query. If there is a cache miss, it will populate the cache.
+
+Write-Through: As objects are created, updated, and deleted, all of the caches are automatically kept up-to-date and coherent.
+
+## Risk
+
+SecondLevelCache is not fully test and verify in production enviroment right now. Use it at your own risk.
+
+## Install
+
+In your gem file:
+
+```ruby
+gem "second_level_cache", :git => "git://github.com/csdn-dev/second_level_cache.git"
+```
+
+## Usage
+
+For example, cache User objects:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_cached
+end
+```
+
+Then it will fetch cached object in this situations:
+
+```ruby
+User.find(1)
+User.find_by_id(1)
+User.find_by_id!(1)
+User.find_by_id_and_name(1, "Hooopo")
+User.where(:status => 1).find_by_id(1)
+user.articles.find_by_id(1)
+user.articles.find(1), user.where(:status => 1).find(1)
+article.user
+```
+
+Cache key:
+
+```ruby
+user = User.find 1
+user.second_level_cache_key  # We will get the key looks like "slc/user/1"
+```
+
+Notice:
+
+* SecondLevelCache cache by model name and id, so only find_one query will work.
+* only equal conditions query WILL get cache; and SQL string query like `User.where("name = 'Hooopo'").find(1)` WILL NOT work.
+
+## configure
+
+cache_store: Default is Rails.cache  
+logger: Default is Rails.logger  
+cache_key_prefix: Avoid cache key conflict with other application, Default is 'slc'  
+
+You can config like this:
+
+```ruby
+# config/initializers/second_level_cache.rb
+SecondLevelCache.configure do |config|
+  config.cache_store = ActiveSupport::Cache::MemoryStore.new
+  config.logger = Logger.new($stdout)
+  config.cache_key_prefix = 'domain'
+end
+```

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "lib" << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+end

data/init.rb

@@ -0,0 +1,2 @@
+# -*- encoding : utf-8 -*-
+require File.expand_path("../lib/second_level_cache", __FILE__)

data/lib/second_level_cache/active_record/base.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+module SecondLevelCache
+  module ActiveRecord
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        after_destroy :expire_second_level_cache
+        after_save :write_second_level_cache
+
+        class << self
+          alias_method_chain :update_counters, :cache
+        end
+      end
+
+
+      module ClassMethods
+        def update_counters_with_cache(id, counters)
+          Array(id).each{|i| expire_second_level_cache(i)}
+          update_counters_without_cache(id, counters)
+        end
+      end
+    end
+  end
+end

data/lib/second_level_cache/active_record/belongs_to_association.rb

@@ -0,0 +1,30 @@
+# -*- encoding : utf-8 -*-
+module SecondLevelCache
+  module ActiveRecord
+    module Associations
+      module BelongsToAssociation
+        extend ActiveSupport::Concern
+        included do
+          class_eval do
+            alias_method_chain :find_target, :second_level_cache
+          end
+        end
+
+        def find_target_with_second_level_cache
+          return find_target_without_second_level_cache unless klass.second_level_cache_enabled?
+          cache_record = klass.read_second_level_cache(second_level_cache_key)
+          return cache_record.tap{|record| set_inverse_instance(record)} if cache_record
+          record = find_target_without_second_level_cache
+          record.write_second_level_cache
+          record
+        end
+
+        private
+
+        def second_level_cache_key
+          owner[reflection.foreign_key]
+        end
+      end
+    end
+  end
+end

data/lib/second_level_cache/active_record/finder_methods.rb

@@ -0,0 +1,109 @@
+# -*- encoding : utf-8 -*-
+require 'second_level_cache/arel/wheres'
+
+module SecondLevelCache
+  module ActiveRecord
+    module FinderMethods
+      extend ActiveSupport::Concern
+
+      included do
+        class_eval do
+          alias_method_chain :find_one, :second_level_cache
+          alias_method_chain :find_by_attributes, :second_level_cache
+        end
+      end
+
+      # TODO fetch multi ids
+      #
+      # Cacheable:
+      #
+      #     current_user.articles.where(:status => 1).visiable.find(params[:id])
+      #
+      # Uncacheable:
+      #
+      #     Article.where("user_id = '1'").find(params[:id])
+      #     Article.where("user_id > 1").find(params[:id])
+      #     Article.where("articles.user_id = 1").find(prams[:id])
+      #     Article.where("user_id = 1 AND ...").find(params[:id])
+      def find_one_with_second_level_cache(id)
+        return find_one_without_second_level_cache(id) unless second_level_cache_enabled?
+
+        id = id.id if ActiveRecord::Base === id
+        if ::ActiveRecord::IdentityMap.enabled? && cachable? && record = from_identity_map(id)
+          return record
+        end
+
+        if cachable?
+          return record if record = @klass.read_second_level_cache(id)
+        end
+
+        if cachable_without_conditions?
+          if record = @klass.read_second_level_cache(id)
+            return record if where_match_with_cache?(where_values, record)
+          end
+        end
+
+        record = find_one_without_second_level_cache(id)
+        record.write_second_level_cache
+        record
+      end
+
+      # TODO cache find_or_create_by_id
+      def find_by_attributes_with_second_level_cache(match, attributes, *args)
+        return find_by_attributes_without_second_level_cache(match, attributes, *args) unless second_level_cache_enabled?
+
+        conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
+
+        if conditions.has_key?("id")
+          result = wrap_bang(match.bang?) do
+            if conditions.size == 1
+              find_one_with_second_level_cache(conditions["id"])
+            else
+              where(conditions.except("id")).find_one_with_second_level_cache(conditions["id"])
+            end
+          end
+          yield(result) if block_given? #edge rails do this bug rails3.1.0 not
+
+          return result
+        end
+
+        find_by_attributes_without_second_level_cache(match, attributes, *args)
+      end
+
+      private
+
+      def wrap_bang(bang)
+        bang ? yield : (yield rescue nil)
+      end
+
+      def cachable?
+        where_values.blank? &&
+          limit_one? && order_values.blank? &&
+          includes_values.blank? && preload_values.blank? &&
+          readonly_value.nil? && joins_values.blank? && !@klass.locking_enabled?
+      end
+
+      def cachable_without_conditions?
+        limit_one? && order_values.blank? &&
+          includes_values.blank? && preload_values.blank? &&
+          readonly_value.nil? && joins_values.blank? && !@klass.locking_enabled?
+      end
+
+      def where_match_with_cache?(where_values, cache_record)
+        condition = SecondLevelCache::Arel::Wheres.new(where_values)
+        return false unless condition.all_equality?
+        condition.extract_pairs.all? do |pair|
+          cache_record.read_attribute(pair[:left]) == pair[:right]
+        end
+      end
+
+      def limit_one?
+        limit_value.blank? || limit_value == 1
+      end
+
+      def from_identity_map(id)
+        ::ActiveRecord::IdentityMap.get(@klass, id)
+      end
+    end
+  end
+end

data/lib/second_level_cache/active_record/persistence.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+module SecondLevelCache
+  module ActiveRecord
+    module Persistence
+      extend ActiveSupport::Concern
+
+      included do
+        class_eval do
+          alias_method_chain :reload, :second_level_cache
+          alias_method_chain :touch, :second_level_cache
+          alias_method_chain :update_column, :second_level_cache
+        end
+      end
+
+      def update_column_with_second_level_cache(name, value)
+        expire_second_level_cache
+        update_column_without_second_level_cache(name, value)
+      end
+
+      def reload_with_second_level_cache(options = nil)
+        expire_second_level_cache
+        reload_without_second_level_cache(options)
+      end
+
+      def touch_with_second_level_cache(name = nil)
+        expire_second_level_cache
+        touch_without_second_level_cache(name)
+      end
+    end
+  end
+end

data/lib/second_level_cache/active_record.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+require 'second_level_cache/active_record/base'
+require 'second_level_cache/active_record/finder_methods'
+require 'second_level_cache/active_record/persistence'
+require 'second_level_cache/active_record/belongs_to_association'
+
+ActiveRecord::Base.send(:include, SecondLevelCache::Mixin)
+ActiveRecord::Base.send(:include, SecondLevelCache::ActiveRecord::Base)
+ActiveRecord::FinderMethods.send(:include, SecondLevelCache::ActiveRecord::FinderMethods)
+ActiveRecord::Base.send(:include, SecondLevelCache::ActiveRecord::Persistence)
+ActiveRecord::Associations::BelongsToAssociation.send(:include, SecondLevelCache::ActiveRecord::Associations::BelongsToAssociation)

data/lib/second_level_cache/arel/wheres.rb

@@ -0,0 +1,35 @@
+# -*- encoding : utf-8 -*-
+module SecondLevelCache
+  module Arel
+    class Wheres
+      attr_reader :where_values
+
+      def initialize(where_values)
+        @where_values = where_values
+      end
+
+      # Determine whether all conditions is equality, for example:
+      #
+      #     Article.where("user_id = 1").where(:status => 1).find(1)
+      def all_equality?
+        where_values.all?{|where_value| where_value.is_a?(::Arel::Nodes::Equality)}
+      end
+
+      # Extract conditions to pairs, for checking whether cache match the conditions.
+      def extract_pairs
+        where_values.map do |where_value|
+          if where_value.is_a?(String)
+            left, right = where_value.split(/\s*=\s*/, 2)
+            right = right.to_i
+          else
+            left, right = where_value.left.name, where_value.right
+          end
+          {
+            :left  => left,
+            :right => right
+          }
+        end
+      end
+    end
+  end
+end

data/lib/second_level_cache/config.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+module SecondLevelCache
+  module Config
+    extend self
+
+    attr_accessor :cache_store, :logger, :cache_key_prefix
+
+    def cache_store
+      @cache_store ||= Rails.cache if defined?(Rails)
+      @cache_store
+    end
+
+    def logger
+      @logger ||= Rails.logger if defined?(Rails)
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def cache_key_prefix
+      @cache_key_prefix ||= 'slc'
+    end
+  end
+end

data/lib/second_level_cache/marshal.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module Marshal
+  class << self
+    def load_with_constantize(value)
+      begin
+        Marshal.load_without_constantize value
+      rescue ArgumentError => e
+        _, class_name = *(/undefined class\/module (\w+)/.match(e.message))
+        raise if !class_name
+        class_name.constantize
+        Marshal.load value
+      end
+    end
+    alias_method_chain :load, :constantize
+  end
+end

data/lib/second_level_cache/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+module SecondLevelCache 
+  VERSION = "1.3.2"
+end

data/lib/second_level_cache.rb

@@ -0,0 +1,70 @@
+# -*- encoding : utf-8 -*-
+require 'active_support/all'
+require 'second_level_cache/config'
+require 'second_level_cache/marshal'
+
+module SecondLevelCache
+  def self.configure
+    block_given? ? yield(Config) : Config
+  end
+
+  class << self
+    delegate :logger, :cache_store, :cache_key_prefix, :to => Config
+  end
+
+  module Mixin
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_reader :second_level_cache_options
+
+      def acts_as_cached(options = {})
+        @second_level_cache_enabled = true
+        @second_level_cache_options = options
+        @second_level_cache_options[:expires_in] ||= 1.day
+      end
+
+      def second_level_cache_enabled?
+        !!@second_level_cache_enabled
+      end
+
+      def cache_store
+        Config.cache_store
+      end
+
+      def logger
+        Config.logger
+      end
+
+      def cache_key_prefix
+        Config.cache_key_prefix
+      end
+
+      def second_level_cache_key(id)
+        "#{cache_key_prefix}/#{name.downcase}/#{id}"
+      end
+
+      def read_second_level_cache(id)
+        SecondLevelCache.cache_store.read(second_level_cache_key(id)) if self.second_level_cache_enabled?
+      end
+
+      def expire_second_level_cache(id)
+        SecondLevelCache.cache_store.delete(second_level_cache_key(id)) if self.second_level_cache_enabled?
+      end
+    end
+
+    def second_level_cache_key
+      self.class.second_level_cache_key(id)
+    end
+
+    def expire_second_level_cache
+      SecondLevelCache.cache_store.delete(second_level_cache_key) if self.class.second_level_cache_enabled?
+    end
+
+    def write_second_level_cache
+      SecondLevelCache.cache_store.write(second_level_cache_key, self, self.class.second_level_cache_options) if self.class.second_level_cache_enabled?
+    end
+  end
+end
+
+require 'second_level_cache/active_record' if defined?(ActiveRecord)

data/second_level_cache.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/second_level_cache/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["wangxz"]
+  gem.email         = ["wangxz@csdn.net"]
+  gem.description   = %q{Write Through and Read Through caching library inspired by CacheMoney and cache_fu, support only Rails3 and ActiveRecord.}
+  gem.summary       = <<-SUMMARY
+  SecondLevelCache is a write-through and read-through caching library inspired by Cache Money and cache_fu, support only Rails3 and ActiveRecord.
+
+  Read-Through: Queries by ID, like current_user.articles.find(params[:id]), will first look in cache store and then look in the database for the results of that query. If there is a cache miss, it will populate the cache.
+
+  Write-Through: As objects are created, updated, and deleted, all of the caches are automatically kept up-to-date and coherent.
+  SUMMARY
+
+  gem.homepage      = "https://github.com/csdn-dev/second_level_cache"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "second_level_cache"
+  gem.require_paths = ["lib"]
+  gem.version       = SecondLevelCache::VERSION
+
+  gem.add_runtime_dependency "activesupport", ["~> 3.2.0"]
+
+  gem.add_development_dependency "activerecord", ["~> 3.2.0"]
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "rake"
+end

data/test/active_record/base_test.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+require 'active_record/test_helper'
+
+class ActiveRecord::BaseTest < Test::Unit::TestCase
+  def setup
+    @user = User.create :name => 'csdn', :email => 'test@csdn.com'
+  end
+
+  def test_should_have_cache_when_create
+    no_connection do
+      assert_not_nil User.read_second_level_cache(@user.id)
+      assert_equal @user, User.find(@user.id)
+    end
+  end
+
+  def test_should_update_cache_when_update
+    @user.update_attributes :name => 'change'
+
+    no_connection do
+      assert_equal 'change', User.find(@user.id).name
+    end
+  end
+
+  def test_should_expire_cache_when_destroy
+    @user.destroy
+    assert_nil User.read_second_level_cache(@user.id)
+  end
+
+  def test_should_expire_cache_when_update_counters
+    assert_equal @user.books_count, 0
+    @user.books.create
+    assert_nil User.read_second_level_cache(@user.id)
+    user = User.find(@user.id)
+    assert_equal user.books_count, @user.books_count + 1
+  end
+end

data/test/active_record/belongs_to_association_test.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+require 'active_record/test_helper'
+
+class ActiveRecord::BelongsToAssociationTest < Test::Unit::TestCase
+  def setup
+    @user = User.create :name => 'csdn', :email => 'test@csdn.com'
+  end
+
+  def test_should_get_cache_when_use_belongs_to_association
+    book = @user.books.create
+
+    no_connection do
+      assert_equal @user, book.user
+    end
+  end
+
+  def test_should_write_belongs_to_association_cache
+    book = @user.books.create
+    @user.expire_second_level_cache
+    assert_nil User.read_second_level_cache(@user.id)
+    assert_equal @user, book.user
+    # assert_not_nil User.read_second_level_cache(@user.id)
+  end
+end

data/test/active_record/finder_methods_test.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+require 'active_record/test_helper'
+
+class ActiveRecord::FinderMethodsTest < Test::Unit::TestCase
+  def setup
+    @user = User.create :name => 'csdn', :email => 'test@csdn.com'
+  end
+
+  def test_should_find_without_cache
+    SecondLevelCache.cache_store.clear
+    assert_equal @user, User.find(@user.id)
+  end
+
+  def test_should_find_with_cache
+    no_connection do
+      assert_equal @user, User.find(@user.id)
+    end
+  end
+
+  def test_should_find_with_condition
+    no_connection do
+      assert_equal @user, User.where(:name => @user.name).find(@user.id)
+    end
+  end
+end

data/test/active_record/model/book.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+ActiveRecord::Base.connection.create_table(:books, :force => true) do |t|
+  t.string  :title
+  t.string  :body
+  t.integer :user_id
+  t.integer :images_count, :default => 0
+end
+
+class Book < ActiveRecord::Base
+  acts_as_cached
+
+  belongs_to :user, :counter_cache => true
+  has_many :images, :as => :imagable
+end

data/test/active_record/model/image.rb

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+ActiveRecord::Base.connection.create_table(:images, :force => true) do |t|
+  t.string  :url
+  t.string  :imagable_type
+  t.integer :imagable_id
+end
+
+class Image < ActiveRecord::Base
+  acts_as_cached
+
+  belongs_to :imagable, :polymorphic => true, :counter_cache => true
+end
+

data/test/active_record/model/post.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+ActiveRecord::Base.connection.create_table(:posts, :force => true) do |t|
+  t.text  :body
+  t.integer :topic_id
+end
+
+class Post < ActiveRecord::Base
+  acts_as_cached
+  belongs_to :topic, :touch => true
+end

data/test/active_record/model/topic.rb

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+ActiveRecord::Base.connection.create_table(:topics, :force => true) do |t|
+  t.string  :title
+  t.text  :body
+
+  t.timestamps
+end
+
+class Topic < ActiveRecord::Base
+  acts_as_cached
+
+  has_many :posts
+end

data/test/active_record/model/user.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+ActiveRecord::Base.connection.create_table(:users, :force => true) do |t|
+  t.string  :name
+  t.string  :email
+  t.integer :books_count, :default => 0
+  t.integer :images_count, :default => 0
+end
+
+class User < ActiveRecord::Base
+  acts_as_cached
+
+  has_many :books
+  has_many :images, :as => :imagable
+end

data/test/active_record/persistence_test.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+require 'active_record/test_helper'
+
+class ActiveRecord::PersistenceTest < Test::Unit::TestCase
+  def setup
+    @user = User.create :name => 'csdn', :email => 'test@csdn.com'
+    @topic = Topic.create :title => "csdn"
+  end
+
+  def test_should_reload_object
+    User.increment_counter :books_count, @user.id
+    assert_equal 0, @user.books_count
+    assert_equal 1, @user.reload.books_count
+  end
+
+  def test_should_clean_cache_after_touch
+    post = @topic.posts.create
+    post.body = "body"
+    post.save
+    new_topic = Topic.find @topic.id
+    assert !(new_topic.updated_at == @topic.updated_at)
+  end
+
+  def test_should_return_true_if_touch_ok
+    assert @topic.touch == true
+  end
+end

data/test/active_record/polymorphic_association_test.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+require 'active_record/test_helper'
+
+class ActiveRecord::PolymorphicAssociationTest < Test::Unit::TestCase
+  def setup
+    @user = User.create :name => 'csdn', :email => 'test@csdn.com'
+  end
+
+  def test_should_get_cache_when_use_polymorphic_association
+    image = @user.images.create
+
+    no_connection do
+      assert_equal @user, image.imagable
+    end
+  end
+
+  def test_should_write_polymorphic_association_cache
+    image = @user.images.create
+    @user.expire_second_level_cache
+    assert_nil User.read_second_level_cache(@user.id)
+    assert_equal @user, image.imagable
+  end
+end
+

data/test/active_record/second_level_cache_test.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+require 'active_record/test_helper'
+
+class ActiveRecord::SecondLevelCacheTest < Test::Unit::TestCase
+  def setup
+    @user = User.create :name => 'csdn', :email => 'test@csdn.com'
+  end
+
+  def test_should_get_cache_key
+    assert_equal "slc/user/#{@user.id}", @user.second_level_cache_key
+  end
+
+  def test_should_write_and_read_cache
+    assert_not_nil User.read_second_level_cache(@user.id)
+    @user.expire_second_level_cache
+    assert_nil User.read_second_level_cache(@user.id)
+    @user.write_second_level_cache
+    assert_not_nil User.read_second_level_cache(@user.id)
+  end
+end

data/test/active_record/test_helper.rb

@@ -0,0 +1,35 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+require 'active_record'
+require 'second_level_cache/active_record'
+
+def open_test_db_connect
+  ActiveRecord::Base.establish_connection(
+    :adapter => 'sqlite3',
+    :database => 'test/test.sqlite3'
+  )
+end
+open_test_db_connect
+
+def close_test_db_connect
+  ActiveRecord::Base.connection.disconnect!
+end
+
+class Test::Unit::TestCase
+  def no_connection
+    close_test_db_connect
+    assert_nothing_raised { yield }
+  ensure
+    open_test_db_connect
+  end
+
+  def teardown
+    User.delete_all
+  end
+end
+
+require 'active_record/model/user'
+require 'active_record/model/book'
+require 'active_record/model/image'
+require 'active_record/model/topic'
+require 'active_record/model/post'

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+require 'rubygems'
+require 'bundler/setup'
+require 'second_level_cache'
+require 'test/unit'
+
+SecondLevelCache.configure do |config|
+  config.cache_store = ActiveSupport::Cache::MemoryStore.new
+end
+
+SecondLevelCache.logger.level = Logger::INFO

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: second_level_cache
+version: !ruby/object:Gem::Version
+  version: 1.3.2
+  prerelease: 
+platform: ruby
+authors:
+- wangxz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Write Through and Read Through caching library inspired by CacheMoney
+  and cache_fu, support only Rails3 and ActiveRecord.
+email:
+- wangxz@csdn.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- init.rb
+- lib/second_level_cache.rb
+- lib/second_level_cache/active_record.rb
+- lib/second_level_cache/active_record/base.rb
+- lib/second_level_cache/active_record/belongs_to_association.rb
+- lib/second_level_cache/active_record/finder_methods.rb
+- lib/second_level_cache/active_record/persistence.rb
+- lib/second_level_cache/arel/wheres.rb
+- lib/second_level_cache/config.rb
+- lib/second_level_cache/marshal.rb
+- lib/second_level_cache/version.rb
+- second_level_cache.gemspec
+- test/active_record/base_test.rb
+- test/active_record/belongs_to_association_test.rb
+- test/active_record/finder_methods_test.rb
+- test/active_record/model/book.rb
+- test/active_record/model/image.rb
+- test/active_record/model/post.rb
+- test/active_record/model/topic.rb
+- test/active_record/model/user.rb
+- test/active_record/persistence_test.rb
+- test/active_record/polymorphic_association_test.rb
+- test/active_record/second_level_cache_test.rb
+- test/active_record/test_helper.rb
+- test/test_helper.rb
+homepage: https://github.com/csdn-dev/second_level_cache
+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.8.24
+signing_key: 
+specification_version: 3
+summary: ! 'SecondLevelCache is a write-through and read-through caching library inspired
+  by Cache Money and cache_fu, support only Rails3 and ActiveRecord.  Read-Through:
+  Queries by ID, like current_user.articles.find(params[:id]), will first look in
+  cache store and then look in the database for the results of that query. If there
+  is a cache miss, it will populate the cache.  Write-Through: As objects are created,
+  updated, and deleted, all of the caches are automatically kept up-to-date and coherent.'
+test_files: []