activerecord_cache 0.0.1

data/Gemfile

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

data/README.md

@@ -0,0 +1,22 @@
+# activerecord_cache
+
+Basic caching for ActiveRecord models using the Rails low-level cache (`Rails.cache`).
+
+### Installation
+
+In your Gemfile, add this line:
+
+    gem "activerecord_cache"
+
+### Usage
+
+To enable caching for a model:
+
+    class User < ActiveRecord::Baes
+      self.use_activerecord_cache = true
+    end
+
+Or:
+
+    User.use_activerecord_cache = true
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/activerecord_cache.gemspec

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'lib/activerecord_cache/version')
+
+Gem::Specification.new do |s|
+  s.name        = 'activerecord_cache'
+  s.version     = ActiveRecordCache::VERSION::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['David Doan']
+  s.email       = ['davedoan@gmail.com']
+  s.homepage    = 'https://github.com/davedoan/activerecord_cache'
+  s.summary     = 'A basic caching plugin for ActiveRecord'
+  s.description = 'Caches ActiveRecord models for simple finds using the Rails low-level cache'
+
+  # s.rubyforge_project = 'activerecord_cache'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+
+  s.licenses = ['MIT']
+
+  s.add_dependency 'rails', ['~> 3.1.3']
+end

data/lib/activerecord_cache/base.rb

@@ -0,0 +1,57 @@
+module ActiveRecordCache
+  module Base
+    
+    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
+    end
+    
+    module CacheMethods
+      def cache_key(id_or_record)
+        unless use_activerecord_cache
+          message = "ActiveRecord cache is not enabled for #{self.name}"
+          raise ActiveRecordCache::CachingNotEnabled, message
+        end
+        
+        if id_or_record.is_a?(ActiveRecord::Base)
+          id = id_or_record[id_or_record.class.primary_key]
+        else
+          id = id_or_record
+        end
+        
+        "#{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
+        end
+
+        Rails.cache.fetch(cache_key(id)) { where(primary_key => id).first }
+      end
+      
+      def write_to_cache(record)
+        unless use_activerecord_cache
+          message = "ActiveRecord cache is not enabled for #{self.name}"
+          raise ActiveRecordCache::CachingNotEnabled, message
+        end
+        
+        unless record.class == self
+          message = "Instance of #{self} expected, got #{record.class}"
+          raise ActiveRecordCache::RecordTypeMismatch, message
+        end
+        
+        Rails.cache.write(cache_key(record), record)
+      end
+      
+    end
+    
+  end
+end

data/lib/activerecord_cache/belongs_to_association.rb

@@ -0,0 +1,21 @@
+module ActiveRecordCache
+  module BelongsToAssociation
+    
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :find_target, :caching
+      end
+    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
+      end
+    end
+    
+  end
+end

data/lib/activerecord_cache/errors.rb

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

data/lib/activerecord_cache/finder_methods.rb

@@ -0,0 +1,65 @@
+module ActiveRecordCache
+  module FinderMethods
+    
+    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
+    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
+      
+      ids = Array(args.first)
+      
+      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
+      
+      results
+    end
+    
+    
+    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
+      
+      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
+      end
+      
+      results
+    end
+    
+    
+    def find_one_with_caching(id)
+      return find_one_without_caching(id) unless cached_lookup_allowed?
+      
+      record = @klass.find_through_cache(id)
+      
+      unless record
+        raise ActiveRecord::RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}"
+      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?
+    end
+    
+  end
+end

data/lib/activerecord_cache/railtie.rb

@@ -0,0 +1,14 @@
+require 'activerecord_cache'
+require 'rails'
+
+class ActiveRecordCache::Railtie < Rails::Railtie
+
+  initializer "activerecord_cache.initialize" do
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::Base.send(:include, ActiveRecordCache::Base)
+      ActiveRecord::FinderMethods.send(:include, ActiveRecordCache::FinderMethods)
+      ActiveRecord::Associations::BelongsToAssociation.send(:include, ActiveRecordCache::BelongsToAssociation)
+    end
+  end
+  
+end

data/lib/activerecord_cache/version.rb

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

data/lib/activerecord_cache.rb

@@ -0,0 +1,8 @@
+module ActiveRecordCache
+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 'activerecord_cache/railtie.rb' if defined?(Rails)

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Doan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &2167650840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *2167650840
+description: Caches ActiveRecord models for simple finds using the Rails low-level
+  cache
+email:
+- davedoan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- activerecord_cache.gemspec
+- lib/activerecord_cache.rb
+- lib/activerecord_cache/base.rb
+- lib/activerecord_cache/belongs_to_association.rb
+- lib/activerecord_cache/errors.rb
+- lib/activerecord_cache/finder_methods.rb
+- lib/activerecord_cache/railtie.rb
+- lib/activerecord_cache/version.rb
+homepage: https://github.com/davedoan/activerecord_cache
+licenses:
+- MIT
+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.15
+signing_key: 
+specification_version: 3
+summary: A basic caching plugin for ActiveRecord
+test_files: []