tobi-cached 0.5.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-06-07
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,18 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+cached.gemspec
+init.rb
+lib/cached.rb
+lib/cached/config.rb
+lib/cached/config_compiler.rb
+lib/cached/model.rb
+lib/cached/record.rb
+test/people_database.rb
+test/test_cached.rb
+test/test_cached_delegation.rb
+test/test_config_compiler.rb
+test/test_helper.rb
+test/test_record.rb

data/README.rdoc

@@ -0,0 +1,63 @@
+= cached
+
+* http://github.com/tobi/cached
+
+== DESCRIPTION:
+
+Small trial project that attempts to accelerate common active record like operations without too much black magic. 
+
+
+== SYNOPSIS:
+
+  class Product < AR:Base
+
+    cache_by_key :id do     
+      index :name         
+      index [:brand, :name]
+      
+      delegate_to :find    
+    end
+  end
+  
+  Product.create :name => 'ipod', :brand => 'apple'
+  
+  Product.lookup(1) # cache_hit, 1 memcached query
+  Product.lookup(2) # cache_miss, 1 memcached query, 1 db query: .find(2) (see delegates_to)
+  Product.lookup_by_name('ipod') # cache_hit, 2 memcached queries
+  Product.lookup_by_brand_and_name('apple','ipod') # cache_hit, 2 memcached queries
+
+  Product.lookup_by_something('else') # raise NoMethodError
+    
+
+== REQUIREMENTS:
+
+* Active Record included with rails 2.3+
+
+== INSTALL:
+
+* Gem install or plugin install
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Tobias Lütke
+
+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/Rakefile

