cache_it 0.0.1

data/.gitignore

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

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Rodrigo Vanegas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,23 @@
+cache_it
+========
+
+Cache for ActiveRecord objects, backed by ActiveSupport::CacheStore of your choice.  Cache-money was 
+not yet ported to Rails 3 so I rolled my own.
+
+
+Example
+=======
+
+class User < ActiveRecord::Base
+  cache_it do |c|
+    c.index :first, :last
+    c.index :email
+  end
+end
+
+user = User.cache_it_find :first => "Joe", :last => "Schmoe"
+user = User.cache_it_find :email => "joe@example.com"
+user.age = 30
+user.cache_it_write
+
+Copyright (c) 2011 Rodrigo Vanegas, released under the MIT license

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rspec/core/rake_task'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+

data/cache_it.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cache_it/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cache_it"
+  s.version     = CacheIt::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Rodrigo Vanegas"]
+  s.email       = ["rvanegas@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{ActiveRecord caching}
+  s.description = %q{Integrates ActiveRecord with cache stores provided by Rails.cache, incluing memcached}
+
+  s.rubyforge_project = "cache_it"
+
+  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/init.rb

@@ -0,0 +1,2 @@
+require 'cache_it'
+

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/cache_it/version.rb

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

data/lib/cache_it.rb

@@ -0,0 +1,228 @@
+
+module ActiveRecord
+  class Base
+    #
+    # First time called, configures \cache_it for this ActiveRecord model.
+    # Subsequent calls returns a delegate to access class methods.
+    #
+    # Examples:
+    # 
+    #   class Foo < ActiveRecord::Base
+    #     cache_it :first, :last
+    #   end
+    # 
+    #   class Foo < ActiveRecord::Base
+    #     cache_it do |c|
+    #       c.index :first, :last
+    #       c.index :email
+    #       c.counters :points
+    #     end
+    #   end
+    #
+    def self.cache_it(*index)
+      if self.class_variable_defined? :@@cache_it
+        raise ArgumentError, "cannot reconfigure" if index.present? or block_given?
+      else
+        raise ArgumentError, "use block or args" if index.present? and block_given?
+        config = CacheIt::Config.new self
+        config.index *index if config and index.present?
+        yield config if config and block_given?
+        self.class_exec do
+          # Returns delegate to access instance methods
+          def cache_it
+            @cache_it ||= CacheIt::InstanceDelegate.new self
+          end
+        end
+        delegate = CacheIt::ClassDelegate.new self, config
+        self.class_variable_set "@@cache_it", delegate
+      end
+      self.class_variable_get "@@cache_it"
+    end
+  end
+end
+
+# 
+# Cache for ActiveRecord objects, backed by ActiveSupport::CacheStore of your choice.  
+# 
+# ==Usage
+#  
+#  # migration
+#  create_table :users do |t|
+#     t.string :first
+#     t.string :last
+#     t.string :email
+#     t.integer :age
+#     t.integer :points
+#   end
+#
+#   class User < ActiveRecord::Base
+#     cache_it do |c|
+#       c.index :first, :last
+#       c.index :email
+#       c.counters :points
+#     end
+#   end
+# 
+#   user = User.cache_it.find(:first => "Joe", :last => "Schmoe")
+#   user = User.cache_it.find(:email => "joe@example.com")
+#   user.age = 30
+#   user.cache_it_write
+# 
+module CacheIt
+  class InstanceDelegate
+    def initialize(base)
+      @base = base
+    end
+
+    def write
+      expires_in = @base.class.cache_it.config.expires_in
+      val = {:attributes => @base.attributes}
+      keys.each {|key| Rails.cache.write(key, val, :expires_in => expires_in)}
+      stale_keys.each {|key| Rails.cache.delete(key)}
+      init_counters
+    end
+
+    def increment(counter, amount = 1)
+      counter = counter.to_s
+      unless @base.class.cache_it.config.counters.include? counter
+        raise ArgumentError, "#{counter} is not a counter"
+      end
+      primary_key = @base.class.primary_key
+      if key = @base.class.cache_it.key({primary_key => @base[primary_key]}, :counter => counter)
+        @base[counter] = Rails.cache.increment(key, amount, :raw => true)
+      end
+    end
+
+    def delete
+      keys(attributes_before_changes).each {|key| Rails.cache.delete(key)}
+    end
+
+    def init_counters
+      primary_key = @base.class.primary_key
+      @base.class.cache_it.config.counters.map do |counter|
+        counter_key = @base.class.cache_it.key({primary_key => @base[primary_key]}, :counter => counter)
+        @base[counter] = Rails.cache.fetch(counter_key, :raw => true) { @base[counter] }
+      end
+    end
+
+    private
+    def attributes_before_changes
+      result = Hash.new
+      @base.attributes.each do |k,v| 
+        result[k] = @base.changes.include?(k) ? @base.changes[k].first : v
+      end
+      return result
+    end
+
+    def keys(attrs = @base.attributes)
+      @base.class.cache_it.config.indexes.map do |index|
+        @base.class.cache_it.key attrs.select {|attr| index.include? attr}
+      end
+    end
+
+    def stale_keys
+      keys(attributes_before_changes) - keys(@base.attributes)
+    end
+  end
+
+  class ClassDelegate
+    def initialize(base, config)
+      @base = base
+      @config = config
+      @base.after_save Proc.new { cache_it.write }
+      @base.after_destroy Proc.new { cache_it.delete }
+    end
+
+    def key(attrs, options = {})
+      attrs = attrs.stringify_keys
+      index = attrs.keys.sort
+      raise ArgumentError, "index not available" unless @config.indexes.include? index
+      if options[:counter]
+        raise ArgumentError, "not a counter" unless @config.counters.include? options[:counter]
+      end
+      key = ["CacheIt.v1", @base.name]
+      key.push options[:counter] if options[:counter]
+      key.push index.map{|name| [name, attrs[name]]}.to_json
+      return key.join(":")
+    end
+
+    def find(attrs, options = {})
+      unless obj = read(attrs, options)
+        obj = @base.where(attrs).first
+        obj.cache_it.write if obj
+      end
+      return obj
+    end
+
+    def read(attrs, options = {})
+      key = key(attrs)
+      obj = nil
+      if val = Rails.cache.read(key)
+        attributes = val[:attributes]
+        obj = @base.new
+        obj.send :attributes=, attributes, false
+        obj.instance_variable_set("@new_record", false) if obj.id
+        obj.cache_it.init_counters unless options[:skip_counters]
+      end
+      return obj
+    end
+
+    def config
+      @config
+    end
+  end
+
+  class Config
+    def initialize(model)
+      @model = model
+      @indexes ||= [[@model.primary_key]]
+      @counters ||= []
+    end
+
+    def index(*index)
+      return nil unless index.present?
+      index = index.map {|n|n.to_s}.sort
+      unless index.all? {|n| @model.column_names.include? n}
+        raise ArgumentError, "index must be list of column names" 
+      end
+      @indexes.push index unless @indexes.include? index
+      validate
+      return nil
+    end
+
+    def indexes
+      @indexes
+    end
+
+    def counters(*counters)
+      return @counters unless counters.present?
+      counters = counters.map {|n|n.to_s}
+      unless counters.all? {|n| @model.columns_hash[n].try(:type) == :integer}
+        raise ArgumentError, "counters must be column names for integer attributes" 
+      end
+      counters.each do |name| 
+        @counters.push name unless @counters.include? name
+      end
+      validate
+      return nil
+    end
+
+    def expires_in(expires_in = nil, &block)
+      unless expires_in or block_given?
+        @expires_in.respond_to?(:call) ? @expires_in.call : @expires_in
+      else
+        raise ArgumentError, "use block or args" if expires_in and block_given?
+        @expires_in = expires_in || block
+        return nil
+      end
+    end
+
+    private
+    def validate
+      if @indexes.flatten.any? {|name| @counters.include? name}
+        raise "cannot use column for both index and counter" 
+      end
+    end
+  end
+end
+

data/spec/cache_it_spec.rb

@@ -0,0 +1,232 @@
+
+require 'ruby-debug'
+Debugger.start
+
+require 'sqlite3'
+require 'active_record'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/cache_it.rb')
+
+class MockCache
+  def initialize
+    clear
+  end
+  
+  def write(key, val, options = {})
+    @hash[key] = val
+  end
+
+  def read(key)
+    @hash[key]
+  end
+
+  def fetch(key, options = {})
+    if @hash.has_key?(key)
+      @hash[key]
+    elsif block_given?
+      @hash[key] = yield
+    end
+  end
+
+  def increment(key, amount = 1, options = {})
+    @hash[key] = @hash[key].to_s.to_i + amount
+  end
+
+  def delete(key)
+    @hash.delete(key)
+  end
+
+  def clear
+    @hash = Hash.new
+  end
+end
+
+describe MockCache do
+  it "writes and reads" do
+    subject.read("foo").should== nil
+    subject.write("foo", 1)
+    subject.read("foo").should== 1
+  end
+
+  it "fetches" do
+    subject.read("foo").should== nil
+    subject.fetch("foo", 1){ 1 }.should== 1
+    subject.read("foo").should== 1
+    subject.fetch("foo", 1).should== 1
+  end
+
+  it "increments" do
+    subject.read("foo").should== nil
+    subject.increment("foo")
+    subject.increment("foo", 2)
+    subject.write("foo", 1)
+    subject.increment("foo")
+    subject.increment("foo", 2)
+    subject.read("foo").should== 4
+  end
+
+  it "deletes" do
+    subject.read("foo").should== nil
+    subject.write("foo", 1)
+    subject.read("foo").should== 1
+    subject.delete("foo")
+    subject.read("foo").should== nil
+  end
+end
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ":memory:")
+
+silence_stream(STDOUT) do
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :users do |t|
+      t.string :code
+      t.string :name
+      t.integer :points, :default => 0
+    end
+  end
+end
+
+class Rails
+  @@cache = MockCache.new
+  def self.cache
+    @@cache
+  end
+end
+
+class User < ActiveRecord::Base
+  cache_it do |c|
+    c.index :code
+    c.index :name
+    c.counters :points
+  end
+end
+
+describe CacheIt do
+  context "User" do
+    before do
+      User.delete_all
+      Rails.cache.clear
+      @u = User.create(:code => "x", :name => "joe")
+    end
+
+    it "reads" do
+      User.cache_it.read(:name => "joe").should== @u
+    end
+
+    it "writes" do
+      @u.name = "jane"
+      @u.cache_it.write
+      User.cache_it.read(:name => "jane").should== @u
+      User.find_by_sql("select * from users where id = #{@u.id}").first.name.should== "joe"
+      @u.save!
+      User.find_by_sql("select * from users where id = #{@u.id}").first.name.should== "jane"
+    end
+
+    it "increments" do
+      @u.cache_it.increment(:points)
+      @u.points.should== 1
+      User.find_by_sql("select * from users where name = 'joe'").first.points.should== 0
+      @u.save!
+      User.find_by_sql("select * from users where name = 'joe'").first.points.should== 1
+    end
+
+    it "deletes stale keys" do
+      @u.code = "y"
+      @u.save!
+      User.cache_it.read(:code => "x").should== nil
+    end
+
+    it "deletes stale keys on destroy" do
+      @u.code = "y"
+      @u.destroy
+      User.cache_it.read(:code => "x").should== nil
+    end
+
+    it "syncs counters" do
+      @u.cache_it.increment(:points)
+      @u2 = User.cache_it.read(:name => "joe")
+      @u2.points.should== 1
+      @u2.cache_it.increment(:points)
+      @u3 = User.cache_it.read({:name => "joe"}, :skip_counters => true)
+      @u3.points.should== 0
+      @u4 = User.cache_it.read(:name => "joe")
+      @u4.points.should== 2
+    end
+
+    it "nil for read of unknown keys" do
+      User.cache_it.read(:name => "dave").should== nil
+    end
+
+    it "flags set right" do
+      @u2 = User.cache_it.read(:name => "joe")
+      @u2.new_record?.should== false
+      @u2.persisted?.should== true
+    end
+
+    it "doesn't accept unknown index" do
+      expect { User.cache_it.read(:points => 10) }.to raise_error(/index not available/)
+    end
+  end
+
+  context "config" do
+    before do
+      @users_class = Class.new ActiveRecord::Base
+      @users_class.set_table_name "users"
+    end
+    
+    it "can't use same column for both index and counter" do
+      expect do
+        @users_class.cache_it do |c|
+          c.index :name, :points
+          c.counters :points
+        end
+      end.to raise_error(/cannot use column/)
+    end
+
+    it "can use arg" do
+      expect do
+        @users_class.cache_it :code
+      end.to_not raise_error
+    end
+
+    it "can't use arg and block" do
+      expect do
+        @users_class.cache_it(:code) {|c| c.index :name}
+      end.to raise_error(/block or args/)
+    end
+
+    it "accepts constant for expires" do
+      expect do
+        @users_class.cache_it {|c| c.expires_in 3}
+      end.to_not raise_error
+    end
+
+    it "accepts proc for expires" do      
+      expect do
+        @users_class.cache_it {|c| c.expires_in { 3 }}
+      end.to_not raise_error
+    end
+
+    it "counter must be integer column" do
+      expect do
+        @users_class.cache_it {|c| c.counters :name}
+      end.to raise_error(/must be column names for integer/)
+    end
+    
+    it "counter must be existing column" do
+      expect do
+        @users_class.cache_it {|c| c.counters :not_a_column}
+      end.to raise_error(/must be column names for integer/)
+    end
+
+    it "each class gets its own config" do
+      @users_class2 = Class.new ActiveRecord::Base
+      @users_class2.set_table_name "users"
+      @users_class2.cache_it.config.should_not== @users_class.cache_it.config
+    end
+
+    it "cannot config twice" do
+      expect {@users_class.cache_it :name}.to_not raise_error
+      expect {@users_class.cache_it :code}.to raise_error
+    end
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: cache_it
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Rodrigo Vanegas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-11 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Integrates ActiveRecord with cache stores provided by Rails.cache, incluing memcached
+email: 
+- rvanegas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README
+- Rakefile
+- cache_it.gemspec
+- init.rb
+- install.rb
+- lib/cache_it.rb
+- lib/cache_it/version.rb
+- spec/cache_it_spec.rb
+- uninstall.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cache_it
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ActiveRecord caching
+test_files: []
+