arid_cache 1.4.1 → 1.4.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ./
   specs:
-    arid_cache (1.4.1)
+    arid_cache (1.4.2)
       will_paginate
 
 GEM

data/README.rdoc

@@ -10,6 +10,8 @@ AridCache simplifies caching by supporting auto-expiring cache keys - as well as
 
 == Changes
 
+* v1.4.2: Add <tt>:proxy_out</tt> and <tt>:proxy_in</tt> options; <tt>AridCache::Proxies::IdProxy</tt>.  Support proxies as +Procs+.
+* v1.4.1: Default <tt>:page</tt> to <tt>1</tt> if it is +nil+
 * v1.4.0: Rails 3 fully supported!
 * v1.3.5: Backwards-compatibility fixes
 * v1.3.4: Inherited cache configurations: Cache options and cache blocks are inherited from superclasses

data/VERSION

@@ -1 +1 @@
-1.4.1
+1.4.2

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "1.4.1"
+  s.version = "1.4.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2011-04-19}
+  s.date = %q{2011-04-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.
 }
@@ -42,6 +42,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "lib/arid_cache/helpers.rb",
      "lib/arid_cache/inflector.rb",
      "lib/arid_cache/inflector/inflections.rb",
+     "lib/arid_cache/proxies.rb",
      "lib/arid_cache/railtie.rb",
      "lib/arid_cache/store.rb",
      "rails/init.rb",
@@ -53,6 +54,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "spec/arid_cache/cache_proxy/utilities_spec.rb",
      "spec/arid_cache/cache_proxy_spec.rb",
      "spec/arid_cache/helpers_spec.rb",
+     "spec/arid_cache/proxies_spec.rb",
      "spec/arid_cache/store_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
@@ -86,6 +88,7 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "spec/arid_cache/cache_proxy/utilities_spec.rb",
      "spec/arid_cache/cache_proxy_spec.rb",
      "spec/arid_cache/helpers_spec.rb",
+     "spec/arid_cache/proxies_spec.rb",
      "spec/arid_cache/store_spec.rb",
      "spec/spec_helper.rb",
      "spec/support/ar_query.rb",

data/lib/arid_cache.rb

@@ -8,9 +8,12 @@ require 'arid_cache/cache_proxy'
 require 'arid_cache/railtie' if defined?(Rails)
 require 'arid_cache/inflector'
 require 'arid_cache/framework'
+require 'arid_cache/proxies'
 
 module AridCache
   extend AridCache::Helpers
+  extend AridCache::CacheProxy::Utilities
+
   Error = Class.new(StandardError) #:nodoc:
 
   class << self

data/lib/arid_cache/cache_proxy/options.rb

@@ -33,7 +33,7 @@ module AridCache
       # @arg ids array of ids to order by unless an :order option is specified.
       def opts_for_find(ids)
         find_opts = reject { |k,v| !OPTIONS_FOR_FIND.include?(k) }
-        find_opts[:order] = AridCache::CacheProxy::Utilities.order_by(ids, self[:result_klass]) unless find_opts.include?(:order)
+        find_opts[:order] = AridCache.order_by(ids, self[:result_klass]) unless find_opts.include?(:order)
         find_opts[:limit] = ids.size unless find_opts.include?(:limit)
         find_opts
       end
@@ -75,8 +75,13 @@ module AridCache
         include?(:order) && (self[:order].is_a?(Symbol) || self[:order].is_a?(String))
       end
 
-      def proxy?
-        include?(:proxy)
+      # Return true if the user has defined a proxy for results processing in the given
+      # direction.
+      #
+      # * +direction+ - :in or :out, depending on whether we are putting results into
+      #                 the cache, or returning results from the cache, respectively
+      def proxy?(direction)
+        include?(:proxy) || include?("proxy_#{direction}".to_sym)
       end
 
       def deprecated_raw?
@@ -94,6 +99,15 @@ module AridCache
       def result_klass
         fetch :result_klass
       end
+
+      # Return the user's proxy method for the given direction.  Returns a symbol, Proc
+      # or nil if no proxy is defined.
+      #
+      # * +direction+ - :in or :out, depending on whether we are putting results into
+      #                 the cache, or returning results from the cache, respectively
+      def proxy(direction)
+        self[:proxy] || self["proxy_#{direction}".to_sym]
+      end
     end
   end
 end

data/lib/arid_cache/cache_proxy/result_processor.rb

@@ -60,11 +60,11 @@ module AridCache
         # a named scope.  Calling respond_to? on an association proxy will trigger a select
         # because it loads up the target and passes the respond_to? on to it.
         @cached =
-          if @options.proxy?
+          if @options.proxy?(:in)
             if is_activerecord_reflection?
               @result = @result.collect { |r| r } # force it to load
             end
-            @options.receiver_klass.send(@options[:proxy], @result)
+            run_user_proxy(:in, @result)
           elsif is_activerecord_reflection?
 
             if @options.count_only?
@@ -99,7 +99,7 @@ module AridCache
         if @options.count_only?
           get_count
 
-        elsif @options.proxy?
+        elsif @options.proxy?(:out)
           results =
             if @cached.nil? || !@options.raw?
               @result
@@ -107,8 +107,10 @@ module AridCache
               @cached
             end
           filtered = filter_results(results)
-          if @cached.nil? && !@options.raw?
-            proxy_result = @options.receiver_klass.send(@options[:proxy], filtered)
+          # If proxying out, we always have to proxy the result.
+          # If proxying both ways, we don't need to proxy the result after seeding the cache.
+          if !@options.raw? && (@options[:proxy_out] || @cached.nil?)
+            proxy_result = run_user_proxy(:out, filtered)
             if filtered.is_a?(WillPaginate::Collection) && proxy_result.is_a?(Enumerable)
               filtered.replace(proxy_result)
             else
@@ -118,6 +120,11 @@ module AridCache
             filtered
           end
 
+        # If proxying in, we want to return what was stored in the cache, not what was
+        # returned by the block.  So with :proxy_in, using :raw => true has no effect.
+        elsif @options.proxy?(:in)
+          filter_results(@cached || @result)
+
         elsif (@cached || @result).is_a?(AridCache::CacheProxy::CachedResult) && (@cached || @result).klass == NilClass
           nil
 
@@ -145,6 +152,24 @@ module AridCache
 
       private
 
+      # Run the user's proxy method (or Proc) and return the result.
+      #
+      # == Arguments
+      # * +direction+ - :in or :out, depending on whether we are putting results into
+      #             the cache, or returning results from the cache, respectively
+      # * +records+ - some kind of result that is passed to the proxy method
+      def run_user_proxy(direction, records)
+        proxy = @options.proxy(direction)
+        case proxy
+        when Symbol, String
+          @options.receiver_klass.send(proxy, records)
+        when Proc
+          proxy.call(records)
+        else
+          records # silently ignore it
+        end
+      end
+
       def get_count
         if @cached.is_a?(AridCache::CacheProxy::CachedResult) # use what we put in the cache
           @cached.count
@@ -230,7 +255,7 @@ module AridCache
             if AridCache.framework.active_record?(3)
               page_opts = @options.opts_for_paginate(ids)
               WillPaginate::Collection.create(page_opts[:page], page_opts[:per_page], page_opts[:total_entries]) do |pager|
-                result = find_all_by_id(ids, find_opts.merge(:limit => pager.per_page, :offset => pager.offset))
+                result = AridCache.find_all_by_id(result_klass, ids, find_opts.merge(:limit => pager.per_page, :offset => pager.offset))
                 pager.replace(result)
               end
             else
@@ -238,12 +263,12 @@ module AridCache
               result_klass.paginate(ids, find_opts)
             end
           else
-            find_all_by_id(ids, find_opts)
+            AridCache.find_all_by_id(result_klass, ids, find_opts)
           end
         else
           # Limits will have already been applied, remove them from the options for find.
           [:offset, :limit].each { |key| find_opts.delete(key) }
-          result = find_all_by_id(ids, find_opts)
+          result = AridCache.find_all_by_id(result_klass, ids, find_opts)
           records.is_a?(::WillPaginate::Collection) ? records.replace(result) : result
         end
       end
@@ -254,28 +279,7 @@ module AridCache
         is_cached_result? ? @result.klass : (@cached.is_a?(AridCache::CacheProxy::CachedResult) ? @cached.klass : @options[:receiver_klass])
       end
 
-      def find_all_by_id(ids, find_opts)
-        if AridCache.framework.active_record?(3)
-          option_map = {
-            :conditions => :where,
-            :include => :includes
-          }
-          query = find_opts.inject(result_klass.scoped) do |scope, pair|
-            key, value = pair
-            key = option_map[key] || key
-            scope.send(key, pair[1])
-          end
-          query = query.scoped.where(Utilities.namespaced_column(:id, result_klass) + ' in (?)', ids)
-          # Fix http://breakthebit.org/post/3487560245/rails-3-arel-count-size-length-weirdness
-          query.class_eval do
-            alias_method :size, :length
-            alias_method :count, :length
-          end
-          query
-        else
-          result_klass.find_all_by_id(ids, find_opts)
-        end
-      end
+
     end
   end
 end

data/lib/arid_cache/cache_proxy/utilities.rb

@@ -35,6 +35,33 @@ module AridCache
       def object_class(object)
         object.is_a?(Class) ? object : object.class
       end
+
+      # Find and return records of the given +klass+ which have id in +ids+.
+      # +find_opts+ is a hash of options which are passed to find.
+      # If no order option is given, the ordering of the ids is preserved.
+      def find_all_by_id(klass, ids, find_opts={})
+        find_opts = Options.new(find_opts.merge(:result_klass => klass)).opts_for_find(ids)
+        if AridCache.framework.active_record?(3)
+          option_map = {
+            :conditions => :where,
+            :include => :includes
+          }
+          query = find_opts.inject(klass.scoped) do |scope, pair|
+            key, value = pair
+            key = option_map[key] || key
+            scope.send(key, pair[1])
+          end
+          query = query.scoped.where(Utilities.namespaced_column(:id, klass) + ' in (?)', ids)
+          # Fix http://breakthebit.org/post/3487560245/rails-3-arel-count-size-length-weirdness
+          query.class_eval do
+            alias_method :size, :length
+            alias_method :count, :length
+          end
+          query
+        else
+          klass.find_all_by_id(ids, find_opts)
+        end
+      end
     end
   end
-end
+end

data/lib/arid_cache/proxies.rb

@@ -0,0 +1,18 @@
+module AridCache
+  module Proxies
+    class IdProxy
+      # Return a Proc which takes an array.  If the array contains ActiveRecords a list of
+      # ids is returned.  If the array contains ids, the corresponding records are returned.
+      # All the records must be of class +klass+
+      def self.for(klass, find_opts={})
+        return Proc.new do |records|
+          if records.empty?
+            records
+          else
+            records.first.is_a?(::ActiveRecord::Base) ? records.collect(&:id) : AridCache.find_all_by_id(klass, records, find_opts)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/arid_cache/arid_cache_spec.rb

@@ -42,17 +42,17 @@ describe AridCache do
     AridCache.raw_with_options = true
     AridCache.raw_with_options.should be_true
   end
-  
+
   describe "pagination" do
     before :each do
       @user = User.make
       @user.companies << Company.make
-    end                
-    
+    end
+
     it "should not fail if the page is nil" do
       lambda {
-        @user.cached_companies(:page => nil) 
-        @user.cached_companies(:page => nil) # works when seeding, so call again to load from cache        
+        @user.cached_companies(:page => nil)
+        @user.cached_companies(:page => nil) # works when seeding, so call again to load from cache
       }.should_not raise_error(WillPaginate::InvalidPage)
     end
   end

data/spec/arid_cache/cache_proxy/options_spec.rb

@@ -109,9 +109,29 @@ describe AridCache::CacheProxy::Options do
     end
   end
 
-  describe "proxies" do
+  describe "proxy?" do
     it "should use proxy" do
-      new_options(:proxy => :serializing_proxy).proxy?.should be_true
+      new_options(:proxy => :xyz).proxy?(:in).should be_true
+      new_options(:proxy => :xyz).proxy?(:out).should be_true
+    end
+
+    it "should proxy in" do
+      new_options(:proxy_in => :xyz).proxy?(:in).should be_true
+      new_options(:proxy_in => :xyz).proxy?(:out).should be_false
+    end
+
+    it "should proxy out" do
+      new_options(:proxy_out => :xyz).proxy?(:in).should be_false
+      new_options(:proxy_out => :xyz).proxy?(:out).should be_true
+    end
+  end
+
+  describe "proxy" do
+    it "should return the proxy" do
+      new_options(:proxy_in => :xyz).proxy(:in).should == :xyz
+      new_options(:proxy_out => :xyz).proxy(:out).should == :xyz
+      new_options(:proxy => :xyz).proxy(:in).should == :xyz
+      new_options(:proxy => :xyz).proxy(:out).should == :xyz
     end
   end
 

data/spec/arid_cache/cache_proxy/result_processor_spec.rb

@@ -8,6 +8,7 @@ describe AridCache::CacheProxy::ResultProcessor do
 
   before :each do
     AridCache.store.delete! # so no options get stored and interfere with other tests
+    Rails.cache.clear
     AridCache.raw_with_options = true
   end
 
@@ -227,10 +228,21 @@ describe AridCache::CacheProxy::ResultProcessor do
     before :each do
       class User
         instance_caches do
-          companies(:proxy => :abc)
+          companies(:proxy => :hash_proxy)
+          companies_in(:proxy_in => :id_proxy) {   # store ids, return ids
+            companies
+          }
+          companies_out(:proxy_out => :id_proxy) { # store ids, return records
+            companies.all.map(&:id)
+          }
         end
 
-        def self.abc(records)
+        def self.id_proxy(records)
+          return records if records.empty?
+          records.first.is_a?(ActiveRecord::Base) ? records.collect(&:id) : AridCache.find_all_by_id(Company, records)
+        end
+
+        def self.hash_proxy(records)
           return records if records.empty?
           records.first.is_a?(ActiveRecord::Base) ? records.collect(&:attributes) : records.collect { |r| Company.find_by_id(r['id']) }
         end
@@ -243,19 +255,26 @@ describe AridCache::CacheProxy::ResultProcessor do
     end
 
     it "the proxy called on itself should return the original value" do
-      User.abc(User.abc([@company])).should == [@company]
+      User.hash_proxy(User.hash_proxy([@company])).should == [@company]
+    end
+
+    it "the proxy called on itself should return the original value" do
+      User.id_proxy(User.id_proxy([@company])).should == [@company]
     end
 
     it "should serialize" do
+      mock.proxy(User).hash_proxy(anything)
       @user.cached_companies.should == [@company]
     end
 
     it "should un-serialize" do
-      @user.cached_companies # seed the cache
+      mock.proxy(User).hash_proxy(anything).twice
+      @user.cached_companies.should == [@company] # seed the cache
       @user.cached_companies.should == [@company]
     end
 
     it "should return json with :raw => true" do
+      mock.proxy(User).hash_proxy(anything)
       # Seed the cache; it should use the serialized result in the return value.
       value = @user.cached_companies(:raw => true)
 
@@ -268,7 +287,7 @@ describe AridCache::CacheProxy::ResultProcessor do
       end
 
       # Cache is seeded, it should use the cached result
-      dont_allow(User).abc
+      dont_allow(User).hash_proxy
       value = @user.cached_companies(:raw => true)
       value.should be_a(Array)
       value.first.should be_a(Hash)
@@ -277,6 +296,56 @@ describe AridCache::CacheProxy::ResultProcessor do
       end
     end
 
+    it "should proxy out only" do
+      mock.proxy(User).id_proxy(anything)
+      @user.cached_companies_out.should == @user.companies.to_a
+      @user.cached_companies_out(:raw => true).should == @user.companies.map(&:id)
+    end
+
+    it "should proxy in only" do
+      mock.proxy(User).id_proxy(anything)
+      @user.cached_companies_in.should == @user.companies.map(&:id)
+      @user.cached_companies_in(:raw => true).should == @user.companies.map(&:id)
+    end
+
+    describe "as a Proc" do
+      before :each do
+        @ids = [1,2,3]
+        @proc = Proc.new { |records| records.reverse }
+      end
+
+      it "the proc should reverse the list" do
+        #mock.proxy(@proxy).call(@ids)
+        @proc.call(@ids).should == @ids.reverse
+      end
+
+      it "should be called going in" do
+        #mock.proxy(@proxy).call(@ids)
+        new_result(nil, :proxy_in => @proc).send(:run_user_proxy, :in, @ids).should == @ids.reverse
+      end
+
+      it "should not be called going out" do
+        #mock.proxy(@proxy).call(@ids).never
+        new_result(nil, :proxy_in => @proc).send(:run_user_proxy, :out, @ids).should == @ids
+      end
+
+      it "should be called going out" do
+        #mock.proxy(@proxy).call(@ids)
+        new_result(nil, :proxy_out => @proc).send(:run_user_proxy, :out, @ids).should == @ids.reverse
+      end
+
+      it "should not be called going in" do
+        #mock.proxy(@proxy).call(@ids).never
+        new_result(nil, :proxy_out => @proc).send(:run_user_proxy, :in, @ids).should == @ids
+      end
+
+      it "should be called both ways" do
+        #mock.proxy(@proxy).call(anything).twice
+        new_result(nil, :proxy => @proc).send(:run_user_proxy, :in, @ids).should == @ids.reverse
+        new_result(nil, :proxy => @proc).send(:run_user_proxy, :out, @ids).should == @ids.reverse
+      end
+    end
+
     describe "with options" do
       before :each do
         @c2 = Company.make
@@ -292,7 +361,7 @@ describe AridCache::CacheProxy::ResultProcessor do
 
       it "should apply limit and offset with :raw => true" do
         @companies = @user.cached_companies
-        @user.cached_companies(:limit => 2, :offset => 1, :raw => true).should == User.abc(@companies[1,2])
+        @user.cached_companies(:limit => 2, :offset => 1, :raw => true).should == User.hash_proxy(@companies[1,2])
       end
 
       it "should apply pagination" do
@@ -312,7 +381,7 @@ describe AridCache::CacheProxy::ResultProcessor do
       end
 
       it "should paginate with :raw => true" do
-        @companies = User.abc(@user.cached_companies)
+        @companies = User.hash_proxy(@user.cached_companies)
         value = @user.cached_companies(:page => 2, :per_page => 2, :raw => true)
         value.should be_a(WillPaginate::Collection)
         value.first.should be_a(Hash)
@@ -482,24 +551,6 @@ describe AridCache::CacheProxy::ResultProcessor do
     end
   end
 
-  describe "find_all_by_id" do
-    before :each do
-      @user = User.make
-      @user.companies << Company.make
-      @user.companies << Company.make
-      Company.make # there must be more than 2 companies for it to fail
-      @cached = AridCache::CacheProxy::CachedResult.new
-      @cached.ids = @user.companies.reverse.map(&:id)
-      @cached.klass = Company
-      @result = new_result(@cached)
-      mock.proxy(@result).find_all_by_id(@cached.ids, anything)
-    end
-
-    it "should maintain order" do
-      @result.to_result.should == @user.companies.reverse
-    end
-  end
-
   describe "result_klass" do
     before :each do
       @obj = Class.new do

data/spec/arid_cache/cache_proxy/utilities_spec.rb

@@ -4,12 +4,35 @@ describe AridCache::CacheProxy::Utilities do
   describe 'order_by' do
     it "id column should be prefixed by the table name" do
       stub(::ActiveRecord::Base).is_mysql_adapter? { true }
-      AridCache::CacheProxy::Utilities.order_by([1,2,3], Company).should =~ %r[#{Company.table_name}]
+      AridCache.order_by([1,2,3], Company).should =~ %r[#{Company.table_name}]
     end
 
     it "id column should be prefixed by the table name" do
       stub(::ActiveRecord::Base).is_mysql_adapter? { false }
-      AridCache::CacheProxy::Utilities.order_by([1,2,3], Company).should =~ %r[#{Company.table_name}]
+      AridCache.order_by([1,2,3], Company).should =~ %r[#{Company.table_name}]
+    end
+  end
+
+  describe "find_all_by_id" do
+    before :each do
+      @user = User.make
+      @user.companies << Company.make
+      @user.companies << Company.make
+      Company.make # there must be more than 2 companies for it to fail
+    end
+
+    it "should maintain order" do
+      @result = AridCache::CacheProxy::Utilities.find_all_by_id(Company, @user.companies.reverse.map(&:id))
+      @result.should == @user.companies.reverse
+    end
+
+    it "should apply options" do
+      @result = AridCache::CacheProxy::Utilities.find_all_by_id(Company, @user.companies.reverse.map(&:id),
+        :limit => 1,
+        :offset => 1
+      )
+      @result.size.should == 1
+      @result.first.should == @user.companies.reverse[1]
     end
   end
 end

data/spec/arid_cache/proxies_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe AridCache::Proxies::IdProxy do
+  before :each do
+    @user = User.make
+    @user.companies << Company.make               
+    @ids = @user.companies.map(&:id)
+  end
+
+  it "should return ids given records" do
+    AridCache::Proxies::IdProxy.for(Company).call(@user.companies).should == @ids
+  end
+
+  it "should return records given ids" do
+    AridCache::Proxies::IdProxy.for(Company).call(@ids).should == @user.companies.to_a
+  end 
+  
+  it "should accept options to find" do
+    result = AridCache::Proxies::IdProxy.for(Company, :order => 'id DESC', :include => :owner).call(@ids)
+    result.should == @user.companies.reverse
+    lambda {
+      result.collect(&:owner)
+    }.should query(0)
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 3
   prerelease: 
   segments: 
   - 1
   - 4
-  - 1
-  version: 1.4.1
+  - 2
+  version: 1.4.2
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-19 00:00:00 -07:00
+date: 2011-04-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,7 @@ files:
 - lib/arid_cache/helpers.rb
 - lib/arid_cache/inflector.rb
 - lib/arid_cache/inflector/inflections.rb
+- lib/arid_cache/proxies.rb
 - lib/arid_cache/railtie.rb
 - lib/arid_cache/store.rb
 - rails/init.rb
@@ -121,6 +122,7 @@ files:
 - spec/arid_cache/cache_proxy/utilities_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/arid_cache/helpers_spec.rb
+- spec/arid_cache/proxies_spec.rb
 - spec/arid_cache/store_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -182,6 +184,7 @@ test_files:
 - spec/arid_cache/cache_proxy/utilities_spec.rb
 - spec/arid_cache/cache_proxy_spec.rb
 - spec/arid_cache/helpers_spec.rb
+- spec/arid_cache/proxies_spec.rb
 - spec/arid_cache/store_spec.rb
 - spec/spec_helper.rb
 - spec/support/ar_query.rb