frivol 0.1.7 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.2.0

data/frivol.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{frivol}
-  s.version = "0.1.7"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Marc Heiligers"]
-  s.date = %q{2010-11-01}
+  s.date = %q{2011-03-17}
   s.description = %q{Simple Redis backed temporary storage intended primarily for use with ActiveRecord models to provide caching}
   s.email = %q{marc@eternal.co.za}
   s.extra_rdoc_files = [

data/lib/frivol.rb

@@ -188,17 +188,24 @@ module Frivol
       data, is_new = get_data_and_is_new instance
       data[bucket.to_s] = hash
       
-      key = instance.send(:storage_key, bucket)
-      Frivol::Config.redis[key] = hash.to_json
-      
-      if is_new[bucket.to_s]
-        time = instance.class.storage_expiry(bucket)
-        Frivol::Config.redis.expire(key, time) if time != Frivol::NEVER_EXPIRE
-        is_new[bucket.to_s] = false
-      end
+      store_value instance, is_new[bucket.to_s], hash.to_json, bucket
       
       self.set_data_and_is_new instance, data, is_new
     end
+    
+    def self.store_value(instance, is_new, value, bucket = nil)
+      key = instance.send(:storage_key, bucket)
+      time = instance.class.storage_expiry(bucket)
+      if time == Frivol::NEVER_EXPIRE
+        Frivol::Config.redis[key] = value
+      else
+        Frivol::Config.redis.multi do |redis|
+          time = redis.ttl(key) unless is_new
+          redis[key] = value
+          redis.expire(key, time)
+        end
+      end
+    end
 
     def self.retrieve_hash(instance, bucket = nil)
       data, is_new = get_data_and_is_new instance
@@ -242,11 +249,7 @@ module Frivol
     def self.store_counter(instance, counter, value)
       key = instance.send(:storage_key, counter)
       is_new = !Frivol::Config.redis.exists(key)
-      Frivol::Config.redis[key] = value
-      if is_new
-        time = instance.class.storage_expiry(counter)
-        Frivol::Config.redis.expire(key, time) if time != Frivol::NEVER_EXPIRE
-      end
+      store_value instance, is_new, value, counter
     end
     
     def self.retrieve_counter(instance, counter, default)
@@ -339,6 +342,60 @@ module Frivol
           Frivol::Helpers.clear_hash(self, bucket)
         end
       end
+      
+      # Use Frivol to cache results for a method (similar to memoize).
+      # Options are :bucket which sets the bucket name for the storage,
+      # :expires_in which sets the expiry time for a bucket,
+      # and :counter to create a special counter storage bucket.
+      #
+      # If not :counter the key is the method_name.
+      #
+      # If you supply :expires_in you must also supply a :bucket otherwise
+      # it is ignored (and the default class expires_in is used if supplied).
+      #
+      # If :counter and no :bucket is provided the :bucket is set to the
+      # :bucket is set to the method_name (and so the :expires_in will be used).
+      def frivolize(method_name, options = {})
+        bucket = options[:bucket]
+        time = options[:expires_in]
+        is_counter = options[:counter]
+        bucket = method_name if bucket.nil? && is_counter
+        frivolized_method_name = "frivolized_#{method_name}"
+        
+        self.class_eval do
+          alias_method frivolized_method_name, method_name
+          storage_bucket(bucket, { :expires_in => time, :counter => is_counter }) unless bucket.nil?
+
+          if is_counter
+            define_method method_name do
+              value = send "retrieve_#{bucket}", -2147483647 # A rediculously small number that is unlikely to be used: -2**31 + 1
+              if value == -2147483647
+                value = send frivolized_method_name
+                send "store_#{bucket}", value
+              end
+              value
+            end
+          elsif !bucket.nil?
+            define_method method_name do
+              value = send "retrieve_#{bucket}", { method_name => false }
+              if !value
+                value = send frivolized_method_name
+                send "store_#{bucket}", { method_name => value }
+              end
+              value
+            end
+          else
+            define_method method_name do
+              value = retrieve method_name => false
+              if !value
+                value = send frivolized_method_name
+                store method_name.to_sym => value
+              end
+              value
+            end
+          end
+        end
+      end
     end
     
     # def storage_default(keys_and_defaults)

data/test/fake_redis.rb

@@ -5,35 +5,61 @@ class Redis
   end
 
   def [](key)
-    # puts "retrieve #{key}"
+    # puts "retrieve #{key} => #{@storage[key]} (#{(!@expires[key].nil? && @expires[key] < Time.now) ? 'expired' : 'alive'})"
     return nil if !@expires[key].nil? && @expires[key] < Time.now
     @storage[key]
   end
 
   def []=(key, value)
-    # puts "store #{key}"
+    # puts "store #{key} => #{value}"
     @storage[key] = value
+    @expires.delete key
   end
 
   def del(key)
     # puts "del #{key}"
-    @storage[key] = nil
-    @expires[key] = nil
+    @storage.delete key
+    @expires.delete key
   end
   
   def incr(key)
+    # puts "incr #{key}"
     @storage[key] += 1
   end
   
   def expire(key, time)
-    @expires[key] = Time.now + time
+    begin
+      t = Integer(time) 
+    rescue 
+      raise RuntimeError.new("-ERR value is not an integer")
+    end
+    @expires[key] = Time.now + t
   end
   
   def exists(key)
     @storage.key? key
   end
   
+  def ttl(key)
+    # puts "ttl #{key}"
+    return -1 if @expires[key].nil? || @expires[key] < Time.now
+    (@expires[key] - Time.now).to_i
+  end
+  
+  def multi(&block)
+    yield(self)
+  end
+  
   def flushdb
     @storage = {}
   end
+  
+  # Help with debugging
+  def inspect
+    @storage.keys.sort.map do |key| 
+      result = "\n#{key} => #{@storage[key].inspect}"
+      result << "\n\texpires at #{@expires[key]}" if @expires.key?(key)
+      result
+    end
+  end
 end

data/test/test_frivol.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "#{File.expand_path(File.dirname(__FILE__))}/helper.rb"
 
 class TestFrivol < Test::Unit::TestCase
   def setup 
@@ -8,6 +8,7 @@ class TestFrivol < Test::Unit::TestCase
   end
   
   def teardown
+    # puts Frivol::Config.redis.inspect
     Frivol::Config.redis.flushdb
   end
   
@@ -114,38 +115,52 @@ class TestFrivol < Test::Unit::TestCase
     assert_equal Time.local(2010, 8, 20), t.load
   end
   
-  should "expire storage the first time it's stored" do
+  should "expire storage the everytime time it's stored" do
     class ExpiryTestClass < TestClass
       storage_expires_in 60
     end
     
-    Frivol::Config.redis.expects(:expire).once
+    Frivol::Config.redis.expects(:expire).twice
+    Frivol::Config.redis.expects(:ttl).once
     t = ExpiryTestClass.new
     t.load
     t.save
+    t = ExpiryTestClass.new # get a new one
     t.save
   end
   
   should "expires should not throw nasty errors" do
     t = TestClass.new
     t.save
-    t.expire_storage 0.5
-    sleep 1
+    t.expire_storage 1
+    sleep 2
     t = TestClass.new # Get a fresh instance so that the @frivol_data is empty
     assert_equal "default", t.load
   end
   
   should "use default expiry set on the class" do
     class ExpiryTestClass < TestClass
-      storage_expires_in 0.5
+      storage_expires_in 1
     end
     t = ExpiryTestClass.new
     t.save
-    sleep 1
-    t = TestClass.new # Get a fresh instance so that the @frivol_data is empty
+    sleep 2
+    t = ExpiryTestClass.new # Get a fresh instance so that the @frivol_data is empty
     assert_equal "default", t.load
   end
 
+  # If you save a value to a volatile key, the expiry is cleared
+  should "resaving a value should not clear the expiry" do
+    class ResavingExpiryTestClass < TestClass
+      storage_expires_in 2
+    end
+    t = ResavingExpiryTestClass.new
+    t.save
+    assert Frivol::Config.redis.ttl(t.storage_key) > 0
+    t.save # a second time
+    assert Frivol::Config.redis.ttl(t.storage_key) > 0
+  end
+  
   should "be able to include in other classes with storage expiry" do
     class BlankTestClass
     end
@@ -199,18 +214,18 @@ class TestFrivol < Test::Unit::TestCase
 
   should "have different expiry times for different buckets" do
     class ExpireBucketsTestClass < TestClass
-      storage_bucket :blue, :expires_in => 0.5
+      storage_bucket :blue, :expires_in => 1
       storage_expires_in 2
     end
     t = ExpireBucketsTestClass.new
-    assert_equal 0.5, ExpireBucketsTestClass.storage_expiry(:blue)
+    assert_equal 1, ExpireBucketsTestClass.storage_expiry(:blue)
     assert_equal 2, ExpireBucketsTestClass.storage_expiry
   end
 
   should "expire data in buckets" do
     class ExpireBucketsTestClass < TestClass
-      storage_bucket :blue, :expires_in => 0.5
-      storage_expires_in 2
+      storage_bucket :blue, :expires_in => 1
+      storage_expires_in 3
       
       def save_blue
         store_blue :value => "blue value"
@@ -223,7 +238,7 @@ class TestFrivol < Test::Unit::TestCase
     t = ExpireBucketsTestClass.new
     t.save
     t.save_blue
-    sleep 1
+    sleep 2
     t = ExpireBucketsTestClass.new # get a new instance so @frivol_data is empty
     assert_equal "value", t.load
     assert_equal "blue default", t.load_blue
@@ -261,15 +276,15 @@ class TestFrivol < Test::Unit::TestCase
   
   should "set expiry on counters" do
     class SetExpireCounterTestClass < TestClass
-      storage_bucket :sheep_counter, :counter => true, :expires_in => 0.5
+      storage_bucket :sheep_counter, :counter => true, :expires_in => 1
     end
     t = SetExpireCounterTestClass.new
-    assert_equal 0.5, SetExpireCounterTestClass.storage_expiry(:sheep_counter)  
+    assert_equal 1, SetExpireCounterTestClass.storage_expiry(:sheep_counter)  
   end
 
   should "expire a counter bucket" do
     class ExpireCounterTestClass < TestClass
-      storage_bucket :kitten_grave, :counter => true, :expires_in => 0.5
+      storage_bucket :kitten_grave, :counter => true, :expires_in => 1
 
       def bury_kittens
         store_kitten_grave 10
@@ -279,12 +294,13 @@ class TestFrivol < Test::Unit::TestCase
         retrieve_kitten_grave 0
       end
     end
+    
     k = ExpireCounterTestClass.new
     k.bury_kittens
     assert_equal 10, k.peek_in_grave
-    sleep(0.6)
-    assert_equal 0, k.peek_in_grave  
     
+    sleep 2
+    assert_equal 0, k.peek_in_grave  
   end
 
   # Note: this test will fail from time to time using fake_redis because fake_redis is not thread safe
@@ -359,5 +375,71 @@ class TestFrivol < Test::Unit::TestCase
     assert_equal "value", t.load_gold
   end
   
+  should "frivolize methods" do
+    class FrivolizeTestClass < TestClass
+      def dinosaur_count
+        10
+      end
+      frivolize :dinosaur_count
+    end
+
+    Frivol::Config.redis.expects(:[]=).once
+    Frivol::Config.redis.expects(:[]).twice.returns(nil, { :dinosaur_count => 10 }.to_json)
+
+    t = FrivolizeTestClass.new
+    assert t.methods.include? "dinosaur_count"
+    assert t.methods.include? "frivolized_dinosaur_count"
+    
+    assert_equal 10, t.dinosaur_count
+    
+    t = FrivolizeTestClass.new # a fresh instance
+    assert_equal 10, t.dinosaur_count
+  end
+  
+  should "frivolize methods with expiry in a bucket" do
+    class FrivolizeExpiringBucketTestClass < TestClass
+      def dinosaur_count
+        10
+      end
+      frivolize :dinosaur_count, { :bucket => :dinosaurs, :expires_in => 1 }
+    end
+    Frivol::Config.redis.expects(:[]=).twice
+    Frivol::Config.redis.expects(:[]).times(3).returns(nil, { :dinosaur_count => 10 }.to_json, nil)
+
+    t = FrivolizeExpiringBucketTestClass.new
+    assert_equal 10, t.dinosaur_count
+  
+    t = FrivolizeExpiringBucketTestClass.new # a fresh instance
+    assert_equal 10, t.dinosaur_count
+    
+    sleep 2
+  
+    t = FrivolizeExpiringBucketTestClass.new # another fresh instance after value expired
+    assert_equal 10, t.dinosaur_count
+  end
+  
+  should "frivolize methods with expiry as a counter" do
+    class FrivolizeExpiringBucketTestClass < TestClass
+      def dinosaur_count
+        10
+      end
+      frivolize :dinosaur_count, { :expires_in => 1, :counter => true }
+    end
+    Frivol::Config.redis.expects(:[]=).twice
+    Frivol::Config.redis.expects(:[]).times(3).returns(nil, 10, nil)
+
+    t = FrivolizeExpiringBucketTestClass.new
+    assert t.methods.include? "store_dinosaur_count" # check that the bucket name is the method name
+
+    assert_equal 10, t.dinosaur_count
+  
+    t = FrivolizeExpiringBucketTestClass.new # a fresh instance
+    assert_equal 10, t.dinosaur_count
+    
+    sleep 2
+  
+    t = FrivolizeExpiringBucketTestClass.new # another fresh instance after value expired
+    assert_equal 10, t.dinosaur_count
+  end
   
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: frivol
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 7
-  version: 0.1.7
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Marc Heiligers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-01 00:00:00 +02:00
+date: 2011-03-17 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency