redis-objects 0.3.1 → 0.3.2

data/README.rdoc

@@ -198,6 +198,11 @@ Lists work just like Ruby arrays:
     @list.clear
     # etc
 
+You can bound the size of the list to only hold N elements like so:
+
+    # Only holds 10 elements, throws out old ones when you reach :maxlength.
+    @list = Redis::List.new('list_name', redis_handle, :maxlength => 10)
+
 Complex data types are no problem with :marshal => true:
 
     @list = Redis::List.new('list_name', :marshal => true)

data/Rakefile

@@ -0,0 +1,7 @@
+
+task :test do
+  base = File.dirname(__FILE__)
+  Dir[base + '/spec/*_spec.rb'].each do |f|
+    sh "ruby #{f}"
+  end
+end

data/lib/redis/list.rb

@@ -17,7 +17,7 @@ class Redis
       @options = args.last.is_a?(Hash) ? args.pop : {}
       @redis = args.first || $redis
     end
-    
+
     # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
       push(value)
@@ -27,6 +27,7 @@ class Redis
     # Add a member to the end of the list. Redis: RPUSH
     def push(value)
       redis.rpush(key, to_redis(value))
+      redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
     end
 
     # Remove a member from the end of the list. Redis: RPOP
@@ -37,6 +38,7 @@ class Redis
     # Add a member to the start of the list. Redis: LPUSH
     def unshift(value)
       redis.lpush(key, to_redis(value))
+      redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
     end
 
     # Remove a member from the start of the list. Redis: LPOP
@@ -118,4 +120,4 @@ class Redis
       values.join(', ')
     end
   end
-end
+end

data/lib/redis/sorted_set.rb

@@ -50,7 +50,7 @@ class Redis
     # specified element does not exist in the sorted set, or the key does not exist
     # at all, nil is returned. Redis: ZSCORE.
     def score(member)
-      redis.zscore(key, to_redis(member)).to_i
+      redis.zscore(key, to_redis(member)).to_f
     end
 
     # Return the rank of the member in the sorted set, with scores ordered from
@@ -78,7 +78,7 @@ class Redis
         val = from_redis redis.zrange(key, start_index, end_index, 'withscores')
         ret = []
         while k = val.shift and v = val.shift
-          ret << [k, v.to_i]
+          ret << [k, v.to_f]
         end
         ret
       else
@@ -92,7 +92,7 @@ class Redis
         val = from_redis redis.zrevrange(key, start_index, end_index, 'withscores')
         ret = []
         while k = val.shift and v = val.shift
-          ret << [k, v.to_i]
+          ret << [k, v.to_f]
         end
         ret
       else

data/spec/redis_objects_instance_spec.rb

@@ -9,11 +9,8 @@ require 'redis/set'
 require 'redis/sorted_set'
 
 describe Redis::Value do
-  before :all do
+  before do
     @value = Redis::Value.new('spec/value')
-  end
-
-  before :each do
     @value.delete
   end
 
@@ -22,8 +19,8 @@ describe Redis::Value do
     @value.value = 'Trevor Hoffman'
     @value.should == 'Trevor Hoffman'
     @value.get.should == 'Trevor Hoffman'
-    @value.del.should be_true
-    @value.should be_nil
+    @value.del.should.be.true
+    @value.should.be.nil
   end
 
   it "should handle complex marshaled values" do
@@ -42,161 +39,191 @@ describe Redis::Value do
     @value.value = [[1,2], {:t3 => 4}]
     @value.should == [[1,2], {:t3 => 4}]
     @value.get.should == [[1,2], {:t3 => 4}]
-    @value.del.should be_true
-    @value.should be_nil
+    @value.del.should.be.true
+    @value.should.be.nil
     @value.options[:marshal] = false
   end
 
   it "should support renaming values" do
     @value.value = 'Peter Pan'
     @value.key.should == 'spec/value'
-    @value.rename('spec/value2').should be_true
+    @value.rename('spec/value2')  # can't test result; switched from true to "OK"
     @value.key.should == 'spec/value2'
     @value.should == 'Peter Pan'
     old = Redis::Value.new('spec/value')
-    old.should be_nil
+    old.should.be.nil
     old.value = 'Tuff'
-    @value.renamenx('spec/value').should be_false
+    @value.renamenx('spec/value')  # can't test result; switched from true to "OK"
     @value.value.should == 'Peter Pan'
   end
 
-  after :all do
+  after do
     @value.delete
   end
 end
 
 
 describe Redis::List do
-  before :all do
-    @list = Redis::List.new('spec/list')
-  end
+  describe "as a bounded list" do
+    before do
+      @list = Redis::List.new('spec/bounded_list',
+                              $redis,
+                              :maxlength => 10)
+      1.upto(10) do |i|
+        @list << i
+      end
 
-  before :each do
-    @list.clear
-  end
+      # Make sure that adding < maxlength doesn't mess up.
+      1.upto(10) do |i|
+        @list.at(i - 1).should == i.to_s
+      end
+    end
 
-  it "should handle lists of simple values" do
-    @list.should be_empty
-    @list << 'a'
-    @list.should == ['a']
-    @list.get.should == ['a']
-    @list.unshift 'b'
-    @list.to_s.should == 'b, a'
-    @list.should == ['b','a']
-    @list.get.should == ['b','a']
-    @list.push 'c'
-    @list.should == ['b','a','c']
-    @list.get.should == ['b','a','c']
-    @list.first.should == 'b'
-    @list.last.should == 'c'
-    @list << 'd'
-    @list.should == ['b','a','c','d']
-    @list[1].should == 'a'
-    @list[0].should == 'b'
-    @list[2].should == 'c'
-    @list[3].should == 'd'
-    @list.include?('c').should be_true
-    @list.include?('no').should be_false
-    @list.pop.should == 'd'
-    @list[0].should == @list.at(0)
-    @list[1].should == @list.at(1)
-    @list[2].should == @list.at(2)
-    @list.should == ['b','a','c']
-    @list.get.should == ['b','a','c']
-    @list.shift.should == 'b'
-    @list.should == ['a','c']
-    @list.get.should == ['a','c']
-    @list << 'e' << 'f' << 'e'
-    @list.should == ['a','c','e','f','e']
-    @list.get.should == ['a','c','e','f','e']
-    @list.delete('e').should == 2
-    @list.should == ['a','c','f']
-    @list.get.should == ['a','c','f']
-    @list << 'j'
-    @list.should == ['a','c','f','j']
-    @list[0..2].should == ['a','c','f']
-    @list[0, 2].should == ['a','c','f']  # consistent with Redis, not Ruby
-    @list[1, 3].should == ['c','f','j']
-    @list.length.should == 4
-    @list.size.should == 4
-    @list.should == ['a','c','f','j']
-    @list.get.should == ['a','c','f','j']
-
-    i = -1
-    @list.each do |st|
-      st.should == @list[i += 1]
+    it "should push the first element out of the list" do
+      @list << '11'
+      @list.last.should == '11'
+      @list.first.should == '2'
+      @list.length.should == 10
     end
-    @list.should == ['a','c','f','j']
-    @list.get.should == ['a','c','f','j']
 
-    @list.each_with_index do |st,i|
-      st.should == @list[i]
+    it "should push the last element out of the list for unshift" do
+      @list.unshift('0')
+      @list.last.should == '9'
+      @list.first.should == '0'
+      @list.length.should == 10
     end
-    @list.should == ['a','c','f','j']
-    @list.get.should == ['a','c','f','j']
-
-    coll = @list.collect{|st| st}
-    coll.should == ['a','c','f','j']
-    @list.should == ['a','c','f','j']
-    @list.get.should == ['a','c','f','j']
-
-    @list << 'a'
-    coll = @list.select{|st| st == 'a'}
-    coll.should == ['a','a']
-    @list.should == ['a','c','f','j','a']
-    @list.get.should == ['a','c','f','j','a']
-  end
 
-  it "should handle lists of complex data types" do
-    @list.options[:marshal] = true
-    v1 = {:json => 'data'}
-    v2 = {:json2 => 'data2'}
-    @list << v1
-    @list << v2
-    @list.first.should == v1
-    @list.last.should == v2
-    @list << [1,2,3,[4,5]]
-    @list.last.should == [1,2,3,[4,5]]
-    @list.shift.should == {:json => 'data'}
-    @list.options[:marshal] = false
-  end
-  
-  it "should support renaming lists" do
-    @list.should be_empty
-    @list << 'a' << 'b' << 'a' << 3
-    @list.should == ['a','b','a','3']
-    @list.key.should == 'spec/list'
-    @list.rename('spec/list3', false).should be_true
-    @list.key.should == 'spec/list'
-    @list.redis.del('spec/list3')
-    @list << 'a' << 'b' << 'a' << 3
-    @list.rename('spec/list2').should be_true
-    @list.key.should == 'spec/list2'
-    @list.redis.lrange(@list.key, 0, 3).should == ['a','b','a','3']
-    old = Redis::List.new('spec/list')
-    old.should be_empty
-    old << 'Tuff'
-    old.values.should == ['Tuff']
-    @list.renamenx('spec/list').should be_false
-    @list.renamenx(old).should be_false
-    @list.renamenx('spec/foo').should be_true
-    old.values.should == ['Tuff']
-    @list.clear
-    @list.redis.del('spec/list2')
+    after do
+      @list.clear
+    end
   end
 
-  after :all do
-    @list.clear
+  describe "with basic operations" do
+    before do
+      @list = Redis::List.new('spec/list')
+      @list.clear
+    end
+
+    it "should handle lists of simple values" do
+      @list.should.be.empty
+      @list << 'a'
+      @list.should == ['a']
+      @list.get.should == ['a']
+      @list.unshift 'b'
+      @list.to_s.should == 'b, a'
+      @list.should == ['b','a']
+      @list.get.should == ['b','a']
+      @list.push 'c'
+      @list.should == ['b','a','c']
+      @list.get.should == ['b','a','c']
+      @list.first.should == 'b'
+      @list.last.should == 'c'
+      @list << 'd'
+      @list.should == ['b','a','c','d']
+      @list[1].should == 'a'
+      @list[0].should == 'b'
+      @list[2].should == 'c'
+      @list[3].should == 'd'
+      @list.include?('c').should.be.true
+      @list.include?('no').should.be.false
+      @list.pop.should == 'd'
+      @list[0].should == @list.at(0)
+      @list[1].should == @list.at(1)
+      @list[2].should == @list.at(2)
+      @list.should == ['b','a','c']
+      @list.get.should == ['b','a','c']
+      @list.shift.should == 'b'
+      @list.should == ['a','c']
+      @list.get.should == ['a','c']
+      @list << 'e' << 'f' << 'e'
+      @list.should == ['a','c','e','f','e']
+      @list.get.should == ['a','c','e','f','e']
+      @list.delete('e').should == 2
+      @list.should == ['a','c','f']
+      @list.get.should == ['a','c','f']
+      @list << 'j'
+      @list.should == ['a','c','f','j']
+      @list[0..2].should == ['a','c','f']
+      @list[0, 2].should == ['a','c','f']  # consistent with Redis, not Ruby
+      @list[1, 3].should == ['c','f','j']
+      @list.length.should == 4
+      @list.size.should == 4
+      @list.should == ['a','c','f','j']
+      @list.get.should == ['a','c','f','j']
+
+      i = -1
+      @list.each do |st|
+        st.should == @list[i += 1]
+      end
+      @list.should == ['a','c','f','j']
+      @list.get.should == ['a','c','f','j']
+
+      @list.each_with_index do |st,i|
+        st.should == @list[i]
+      end
+      @list.should == ['a','c','f','j']
+      @list.get.should == ['a','c','f','j']
+
+      coll = @list.collect{|st| st}
+      coll.should == ['a','c','f','j']
+      @list.should == ['a','c','f','j']
+      @list.get.should == ['a','c','f','j']
+
+      @list << 'a'
+      coll = @list.select{|st| st == 'a'}
+      coll.should == ['a','a']
+      @list.should == ['a','c','f','j','a']
+      @list.get.should == ['a','c','f','j','a']
+    end
+
+    it "should handle lists of complex data types" do
+      @list.options[:marshal] = true
+      v1 = {:json => 'data'}
+      v2 = {:json2 => 'data2'}
+      @list << v1
+      @list << v2
+      @list.first.should == v1
+      @list.last.should == v2
+      @list << [1,2,3,[4,5]]
+      @list.last.should == [1,2,3,[4,5]]
+      @list.shift.should == {:json => 'data'}
+      @list.options[:marshal] = false
+    end
+    
+    it "should support renaming lists" do
+      @list.should.be.empty
+      @list << 'a' << 'b' << 'a' << 3
+      @list.should == ['a','b','a','3']
+      @list.key.should == 'spec/list'
+      @list.rename('spec/list3', false)  # can't test result; switched from true to "OK"
+      @list.key.should == 'spec/list'
+      @list.redis.del('spec/list3')
+      @list << 'a' << 'b' << 'a' << 3
+      @list.rename('spec/list2')  # can't test result; switched from true to "OK"
+      @list.key.should == 'spec/list2'
+      @list.redis.lrange(@list.key, 0, 3).should == ['a','b','a','3']
+      old = Redis::List.new('spec/list')
+      old.should.be.empty
+      old << 'Tuff'
+      old.values.should == ['Tuff']
+      @list.renamenx('spec/list').should.be.false
+      @list.renamenx(old).should.be.false
+      @list.renamenx('spec/foo').should.be.true
+      old.values.should == ['Tuff']
+      @list.clear
+      @list.redis.del('spec/list2')
+    end
+
+    after do
+      @list.clear
+    end
   end
 end
 
 describe Redis::Counter do
-  before :all do
+  before do
     @counter  = Redis::Counter.new('spec/counter')
     @counter2 = Redis::Counter.new('spec/counter')
-  end
-
-  before :each do
     @counter.reset
   end
 
@@ -206,11 +233,11 @@ describe Redis::Counter do
     @counter.should == 10
     
     # math proxy ops
-    (@counter == 10).should be_true
-    (@counter <= 10).should be_true
-    (@counter < 11).should be_true
-    (@counter > 9).should be_true
-    (@counter >= 10).should be_true
+    (@counter == 10).should.be.true
+    (@counter <= 10).should.be.true
+    (@counter < 11).should.be.true
+    (@counter > 9).should.be.true
+    (@counter >= 10).should.be.true
     "#{@counter}".should == "10"
 
     @counter.increment.should == 11
@@ -222,19 +249,19 @@ describe Redis::Counter do
     @counter.decrement.should == 12
     @counter2.decrement(4).should == 8
     @counter.should == 8
-    @counter.reset.should be_true
+    @counter.reset.should.be.true
     @counter.should == 0
-    @counter.reset(15).should be_true
+    @counter.reset(15).should.be.true
     @counter.should == 15
   end
 
-  after :all do
+  after do
     @counter.delete
   end
 end
 
 describe Redis::Lock do
-  before :each do
+  before do
     $redis.flushall
   end
 
@@ -247,11 +274,11 @@ describe Redis::Lock do
 
       # The expiration stored in redis should be 15 seconds from when we started
       # or a little more
-      expiration.should be_close((start + expiry).to_f, 2.0)
+      expiration.should.be.close((start + expiry).to_f, 2.0)
     end
 
     # key should have been cleaned up
-    $redis.get("test_lock").should be_nil
+    $redis.get("test_lock").should.be.nil
   end
 
   it "should set value to 1 when no expiration is set" do
@@ -261,7 +288,7 @@ describe Redis::Lock do
     end
 
     # key should have been cleaned up
-    $redis.get("test_lock").should be_nil
+    $redis.get("test_lock").should.be.nil
   end
 
   it "should let lock be gettable when lock is expired" do
@@ -277,8 +304,8 @@ describe Redis::Lock do
     end
 
     # should get the lock because it has expired
-    gotit.should be_true
-    $redis.get("test_lock").should be_nil
+    gotit.should.be.true
+    $redis.get("test_lock").should.be.nil
   end
 
   it "should not let non-expired locks be gettable" do
@@ -297,13 +324,13 @@ describe Redis::Lock do
     rescue => error
     end
 
-    error.should be_kind_of(Redis::Lock::LockTimeout)
+    error.should.be.kind_of(Redis::Lock::LockTimeout)
 
     # should not have the lock
-    gotit.should_not be_true
+    gotit.should.not.be.true
 
     # lock value should still be set
-    $redis.get("test_lock").should_not be_nil
+    $redis.get("test_lock").should.not.be.nil
   end
 
   it "should not remove the key if lock is held past expiration" do
@@ -314,19 +341,16 @@ describe Redis::Lock do
     end
 
     # lock value should still be set since the lock was held for more than the expiry
-    $redis.get("test_lock").should_not be_nil
+    $redis.get("test_lock").should.not.be.nil
   end
 end
 
 describe Redis::Set do
-  before :all do
+  before do
     @set = Redis::Set.new('spec/set')
     @set_1 = Redis::Set.new('spec/set_1')
     @set_2 = Redis::Set.new('spec/set_2')
     @set_3 = Redis::Set.new('spec/set_3')
-  end
-
-  before :each do
     @set.clear
     @set_1.clear
     @set_2.clear
@@ -334,7 +358,7 @@ describe Redis::Set do
   end
 
   it "should handle sets of simple values" do
-    @set.should be_empty
+    @set.should.be.empty
     @set << 'a' << 'a' << 'a'
     @set.should == ['a']
     @set.get.should == ['a']
@@ -364,9 +388,9 @@ describe Redis::Set do
     @set.get.should == ['a','b']
 
     @set << 'c'
-    @set.member?('c').should be_true
-    @set.include?('c').should be_true
-    @set.member?('no').should be_false
+    @set.member?('c').should.be.true
+    @set.include?('c').should.be.true
+    @set.member?('no').should.be.false
     coll = @set.select{|st| st == 'c'}
     coll.should == ['c']
     @set.sort.should == ['a','b','c']
@@ -411,23 +435,23 @@ describe Redis::Set do
   end
 
   it "should support renaming sets" do
-    @set.should be_empty
+    @set.should.be.empty
     @set << 'a' << 'b' << 'a' << 3
     @set.sort.should == ['3','a','b']
     @set.key.should == 'spec/set'
-    @set.rename('spec/set2').should be_true
+    @set.rename('spec/set2')  # can't test result; switched from true to "OK"
     @set.key.should == 'spec/set2'
     old = Redis::Set.new('spec/set')
-    old.should be_empty
+    old.should.be.empty
     old << 'Tuff'
-    @set.renamenx('spec/set').should be_false
-    @set.renamenx(old).should be_false
-    @set.renamenx('spec/foo').should be_true
+    @set.renamenx('spec/set').should.be.false
+    @set.renamenx(old).should.be.false
+    @set.renamenx('spec/foo').should.be.true
     @set.clear
     @set.redis.del('spec/set2')
   end
 
-  after :all do
+  after do
     @set.clear
     @set_1.clear
     @set_2.clear
@@ -436,14 +460,11 @@ describe Redis::Set do
 end
 
 describe Redis::SortedSet do
-  before :all do
+  before do
     @set = Redis::SortedSet.new('spec/zset')
     @set_1 = Redis::SortedSet.new('spec/zset_1')
     @set_2 = Redis::SortedSet.new('spec/zset_2')
     @set_3 = Redis::SortedSet.new('spec/zset_3')
-  end
-
-  before :each do
     @set.clear
     @set_1.clear
     @set_2.clear
@@ -451,15 +472,15 @@ describe Redis::SortedSet do
   end
 
   it "should handle sets of simple values" do
-    @set.should be_empty
+    @set.should.be.empty
     @set['a'] = 11
     @set['a'] = 21
     @set.add('a', 5)
     @set.score('a').should == 5
     @set['a'].should == 5
     @set['a'] = 3
-    @set['b'] = 5
-    @set['b'].should == 5
+    @set['b'] = 5.6
+    @set['b'].should == 5.6
     @set['c'] = 4
 
     @set[0,-1].should == ['a','c','b']
@@ -475,7 +496,7 @@ describe Redis::SortedSet do
     @set.last.should == 'b'
 
     @set.members.should == ['a','c','b']
-    @set.members(:withscores => true).should == [['a',3],['c',4],['b',5]]
+    @set.members(:withscores => true).should == [['a',3],['c',4],['b',5.6]]
 
     @set['b'] = 5
     @set['b'] = 6
@@ -520,8 +541,10 @@ describe Redis::SortedSet do
     @set.size.should == 4
   end
 
+=begin
+
   # Not until Redis 1.3.5 with hashes
-  xit "Redis 1.3.5: should handle set intersections, unions, and diffs" do
+  it "Redis 1.3.5: should handle set intersections, unions, and diffs" do
     @set_1['a'] = 5
     @set_2['b'] = 18
     @set_2['c'] = 12
@@ -569,25 +592,27 @@ describe Redis::SortedSet do
     @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['b']
   end
 
+=end
+
   it "should support renaming sets" do
-    @set.should be_empty
+    @set.should.be.empty
     @set['zynga'] = 151
     @set['playfish'] = 202
     @set.members.should == ['zynga','playfish']
     @set.key.should == 'spec/zset'
-    @set.rename('spec/zset2').should be_true
+    @set.rename('spec/zset2')  # can't test result; switched from true to "OK"
     @set.key.should == 'spec/zset2'
     old = Redis::SortedSet.new('spec/zset')
-    old.should be_empty
+    old.should.be.empty
     old['tuff'] = 54
-    @set.renamenx('spec/zset').should be_false
-    @set.renamenx(old).should be_false
-    @set.renamenx('spec/zfoo').should be_true
+    @set.renamenx('spec/zset').should.be.false
+    @set.renamenx(old).should.be.false
+    @set.renamenx('spec/zfoo').should.be.true
     @set.clear
     @set.redis.del('spec/zset2')
   end
 
-  after :all do
+  after do
     @set.clear
     @set_1.clear
     @set_2.clear

data/spec/redis_objects_model_spec.rb

@@ -34,16 +34,14 @@ class Roster
 end
 
 describe Redis::Objects do
-  before :all do
+  before do
     @roster  = Roster.new
     @roster2 = Roster.new
     
     @roster_1 = Roster.new(1)
     @roster_2 = Roster.new(2)
     @roster_3 = Roster.new(3)
-  end
-  
-  before :each do
+
     @roster.available_slots.reset
     @roster.pitchers.reset
     @roster.basic.reset
@@ -72,13 +70,13 @@ describe Redis::Objects do
 
   it "should provide a connection method" do
     Roster.redis.should == Redis::Objects.redis
-    # Roster.redis.should be_kind_of(Redis)
+    # Roster.redis.should.be.kind_of(Redis)
   end
   
   it "should support custom key names" do
     @roster.player_totals.incr
     @roster.redis.get('players/user1/total').should == '1'
-    @roster.redis.get('players/#{username}/total').should be_nil
+    @roster.redis.get('players/#{username}/total').should.be.nil
     @roster.all_player_stats << 'a'
     @roster.redis.lindex('players:all_stats', 0).should == 'a'
     @roster.total_wins << 'a'
@@ -101,11 +99,11 @@ describe Redis::Objects do
     @roster.available_slots.should == 10
     
     # math proxy ops
-    (@roster.available_slots == 10).should be_true
-    (@roster.available_slots <= 10).should be_true
-    (@roster.available_slots < 11).should be_true
-    (@roster.available_slots > 9).should be_true
-    (@roster.available_slots >= 10).should be_true
+    (@roster.available_slots == 10).should.be.true
+    (@roster.available_slots <= 10).should.be.true
+    (@roster.available_slots < 11).should.be.true
+    (@roster.available_slots > 9).should.be.true
+    (@roster.available_slots >= 10).should.be.true
     "#{@roster.available_slots}".should == "10"
 
     @roster.available_slots.increment.should == 11
@@ -117,9 +115,9 @@ describe Redis::Objects do
     @roster.available_slots.decrement.should == 12
     @roster2.available_slots.decrement(4).should == 8
     @roster.available_slots.should == 8
-    @roster.available_slots.reset.should be_true
+    @roster.available_slots.reset.should.be.true
     @roster.available_slots.should == 10
-    @roster.available_slots.reset(15).should be_true
+    @roster.available_slots.reset(15).should.be.true
     @roster.available_slots.should == 15
     @roster.pitchers.increment.should == 1
     @roster.basic.increment.should == 1
@@ -143,7 +141,7 @@ describe Redis::Objects do
     Roster.total_players_online.decrement.should == 0
     Roster.total_players_online.increment(3).should == 3
     Roster.total_players_online.decrement(2).should == 1
-    Roster.total_players_online.reset.should be_true
+    Roster.total_players_online.reset.should.be.true
     Roster.total_players_online.should == 0
     
     Roster.get_counter(:total_players_online).should == 0
@@ -164,7 +162,7 @@ describe Redis::Objects do
       end
     end
     @roster.available_slots.should == 9
-    a.should be_true
+    a.should.be.true
     
     @roster.available_slots.should == 9
     @roster.available_slots.decr do |cnt|
@@ -224,7 +222,7 @@ describe Redis::Objects do
       end
     end
     Roster.get_counter(:available_slots, @roster.id).should == 9
-    a.should be_true
+    a.should.be.true
 
     Roster.get_counter(:available_slots, @roster.id).should == 9
     Roster.decrement_counter(:available_slots, @roster.id) do |cnt|
@@ -281,48 +279,48 @@ describe Redis::Objects do
       Roster.increment_counter(:badness, 2)
     rescue => error
     end
-    error.should be_kind_of(Redis::Objects::UndefinedCounter)
+    error.should.be.kind_of(Redis::Objects::UndefinedCounter)
 
     error = nil
     begin
       Roster.obtain_lock(:badness, 2){}
     rescue => error
     end
-    error.should be_kind_of(Redis::Objects::UndefinedLock)
+    error.should.be.kind_of(Redis::Objects::UndefinedLock)
 
     error = nil
     begin
       @roster.available_slots = 42
     rescue => error
     end
-    error.should be_kind_of(NoMethodError)
+    error.should.be.kind_of(NoMethodError)
 
     error = nil
     begin
       @roster.available_slots += 69
     rescue => error
     end
-    error.should be_kind_of(NoMethodError)
+    error.should.be.kind_of(NoMethodError)
 
     error = nil
     begin
       @roster.available_slots -= 15
     rescue => error
     end
-    error.should be_kind_of(NoMethodError)
+    error.should.be.kind_of(NoMethodError)
   end
 
   it "should support obtain_lock as a class method" do
     error = nil
     begin
       Roster.obtain_lock(:resort, 2) do
-        Roster.redis.get("roster:2:resort_lock").should_not be_nil
+        Roster.redis.get("roster:2:resort_lock").should.not.be.nil
       end
     rescue => error
     end
 
-    error.should be_nil
-    Roster.redis.get("roster:2:resort_lock").should be_nil
+    error.should.be.nil
+    Roster.redis.get("roster:2:resort_lock").should.be.nil
   end
   
   it "should handle simple values" do
@@ -332,8 +330,8 @@ describe Redis::Objects do
     @roster.starting_pitcher.get.should == 'Trevor Hoffman'
     @roster.starting_pitcher = 'Tom Selleck'
     @roster.starting_pitcher.should == 'Tom Selleck'
-    @roster.starting_pitcher.del.should be_true
-    @roster.starting_pitcher.should be_nil
+    @roster.starting_pitcher.del.should.be.true
+    @roster.starting_pitcher.should.be.nil
   end
 
   it "should handle complex marshaled values" do
@@ -341,12 +339,12 @@ describe Redis::Objects do
     @roster.starting_pitcher = {:json => 'data'}
     @roster.starting_pitcher.should == {:json => 'data'}
     @roster.starting_pitcher.get.should == {:json => 'data'}
-    @roster.starting_pitcher.del.should be_true
-    @roster.starting_pitcher.should be_nil
+    @roster.starting_pitcher.del.should.be.true
+    @roster.starting_pitcher.should.be.nil
   end
 
   it "should handle lists of simple values" do
-    @roster.player_stats.should be_empty
+    @roster.player_stats.should.be.empty
     @roster.player_stats << 'a'
     @roster.player_stats.should == ['a']
     @roster.player_stats.get.should == ['a']
@@ -365,8 +363,8 @@ describe Redis::Objects do
     @roster.player_stats[0].should == 'b'
     @roster.player_stats[2].should == 'c'
     @roster.player_stats[3].should == 'd'
-    @roster.player_stats.include?('c').should be_true
-    @roster.player_stats.include?('no').should be_false
+    @roster.player_stats.include?('c').should.be.true
+    @roster.player_stats.include?('no').should.be.false
     @roster.player_stats.pop.should == 'd'
     @roster.player_stats[0].should == @roster.player_stats.at(0)
     @roster.player_stats[1].should == @roster.player_stats.at(1)
@@ -417,7 +415,7 @@ describe Redis::Objects do
   end
 
   it "should handle sets of simple values" do
-    @roster.outfielders.should be_empty
+    @roster.outfielders.should.be.empty
     @roster.outfielders << 'a' << 'a' << 'a'
     @roster.outfielders.should == ['a']
     @roster.outfielders.get.should == ['a']
@@ -447,9 +445,9 @@ describe Redis::Objects do
     @roster.outfielders.get.should == ['a','b']
 
     @roster.outfielders << 'c'
-    @roster.outfielders.member?('c').should be_true
-    @roster.outfielders.include?('c').should be_true
-    @roster.outfielders.member?('no').should be_false
+    @roster.outfielders.member?('c').should.be.true
+    @roster.outfielders.include?('c').should.be.true
+    @roster.outfielders.member?('no').should.be.false
     coll = @roster.outfielders.select{|st| st == 'c'}
     coll.should == ['c']
     @roster.outfielders.sort.should == ['a','b','c']
@@ -483,7 +481,7 @@ describe Redis::Objects do
   end
 
   it "should handle class-level global lists of simple values" do
-    Roster.all_player_stats.should be_empty
+    Roster.all_player_stats.should.be.empty
     Roster.all_player_stats << 'a'
     Roster.all_player_stats.should == ['a']
     Roster.all_player_stats.get.should == ['a']
@@ -502,8 +500,8 @@ describe Redis::Objects do
     Roster.all_player_stats[0].should == 'b'
     Roster.all_player_stats[2].should == 'c'
     Roster.all_player_stats[3].should == 'd'
-    Roster.all_player_stats.include?('c').should be_true
-    Roster.all_player_stats.include?('no').should be_false
+    Roster.all_player_stats.include?('c').should.be.true
+    Roster.all_player_stats.include?('no').should.be.false
     Roster.all_player_stats.pop.should == 'd'
     Roster.all_player_stats[0].should == Roster.all_player_stats.at(0)
     Roster.all_player_stats[1].should == Roster.all_player_stats.at(1)
@@ -554,7 +552,7 @@ describe Redis::Objects do
   end
 
   it "should handle class-level global sets of simple values" do
-    Roster.all_players_online.should be_empty
+    Roster.all_players_online.should.be.empty
     Roster.all_players_online << 'a' << 'a' << 'a'
     Roster.all_players_online.should == ['a']
     Roster.all_players_online.get.should == ['a']
@@ -584,9 +582,9 @@ describe Redis::Objects do
     Roster.all_players_online.get.should == ['a','b']
 
     Roster.all_players_online << 'c'
-    Roster.all_players_online.member?('c').should be_true
-    Roster.all_players_online.include?('c').should be_true
-    Roster.all_players_online.member?('no').should be_false
+    Roster.all_players_online.member?('c').should.be.true
+    Roster.all_players_online.include?('c').should.be.true
+    Roster.all_players_online.member?('no').should.be.false
     coll = Roster.all_players_online.select{|st| st == 'c'}
     coll.should == ['c']
     Roster.all_players_online.sort.should == ['a','b','c']
@@ -599,12 +597,12 @@ describe Redis::Objects do
     Roster.last_player.get.should == 'Trevor Hoffman'
     Roster.last_player = 'Tom Selleck'
     Roster.last_player.should == 'Tom Selleck'
-    Roster.last_player.del.should be_true
-    Roster.last_player.should be_nil
+    Roster.last_player.del.should.be.true
+    Roster.last_player.should.be.nil
   end
 
   it "should easily enable @object.class.global_objects" do
-    @roster.class.all_players_online.should be_empty
+    @roster.class.all_players_online.should.be.empty
     @roster.class.all_players_online << 'a' << 'a' << 'a'
     @roster.class.all_players_online.should == ['a']
     @roster2.class.all_players_online.should == ['a']
@@ -612,7 +610,7 @@ describe Redis::Objects do
     @roster.all_players_online.should == ['a']
     @roster2.all_players_online.should == ['a']
 
-    @roster.class.all_player_stats.should be_empty
+    @roster.class.all_player_stats.should.be.empty
     @roster.class.all_player_stats << 'a'
     @roster.class.all_player_stats.should == ['a']
     @roster.class.all_player_stats.get.should == ['a']
@@ -633,9 +631,9 @@ describe Redis::Objects do
     @roster2.last_player.get.should == 'Trevor Hoffman'
     @roster2.last_player = 'Tom Selleck'
     @roster.last_player.should == 'Tom Selleck'
-    @roster.last_player.del.should be_true
-    @roster.last_player.should be_nil
-    @roster2.last_player.should be_nil
+    @roster.last_player.del.should.be.true
+    @roster.last_player.should.be.nil
+    @roster2.last_player.should.be.nil
   end
 
   it "should handle lists of complex data types" do
@@ -664,7 +662,7 @@ describe Redis::Objects do
     @roster.resort_lock.lock do
       a = true
     end
-    a.should be_true
+    a.should.be.true
   end
   
   it "should raise an exception if the timeout is exceeded" do
@@ -674,7 +672,7 @@ describe Redis::Objects do
       @roster.resort_lock.lock {}
     rescue => error
     end
-    error.should_not be_nil
-    error.should be_kind_of(Redis::Lock::LockTimeout)
+    error.should.not.be.nil
+    error.should.be.kind_of(Redis::Lock::LockTimeout)
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,10 @@
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'redis'
 
+require 'rubygems'  # poor people still on 1.8
+require 'bacon'
+Bacon.summary_at_exit
+
 $redis = Redis.new(:host => ENV['REDIS_HOST'], :port => ENV['REDIS_PORT'])
 
 UNIONSTORE_KEY = 'test:unionstore'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 1
-  version: 0.3.1
+  - 2
+  version: 0.3.2
 platform: ruby
 authors: 
 - Nate Wiger
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-01 00:00:00 -07:00
+date: 2010-07-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,6 +40,7 @@ extensions: []
 extra_rdoc_files: 
 - ATOMICITY.rdoc
 - CHANGELOG.rdoc
+- Rakefile
 - README.rdoc
 files: 
 - lib/redis/counter.rb
@@ -62,6 +63,7 @@ files:
 - spec/spec_helper.rb
 - ATOMICITY.rdoc
 - CHANGELOG.rdoc
+- Rakefile
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/nateware/redis-objects