arid_cache 0.1.1 → 0.2.1

data/lib/arid_cache/cache_proxy.rb

@@ -1,6 +1,6 @@
 module AridCache
   class CacheProxy
-    attr_accessor :object, :key, :opts, :blueprint, :cached, :cache_key, :block, :records
+    attr_accessor :object, :key, :opts, :blueprint, :cached, :cache_key, :block, :records, :combined_options
     
     # AridCache::CacheProxy::Result
     #
@@ -17,7 +17,7 @@ module AridCache
       end
             
       def klass=(value)
-        self['klass'] = value.is_a?(Class) ? value.name : value
+        self['klass'] = value.is_a?(Class) ? value.name : value.class.name
       end
       
       def klass
@@ -25,7 +25,11 @@ module AridCache
       end
     end
 
-    def self.clear_all_caches
+    #
+    # Managing your caches
+    # 
+    
+    def self.clear_caches
       Rails.cache.delete_matched(%r[arid-cache-.*])
     end 
     
@@ -37,12 +41,12 @@ module AridCache
     def self.clear_instance_caches(object)
       key = (object.is_a?(Class) ? object : object.class).name.pluralize.downcase
       Rails.cache.delete_matched(%r[arid-cache-#{key}.*])
-    end    
-    
-    def self.has?(object, key)
-      Rails.cache.exist?(object.arid_cache_key(key))
     end
 
+    #
+    # Fetching results
+    #
+    
     def self.fetch_count(object, key, opts, &block)
       CacheProxy.new(object, key, opts, &block).fetch_count
     end
@@ -54,16 +58,20 @@ module AridCache
     def initialize(object, key, opts, &block)
       self.object = object
       self.key = key
-      self.opts = opts || {}
+      self.opts = opts.symbolize_keys || {}
       self.blueprint = AridCache.store.find(object, key)
-      self.cache_key = object.arid_cache_key(key)
-      self.cached = Rails.cache.read(cache_key)
       self.block = block
       self.records = nil
+      
+      # The options from the blueprint merged with the options for this call
+      self.combined_options = self.blueprint.nil? ? self.opts : self.blueprint.opts.merge(self.opts)
+      
+      self.cache_key = object.arid_cache_key(key, opts_for_cache_key)
+      self.cached = Rails.cache.read(cache_key, opts_for_cache)
     end
             
     def fetch_count
-      if cached.nil? || opts[:force]
+      if refresh_cache?
         execute_count
       elsif cached.is_a?(AridCache::CacheProxy::Result)
         cached.has_count? ? cached.count : execute_count
@@ -77,13 +85,26 @@ module AridCache
     end
           
     def fetch
-      if cached.nil? || opts[:force]
+      if refresh_cache?
         execute_find
       elsif cached.is_a?(AridCache::CacheProxy::Result)
-        if cached.has_ids? # paginate and fetch here
-          klass = find_class_of_results
-          if opts.include?(:page)
-            klass.paginate(cached.ids, opts_for_paginate)
+        if cached.has_ids?
+          klass = cached.klass || object_base_class
+          if combined_options.include?(:page)    
+            if combined_options.include?(:order) # order and paginate in the database
+              klass.paginate(cached.ids, opts_for_find.merge(opts_for_paginate(klass)))
+            else # paginate in memory
+              paged_ids = cached.ids.paginate(opts_for_paginate(klass))
+              paged_ids.replace(klass.find(paged_ids, preserve_order(opts_for_find, paged_ids)))
+            end
+          elsif combined_options.include?(:limit) || combined_options.include?(:offset)
+            if combined_options.include?(:order) # limit and offset in the database
+              klass.find(cached.ids, opts_for_find)
+            else # limit and offset in memory
+              offset, limit = combined_options.delete(:offset) || 0, combined_options.delete(:limit) || cached.count
+              ids = cached.ids[offset, limit]
+              klass.find(ids, preserve_order(opts_for_find, ids))
+            end
           else
             klass.find(cached.ids, opts_for_find)
           end
@@ -97,8 +118,12 @@ module AridCache
       
     private
 
+      def refresh_cache?
+        cached.nil? || opts[:force]
+      end
+      
       def get_records
-        block = block || blueprint.proc
+        block = block || (blueprint && blueprint.proc)
         self.records = block.nil? ? object.instance_eval(key) : object.instance_eval(&block)
       end
       
@@ -119,7 +144,7 @@ module AridCache
             cached.klass = object_base_class
           end
         end
-        Rails.cache.write(cache_key, cached)
+        Rails.cache.write(cache_key, cached, opts_for_cache)
         
         self.cached = cached
         return_records(records)
@@ -142,7 +167,7 @@ module AridCache
       # If you do want a specialized, modified, or subset of the collection it's best
       # to define it in a block and have a new cache for it:
       #
-      # model.my_special_collection { the_collection(:order => 'new order') }      
+      # model.my_special_collection { the_collection(:order => 'new order', :limit => 10) }      
       def return_records(records)
         if opts.include?(:page)
           records = records.respond_to?(:to_a) ? records.to_a : records
@@ -180,30 +205,58 @@ module AridCache
           cached = records # some base type, cache it as itself
         end
         
-        Rails.cache.write(cache_key, cached)
+        Rails.cache.write(cache_key, cached, opts_for_cache)
         self.cached = cached
         cached.respond_to?(:count) ? cached.count : cached
       end
-                  
-      def opts_for_paginate
-        paginate_opts = blueprint.nil? ? opts.symbolize_keys : blueprint.opts.merge(opts.symbolize_keys)
-        paginate_opts[:total_entries] = cached.count
+      
+      OPTIONS_FOR_PAGINATE = [:page, :per_page, :total_entries]
+      
+      # @arg klass target class, if supplied and no :per_page option is specified, calls
+      #      klass.per_page to get it
+      def opts_for_paginate(klass = nil)
+        paginate_opts = combined_options.reject { |k,v| !OPTIONS_FOR_PAGINATE.include?(k) }
+        paginate_opts[:per_page] = klass.per_page if klass && !paginate_opts.include?(:per_page)
         paginate_opts
       end
     
-      VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :having, :from, :lock ]
-      
+      OPTIONS_FOR_FIND = [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :having, :from, :lock ]
+
       def opts_for_find
-        find_opts = blueprint.nil? ? opts.symbolize_keys : blueprint.opts.merge(opts.symbolize_keys) 
-        find_opts.delete_if { |k,v| !VALID_FIND_OPTIONS.include?(k) }
+        combined_options.reject { |k,v| !OPTIONS_FOR_FIND.include?(k) }
       end
       
-      def object_base_class
-        object.is_a?(Class) ? object : object.class
+      OPTIONS_FOR_CACHE = [ :expires_in ]
+      
+      def opts_for_cache
+        combined_options.reject { |k,v| !OPTIONS_FOR_CACHE.include?(k) }
       end
+
+      OPTIONS_FOR_CACHE_KEY = [ :auto_expire ]
       
-      def find_class_of_results
-        opts[:class] || (blueprint && blueprint.opts[:class]) || cached.klass || object_base_class
+      def opts_for_cache_key
+        combined_options.reject { |k,v| !OPTIONS_FOR_CACHE_KEY.include?(k) }
+      end
+            
+      def object_base_class
+        object.is_a?(Class) ? object : object.class
       end
+
+      # Preserve the original order of the results if no :order option is specified.
+      # The method we use depends on the database adapter because only MySQL 
+      # supports the ORDER BY FIELD() function.   
+      # @arg options hash options for find
+      # @arg ids array of ids to order by     
+      def preserve_order(options, ids)
+        return options if options.include?(:order)
+        if ::ActiveRecord::Base.is_mysql_adapter?
+          options[:order] = "FIELD(id,#{ids.join(',')})" 
+        else
+          order = ''
+          ids.each_index { |i| order << "WHEN id=#{ids[i]} THEN #{i+1} " }
+          options[:order] = "CASE " + order + " END"
+        end
+        options
+      end 
   end
 end

data/lib/arid_cache/helpers.rb

@@ -23,7 +23,9 @@ module AridCache
           define(object, $1, opts, :fetch_count, key)
         else
           raise ArgumentError.new("#{object} doesn't respond to #{key} or #{$1}!  Cannot dynamically create query to get the count, please call with a block.")
-        end 
+        end
+      elsif AridCache.store.has?(object, key)
+        method_for_cached(object, key, :fetch)
       elsif object.respond_to?(key)
         define(object, key, opts, &block)
       else
@@ -38,9 +40,6 @@ module AridCache
     #
     # @return an AridCache::Store::Blueprint.
     def define(object, key, opts, fetch_method=:fetch, method_name=nil, &block)
-      if block.nil? && !object.respond_to?(key)
-        raise ArgumentError.new("#{object} doesn't respond to #{key}!  Cannot dynamically create a block for your cache item.")
-      end
       
       # FIXME: Pass default options to store.add
       # Pass nil in for now until we get the cache_ calls working.
@@ -57,7 +56,7 @@ module AridCache
       #
       # When the cache_ methods are supported, those options should be
       # remembered and applied to the collection however.
-      blueprint = AridCache.store.add(object, key, block, nil)
+      blueprint = AridCache.store.add_object_cache_configuration(object, key, nil, block)
       method_for_cached(object, key, fetch_method, method_name)
       blueprint
     end

data/lib/arid_cache/store.rb

@@ -1,22 +1,21 @@
 module AridCache
   class Store < Hash
-    extend ActiveSupport::Memoizable
     
     # AridCache::Store::Blueprint
     #
     # Stores options and blocks that are used to generate results for finds
     # and counts.
-    Blueprint = Struct.new(:key, :klass, :proc, :opts)  do
+    Blueprint = Struct.new(:klass, :key, :opts, :proc)  do
 
-      def initialize(key, klass, proc=nil, opts={})
+      def initialize(klass, key, opts={}, proc=nil)
         self.key = key
         self.klass = klass
         self.proc = proc
         self.opts = opts
       end
             
-      def klass=(value) # store the base class of *value*
-        self['klass'] = value.is_a?(Class) ? value.name : value.class.name
+      def klass=(object) # store the class name only
+        self['klass'] = object.is_a?(Class) ? object.name : object.class.name
       end
       
       def klass
@@ -40,6 +39,35 @@ module AridCache
       end 
     end
     
+    #
+    # Capture cache configurations and blocks and store them in the store.
+    #
+    # A block is evaluated within the scope of this class.  The blocks
+    # contains calls to methods which define the caches and give options
+    # for each cache. 
+    #
+    # Don't instantiate directly.  Rather instantiate the Instance- or 
+    # ClassCacheConfiguration.
+    Configuration = Struct.new(:klass, :global_opts)  do
+
+      def initialize(klass, global_opts={})
+        self.global_opts = global_opts
+        self.klass = klass
+      end
+      
+      def method_missing(key, *args, &block)
+        opts = global_opts.merge(args.empty? ? {} : args.first)
+        case self
+        when InstanceCacheConfiguration
+          AridCache.store.add_instance_cache_configuration(klass, key, opts, block)
+        else
+          AridCache.store.add_class_cache_configuration(klass, key, opts, block)
+        end
+      end
+    end
+    class InstanceCacheConfiguration < Configuration; end
+    class ClassCacheConfiguration    < Configuration; end
+    
     def has?(object, key)
       self.include?(object_store_key(object, key))
     end
@@ -57,17 +85,27 @@ module AridCache
       self[object_store_key(object, key)]
     end
     
-    def add(object, key, proc, opts)
+    def add_instance_cache_configuration(klass, key, opts, proc)
+      store_key = instance_store_key(klass, key)
+      self[store_key] = AridCache::Store::Blueprint.new(klass, key, opts, proc)
+    end
+
+    def add_class_cache_configuration(klass, key, opts, proc)
+      store_key = class_store_key(klass, key)
+      self[store_key] = AridCache::Store::Blueprint.new(klass, key, opts, proc)
+    end
+
+    def add_object_cache_configuration(object, key, opts, proc)
       store_key = object_store_key(object, key)
-      self[store_key] = AridCache::Store::Blueprint.new(key, object, proc, opts)
+      self[store_key] = AridCache::Store::Blueprint.new(object, key, opts, proc)
     end
-    
+            
     def find_or_create(object, key)
       store_key = object_store_key(object, key)
       if self.include?(store_key)
         self[store_key]
       else
-        self[store_key] = AridCache::Store::Blueprint.new(key, object)
+        self[store_key] = AridCache::Store::Blueprint.new(object, key)
       end
     end
     
@@ -76,9 +114,10 @@ module AridCache
     def initialize
     end
     
+    def class_store_key(klass, key);    klass.name.downcase + '-' + key.to_s; end
+    def instance_store_key(klass, key); klass.name.downcase.pluralize + '-' + key.to_s; end
     def object_store_key(object, key)
-      (object.is_a?(Class) ? object.name.downcase : object.class.name.pluralize.downcase) + '-' + key.to_s
+      case object; when Class; class_store_key(object, key); else; instance_store_key(object.class, key); end
     end
-    memoize :object_store_key
   end 
 end

data/lib/arid_cache.rb

@@ -14,8 +14,8 @@ module AridCache
     AridCache::CacheProxy
   end
 
-  def self.clear_all_caches
-    AridCache::CacheProxy.clear_all_caches
+  def self.clear_caches
+    AridCache::CacheProxy.clear_caches
   end 
   
   def self.clear_class_caches(object)
@@ -37,7 +37,7 @@ module AridCache
     base.send(:include, AridCache::ActiveRecord)
   end
   
-  # Initializes ARID Cache for Rails.
+  # Initializes AridCache for Rails.
   #
   # This method is called by `init.rb`,
   # which is run by Rails on startup.