record-cache 0.1.3 → 0.1.4

data/lib/record_cache/strategy/util.rb

@@ -19,7 +19,13 @@ module RecordCache
           record = serialized[CLASS_KEY].constantize.allocate
           attributes = serialized[ATTRIBUTES_KEY]
           record.class.serialized_attributes.keys.each do |attribute|
-            attributes[attribute] = attributes[attribute].unserialize if attributes[attribute].respond_to?(:unserialize)
+            if attributes[attribute].respond_to?(:unserialize)
+              if attributes[attribute].method(:unserialize).arity > 0
+                attributes[attribute] = attributes[attribute].unserialize(attributes[attribute].value)
+              else
+                attributes[attribute] = attributes[attribute].unserialize
+              end
+            end
           end
           record.init_with('attributes' => attributes)
           record
@@ -27,15 +33,26 @@ module RecordCache
 
         # Filter the cached records in memory
         # only simple x = y or x IN (a,b,c) can be handled
+        # string comparison is case insensitive
         # 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)) }
+              where_values = Set.new(value.first.respond_to?(:downcase) ? value.map(&:downcase) : value)
+              records.to_a.select! do |record|
+                attribute_value = record.send(attr)
+                attribute_value = attribute_value.downcase if attribute_value.respond_to?(:downcase)
+                where_values.include?(attribute_value)
+              end
             else
-              records.reject! { |record| record.send(attr) != value }
+              where_value = value.respond_to?(:downcase) ? value.downcase : value
+              records.to_a.select! do |record|
+                attribute_value = record.send(attr)
+                attribute_value = attribute_value.downcase if attribute_value.respond_to?(:downcase)
+                attribute_value == where_value
+              end
             end
           end
         end

data/lib/record_cache/version.rb

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

data/spec/db/create-record-cache-db_and_user.sql

@@ -0,0 +1,5 @@
+DROP DATABASE IF EXISTS record_cache;
+CREATE DATABASE record_cache;
+CREATE USER 'record_cache'@'localhost' IDENTIFIED BY 'test';
+GRANT ALL ON record_cache.* to 'record_cache'@'localhost';
+FLUSH PRIVILEGES;

data/spec/db/database.yml

@@ -4,3 +4,10 @@ sqlite3:
   encoding: utf8
   charset: utf8
   timeout: 5000
+
+
+mysql:
+  adapter: mysql2
+  database: "record_cache"
+  username: record_cache
+  password: test

data/spec/db/schema.rb

@@ -1,52 +1,46 @@
-ActiveRecord::Schema.define :version => 0 do
+ActiveRecord::Schema.define version: 0 do
 
-  create_table :people, :force => true do |t|
-    t.integer :id
+  create_table :people, force: true do |t|
     t.string  :name
     t.date    :birthday
     t.float   :height
   end
 
-  create_table :stores, :force => true do |t|
-    t.integer :id
+  create_table :stores, force: true do |t|
     t.string  :name
     t.integer :owner_id
   end
 
-  create_table :people_stores, :id => false, :force => true do |t|
+  create_table :people_stores, id: false, force: true do |t|
     t.integer :person_id
     t.string  :store_id
   end
 
-  create_table :apples, :force => true do |t|
-    t.integer :id
+  create_table :apples, force: true do |t|
     t.string  :name
     t.integer :store_id
     t.integer :person_id
   end
 
-  create_table :bananas, :force => true do |t|
-    t.integer :id
+  create_table :bananas, force: true do |t|
     t.string  :name
     t.integer :store_id
     t.integer :person_id
   end
 
-  create_table :pears, :force => true do |t|
-    t.integer :id
+  create_table :pears, force: true do |t|
     t.string  :name
     t.integer :store_id
     t.integer :person_id
   end
 
-  create_table :addresses, :force => true do |t|
-    t.integer :id
+  create_table :addresses, force: true do |t|
     t.string  :name
     t.integer :store_id
     t.string  :location
   end
 
