activerecord_cache 0.0.1 → 0.0.2

data/lib/activerecord_cache/base.rb

@@ -1,18 +1,16 @@
 module ActiveRecordCache
   module Base
+    extend ActiveSupport::Concern
     
-    def self.included(base)
-      base.class_eval do
-        
-        class_attribute :use_activerecord_cache, :instance_writer => false
-        self.use_activerecord_cache = false
-        
-        extend ActiveRecordCache::Base::CacheMethods
-        
-      end
+    included do
+      class_attribute :use_activerecord_cache, :instance_writer => false
+      self.use_activerecord_cache = false
+      
+      after_save    :write_to_cache,    :if => lambda { self.class.use_activerecord_cache }
+      after_destroy :delete_from_cache, :if => lambda { self.class.use_activerecord_cache }
     end
     
-    module CacheMethods
+    module ClassMethods
       def cache_key(id_or_record)
         unless use_activerecord_cache
           message = "ActiveRecord cache is not enabled for #{self.name}"
@@ -25,30 +23,66 @@ module ActiveRecordCache
           id = id_or_record
         end
         
-        "#{name}:#{id}"
+        "#{model_name}/#{id}"
       end
       
       def find_through_cache(id)
         unless use_activerecord_cache
           message = "ActiveRecord cache is not enabled for #{self.name}"
-          raise ActiveRecordCache::CachingNotEnabled, message
+          raise ActiveRecordCache::CacheNotEnabled, message
         end
 
-        Rails.cache.fetch(cache_key(id)) { where(primary_key => id).first }
+        Rails.cache.read(cache_key(id)) || where(primary_key => id).first
       end
       
-      def write_to_cache(record)
+      def find_some_through_cache(ids)
         unless use_activerecord_cache
           message = "ActiveRecord cache is not enabled for #{self.name}"
-          raise ActiveRecordCache::CachingNotEnabled, message
+          raise ActiveRecordCache::CacheNotEnabled, message
         end
         
-        unless record.class == self
-          message = "Instance of #{self} expected, got #{record.class}"
-          raise ActiveRecordCache::RecordTypeMismatch, message
+        records = []
+        cache_misses = []
+        
+        ids.each do |id|
+          if record = find_in_cache(id)
+            records << record
+          else
+            cache_misses << id 
+          end
+        end
+        
+        if cache_misses.present?
+          records += where(primary_key => cache_misses).all
         end
         
-        Rails.cache.write(cache_key(record), record)
+        records
+      end
+      
+      def find_in_cache(id)
+        unless use_activerecord_cache
+          message = "ActiveRecord cache is not enabled for #{self.name}"
+          raise ActiveRecordCache::CacheNotEnabled, message
+        end
+
+        Rails.cache.read(cache_key(id))
+      end
+      
+    end
+    
+    module InstanceMethods
+
+      def write_to_cache
+        unless self.class.use_activerecord_cache
+          message = "ActiveRecord cache is not enabled for #{self.class.name}"
+          raise ActiveRecordCache::CacheNotEnabled, message
+        end
+        
+        Rails.cache.write(self.class.cache_key(self), self)
+      end
+
+      def delete_from_cache
+        Rails.cache.delete(self.class.cache_key(self))
       end
       
     end

data/lib/activerecord_cache/belongs_to_association.rb

@@ -1,19 +1,22 @@
 module ActiveRecordCache
   module BelongsToAssociation
+    extend ActiveSupport::Concern
     
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :find_target, :caching
-      end
+    included do
+      alias_method_chain :find_target, :caching
     end
-
-  protected
-
-    def find_target_with_caching
-      if klass.use_activerecord_cache
-        klass.find_through_cache(owner[reflection.foreign_key])
-      else
-        find_target_without_caching
+    
+    
+    module InstanceMethods
+      
+    private
+    
+      def find_target_with_caching
+        if klass.use_activerecord_cache && reflection.foreign_key == klass.primary_key
+          klass.find_through_cache(owner[reflection.foreign_key]).tap { |record| set_inverse_instance(record) }
+        else
+          find_target_without_caching
+        end
       end
     end
     

data/lib/activerecord_cache/belongs_to_preloader.rb

@@ -0,0 +1,23 @@
+module ActiveRecordCache
+  module BelongsToPreloader
+    extend ActiveSupport::Concern
+    
+    included do
+      alias_method_chain :records_for, :caching
+    end
+    
+    
+    module InstanceMethods
+      
+      def records_for_with_caching(ids)
+        if klass.use_activerecord_cache && association_key.name == klass.primary_key
+          find_some_through_cache(ids)
+        else
+          records_for_without_caching(ids) 
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/activerecord_cache/errors.rb

@@ -1,9 +1,6 @@
 module ActiveRecordCache
 
-  class CachingNotEnabled < StandardError
-  end
-  
-  class RecordTypeMismatch < StandardError
+  class CacheNotEnabled < StandardError
   end
   
 end

data/lib/activerecord_cache/finder_methods.rb

@@ -1,64 +1,67 @@
 module ActiveRecordCache
   module FinderMethods
+    extend ActiveSupport::Concern
     
-    def self.included(base)
-      base.module_eval do
-        alias_method_chain :find_by_attributes, :caching
-        alias_method_chain :find_some, :caching
-        alias_method_chain :find_one, :caching
-      end
+    included do
+      alias_method_chain :find_by_attributes, :caching
+      alias_method_chain :find_some, :caching
+      alias_method_chain :find_one, :caching
     end
-    
-  protected
 
-    def find_by_attributes_with_caching(match, attributes, *args)
-      unless cached_lookup_allowed? && attributes == Array(@klass.primary_key) # must only be finding by primary key
-        return find_by_attributes_without_caching(match, attributes, *args)
-      end
+    module InstanceMethods
       
