persistent-cache 0.1.3 → 0.1.6

data/lib/persistent-cache.rb

@@ -31,27 +31,27 @@ module Persistent
 
     def set(key, value, timestamp)
       if value.nil?
-        delete_entry(Marshal.dump(key))
+        delete_entry(key)
       else
-        save_key_value_pair(Marshal.dump(key), Marshal.dump(value), timestamp)
+        save_key_value_pair(key, value, timestamp)
       end
     end
 
     def []=(key, value)
       if value.nil?
-        delete_entry(Marshal.dump(key))
+        delete_entry(key)
       else
-        save_key_value_pair(Marshal.dump(key), Marshal.dump(value))
+        save_key_value_pair(key, value)
       end
     end
 
     def [](key)
-      lookup_key(Marshal.dump(key))
+      lookup_key(key)
     end
 
     def each(&block)
       keys.each do |key|
-        yield key, lookup_key(Marshal.dump(key))
+        yield key, lookup_key(key)
       end
     end
 
@@ -60,9 +60,7 @@ module Persistent
     end
 
     def keys
-      @storage.keys.collect { |key|
-        Marshal.load(key[0])
-      }
+      @storage.keys    
     end
 
     def clear
@@ -71,32 +69,32 @@ module Persistent
 
     private
 
-    def save_key_value_pair(serialized_key, serialized_value, timestamp = nil)
-      delete_entry(serialized_key)
-      @storage.save_key_value_pair(serialized_key, serialized_value, timestamp)
+    def save_key_value_pair(key, value, timestamp = nil)
+      @storage.delete_entry(key)
+      @storage.save_key_value_pair(key, value, timestamp)
     end
 
-    def lookup_key(serialized_key)
-      result = @storage.lookup_key(serialized_key)
+    def lookup_key(key)
+      result = @storage.lookup_key(key)
       return nil if nil_result?(result)
-      return nil if stale_entry?(serialized_key, result)
+      return nil if stale_entry?(key, result)
 
-      return Marshal.load(result[0][0])
+      return result[0]
     end
 
-    def stale_entry?(serialized_key, result)
+    def stale_entry?(key, result)
       return false if @fresh.nil?
 
-      timestamp = Time.parse(result[0][1])
+      timestamp = Time.parse(result[1])
       if ((Time.now - timestamp) > FRESH)
-        delete_entry(serialized_key)
+        delete_entry(key)
         return true
       end
       return false
     end
 
-    def delete_entry(serialized_key)
-      @storage.delete_entry(serialized_key)
+    def delete_entry(key)
+      @storage.delete_entry(key)
     end
 
     def nil_result?(result)

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

@@ -3,7 +3,7 @@ require 'tempfile'
 
 module Persistent
   class StorageDirectory
-    CACHE_FILE = "cache" unless defined? CACHE_FILE; CACHE_FILE.freeze
+    CACHE_FILE = "cache.gz" unless defined? CACHE_FILE; CACHE_FILE.freeze
 
     attr_accessor :storage_root
 

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

@@ -16,23 +16,24 @@ module Persistent
       @storage_handler.busy_timeout = 30000
     end
 
-    def save_key_value_pair(serialized_key, serialized_value, timestamp = nil)
-      delete_entry(serialized_key)
+    def save_key_value_pair(key, value, timestamp = nil)
+      delete_entry(key)
       time_entry = timestamp.nil? ? Time.now.to_s : timestamp.to_s
-      EH::retry!(:args => [serialized_key, serialized_value, time_entry]) do
-        @storage_handler.execute("INSERT INTO #{DB_TABLE} (key, value, timestamp) VALUES(?, ?, ?)",serialized_key, serialized_value, time_entry)
+      EH::retry!(:args => [Marshal.dump(key), Marshal.dump(value), time_entry]) do
+        @storage_handler.execute("INSERT INTO #{DB_TABLE} (key, value, timestamp) VALUES(?, ?, ?)",Marshal.dump(key), Marshal.dump(value), time_entry)
       end
     end
 
-    def lookup_key(serialized_key)
-      EH::retry!(:args => [serialized_key]) do
-        @storage_handler.execute("SELECT value, timestamp FROM #{DB_TABLE} WHERE key=?", serialized_key)
+    def lookup_key(key)
+      EH::retry!(:args => [Marshal.dump(key)]) do
+        result = @storage_handler.execute("SELECT value, timestamp FROM #{DB_TABLE} WHERE key=?", Marshal.dump(key))
+        !result.nil? && !result.empty? ? [Marshal.load(result[0][0]), result[0][1]] : nil
       end
     end
 
-    def delete_entry(serialized_key)
-      EH::retry!(:args => [serialized_key]) do
-        @storage_handler.execute("DELETE FROM #{DB_TABLE} WHERE key=?", serialized_key)
+    def delete_entry(key)
+      EH::retry!(:args => [Marshal.dump(key)]) do
+        @storage_handler.execute("DELETE FROM #{DB_TABLE} WHERE key=?", Marshal.dump(key))
       end
     end
 
@@ -44,7 +45,7 @@ module Persistent
 
     def keys
       EH::retry!(:args => []) do
-        @storage_handler.execute("SELECT key FROM #{DB_TABLE}")
+        @storage_handler.execute("SELECT key FROM #{DB_TABLE}").collect { |k| Marshal.load(k[0]) }
       end
     end
 
@@ -81,4 +82,4 @@ module Persistent
       @storage_handler
     end
   end
-end
+end

data/lib/persistent-cache/version.rb

@@ -1,5 +1,5 @@
 module Persistent
   class Cache
-    VERSION = "0.1.3"
+    VERSION = "0.1.6"
   end
 end

data/spec/persistent-cache_spec.rb

@@ -51,21 +51,21 @@ describe Persistent::Cache 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(Marshal.dump(@test_key), Marshal.dump(@test_value), nil)
+      @mock_storage.should_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(Marshal.dump(@test_key))
+      @mock_storage.should_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(Marshal.dump(@test_key))
+      @mock_storage.should_receive(:delete_entry).with(@test_key)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache.set(@test_key, nil, Time.now)
     end
@@ -73,7 +73,7 @@ describe Persistent::Cache do
     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(Marshal.dump(@test_key), Marshal.dump(@test_value), nil)
+      @mock_storage.should_receive(:save_key_value_pair).with(@test_key, @test_value, nil)
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key] = @test_value
     end
@@ -82,7 +82,7 @@ describe Persistent::Cache do
       Persistent::StorageSQLite.should_receive(:new).and_return @mock_storage
       @mock_storage.should_receive(:delete_entry)
       timestamp = Time.now - 100
-      @mock_storage.should_receive(:save_key_value_pair).with(Marshal.dump(@test_key), Marshal.dump(@test_value), timestamp)
+      @mock_storage.should_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
@@ -91,8 +91,8 @@ 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(Marshal.dump(@test_key), Marshal.dump(@test_value), nil)
-      @mock_storage.should_receive(:lookup_key).with(Marshal.dump(@test_key)).and_return([[Marshal.dump(@test_value), Time.now.to_s]])
+      @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
       @pcache = Persistent::Cache.new(@db_name)
       @pcache[@test_key] = @test_value
@@ -102,7 +102,7 @@ describe Persistent::Cache do
 
     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(Marshal.dump(@test_key)).and_return([[Marshal.dump(@test_value), (Time.now - Persistent::Cache::FRESH).to_s]])
+      @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
 
       @pcache = Persistent::Cache.new(@db_name)
@@ -111,7 +111,7 @@ describe Persistent::Cache do
 
     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(Marshal.dump(@test_key)).and_return([[Marshal.dump(@test_value), (Time.now - Persistent::Cache::FRESH).to_s]])
+      @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
 
       @pcache = Persistent::Cache.new(@db_name)
@@ -127,7 +127,7 @@ describe Persistent::Cache do
     it "should serialize the key for lookup" do
       @pcache = Persistent::Cache.new(@db_name)
       @pcache["testkey"] = "testvalue"
-      @pcache.should_receive(:lookup_key).with(Marshal.dump("testkey"))
+      @pcache.should_receive(:lookup_key).with("testkey")
       @pcache["testkey"]
     end
   end
@@ -159,7 +159,7 @@ describe Persistent::Cache do
     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
 
@@ -167,7 +167,9 @@ describe Persistent::Cache do
       100.times do |i|
         threads << Thread.new do
           Thread.current['pcache'] = Persistent::Cache.new("multidb") 
-          Thread.current['pcache']["multi_test"] += 1 if not Thread.current['pcache'].nil? and not Thread.current['pcache']["multi_test"].nil?
+          if (!Thread.current['pcache'].nil? && !Thread.current['pcache']["multi_test"].nil?)
+            Thread.current['pcache']["multi_test"] += 1
+          end
         end
       end
       threads.each { |t| t.join }

data/spec/storage/storage_sqlite_spec.rb

@@ -61,7 +61,7 @@ describe Persistent::StorageSQLite do
   context "when asked to store a key value pair" do
     it "should store the key/value pair in the db, with the current time as timestamp" do
       start_time = Time.now - 1
-      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      @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
@@ -73,7 +73,7 @@ describe Persistent::StorageSQLite do
 
     it "should store the key/value pair in the db, 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)
+      @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
@@ -84,8 +84,8 @@ describe Persistent::StorageSQLite do
     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"))
+      @iut.save_key_value_pair(@test_key, @test_value)
+      @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
@@ -97,24 +97,23 @@ describe Persistent::StorageSQLite do
 
   context "When looking up a value given its key" do
     it "should retrieve the value from the database" 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)
+      @iut.save_key_value_pair(@test_key, @test_value)
+      result = @iut.lookup_key(@test_key)
+      result[0].should == @test_value
     end
 
     it "should retrieve the timestamp when the value was stored from the database" do
       now = Time.now.to_s
-      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      @iut.save_key_value_pair(@test_key, @test_value)
       sleep 1
-      result = @iut.lookup_key(Marshal.dump(@test_key))
-      result[0][1].should == now
+      result = @iut.lookup_key(@test_key)
+      result[1].should == now
     end
 
     it "should return an empty array if a key is not in the database" do
-      @iut.delete_entry(Marshal.dump(@test_key))
-      result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.should == []
-      result[0].should == nil
+      @iut.delete_entry(@test_key)
+      result = @iut.lookup_key(@test_key)
+      result.should == nil
     end
   end
 
@@ -124,12 +123,12 @@ describe Persistent::StorageSQLite do
     end
 
     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)
-      @iut.delete_entry(Marshal.dump(@test_key))
-      result = @iut.lookup_key(Marshal.dump(@test_key))
-      result.should == []
+      @iut.save_key_value_pair(@test_key, @test_value)
+      result = @iut.lookup_key(@test_key)
+      result[0].should == @test_value
+      @iut.delete_entry(@test_key)
+      result = @iut.lookup_key(@test_key)
+      result.should == nil
     end
   end
 
@@ -152,17 +151,17 @@ describe Persistent::StorageSQLite do
     it "should return the keys in the 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
+      keys.include?("one").should == true
+      keys.include?("two").should == true
+      keys.include?("three").should == true
       @iut.size.should == 3
     end
 
-    it "should return the keys in an array, with each key in its own sub-array" do
+    it "should return the keys in an array" do
       populate_database(@iut)
       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)
+      test = "one"
+      found = true if (@iut.keys.include?(test))
       found.should == true
     end
   end
@@ -182,12 +181,12 @@ describe Persistent::StorageSQLite do
   end
 
   def populate_database(iut)
-    iut.save_key_value_pair(Marshal.dump("one"), Marshal.dump("one"))
-    iut.save_key_value_pair(Marshal.dump("two"), Marshal.dump("two"))
-    iut.save_key_value_pair(Marshal.dump("three"), Marshal.dump("three"))
+    iut.save_key_value_pair("one", "one")
+    iut.save_key_value_pair("two", "two")
+    iut.save_key_value_pair("three", "three")
   end
 
   def delete_database
     FileUtils.rm_f(@db_name)
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: persistent-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-16 00:00:00.000000000 Z
+date: 2013-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -112,7 +112,6 @@ 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
@@ -139,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.28
 signing_key: 
 specification_version: 3
 summary: Persistent Cache has a default freshness threshold of 179 days after which