record-cache 0.1.1 → 0.1.2

data/lib/record_cache.rb

@@ -1,6 +1,6 @@
 # Record Cache files
 ["query", "version_store", "multi_read",
- "strategy/base", "strategy/id_cache", "strategy/index_cache", "strategy/request_cache",
+ "strategy/util", "strategy/base", "strategy/id_cache", "strategy/index_cache", "strategy/request_cache",
  "statistics", "dispatcher", "base"].each do |file|
   require File.dirname(__FILE__) + "/record_cache/#{file}.rb"
 end

data/lib/record_cache/query.rb

@@ -12,7 +12,6 @@ module RecordCache
     end
 
     # Set equality of an attribute (usually found in where clause)
-    # Returns false if another attribute values was already set (making this query uncachable)
     def where(attribute, values)
       @wheres[attribute.to_sym] = values if attribute
     end

data/lib/record_cache/strategy/base.rb

@@ -1,8 +1,6 @@
 module RecordCache
   module Strategy
     class Base
-      CLASS_KEY = :c
-      ATTRIBUTES_KEY = :a
 
       def initialize(base, strategy_id, record_store, options)
         @base = base
@@ -14,8 +12,8 @@ module RecordCache
       # Fetch all records and sort and filter locally
       def fetch(query)
         records = fetch_records(query)
-        filter!(records, query.wheres) if query.wheres.size > 0
-        sort!(records, query.sort_orders) if query.sorted?
+        Util.filter!(records, query.wheres) if query.wheres.size > 0
+        Util.sort!(records, query.sort_orders) if query.sorted?
         records
       end
 
@@ -67,88 +65,6 @@ module RecordCache
         "#{cache_key}v#{version.to_s}".freeze
       end
   
-      # serialize one record before adding it to the cache
-      # creates a shallow clone with a version and without associations
-      def serialize(record)
-        {CLASS_KEY => record.class.name,
-         ATTRIBUTES_KEY => record.instance_variable_get(:@attributes)}.freeze
-      end
-  
-      # deserialize a cached record
-      def deserialize(serialized)
-        record = serialized[CLASS_KEY].constantize.new
-        attributes = serialized[ATTRIBUTES_KEY]
-        record.instance_variable_set(:@attributes, Hash[attributes])
-        record.instance_variable_set(:@new_record, false)
-        record.instance_variable_set(:@changed_attributes, {})
-        record.instance_variable_set(:@previously_changed, {})
-        record
-      end
-
-      private
-
-      # Filter the cached records in memory
-      # only simple x = y or x IN (a,b,c) can be handled 
-      def filter!(records, wheres)
-        wheres.each_pair do |attr, value|
-          if value.is_a?(Array)
-            records.reject! { |record| !value.include?(record.send(attr)) }
-          else
-            records.reject! { |record| record.send(attr) != value }
-          end
-        end
-      end
-  
-      # Sort the cached records in memory
-      def sort!(records, sort_orders)
-        records.sort!(&sort_proc(sort_orders))
-        Collator.clear
-        records
-      end
-  
-      # Retrieve the Proc based on the order by attributes
-      # Note: Case insensitive sorting with collation is used for Strings
-      def sort_proc(sort_orders)
-        # [['(COLLATER.collate(x.name) || NIL_COMES_FIRST)', 'COLLATER.collate(y.name)'], ['(y.updated_at || NIL_COMES_FIRST)', 'x.updated_at']]
-        sort = sort_orders.map do |attr, asc|
-          lr = ["x.", "y."]
-          lr.reverse! unless asc
-          lr.each{ |s| s << attr }
-          lr.each{ |s| s.replace("Collator.collate(#{s})") } if @base.columns_hash[attr].type == :string
-          lr[0].replace("(#{lr[0]} || NIL_COMES_FIRST)")
-          lr
-        end
-        # ['[(COLLATER.collate(x.name) || NIL_COMES_FIRST), (y.updated_at || NIL_COMES_FIRST)]', '[COLLATER.collate(y.name), x.updated_at]']
-        sort = sort.transpose.map{|s| s.size == 1 ? s.first : "[#{s.join(',')}]"}
-        # Proc.new{ |x,y| { ([(COLLATER.collate(x.name) || NIL_COMES_FIRST), (y.updated_at || NIL_COMES_FIRST)] <=> [COLLATER.collate(y.name), x.updated_at]) || 1 }
-        eval("Proc.new{ |x,y| (#{sort[0]} <=> #{sort[1]}) || 1 }")
-      end
-  
-      # If +x.nil?+ this class will return -1 for +x <=> y+
-      NIL_COMES_FIRST = ((class NilComesFirst; def <=>(y); -1; end; end); NilComesFirst.new)
-  
-      # StringCollator uses the Rails transliterate method for collation
-      module Collator
-        @collated = []
-  
-        def self.clear
-          @collated.each { |string| string.send(:remove_instance_variable, :@rc_collated) }
-          @collated.clear
-        end
-  
-        def self.collate(string)
-          collated = string.instance_variable_get(:@rc_collated)
-          return collated if collated
-          normalized = ActiveSupport::Multibyte::Unicode.normalize(ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c).mb_chars
-          collated = I18n.transliterate(normalized).downcase.mb_chars
-          # transliterate will replace ignored/unknown chars with ? the following line replaces ? with the original character
-          collated.chars.each_with_index{ |c, i| collated[i] = normalized[i] if c == '?' } if collated.index('?')
-          # puts "collation: #{string} => #{collated.to_s}"
-          string.instance_variable_set(:@rc_collated, collated)
-          @collated << string
-          collated
-        end
-      end
     end
   end
 end

data/lib/record_cache/strategy/id_cache.rb

@@ -16,7 +16,7 @@ module RecordCache
         else
           # update the version store and add the record to the cache
           new_version = version_store.increment(key)
-          record_store.write(versioned_key(key, new_version), serialize(record))
+          record_store.write(versioned_key(key, new_version), Util.serialize(record))
         end
       end
 
@@ -56,7 +56,7 @@ module RecordCache
       # retrieve the records from the cache with the given keys
       def from_cache(id_to_versioned_key_map)
         records = record_store.read_multi(*(id_to_versioned_key_map.values)).values.compact
-        records.map{ |record| deserialize(record) }
+        records.map{ |record| Util.deserialize(record) }
       end
     
       # retrieve the records with the given ids from the database
@@ -72,7 +72,7 @@ module RecordCache
               versioned_key = versioned_key(key, version_store.renew(key))
             end
             # store the record based on the versioned key
-            record_store.write(versioned_key, serialize(record))
+            record_store.write(versioned_key, Util.serialize(record))
           end
           records
         end

data/lib/record_cache/strategy/util.rb

@@ -0,0 +1,114 @@
+# Utility methods for the Cache Strategies
+module RecordCache
+  module Strategy
+    module Util
+      CLASS_KEY = :c
+      ATTRIBUTES_KEY = :a
+
+      class << self
+
+        # serialize one record before adding it to the cache
+        # creates a shallow clone with a version and without associations
+        def serialize(record)
+          {CLASS_KEY => record.class.name,
+           ATTRIBUTES_KEY => record.instance_variable_get(:@attributes)}.freeze
+        end
+
+        # deserialize a cached record
+        def deserialize(serialized)
+          record = serialized[CLASS_KEY].constantize.new
+          attributes = serialized[ATTRIBUTES_KEY]
+          record.instance_variable_set(:@attributes, Hash[attributes])
+          record.instance_variable_set(:@new_record, false)
+          record.instance_variable_set(:@changed_attributes, {})
+          record.instance_variable_set(:@previously_changed, {})
+          record
+        end
+
+        # Filter the cached records in memory
+        # only simple x = y or x IN (a,b,c) can be handled
+        # Example:
+        #  RecordCache::Strategy::Util.filter!(Apple.all, :price => [0.49, 0.59, 0.69], :name => "Green Apple")
+        def filter!(records, wheres)
+          wheres.each_pair do |attr, value|
+            attr = attr.to_sym
+            if value.is_a?(Array)
+              records.reject! { |record| !value.include?(record.send(attr)) }
+            else
+              records.reject! { |record| record.send(attr) != value }
+            end
+          end
+        end
+
+        # Sort the cached records in memory, similar to MySql sorting rules including collatiom
+        # Simply provide the Symbols of the attributes to sort in Ascending order, or use
+        # [<attribute>, false] for Descending order.
+        # Example:
+        #  RecordCache::Strategy::Util.sort!(Apple.all, :name)
+        #  RecordCache::Strategy::Util.sort!(Apple.all, [:name, false])
+        #  RecordCache::Strategy::Util.sort!(Apple.all, [:price, false], :name)
+        #  RecordCache::Strategy::Util.sort!(Apple.all, [:price, false], [:name, true])
+        #  RecordCache::Strategy::Util.sort!(Apple.all, [[:price, false], [:name, true]])
+        def sort!(records, *sort_orders)
+          return records if records.empty? || sort_orders.empty?
+          if sort_orders.first.is_a?(Array) && sort_orders.first.first.is_a?(Array)
+            sort_orders = sort_orders.first
+          else
+            sort_orders = sort_orders.map{ |order| order.is_a?(Array) ? order : [order, true] } unless sort_orders.all?{ |order| order.is_a?(Array) }
+          end
+          records.sort!(&sort_proc(records.first.class, sort_orders))
+          Collator.clear
+          records
+        end
+
+        private
+
+        # Retrieve the Proc based on the order by attributes
+        # Note: Case insensitive sorting with collation is used for Strings
+        def sort_proc(base, sort_orders)
+          # [['(COLLATER.collate(x.name) || NIL_COMES_FIRST)', 'COLLATER.collate(y.name)'], ['(y.updated_at || NIL_COMES_FIRST)', 'x.updated_at']]
+          sort = sort_orders.map do |attr, asc|
+            attr = attr.to_s
+            lr = ["x.", "y."]
+            lr.reverse! unless asc
+            lr.each{ |s| s << attr }
+            lr.each{ |s| s.replace("Collator.collate(#{s})") } if base.columns_hash[attr].type == :string
+            lr[0].replace("(#{lr[0]} || NIL_COMES_FIRST)")
+            lr
+          end
+          # ['[(COLLATER.collate(x.name) || NIL_COMES_FIRST), (y.updated_at || NIL_COMES_FIRST)]', '[COLLATER.collate(y.name), x.updated_at]']
+          sort = sort.transpose.map{|s| s.size == 1 ? s.first : "[#{s.join(',')}]"}
+          # Proc.new{ |x,y| { ([(COLLATER.collate(x.name) || NIL_COMES_FIRST), (y.updated_at || NIL_COMES_FIRST)] <=> [COLLATER.collate(y.name), x.updated_at]) || 1 }
+          eval("Proc.new{ |x,y| (#{sort[0]} <=> #{sort[1]}) || 1 }")
+        end
+    
+        # If +x.nil?+ this class will return -1 for +x <=> y+
+        NIL_COMES_FIRST = ((class NilComesFirst; def <=>(y); -1; end; end); NilComesFirst.new)
+    
+        # StringCollator uses the Rails transliterate method for collation
+        module Collator
+          @collated = []
+    
+          def self.clear
+            @collated.each { |string| string.send(:remove_instance_variable, :@rc_collated) }
+            @collated.clear
+          end
+    
+          def self.collate(string)
+            collated = string.instance_variable_get(:@rc_collated)
+            return collated if collated
+            normalized = ActiveSupport::Multibyte::Unicode.normalize(ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c).mb_chars
+            collated = I18n.transliterate(normalized).downcase.mb_chars
+            # transliterate will replace ignored/unknown chars with ? the following line replaces ? with the original character
+            collated.chars.each_with_index{ |c, i| collated[i] = normalized[i] if c == '?' } if collated.index('?')
+            # puts "collation: #{string} => #{collated.to_s}"
+            string.instance_variable_set(:@rc_collated, collated)
+            @collated << string
+            collated
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/record_cache/version.rb

@@ -1,5 +1,5 @@
 module RecordCache # :nodoc:
   module Version # :nodoc:
-    STRING = '0.1.1'
+    STRING = '0.1.2'
   end
 end

data/lib/record_cache/version_store.rb

@@ -23,7 +23,7 @@ module RecordCache
     end
 
     # In case the version store did not have a key anymore, call this methods
-    # to reset the key with a unique new key
+    # to reset the key with a (unique) new version
     def renew(key)
       new_version = (Time.current.to_f * 10000).to_i
       @store.write(key, new_version)
@@ -43,7 +43,7 @@ module RecordCache
       version
     end
     
-    # Delete key from the version store, in case the record(s) are destroyed
+    # Delete key from the version store (records cached in the Record Store belonging to this key will become unreachable)
     def delete(key)
       deleted = @store.delete(key)
       RecordCache::Base.logger.debug("Version Store: deleted #{key}") if RecordCache::Base.logger.debug?

data/spec/lib/strategy/base_spec.rb

@@ -29,14 +29,6 @@ describe RecordCache::Strategy::Base do
     Banana.record_cache[:id].send(:versioned_key, "rc/Banana/1", 2312423).should == "rc/Banana/1v2312423"
   end
 
-  it "should serialize a record (currently Active Record only)" do
-    Banana.record_cache[:id].send(:serialize, Banana.find(1)).should == {:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}
-  end
-
-  it "should deserialize a record (currently Active Record only)" do
-    Banana.record_cache[:id].send(:deserialize, {:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}).should == Banana.find(1)
-  end
-
   context "filter" do
     it "should apply filter on :id cache hits" do
       lambda{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.should use_cache(Apple).on(:id)

data/spec/lib/strategy/util_spec.rb

@@ -0,0 +1,228 @@
+$KCODE = 'UTF8'
+require 'spec_helper'
+
+describe RecordCache::Strategy::Util do
+
+  it "should serialize a record (currently Active Record only)" do
+    subject.serialize(Banana.find(1)).should == {:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}
+  end
+
+  it "should deserialize a record (currently Active Record only)" do
+    subject.deserialize({:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}).should == Banana.find(1)
+  end
+
+  context "filter" do
+    it "should apply filter" do
+      apples = Apple.where(:id => [1,2]).all
+      subject.filter!(apples, :name => "Adams Apple 1")
+      apples.should == [Apple.find_by_name("Adams Apple 1")]
+    end
+    
+    it "should return empty array when filter does not match any record" do
+      apples = Apple.where(:id => [1,2]).all
+      subject.filter!(apples, :name => "Adams Apple Pie")
+      apples.should be_empty
+    end
+
+    it "should filter on text" do
+      apples = Apple.where(:id => [1,2]).all
+      subject.filter!(apples, :name => "Adams Apple 1")
+      apples.should == [Apple.find_by_name("Adams Apple 1")]
+    end
+
+    it "should filter on integers" do
+      apples = Apple.where(:id => [1,2,8,9]).all
+      subject.filter!(apples, :store_id => 2)
+      apples.map(&:id).sort.should == [8,9]
+    end
+
+    it "should filter on dates" do
+      people = Person.where(:id => [1,2,3]).all
+      subject.filter!(people, :birthday => Date.civil(1953,11,11))
+      people.size.should == 1
+      people.first.name.should == "Blue"
+    end
+
+    it "should filter on floats" do
+      people = Person.where(:id => [1,2,3]).all
+      subject.filter!(people, :height => 1.75)
+      people.size.should == 2
+      people.map(&:name).sort.should == ["Blue", "Cris"]
+    end
+
+    it "should filter on arrays" do
+      apples = Apple.where(:id => [1,2,8,9])
+      subject.filter!(apples, :store_id => [2, 4])
+      apples.map(&:id).sort.should == [8,9]
+    end
+    
+    it "should filter on multiple fields" do
+      # make sure two apples exist with the same name
+      apple = Apple.find(8)
+      apple.name = Apple.find(9).name
+      apple.save!
+
+      apples = Apple.where(:id => [1,2,3,8,9,10]).all
+      subject.filter!(apples, :store_id => [2, 4], :name => apple.name)
+      apples.size.should == 2
+      apples.map(&:name).should == [apple.name, apple.name]
+      apples.map(&:id).sort.should == [8,9]
+    end
+
+  end
+
+  context "sort" do
+    it "should accept a Symbol as a sort order" do
+      people = Person.where(:id => [1,2,3]).all
+      subject.sort!(people, :name)
+      people.map(&:name).should == ["Adam", "Blue", "Cris"]
+    end
+
+   it "should accept a single Array as a sort order" do
+      people = Person.where(:id => [1,2,3]).all
+      subject.sort!(people, [:name, false])
+      people.map(&:name).should == ["Cris", "Blue", "Adam"]
+    end
+
+    it "should accept multiple Symbols as a sort order" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, :height, :id)
+      people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
+      people.map(&:id).should == [4, 2, 3, 5]
+    end
+
+    it "should accept a mix of Symbols and Arrays as a sort order" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [:height, false], :id)
+      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      people.map(&:id).should == [5, 2, 3, 4]
+    end
+
+    it "should accept multiple Arrays as a sort order" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [:height, false], [:id, false])
+      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      people.map(&:id).should == [5, 3, 2, 4]
+    end
+
+    it "should accept an Array with Arrays as a sort order (default used by record cache)" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [[:height, false], [:id, false]])
+      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      people.map(&:id).should == [5, 3, 2, 4]
+    end
+
+    it "should order nil first for ASC" do
+      apples = Apple.where(:store_id => 1).all
+      subject.sort!(apples, [:person_id, true])
+      apples.map(&:person_id).should == [nil, nil, 4, 4, 5]
+    end
+
+    it "should order nil last for DESC" do
+      apples = Apple.where(:store_id => 1).all
+      subject.sort!(apples, [:person_id, false])
+      apples.map(&:person_id).should == [5, 4, 4, nil, nil]
+    end
+
+    it "should order ascending on text" do
+      people = Person.where(:id => [1,2,3,4]).all
+      subject.sort!(people, [:name, true])
+      people.map(&:name).should == ["Adam", "Blue", "Cris", "Fry"]
+    end
+
+    it "should order descending on text" do
+      people = Person.where(:id => [1,2,3,4]).all
+      subject.sort!(people, [:name, false])
+      people.map(&:name).should == ["Fry", "Cris", "Blue", "Adam"]
+    end
+
+    it "should order ascending on integers" do
+      people = Person.where(:id => [4,2,1,3]).all
+      subject.sort!(people, [:id, true])
+      people.map(&:id).should == [1,2,3,4]
+    end
+
+    it "should order descending on integers" do
+      people = Person.where(:id => [4,2,1,3]).all
+      subject.sort!(people, [:id, false])
+      people.map(&:id).should == [4,3,2,1]
+    end
+
+    it "should order ascending on dates" do
+      people = Person.where(:id => [1,2,3,4]).all
+      subject.sort!(people, [:birthday, true])
+      people.map(&:birthday).should == [Date.civil(1953,11,11), Date.civil(1975,03,20), Date.civil(1975,03,20), Date.civil(1985,01,20)]
+    end
+
+    it "should order descending on dates" do
+      people = Person.where(:id => [1,2,3,4]).all
+      subject.sort!(people, [:birthday, false])
+      people.map(&:birthday).should == [Date.civil(1985,01,20), Date.civil(1975,03,20), Date.civil(1975,03,20), Date.civil(1953,11,11)]
+    end
+
+    it "should order ascending on float" do
+      people = Person.where(:id => [1,2,3,4]).all
+      subject.sort!(people, [:height, true])
+      people.map(&:height).should == [1.69, 1.75, 1.75, 1.83]
+    end
+
+    it "should order descending on float" do
+      people = Person.where(:id => [1,2,3,4]).all
+      subject.sort!(people, [:height, false])
+      people.map(&:height).should == [1.83, 1.75, 1.75, 1.69]
+    end
+
+    it "should order on multiple fields (ASC + ASC)" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [:height, true], [:id, true])
+      people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
+      people.map(&:id).should == [4, 2, 3, 5]
+    end
+
+    it "should order on multiple fields (ASC + DESC)" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [:height, true], [:id, false])
+      people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
+      people.map(&:id).should == [4, 3, 2, 5]
+    end
+
+    it "should order on multiple fields (DESC + ASC)" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [:height, false], [:id, true])
+      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      people.map(&:id).should == [5, 2, 3, 4]
+    end
+
+    it "should order on multiple fields (DESC + DESC)" do
+      people = Person.where(:id => [2,3,4,5]).all
+      subject.sort!(people, [:height, false], [:id, false])
+      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      people.map(&:id).should == [5, 3, 2, 4]
+    end
+    
+    it "should use mysql style collation" do
+      ids = []
+      ids << Person.create!(:name => "ċedriĉ 3").id # latin other special
+      ids << Person.create!(:name => "a cedric").id # first in ascending order
+      ids << Person.create!(:name => "čedriĉ 4").id # latin another special
+      ids << Person.create!(:name => "ćedriĉ Last").id # latin special lowercase
+      ids << Person.create!(:name => "sedric 1").id # second to last latin in ascending order 
+      ids << Person.create!(:name => "Cedric 2").id # ascii uppercase
+      ids << Person.create!(:name => "čedriĉ คฉ Almost last cedric").id # latin special, with non-latin
+      ids << Person.create!(:name => "Sedric 2").id # last latin in ascending order
+      ids << Person.create!(:name => "1 cedric").id # numbers before characters
+      ids << Person.create!(:name => "cedric 1").id # ascii lowercase
+      ids << Person.create!(:name => "คฉ Really last").id # non-latin characters last in ascending order
+      ids << Person.create!(:name => "čedriĉ ꜩ Last").id # latin special, with latin non-collateable
+
+      names_asc = ["1 cedric", "a cedric", "cedric 1", "Cedric 2", "ċedriĉ 3", "čedriĉ 4", "ćedriĉ Last", "čedriĉ คฉ Almost last cedric", "čedriĉ ꜩ Last", "sedric 1", "Sedric 2",  "คฉ Really last"]
+      people = Person.where(:id => ids).all
+      subject.sort!(people, [:name, true])
+      people.map(&:name).should == names_asc
+
+      subject.sort!(people, [:name, false])
+      people.map(&:name).should == names_asc.reverse
+    end
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: record-cache
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Orslumen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-07 00:00:00 Z
+date: 2011-10-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rails
@@ -23,7 +23,7 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 7
         segments: 
@@ -38,7 +38,7 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
         hash: 7
         segments: 
@@ -168,6 +168,7 @@ files:
 - lib/record_cache/strategy/id_cache.rb
 - lib/record_cache/strategy/index_cache.rb
 - lib/record_cache/strategy/request_cache.rb
+- lib/record_cache/strategy/util.rb
 - lib/record_cache/test/resettable_version_store.rb
 - lib/record_cache/version.rb
 - lib/record_cache/version_store.rb
@@ -183,6 +184,7 @@ files:
 - spec/lib/strategy/id_cache_spec.rb
 - spec/lib/strategy/index_cache_spec.rb
 - spec/lib/strategy/request_cache_spec.rb
+- spec/lib/strategy/util_spec.rb
 - spec/lib/version_store_spec.rb
 - spec/models/apple.rb
 - spec/models/banana.rb
@@ -226,7 +228,7 @@ rubyforge_project:
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Record Cache v0.1.1 transparantly stores Records in a Cache Store and retrieve those Records from the store when queried (by ID) using Active Model.
+summary: Record Cache v0.1.2 transparantly stores Records in a Cache Store and retrieve those Records from the store when queried (by ID) using Active Model.
 test_files: 
 - spec/db/database.yml
 - spec/db/schema.rb
@@ -240,6 +242,7 @@ test_files:
 - spec/lib/strategy/id_cache_spec.rb
 - spec/lib/strategy/index_cache_spec.rb
 - spec/lib/strategy/request_cache_spec.rb
+- spec/lib/strategy/util_spec.rb
 - spec/lib/version_store_spec.rb
 - spec/models/apple.rb
 - spec/models/banana.rb