onyx-cache-money 0.2.5.7 → 0.2.5.8

data/lib/cash/accessor.rb

@@ -11,15 +11,11 @@ module Cash
       def fetch(keys, options = {}, &block)
         case keys
         when Array
-          cache_and_actual_keys = keys.inject({}) { |memo, key| memo[cache_key(key)] = key; memo }
-          cache_keys = keys.collect {|key| cache_key(key)}
-          
-          hits = repository.get_multi(cache_keys)
-          if (missed_cache_keys = cache_keys - hits.keys).any?
-            actual_missed_keys = missed_cache_keys.collect {|missed_cache_key| cache_and_actual_keys[missed_cache_key]}
-            missed_values = block.call(actual_missed_keys)
-            
-            hits.merge!(missed_cache_keys.zip(Array(missed_values)).to_hash)
+          keys = keys.collect { |key| cache_key(key) }
+          hits = repository.get_multi(keys)
+          if (missed_keys = keys - hits.keys).any?
+            missed_values = block.call(missed_keys)
+            hits.merge!(missed_keys.zip(Array(missed_values)).to_hash)
           end
           hits
         else
@@ -30,11 +26,7 @@ module Cash
       def get(keys, options = {}, &block)
         case keys
         when Array
-          fetch(keys, options) do |missed_keys|
-            results = yield(missed_keys)
-            results.each_with_index {|result, index| add(missed_keys[index], result, options)}
-            results
-          end
+          fetch(keys, options, &block)
         else
           fetch(keys, options) do
             if block_given?
@@ -74,8 +66,7 @@ module Cash
       end
 
       def cache_key(key)
-        ready = key =~ /#{name}:#{cache_config.version}/
-        ready ? key : "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
+        "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
       end
     end
 

data/lib/cash/finders.rb

@@ -10,7 +10,7 @@ module Cash
       def self.extended(active_record_class)
         class << active_record_class
           alias_method_chain :find_every, :cache
-          # alias_method_chain :find_from_ids, :cache
+          alias_method_chain :find_from_ids, :cache
           alias_method_chain :calculate, :cache
         end
       end
@@ -25,9 +25,9 @@ module Cash
       end
 
       # User.find(1), User.find(1, 2, 3), User.find([1, 2, 3]), User.find([])
-      # def find_from_ids_with_cache(ids, options)
-      #   Query::PrimaryKey.perform(self, ids, options, scope(:find))
-      # end
+      def find_from_ids_with_cache(ids, options)
+        Query::PrimaryKey.perform(self, ids, options, scope(:find))
+      end
 
       # User.count(:all), User.count, User.sum(...)
       def calculate_with_cache(operation, column_name, options = {})

data/lib/cash/query/abstract.rb

@@ -1,8 +1,7 @@
 module Cash
   module Query
     class Abstract
-      delegate :with_exclusive_scope, :get, :quoted_table_name, :connection, :indices, 
-        :find_every_without_cache, :cache_key, :columns_hash, :quote_value, :to => :@active_record
+      delegate :with_exclusive_scope, :get, :table_name, :indices, :find_from_ids_without_cache, :cache_key, :columns_hash, :to => :@active_record
 
       def self.perform(*args)
         new(*args).perform
@@ -52,7 +51,7 @@ module Cash
       def cacheable?(*optionss)
         optionss.each { |options| return unless safe_options_for_cache?(options) }
         partial_indices = optionss.collect { |options| attribute_value_pairs_for_conditions(options[:conditions]) }
-        return if partial_indices.flatten.include?(nil)
+        return if partial_indices.include?(nil)
         attribute_value_pairs = partial_indices.sum.sort { |x, y| x[0] <=> y[0] }
         if index = indexed_on?(attribute_value_pairs.collect { |pair| pair[0] })
           if index.matches?(self)
@@ -71,20 +70,7 @@ module Cash
       end
 
       def cache_keys(attribute_value_pairs)
-        cache_keys = collect_cache_keys(attribute_value_pairs)
-        cache_keys.size == 1 ? cache_keys.first : cache_keys
-      end
-      
-      def collect_cache_keys(pairs)
-        return [] if pairs.empty?
-        key, values = pairs.shift
-        Array(values).inject([]) do |memo,value|
-          partial_keys = collect_cache_keys(pairs.clone)
-
-          memo << "#{key}/#{value}" if partial_keys.empty?
-          partial_keys.each { |partial_key| memo << "#{key}/#{value}/#{partial_key}" }
-          memo
-        end
+        attribute_value_pairs.flatten.join('/')
       end
 
       def safe_options_for_cache?(options)
@@ -95,10 +81,13 @@ module Cash
       def attribute_value_pairs_for_conditions(conditions)
         case conditions
         when Hash
+          # avoid key too long error when passing in array of ids
+          return nil if conditions.values.any? {|value| value.is_a?(Array)}
           conditions.to_a.collect { |key, value| [key.to_s, value] }
         when String
           parse_indices_from_condition(conditions)
         when Array
+          # do not cache find(:conditions => ["... :attr", {:attr => 1}]
           return nil if conditions.last.is_a?(Hash)
           parse_indices_from_condition(*conditions)
         when NilClass
@@ -108,19 +97,17 @@ module Cash
 
       AND = /\s+AND\s+/i
       TABLE_AND_COLUMN = /(?:(?:`|")?(\w+)(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/              # Matches: `users`.id, `users`.`id`, users.id, id
-      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*?))'?/                                            # Matches: 123, ?, '123', '12 ''3'
-      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+(?:=|IN)\s+\(?(?:#{VALUE})\)?\)?$/      # Matches: KEY = VALUE, (KEY = VALUE), KEY IN (VALUE,VALUE,..)
-      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i                                      # Matches: COLUMN ASC, COLUMN DESC, COLUMN
+      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*))'?/                     # Matches: 123, ?, '123', '12''3'
+      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+=\s+#{VALUE}\)?$/ # Matches: KEY = VALUE, (KEY = VALUE)
+      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i              # Matches: COLUMN ASC, COLUMN DESC, COLUMN
 
       def parse_indices_from_condition(conditions = '', *values)
         values = values.dup
         conditions.split(AND).inject([]) do |indices, condition|
-          matched, table_name, column_name, sql_values = *(KEY_EQ_VALUE.match(condition))
+          matched, table_name, column_name, sql_value = *(KEY_EQ_VALUE.match(condition))
           if matched
-            actual_values = sql_values.split(',').collect do |sql_value|
-              sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
-            end
-            indices << [column_name, actual_values]
+            value = sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
+            indices << [column_name, value]
           else
             return nil
           end
@@ -165,30 +152,14 @@ module Cash
           objects
         else
           cache_keys = objects.collect { |id| "id/#{id}" }
-          objects = get(cache_keys) {|missed_keys| find_from_keys(missed_keys)}
+          objects = get(cache_keys, &method(:find_from_keys))
           convert_to_array(cache_keys, objects)
         end
       end
 
-      def find_from_keys(missing_keys, options = {})
-        missing_keys_pairs = Array(missing_keys).flatten.collect { |key| key.split('/') }
-
-        keys_values = missing_keys_pairs.inject({}) do |memo, missing_keys_pair|
-          while missing_keys_pair.any?
-            key = missing_keys_pair.shift
-            memo[key] ||= []
-            memo[key] << missing_keys_pair.shift
-          end
-          memo
-        end
-
-        conditions = keys_values.collect do |key,values|
-          converted_values = values.collect {|value| quote_value(value, columns_hash[key])}
-          quoted_table_and_column_name = "#{quoted_table_name}.#{connection.quote_column_name(key)}"
-          converted_values.size == 1 ? "#{quoted_table_and_column_name} = #{converted_values}" : "#{quoted_table_and_column_name} IN (#{converted_values.join(',')})"
-        end
-
-        find_every_without_cache(options.merge(:conditions => conditions.join(" AND ")))
+      def find_from_keys(*missing_keys)
+        missing_ids = Array(missing_keys).flatten.collect { |key| key.split('/')[2].to_i }
+        find_from_ids_without_cache(missing_ids, {})
       end
     end
   end

data/lib/cash/query/select.rb

@@ -4,9 +4,8 @@ module Cash
       delegate :find_every_without_cache, :to => :@active_record
 
       protected
-      def miss(missed_keys, miss_options)
-        # find_every_without_cache(miss_options)
-        misses = find_from_keys(missed_keys, miss_options)
+      def miss(_, miss_options)
+        find_every_without_cache(miss_options)
       end
 
       def uncacheable

data/spec/cash/finders_spec.rb

@@ -170,9 +170,8 @@ module Cash
 
               describe '#find(1, :conditions => ...)' do
                 it "does not use the database" do
-                  Story.create!
                   story = Story.create!
-                  character = Character.create!(:name => name = 'barbara', :story_id => story.id)
+                  character = Character.create!(:name => name = 'barbara', :story_id => story)
                   mock(Character.connection).execute.never
                   Character.send :with_scope, :find => { :conditions => { :story_id => story.id } } do
                     Character.find(character.id, :conditions => { :name => name }).should == character
@@ -212,6 +211,19 @@ module Cash
             end
           end
 
+          describe "#find_all_by_id" do
+            it "should not create a key over 250 characters" do
+              150.times do
+                Story.create!
+              end
+              ids = Story.find(:all).map(&:id)
+              $memcache.flush_all
+              lambda do 
+                Story.find_all_by_id(ids)
+              end.should_not raise_error(ArgumentError)
+            end
+          end
+
           describe '#find(:all)' do
             it "uses the database, not the cache" do
               character = Character.create!
@@ -228,6 +240,28 @@ module Cash
                   Story.find(:all, :conditions => { :title => story1.title }).should == [story1, story2]
                 end
               end
+              
+              it "should not create a key over 250 characters with hash for conditions" do
+                150.times do
+                  Story.create!
+                end
+                ids = Story.find(:all).map(&:id)
+                $memcache.flush_all
+                lambda do 
+                  Story.find(:all, :conditions => {:id => ids})
+                end.should_not raise_error(ArgumentError)
+              end
+
+              it "should not create a key over 250 characters with array for conditions" do
+                150.times do
+                  Story.create!
+                end
+                ids = Story.find(:all).map(&:id)
+                $memcache.flush_all
+                lambda do 
+                  Story.find(:all, :conditions => ["id IN (?)", ids])
+                end.should_not raise_error(ArgumentError)
+              end
             end
 
             describe '#find(:all, :limit => ..., :offset => ...)' do
@@ -262,7 +296,7 @@ module Cash
             end
           end
 
-          describe '#find_by_attr' do
+          describe '#find_by_attr' do            
             describe 'on indexed attributes' do
               describe '#find_by_id(id)' do
                 it "does not use the database" do
@@ -335,102 +369,27 @@ module Cash
             Story.fetch("title/#{@story.title}").should == [@story.id]
           end
         end
-
+        
         describe '#find(:conditions => ["... :attr", {:attr => 1}])' do
-          it 'retrieves story from database - no support yet for retrieving from cache' do
-            Story.find(:all, :conditions => ["id = :id", {:id => @story.id}]).should == [@story]
+          it 'never retrieves from cache' do
+            mock(Story).add.never
+            Story.find(:all, :conditions => ["id = :id", {:id => @story.id}])
+          end
+          
+          it 'populates the cache' do
+            pending "remove test above when this is fixed"
+            Story.find(:all, :conditions => ["id = :id", {:id => @story.id}])
+            Story.fetch("id/#{@story.id}").should == @story
           end
         end
-        
+
         describe '#find(1)' do
           it 'populates the cache' do
             Story.find(@story.id)
             Story.fetch("id/#{@story.id}").should == [@story]
           end
         end
-        
-        describe '#find(1,2)' do
-          it 'populates the cache' do
-            another_story = Story.create!
-            $memcache.flush_all
-            
-            Story.find(@story.id, another_story.id).should == [@story, another_story]
-            Story.fetch("id/#{@story.id}").should == @story
-            Story.fetch("id/#{another_story.id}").should == another_story
-          end
-          
-          it "populates the cache and retrieves from the cache" do
-            story1 = Story.create!
-            story2 = Story.create!
-            story3 = Story.create!
-            $memcache.flush_all
-
-            Story.find(story1.id, story2.id, story3.id).should == [story1, story2, story3]
-            mock(Story.connection).execute.never
-            Story.find(story1.id, story2.id).should == [story1, story2]
-          end
-          
-          it "uses database for missing keys" do
-            story1 = Story.create!
-            story2 = Story.create!
-            story3 = Story.create!
-            $memcache.flush_all
 
-            Story.find(story1.id, story3.id).should == [story1, story3]
-            Story.fetch("id/#{story2.id}").should be_nil
-
-            mock(Story).find_every_without_cache(:limit => nil, :conditions => "\"stories\".\"id\" = #{story2.id}") do 
-              story2
-            end
-            Story.find(story1.id, story2.id)
-          end
-          
-          it "populates and retrieves from cache when passing in a hash" do
-            story1 = Story.create!
-            story2 = Story.create!
-            $memcache.flush_all
-
-            Story.find(:all, :conditions => {:id => [story1.id, story2.id]})
-            mock(Story.connection).execute.never
-            Story.find(story1.id, story2.id)
-          end
-
-          it "populates and retrieves from cache when passing in a parametrized conditions" do
-            story1 = Story.create!
-            story2 = Story.create!
-            $memcache.flush_all
-
-            Story.find(:all, :conditions => ["id IN (?,?)", story1.id, story2.id])
-            mock(Story.connection).execute.never
-            Story.find(story1.id, story2.id)
-          end
-
-          it "populates and retrieves from cache when passing in a list of non-numeric keys" do
-            pending "need to fix regex to properly parse this"
-            story1 = Story.create! :title => 'one'
-            story2 = Story.create! :title => 'two'
-            $memcache.flush_all
-
-            Story.find(:all, :conditions => ["title IN ('one', 'two')"])
-            # We need to add this extra call as cache money will always go to the database
-            #  one more time when finding by a non-id field first
-            Story.find_all_by_title(['one', 'two'])
-            mock(Story.connection).execute.never
-            Story.find(story1.id, story2.id)
-          end
-          
-          it "should not create a key over 250 characters on a find_all_by_ids" do
-            75.times do
-              Story.create!
-            end
-            ids = Story.find(:all).map(&:id)
-            $memcache.flush_all
-            lambda do 
-              Story.find(:all, :conditions => {:id => ids})
-            end.should_not raise_error(ArgumentError)
-          end
-        end
-        
         describe 'when there is a with_scope' do
           it "uses the database, not the cache" do
             Story.send :with_scope, :find => { :conditions => { :title => @story.title }} do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: onyx-cache-money
 version: !ruby/object:Gem::Version 
-  version: 0.2.5.7
+  version: 0.2.5.8
 platform: ruby
 authors: 
 - Nick Kallen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-26 00:00:00 -07:00
+date: 2009-05-28 00:00:00 -07:00
 default_executable: 
 dependencies: []