-      ids = Array(args.first)
+    protected
       
-      results = case match.finder
-      when :all   then ids.map {|id| @klass.find_through_cache(id)}.compact
-      when :first then @klass.find_through_cache(ids.first)
-      when :last  then @klass.find_through_cache(ids.last)
-      end
+      def find_by_attributes_with_caching(match, attributes, *args)
+        unless cached_lookup_allowed? && attributes == Array(@klass.primary_key) && (match.finder == :all || !args.first.is_a?(Array))
+          return find_by_attributes_without_caching(match, attributes, *args)
+        end
+        
+        param = args.first
       
-      results
-    end
+        results = case match.finder
+        when :all   then @klass.find_some_through_cache(Array(param))
+        when :first then @klass.find_through_cache(param)
+        when :last  then @klass.find_through_cache(param)
+        end
+      
+        results
+      end
     
     
-    def find_some_with_caching(ids)
-      return find_some_without_caching(ids) unless cached_lookup_allowed?
+      def find_some_with_caching(ids)
+        return find_some_without_caching(ids) unless cached_lookup_allowed?
       
-      results = ids.map {|id| @klass.find_through_cache(id)}.compact
+        results = find_some_through_cache(ids)
+
+        if results.size != ids.size
+          error = "Couldn't find all #{@klass.name.pluralize} with IDs "
+          error << "(#{ids.join(", ")}) (found #{results.size} results, but was looking for #{ids.size})"
+          raise ActiveRecord::RecordNotFound, error
+        end
       
-      if results.size != ids.size
-        error = "Couldn't find all #{@klass.name.pluralize} with IDs "
-        error << "(#{ids.join(", ")}) (found #{result.size} results, but was looking for #{ids.size})"
-        raise ActiveRecord::RecordNotFound, error
+        results
       end
-      
-      results
-    end
     
     
-    def find_one_with_caching(id)
-      return find_one_without_caching(id) unless cached_lookup_allowed?
+      def find_one_with_caching(id)
+        return find_one_without_caching(id) unless cached_lookup_allowed?
       
-      record = @klass.find_through_cache(id)
+        record = @klass.find_through_cache(id)
       
-      unless record
-        raise ActiveRecord::RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}"
-      end
+        unless record
+          raise ActiveRecord::RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}"
+        end
       
-      record
-    end
+        record
+      end
     
     
-    # only support the most basic lookups through the cache
-    def cached_lookup_allowed?
-      @klass.use_activerecord_cache && arel.where_sql.nil? && @limit_value.nil? && @offset_value.nil?
+      # only support the most basic lookups through the cache
+      def cached_lookup_allowed?
+        @klass.use_activerecord_cache && arel.where_sql.nil? && arel.join_sql.nil? && @limit_value.nil? && @offset_value.nil?
+      end
+      
     end
     
   end

data/lib/activerecord_cache/railtie.rb

@@ -8,6 +8,8 @@ class ActiveRecordCache::Railtie < Rails::Railtie
       ActiveRecord::Base.send(:include, ActiveRecordCache::Base)
       ActiveRecord::FinderMethods.send(:include, ActiveRecordCache::FinderMethods)
       ActiveRecord::Associations::BelongsToAssociation.send(:include, ActiveRecordCache::BelongsToAssociation)
+      ActiveRecord::Associations::Preloader::BelongsTo.send(:include, ActiveRecordCache::BelongsToPreloader)
+      ActiveRecord::Relation.send(:include, ActiveRecordCache::Relation)
     end
   end
   

data/lib/activerecord_cache/relation.rb

@@ -0,0 +1,22 @@
+module ActiveRecordCache
+  module Relation
+    extend ActiveSupport::Concern
+    
+    included do
+      alias_method_chain :to_a, :caching
+    end
+    
+    module InstanceMethods
+      def to_a_with_caching
+        previously_loaded = loaded?
+
+        records = to_a_without_caching
+        records.each(&:write_to_cache) if @klass.use_activerecord_cache && !previously_loaded
+        
+        records
+      end
+      
+    end
+    
+  end
+end

data/lib/activerecord_cache/version.rb

@@ -2,7 +2,7 @@ module ActiveRecordCache
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/lib/activerecord_cache.rb

@@ -4,5 +4,7 @@ end
 require File.join(File.dirname(__FILE__), 'activerecord_cache/base')
 require File.join(File.dirname(__FILE__), 'activerecord_cache/finder_methods')
 require File.join(File.dirname(__FILE__), 'activerecord_cache/belongs_to_association')
+require File.join(File.dirname(__FILE__), 'activerecord_cache/belongs_to_preloader')
+require File.join(File.dirname(__FILE__), 'activerecord_cache/relation')
 
 require 'activerecord_cache/railtie.rb' if defined?(Rails)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_cache
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-14 00:00:00.000000000Z
+date: 2012-02-16 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2167650840 !ruby/object:Gem::Requirement
+  requirement: &2167643440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 3.1.3
   type: :runtime
   prerelease: false
-  version_requirements: *2167650840
+  version_requirements: *2167643440
 description: Caches ActiveRecord models for simple finds using the Rails low-level
   cache
 email:
@@ -37,9 +37,11 @@ files:
 - lib/activerecord_cache.rb
 - lib/activerecord_cache/base.rb
 - lib/activerecord_cache/belongs_to_association.rb
+- lib/activerecord_cache/belongs_to_preloader.rb
 - lib/activerecord_cache/errors.rb
 - lib/activerecord_cache/finder_methods.rb
 - lib/activerecord_cache/railtie.rb
+- lib/activerecord_cache/relation.rb
 - lib/activerecord_cache/version.rb
 homepage: https://github.com/davedoan/activerecord_cache
 licenses: