redis-objects 0.2.2 → 0.3.0

data/lib/redis/objects/sorted_sets.rb

@@ -0,0 +1,45 @@
+# This is the class loader, for use as "include Redis::Objects::Sets"
+# For the object itself, see "Redis::Set"
+require 'redis/sorted_set'
+class Redis
+  module Objects
+    module SortedSets
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # 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)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+          
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects.rb

@@ -6,7 +6,7 @@ class Redis
   # Redis::Objects enables high-performance atomic operations in your app
   # by leveraging the atomic features of the Redis server.  To use Redis::Objects,
   # first include it in any class you want.  (This example uses an ActiveRecord
-  # subclass, but that is *not* required.) Then, use +counter+ and +lock+
+  # subclass, but that is *not* required.) Then, use +counter+, +lock+, +set+, etc
   # to define your primitives:
   #
   #   class Game < ActiveRecord::Base
@@ -14,8 +14,8 @@ class Redis
   #
   #     counter :joined_players
   #     counter :active_players
-  #     set :player_ids
   #     lock :archive_game
+  #     set :player_ids
   #   end
   # 
   # The, you can use these counters both for bookeeping and as atomic actions:
@@ -39,10 +39,11 @@ class Redis
     dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
 
     autoload :Counters, File.join(dir, 'counters')
-    autoload :Values, File.join(dir, 'values')
     autoload :Lists, File.join(dir, 'lists')
-    autoload :Sets, File.join(dir, 'sets')
     autoload :Locks, File.join(dir, 'locks')
+    autoload :Sets, File.join(dir, 'sets')
+    autoload :SortedSets, File.join(dir, 'sorted_sets')
+    autoload :Values, File.join(dir, 'values')
 
     class NotConnected  < StandardError; end
 
@@ -61,10 +62,11 @@ class Redis
         
         # Pull in each object type
         klass.send :include, Redis::Objects::Counters
-        klass.send :include, Redis::Objects::Values
         klass.send :include, Redis::Objects::Lists
-        klass.send :include, Redis::Objects::Sets
         klass.send :include, Redis::Objects::Locks
+        klass.send :include, Redis::Objects::Sets
+        klass.send :include, Redis::Objects::SortedSets
+        klass.send :include, Redis::Objects::Values
       end
     end
 

data/lib/redis/set.rb

@@ -13,10 +13,10 @@ class Redis
     attr_reader :key, :options, :redis
     
     # Create a new Set.
-    def initialize(key, redis=$redis, options={})
+    def initialize(key, *args)
       @key = key
-      @redis = redis
-      @options = options
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+      @redis = args.first || $redis
     end
 
     # Works like add.  Can chain together: list << 'a' << 'b'

data/lib/redis/sorted_set.rb

@@ -0,0 +1,275 @@
+class Redis
+  #
+  # Class representing a sorted set.
+  #
+  class SortedSet
+    # require 'enumerator'
+    # include Enumerable
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+    require 'redis/helpers/serialize'
+    include Redis::Helpers::Serialize
+
+    attr_reader :key, :options, :redis
+    
+    # Create a new SortedSet.
+    def initialize(key, *args)
+      @key = key
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+      @redis = args.first || $redis
+    end
+
+    # How to add values using a sorted set.  The key is the member, eg,
+    # "Peter", and the value is the score, eg, 163.  So:
+    #    num_posts['Peter'] = 163 
+    def []=(member, score)
+      add(member, score)
+    end
+
+    # Add a member and its corresponding value to Redis.  Note that the
+    # arguments to this are flipped; the member comes first rather than
+    # the score, since the member is the unique item (not the score).
+    def add(member, score)
+      redis.zadd(key, score, to_redis(member))
+    end
+
+    # Same functionality as Ruby arrays.  If a single number is given, return
+    # just the element at that index using Redis: ZRANGE. Otherwise, return
+    # a range of values using Redis: ZRANGE.
+    def [](index, length=nil)
+      if index.is_a? Range
+        range(index.first, index.last)
+      elsif length
+        range(index, length)
+      else
+        score(index)
+      end
+    end
+
+    # Return the score of the specified element of the sorted set at key. If the
+    # 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
+    end
+
+    # Return the rank of the member in the sorted set, with scores ordered from
+    # low to high. +revrank+ returns the rank with scores ordered from high to low.
+    # When the given member does not exist in the sorted set, nil is returned.
+    # The returned rank (or index) of the member is 0-based for both commands
+    def rank(member)
+      redis.zrank(key, to_redis(member)).to_i
+    end
+
+    def revrank(member)
+      redis.zrevrank(key, to_redis(member)).to_i
+    end
+
+    # Return all members of the sorted set with their scores.  Extremely CPU-intensive.
+    # Better to use a range instead.
+    def members(options={})
+      range(0, -1, options)
+    end
+
+    # Return a range of values from +start_index+ to +end_index+.  Can also use
+    # the familiar list[start,end] Ruby syntax. Redis: ZRANGE
+    def range(start_index, end_index, options={})
+      if options[:withscores]
+        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]
+        end
+        ret
+      else
+        from_redis redis.zrange(key, start_index, end_index)
+      end
+    end
+
+    # Return a range of values from +start_index+ to +end_index+ in reverse order. Redis: ZREVRANGE
+    def revrange(start_index, end_index, options={})
+      if options[:withscores]
+        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]
+        end
+        ret
+      else
+        from_redis redis.zrevrange(key, start_index, end_index)
+      end
+    end
+
+    # Return the all the elements in the sorted set at key with a score between min and max
+    # (including elements with score equal to min or max).  Options:
+    #     :count, :offset - passed to LIMIT
+    #     :withscores     - if true, scores are returned as well
+    # Redis: ZRANGEBYSCORE
+    def rangebyscore(min, max, options={})
+      args = []
+      args += ['limit', options[:offset] || 0, options[:limit] || options[:count]] if
+                options[:offset] || options[:limit] || options[:count]
+      args += ['withscores'] if options[:withscores]
+      from_redis redis.zrangebyscore(key, min, max, *args)
+    end
+
+    # Forwards compat (not yet implemented in Redis)
+    def revrangebyscore(min, max, options={})
+      args = []
+      args += ['limit', options[:offset] || 0, options[:limit] || options[:count]] if
+                options[:offset] || options[:limit] || options[:count]
+      args += ['withscores'] if options[:withscores]
+      from_redis redis.zrevrangebyscore(key, min, max, *args)
+    end
+
+    # Remove all elements in the sorted set at key with rank between start and end. Start and end are
+    # 0-based with rank 0 being the element with the lowest score. Both start and end can be negative
+    # numbers, where they indicate offsets starting at the element with the highest rank. For example:
+    # -1 is the element with the highest score, -2 the element with the second highest score and so forth. 
+    # Redis: ZREMRANGEBYRANK
+    def remrangebyrank(min, max)
+      redis.zremrangebyrank(key, min, max)
+    end
+
+    # Remove all the elements in the sorted set at key with a score between min and max (including
+    # elements with score equal to min or max). Redis: ZREMRANGEBYSCORE
+    def remrangebyscore(min, max)
+      redis.zremrangebyscore(key, min, max)
+    end
+
+    # Delete the value from the set.  Redis: ZREM
+    def delete(value)
+      redis.zrem(key, value)
+    end
+
+    # Increment the rank of that member atomically and return the new value. This
+    # method is aliased as incr() for brevity. Redis: ZINCRBY
+    def increment(member, by=1)
+      redis.zincrby(key, by, member).to_i
+    end
+    alias_method :incr, :increment
+    alias_method :incrby, :increment
+
+    # Convenience to calling increment() with a negative number. 
+    def decrement(by=1)
+      redis.zincrby(key, -by).to_i
+    end
+    alias_method :decr, :decrement
+    alias_method :decrby, :decrement
+
+    # Return the intersection with another set.  Can pass it either another set
+    # object or set name.  Also available as & which is a bit cleaner:
+    #
+    #    members_in_both = set1 & set2
+    #
+    # If you want to specify multiple sets, you must use +intersection+:
+    #
+    #    members_in_all = set1.intersection(set2, set3, set4)
+    #    members_in_all = set1.inter(set2, set3, set4)  # alias
+    #
+    # Redis: SINTER
+    def intersection(*sets)
+      from_redis redis.zinter(key, *keys_from_objects(sets))
+    end
+    alias_method :intersect, :intersection
+    alias_method :inter, :intersection
+    alias_method :&, :intersection
+    
+    # Calculate the intersection and store it in Redis as +name+. Returns the number
+    # of elements in the stored intersection. Redis: SUNIONSTORE
+    def interstore(name, *sets)
+      redis.zinterstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Return the union with another set.  Can pass it either another set
+    # object or set name. Also available as | and + which are a bit cleaner:
+    #
+    #    members_in_either = set1 | set2
+    #    members_in_either = set1 + set2
+    #
+    # If you want to specify multiple sets, you must use +union+:
+    #
+    #    members_in_all = set1.union(set2, set3, set4)
+    #
+    # Redis: SUNION
+    def union(*sets)
+      from_redis redis.zunion(key, *keys_from_objects(sets))
+    end
+    alias_method :|, :union
+    alias_method :+, :union
+
+    # Calculate the union and store it in Redis as +name+. Returns the number
+    # of elements in the stored union. Redis: SUNIONSTORE
+    def unionstore(name, *sets)
+      redis.zunionstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Return the difference vs another set.  Can pass it either another set
+    # object or set name. Also available as ^ or - which is a bit cleaner:
+    #
+    #    members_difference = set1 ^ set2
+    #    members_difference = set1 - set2
+    #
+    # If you want to specify multiple sets, you must use +difference+:
+    #
+    #    members_difference = set1.difference(set2, set3, set4)
+    #    members_difference = set1.diff(set2, set3, set4)
+    #
+    # Redis: SDIFF
+    def difference(*sets)
+      from_redis redis.zdiff(key, *keys_from_objects(sets))
+    end
+    alias_method :diff, :difference
+    alias_method :^, :difference
+    alias_method :-, :difference
+
+    # Calculate the diff and store it in Redis as +name+. Returns the number
+    # of elements in the stored union. Redis: SDIFFSTORE
+    def diffstore(name, *sets)
+      redis.zdiffstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Returns true if the set has no members. Redis: SCARD == 0
+    def empty?
+      length == 0
+    end
+
+    def ==(x)
+      members == x
+    end
+    
+    def to_s
+      members.join(', ')
+    end
+
+    # Return the value at the given index. Can also use familiar list[index] syntax.
+    # Redis: ZRANGE
+    def at(index)
+      range(index, index).first
+    end
+
+    # Return the first element in the list. Redis: ZRANGE(0)
+    def first
+      at(0)
+    end
+
+    # Return the last element in the list. Redis: ZRANGE(-1)
+    def last
+      at(-1)
+    end
+    
+    # The number of members in the set. Aliased as size. Redis: ZCARD
+    def length
+      redis.zcard(key)
+    end
+    alias_method :size, :length
+
+    private
+    
+    def keys_from_objects(sets)
+      raise ArgumentError, "Must pass in one or more set names" if sets.empty?
+      sets.collect{|set| set.is_a?(Redis::SortedSet) ? set.key : set}
+    end
+    
+  end
+end

data/lib/redis/value.rb

@@ -9,10 +9,10 @@ class Redis
     include Redis::Helpers::Serialize
 
     attr_reader :key, :options, :redis
-    def initialize(key, redis=$redis, options={})
+    def initialize(key, *args)
       @key = key
-      @redis = redis
-      @options = options
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+      @redis = args.first || $redis
       @redis.setnx(key, @options[:default]) if @options[:default]
     end