persistent-cache 0.1.8 → 0.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWY0N2Y0ZmU4YmE3ZDRhMTAwNDg4MmU2YmUyNDE1ZjZhZDgzZWJlNQ==
+  data.tar.gz: !binary |-
+    NjZiMjdhYWYyYWM4ZjY1YmFiOWJkNThhOTUzNjdjZjE1NTcxNWI3MA==
+SHA512:
+  metadata.gz: !binary |-
+    YWRhODc0MGYwNjNjOGI3ZTg0NTEwMmM2NWI2OGQ3NDgxOWU2ZTIxNWVkY2Y0
+    OThkOTAxYTljNDIxNTQ2NzA5ZTY0ZTg0MmRmOWJmMjRkMzM3ZGE4YTg3OWVi
+    NDBlZjcyOGU1OGJjZDg2M2IzYmU5NDZlZmFkYzllY2FmMTk3YTc=
+  data.tar.gz: !binary |-
+    M2NkMjJkZWRmN2I1MWUyYWZlYzZhOTg1NTZlYjYyZWJkNmY2ODY1NjIxNzYx
+    YzQyMTI0Y2JjOWFmMzkwMTEzZDFhMTg3ZGJmM2MxMjM4OWI3YTk1OGQyMDU5
+    OTU1ZjgxZWUzODI0ZGMwNDQ4NzRkNWQyMWY4ZmY3NmVlN2I4Mzc=

data/README.md

@@ -4,6 +4,8 @@ Persistent cache behaves like a hash, with a pluggable back-end. Currently sqlit
 
 Values in the cache have a default freshness period of 15465600 ms. This can be configured in the cache initializer. Setting fresh = nil indicates that data remains fresh for-ever. Each user of the cache may have his own independent freshness value. Not though that accessing a stale entry deletes it from the cache. You can use timestamp?(key) to read the timestamp of an entry. If stale data is requested from the cache, nil is returned. Data is marshalled before storage. If a key is not found in the cache, nil is returned. Setting the value of a key in the cache to nil deletes the entry. If required, creation time of an entry can be specified using set(key, value, timestamp)
 
+Note that when using a back-end that requires marshalling (e.g. sqlite) the string encoding for []= and [] needs to be the same (e.g. UTF-8, US-ASCII, etc.) If the coding does not match, [] will not be able to find the entry during lookup and will return nil.
+
 This gem is sponsored by Hetzner (Pty) Ltd - http://hetzner.co.za
 
 ## StorageSQLite

data/lib/persistent-cache/storage/storage_directory.rb

@@ -61,6 +61,10 @@ module Persistent
       compile_value_path(key)
     end
 
+    def get_value_path_even_when_not_cached(key)
+      compile_value_path(key)
+    end
+
     def key_cached?(key)
       # don't read the value here, as it may be very large - rather look whether the key is present
       File.exists? compile_key_path(key)

data/lib/persistent-cache/version.rb

@@ -1,5 +1,5 @@
 module Persistent
   class Cache
-    VERSION = "0.1.8"
+    VERSION = "0.2.0"
   end
 end

data/persistent-cache.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rspec', '2.12.0'
   gem.add_development_dependency 'simplecov'
   gem.add_development_dependency 'simplecov-rcov'
+  gem.add_development_dependency 'debugger'
   gem.add_dependency 'sqlite3', '1.3.7'
   gem.add_dependency 'eh'
 end

data/spec/persistent-cache_spec.rb

@@ -15,8 +15,8 @@ describe Persistent::Cache do
   context "when constructing" do
     it "should receive database connection details and create a StorageSQLite instance if specified" do
       @pcache = Persistent::Cache.new(@db_name, Persistent::Cache::STORAGE_SQLITE)
-      @pcache.class.should == Persistent::Cache
-      @pcache.storage.is_a?(Persistent::StorageSQLite).should == true
+      expect(@pcache.class).to eq(Persistent::Cache)
+      expect(@pcache.storage.is_a?(Persistent::StorageSQLite)).to eq(true)
     end
 
     it "should raise an ArgumentError if storage details have not been provided" do
@@ -27,17 +27,17 @@ describe Persistent::Cache do
 
     it "should remember the freshness interval if provided" do
       @pcache = Persistent::Cache.new(@db_name, 123)
-      @pcache.fresh.should == 123
+      expect(@pcache.fresh).to eq(123)
     end
 
     it "should remember the storage details provided" do
       @pcache = Persistent::Cache.new(@db_name, 123)
-      @pcache.storage_details.should == @db_name
+      expect(@pcache.storage_details).to eq(@db_name)
     end
 
     it "should default the freshness interval to FRESH if not provided" do
       @pcache = Persistent::Cache.new(@db_name)
-      @pcache.fresh.should == Persistent::Cache::FRESH
+      expect(@pcache.fresh).to eq(Persistent::Cache::FRESH)
     end
 
     it "should raise an ArgumentError if an unknown storage type has been provided" do
@@ -49,40 +49,40 @@ describe Persistent::Cache do
 
   context "When assigning a value to a key" do
     it "should ask the storage handler to first delete, then save the key/value pair" do
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
-      @mock_storage.should_receive(:delete_entry)
-      @mock_storage.should_receive(:save_key_value_pair).with(@test_key, @test_value, nil)
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, nil)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key] = @test_value
     end
 
     it "should ask the storage handler to delete if the value is nil using []" do
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
-      @mock_storage.should_receive(:delete_entry).with(@test_key)
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry).with(@test_key)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key] = nil
     end
 
     it "should ask the storage handler to delete if the value is nil using set()" do
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
-      @mock_storage.should_receive(:delete_entry).with(@test_key)
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry).with(@test_key)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache.set(@test_key, nil, Time.now)
     end
 
     it "should serialize the key and value for persistence" do
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
-      @mock_storage.should_receive(:delete_entry)
-      @mock_storage.should_receive(:save_key_value_pair).with(@test_key, @test_value, nil)
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, nil)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key] = @test_value
     end
 
     it "should ask the storage handler to store the value, with a specific timestamp if specified" do
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
-      @mock_storage.should_receive(:delete_entry)
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry)
       timestamp = Time.now - 100
-      @mock_storage.should_receive(:save_key_value_pair).with(@test_key, @test_value, timestamp)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, timestamp)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache.set(@test_key, @test_value, timestamp)
     end
@@ -90,29 +90,29 @@ describe Persistent::Cache do
   
   context "When looking up a value given its key" do
     it "should retrieve the value from storage using lookup_key and deserialize the value" do
-      @mock_storage.should_receive(:delete_entry)
-      @mock_storage.should_receive(:save_key_value_pair).with(@test_key, @test_value, nil)
-      @mock_storage.should_receive(:lookup_key).with(@test_key).and_return([@test_value, Time.now.to_s])
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, nil)
+      expect(@mock_storage).to receive(:lookup_key).with(@test_key).and_return([@test_value, Time.now.to_s])
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key] = @test_value
       result = @pcache[@test_key]
-      result.should == @test_value
+      expect(result).to eq(@test_value)
     end
 
     it "should return nil if a value exists but it not fresh" do
-      @mock_storage.should_receive(:delete_entry)
-      @mock_storage.should_receive(:lookup_key).with(@test_key).and_return([@test_value, (Time.now - Persistent::Cache::FRESH).to_s])
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:lookup_key).with(@test_key).and_return([@test_value, (Time.now - Persistent::Cache::FRESH).to_s])
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
 
       @pcache = Persistent::Cache.new(@db_name)
-      @pcache[@test_key].nil?.should == true
+      expect(@pcache[@test_key].nil?).to eq(true)
     end
 
     it "should remove from the cache an entry it encounters that is not fresh" do
-      @mock_storage.should_receive(:delete_entry)
-      @mock_storage.should_receive(:lookup_key).with(@test_key).and_return([@test_value, (Time.now - Persistent::Cache::FRESH).to_s])
-      Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:lookup_key).with(@test_key).and_return([@test_value, (Time.now - Persistent::Cache::FRESH).to_s])
+      expect(Persistent::StorageSQLite).to receive(:new).and_return(@mock_storage)
 
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key]
@@ -121,13 +121,13 @@ describe Persistent::Cache do
     it "should return nil if a key is not in the database" do
       @pcache = Persistent::Cache.new(@db_name)
       result = @pcache["thiskeydoesnotexist"]
-      result.nil?.should == true
+      expect(result.nil?).to eq(true)
     end
 
     it "should serialize the key for lookup" do
       @pcache = Persistent::Cache.new(@db_name)
       @pcache["testkey"] = "testvalue"
-      @pcache.should_receive(:lookup_key).with("testkey")
+      expect(@pcache).to receive(:lookup_key).with("testkey")
       @pcache["testkey"]
     end
   end
@@ -135,12 +135,12 @@ describe Persistent::Cache do
   context "it should behave like a cache" do
     it "should return the correct size" do
       setup_cache
-      @pcache.size.should == 3
+      expect(@pcache.size).to eq(3)
     end
 
     it "should return the list of keys when asked" do
       setup_cache
-      @pcache.keys.should == ["one", "two", "three"]
+      expect(@pcache.keys).to eq(["one", "two", "three"])
     end
 
     it "should allow iteration through each" do
@@ -149,17 +149,17 @@ describe Persistent::Cache do
       @pcache.each do |key, value|
         test << "#{key} => #{value}"
       end
-      test.should == ["one => value one", "two => value two", "three => value three"]
+      expect(test).to eq(["one => value one", "two => value two", "three => value three"])
     end
 
     it "should delete all entries in the database when asked to clear" do
       setup_cache
       @pcache.clear
-      @pcache.size.should == 0
+      expect(@pcache.size).to eq(0)
     end
 
     it "should be able to handle multiple accesses to the same db" do
-      pending "find a better way to test this, currently you need to spawn multiple rspecs running this test to hit the error if the busy_timeout is not specified"
+      #pending "find a better way to test this, currently you need to spawn multiple rspecs running this test to hit the error if the busy_timeout is not specified"
       pcache = Persistent::Cache.new("multidb") 
       pcache["multi_test"] = 0
 

data/spec/spec_helper.rb

@@ -14,9 +14,9 @@ require 'simplecov-rcov'
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'persistent-cache'))
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
+  #config.expect_with(:rspec) { |c| c.syntax = :should }
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing

data/spec/storage/storage_directory_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require "persistent-cache/storage/storage_directory"
+require 'debugger'
 
 describe Persistent::StorageDirectory do
   before :each do
@@ -16,12 +17,14 @@ describe Persistent::StorageDirectory do
 
   context "when constructed" do
     it "should create the database if it does not exist" do
-      File.exists?(@db_name).should be_true
+      #debugger
+      result = File.exists?(@db_name)
+      expect(result).to eq(true)
     end
 
     it "should propagate errors that are raised when failing to create a database" do
       delete_database
-      FileUtils.should_receive(:makedirs).and_raise RuntimeError.new("testing")
+      expect(FileUtils).to receive(:makedirs).and_raise RuntimeError.new("testing")
       expect {
         @iut = Persistent::StorageDirectory.new(@db_name)
       }.to raise_error RuntimeError
@@ -33,11 +36,11 @@ describe Persistent::StorageDirectory do
       test_file = "#{@db_name}/hello"
       `touch #{test_file}`
       Persistent::StorageDirectory.new(@db_name)
-      File.exist?(test_file).should == true
+      expect(File.exist?(test_file)).to eq(true)
     end
 
     it "should have a database" do
-      @iut.is_a?(Persistent::StorageDirectory).should == true
+      expect(@iut.is_a?(Persistent::StorageDirectory)).to eq(true)
     end
 
     it "should raise an ArgumentError if storage details have not been provided" do
@@ -50,7 +53,7 @@ describe Persistent::StorageDirectory do
   context "when asked to store a key value pair" do
     it "should create a directory named the same as the key, in the storage root, if that directory does not exist, and store the value in a file called CACHE_FILE" do
       setup_test_entry
-      read_file_content(@test_file).should == @test_data
+      expect(read_file_content(@test_file)).to eq(@test_data)
     end
 
     it "should default to storing the current time as the first line of the catalogue" do
@@ -64,16 +67,16 @@ describe Persistent::StorageDirectory do
       time = Time.now - 2500
       FileUtils.rm_f(@test_dir)
       @iut.save_key_value_pair(@test_key, @test_data, time)
-      read_file_timestamp(@test_file).should == time.to_s
+      expect(read_file_timestamp(@test_file)).to eq(time.to_s)
     end
 
     it "should overwrite the existing key/value pair if they already exist" do
       FileUtils.rm_f(@test_dir)
       @iut.save_key_value_pair(@test_key, "old data")
       @iut.save_key_value_pair(@test_key, @test_data)
-      File.exists?(@test_dir).should == true
-      File.exists?(@test_file).should == true
-      read_file_content(@test_file).should == @test_data
+      expect(File.exists?(@test_dir)).to eq(true)
+      expect(File.exists?(@test_file)).to eq(true)
+      expect(read_file_content(@test_file)).to eq(@test_data)
     end
 
     it "should raise an ArgumentError if the key is not a string" do
@@ -90,16 +93,16 @@ describe Persistent::StorageDirectory do
 
     it "should store the value exactly as given, regardless of newlines" do
       @iut.save_key_value_pair(@test_key, "some data")
-      @iut.lookup_key(@test_key)[0][0].should == "some data"
+      expect(@iut.lookup_key(@test_key)[0][0]).to eq("some data")
 
       @iut.save_key_value_pair(@test_key, "some data\n")
-      @iut.lookup_key(@test_key)[0][0].should == "some data\n"
+      expect(@iut.lookup_key(@test_key)[0][0]).to eq("some data\n")
 
       @iut.save_key_value_pair(@test_key, "some data\n\n")
-      @iut.lookup_key(@test_key)[0][0].should == "some data\n\n"
+      expect(@iut.lookup_key(@test_key)[0][0]).to eq("some data\n\n")
 
       @iut.save_key_value_pair(@test_key, "\nline 1\n23456\n\n\nsome data\n")
-      @iut.lookup_key(@test_key)[0][0].should == "\nline 1\n23456\n\n\nsome data\n"
+      expect(@iut.lookup_key(@test_key)[0][0]).to eq("\nline 1\n23456\n\n\nsome data\n")
     end
   end
 
@@ -107,20 +110,20 @@ describe Persistent::StorageDirectory do
     it "should retrieve the contents of the catalogue file from the database, excluding the timestamp" do
       setup_test_entry
       result = @iut.lookup_key(@test_key)
-      result[0][0].should == @test_data
+      expect(result[0][0]).to eq(@test_data)
     end
 
     it "should retrieve the timestamp of the revision from the database" do
       now = Time.now
       setup_test_entry
       result = @iut.lookup_key(@test_key)
-      result[0][1].should == now.to_s
+      expect(result[0][1]).to eq(now.to_s)
     end
 
     it "should return an empty array if a key is not in the database" do
       setup_test_entry
       result = @iut.lookup_key("thiskeyshouldnotexist")
-      result.should == []
+      expect(result).to eq([])
     end
 
     it "should raise an ArgumentError if the key is not a string" do
@@ -138,9 +141,9 @@ describe Persistent::StorageDirectory do
     it "should delete the directory that results from the hash if it is present" do
       setup_test_entry
       @iut.delete_entry(@test_key)
-      @iut.lookup_key(@test_key).should == []
-      File.exists?(@test_dir).should == false
-      File.exists?(@test_file).should == false
+      expect(@iut.lookup_key(@test_key)).to eq([])
+      expect(File.exists?(@test_dir)).to eq(false)
+      expect(File.exists?(@test_file)).to eq(false)
     end
 
     it "should raise an ArgumentError if the key is not a string" do
@@ -152,48 +155,48 @@ describe Persistent::StorageDirectory do
 
   context "when asked the size of the database" do
     it "should return 0 if the database has no entries" do
-      @iut.size.should == 0
+      expect(@iut.size).to eq(0)
     end
 
     it "should return the number of entries" do
       populate_database
-      @iut.size.should == 3
+      expect(@iut.size).to eq(3)
     end
 
     it "should return 0 if the database does not exist" do
       delete_database
-      @iut.size.should == 0
+      expect(@iut.size).to eq(0)
     end
   end
 
   context "when asked for the keys in the database" do
     it "should return an empty array if there are no entries in the database" do
-      @iut.keys.should == []
+      expect(@iut.keys).to eq([])
     end
 
     it "should return the keys (directories) in the database" do
       populate_database
-      @iut.keys.should == [["one"], ["three"], ["two"]]
+      expect(@iut.keys).to eq([["one"], ["three"], ["two"]])
     end
 
     it "should return the keys in a sorted array" do
       populate_database
-      @iut.keys.should == [["one"], ["three"], ["two"]]
+      expect(@iut.keys).to eq([["one"], ["three"], ["two"]])
     end
 
     it "should not return the storage root itself" do
       populate_database
       @iut.keys.each do |key|
-        (key == "").should == false
-        (key == "/").should == false
+        expect((key == "")).to eq(false)
+        expect((key == "/")).to eq(false)
       end
     end
 
     it "should return the keys in an array, with each key in its own sub-array" do
       populate_database
-      @iut.keys.is_a?(Array).should == true
-      @iut.keys[0].is_a?(Array).should == true
-      @iut.keys[0][0].is_a?(String).should == true
+      expect(@iut.keys.is_a?(Array)).to eq(true)
+      expect(@iut.keys[0].is_a?(Array)).to eq(true)
+      expect(@iut.keys[0][0].is_a?(String)).to eq(true)
     end
   end
 
@@ -201,26 +204,26 @@ describe Persistent::StorageDirectory do
     it "should not delete the database root directory" do
       setup_test_entry
       @iut.clear
-      File.exists?(@test_file).should == false
-      File.exists?(@test_dir).should == false
-      File.exist?(@iut.storage_root).should == true
+      expect(File.exists?(@test_file)).to eq(false)
+      expect(File.exists?(@test_dir)).to eq(false)
+      expect(File.exist?(@iut.storage_root)).to eq(true)
     end
 
     it "should delete all directories in the database" do
       populate_database
       @iut.clear
-      @iut.size.should == 0
+      expect(@iut.size).to eq(0)
     end
   end
 
   context "when asked about the path to a key's cache value file" do
     it "should return nil if the key is not in the cache" do
-      @iut.get_value_path(@test_key).should == nil
+      expect(@iut.get_value_path(@test_key)).to eq(nil)
     end
 
     it "should return the path to the key's cache value file if the key is in the cache" do
       @iut.save_key_value_pair(@test_key, @test_data)
-      @iut.get_value_path(@test_key).should == @test_file
+      expect(@iut.get_value_path(@test_key)).to eq(@test_file)
     end
 
     it "should raise an ArgumentError if the key is not a string" do
@@ -239,13 +242,13 @@ describe Persistent::StorageDirectory do
   def setup_test_entry
     FileUtils.rm_f(@test_dir)
     @iut.save_key_value_pair(@test_key, @test_data)
-    File.exists?(@test_dir).should == true
-    File.exists?(@test_file).should == true
+    expect(File.exists?(@test_dir)).to eq(true)
+    expect(File.exists?(@test_file)).to eq(true)
   end
 
   def delete_database
     FileUtils.rm_rf(@db_name)
-    File.exists?(@db_name).should == false
+    expect(File.exists?(@db_name)).to eq(false)
   end
 
   def read_file_data(file)
@@ -261,4 +264,4 @@ describe Persistent::StorageDirectory do
     result = File.read(file)
     result.lines.to_a[1..-1].join
   end
-end
+end

data/spec/storage/storage_ram_spec.rb

@@ -10,8 +10,8 @@ describe Persistent::StorageRAM do
 
   context "when constructed" do
     it "should have a storage hash in RAM" do
-      @iut.storage.nil?.should == false
-      @iut.storage.instance_of?(Hash).should == true
+      expect(@iut.storage.nil?).to eql(false)
+      expect(@iut.storage.instance_of?(Hash)).to eql(true)
     end
   end
 
@@ -20,32 +20,33 @@ describe Persistent::StorageRAM do
       start_time = Time.now - 1
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.nil?.should == false
-      result[0].nil?.should == false
-      result[0][0].should == Marshal.dump(@test_value)
+      expect(result.nil?).to eql(false)
+      expect(result[0].nil?).to eql(false)
+      expect(result[0][0]).to eql(Marshal.dump(@test_value))
       test_time = Time.parse(result[0][1])
-      test_time.should > start_time and test_time.should < start_time + 600
+      expect(test_time).to be > start_time
+      expect(test_time).to be < start_time + 600
     end
 
     it "should store the key/value pair in RAM, with a timestamp specified" do
       test_time = (Time.now - 2500)
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value), test_time)
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.nil?.should == false
-      result[0].nil?.should == false
-      result[0][0].should == Marshal.dump(@test_value)
+      expect(result.nil?).to eql(false)
+      expect(result[0].nil?).to eql(false)
+      expect(result[0][0]).to eql(Marshal.dump(@test_value))
       time_retrieved = Time.parse(result[0][1])