@@ -0,0 +1,29 @@
+BEGIN {$VERBOSE = nil;$DEBUG = nil}
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+%w[rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/cached'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('cached', Cached::VERSION) do |p|
+  p.developer('Tobias Lütke', 'tobi@leetsoft.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")  
+  p.extra_deps         = [
+    ['activesupport','>= 2.3.2'],
+  ]
+
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/cached.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cached}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tobias L\303\274tke"]
+  s.date = %q{2009-06-10}
+  s.description = %q{Small trial project that attempts to accelerate common active record like operations without too much black magic.}
+  s.email = ["tobi@leetsoft.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc"]
+  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "cached.gemspec", "init.rb", "lib/cached.rb", "lib/cached/config.rb", "lib/cached/config_compiler.rb", "lib/cached/model.rb", "lib/cached/record.rb", "test/people_database.rb", "test/test_cached.rb", "test/test_cached_delegation.rb", "test/test_config_compiler.rb", "test/test_helper.rb", "test/test_record.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/tobi/cached}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{cached}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Small trial project that attempts to accelerate common active record like operations without too much black magic.}
+  s.test_files = ["test/test_cached.rb", "test/test_cached_delegation.rb", "test/test_config_compiler.rb", "test/test_helper.rb", "test/test_record.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.2"])
+      s.add_development_dependency(%q<newgem>, [">= 1.4.1"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+      s.add_dependency(%q<newgem>, [">= 1.4.1"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+    s.add_dependency(%q<newgem>, [">= 1.4.1"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/init.rb

@@ -0,0 +1,4 @@
+require 'cached'
+
+ActiveRecord::Base.send(:include, Cached::Model)
+ActiveRecord::Base.send(:include, Cached::Record)

data/lib/cached.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'active_support'
+
+module Cached
+  VERSION = '0.5.0' 
+  
+  mattr_accessor :store
+  self.store = ActiveSupport::Cache.lookup_store(:memory_store)
+end            
+
+
+require 'cached/config'
+require 'cached/config_compiler'
+require 'cached/model'

data/lib/cached/config.rb

@@ -0,0 +1,18 @@
+module Cached
+  class Config     
+    attr_accessor :indexes, :class_name, :primary_key, :delegates
+    
+    def initialize(class_name, primary_key)           
+      @delegates, @indexes, @class_name, @primary_key = [], [], class_name.to_s, primary_key.to_s
+    end
+          
+    def index(*args)
+      @indexes.push args.flatten
+    end         
+    
+    def delegate_to(*methods)
+      @delegates += methods.flatten
+    end
+
+  end
+end

data/lib/cached/config_compiler.rb

@@ -0,0 +1,103 @@
+module Cached
+    
+  class ConfigCompiler
+    
+    def initialize(config)
+      @config = config      
+    end
+    
+    def to_ruby    
+      [compiled_meta_methods, compiled_save_methods, compiled_fetch_methods].join      
+    end        
+        
+    def compiled_meta_methods
+      
+      # Instance methods
+      "def object_cache_primary_key; \"#{@config.primary_key}\"; end;" + 
+      "def object_cache_key; \"\#{object_cache_prefix}:\#{#{@config.primary_key}}\"; end;" + 
+      "def object_cache_prefix; \"#{@config.class_name}\"; end;" +       
+      "def object_cache_hash(*args); args.join.hash; end;" +
+      
+      # Class methods
+      "def self.object_cache_prefix; \"#{@config.class_name}\"; end;" +       
+      "def self.object_cache_hash(*args); args.join.hash; end;"
+    end
+    
+    def compiled_save_methods
+      compiled_save_object_method + compiled_save_index_method
+    end
+    
+    def compiled_save_object_method          
+      "def save_object_to_cache;" + 
+        "Cached.store.write(object_cache_key, self);" +
+      "end;" +
+      
+      "def expire_object_in_cache;" + 
+        "Cached.store.delete(object_cache_key);" +
+      "end;"
+    end          
+    
+    def compiled_save_index_method
+            
+      keys = @config.indexes.collect { |index| index_cache_key(index) }
+      
+      "def save_indexes_to_cache;" + 
+        "v = #{@config.primary_key};" +
+        keys.collect{|k| "Cached.store.write(#{k}, v);"}.join +
+      "end;" +
+      
+      "def expire_indexes_in_cache;" +
+        keys.collect{|k| "Cached.store.delete(#{k});"}.join +
+      "end;"
+    end
+    
+    def compiled_fetch_method_for(index)  
+      index_name = index_name(index)     
+      cache_key  = index_cache_key(index)
+      
+      method_suffix_and_parameters = "#{index_name}(#{index.join(', ')})"
+      
+      delegation = @config.delegates.collect { |delegate| "|| #{delegate}_by_#{method_suffix_and_parameters}"  }
+      
+      "def self.lookup_by_#{method_suffix_and_parameters};" + 
+      "  if key = Cached.store.read(#{cache_key});"+
+      "    lookup(key);"+
+      "  else;"+ 
+      "    obj = nil #{delegation};" +
+      "    obj.save_indexes_to_cache if obj.respond_to?(:save_indexes_to_cache);" +
+      "    obj;" +
+      "  end;" +
+      "end;"
+    end
+
+    def compiled_fetch_method_for_primary_key      
+      
+      delegation = @config.delegates.collect{|c| "|| #{c}(pk)" }.join
+      
+      "def self.lookup(pk);" +
+      "  Cached.store.fetch(\"#\{object_cache_prefix}:#\{pk}\") { nil #{delegation} };" +      
+      "end;" +
+      
+      
+      "def self.lookup_by_#{@config.primary_key}(pk);" + 
+      "  lookup(pk); "+
+      "end;" 
+    end
+    
+    def compiled_fetch_methods
+      compiled_fetch_method_for_primary_key + @config.indexes.collect { |index| compiled_fetch_method_for(index) }.join(';')
+    end
+          
+    private        
+    
+    def index_cache_key(index)
+      "\"#\{object_cache_prefix}/#{index_name(index)}:#\{object_cache_hash(#{index.join(', ')})}\""  
+    end  
+    
+    def index_name(index)
+      index.collect(&:to_s).collect(&:downcase).collect(&:underscore).join('_and_')
+    end
+  end
+  
+  
+end

data/lib/cached/model.rb

@@ -0,0 +1,27 @@
+module Cached
+   
+  module Model
+    
+    module ClassMethods
+      def cache_by_key(primary_key, &block)
+        config = Config.new(name.underscore.downcase, primary_key)
+        config.instance_eval(&block)      
+        
+        self.class_eval ConfigCompiler.new(config).to_ruby, __FILE__, __LINE__               
+      end            
+    end
+    
+    def self.included(base)          
+      base.extend ClassMethods                            
+    end
+    
+                                                                                                     
+    def save_to_cache
+      save_object_to_cache
+      save_indexes_to_cache
+    end
+        
+  end            
+  
+  
+end

data/lib/cached/record.rb

@@ -0,0 +1,25 @@
+module Cached
+  module Record
+    
+    def self.included?(base)
+      
+      if base.respond_to?(:save)
+        base.alias_method_chain :save, :cached        
+      end
+      
+    end
+    
+    
+    def save_with_cached
+      save_without_cached
+      
+      # expire the cache, the object will be stored in it's prestine form
+      # after the next lookup call hopefull.       
+      expire_object_in_cache
+      
+      # update the indexes for the new values.
+      store_indexes_in_cache      
+    end
+    
+  end
+end

data/test/people_database.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => '/tmp/people.db')
+
+ActiveRecord::Schema.define do
+
+  create_table :people, :force => true do |t|
+    t.column :first_name, :string
+    t.column :last_name, :string
+  end
+end
+

data/test/test_cached.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/test_helper.rb'            
+                     
+class Product < Struct.new(:id, :name, :price, :vendor)  
+  include Cached::Model
+  
+  cache_by_key :id do     
+    index :name         
+    index [:vendor, :name]    
+  end
+  
+end
+
+
+class TestCached < Test::Unit::TestCase
+
+  def setup                             
+    @product = Product.new(1, 'ipod', 149.00, 'apple')
+  end
+  
+  context "cache storage" do
+  
+    test "product can be stored to cache" do    
+      @product.respond_to?(:save_to_cache)
+    end
+  
+    test "product stores meta data in instance methods" do    
+      assert_equal "id", @product.object_cache_primary_key
+    end
+  
+    test "product has efficient object_cache_key instance method" do
+      assert_equal "product:1", @product.object_cache_key    
+    end
+  
+    test "product stores itself to memcached on save_to_cache call" do
+      assert @product.save_to_cache    
+      assert_equal @product, Cached.store.read('product:1')             
+    end
+  
+    test "product stores defined indexes as backreference to product key" do
+      assert @product.save_to_cache    
+      assert_equal 1, Cached.store.read("product/name:#{hash('ipod')}")
+      assert_equal 1, Cached.store.read("product/vendor_and_name:#{hash('appleipod')}")
+    end                     
+    
+  end
+  
+  context "lookups" do
+    
+    test "product explicit lookup by primary_key" do      
+      @product.save_to_cache
+      Cached.store.expects(:read).with('product:1', {})
+      Product.lookup_by_id(1)
+    end
+    
+    test "product lookup by primary_key" do      
+      @product.save_to_cache
+      Cached.store.expects(:read).with('product:1', {})
+      Product.lookup(1)
+    end
+    
+    test "product lookup by index" do      
+      @product.save_to_cache
+      Cached.store.expects(:read).with("product/name:#{hash('ipod')}").returns(1)
+      Cached.store.expects(:read).with('product:1', {})
+      Product.lookup_by_name('ipod')
+    end
+
+    test "product lookup by multi index" do      
+      @product.save_to_cache
+      Cached.store.expects(:read).with("product/vendor_and_name:#{hash('appleipod')}").returns(1)
+      Cached.store.expects(:read).with('product:1', {})
+      Product.lookup_by_vendor_and_name('apple', 'ipod')
+    end
+    
+  end
+    
+  private
+  
+  def hash(text)
+    text.hash
+  end
+  
+end
+
+

data/test/test_cached_delegation.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper.rb'            
+
+
+class DelegatingProduct < Struct.new(:id, :name, :price, :vendor)
+  include Cached::Model
+
+  cache_by_key :id do     
+    index :name         
+    index [:vendor, :name]    
+    
+    delegate_to :find
+  end  
+end
+
+class TestCachedDelegation < Test::Unit::TestCase
+
+  def setup                             
+    @delegating_product = DelegatingProduct.new(1, 'ipod', 149.00, 'apple')
+  end
+  
+  
+  test "lookup miss will delegate to find method" do        
+    DelegatingProduct.expects(:find).with(2)    
+    DelegatingProduct.lookup(2)      
+  end
+      
+  test "lookup by index miss will delegate to find_by_index method" do        
+    DelegatingProduct.expects(:find).with(2)    
+    DelegatingProduct.lookup(2)      
+  end
+      
+  private
+  
+  def hash(text)
+    text.hash
+  end
+  
+end
+
+
+

data/test/test_config_compiler.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/test_helper.rb'                                 
+
+class TestConfigCompiler < Test::Unit::TestCase
+
+  def setup                             
+    @dump = Class.new
+    @config = Cached::ConfigCompiler.new(Cached::Config.new('product', 'id'))
+  end
+  
+  test "syntax compiled_meta_methods" do    
+    @dump.instance_eval @config.compiled_meta_methods
+    @dump.respond_to?(:object_cache_primary_key)    
+    @dump.respond_to?(:object_cache_key)    
+    @dump.respond_to?(:object_cache_prefix)    
+    @dump.respond_to?(:object_cache_hash)    
+  end
+  
+  test "syntax compiled_save_object_method" do
+    @dump.instance_eval @config.compiled_save_object_method
+    
+    @dump.respond_to?(:save_object_to_cache)    
+  end
+  
+  test "syntax compiled_save_index_method" do
+    @dump.instance_eval @config.compiled_save_index_method
+    
+    @dump.respond_to?(:save_indexes_to_cache)        
+  end
+  
+  test "syntax compiled_fetch_method_for single column" do
+    @dump.instance_eval @config.compiled_fetch_method_for([:name])
+    
+    @dump.respond_to?(:lookup_by_name)    
+  end
+  
+  test "syntax compiled_fetch_method_for multi column" do
+    @dump.instance_eval @config.compiled_fetch_method_for([:name, :brand])
+    
+    @dump.respond_to?(:lookup_by_name_and_brand)        
+  end
+  
+  test "syntax compiled_fetch_method_for_primary_key" do
+    @dump.instance_eval @config.compiled_fetch_method_for_primary_key
+    
+    @dump.respond_to?(:lookup)    
+    @dump.respond_to?(:lookup_by_id)        
+  end
+  
+  test "all syntax" do
+    @dump.instance_eval @config.to_ruby
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+require 'stringio'
+require 'test/unit'
+require 'rubygems'                                                 
+require 'mocha'
+require File.dirname(__FILE__) + '/../lib/cached'
+              
+require 'active_support/cache'
+require 'active_record'
+
+Cached.store = ActiveSupport::Cache.lookup_store(:memory_store)
+#Cached.store = ActiveSupport::Cache.lookup_store(:mem_cache_store)
+                                                                 
+
+class Test::Unit::TestCase
+  
+  def self.test(string, &block)
+    define_method("test:#{string}", &block)
+  end
+  
+  def self.context(string)
+    yield
+  end
+  
+end

data/test/test_record.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/test_helper.rb'                                 
+require File.dirname(__FILE__) + '/people_database'
+
+require 'cached/record'
+
+class Person < ActiveRecord::Base  
+  include Cached::Model
+  include Cached::Record
+  
+  def name
+    "#{first_name} #{last_name}"
+  end
+  
+  cache_by_key :id do     
+    index :first_name
+    index :last_name         
+    index [:first_name, :last_name]
+    
+    delegate_to :find
+  end
+end
+
+class TestRecord < Test::Unit::TestCase
+    
+  def setup                             
+    @bob = Person.create(:first_name => 'Bob', :last_name => 'Bobsen')
+  end
+  
+  test "cachemiss delegates to find" do
+    assert !Cached.store.read("person:1")
+    assert_equal @bob, Person.lookup(@bob.id)
+  end
+  
+  test "load bob from cache store" do
+    @bob.save_to_cache
+    
+    assert_equal @bob, Person.lookup_by_first_name('Bob')
+    assert_equal @bob, Person.lookup_by_last_name('Bobsen')
+    assert_equal @bob, Person.lookup_by_first_name_and_last_name('Bob', 'Bobsen')    
+  end
+  
+  test "cache miss on index query will make returned object re-save its indexes" do
+    assert !Cached.store.read("person/first_name:#{hash('Bob')}")
+    assert_equal @bob, Person.lookup_by_first_name('Bob')
+
+    assert Cached.store.read("person/first_name:#{hash('Bob')}")
+  end
+  
+    
+  private
+  
+  def hash(text)
+    text.hash
+  end
+  
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: tobi-cached
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- "Tobias L\xC3\xBCtke"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: Small trial project that attempts to accelerate common active record like operations without too much black magic.
+email: 
+- tobi@leetsoft.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- cached.gemspec
+- init.rb
+- lib/cached.rb
+- lib/cached/config.rb
+- lib/cached/config_compiler.rb
+- lib/cached/model.rb
+- lib/cached/record.rb
+- test/people_database.rb
+- test/test_cached.rb
+- test/test_cached_delegation.rb
+- test/test_config_compiler.rb
+- test/test_helper.rb
+- test/test_record.rb
+has_rdoc: true
+homepage: http://github.com/tobi/cached
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cached
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Small trial project that attempts to accelerate common active record like operations without too much black magic.
+test_files: 
+- test/test_cached.rb
+- test/test_cached_delegation.rb
+- test/test_config_compiler.rb
+- test/test_helper.rb
+- test/test_record.rb