djmaze-arid_cache 1.1.0

data/lib/arid_cache/helpers.rb

@@ -0,0 +1,86 @@
+module AridCache
+  module Helpers
+
+    # Lookup something from the cache.
+    #
+    # If no block is provided, create one dynamically.  If a block is
+    # provided, it is only used the first time it is encountered.
+    # This allows you to dynamically define your caches while still
+    # returning the results of your query.
+    #
+    # @return a WillPaginate::Collection if the options include :page,
+    #  a Fixnum count if the request is for a count or the results of
+    #  the ActiveRecord query otherwise.
+    def lookup(object, key, opts, &block)
+      if !block.nil?
+        define(object, key, opts, &block)
+      elsif key =~ /(.*)_count$/
+        if AridCache.store.has?(object, $1)
+          method_for_cached(object, $1, :fetch_count, key)
+        elsif object.respond_to?(key)
+          define(object, key, opts, :fetch_count)
+        elsif object.respond_to?($1)
+          define(object, $1, opts, :fetch_count, key)
+        else
+          raise ArgumentError.new("#{object} doesn't respond to #{key} or #{$1}!  Cannot dynamically create query to get the count, please call with a block.")
+        end
+      elsif AridCache.store.has?(object, key)
+        method_for_cached(object, key, :fetch)
+      elsif object.respond_to?(key)
+        define(object, key, opts, &block)
+      else
+        raise ArgumentError.new("#{object} doesn't respond to #{key}!  Cannot dynamically create query, please call with a block.")
+      end
+      object.send("cached_#{key}", opts)
+    end
+
+    # Store the options and optional block for a call to the cache.
+    #
+    # If no block is provided, create one dynamically.
+    #
+    # @return an AridCache::Store::Blueprint.
+    def define(object, key, opts, fetch_method=:fetch, method_name=nil, &block)
+      
+      # FIXME: Pass default options to store.add
+      # Pass nil in for now until we get the cache_ calls working.
+      # This means that the first time you define a dynamic cache
+      # (by passing in a block), the options you used are not
+      # stored in the blueprint and applied to each subsequent call.
+      #
+      # Otherwise we have a situation where a :limit passed in to the
+      # first call persists when no options are passed in on subsequent calls,
+      # but if a different :limit is passed in that limit is applied.
+      #
+      # I think in this scenario one would expect no limit to be applied
+      # if no options are passed in.
+      #
+      # When the cache_ methods are supported, those options should be
+      # remembered and applied to the collection however.
+      blueprint = AridCache.store.add_object_cache_configuration(object, key, nil, block)
+      method_for_cached(object, key, fetch_method, method_name)
+      blueprint
+    end
+
+    private
+
+    # Dynamically define a method on the given object or class to return cached results
+    def method_for_cached(object_or_class, key, fetch_method=:fetch, method_name=nil)
+      method_name = ("cached_" + (method_name || key)).gsub(/[^\w\!\?]/, '_')
+      method_body = <<-END
+        def #{method_name}(*args, &block)
+          opts = args.empty? ? {} : args.first
+
+          proxy = AridCache::CacheProxy.new(self, #{key.inspect}, opts, &block)
+          if opts[:clear] == true
+            proxy.clear_cached
+          else
+            proxy.#{fetch_method.to_s}
+          end
+        end
+      END
+      # Get the correct class
+      klass = object_or_class.is_a?(Class) ? object_or_class : object_or_class.class
+      klass.class_eval(method_body, __FILE__, __LINE__)
+    end
+  end  
+end

data/lib/arid_cache/store.rb

@@ -0,0 +1,125 @@
+module AridCache
+  class Store < Hash
+    
+    # AridCache::Store::Blueprint
+    #
+    # Stores options and blocks that are used to generate results for finds
+    # and counts.
+    Blueprint = Struct.new(:klass, :key, :opts, :proc)  do
+
+      def initialize(klass, key, opts={}, proc=nil)
+        self.key = key
+        self.klass = klass
+        self.proc = proc
+        self.opts = opts
+      end
+            
+      def klass=(object) # store the class name only
+        self['klass'] = object.is_a?(Class) ? object.name : object.class.name
+      end
+      
+      def klass
+        self['klass'].constantize unless self['klass'].nil?
+      end 
+      
+      def opts=(value)
+        self['opts'] = value.symbolize_keys! unless !value.respond_to?(:symbolize_keys)
+      end    
+      
+      def opts
+        self['opts'] || {}
+      end
+      
+      def proc(object=nil)
+        if self['proc'].nil? && !object.nil?
+          self['proc'] = key
+        else
+          self['proc']
+        end
+      end 
+    end
+    
+    #
+    # Capture cache configurations and blocks and store them in the store.
+    #
+    # A block is evaluated within the scope of this class.  The blocks
+    # contains calls to methods which define the caches and give options
+    # for each cache. 
+    #
+    # Don't instantiate directly.  Rather instantiate the Instance- or 
+    # ClassCacheConfiguration.
+    Configuration = Struct.new(:klass, :global_opts)  do
+
+      def initialize(klass, global_opts={})
+        self.global_opts = global_opts
+        self.klass = klass
+      end
+      
+      def method_missing(key, *args, &block)
+        opts = global_opts.merge(args.empty? ? {} : args.first)
+        case self
+        when InstanceCacheConfiguration
+          AridCache.store.add_instance_cache_configuration(klass, key, opts, block)
+        else
+          AridCache.store.add_class_cache_configuration(klass, key, opts, block)
+        end
+      end
+    end
+    class InstanceCacheConfiguration < Configuration; end #:nodoc:
+    class ClassCacheConfiguration    < Configuration; end #:nodoc:
+    
+    def has?(object, key)
+      self.include?(object_store_key(object, key))
+    end
+    
+    # Empty the proc store
+    def delete!
+      delete_if { true }
+    end 
+
+    def self.instance
+      @@singleton_instance ||= self.new
+    end
+
+    def find(object, key)
+      self[object_store_key(object, key)]
+    end
+    
+    def add_instance_cache_configuration(klass, key, opts, proc)
+      add_generic_cache_configuration(instance_store_key(klass, key), klass, key, opts, proc)
+    end
+
+    def add_class_cache_configuration(klass, key, opts, proc)
+      add_generic_cache_configuration(class_store_key(klass, key), klass, key, opts, proc)
+    end
+
+    def add_object_cache_configuration(object, key, opts, proc)
+      add_generic_cache_configuration(object_store_key(object, key), object, key, opts, proc)
+    end
+    
+    def find_or_create(object, key)
+      store_key = object_store_key(object, key)
+      if self.include?(store_key)
+        self[store_key]
+      else
+        self[store_key] = AridCache::Store::Blueprint.new(object, key)
+      end
+    end
+    
+    protected
+    
+    def add_generic_cache_configuration(store_key, *args)
+      AridCache.send(:method_for_cached, args[0], args[1].to_s)		# TODO Right place for this?
+      self[store_key] = AridCache::Store::Blueprint.new(*args)
+    end
+      
+    def initialize
+    end
+    
+    def class_store_key(klass, key);    klass.name.downcase + '-' + key.to_s; end
+    def instance_store_key(klass, key); klass.name.downcase.pluralize + '-' + key.to_s; end
+    def object_store_key(object, key)
+      case object; when Class; class_store_key(object, key); else; instance_store_key(object.class, key); end
+    end
+  end 
+end

data/lib/arid_cache.rb

@@ -0,0 +1,47 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'arid_cache/helpers'
+require 'arid_cache/store'
+require 'arid_cache/active_record'
+require 'arid_cache/cache_proxy'
+
+module AridCache
+  extend AridCache::Helpers
+  class Error < StandardError; end #:nodoc:
+
+  def self.cache
+    AridCache::CacheProxy
+  end
+
+  def self.clear_caches
+    AridCache::CacheProxy.clear_caches
+  end 
+  
+  def self.clear_class_caches(object)
+    AridCache::CacheProxy.clear_class_caches(object)
+  end 
+      
+  def self.clear_instance_caches(object)
+    AridCache::CacheProxy.clear_instance_caches(object)
+  end  
+    
+  def self.store
+    AridCache::Store.instance
+  end
+  
+  # The old method of including this module, if you don't want to
+  # extend active record.  Just add 'include AridCache' to your
+  # model class.
+  def self.included(base)
+    base.send(:include, AridCache::ActiveRecord)
+  end
+  
+  # Initializes AridCache for Rails.
+  #
+  # This method is called by `init.rb`,
+  # which is run by Rails on startup.
+  def self.init_rails
+    ::ActiveRecord::Base.send(:include, AridCache::ActiveRecord)
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')

data/spec/arid_cache/arid_cache_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe AridCache do
+  describe 'results' do
+    before :each do
+      Company.destroy_all
+      @company1 = Company.make(:name => 'a')
+      @company2 = Company.make(:name => 'b')
+      Company.class_caches do
+        ordered_by_name { Company.all(:order => 'name ASC') }
+      end
+      Company.clear_caches
+    end
+
+    it "order should match the original order" do
+      3.times do |t|
+        results = Company.cached_ordered_by_name
+        results.size.should == 2
+        results[0].name.should == @company1.name
+        results[1].name.should == @company2.name
+      end
+    end
+  
+    it "order should match the order option" do
+      3.times do |t|
+        results = Company.cached_ordered_by_name(:order => 'name DESC')
+        results.size.should == 2
+        results[0].name.should == @company2.name
+        results[1].name.should == @company1.name
+      end
+    end
+    
+    it "with order option should go to the database to order" do
+      lambda {
+        Company.cached_ordered_by_name(:order => 'name DESC')
+      }.should query(2)
+    end
+  end
+end

data/spec/arid_cache/cache_proxy_result_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe AridCache::CacheProxy::Result do
+  before :each do
+    class X; end
+    @result = AridCache::CacheProxy::Result.new
+  end
+
+  it "should set the klass from a class" do
+    @result.klass = X
+    @result.klass.should be(X)
+  end
+  
+  it "should set the klass from an object" do
+    @result.klass = X.new
+    @result.klass.should be(X)
+  end
+  
+  it "should store the klass as a string" do
+    @result.klass = X
+    @result[:klass].should == X.name
+  end
+
+  it "should not have ids if it's nil" do
+    @result.ids = nil
+    @result.has_ids?.should be_false
+  end
+  
+  it "should have ids" do
+    @result.ids = [1,2,3]
+    @result.has_ids?.should be_true
+  end
+  
+  it "should have ids even if the array is empty" do
+    @result.ids = []
+    @result.has_ids?.should be_true
+  end
+
+  it "should not have a count if it's nil" do
+    @result.count = nil
+    @result.has_count?.should be_false
+  end
+  
+  it "should have a count" do
+    @result.count = 3
+    @result.has_count?.should be_true
+  end
+  
+  it "should have a count even if it is zero" do
+    @result.count = 0
+    @result.has_count?.should be_true
+  end
+end

data/spec/arid_cache/cache_proxy_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe AridCache::CacheProxy do
+  describe 'preserve_order' do
+    before :each do
+      @proxy = AridCache::CacheProxy.new(Company, 'dummy-key', {})
+    end
+
+    it "id column should be prefixed by the table name" do
+      ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(true)
+      @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
+    end
+
+    it "id column should be prefixed by the table name" do
+      ::ActiveRecord::Base.stubs(:is_mysql_adapter?).returns(false)
+      @proxy.send(:preserve_order, [1,2,3]).should =~ %r[#{Company.table_name}]
+    end
+  end
+
+  describe "with raw => true" do
+    before :each do
+      @user = User.make
+      @user.companies << Company.make
+      @user.companies << Company.make
+      @user.clear_instance_caches
+    end
+
+    it "should return a CacheProxy::Result" do
+      @user.cached_companies(:raw => true).should be_a(AridCache::CacheProxy::Result)
+    end
+
+    it "result should have the same ids as the normal result" do
+      @user.cached_companies(:raw => true).ids.should == @user.cached_companies.collect(&:id)
+    end
+
+    it "should ignore :raw => false" do
+      @user.cached_companies(:raw => false).should == @user.cached_companies
+    end
+
+    it "should only query once to seed the cache, ignoring all other options" do
+      lambda { @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column desc') }.should query(1)
+    end
+
+    it "should ignore all other options if the cache has already been seeded" do
+      lambda {
+        companies = @user.cached_companies
+        @user.cached_companies(:raw => true, :limit => 0, :order => 'nonexistent_column').ids.should == companies.collect(&:id)
+      }.should query(1)
+    end
+
+    it "should not use the raw option when reading from the cache" do
+      Rails.cache.expects(:read).with(@user.arid_cache_key(:companies), {})
+      @user.cached_companies(:raw => true)
+    end
+
+    it "should work for calls to a method that ends with _count" do
+      @user.cached_bogus_count do
+        10
+      end
+      @user.cached_bogus_count(:raw => true).should == 10
+    end
+
+    it "should work for calls to a method that ends with _count" do
+      @user.cached_companies_count(:raw => true).should == @user.cached_companies_count
+    end
+  end
+
+  describe "with clear => true" do
+    before :each do
+      @user = User.make
+      @user.companies << Company.make
+      @user.companies << Company.make
+      @user.clear_instance_caches rescue Rails.cache.clear
+    end
+
+    it "should not fail if there is no cached value" do
+      lambda { @user.cached_companies(:clear => true) }.should_not raise_exception
+    end
+
+    it "should clear the cached entry" do
+      key = @user.arid_cache_key(:companies)
+      @user.cached_companies
+      Rails.cache.read(key).should_not be_nil
+      @user.cached_companies(:clear => true)
+      Rails.cache.read(key).should be_nil
+    end
+
+    it "should not read from the cache or database" do
+      Rails.cache.expects(:read).never
+      lambda {
+        @user.cached_companies(:clear => true)
+      }.should query(0)
+    end
+  end
+end