activerecord_cache 0.0.6 → 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc8aa7320c445aea2920adb2282e87eaf140c084
+  data.tar.gz: ef5d398cf49741e94e3b1073ba619e0c810559b7
+SHA512:
+  metadata.gz: b57793fdef8d3b740e866bab4595401201f211e881b91e198c77c809ed99770b39563a059805745d374da2f2a5552efd6b3ddcf9384ed0d0a981cc70095fc66a
+  data.tar.gz: ccb1921116861244af6285ffaa82106f28279d8e7ac328521d30bad004a031ef877fd7a96266ec399ea8e20d492ea97fe70092bb4e54b451c0e096afd8ebb85d

data/Gemfile

@@ -2,3 +2,8 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in activerecord_cache.gemspec
 gemspec
+
+group :test do
+  gem 'sqlite3'
+  gem 'bourne'
+end

data/Gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: .
+  specs:
+    activerecord_cache (0.0.7)
+      rails (~> 4.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (4.0.8)
+      actionpack (= 4.0.8)
+      mail (~> 2.5.4)
+    actionpack (4.0.8)
+      activesupport (= 4.0.8)
+      builder (~> 3.1.0)
+      erubis (~> 2.7.0)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    activemodel (4.0.8)
+      activesupport (= 4.0.8)
+      builder (~> 3.1.0)
+    activerecord (4.0.8)
+      activemodel (= 4.0.8)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.8)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.8)
+      i18n (~> 0.6, >= 0.6.9)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.2)
+    bourne (1.5.0)
+      mocha (>= 0.13.2, < 0.15)
+    builder (3.1.4)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.11)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    metaclass (0.0.4)
+    mime-types (1.25.1)
+    minitest (4.7.5)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.10.1)
+    polyglot (0.3.5)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (4.0.8)
+      actionmailer (= 4.0.8)
+      actionpack (= 4.0.8)
+      activerecord (= 4.0.8)
+      activesupport (= 4.0.8)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.0.8)
+      sprockets-rails (~> 2.0)
+    railties (4.0.8)
+      actionpack (= 4.0.8)
+      activesupport (= 4.0.8)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.3.2)
+    sprockets (2.12.1)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.1.3)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (~> 2.8)
+    sqlite3 (1.3.9)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.40)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord_cache!
+  bourne
+  sqlite3

data/Rakefile

@@ -1,2 +1,32 @@
-require 'bundler'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TestPlugin'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
 Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/activerecord_cache.gemspec

@@ -17,5 +17,5 @@ Gem::Specification.new do |s|
 
   s.licenses = ['MIT']
 
-  s.add_dependency 'rails', ['>= 3.1.3', '<= 3.3.0']
+  s.add_dependency 'rails', ['~> 4.0.0']
 end

data/lib/activerecord_cache.rb

@@ -6,5 +6,6 @@ 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 File.join(File.dirname(__FILE__), 'activerecord_cache/errors')
 
 require 'activerecord_cache/railtie.rb' if defined?(Rails)

data/lib/activerecord_cache/base.rb

@@ -14,7 +14,7 @@ module ActiveRecordCache
       def cache_key(id_or_record)
         unless use_activerecord_cache
           message = "ActiveRecord cache is not enabled for #{self.name}"
-          raise ActiveRecordCache::CachingNotEnabled, message
+          raise ActiveRecordCache::CacheNotEnabled, message
         end
 
         if id_or_record.is_a?(ActiveRecord::Base)
@@ -53,7 +53,7 @@ module ActiveRecordCache
         end
 
         if cache_misses.present?
-          records += where(primary_key => cache_misses).all
+          records += where(primary_key => cache_misses).load
         end
 
         records

data/lib/activerecord_cache/finder_methods.rb

@@ -3,39 +3,18 @@ module ActiveRecordCache
     extend ActiveSupport::Concern
 
     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) && (match.finder == :all || !args.first.is_a?(Array))
-        return find_by_attributes_without_caching(match, attributes, *args)
-      end
-
-      param = args.first
-
-      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?
 
       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
+      raise_record_not_found_exception!(ids, result.size, ids.size) unless results.size == ids.size
 
       results
     end
@@ -43,11 +22,9 @@ module ActiveRecordCache
     def find_one_with_caching(id)
       return find_one_without_caching(id) unless cached_lookup_allowed?
 
-      record = @klass.find_through_cache(id)
+      record = find_through_cache(id)
 
-      unless record
-        raise ActiveRecord::RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}"
-      end
+      raise_record_not_found_exception!(id, 0, 1) unless record
 
       record
     end

data/lib/activerecord_cache/railtie.rb

@@ -6,10 +6,13 @@ 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)
       ActiveRecord::Associations::Preloader::BelongsTo.send(:include, ActiveRecordCache::BelongsToPreloader)
       ActiveRecord::Relation.send(:include, ActiveRecordCache::Relation)
+
+      # FinderMethods only gets included in ActiveRecord::Relation, so extend it there.
+      # This gets around some headaches caused by extending modules already included in other classes.
+      ActiveRecord::Relation.send(:include, ActiveRecordCache::FinderMethods)
     end
   end
   

data/lib/activerecord_cache/relation.rb

@@ -3,14 +3,12 @@ module ActiveRecordCache
     extend ActiveSupport::Concern
 
     included do
-      alias_method_chain :to_a, :caching
+      alias_method_chain :exec_queries, :caching
     end
 
-    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 && select_values.empty?
+    def exec_queries_with_caching
+      records = exec_queries_without_caching
+      records.each(&:write_to_cache) if @klass.use_activerecord_cache && select_values.empty?
 
       records
     end

data/lib/activerecord_cache/version.rb

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

data/test/activerecord_cache_test.rb

@@ -0,0 +1,167 @@
+require 'test_helper'
+
+class ActiveRecordCacheTest < ActiveSupport::TestCase
+
+  setup do
+    Rails.cache.clear
+  end
+
+
+
+  # Loading records should persist to cache
+  test "loading records using find should persist them to the cache" do
+    Rails.cache.expects(:write).twice
+    CachedRecord.find(1, 2)
+  end
+
+  test "loading all records should persist them to the cache" do
+    Rails.cache.expects(:write).twice
+    CachedRecord.all.load    
+  end
+
+  test "loading records using a where should persist them to the cache" do
+    Rails.cache.expects(:write).once
+    CachedRecord.where(:name => 'John').load    
+  end
+
+
+
+  # Finders should use the cache
+  test "#find(id) should use the cache" do
+    cache_records(1)
+
+    assert_query_count 0 do
+      CachedRecord.find(1)
+    end
+  end
+
+  test "#find(ids) should use the cache" do
+    cache_records(1,2)
+
+    assert_query_count 0 do
+      CachedRecord.find(1, 2)
+    end
+  end
+
+  test "#find(ids) with some cached records should query for additional records" do
+    cache_records(1)
+
+    assert_query_count 1 do
+      CachedRecord.find(1, 2)
+    end
+  end
+
+
+
+  # Complex queries should skip the cache
+  test "#where(:id => id, :other => criteria) should NOT use the cache" do
+    cache_records(1)
+
+    records = CachedRecord.where(:id => 1, :name => 'Bogus').load
+
+    assert records.empty?, 'should not find cached record'
+  end
+
+  test "#select(:id) should NOT use the cache" do
+    cache_records(1)
+
+    Rails.cache.expects(:write).never
+    CachedRecord.select(:id).load
+  end
+
+
+
+  # belongs_to associations should use the cache
+  test "accessing cached associations should use the cache" do
+    cache_records(1)
+    associated = AssociatedRecord.find(1)
+
+    assert_query_count 0 do
+      associated.cached_record
+    end
+  end
+
+  test "accessing associations should persist records to the cache" do
+    associated = AssociatedRecord.find(1)
+
+    Rails.cache.expects(:write).once
+    associated.cached_record
+  end
+
+  test "associations that do not reference the primary key should NOT use the cache" do
+    cache_records(1, 2)
+    non_primary = NonPrimaryAssociated.find(1)
+
+    assert_query_count 1 do
+      non_primary.cached_record
+    end
+  end
+
+
+
+  # Preloading associations should use the cache
+  test "preloading associations should use the cache" do
+    cache_records(1)
+
+    assert_query_count 1 do
+      AssociatedRecord.includes(:cached_record).find(1)
+    end
+  end
+
+  test "preloading associations should persist records to the cache" do
+    Rails.cache.expects(:write).once
+    AssociatedRecord.includes(:cached_record).find(1)
+  end
+
+  test "preloading associations that do not reference the primary key should NOT use the cache" do
+    cache_records(1, 2)
+
+    assert_query_count 2 do
+      NonPrimaryAssociated.includes(:cached_record).find(1)
+    end
+  end
+
+
+
+  # Saving and destroying
+  test "saving a record should write it to the cache" do
+    Rails.cache.expects(:write).once
+    CachedRecord.create!({})
+  end
+
+  test "destroying a record should remove it from the cache" do
+    Rails.cache.expects(:delete).once
+    CachedRecord.find(1).destroy
+  end
+
+
+
+  private
+
+  def assert_query_count(expected_count, &block)
+    count = count_queries do
+      yield block
+    end
+
+    assert_equal expected_count, count, "expected #{expected_count} queries"
+  end
+
+  def count_queries(&block)
+    count = 0
+
+    counter = ->(name, started, finished, unique_id, payload) {
+      unless payload[:name].in? %w[ CACHE SCHEMA ]
+        count += 1
+      end
+    }
+
+    ActiveSupport::Notifications.subscribed(counter, "sql.active_record", &block)
+
+    count
+  end
+
+  def cache_records(*records)
+    CachedRecord.find(Array(records).flatten)
+  end
+
+end