arid_cache 1.0.2 → 1.0.3

data/Gemfile

@@ -0,0 +1,18 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gem 'activerecord', '=2.3.8'
+gem 'activesupport', '=2.3.8'
+gem 'sqlite3-ruby', '=1.3.1'
+
+gem 'will_paginate', '=2.3.15'
+gem 'jeweler', '=1.4.0'
+
+gem 'ruby-debug', '=0.10.3'
+gem 'ruby-debug-base', '=0.10.3'
+gem 'machinist', '=1.0.6'
+gem 'faker', '=0.3.1'
+gem 'rspec', '=1.3.0', :require => 'spec'
+gem 'test-unit', '=1.2.3'
+gem 'mocha', '=0.9.8'
+gem 'arid_cache', :path => "./"

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    arid_cache (1.0.2)
+      will_paginate
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activerecord (2.3.8)
+      activesupport (= 2.3.8)
+    activesupport (2.3.8)
+    columnize (0.3.1)
+    faker (0.3.1)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    hoe (2.6.2)
+      rake (>= 0.8.7)
+      rubyforge (>= 2.0.4)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    linecache (0.43)
+    machinist (1.0.6)
+    mocha (0.9.8)
+      rake
+    rake (0.8.7)
+    rspec (1.3.0)
+    ruby-debug (0.10.3)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.3.0)
+    ruby-debug-base (0.10.3)
+      linecache (>= 0.3)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    sqlite3-ruby (1.3.1)
+    test-unit (1.2.3)
+      hoe (>= 1.5.1)
+    will_paginate (2.3.15)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (= 2.3.8)
+  activesupport (= 2.3.8)
+  arid_cache!
+  faker (= 0.3.1)
+  jeweler (= 1.4.0)
+  machinist (= 1.0.6)
+  mocha (= 0.9.8)
+  rspec (= 1.3.0)
+  ruby-debug (= 0.10.3)
+  ruby-debug-base (= 0.10.3)
+  sqlite3-ruby (= 1.3.1)
+  test-unit (= 1.2.3)
+  will_paginate (= 2.3.15)

data/README.rdoc

@@ -9,9 +9,9 @@ AridCache simplifies caching by supporting auto-expiring cache keys - as well as
 == Install
 
 Add this to your <tt>config/environment.rb</tt> file:
-  
+
   config.gem 'arid_cache'
-  
+
 Then
 
   rake gems:install
@@ -28,7 +28,7 @@ The way you interact with the cache via your model methods is to prepend the met
 
   User.cached_count            # cache key is arid-cache-user-count
   genre.cached_top_ten_tracks  # cache key is arid-cache-genres/<id>-top_ten_tracks
-  
+
 You can also define caches that use compositions of methods or named scopes, or other complex queries, without having to add a new method to your class.  This way you can also create different caches that all use the same method.  For example,
 
   # cache key is arid-cache-user-most_active_users
@@ -78,13 +78,13 @@ To dynamically define caches just pass a block to your <tt>cached_</tt> calls.
   User.cached_most_active_users do
     active.find(:order => 'activity DESC', :limit => 5)
   end
-  
+
   => [#<User id: 23>, #<User id: 30>, #<User id: 5>, #<User id: 2>, #<User id: 101>]
-  
+
   user.cached_favorite_pets do
     pets.find(:all, :conditions => { 'favorite' => true })
   end
-  
+
   => [#<Pet id: 11>, #<Pet id: 21>, #<Pet id: 3>]
 
 === Configuring Caches on your Models
@@ -100,12 +100,12 @@ You can pass a hash of options to <tt>instance_caches</tt> and <tt>class_caches<
         popular(:limit => 10, :order => 'popularity DESC')
       end
     end
-    
+
     instance_caches(:order => 'release_date DESC') do
       highlight_tracks(:include => [:album, :artist]) do
         cached_tracks(:limit => 10, :include => [:album, :artist])
       end
-      highlight_artists(:order => nil) do   # override the global :order option 
+      highlight_artists(:order => nil) do   # override the global :order option
         cached_artists(:limit => 10)
       end
       highlight_albums(:include => :artist) do
@@ -113,7 +113,7 @@ You can pass a hash of options to <tt>instance_caches</tt> and <tt>class_caches<
       end
     end
   end
-  
+
   # app/controllers/genre_controller.rb
   @most_popular = Genre.cached_most_popular
   @tracks  = @genre.cached_highlight_tracks
@@ -135,8 +135,8 @@ AridCache cache keys are defined based on the methods you call to interact with
 
   Album.cached_featured_albums  => cache key is arid-cache-album-featured_albums
   album.cached_top_tracks       => cache key is arid-cache-albums/<id>-top_tracks
-    
-Caches on model instances can be set to automatically incorporate the ActiveRecord <tt>cache_key</tt> which includes the <tt>updated_at</tt> timestamp of that instance, making them auto-expire when the instance is updated.  
+
+Caches on model instances can be set to automatically incorporate the ActiveRecord <tt>cache_key</tt> which includes the <tt>updated_at</tt> timestamp of that instance, making them auto-expire when the instance is updated.
 
 To incorporate the the <tt>cache_key</tt> pass <b><tt>:auto_expire => true</tt></b> to your cache method:
 
@@ -153,22 +153,22 @@ If you need to examine values in the cache yourself you can build the AridCache
   Album.arid_cache_key('featured_albums') => arid-cache-album-featured_albums
   album.arid_cache_key('top_tracks')      => arid-cache-albums/2-top_tracks
   album.arid_cache_key('top_tracks', :auto_expire => true) => arid-cache-albums/2-20091211120100-top_tracks
-  
+
 == Managing your Caches
 
 === Deleting & Expiring Caches
 
 AridCache provides methods to help you clear your caches:
-  
+
   AridCache.clear_caches      => expires all AridCache caches
   Model.clear_caches          => expires class and instance-level caches for this model
   Model.clear_instance_caches => expires instance-level caches for this model
   Model.clear_class_caches    => expires class-level caches for this model
-  
+
 The <tt>Model.clear_caches</tt> methods are also available on all model instances.
 
 <B>Your cache store needs to support the <tt>delete_matched</tt> method for the above to work. Currently MemCacheStore and MemoryStore do not.</b>
- 
+
 Alternatively you can pass a <b><tt>:force => true</tt></b> option in your <tt>cached_</tt> calls to force a refresh of a particular cache, while still returning the refreshed results.  For example:
 
   Album.cached_featured_albums(:force => true)  => returns featured albums
@@ -190,7 +190,7 @@ If you would like to be able to pass more options to your cache store (like <tt>
 
   AridCache::CacheProxy::OPTIONS_FOR_CACHE.push(:raw, :unless_exist)
 
-== Extras 
+== Extras
 
 === Cached Counts
 
@@ -199,7 +199,7 @@ AridCache stores the count as well so the next time you request the count it
 just takes a single read from the cache.
 
 To get the count just append <tt>_count</tt> to your <tt>cached_</tt> call.  For example, if we have a cache like <tt>album.cached_tracks</tt> we can get the count by calling,
-  
+
   album.cached_tracks        => returns an array of tracks
   album.cached_tracks_count  => returns the count with a single read from the cache
 
@@ -207,7 +207,7 @@ This is also supported for your non-ActiveRecord collections if the collection <
 
   album.cached_similar_genres       => returns ['Pop', 'Rock', 'Rockabilly']
   album.cached_similar_genres_count => returns 3
-  
+
 Sometimes you may want the collection count without loading and caching the collection itself.  AridCache is smart enough that if you only ask for a count it will only query for the count.  This is only possible if the return value of your method is a named scope or association proxy (since these are lazy-loaded unlike a call to <tt>find()</tt>).
 
 In the example above if we only ever call <tt>album.cached_tracks_count</tt>, only the count will be cached.  If we subsequently call <tt>album.cached_tracks</tt> the collection will be loaded and the IDs cached as per normal.
@@ -222,21 +222,37 @@ AridCache supports pagination using WillPaginate.  If you are not changing the o
 
 An advantage of using AridCache is that since we already have the size of the collection in the cache no query is required to set the <tt>:total_entries</tt> on the <tt>WillPaginate::Collection</tt>.
 
-To paginate just pass a <tt>:page</tt> option in your call to <tt>cached_</tt>.  If you don't pass a value for <tt>:per_page</tt> AridCache gets the value from <tt>Model.per_page</tt>.
+To paginate just pass a <tt>:page</tt> option in your call to <tt>cached_</tt>.  If you don't pass a value for <tt>:per_page</tt> AridCache gets the value from <tt>Model.per_page</tt>, which is what <tt>WillPaginate</tt> uses.
 
 Some examples of pagination:
 
   User.cached_active(:page => 1, :per_page => 30)
-  User.cached_active(:page => 2)                  # uses User.per_page 
+  User.cached_active(:page => 2)                  # uses User.per_page
   user.cached_pets(:page => 1)                    # uses Pet.per_page
 
-If you want to paginate using a different ordering, pass an <tt>:order</tt> option.  Because the order is being changed AridCache cannot paginate in memory.  Instead, the cached IDs are passed to your <tt>Model.paginate</tt> method along with any other options and the database will order the collection and apply limits etc.
+If you want to paginate using a different ordering, pass an <tt>:order</tt> option.  Because the order is being changed AridCache cannot paginate in memory.  Instead, the cached IDs are passed to your <tt>Model.paginate</tt> method along with any other options and the database will order the collection, apply limits and offsets, etc.  Because the number of records the database deals with is limited, this is still much, much faster than ordering over the whole table.
 
 For example, the following queries will work:
 
   user.cached_companies(:page => 1, :per_page => 3, :order => 'name DESC')
   user.cached_companies(:page => 1, :per_page => 3, :order => 'name ASC')
-  
+
+By specifying an <tt>:order</tt> option in our cached call we can get different "views" of the cached collection.  I think this a "good thing".  However, you need to be aware that in order to guarantee that the ordering you requested is the same as the order of the initial results (when the cache was primed), we have to order in the database.  This results in two queries being executed the first time you query the cache (one to prime it and the other to order and return the results).  If no order option is specified, we can skip the second query and do everything in memory.
+
+If you have an expensive cache and don't want that extra query, just define a new cache with your desired ordering and use that.  Make sure that the order of the initial results matches your desired ordering.  Building on the example above we could do:
+
+  User.instance_caches do
+    companies_asc do
+      companies(:order => 'name ASC')
+    end
+    companies_desc do
+      companies(:order => 'name DESC')
+    end
+  end
+  user.cached_companies_asc(:page => 1, :per_page => 3)
+  user.cached_companies_desc(:page => 1, :per_page => 3)
+
+
 === Limit & Offset
 
 You apply <tt>:limit</tt> and <tt>:offset</tt> options in a similar manner to the <tt>:page</tt> and <tt>:per_page</tt> options.  The limit and offset will be applied in memory and only the resulting subset selected from the target table - unless you specify a new order.
@@ -244,18 +260,18 @@ You apply <tt>:limit</tt> and <tt>:offset</tt> options in a similar manner to th
   user.cached_pets(:limit => 2, :include => :toys)
   user.cached_pets(:limit => 2, :offset => 3, :include => :toys)
   genre.cached_top_ten_tracks { cached_tracks(:limit => 10, :order => 'popularity DESC') }
-  
+
 === Other Options to <tt>find</tt>
-  
+
 You can pass options like <tt>:include</tt> (or any other valid <tt>find</tt> options) to augment the results of your cached query.  Just because all of the options are supported, does not mean it's a good idea to use them, though.  Take a look at your logs to see how AridCache is interacting with the cache and the database if you don't get the results you expect.
 
 For example, assume we have a <tt>named_scope :active</tt> on <tt>User</tt> which gives the active users.  We can call:
-  
+
   User.cached_active.paginate(:page => 2, :per_page => 10, :include => :preferences)
   User.cached_active(:limit => 10, :offset => 10, :include => :preferences)
 
 (These calls return similar results, except that the first call returns a <tt>WillPaginate::Collection</tt> and the second just returns an <tt>Array</tt>.)
-  
+
 == Efficiency
 
 * AridCache intercepts calls to <tt>cached_</tt> methods using <tt>method_missing</tt> then defines those methods on your models as they are called, so they bypass method missing on subsequent calls.
@@ -265,10 +281,10 @@ For example, assume we have a <tt>named_scope :active</tt> on <tt>User</tt> whic
 
 == Compatibility
 
-Tested on Ruby 1.8.6, 1.8.7 and 1.9.1. 
+Tested on Ruby 1.8.6, 1.8.7 and 1.9.1.
 
 For Ruby < 1.8.7 you probably want to include the following to extend the Array class with a <tt>count</tt> method.  Otherwise your <tt>cached_<key>_count</tt> calls probably won't work:
-  
+
   Array.class_eval { alias count size }
 
 The version of Rails shouldn't matter much, but it's working on 2.3.4.

data/Rakefile

@@ -1,5 +1,6 @@
 require 'rubygems'
-require 'rake'
+require 'bundler/setup'
+Bundler.require
 
 begin
   require 'jeweler'
@@ -25,19 +26,19 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-# require 'spec/rake/spectask'
-# Spec::Rake::SpecTask.new(:spec) do |spec|
-#   spec.libs << 'lib' << 'spec'
-#   spec.spec_files = FileList['spec/**/*_spec.rb']
-# end
-#
-# Spec::Rake::SpecTask.new(:rcov) do |spec|
-#   spec.libs << 'lib' << 'spec'
-#   spec.pattern = 'spec/**/*_spec.rb'
-#   spec.rcov = true
-# end
-#
-# task :spec => :check_dependencies
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "1.0.2"
+  s.version = "1.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2010-09-07}
+  s.date = %q{2010-10-21}
   s.description = %q{AridCache makes caching easy and effective.  AridCache supports caching on all your model named scopes, class methods and instance methods right out of the box.  AridCache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
 AridCache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
 }
@@ -20,6 +20,8 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
   ]
   s.files = [
     ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -35,17 +37,21 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "spec/arid_cache_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
+     "spec/support/ar_query.rb",
+     "spec/support/custom_methods.rb",
+     "spec/support/matchers.rb",
      "tasks/arid_cache_tasks.rake",
      "test/arid_cache_test.rb",
      "test/console",
-     "test/db/prepare.rb",
-     "test/db/schema.rb",
-     "test/lib/active_support/cache/file_store_extras.rb",
+     "test/lib/add_query_counting_to_active_record.rb",
      "test/lib/blueprint.rb",
+     "test/lib/db_prepare.rb",
+     "test/lib/fix_active_support_file_store_expires_in.rb",
+     "test/lib/mock_rails.rb",
+     "test/lib/models/company.rb",
+     "test/lib/models/empty_user_relation.rb",
+     "test/lib/models/user.rb",
      "test/log/.gitignore",
-     "test/models/company.rb",
-     "test/models/empty_user_relation.rb",
-     "test/models/user.rb",
      "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/kjvarga/arid_cache}
@@ -56,14 +62,18 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
   s.test_files = [
     "spec/arid_cache_spec.rb",
      "spec/spec_helper.rb",
+     "spec/support/ar_query.rb",
+     "spec/support/custom_methods.rb",
+     "spec/support/matchers.rb",
      "test/arid_cache_test.rb",
-     "test/db/prepare.rb",
-     "test/db/schema.rb",
-     "test/lib/active_support/cache/file_store_extras.rb",
+     "test/lib/add_query_counting_to_active_record.rb",
      "test/lib/blueprint.rb",
-     "test/models/company.rb",
-     "test/models/empty_user_relation.rb",
-     "test/models/user.rb",
+     "test/lib/db_prepare.rb",
+     "test/lib/fix_active_support_file_store_expires_in.rb",
+     "test/lib/mock_rails.rb",
+     "test/lib/models/company.rb",
+     "test/lib/models/empty_user_relation.rb",
+     "test/lib/models/user.rb",
      "test/test_helper.rb"
   ]
 

data/lib/arid_cache/cache_proxy.rb

@@ -68,6 +68,11 @@ module AridCache
 
       self.cache_key = object.arid_cache_key(key, opts_for_cache_key)
       self.cached = Rails.cache.read(cache_key, opts_for_cache)
+      self.klass = if self.cached && self.cached.is_a?(AridCache::CacheProxy::Result) # infer class of the results to return
+        self.cached.klass
+      else
+        object_base_class
+      end
     end
 
     def fetch_count
@@ -89,10 +94,6 @@ module AridCache
         execute_find
       elsif cached.is_a?(AridCache::CacheProxy::Result)
         if cached.has_ids?
-
-          # Infer the class of the objects we are returning
-          self.klass = cached.klass || object_base_class
-
           fetch_from_cache
         else
           execute_find
@@ -116,11 +117,9 @@ module AridCache
         if paginate?
 
           # Return a paginated collection
-
           if cached.ids.empty?
 
             # No ids, return an empty WillPaginate result
-
             [].paginate(opts_for_paginate)
 
           elsif combined_options.include?(:order)
@@ -128,14 +127,12 @@ module AridCache
             # An order has been specified.  We have to go to the database
             # and paginate there because the contents of the requested
             # page will be different.
-
             klass.paginate(cached.ids, { :total_entries => cached.ids.size }.merge(opts_for_find.merge(opts_for_paginate)))
 
           else
 
             # Order is unchanged.  We can paginate in memory and only select
             # those ids that we actually need.  This is the most efficient.
-
             paged_ids = cached.ids.paginate(opts_for_paginate)
             paged_ids.replace(klass.find_all_by_id(paged_ids, opts_for_find(paged_ids)))
 
@@ -146,13 +143,11 @@ module AridCache
           # We are returning a regular (non-paginated) result.
           # If we don't have any ids, that's an empty result
           # in any language.
-
           []
 
         elsif combined_options.include?(:order)
 
           # An order has been specified, so use it.
-
           klass.find_all_by_id(cached.ids, opts_for_find)
 
         else
@@ -160,7 +155,6 @@ module AridCache
           # No order has been specified, so we have to maintain
           # the current order.  We do this by passing some extra
           # SQL which orders by the current array ordering.
-
           offset, limit = combined_options.delete(:offset) || 0, combined_options.delete(:limit) || cached.count
           ids = cached.ids[offset, limit]
 
@@ -201,7 +195,14 @@ module AridCache
         Rails.cache.write(cache_key, cached, opts_for_cache)
 
         self.cached = cached
-        return_records(records)
+        # An order has been specified.  We have to go to the database
+        # to order because we can't be sure that the current order is the same as the cache.
+        if cached.is_a?(AridCache::CacheProxy::Result) && combined_options.include?(:order)
+          self.klass = self.cached.klass # TODO used by fetch_from_cache needs refactor
+          fetch_from_cache
+        else
+          process_result_in_memory(records)
+        end
       end
 
       # Convert records to an array before calling paginate.  If we don't do this
@@ -222,7 +223,7 @@ module AridCache
       # to define it in a block and have a new cache for it:
       #
       # model.my_special_collection { the_collection(:order => 'new order', :limit => 10) }
-      def return_records(records)
+      def process_result_in_memory(records)
         if opts.include?(:page)
           records = records.respond_to?(:to_a) ? records.to_a : records
           records.respond_to?(:paginate) ? records.paginate(opts_for_paginate) : records

data/spec/arid_cache_spec.rb

@@ -1,7 +1,39 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "AridCache" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+  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/spec_helper.rb

@@ -1,12 +1,29 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'arid_cache'
-require 'spec'
+root_path = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$LOAD_PATH.unshift(File.join(root_path, '/test/lib')) # make requiring from test/lib easy
+
+require 'bundler/setup'
+Bundler.require
+
 require 'spec/autorun'
+require 'mock_rails'
+require 'blueprint'
+
+WillPaginate.enable_activerecord
+AridCache.init_rails
 
-require 'rubygems'
-require 'will_paginate'
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
 
 Spec::Runner.configure do |config|
-  
-end
+  include ActiveRecordQueryMatchers
+  config.mock_with :mocha
+
+  config.before(:all) do
+    Sham.reset(:before_all)
+  end
+
+  config.before(:each) do
+    Sham.reset(:before_each)
+    full_example_description = "#{self.class.description} #{@method_name}"
+    RAILS_DEFAULT_LOGGER.info("\n\n#{full_example_description}\n#{'-' * (full_example_description.length)}")
+  end
+end

data/spec/support/ar_query.rb

@@ -0,0 +1,128 @@
+module ActiveRecordQueryMatchers
+
+  class ArQuery  #:nodoc:
+    cattr_accessor :executed
+
+    @@recording_queries = false
+    def self.recording_queries?
+      @@recording_queries
+    end
+
+    def initialize(expected, &block)
+      @expected = expected
+      @block = block
+    end
+
+    def matches?(given_proc)
+      @eval_block = false
+      @eval_error = nil
+      ArQuery.executed = []
+      @@recording_queries = true
+
+      given_proc.call
+
+      if @expected.is_a?(Fixnum)
+        @actual = ArQuery.executed.length
+        @matched = @actual == @expected
+      else
+        @actual = ArQuery.executed.detect { |sql| @expected === sql }
+        @matched = !@actual.nil?
+      end
+
+      eval_block if @block && @matched && !negative_expectation?
+
+    ensure
+      ArQuery.executed = nil
+      @@recording_queries = false
+      return @matched && @eval_error.nil?
+    end
+
+    def eval_block
+      @eval_block = true
+      begin
+        @block[ArQuery.executed]
+      rescue Exception => err
+        @eval_error = err
+      end
+    end
+
+    def failure_message_for_should
+      if @eval_error
+        @eval_error.message
+      elsif @expected.is_a?(Fixnum)
+        "expected #{@expected}, got #{@actual}"
+      else
+        "expected to execute a query with pattern #{@expected.inspect}, but it wasn't"
+      end
+    end
+
+    def failure_message_for_should_not
+      if @expected.is_a?(Fixnum)
+        "did not expect #{@expected}"
+      else
+        "did not expect to execute a query with pattern #{@expected.inspect}, but it was executed"
+      end
+    end
+
+    def description
+      if @expected.is_a?(Fixnum)
+        @expected == 1 ? "execute 1 query" : "execute #{@expected} queries"
+      else
+        "execute query with pattern #{@expected.inspect}"
+      end
+    end
+
+    # Copied from raise_error
+    def negative_expectation?
+      @negative_expectation ||= !caller.first(3).find { |s| s =~ /should_not/ }.nil?
+    end
+
+  end
+
+  unless defined?(IGNORED_SQL)
+    # From active_record/test/cases/helper.rb :
+    ActiveRecord::Base.connection.class.class_eval do
+      IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+      def execute_with_query_record(sql, name = nil, &block)
+        if ArQuery.recording_queries?
+          ArQuery.executed << sql unless IGNORED_SQL.any? { |ignore| sql =~ ignore }
+        end
+        execute_without_query_record(sql, name, &block)
+      end
+      alias_method_chain :execute, :query_record
+    end
+  end
+
+  # :call-seq:
+  #   response.should query
+  #   response.should query(expected)
+  #   response.should query(expected) { |sql| ... }
+  #   response.should_not query
+  #   response.should_not query(expected)
+  #
+  # Accepts a Fixnum or a Regexp as argument.
+  #
+  # With no args, matches if exactly 1 query is executed.
+  # With a Fixnum arg, matches if the number of queries executed equals the given number.
+  # With a Regexp arg, matches if any query is executed with the given pattern.
+  #
+  # Pass an optional block to perform extra verifications of the queries matched.
+  # The argument of the block will receive an array of query strings that were executed.
+  #
+  # == Examples
+  #
+  #   lambda { @object.posts }.should query
+  #   lambda { @object.valid? }.should query(0)
+  #   lambda { @object.save }.should query(3)
+  #   lambda { @object.line_items }.should query(/SELECT DISTINCT/)
+  #   lambda { @object.line_items }.should query(1) { |sql| sql[0].should =~ /SELECT DISTINCT/ }
+  #
+  #   lambda { @object.posts }.should_not query
+  #   lambda { @object.valid? }.should_not query(0)
+  #   lambda { @object.save }.should_not query(3)
+  #   lambda { @object.line_items }.should_not query(/SELECT DISTINCT/)
+  #
+  def query(expected = 1, &block)
+    ArQuery.new(expected, &block)
+  end
+end

data/spec/support/custom_methods.rb

@@ -0,0 +1,7 @@
+class String
+  
+  def json_to_hash
+    HashWithIndifferentAccess.new JSON.parse(self)
+  end
+  
+end

data/spec/support/matchers.rb

@@ -0,0 +1,33 @@
+Spec::Matchers.define :include_keys do |*expected|
+  
+  match do |actual|
+    check_all_present(actual, expected) == []
+  end
+
+  failure_message_for_should do |actual|
+    "expected key #{check_all_present(actual, expected).first} but did not see it in #{actual.keys.map(&:to_sym)}"
+   end
+
+   def check_all_present actual, expected
+     keys_we_have = actual.keys.map(&:to_sym)
+     expected = [expected] unless expected.is_a?(Array)
+     remainder = expected.map(&:to_sym) - keys_we_have
+   end
+end
+
+Spec::Matchers.define :match_object do |object, *expected_matching_keys|
+
+  match do |actual|
+    check_specified_keys_match(actual, object, expected_matching_keys) == []
+  end
+
+  failure_message_for_should do |actual|
+    offending_key = check_specified_keys_match(actual, object, expected_matching_keys).first
+    "expected match for #{offending_key} but it did not. Expected: #{object.send(offending_key).inspect} but got #{actual[offending_key].inspect}"
+  end
+
+  def check_specified_keys_match actual, object, expected_matches
+    expected_matches = [expected_matches] unless expected_matches.is_a?(Array)
+    expected_matches.map(&:to_sym).map { |key| key unless (object.send(key) == actual[key]) }.compact
+  end
+end

data/test/arid_cache_test.rb

@@ -76,7 +76,7 @@ class AridCacheTest < ActiveSupport::TestCase
   end
 
   test "passes on options to find" do
-    actual = @user.cached_companies(:order => 'users.id DESC')
+    actual = @user.cached_companies(:order => 'users.id DESC', :include => [:owner])
     expected = @user.companies
     assert_equal expected, actual
     assert_equal expected.first, actual.first

data/test/console

@@ -1,8 +1,15 @@
-#!/usr/bin/env ruby
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-libs = []
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
-libs << 'irb/completion'
-libs << 'test_helper'
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require
+require 'mock_rails'
+require 'blueprint'
+require 'irb'
 
-exec "#{irb} -Ilib:test#{libs.map{ |l| " -r #{l}" }.join} --simple-prompt"
+WillPaginate.enable_activerecord
+AridCache.init_rails
+Blueprint.seeds
+
+ARGV.clear
+IRB.start

data/test/lib/add_query_counting_to_active_record.rb

@@ -0,0 +1,11 @@
+class << ActiveRecord::Base.connection
+  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SHOW FIELDS /]
+
+  def execute_with_counting(sql, name = nil, &block)
+    $query_count ||= 0
+    $query_count  += 1 unless IGNORED_SQL.any? { |r| sql =~ r }
+    execute_without_counting(sql, name, &block)
+  end
+
+  alias_method_chain :execute, :counting
+end

data/test/lib/db_prepare.rb

@@ -0,0 +1,34 @@
+require 'active_record'
+
+# Create an in-memory sqlite3 database
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
+
+# Schema
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+
+  ActiveRecord::Schema.define do
+    create_table "users", :force => true do |t|
+      t.column "name",  :text
+      t.column "email", :text
+      t.timestamps
+    end
+
+    create_table "companies", :force => true do |t|
+      t.column "name",  :text
+      t.column "owner_id", :integer
+      t.column "country_id", :integer
+      t.column "employees", :integer
+      t.timestamps
+    end
+
+    create_table "empty_user_relations", :force => true do |t|
+      t.column "user_id", :integer
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'models', '*.rb')].each { |f| require f }

data/test/lib/{active_support/cache/file_store_extras.rb → fix_active_support_file_store_expires_in.rb}

@@ -1,3 +1,4 @@
+# Add support for expiring file-cache store.
 
 module ActiveSupport
   module Cache

data/test/lib/mock_rails.rb

@@ -0,0 +1,29 @@
+require 'logger'
+require 'fix_active_support_file_store_expires_in'
+
+root_path = File.expand_path(File.join(File.dirname(__FILE__), '../../'))
+RAILS_DEFAULT_LOGGER = ENV["STDOUT"] ? Logger.new(STDOUT) : Logger.new(File.join(root_path, '/test/log/test.log'))
+RAILS_CACHE = ActiveSupport::Cache.lookup_store(:file_store, File.join(root_path, '/tmp/cache'))
+
+# Mock Rails
+Rails = Class.new do
+  cattr_accessor :logger, :cache
+  def self.cache
+    return RAILS_CACHE
+  end
+  def self.logger
+    return RAILS_DEFAULT_LOGGER
+  end
+end
+
+# Set loggers for all frameworks
+for framework in ([ :active_record, :action_controller, :action_mailer ])
+  if Object.const_defined?(framework.to_s.camelize)
+    framework.to_s.camelize.constantize.const_get("Base").logger = Rails.logger
+  end
+end
+ActiveSupport::Dependencies.logger = Rails.logger
+Rails.cache.logger = Rails.logger
+
+# Include this last otherwise the logger isn't set properly
+require 'db_prepare'

data/test/test_helper.rb

@@ -1,57 +1,19 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) # AridCache lib
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))       # test lib
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib')) # make requiring from test/lib easy
 
 require 'fileutils'
 require 'rubygems'
-require 'active_record'
-require 'active_support'
-require 'active_support/test_case'
+require 'bundler/setup'
+Bundler.require
 require 'test/unit' # required by ActiveSupport::TestCase
-require 'will_paginate'
-require 'ruby-debug'
-
-# Activate Will Paginate
-WillPaginate.enable_activerecord
+require 'active_support/test_case'
 
-# Add support for expiring file-cache store.
-require 'active_support/cache/file_store_extras'
+require 'mock_rails'
+require 'blueprint'
+require 'add_query_counting_to_active_record'
 
-# Activate AridCache
-require 'arid_cache'
+WillPaginate.enable_activerecord
 AridCache.init_rails
-
-# Setup logging
-log = File.expand_path(File.join(File.dirname(__FILE__), 'log', 'test.log'))
-RAILS_DEFAULT_LOGGER = ENV["STDOUT"] ? Logger.new(STDOUT) : Logger.new(log)
-
-# Setup the cache. Use the file-store cache because the
-# memory-store cache doesn't delete cache keys...I don't know why.
-RAILS_CACHE = ActiveSupport::Cache.lookup_store(:file_store, "#{File.dirname(__FILE__)}/tmp/cache")
-
-# Mock Rails
-Rails = Class.new do
-  cattr_accessor :logger, :cache
-  def self.cache
-    return RAILS_CACHE
-  end
-  def self.logger
-    return RAILS_DEFAULT_LOGGER
-  end
-end
-
-# Set loggers for all frameworks
-for framework in ([ :active_record, :action_controller, :action_mailer ])
-  if Object.const_defined?(framework.to_s.camelize)
-    framework.to_s.camelize.constantize.const_get("Base").logger = Rails.logger
-  end
-end
-ActiveSupport::Dependencies.logger = Rails.logger
-Rails.cache.logger = Rails.logger
-
-# Include this last otherwise the logger isn't set properly
-require 'db/prepare'
+Blueprint.seeds
 
 ActiveRecord::Base.logger.info("#{"="*25} RUNNING UNIT TESTS #{"="*25}\n\t\t\t#{Time.now.to_s}\n#{"="*70}")
-
 Array.class_eval { alias count size } if RUBY_VERSION < '1.8.7'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 1
   - 0
-  - 2
-  version: 1.0.2
+  - 3
+  version: 1.0.3
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,13 +15,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-07 00:00:00 -07:00
+date: 2010-10-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: will_paginate
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  name: will_paginate
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -30,12 +31,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :runtime
-  version_requirements: *id001
+  requirement: *id001
 - !ruby/object:Gem::Dependency 
-  name: will_paginate
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :development
+  name: will_paginate
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -44,12 +45,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  version_requirements: *id002
+  requirement: *id002
 - !ruby/object:Gem::Dependency 
-  name: faker
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  type: :development
+  name: faker
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -58,12 +59,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  version_requirements: *id003
+  requirement: *id003
 - !ruby/object:Gem::Dependency 
-  name: machinist
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  type: :development
+  name: machinist
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -72,8 +73,7 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  version_requirements: *id004
+  requirement: *id004
 description: |
   AridCache makes caching easy and effective.  AridCache supports caching on all your model named scopes, class methods and instance methods right out of the box.  AridCache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
   AridCache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
@@ -88,6 +88,8 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .gitignore
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -103,17 +105,21 @@ files:
 - spec/arid_cache_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/support/ar_query.rb
+- spec/support/custom_methods.rb
+- spec/support/matchers.rb
 - tasks/arid_cache_tasks.rake
 - test/arid_cache_test.rb
 - test/console
