redis-objects 0.1.1 → 0.1.2

data/README.rdoc

@@ -1,4 +1,4 @@
-= Redis::Objects - Lightweight, atomic object layer around redis-rb
+= Redis::Objects - Map Redis types directly to Ruby objects
 
 This is *not* an ORM.  People that are wrapping ORM's around Redis are missing
 the point.
@@ -53,22 +53,21 @@ Familiar Ruby array operations Just Work (TM):
     @team.on_base << 'player1'
     @team.on_base << 'player2'
     @team.on_base << 'player3'
-    puts @team.on_base    # ['player1', 'player2']
+    @team.on_base    # ['player1', 'player2']
     @team.on_base.pop
     @team.on_base.shift
     @team.on_base.length  # 1
     @team.on_base.delete('player3')
-    
+
 Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
     
-    @team.outfielders['1b'] = 'outfielder1'
-    @team.outfielders['lf'] = 'outfielder3'
-    @team.outfielders['lf'] = 'outfielder2'
-    @team.outfielders.keys
-    @team.outfielders.each do |position,player|
-      puts "#{player} is playing #{position}"
+    @team.outfielders << 'outfielder1' << 'outfielder1'
+    @team.outfielders << 'outfielder2'
+    @team.outfielders  # ['outfielder1', 'outfielder2']
+    @team.outfielders.each do |player|
+      puts player
     end
-    position = @team.outfielders.detect{|pos,of| of == 'outfielder3'}
+    player = @team.outfielders.detect{|of| of == 'outfielder2'}
 
 Note counters cannot be assigned to, only incremented/decremented:
 
@@ -101,15 +100,48 @@ Or can pass the handle into the new method:
     @counter = Redis::Counter.new('counter_name')
     @counter.increment
     @counter.decrement
-    puts @counter
-    puts @counter.get  # force re-fetch
+    puts @counter.value
+    @counter.increment do |val|
+      raise "Full" if val > MAX_VAL  # rewind counter
+    end
+
+See the section on "Atomicity" for cool uses of atomic counter blocks.
 
 === Lists
 
+These work just like Ruby arrays:
+
     @list = Redis::List.new('list_name')
     @list << 'a'
     @list << 'b'
-    puts @list
+    @list.include? 'c'   # false
+    @list.values  # ['a','b']
+    @list.shift
+    @list.pop
+    @list.clear
+    # etc
+
+=== Sets
+
+Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
+
+    @set = Redis::Set.new('set_name')
+    @set << 'a'
+    @set << 'b'
+    @set << 'a'
+    @set.member? 'c'   # false
+    @set.members  # ['a','b']
+    @set.each do |member|
+      puts member
+    end
+    @set.clear
+    # etc
+
+=== Values
+
+    @value = Redis::Value.new('value_name')
+    @value.value = 'a'
+    @value.delete
 
 == Atomicity
 

data/lib/redis/list.rb

@@ -59,37 +59,54 @@ class Redis
       end
     end
     
+    # Delete the element(s) from the list that match name. If count is specified,
+    # only the first-N (if positive) or last-N (if negative) will be removed.
+    # Redis: LREM
     def delete(name, count=0)
       redis.lrem(key, count, name)  # weird api
       get
     end
 
+    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
     def each(&block)
       values.each(&block)
     end
 
+    # Return a range of values from +start_index+ to +end_index+.  Can also use
+    # the familiar list[start,end] Ruby syntax. Redis: LRANGE
     def range(start_index, end_index)
       redis.lrange(key, start_index, end_index)
     end
 
-    # Return the value at the given index.
+    # Return the value at the given index. Can also use familiar list[index] syntax.
+    # Redis: LINDEX
     def at(index)
       redis.lindex(key, index)
     end
 
+    # Return the first element in the list. Redis: LINDEX(0)
+    def first
+      at(0)
+    end
+
+    # Return the last element in the list. Redis: LINDEX(-1)
     def last
-      redis.lrange(key, -1, -1)
+      at(-1)
     end
 
+    # Clear the list entirely. Redis: DEL
     def clear
       redis.del(key)
     end
 
+    # Return the length of the list. Aliased as size. Redis: LLEN
     def length
       redis.llen(key)
     end
     alias_method :size, :length
-    
+   
+    # Returns true if there are no elements in the list. Redis: LLEN == 0
     def empty?
       length == 0
     end

data/lib/redis/set.rb

@@ -35,6 +35,7 @@ class Redis
     def member?(value)
       redis.sismember(key, value)
     end
+    alias_method :include?, :member?
 
     # Delete the value from the set.  Redis: SREM
     def delete(name)

data/spec/redis_objects_model_spec.rb

@@ -264,12 +264,16 @@ describe Redis::Objects do
     @roster.player_stats.push 'c'
     @roster.player_stats.should == ['b','a','c']
     @roster.player_stats.get.should == ['b','a','c']
+    @roster.player_stats.first.should == 'b'
+    @roster.player_stats.last.should == 'c'
     @roster.player_stats << 'd'
     @roster.player_stats.should == ['b','a','c','d']
     @roster.player_stats[1].should == 'a'
     @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.pop
     @roster.player_stats[0].should == @roster.player_stats.at(0)
     @roster.player_stats[1].should == @roster.player_stats.at(1)
@@ -350,7 +354,9 @@ describe Redis::Objects do
     @roster.outfielders.get.should == ['a','b']
 
     @roster.outfielders << 'c'
-    @roster.outfielders.member? 'c'
+    @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']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: redis-objects
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Nate Wiger