-  create_table :languages, :force => true do |t|
+  create_table :languages, force: true do |t|
     t.string  :name
     t.string  :locale
   end

data/spec/initializers/backward_compatibility.rb

@@ -0,0 +1,32 @@
+if ActiveRecord::VERSION::MAJOR < 4
+
+  module ActiveRecord
+    class Base
+      class << self
+        # generic find_by introduced in Rails 4
+        def find_by(*args)
+          where(*args).first
+        rescue RangeError
+          nil
+        end unless method_defined? :find_by
+      end
+    end
+  end
+
+  module ActiveSupport
+    module Dependencies
+      module Loadable
+        # load without arguments in Rails 4 is similar to +to_a+ in Rails 3
+        def load_with_default(*args)
+          if self.respond_to?(:to_a)
+            self.to_a
+          else
+            self.load_without_default(*args)
+          end
+        end
+        alias_method_chain :load, :default
+      end
+    end
+  end
+
+end

data/spec/lib/active_record/visitor_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'ActiveRecord Visitor' do
+RSpec.describe 'ActiveRecord Visitor' do
 
   def find_visit_methods(visitor_class)
     (visitor_class.instance_methods + visitor_class.private_instance_methods).select{ |method| method.to_s =~ /^visit_Arel_/ }.sort.uniq

data/spec/lib/base_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe RecordCache::Base do
+RSpec.describe RecordCache::Base do
 
   it "should run a block in enabled mode" do
     RecordCache::Base.disable!
@@ -18,4 +18,4 @@ describe RecordCache::Base do
     RecordCache::Base.logger = nil
     expect(RecordCache::Base.logger).to eq(::ActiveRecord::Base.logger)
   end
-end
+end

data/spec/lib/dispatcher_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RecordCache::Dispatcher do
+RSpec.describe RecordCache::Dispatcher do
   before(:each) do
     @apple_dispatcher = Apple.record_cache
   end

data/spec/lib/multi_read_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RecordCache::MultiRead do
+RSpec.describe RecordCache::MultiRead do
 
   it "should not delegate to single reads when multi_read is supported" do
     class MultiReadSupported

data/spec/lib/query_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RecordCache::Query do
+RSpec.describe RecordCache::Query do
   before(:each) do
     @query = RecordCache::Query.new
   end

data/spec/lib/statistics_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RecordCache::Statistics do
+RSpec.describe RecordCache::Statistics do
   before(:each) do
     # remove active setting from other tests
     RecordCache::Statistics.send(:remove_instance_variable, :@active) if RecordCache::Statistics.instance_variable_get(:@active)

data/spec/lib/strategy/base_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe RecordCache::Strategy::Base do
+RSpec.describe RecordCache::Strategy::Base do
 
   it "should force implementation of self.parse method" do
     module RecordCache
@@ -46,54 +46,54 @@ describe RecordCache::Strategy::Base do
 
   context "filter" do
     it "should apply filter on :id cache hits" do
-      expect{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.to use_cache(Apple).on(:id)
-      expect(@apples).to eq([Apple.find_by_name("Adams Apple 1")])
+      expect{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").load }.to use_cache(Apple).on(:id)
+      expect(@apples).to eq([Apple.find_by(name: "Adams Apple 1")])
     end
-    
+
     it "should apply filter on index cache hits" do
-      expect{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple 1").all }.to use_cache(Apple).on(:store_id)
-      expect(@apples).to eq([Apple.find_by_name("Adams Apple 1")])
+      expect{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple 1").load }.to use_cache(Apple).on(:store_id)
+      expect(@apples).to eq([Apple.find_by(name: "Adams Apple 1")])
     end
 
     it "should return empty array when filter does not match any record" do
-      expect{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple Pie").all }.to use_cache(Apple).on(:store_id)
+      expect{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple Pie").load }.to use_cache(Apple).on(:store_id)
       expect(@apples).to be_empty
     end
 
     it "should filter on text" do
-      expect{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.to use_cache(Apple).on(:id)
-      expect(@apples).to eq([Apple.find_by_name("Adams Apple 1")])
+      expect{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").load }.to use_cache(Apple).on(:id)
+      expect(@apples).to eq([Apple.find_by(name: "Adams Apple 1")])
     end
 
     it "should filter on integers" do
-      expect{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => 2).all }.to use_cache(Apple).on(:id)
+      expect{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => 2).load }.to use_cache(Apple).on(:id)
       expect(@apples.map(&:id).sort).to eq([8,9])
     end
 
     it "should filter on dates" do
-      expect{ @people = Person.where(:id => [1,2,3]).where(:birthday => Date.civil(1953,11,11)).all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3]).where(:birthday => Date.civil(1953,11,11)).load }.to use_cache(Person).on(:id)
       expect(@people.size).to eq(1)
       expect(@people.first.name).to eq("Blue")
     end
 
     it "should filter on floats" do
-      expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).load }.to use_cache(Person).on(:id)
       expect(@people.size).to eq(2)
       expect(@people.map(&:name).sort).to eq(["Blue", "Cris"])
     end
 
     it "should filter on arrays" do
-      expect{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => [2, 4]).all }.to use_cache(Apple).on(:id)
+      expect{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => [2, 4]).load }.to use_cache(Apple).on(:id)
       expect(@apples.map(&:id).sort).to eq([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!
 
-      expect{ @apples = Apple.where(:id => [1,2,3,8,9,10]).where(:store_id => 2).where(:name => @apple.name).all }.to use_cache(Apple).on(:id)
+      expect{ @apples = Apple.where(:id => [1,2,3,8,9,10]).where(:store_id => 2).where(:name => @apple.name).load }.to use_cache(Apple).on(:id)
       expect(@apples.size).to eq(2)
       expect(@apples.map(&:name)).to eq([@apple.name, @apple.name])
       expect(@apples.map(&:id).sort).to eq([8,9])
@@ -103,94 +103,94 @@ describe RecordCache::Strategy::Base do
 
   context "sort" do
     it "should apply sort on :id cache hits" do
-      expect{ @people = Person.where(:id => [1,2,3]).order("name DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3]).order("name DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:name)).to eq(["Cris", "Blue", "Adam"])
     end
 
     it "should apply sort on index cache hits" do
-      expect{ @apples = Apple.where(:store_id => 1).order("person_id ASC").all }.to use_cache(Apple).on(:store_id)
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id ASC").load }.to use_cache(Apple).on(:store_id)
       expect(@apples.map(&:person_id)).to eq([nil, nil, 4, 4, 5])
     end
-    
+
     it "should default to ASC" do
-      expect{ @apples = Apple.where(:store_id => 1).order("person_id").all }.to use_cache(Apple).on(:store_id)
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id").load }.to use_cache(Apple).on(:store_id)
       expect(@apples.map(&:person_id)).to eq([nil, nil, 4, 4, 5])
     end
 
     it "should apply sort nil first for ASC" do
-      expect{ @apples = Apple.where(:store_id => 1).order("person_id ASC").all }.to use_cache(Apple).on(:store_id)
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id ASC").load }.to use_cache(Apple).on(:store_id)
       expect(@apples.map(&:person_id)).to eq([nil, nil, 4, 4, 5])
     end
 
     it "should apply sort nil last for DESC" do
-      expect{ @apples = Apple.where(:store_id => 1).order("person_id DESC").all }.to use_cache(Apple).on(:store_id)
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id DESC").load }.to use_cache(Apple).on(:store_id)
       expect(@apples.map(&:person_id)).to eq([5, 4, 4, nil, nil])
     end
 
     it "should sort ascending on text" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("name ASC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("name ASC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:name)).to eq(["Adam", "Blue", "Cris", "Fry"])
     end
 
     it "should sort descending on text" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("name DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("name DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:name)).to eq(["Fry", "Cris", "Blue", "Adam"])
     end
 
     it "should sort ascending on integers" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("id ASC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("id ASC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:id)).to eq([1,2,3,4])
     end
 
     it "should sort descending on integers" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("id DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("id DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:id)).to eq([4,3,2,1])
     end
 
     it "should sort ascending on dates" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("birthday ASC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("birthday ASC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:birthday)).to eq([Date.civil(1953,11,11), Date.civil(1975,03,20), Date.civil(1975,03,20), Date.civil(1985,01,20)])
     end
 
     it "should sort descending on dates" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("birthday DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("birthday DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:birthday)).to eq([Date.civil(1985,01,20), Date.civil(1975,03,20), Date.civil(1975,03,20), Date.civil(1953,11,11)])
     end
 
     it "should sort ascending on float" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("height ASC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("height ASC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:height)).to eq([1.69, 1.75, 1.75, 1.83])
     end
 
     it "should sort descending on float" do
-      expect{ @people = Person.where(:id => [1,2,3,4]).order("height DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("height DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:height)).to eq([1.83, 1.75, 1.75, 1.69])
     end
 
     it "should sort on multiple fields (ASC + ASC)" do
-      expect{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id ASC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id ASC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:height)).to eq([1.69, 1.75, 1.75, 1.91])
       expect(@people.map(&:id)).to eq([4, 2, 3, 5])
     end
 
     it "should sort on multiple fields (ASC + DESC)" do
-      expect{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:height)).to eq([1.69, 1.75, 1.75, 1.91])
       expect(@people.map(&:id)).to eq([4, 3, 2, 5])
     end
 
     it "should sort on multiple fields (DESC + ASC)" do
-      expect{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id ASC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id ASC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:height)).to eq([1.91, 1.75, 1.75, 1.69])
       expect(@people.map(&:id)).to eq([5, 2, 3, 4])
     end
 
     it "should sort on multiple fields (DESC + DESC)" do
-      expect{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id DESC").all }.to use_cache(Person).on(:id)
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id DESC").load }.to use_cache(Person).on(:id)
       expect(@people.map(&:height)).to eq([1.91, 1.75, 1.75, 1.69])
       expect(@people.map(&:id)).to eq([5, 3, 2, 4])
     end
-    
+
     it "should use mysql style collation" do
       ids = []
       ids << Person.create!(:name => "ċedriĉ 3").id # latin other special
@@ -207,23 +207,23 @@ describe RecordCache::Strategy::Base do
       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"]
-      expect{ @people = Person.where(:id => ids).order("name ASC").all }.to hit_cache(Person).on(:id).times(ids.size)
+      expect{ @people = Person.where(:id => ids).order("name ASC").load }.to hit_cache(Person).on(:id).times(ids.size)
       expect(@people.map(&:name)).to eq(names_asc)
 
-      expect{ @people = Person.where(:id => ids).order("name DESC").all }.to hit_cache(Person).on(:id).times(ids.size)
+      expect{ @people = Person.where(:id => ids).order("name DESC").load }.to hit_cache(Person).on(:id).times(ids.size)
       expect(@people.map(&:name)).to eq(names_asc.reverse)
     end
   end
 
   it "should combine filter and sort" do
-    expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name DESC").all }.to use_cache(Person).on(:id)
+    expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name DESC").load }.to use_cache(Person).on(:id)
     expect(@people.size).to eq(2)
     expect(@people.map(&:name)).to eq(["Cris", "Blue"])
 
-    expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name").all }.to hit_cache(Person).on(:id).times(3)
+    expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name").load }.to hit_cache(Person).on(:id).times(3)
     expect(@people.map(&:name)).to eq(["Blue", "Cris"])
   end
-  
+
   context "NotImplementedError" do
     before(:each) do
       @invalid_strategy = RecordCache::Strategy::Base.new(Object, nil, nil, {:key => "key"})