-- test/db/prepare.rb
-- test/db/schema.rb
-- test/lib/active_support/cache/file_store_extras.rb
+- test/lib/add_query_counting_to_active_record.rb
 - test/lib/blueprint.rb
+- test/lib/db_prepare.rb
+- test/lib/fix_active_support_file_store_expires_in.rb
+- test/lib/mock_rails.rb
+- test/lib/models/company.rb
+- test/lib/models/empty_user_relation.rb
+- test/lib/models/user.rb
 - test/log/.gitignore
-- test/models/company.rb
-- test/models/empty_user_relation.rb
-- test/models/user.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/kjvarga/arid_cache
@@ -152,12 +158,16 @@ summary: Automates efficient caching of your ActiveRecord collections, gives you
 test_files: 
 - spec/arid_cache_spec.rb
 - spec/spec_helper.rb
+- spec/support/ar_query.rb
+- spec/support/custom_methods.rb
+- spec/support/matchers.rb
 - test/arid_cache_test.rb
-- test/db/prepare.rb
-- test/db/schema.rb
-- test/lib/active_support/cache/file_store_extras.rb
+- test/lib/add_query_counting_to_active_record.rb
 - test/lib/blueprint.rb
-- test/models/company.rb
-- test/models/empty_user_relation.rb
-- test/models/user.rb
+- test/lib/db_prepare.rb
+- test/lib/fix_active_support_file_store_expires_in.rb
+- test/lib/mock_rails.rb
+- test/lib/models/company.rb
+- test/lib/models/empty_user_relation.rb
+- test/lib/models/user.rb
 - test/test_helper.rb

data/test/db/prepare.rb

@@ -1,33 +0,0 @@
-require 'active_record'
-require 'active_record/fixtures'
-
-# Create an in-memory test database and load the fixures into it
-ActiveRecord::Base.establish_connection(
-  :adapter  => "sqlite3",
-  :database => ":memory:"
-)
-
-# Schema
-ActiveRecord::Base.silence do
-  ActiveRecord::Migration.verbose = false
-  load(File.join(File.dirname(__FILE__), 'schema.rb'))
-end
-
-# Models
-Dir[File.join(File.dirname(__FILE__), '..', 'models', '*.rb')].each { |f| require f }
-
-# Populate
-require 'blueprint'
-Blueprint.seeds
-
-class << ActiveRecord::Base.connection
-  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SHOW FIELDS /]
-
-  def execute_with_counting(sql, name = nil, &block)
-    $query_count ||= 0
-    $query_count  += 1 unless IGNORED_SQL.any? { |r| sql =~ r }
-    execute_without_counting(sql, name, &block)
-  end
-
-  alias_method_chain :execute, :counting
-end

data/test/db/schema.rb

@@ -1,19 +0,0 @@
-ActiveRecord::Schema.define do
-  create_table "users", :force => true do |t|
-    t.column "name",  :text
-    t.column "email", :text
-    t.timestamps
-  end
-
-  create_table "companies", :force => true do |t|
-    t.column "name",  :text
-    t.column "owner_id", :integer
-    t.column "country_id", :integer
-    t.column "employees", :integer
-    t.timestamps
-  end
-
-  create_table "empty_user_relations", :force => true do |t|
-    t.column "user_id", :integer
-  end
-end