-      time_retrieved.to_s.should == test_time.to_s
+      expect(time_retrieved.to_s).to eql(test_time.to_s)
     end
 
     it "should overwrite the existing key/value pair if they already exist" do
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump("testvalue2"))
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.nil?.should == false
-      result[0].nil?.should == false
-      result.size.should == 1
-      result[0][0].should == Marshal.dump("testvalue2")
+      expect(result.nil?).to eql(false)
+      expect(result[0].nil?).to eql(false)
+      expect(result.size).to eql(1)
+      expect(result[0][0]).to eql(Marshal.dump("testvalue2"))
     end
   end
 
@@ -53,7 +54,7 @@ describe Persistent::StorageRAM do
     it "should retrieve the value from RAM" do
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result[0][0].should == Marshal.dump(@test_value)
+      expect(result[0][0]).to eql(Marshal.dump(@test_value))
     end
 
     it "should retrieve the timestamp when the value was stored from RAM" do
@@ -61,14 +62,14 @@ describe Persistent::StorageRAM do
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
       sleep 1
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result[0][1].should == now
+      expect(result[0][1]).to eql(now)
     end
 
     it "should return an empty array if a key is not in RAM" do
       @iut.delete_entry(Marshal.dump(@test_key))
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.should == []
-      result[0].should == nil
+      expect(result).to eql([])
+      expect(result[0]).to eql(nil)
     end
   end
 
@@ -80,36 +81,36 @@ describe Persistent::StorageRAM do
     it "should delete the entry if it is present" do
       @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result[0][0].should == Marshal.dump(@test_value)
+      expect(result[0][0]).to eql(Marshal.dump(@test_value))
       @iut.delete_entry(Marshal.dump(@test_key))
       result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.should == []
+      expect(result).to eql([])
     end
   end
 
   context "when asked the size of the RAM database" do
     it "should return 0 if the RAM database has no entries" do
-      @iut.size.should == 0
+      expect(@iut.size).to eql(0)
     end
 
     it "should return the number of entries" do
       populate_database(@iut)
-      @iut.size.should == 3
+      expect(@iut.size).to eql(3)
     end
   end
 
   context "when asked for the keys in the RAM database" do
     it "should return an empty array if there are no entries in the RAM database" do
-      @iut.keys.should == []
+      expect(@iut.keys).to eql([])
     end
 
     it "should return the keys in the RAM database" do
       populate_database(@iut)
       keys = @iut.keys.flatten
-      keys.include?(Marshal.dump("one")).should == true
-      keys.include?(Marshal.dump("two")).should == true
-      keys.include?(Marshal.dump("three")).should == true
-      @iut.size.should == 3
+      expect(keys.include?(Marshal.dump("one"))).to eql(true)
+      expect(keys.include?(Marshal.dump("two"))).to eql(true)
+      expect(keys.include?(Marshal.dump("three"))).to eql(true)
+      expect(@iut.size).to eql(3)
     end
 
     it "should return the keys in an array, with each key in its own sub-array" do
@@ -117,7 +118,7 @@ describe Persistent::StorageRAM do
       found = false
       test = Marshal.dump("one")
       found = true if (@iut.keys[0][0] == test or @iut.keys[0][1] == test or @iut.keys[0][2] == test)
-      found.should == true
+      expect(found).to eql(true)
     end
   end
 
@@ -125,7 +126,7 @@ describe Persistent::StorageRAM do
     it "should delete all entries in RAM" do
       populate_database(@iut)
       @iut.clear
-      @iut.size.should == 0
+      expect(@iut.size).to eql(0)
     end
   end
 

data/spec/storage/storage_sqlite_spec.rb

@@ -12,18 +12,18 @@ describe Persistent::StorageSQLite do
 
   context "when constructed" do
     it "should create the database if it does not exist" do
-      File.exists?(@db_name).should be_true
+      expect(File.exists?(@db_name)).to eq(true)
     end
 
     it "should create a key_value table with key (TEXT) and value (TEXT) and timestamp (TEXT) columns" do
       handle = SQLite3::Database.open(@db_name)
       result = handle.execute "PRAGMA table_info(#{Persistent::StorageSQLite::DB_TABLE})"
-      result[0][1].should == "key"
-      result[0][2].should == "TEXT"
-      result[1][1].should == "value"
-      result[1][2].should == "TEXT"
-      result[2][1].should == "timestamp"
-      result[2][2].should == "TEXT"
+      expect(result[0][1]).to eq("key")
+      expect(result[0][2]).to eq("TEXT")
+      expect(result[1][1]).to eq("value")
+      expect(result[1][2]).to eq("TEXT")
+      expect(result[2][1]).to eq("timestamp")
+      expect(result[2][2]).to eq("TEXT")
     end
 
 
@@ -35,19 +35,19 @@ describe Persistent::StorageSQLite do
       Persistent::StorageSQLite.new(@db_name)
       handle = SQLite3::Database.open(@db_name)
       result = handle.execute "select name from sqlite_master where type='table'"
-      result[0][0].should == "test123"
+      expect(result[0][0]).to eq("test123")
     end
 
     it "should have a database handler" do
-      @iut.storage_handler.is_a?(SQLite3::Database).should == true
+      expect(@iut.storage_handler.is_a?(SQLite3::Database)).to eq(true)
     end
 
     it "should set the SQLite busy timeout to DB_TIMEOUT" do
       delete_database
       mock_database = double(SQLite3::Database)
-      mock_database.should_receive(:execute).at_least(0)
-      mock_database.should_receive(:busy_timeout=).with(Persistent::StorageSQLite::DB_TIMEOUT)
-      SQLite3::Database.should_receive(:new).and_return(mock_database)
+      expect(mock_database).to receive(:execute)
+      expect(mock_database).to receive(:busy_timeout=).with(Persistent::StorageSQLite::DB_TIMEOUT)
+      expect(SQLite3::Database).to receive(:new).and_return(mock_database)
       Persistent::StorageSQLite.new(@db_name)
     end
 
@@ -64,11 +64,12 @@ describe Persistent::StorageSQLite do
       @iut.save_key_value_pair(@test_key, @test_value)
       handle = SQLite3::Database.open(@db_name)
       result = handle.execute "select value, timestamp from #{Persistent::StorageSQLite::DB_TABLE} where key=?", Marshal.dump(@test_key)
-      result.nil?.should == false
-      result[0].nil?.should == false
-      result[0][0].should == Marshal.dump(@test_value)
+      expect(result.nil?).to eq(false)
+      expect(result[0].nil?).to eq(false)
+      expect(result[0][0]).to eq(Marshal.dump(@test_value))
       test_time = Time.parse(result[0][1])
-      test_time.should > start_time and test_time.should < start_time + 600
+      expect(test_time).to be > start_time
+      expect(test_time).to be < start_time + 600
     end
 
     it "should store the key/value pair in the db, with a timestamp specified" do
@@ -76,11 +77,11 @@ describe Persistent::StorageSQLite do
       @iut.save_key_value_pair(@test_key, @test_value, test_time)
       handle = SQLite3::Database.open(@db_name)
       result = handle.execute "select value, timestamp from #{Persistent::StorageSQLite::DB_TABLE} where key=?", Marshal.dump(@test_key)
-      result.nil?.should == false
-      result[0].nil?.should == false
-      result[0][0].should == Marshal.dump(@test_value)
+      expect(result.nil?).to eq(false)
+      expect(result[0].nil?).to eq(false)
+      expect(result[0][0]).to eq(Marshal.dump(@test_value))
       time_retrieved = Time.parse(result[0][1])
-      time_retrieved.to_s.should == test_time.to_s
+      expect(time_retrieved.to_s).to eq(test_time.to_s)
     end
 
     it "should overwrite the existing key/value pair if they already exist" do
@@ -88,10 +89,10 @@ describe Persistent::StorageSQLite do
       @iut.save_key_value_pair(@test_key, "testvalue2")
       handle = SQLite3::Database.open(@db_name)
       result = handle.execute "select value from #{Persistent::StorageSQLite::DB_TABLE} where key=?", Marshal.dump(@test_key)
-      result.nil?.should == false
-      result[0].nil?.should == false
-      result.size.should == 1
-      result[0][0].should == Marshal.dump("testvalue2")
+      expect(result.nil?).to eq(false)
+      expect(result[0].nil?).to eq(false)
+      expect(result.size).to eq(1)
+      expect(result[0][0]).to eq(Marshal.dump("testvalue2"))
     end
   end
 
@@ -99,7 +100,7 @@ describe Persistent::StorageSQLite do
     it "should retrieve the value from the database" do
       @iut.save_key_value_pair(@test_key, @test_value)
       result = @iut.lookup_key(@test_key)
-      result[0].should == @test_value
+      expect(result[0]).to eq(@test_value)
     end
 
     it "should retrieve the timestamp when the value was stored from the database" do
@@ -107,13 +108,13 @@ describe Persistent::StorageSQLite do
       @iut.save_key_value_pair(@test_key, @test_value)
       sleep 1
       result = @iut.lookup_key(@test_key)
-      result[1].should == now
+      expect(result[1]).to eq(now)
     end
 
     it "should return an empty array if a key is not in the database" do
       @iut.delete_entry(@test_key)
       result = @iut.lookup_key(@test_key)
-      result.should == nil
+      expect(result).to eq(nil)
     end
   end
 
@@ -125,36 +126,36 @@ describe Persistent::StorageSQLite do
     it "should delete the entry if it is present" do
       @iut.save_key_value_pair(@test_key, @test_value)
       result = @iut.lookup_key(@test_key)
-      result[0].should == @test_value
+      expect(result[0]).to eq(@test_value)
       @iut.delete_entry(@test_key)
       result = @iut.lookup_key(@test_key)
-      result.should == nil
+      expect(result).to eq(nil)
     end
   end
 
   context "when asked the size of the database" do
     it "should return 0 if the database has no entries" do
-      @iut.size.should == 0
+      expect(@iut.size).to eq(0)
     end
 
     it "should return the number of entries" do
       populate_database(@iut)
-      @iut.size.should == 3
+      expect(@iut.size).to eq(3)
     end
   end
 
   context "when asked for the keys in the database" do
     it "should return an empty array if there are no entries in the database" do
-      @iut.keys.should == []
+      expect(@iut.keys).to eq([])
     end
 
     it "should return the keys in the database" do
       populate_database(@iut)
       keys = @iut.keys.flatten
-      keys.include?("one").should == true
-      keys.include?("two").should == true
-      keys.include?("three").should == true
-      @iut.size.should == 3
+      expect(keys.include?("one")).to eq(true)
+      expect(keys.include?("two")).to eq(true)
+      expect(keys.include?("three")).to eq(true)
+      expect(@iut.size).to eq(3)
     end
 
     it "should return the keys in an array" do
@@ -162,7 +163,7 @@ describe Persistent::StorageSQLite do
       found = false
       test = "one"
       found = true if (@iut.keys.include?(test))
-      found.should == true
+      expect(found).to eq(true)
     end
   end
 
@@ -170,13 +171,13 @@ describe Persistent::StorageSQLite do
     it "should not delete the database file" do
       populate_database(@iut)
       @iut.clear
-      File.exists?(@db_name).should be_true
+      expect(File.exists?(@db_name)).to eq(true)
     end
 
     it "should delete all entries in the database" do
       populate_database(@iut)
       @iut.clear
-      @iut.size.should == 0
+      expect(@iut.size).to eq(0)
     end
   end
 

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: persistent-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.8
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Wynand van Dyk
@@ -10,12 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-30 00:00:00.000000000 Z
+date: 2015-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -23,7 +21,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -31,7 +28,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -39,7 +35,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -47,7 +42,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov-rcov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -55,7 +49,20 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -63,7 +70,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -71,7 +77,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -79,7 +84,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: eh
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -87,7 +91,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -112,6 +115,7 @@ files:
 - lib/persistent-cache/storage/storage_ram.rb
 - lib/persistent-cache/storage/storage_sq_lite.rb
 - lib/persistent-cache/version.rb
+- multidb
 - persistent-cache.gemspec
 - spec/persistent-cache_spec.rb
 - spec/spec_helper.rb
@@ -120,27 +124,26 @@ files:
 - spec/storage/storage_sqlite_spec.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.28
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Persistent Cache has a default freshness threshold of 179 days after which
   entries are no longer returned
 test_files: