redis-objects 0.3.0 → 0.3.1

data/CHANGELOG.rdoc

@@ -1,13 +1,14 @@
 = Changelog for Redis::Objects
 
+== 0.3.1 [Final] (1 June 2010)
+
+* Integrated fixes for sorted_set deletions from capotej (Julio Capote)
+
 == 0.3.0 [Final] (14 April 2010)
 
-* Due to Ruby 1.9 bugs and performance considerations, marshaling of
-data types is now OFF by default.  You must say :marshal => true for
-any objects that you want serialization enabled on. [Nate Wiger]
+* Due to Ruby 1.9 bugs and performance considerations, marshaling of data types is now OFF by default.  You must say :marshal => true for any objects that you want serialization enabled on. [Nate Wiger]
 
-* Sorted Set class changed slightly due to feedback. You can now get
-an individual element back via @set['item'] since it acts like a Hash.
+* Sorted Set class changed slightly due to feedback. You can now get an individual element back via @set['item'] since it acts like a Hash.
 
 == 0.2.4 [Final] (9 April 2010)*
 

data/lib/redis/objects.rb

@@ -13,7 +13,7 @@ class Redis
   #     include Redis::Objects
   #
   #     counter :joined_players
-  #     counter :active_players
+  #     counter :active_players, :key => 'game:#{id}:act_plyr'
   #     lock :archive_game
   #     set :player_ids
   #   end
@@ -83,18 +83,24 @@ class Redis
           gsub(/([a-z\d])([A-Z])/,'\1_\2').
           downcase
       end
-      
-      def field_key(name, id) #:nodoc:
-        "#{prefix}:#{id}:#{name}"
-      end
 
+      def field_key(name, id='') #:nodoc:
+        # This can never ever ever ever change or upgrades will corrupt all data
+        @redis_objects[name.to_sym][:key] || "#{prefix}:#{id}:#{name}"
+      end
     end
 
     # Instance methods that appear in your class when you include Redis::Objects.
     module InstanceMethods
       def redis() self.class.redis end
       def field_key(name) #:nodoc:
-        self.class.field_key(name, id)
+        # This can never ever ever ever change or upgrades will corrupt all data
+        if key = self.class.redis_objects[name.to_sym][:key]
+          eval "%(#{key})"
+        else
+          # don't try to refactor into class field_key because fucks up eval context
+          "#{self.class.prefix}:#{id}:#{name}"
+        end
       end
     end
   end

data/lib/redis/objects/counters.rb

@@ -22,11 +22,11 @@ class Redis
         def counter(name, options={})
           options[:start] ||= 0
           options[:type]  ||= options[:start] == 0 ? :increment : :decrement
-          @redis_objects[name] = options.merge(:type => :counter)
+          @redis_objects[name.to_sym] = options.merge(:type => :counter)
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Counter.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods

data/lib/redis/objects/lists.rb

@@ -14,11 +14,11 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def list(name, options={})
-          @redis_objects[name] = options.merge(:type => :list)
+          @redis_objects[name.to_sym] = options.merge(:type => :list)
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::List.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::List.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods

data/lib/redis/objects/locks.rb

@@ -16,22 +16,23 @@ class Redis
         # so it can be used alongside ActiveRecord/DataMapper, etc.
         def lock(name, options={})
           options[:timeout] ||= 5  # seconds
-          @redis_objects[name] = options.merge(:type => :lock)
+          lock_name = "#{name}_lock"
+          @redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
           if options[:global]
             instance_eval <<-EndMethods
-              def #{name}_lock(&block)
-                @#{name} ||= Redis::Lock.new(field_key(:#{name}_lock, ''), redis, @redis_objects[:#{name}])
+              def #{lock_name}(&block)
+                @#{lock_name} ||= Redis::Lock.new(field_key(:#{lock_name}), redis, @redis_objects[:#{lock_name}])
               end
             EndMethods
             class_eval <<-EndMethods
-              def #{name}_lock(&block)
-                self.class.#{name}(block)
+              def #{lock_name}(&block)
+                self.class.#{lock_name}(block)
               end
             EndMethods
           else
             class_eval <<-EndMethods
-              def #{name}_lock(&block)
-                @#{name} ||= Redis::Lock.new(field_key(:#{name}_lock), redis, self.class.redis_objects[:#{name}])
+              def #{lock_name}(&block)
+                @#{lock_name} ||= Redis::Lock.new(field_key(:#{lock_name}), redis, self.class.redis_objects[:#{lock_name}])
               end
             EndMethods
           end
@@ -43,22 +44,23 @@ class Redis
         def obtain_lock(name, id, &block)
           verify_lock_defined!(name)
           raise ArgumentError, "Missing block to #{self.name}.obtain_lock" unless block_given?
-          lock_name = field_key("#{name}_lock", id)
-          Redis::Lock.new(lock_name, redis, self.redis_objects[name]).lock(&block)
+          lock_name = "#{name}_lock"
+          Redis::Lock.new(field_key(lock_name, id), redis, @redis_objects[lock_name.to_sym]).lock(&block)
         end
 
         # Clear the lock.  Use with care - usually only in an Admin page to clear
         # stale locks (a stale lock should only happen if a server crashes.)
         def clear_lock(name, id)
           verify_lock_defined!(name)
-          lock_name = field_key("#{name}_lock", id)
-          redis.del(lock_name)
+          redis.del(field_key("#{name}_lock", id))
         end
-        
+
         private
         
         def verify_lock_defined!(name)
-          raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}" unless @redis_objects.has_key?(name)
+          unless @redis_objects.has_key?("#{name}_lock".to_sym)
+            raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}"
+          end
         end
       end
     end

data/lib/redis/objects/sets.rb

@@ -14,11 +14,11 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def set(name, options={})
-          @redis_objects[name] = options.merge(:type => :set)
+          @redis_objects[name.to_sym] = options.merge(:type => :set)
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Set.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods

data/lib/redis/objects/sorted_sets.rb

@@ -14,11 +14,11 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def sorted_set(name, options={})
-          @redis_objects[name] = options.merge(:type => :sorted_set)
+          @redis_objects[name.to_sym] = options.merge(:type => :sorted_set)
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -33,7 +33,6 @@ class Redis
               end
             EndMethods
           end
-          
         end
       end
 

data/lib/redis/objects/values.rb

@@ -14,11 +14,11 @@ class Redis
         # Define a new simple value.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def value(name, options={})
-          @redis_objects[name] = options.merge(:type => :value)
+          @redis_objects[name.to_sym] = options.merge(:type => :value)
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Value.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
               end
               def #{name}=(value)
                 #{name}.value = value

data/lib/redis/set.rb

@@ -42,12 +42,23 @@ class Redis
       redis.sismember(key, to_redis(value))
     end
     alias_method :include?, :member?
-
+    
     # Delete the value from the set.  Redis: SREM
     def delete(value)
-      redis.srem(key, value)
+      redis.srem(key, to_redis(value))
     end
-
+    
+    # Delete if matches block
+    def delete_if(&blk)
+      res = false
+      redis.smembers(key).each do |m|
+        if blk.call(from_redis(m))
+          res = redis.srem(key, m)
+        end
+      end
+      res
+    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)
@@ -131,6 +142,7 @@ class Redis
       redis.scard(key)
     end
     alias_method :size, :length
+    alias_method :count, :length
 
     # Returns true if the set has no members. Redis: SCARD == 0
     def empty?
@@ -153,4 +165,4 @@ class Redis
     end
     
   end
-end
+end

data/lib/redis/sorted_set.rb

@@ -14,7 +14,7 @@ class Redis
     
     # Create a new SortedSet.
     def initialize(key, *args)
-      @key = key
+      @key = key.is_a?(Array) ? key.flatten.join(':') : key
       @options = args.last.is_a?(Hash) ? args.pop : {}
       @redis = args.first || $redis
     end

data/spec/redis_objects_model_spec.rb

@@ -19,9 +19,17 @@ class Roster
   list :all_player_stats, :global => true
   set :all_players_online, :global => true
   value :last_player, :global => true
+  
+  # custom keys
+  counter :player_totals, :key => 'players/#{username}/total'
+  list :all_player_stats, :key => 'players:all_stats'
+  set :total_wins, :key => 'players:#{id}:all_stats'
+  value :my_rank, :key => 'players:my_rank:#{username}'
+  value :weird_key, :key => 'players:weird_key:#{raise}', :global => true
 
   def initialize(id=1) @id = id end
   def id; @id; end
+  def username; "user#{id}"; end
   def max_pitchers; 3; end
 end
 
@@ -49,17 +57,38 @@ describe Redis::Objects do
     @roster.redis.del(UNIONSTORE_KEY)
     @roster.redis.del(INTERSTORE_KEY)
     @roster.redis.del(DIFFSTORE_KEY)
-    
+
     Roster.total_players_online.reset
     Roster.all_player_stats.clear
     Roster.all_players_online.clear
     Roster.last_player.delete
+    Roster.weird_key.clear
+    
+    @roster.player_totals.clear
+    @roster.all_player_stats.clear
+    @roster.total_wins.clear
+    @roster.my_rank.clear
   end
 
   it "should provide a connection method" do
     Roster.redis.should == Redis::Objects.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.all_player_stats << 'a'
+    @roster.redis.lindex('players:all_stats', 0).should == 'a'
+    @roster.total_wins << 'a'
+    @roster.redis.smembers('players:1:all_stats').should == ['a']
+    @roster.redis.smembers('players:#{id}:all_stats').should == []
+    @roster.my_rank = 'a'
+    @roster.redis.get('players:my_rank:user1').should == 'a'
+    Roster.weird_key = 'tuka'
+    Roster.redis.get('players:weird_key:#{raise}').should == 'tuka'
+  end
 
   it "should create counter accessors" do
     [:available_slots, :pitchers, :basic].each do |m|
@@ -648,5 +677,4 @@ describe Redis::Objects do
     error.should_not be_nil
     error.should be_kind_of(Redis::Lock::LockTimeout)
   end
-
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Nate Wiger
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-14 00:00:00 -07:00
+date: 2010-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency