fresh_redis 0.0.4 → 0.0.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fresh_redis (0.0.4)
+    fresh_redis (0.0.5)
       redis
 
 GEM
@@ -16,6 +16,7 @@ GEM
       rspec (~> 2.11)
     listen (0.5.3)
     mock_redis (0.5.2)
+    rake (0.9.2.2)
     redis (3.0.2)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
@@ -34,4 +35,5 @@ DEPENDENCIES
   fresh_redis!
   guard-rspec (= 2.1.0)
   mock_redis (= 0.5.2)
+  rake (= 0.9.2.2)
   rspec

data/fresh_redis.gemspec

@@ -20,4 +20,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'
+  gem.add_development_dependency 'rake', '0.9.2.2'
 end

data/lib/fresh_redis/hash.rb

@@ -1,38 +1,47 @@
 class FreshRedis
   module Hash
+
     def fhset(key, hash_key, value, options={})
-      key = Key.build(key, options)
+      key = build_key(key, options)
       @redis.multi do
-        @redis.hset(key.redis_key, hash_key, value)
+        @redis.hset(key.redis_key, hash_key, n(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|
+      key = build_key(key, options)
+
+      bucket_values = @redis.pipelined {
+        key.timestamp_buckets.reverse.each do |bucket_key|
           @redis.hget(bucket_key, hash_key)
         end
-      }.compact
+      }
+
+      # find the first non-nil value
+      most_recent_value = bucket_values.find{|e| e } 
+
+      un_n(most_recent_value)
     end
 
     def fhgetall(key, options={})
-      key = Key.build(key, options)
-      @redis.pipelined {
+      key = build_key(key, options)
+
+      bucket_values = @redis.pipelined {
         key.timestamp_buckets.each do |bucket_key|
           @redis.hgetall(bucket_key)
         end
-      }.reject { |hash| hash.count.zero? }
+      }
+
+      merged_values = bucket_values.inject({}){ |acc, bucket_hash|
+        acc.merge(bucket_hash)
+      }
+
+      merged_values.reject{ |key, value| n?(value) }
     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
+      fhset(key, hash_key, nil, options)
     end
   end
 end

data/lib/fresh_redis/string.rb

@@ -1,7 +1,7 @@
 class FreshRedis
   module String
     def fincr(key, options={})
-      key = Key.build(key, options)
+      key = build_key(key, options)
       @redis.multi do
         @redis.incr(key.redis_key)
         @redis.expire(key.redis_key, key.freshness)
@@ -9,7 +9,7 @@ class FreshRedis
     end
 
     def fsum(key, options={})
-      key = Key.build(key, options)
+      key = build_key(key, options)
       @redis.pipelined {
         key.timestamp_buckets.each do |bucket_key|
           @redis.get(bucket_key)

data/lib/fresh_redis/version.rb

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

data/lib/fresh_redis.rb

@@ -7,7 +7,28 @@ class FreshRedis
   include Hash
   include String
 
-  def initialize(redis)
+  NIL_VALUE = "__FR_NIL__"
+
+  def initialize(redis, options={})
     @redis = redis
+    @options = options
+  end
+
+  def build_key(base_key, options={})
+    options = @options.merge(options)
+    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

@@ -6,53 +6,107 @@ describe FreshRedis do
   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 } 
 
   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
+      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
+
         mock_redis.data["foo:#{normalized_now_minute}"].should == {"bar" => "newer_value"}
       end
 
-      it "should set the freshness as the expiry" do
+      it "sets a placeholder value if nil is set as the value" do
+        subject.fhset "foo", "bar", nil, :t => now
+
+        mock_redis.data["foo:#{normalized_now_minute}"].should == {"bar" => FreshRedis::NIL_VALUE }
+      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
+
         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"]
+      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
+
+        subject.fhdel "foo", "bar", :t => now # 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" }
       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"]
+      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"
+
+        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"
+      end
+
+      it "returns nil if value is not found" do
+        subject.fhget("foo", "bar", :t => now).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
       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"}
-        ]
+      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"
+
+        subject.fhgetall("foo", :t => now).should == { "bar" => "francis", "baz" => "bill" }
       end
     end
   end

data/spec/fresh_redis/key_spec.rb

@@ -3,7 +3,6 @@ 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

data/spec/fresh_redis/string_spec.rb

@@ -10,9 +10,9 @@ describe FreshRedis do
   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
+        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
       end
 
@@ -24,19 +24,20 @@ describe FreshRedis do
     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", :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.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
 
-        subject.fsum("foo", :freshness => 60, :granularity => 10, :t => now).should ==  9
+        subject.fsum("foo", :t => now).should ==  9
       end
     end
 

data/spec/fresh_redis_spec.rb

@@ -2,4 +2,26 @@ require 'fresh_redis'
 require 'mock_redis'
 
 describe FreshRedis do
+  let(:mock_redis) { MockRedis.new }
+
+  describe "#build_key" do
+    it "builds a new key based on custom options" do
+      key = "key"
+      FreshRedis::Key.should_receive(:build).with("foo", :granularity => 111, :freshness => 222).and_return(key)
+
+      fresh_redis = FreshRedis.new(mock_redis, :granularity => 111, :freshness => 222)
+
+      fresh_redis.build_key("foo").should == key
+    end
+
+    it "builds a new key no options if custom options not provided" do
+      key = "key"
+      FreshRedis::Key.should_receive(:build).with("foo", {}).and_return(key)
+
+      fresh_redis = FreshRedis.new(mock_redis)
+
+      fresh_redis.build_key("foo").should == key
+    end
+
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fresh_redis
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-14 00:00:00.000000000 Z
+date: 2012-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -75,6 +75,22 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
 description: Aggregate, expiring, recent data in Redis
 email:
 - madlep@madlep.com
@@ -112,12 +128,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1443868887867383191
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1443868887867383191
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23