fresh_redis 0.0.1 → 0.0.4

data/Gemfile.lock

@@ -1,15 +1,22 @@
 PATH
   remote: .
   specs:
-    fresh_redis (0.0.1)
+    fresh_redis (0.0.4)
       redis
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.1.3)
+    guard (1.4.0)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-rspec (2.1.0)
+      guard (>= 1.1)
+      rspec (~> 2.11)
+    listen (0.5.3)
     mock_redis (0.5.2)
-    redis (3.0.1)
+    redis (3.0.2)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
       rspec-expectations (~> 2.11.0)
@@ -18,11 +25,13 @@ GEM
     rspec-expectations (2.11.3)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.11.3)
+    thor (0.16.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   fresh_redis!
+  guard-rspec (= 2.1.0)
   mock_redis (= 0.5.2)
   rspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -1,6 +1,12 @@
-# FreshRedis
+# fresh\_redis
 
-TODO: Write a gem description
+Redis is great for managing data that expires on atomically (like caches). However, for data that expires gradually over time, built in commands don't get you all the way. 
+
+For instance, how would you calculate _"count of login failures and successes for the last hour"_? The problem is while you can keep a count using a simple `incr` operation, you have to expire the entire total all at once, or not at all.
+
+A common solution is to split the data up into buckets, say one for each minute, each with their own expiry. You write to the current bucket, set the expiry, then allow it to naturally expire and drop out of your result set over time. To obtain the total value, you `get` all the bucket values, and aggregate the values in some fashion.
+
+That's pretty much what fresh\_redis does, except with less boilerplate, and a little more flexibility.
 
 ## Installation
 
@@ -18,7 +24,42 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Simple usage
+
+```ruby
+require "redis"
+require "fresh_redis"
+fresh = FreshRedis.new(Redis.current)
+
+fresh.fincr "failed_login"
+
+# wait a bit...
+fresh.fincr "failed_login"
+
+# then straight away...
+fresh.fincr "failed_login"
+
+fresh.fsum "failed_login" # will return 3
+
+# wait for the first incr to expire...
+fresh.fsum "failed_login" # will return 2, cause the first incr has expired by now
+```
+
+### 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.
+
+```ruby
+# lets track douch users spamming the forum so we can do something about it...
+
+# store post count for a user for 10 minutes (600 seconds), in buckets of time duration 30 seconds
+fresh.fincr "recent_posts:#{user.id}", :freshness => 600, :granularity => 30
+
+# ...
+
+# note, need to pass in the SAME freshness and granularity options as fincr, so it can correclty lookup the correct keys
+fresh.fsum "recent_posts:#{user.id}", :freshness => 600, :granularity => 30
+```
 
 ## Contributing
 
@@ -27,3 +68,6 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## 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

data/fresh_redis.gemspec

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

data/lib/fresh_redis/hash.rb

@@ -0,0 +1,38 @@
+class FreshRedis
+  module Hash
+    def fhset(key, hash_key, value, options={})
+      key = Key.build(key, options)
+      @redis.multi do
+        @redis.hset(key.redis_key, hash_key, value)
+        @redis.expire(key.redis_key, key.freshness)
+      end
+    end
+
+    def fhget(key, hash_key, options={})
+      key = Key.build(key, options)
+      @redis.pipelined {
+        key.timestamp_buckets.each do |bucket_key|
+          @redis.hget(bucket_key, hash_key)
+        end
+      }.compact
+    end
+
+    def fhgetall(key, options={})
+      key = Key.build(key, options)
+      @redis.pipelined {
+        key.timestamp_buckets.each do |bucket_key|
+          @redis.hgetall(bucket_key)
+        end
+      }.reject { |hash| hash.count.zero? }
+    end
+
+    def fhdel(key, hash_key, options={})
+      key = Key.build(key, options)
+      @redis.pipelined do
+        key.timestamp_buckets.each do |bucket_key|
+          @redis.hdel(bucket_key, hash_key)
+        end
+      end
+    end
+  end
+end

data/lib/fresh_redis/key.rb

@@ -0,0 +1,56 @@
+class FreshRedis
+  class Key
+
+    DEFAULT_OPTIONS = {
+      :freshness => 60 * 60, # 1 hour
+      :granularity => 1 * 60 # 1 minute
+    }
+
+    def self.build(*args)
+      raise "Don't know how to build FreshRedis::Key for #{args.inspect}" unless args[0]
+
+      return args[0] if Key === args[0] # early exit if we've already got a key
+
+      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])
+    end
+    
+    attr_reader :freshness
+
+    def initialize(base_key, t, freshness, granularity)
+      @base_key     = base_key
+      @t            = t
+      @freshness    = freshness
+      @granularity  = granularity
+    end
+
+    def redis_key
+      [@base_key, normalize_time(@t, @granularity)].join(":")
+    end
+
+    def timestamp_buckets
+      from = normalize_time(@t - @freshness, @granularity)
+      to = normalize_time(@t, @granularity)
+      (from..to).step(@granularity).map{|timestamp| [@base_key, timestamp].join(":") }
+    end
+
+    def ==(other)
+      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
+    end
+
+    private
+    def normalize_time(t, granularity)
+      t - (t % granularity)
+    end
+  end
+end

data/lib/fresh_redis/string.rb

@@ -0,0 +1,22 @@
+class FreshRedis
+  module String
+    def fincr(key, options={})
+      key = Key.build(key, options)
+      @redis.multi do
+        @redis.incr(key.redis_key)
+        @redis.expire(key.redis_key, key.freshness)
+      end
+    end
+
+    def fsum(key, options={})
+      key = Key.build(key, options)
+      @redis.pipelined {
+        key.timestamp_buckets.each do |bucket_key|
+          @redis.get(bucket_key)
+        end
+      }.reduce(0){|acc, value|
+        value ? acc + value.to_i : acc
+      }
+    end
+  end
+end

data/lib/fresh_redis/version.rb

@@ -1,3 +1,3 @@
 class FreshRedis
-  VERSION = "0.0.1"
+  VERSION = "0.0.4"
 end

data/lib/fresh_redis.rb

@@ -1,61 +1,13 @@
-require 'fresh_redis/timestamp'
+require 'fresh_redis/hash'
+require 'fresh_redis/key'
+require 'fresh_redis/string'
 require 'fresh_redis/version'
 
 class FreshRedis
-  include Timestamp
-
-  VERSION = "0.0.1"
-
-  DEFAULT_OPTIONS = {
-    :freshness => 60 * 60, # 1 hour
-    :granularity => 1 * 60 # 1 minute
-  }
+  include Hash
+  include String
 
   def initialize(redis)
     @redis = redis
   end
-
-  def fincr(key, options={})
-    options = default_options(options)
-    t           = options[:t]
-    freshness   = options[:freshness]
-    granularity = options[:granularity]
-
-    key = normalize_key(key, t, granularity)
-    @redis.multi do
-      @redis.incr key
-      @redis.expire key, freshness
-    end
-  end
-
-  def fsum(key, options={})
-    options = default_options(options)
-
-    reduce(key, options, 0){|acc, timestamp_total|
-      acc + timestamp_total.to_i
-    }
-  end
-
-  private
-  def reduce(key, options={}, initial=nil, &reduce_operation)
-    options = default_options(options)
-    t           = options[:t]
-    freshness   = options[:freshness]
-    granularity = options[:granularity]
-
-    raw_totals = @redis.pipelined {
-      range_timestamps(t, freshness, granularity).each do |timestamp|
-        timestamp_key = [key, timestamp].join(":")
-        @redis.get(timestamp_key)
-      end
-    }
-
-    raw_totals.reduce(initial, &reduce_operation)
-  end
-
-  def default_options(options)
-    options = DEFAULT_OPTIONS.merge(options)
-    options[:t] ||= Time.now.to_i
-    options
-  end
 end

data/spec/fresh_redis/hash_spec.rb

@@ -0,0 +1,60 @@
+require 'fresh_redis'
+require 'mock_redis'
+
+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 }
+
+  context "hash keys" do 
+
+    describe "#fhset" do
+      it "should set a value for a key in a hash for the normalized timestamp" do
+        subject.fhset "foo", "bar", "value", :granularity => 60, :t => now
+        subject.fhset "foo", "bar", "newer_value", :granularity => 60, :t => now + 3
+        subject.fhset "foo", "bar", "different_bucket", :granularity => 60, :t => now + 60 # different normalized key
+        mock_redis.data["foo:#{normalized_now_minute}"].should == {"bar" => "newer_value"}
+      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.fhset "foo", "bar", "baz", :freshness => 3600, :t => now
+        mock_redis.ttl("foo:#{normalized_now_minute}").should == 3600
+      end
+    end
+
+    describe "#fhdel" do
+      it "should remove a value for a key in a hash for the normalized timestamp" do
+        subject.fhset "foo", "bar", "value", :granularity => 10, :freshness => 20, :t => now - 15
+        subject.fhset "foo", "bar", "different_bucket", :granularity => 10, :freshness => 20, :t => now
+        subject.fhdel "foo", "bar", :granularity => 10, :freshness => 0, :t => now # Should only delete the most recent bucket
+        subject.fhget("foo", "bar", :granularity => 10, :freshness => 20, :t => now ).should == ["value"]
+      end
+    end
+
+    describe "#fhget" do
+      it "should get all the values of the specified key in specified hash for specified freshness and granularity" do
+        subject.fhset "requests", "some_key", "0", :freshness => 60, :granularity => 10, :t => now - 60 - 10 # Too old of a bucket
+        subject.fhset "requests", "some_key", "1", :freshness => 60, :granularity => 10, :t => now - 60 + 5
+        subject.fhset "requests", "some_key", "2", :freshness => 60, :granularity => 10, :t => now - 60 + 15
+        subject.fhset "requests", "some_key", "3", :freshness => 60, :granularity => 10, :t => now - 60 + 16 # This overwrites the previous value in the bucket
+        subject.fhget("requests", "some_key", :freshness => 60, :granularity => 10, :t => now).should == ["1", "3"]
+      end
+    end
+
+    describe "#fhgetall" do
+      it "should get all the values of the specified hash for specified freshness and granularity" do
+        subject.fhset "requests", "some_key", "0", :freshness => 60, :granularity => 10, :t => now - 60 - 10 # Too old of a bucket
+        subject.fhset "requests", "some_key", "1", :freshness => 60, :granularity => 10, :t => now - 60 + 5
+        subject.fhset "requests", "some_key", "2", :freshness => 60, :granularity => 10, :t => now - 60 + 15
+        subject.fhset "requests", "another_key", "3", :freshness => 60, :granularity => 10, :t => now - 60 + 16 # This overwrites the previous value in the bucket
+        subject.fhgetall("requests", :freshness => 60, :granularity => 10, :t => now).should == [
+          {"some_key" => "1"},
+          {"some_key" => "2", "another_key" => "3"}
+        ]
+      end
+    end
+  end
+
+end

data/spec/fresh_redis/key_spec.rb

@@ -0,0 +1,64 @@
+require 'fresh_redis'
+
+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(:normalized_now_hour) { Time.new(2012, 9, 27, 15, 0, 0, "+10:00").to_i }
+
+  describe ".build" do
+    it "complains if no args" do
+      expect { FreshRedis::Key.build() }.to raise_error
+    end
+
+    it "just returns the key if a FreshRedis::Key is provided" do
+      key = FreshRedis::Key.new("key", 123, 456, 789)
+      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)
+    end
+
+        
+    it "constructs a FreshRedis::Key with the default options" 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]
+      )
+    end
+
+  end
+
+  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}"
+    end
+  end
+  
+  describe "#timestamp_buckets" do
+    let(:buckets) { FreshRedis::Key.build("foo", :t => now, :freshness => 600, :granularity => 60).timestamp_buckets }
+    it "generates an enumerable over the range" do
+      buckets.should be_kind_of(Enumerable)
+    end
+
+    it "has one timestamp bucket for each granularity step in the fresh range" do
+      buckets.count.should == 11 # fence-posting. we include the first and last elements in a timestamp range split by granularity
+    end
+
+    it "has the first timestamp as the maximum freshness" do
+      buckets.first.should == ["foo", normalized_now_minute - 600].join(":")
+    end
+
+    it "has now as the maximum freshness" do
+      buckets.to_a.last.should == ["foo", normalized_now_minute].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(":") }
+    end
+  end
+end

data/spec/fresh_redis/string_spec.rb

@@ -0,0 +1,44 @@
+require 'fresh_redis'
+require 'mock_redis'
+
+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 }
+
+  context "string keys" do
+    describe "#fincr" do
+      it "should increment the key for the normalized timestamp" do
+        subject.fincr "foo", :granularity => 60, :t => now
+        subject.fincr "foo", :granularity => 60, :t => now + 3
+        subject.fincr "foo", :granularity => 60, :t => now + 60 # different normalized key
+        mock_redis.data["foo:#{normalized_now_minute}"].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
+      end
+    end
+
+    describe "#fsum" do
+      it "should add the values of keys for specified freshness and granularity" do
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 - 10
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 1
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 2
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 3
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 5
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 8
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 13
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 21
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 34
+        subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 55
+
+        subject.fsum("foo", :freshness => 60, :granularity => 10, :t => now).should ==  9
+      end
+    end
+
+  end
+end

data/spec/fresh_redis_spec.rb

@@ -2,39 +2,4 @@ require 'fresh_redis'
 require 'mock_redis'
 
 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 }
-
-  describe "#fincr" do
-    it "should increment the key for the normalized timestamp" do
-      subject.fincr "foo", :granularity => 60, :t => now
-      subject.fincr "foo", :granularity => 60, :t => now + 3
-      subject.fincr "foo", :granularity => 60, :t => now + 60 # different normalized key
-      mock_redis.data["foo:#{normalized_now_minute}"].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
-    end
-  end
-
-  describe "#fsum" do
-    it "should add the values of keys for specified freshness and granularity" do
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 1
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 2
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 3
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 5
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 8
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 13
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 21
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 34
-      subject.fincr "foo", :freshness => 60, :granularity => 10, :t => now - 60 + 55
-
-      subject.fsum("foo", :freshness => 60, :granularity => 10, :t => now).should ==  9
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fresh_redis
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000Z
+date: 2012-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70193817243680 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70193817243680
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70193817243180 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,18 +37,44 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193817243180
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mock_redis
-  requirement: &70193817242380 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - =
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.5.2
   type: :development
   prerelease: false
-  version_requirements: *70193817242380
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 description: Aggregate, expiring, recent data in Redis
 email:
 - madlep@madlep.com
@@ -55,14 +86,19 @@ files:
 - .rspec
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - fresh_redis.gemspec
 - lib/fresh_redis.rb
-- lib/fresh_redis/timestamp.rb
+- lib/fresh_redis/hash.rb
+- lib/fresh_redis/key.rb
+- lib/fresh_redis/string.rb
 - lib/fresh_redis/version.rb
-- spec/fresh_redis/timestamp_spec.rb
+- spec/fresh_redis/hash_spec.rb
+- spec/fresh_redis/key_spec.rb
+- spec/fresh_redis/string_spec.rb
 - spec/fresh_redis_spec.rb
 homepage: ''
 licenses: []
@@ -76,25 +112,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 107948125749487774
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 107948125749487774
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Use redis for working with recent temporal based data that can expiry gradually.
   Useful for things like "get a count all failed login attempts for the last hour"
 test_files:
-- spec/fresh_redis/timestamp_spec.rb
+- spec/fresh_redis/hash_spec.rb
+- spec/fresh_redis/key_spec.rb
+- spec/fresh_redis/string_spec.rb
 - spec/fresh_redis_spec.rb

data/lib/fresh_redis/timestamp.rb

@@ -1,17 +0,0 @@
-class FreshRedis
-  module Timestamp
-    def normalize_key(key, t, granularity)
-      [key, normalize_time(t, granularity)].join(":")
-    end
-
-    def normalize_time(t, granularity)
-      t - (t % granularity)
-    end
-
-    def range_timestamps(t, freshness, granularity)
-      from = normalize_time(t - freshness, granularity)
-      to = normalize_time(t, granularity)
-      (from..to).step(granularity)
-    end
-  end
-end

data/spec/fresh_redis/timestamp_spec.rb

@@ -1,49 +0,0 @@
-require 'fresh_redis'
-
-describe FreshRedis::Timestamp do
-  subject { Class.new.extend(FreshRedis::Timestamp) }
-  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_now_hour) { Time.new(2012, 9, 27, 15, 0, 0, "+10:00").to_i }
-
-  describe "#normalize_key" do
-    it "should append the normalized timestamp to the key" do
-      subject.normalize_key("foo", now, 60).should == "foo:#{normalized_now_minute}"
-    end
-  end
-  
-  describe "#normalize_time" do
-    it "should round down timestamp to nearest multiple of granularity" do
-      subject.normalize_time(now, 60).should == normalized_now_minute
-      subject.normalize_time(now, 3600).should == normalized_now_hour
-    end
-
-    it "shouldn't change the timestamp if the granularity is 1" do
-      subject.normalize_time(now, 1).should == now
-    end
-  end
-
-  describe "#range_timestamps" do
-    let(:range) { subject.range_timestamps(now, 600, 60) }
-    it "should generate an enumerable over the range" do
-      range.should be_kind_of(Enumerable)
-    end
-
-    it "should have one timestamp for each granularity step in the fresh range" do
-      range.count.should == 11 # fence-posting. we include the first and last elements in a timestamp range split by granularity
-    end
-
-    it "should have the first timestamp as the maximum freshness" do
-      range.first.should == normalized_now_minute - 600
-    end
-
-    it "should have now as the maximum freshness" do
-      range.to_a.last.should == normalized_now_minute
-    end
-
-    it "should step through the normalized timestamps split up by granularity" do
-      range.each_with_index{|t, i| t.should == normalized_now_minute - 600 + i * 60 }
-    end
-  end
-
-end