fresh_redis 0.0.5 → 0.0.6

data/Gemfile

@@ -2,3 +2,10 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in fresh_redis.gemspec
 gemspec
+
+# HAX to allow native file change detection to work on linux AND OSX
+# from https://github.com/carlhuda/bundler/issues/663#issuecomment-2849045
+group :development do
+  gem 'rb-fsevent', :require => RUBY_PLATFORM.include?('darwin') && 'rb-fsevent'
+  gem 'rb-inotify', :require => RUBY_PLATFORM.include?('linux') && 'rb-inotify'
+end

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    fresh_redis (0.0.5)
+    fresh_redis (0.0.6)
       redis
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.1.3)
+    ffi (1.1.5)
     guard (1.4.0)
       listen (>= 0.4.2)
       thor (>= 0.14.6)
@@ -17,6 +18,9 @@ GEM
     listen (0.5.3)
     mock_redis (0.5.2)
     rake (0.9.2.2)
+    rb-fsevent (0.9.2)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
     redis (3.0.2)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
@@ -27,6 +31,7 @@ GEM
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.11.3)
     thor (0.16.0)
+    timecop (0.5.2)
 
 PLATFORMS
   ruby
@@ -36,4 +41,7 @@ DEPENDENCIES
   guard-rspec (= 2.1.0)
   mock_redis (= 0.5.2)
   rake (= 0.9.2.2)
+  rb-fsevent
+  rb-inotify
   rspec
+  timecop (= 0.5.2)

data/README.md

@@ -24,7 +24,7 @@ Or install it yourself as:
 
 ## Usage
 
-### Simple usage
+### Simple counts
 
 ```ruby
 require "redis"
@@ -45,6 +45,14 @@ fresh.fsum "failed_login" # will return 3
 fresh.fsum "failed_login" # will return 2, cause the first incr has expired by now
 ```
 
+### Hash operations
+
+```ruby
+# TODO
+```
+
+TODO note about handling of deletes/nil values and :force option on `fhdel` operation
+
 ### Tweaking _"freshness"_ and _"granularity"_. 
 
 Think of it like stock rotation at your local supermarket. Freshness is how long we'll keep food around for before throwing it out, granularity is what batches we'll throw old food out together as. Something like _"we'll keep food around for a week, but we'll throw out everything for the same day at the same time."_ This is a performance trade off. Smaller granularity means more precise expiration of data, at the expense of having to store, retrieve, and check more buckets of data to get the aggregate value.
@@ -61,6 +69,14 @@ fresh.fincr "recent_posts:#{user.id}", :freshness => 600, :granularity => 30
 fresh.fsum "recent_posts:#{user.id}", :freshness => 600, :granularity => 30
 ```
 
+# Recipes
+
+## Tracking user signin attempts count over the last hour
+TODO
+
+## Tracking dropped requests for the last day
+TODO
+
 ## Contributing
 
 1. Fork it
@@ -71,3 +87,5 @@ fresh.fsum "recent_posts:#{user.id}", :freshness => 600, :granularity => 30
 
 ## Who the hell?
 I blame [@madlep](http://twitter.com/madlep) aka Julian Doherty. Send hate mail to [madlep@madlep.com](mailto:madlep@madlep.com), or deface [madlep.com](http://madlep.com) in protest
+
+Thanks to [chendo](https://github.com/chendo) for initial hash operations.

data/fresh_redis.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'mock_redis', '0.5.2'
   gem.add_development_dependency 'guard-rspec', '2.1.0'
   gem.add_development_dependency 'rake', '0.9.2.2'
+  gem.add_development_dependency 'timecop', '0.5.2'
 end

data/lib/fresh_redis/hash.rb

@@ -4,7 +4,7 @@ class FreshRedis
     def fhset(key, hash_key, value, options={})
       key = build_key(key, options)
       @redis.multi do
-        @redis.hset(key.redis_key, hash_key, n(value))
+        @redis.hset(key.redis_key, hash_key, value)
         @redis.expire(key.redis_key, key.freshness)
       end
     end
@@ -19,9 +19,7 @@ class FreshRedis
       }
 
       # find the first non-nil value
-      most_recent_value = bucket_values.find{|e| e } 
-
-      un_n(most_recent_value)
+      bucket_values.find{|e| e } 
     end
 
     def fhgetall(key, options={})
@@ -37,11 +35,17 @@ class FreshRedis
         acc.merge(bucket_hash)
       }
 
-      merged_values.reject{ |key, value| n?(value) }
+      merged_values.reject{ |key, value| !value }
     end
 
     def fhdel(key, hash_key, options={})
-      fhset(key, hash_key, nil, options)
+      key = build_key(key, options)
+
+      bucket_values = @redis.pipelined {
+        key.timestamp_buckets.each do |bucket_key|
+          @redis.hdel(bucket_key, hash_key)
+        end
+      }
     end
   end
 end

data/lib/fresh_redis/key.rb

@@ -1,5 +1,8 @@
+require 'time'
+
 class FreshRedis
   class Key
+    # TODO remove concept of time from a key. Just be about redis key, freshness, granularity
 
     DEFAULT_OPTIONS = {
       :freshness => 60 * 60, # 1 hour
@@ -14,27 +17,27 @@ class FreshRedis
       base_key = args[0]
         
       options = DEFAULT_OPTIONS.merge(args[1] || {})
-      options[:t] ||= Time.now.to_i
 
-      self.new(base_key, options[:t], options[:freshness], options[:granularity])
+      self.new(base_key, options[:freshness], options[:granularity])
     end
     
     attr_reader :freshness
 
-    def initialize(base_key, t, freshness, granularity)
+    def initialize(base_key, freshness, granularity)
       @base_key     = base_key
-      @t            = t
       @freshness    = freshness
       @granularity  = granularity
     end
 
     def redis_key
-      [@base_key, normalize_time(@t, @granularity)].join(":")
+      [@base_key, normalize_time(Time.now.to_i, @granularity)].join(":")
     end
 
     def timestamp_buckets
-      from = normalize_time(@t - @freshness, @granularity)
-      to = normalize_time(@t, @granularity)
+      t = Time.now.to_i
+
+      from = normalize_time(t - @freshness, @granularity)
+      to = normalize_time(t, @granularity)
       (from..to).step(@granularity).map{|timestamp| [@base_key, timestamp].join(":") }
     end
 
@@ -42,7 +45,6 @@ class FreshRedis
       same = true
       same &= Key === other
       same &= @base_key     == other.instance_variable_get(:@base_key)
-      same &= @t            == other.instance_variable_get(:@t)
       same &= @freshness    == other.instance_variable_get(:@freshness)
       same &= @granularity  == other.instance_variable_get(:@granularity)
       same

data/lib/fresh_redis/version.rb

@@ -1,3 +1,3 @@
 class FreshRedis
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/fresh_redis.rb

@@ -7,8 +7,6 @@ class FreshRedis
   include Hash
   include String
 
-  NIL_VALUE = "__FR_NIL__"
-
   def initialize(redis, options={})
     @redis = redis
     @options = options
@@ -19,16 +17,4 @@ class FreshRedis
     Key.build(base_key, options)
   end
 
-  private
-  def n(value)
-    value || NIL_VALUE
-  end
-
-  def un_n(value)
-    n?(value) ? nil : value
-  end
-
-  def n?(value)
-    value == NIL_VALUE
-  end
 end

data/spec/fresh_redis/hash_spec.rb

@@ -1,112 +1,85 @@
 require 'fresh_redis'
 require 'mock_redis'
+require 'timecop'
 
 describe FreshRedis do
   subject{ FreshRedis.new(mock_redis) }
-  let(:mock_redis) { MockRedis.new }
-  let(:now) { Time.new(2012, 9, 27, 15, 40, 56, "+10:00").to_i }
-  let(:normalized_now_minute) { Time.new(2012, 9, 27, 15, 40, 0, "+10:00").to_i }
-  let(:normalized_one_minute_ago) { Time.new(2012, 9, 27, 15, 39, 0, "+10:00").to_i }
-  let(:normalized_two_minutes_ago) { Time.new(2012, 9, 27, 15, 38, 0, "+10:00").to_i }
-  let(:normalized_old) { Time.new(2012, 9, 27, 14, 38, 0, "+10:00").to_i } 
+  let!(:mock_redis) { MockRedis.new }
+  let(:now) { Time.new(2012, 9, 27, 15, 40, 56, "+10:00") }
+  let(:normalized_now_minute) { Time.new(2012, 9, 27, 15, 40, 0, "+10:00") }
+  let(:normalized_one_minute_ago) { Time.new(2012, 9, 27, 15, 39, 0, "+10:00") }
+  let(:normalized_two_minutes_ago) { Time.new(2012, 9, 27, 15, 38, 0, "+10:00") }
+  let(:normalized_old) { Time.new(2012, 9, 27, 14, 38, 0, "+10:00") } 
 
   context "hash keys" do 
+    before(:each) { Timecop.travel(now) }
+    after(:each) { Timecop.return }
 
     describe "#fhset" do
       it "sets a value for a key in a hash for the normalized timestamp" do
-        subject.fhset "foo", "bar", "value", :t => now - 3
-        subject.fhset "foo", "bar", "newer_value", :t => now
-        subject.fhset "foo", "bar", "different_bucket", :t => now - 60 # different normalized key
+        Timecop.freeze(now - 3)   { subject.fhset "foo", "bar", "value" }
+        Timecop.freeze(now)       { subject.fhset "foo", "bar", "newer_value" }
+        Timecop.freeze(now - 60)  { subject.fhset "foo", "bar", "different_bucket" } # different normalized key
 
-        mock_redis.data["foo:#{normalized_now_minute}"].should == {"bar" => "newer_value"}
+        mock_redis.data["foo:#{normalized_now_minute.to_i}"].should == {"bar" => "newer_value"}
       end
 
-      it "sets a placeholder value if nil is set as the value" do
-        subject.fhset "foo", "bar", nil, :t => now
+      it "sets a nil value ok" do
+        Timecop.freeze(now) { subject.fhset "foo", "bar", nil }
 
-        mock_redis.data["foo:#{normalized_now_minute}"].should == {"bar" => FreshRedis::NIL_VALUE }
+        mock_redis.data["foo:#{normalized_now_minute.to_i}"].should == {"bar" => "" }
       end
 
       it "sets the freshness as the expiry" do
         # relying on mock_redis's time handling here - which converts to/from using Time.now Possible flakey temporal breakage potential
-        subject.fhset "foo", "bar", "baz", :freshness => 3600, :t => now
+        subject.fhset "foo", "bar", "baz", :freshness => 3600
 
-        mock_redis.ttl("foo:#{normalized_now_minute}").should == 3600
+        mock_redis.ttl("foo:#{normalized_now_minute.to_i}").should == 3600
       end
     end
 
     describe "#fhdel" do
-      it "sets the value for a key in a hash for the normalized timestamp to be placeholder nil" do
-        subject.fhset "foo", "bar", "value", :t => now
-        subject.fhset "foo", "bar", "different_bucket", :t => now - 60
+      it "removes the field from all timestamp buckets" do
+        Timecop.travel(now)       { subject.fhset "foo", "bar", "value" }
+        Timecop.travel(now)       { subject.fhset "foo", "baz", "don't touch" }
+        Timecop.travel(now - 60)  { subject.fhset "foo", "bar", "different_bucket" }
+        Timecop.travel(now - 60)  { subject.fhset "foo", "baz", "I shouldn't be returned" }
 
-        subject.fhdel "foo", "bar", :t => now # Should only change the most recent bucket
+        Timecop.travel(now)       { subject.fhdel "foo", "bar" } # Should only change the most recent bucket
 
-        mock_redis.data["foo:#{normalized_now_minute}"].should == { "bar" => FreshRedis::NIL_VALUE }
-        mock_redis.data["foo:#{normalized_one_minute_ago}"].should == { "bar" => "different_bucket" }
+        mock_redis.data["foo:#{normalized_now_minute.to_i}"].should == {"baz" => "don't touch"}
+        mock_redis.data["foo:#{normalized_one_minute_ago.to_i}"].should == {"baz" => "I shouldn't be returned"}
       end
     end
 
     describe "#fhget" do
       it "gets the most recent value for the field across timestamped buckets" do
-        mock_redis.hset "foo:#{normalized_now_minute}", "notbar", "francis"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "bar", "bill"
-        mock_redis.hset "foo:#{normalized_two_minutes_ago}", "bar", "louis"
+        mock_redis.hset "foo:#{normalized_now_minute.to_i}", "notbar", "francis"
+        mock_redis.hset "foo:#{normalized_one_minute_ago.to_i}", "bar", "bill"
+        mock_redis.hset "foo:#{normalized_two_minutes_ago.to_i}", "bar", "louis"
 
-        subject.fhget("foo", "bar", :t => now).should == "bill"
-      end
-
-      it "returns nil if the most recent value is the nil placeholder" do
-        mock_redis.hset "foo:#{normalized_now_minute}", "notbar", "francis"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "bar", FreshRedis::NIL_VALUE
-        mock_redis.hset "foo:#{normalized_two_minutes_ago}", "bar", "louis"
-
-        subject.fhget("foo", "bar", :t => now).should be_nil
-      end
-
-      it "returns the most recent value if a nil placeholder value in an earlier bucket has been overwritten in a later bucket" do
-        mock_redis.hset "foo:#{normalized_now_minute}", "bar", "francis"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "bar", FreshRedis::NIL_VALUE
-        mock_redis.hset "foo:#{normalized_two_minutes_ago}", "bar", "louis"
-
-        subject.fhget("foo", "bar", :t => now).should == "francis"
+        subject.fhget("foo", "bar").should == "bill"
       end
 
       it "returns nil if value is not found" do
-        subject.fhget("foo", "bar", :t => now).should be_nil
+        subject.fhget("foo", "bar").should be_nil
       end
 
       it "returns nil if the value is in a bucket that has expired" do
         # this should be handled by redis expiry anyway, but verify code is behaving as expected and not querying more data than needed
-        mock_redis.hset "foo:#{normalized_old}", "bar", "louis"
-        subject.fhget("foo", "bar", :t => now).should be_nil
+        mock_redis.hset "foo:#{normalized_old.to_i}", "bar", "louis"
+        subject.fhget("foo", "bar").should be_nil
       end
     end
 
     describe "#fhgetall" do
       it "merges the values for all keys across timestamp buckets" do
-        mock_redis.hset "foo:#{normalized_now_minute}", "bar", "francis"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "baz", "zoey"
-        mock_redis.hset "foo:#{normalized_two_minutes_ago}", "boz", "louis"
-
-        subject.fhgetall("foo", :t => now).should == { "bar" => "francis", "baz" => "zoey", "boz" => "louis" }
-      end
-
-      it "removes keys that have a nil placeholder value as the most recent value" do
-        mock_redis.hset "foo:#{normalized_now_minute}", "bar", FreshRedis::NIL_VALUE
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "bar", "zoey"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "baz", "louis"
-
-        subject.fhgetall("foo", :t => now).should == { "baz" => "louis" }
-      end
-
-      it "returns the most recent value if a nil placeholder value in an earlier bucket has been overwritten in a later bucket" do
-        mock_redis.hset "foo:#{normalized_now_minute}", "bar", "francis"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "bar", FreshRedis::NIL_VALUE
-        mock_redis.hset "foo:#{normalized_two_minutes_ago}", "bar", "louis"
-        mock_redis.hset "foo:#{normalized_one_minute_ago}", "baz", "bill"
+        mock_redis.hset "foo:#{normalized_now_minute.to_i}", "bar", "francis"
+        mock_redis.hset "foo:#{normalized_one_minute_ago.to_i}", "baz", "zoey"
+        mock_redis.hset "foo:#{normalized_one_minute_ago.to_i}", "bar", "I shouldn't be returned"
+        mock_redis.hset "foo:#{normalized_two_minutes_ago.to_i}", "boz", "louis"
 
-        subject.fhgetall("foo", :t => now).should == { "bar" => "francis", "baz" => "bill" }
+        subject.fhgetall("foo").should == { "bar" => "francis", "baz" => "zoey", "boz" => "louis" }
       end
     end
   end

data/spec/fresh_redis/key_spec.rb

@@ -1,8 +1,12 @@
 require 'fresh_redis'
+require 'timecop'
 
 describe FreshRedis::Key do
-  let(:now) { Time.new(2012, 9, 27, 15, 40, 56, "+10:00").to_i }
-  let(:normalized_now_minute) { Time.new(2012, 9, 27, 15, 40, 0, "+10:00").to_i }
+  let(:now) { Time.new(2012, 9, 27, 15, 40, 56, "+10:00") }
+  let(:normalized_now_minute) { Time.new(2012, 9, 27, 15, 40, 0, "+10:00") }
+
+  before(:each) { Timecop.travel(now) }
+  after(:each) { Timecop.return }
 
   describe ".build" do
     it "complains if no args" do
@@ -10,13 +14,13 @@ describe FreshRedis::Key do
     end
 
     it "just returns the key if a FreshRedis::Key is provided" do
-      key = FreshRedis::Key.new("key", 123, 456, 789)
+      key = FreshRedis::Key.new("key", 123, 456)
       FreshRedis::Key.build(key).should == key
     end
 
     it "constructs a FreshRedis::Key with the provided options" do
-      key = FreshRedis::Key.build("key", :t => 123, :freshness => 456, :granularity => 789)
-      key.should == FreshRedis::Key.new("key", 123, 456, 789)
+      key = FreshRedis::Key.build("key", :freshness => 123, :granularity => 456)
+      key.should == FreshRedis::Key.new("key", 123, 456)
     end
 
         
@@ -24,7 +28,6 @@ describe FreshRedis::Key do
       key = FreshRedis::Key.build("key")
       key.should == FreshRedis::Key.new(
         "key", 
-        Time.now.to_i,
         FreshRedis::Key::DEFAULT_OPTIONS[:freshness], 
         FreshRedis::Key::DEFAULT_OPTIONS[:granularity]
       )
@@ -34,12 +37,12 @@ describe FreshRedis::Key do
 
   describe "#redis_key" do
     it "should append the normalized timestamp to the key" do
-      FreshRedis::Key.build("foo", :t => now, :granularity => 60).redis_key.should == "foo:#{normalized_now_minute}"
+      FreshRedis::Key.build("foo", :granularity => 60).redis_key.should == "foo:#{normalized_now_minute.to_i}"
     end
   end
   
   describe "#timestamp_buckets" do
-    let(:buckets) { FreshRedis::Key.build("foo", :t => now, :freshness => 600, :granularity => 60).timestamp_buckets }
+    let(:buckets) { FreshRedis::Key.build("foo", :freshness => 600, :granularity => 60).timestamp_buckets }
     it "generates an enumerable over the range" do
       buckets.should be_kind_of(Enumerable)
     end
@@ -49,15 +52,15 @@ describe FreshRedis::Key do
     end
 
     it "has the first timestamp as the maximum freshness" do
-      buckets.first.should == ["foo", normalized_now_minute - 600].join(":")
+      buckets.first.should == ["foo", normalized_now_minute.to_i - 600].join(":")
     end
 
     it "has now as the maximum freshness" do
-      buckets.to_a.last.should == ["foo", normalized_now_minute].join(":")
+      buckets.to_a.last.should == ["foo", normalized_now_minute.to_i].join(":")
     end
 
     it "steps through the normalized timestamps split up by granularity" do
-      buckets.each_with_index{|b, i| b.should == ["foo", normalized_now_minute - 600 + i * 60].join(":") }
+      buckets.each_with_index{|b, i| b.should == ["foo", normalized_now_minute.to_i - 600 + i * 60].join(":") }
     end
   end
 end

data/spec/fresh_redis/string_spec.rb

@@ -1,43 +1,47 @@
 require 'fresh_redis'
 require 'mock_redis'
+require 'timecop'
 
 describe FreshRedis do
   subject{ FreshRedis.new(mock_redis) }
   let(:mock_redis) { MockRedis.new }
-  let(:now) { Time.new(2012, 9, 27, 15, 40, 56, "+10:00").to_i }
-  let(:normalized_now_minute) { Time.new(2012, 9, 27, 15, 40, 0, "+10:00").to_i }
+  let(:now) { Time.new(2012, 9, 27, 15, 40, 56, "+10:00") }
+  let(:normalized_now_minute) { Time.new(2012, 9, 27, 15, 40, 0, "+10:00") }
+
+  before(:each) { Timecop.travel(now) }
+  after(:each) { Timecop.return }
 
   context "string keys" do
     describe "#fincr" do
       it "should increment the key for the normalized timestamp" do
-        subject.fincr "foo", :t => now
-        subject.fincr "foo", :t => now + 3
-        subject.fincr "foo", :t => now + 60 # different normalized key
-        mock_redis.data["foo:#{normalized_now_minute}"].to_i.should == 2
+        Timecop.freeze(now)       { subject.fincr "foo" }
+        Timecop.freeze(now + 3)   { subject.fincr "foo" }
+        Timecop.freeze(now + 60)  { subject.fincr "foo" } # different normalized key
+        mock_redis.data["foo:#{normalized_now_minute.to_i}"].to_i.should == 2
       end
 
       it "should set the freshness as the expiry" do
         # relying on mock_redis's time handling here - which converts to/from using Time.now Possible flakey temporal breakage potential
-        subject.fincr "foo", :freshness => 3600, :t => now
-        mock_redis.ttl("foo:#{normalized_now_minute}").should == 3600
+        subject.fincr "foo", :freshness => 3600
+        mock_redis.ttl("foo:#{normalized_now_minute.to_i}").should == 3600
       end
     end
 
     describe "#fsum" do
       subject{ FreshRedis.new(mock_redis, :granularity => 10, :freshness => 60) }
       it "should add the values of keys for specified freshness and granularity" do
-        subject.fincr "foo", :t => now - 60 - 10
-        subject.fincr "foo", :t => now - 60 + 1
-        subject.fincr "foo", :t => now - 60 + 2
-        subject.fincr "foo", :t => now - 60 + 3
-        subject.fincr "foo", :t => now - 60 + 5
-        subject.fincr "foo", :t => now - 60 + 8
-        subject.fincr "foo", :t => now - 60 + 13
-        subject.fincr "foo", :t => now - 60 + 21
-        subject.fincr "foo", :t => now - 60 + 34
-        subject.fincr "foo", :t => now - 60 + 55
+        Timecop.freeze(now - 60 - 10) { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 1)  { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 2)  { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 3)  { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 5)  { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 8)  { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 13) { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 21) { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 34) { subject.fincr "foo" }
+        Timecop.freeze(now - 60 + 55) { subject.fincr "foo" }
 
-        subject.fsum("foo", :t => now).should ==  9
+        subject.fsum("foo").should ==  9
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fresh_redis
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-16 00:00:00.000000000 Z
+date: 2012-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -91,6 +91,22 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
 description: Aggregate, expiring, recent data in Redis
 email:
 - madlep@madlep.com
@@ -130,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1443868887867383191
+      hash: -3713423432962146166
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -139,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1443868887867383191
+      hash: -3713423432962146166
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23