redis-objects-legacy 1.6.0

data/lib/redis/objects.rb

@@ -0,0 +1,199 @@
+# Redis::Objects - Lightweight object layer around redis-rb
+# See README.rdoc for usage and approach.
+require 'redis'
+require 'redis/objects/connection_pool_proxy'
+
+class Redis
+  autoload :Counter,   'redis/counter'
+  autoload :List,      'redis/list'
+  autoload :Lock,      'redis/lock'
+  autoload :Set,       'redis/set'
+  autoload :SortedSet, 'redis/sorted_set'
+  autoload :Value,     'redis/value'
+  autoload :HashKey,   'redis/hash_key'
+
+  #
+  # 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+, +lock+, +set+, etc
+  # to define your primitives:
+  #
+  #   class Game < ActiveRecord::Base
+  #     include Redis::Objects
+  #
+  #     counter :joined_players
+  #     counter :active_players, :key => 'game:#{id}:act_plyr'
+  #     lock :archive_game
+  #     set :player_ids
+  #   end
+  #
+  # The, you can use these counters both for bookkeeping and as atomic actions:
+  #
+  #   @game = Game.find(id)
+  #   @game_user = @game.joined_players.increment do |val|
+  #     break if val > @game.max_players
+  #     gu = @game.game_users.create!(:user_id => @user.id)
+  #     @game.active_players.increment
+  #     gu
+  #   end
+  #   if @game_user.nil?
+  #     # game is full - error screen
+  #   else
+  #     # success
+  #   end
+  #
+  #
+  #
+  module Objects
+    autoload :Counters,   'redis/objects/counters'
+    autoload :Lists,      'redis/objects/lists'
+    autoload :Locks,      'redis/objects/locks'
+    autoload :Sets,       'redis/objects/sets'
+    autoload :SortedSets, 'redis/objects/sorted_sets'
+    autoload :Values,     'redis/objects/values'
+    autoload :Hashes,     'redis/objects/hashes'
+
+    class NotConnected < StandardError; end
+    class NilObjectId  < StandardError; end
+
+    class << self
+      def redis=(conn)
+        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+      end
+      def redis
+        @redis || $redis || Redis.current ||
+          raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
+      end
+
+      def included(klass)
+        # Core (this file)
+        klass.instance_variable_set(:@redis, nil)
+        klass.instance_variable_set(:@redis_objects, {})
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+
+        # Pull in each object type
+        klass.send :include, Redis::Objects::Counters
+        klass.send :include, Redis::Objects::Lists
+        klass.send :include, Redis::Objects::Locks
+        klass.send :include, Redis::Objects::Sets
+        klass.send :include, Redis::Objects::SortedSets
+        klass.send :include, Redis::Objects::Values
+        klass.send :include, Redis::Objects::Hashes
+      end
+    end
+
+    # Class methods that appear in your class when you include Redis::Objects.
+    module ClassMethods
+      # Enable per-class connections (eg, User and Post can use diff redis-server)
+      def redis=(conn)
+        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+      end
+
+      def redis
+        @redis || Objects.redis
+      end
+
+      # Internal list of objects
+      attr_writer :redis_objects
+      def redis_objects
+        @redis_objects ||= {}
+      end
+
+      # Set the Redis redis_prefix to use. Defaults to model_name
+      def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end
+      def redis_prefix(klass = self) #:nodoc:
+        @redis_prefix ||= klass.name.to_s.
+          sub(%r{(.*::)}, '').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      end
+
+      def redis_options(name)
+        klass = first_ancestor_with(name)
+        return klass.redis_objects[name.to_sym] || {}
+      end
+
+      def redis_field_redis(name) #:nodoc:
+        klass = first_ancestor_with(name)
+        override_redis = klass.redis_objects[name.to_sym][:redis]
+        if override_redis
+          Objects::ConnectionPoolProxy.proxy_if_needed(override_redis)
+        else
+          self.redis
+        end
+      end
+
+      def redis_field_key(name, id=nil, context=self) #:nodoc:
+        klass = first_ancestor_with(name)
+        # READ THIS: This can never ever ever ever change or upgrades will corrupt all data
+        # I don't think people were using Proc as keys before (that would create a weird key). Should be ok
+        if key = klass.redis_objects[name.to_sym][:key]
+          if key.respond_to?(:call)
+            key = key.call context
+          else
+            context.instance_eval "%(#{key})"
+          end
+        else
+          if id.nil? and !klass.redis_objects[name.to_sym][:global]
+            raise NilObjectId,
+              "[#{klass.redis_objects[name.to_sym]}] Attempt to address redis-object " +
+              ":#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+          end
+          "#{redis_prefix(klass)}:#{id}:#{name}"
+        end
+      end
+
+      def first_ancestor_with(name)
+        if redis_objects && redis_objects.key?(name.to_sym)
+          self
+        elsif superclass && superclass.respond_to?(:redis_objects)
+          superclass.first_ancestor_with(name)
+        end
+      end
+
+      def redis_id_field(id=nil)
+        @redis_id_field = id || @redis_id_field
+
+        if superclass && superclass.respond_to?(:redis_id_field)
+          @redis_id_field ||= superclass.redis_id_field
+        end
+
+        @redis_id_field ||= :id
+      end
+    end
+
+    # Instance methods that appear in your class when you include Redis::Objects.
+    module InstanceMethods
+      # Map up one level to make modular extend/include approach sane
+      def redis()         self.class.redis end
+      def redis_objects() self.class.redis_objects end
+
+      def redis_delete_objects
+        redis.del(redis_instance_keys)
+      end
+
+      def redis_instance_keys
+        redis_objects
+          .reject { |_, value| value[:global] }
+          .keys
+          .collect { |name| redis_field_key(name) }
+      end
+
+      def redis_options(name) #:nodoc:
+        return self.class.redis_options(name)
+      end
+
+      def redis_field_redis(name) #:nodoc:
+        return self.class.redis_field_redis(name)
+      end
+
+      def redis_field_key(name) #:nodoc:
+        id = send(self.class.redis_id_field)
+        self.class.redis_field_key(name, id, self)
+      end
+    end
+  end
+end

data/lib/redis/set.rb

@@ -0,0 +1,182 @@
+require File.dirname(__FILE__) + '/enumerable_object'
+
+class Redis
+  #
+  # Class representing a set.
+  #
+  class Set < EnumerableObject
+    # Works like add.  Can chain together: list << 'a' << 'b'
+    def <<(value)
+      add(value)
+      self  # for << 'a' << 'b'
+    end
+
+    # Add the specified value to the set only if it does not exist already.
+    # Redis: SADD
+    def add(value)
+      allow_expiration do
+        redis.sadd(key, marshal(value)) if value.nil? || !Array(value).empty?
+      end
+    end
+
+    # Remove and return a random member.  Redis: SPOP
+    def pop(count = nil)
+      unmarshal redis.spop(key, count)
+    end
+
+    # return a random member.  Redis: SRANDMEMBER
+    def randmember(count = nil)
+      unmarshal redis.srandmember(key, count)
+    end
+
+    # Adds the specified values to the set. Only works on redis > 2.4
+    # Redis: SADD
+    def merge(*values)
+      allow_expiration do
+        redis.sadd(key, values.flatten.map{|v| marshal(v)})
+      end
+    end
+
+    # Return all members in the set.  Redis: SMEMBERS
+    def members
+      vals = redis.smembers(key)
+      vals.nil? ? [] : vals.map{|v| unmarshal(v) }
+    end
+    alias_method :get, :members
+    alias_method :value, :members
+
+    # Returns true if the specified value is in the set.  Redis: SISMEMBER
+    def member?(value)
+      redis.sismember(key, marshal(value))
+    end
+    alias_method :include?, :member?
+
+    # Delete the value from the set.  Redis: SREM
+    def delete(value)
+      redis.srem(key, marshal(value))
+    end
+
+    # Delete if matches block
+    def delete_if(&block)
+      res = false
+      redis.smembers(key).each do |m|
+        if block.call(unmarshal(m))
+          res = redis.srem(key, m)
+        end
+      end
+      res
+    end
+
+    # 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)
+      redis.sinter(key, *keys_from_objects(sets)).map{|v| unmarshal(v)}
+    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.sinterstore(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)
+      redis.sunion(key, *keys_from_objects(sets)).map{|v| unmarshal(v)}
+    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.sunionstore(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)
+      redis.sdiff(key, *keys_from_objects(sets)).map{|v| unmarshal(v)}
+    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.sdiffstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Moves value from one set to another. Destination can be a String
+    # or Redis::Set.
+    #
+    #   set.move(value, "name_of_key_in_redis")
+    #   set.move(value, set2)
+    #
+    # Returns true if moved successfully.
+    #
+    # Redis: SMOVE
+    def move(value, destination)
+      redis.smove(key, destination.is_a?(Redis::Set) ? destination.key : destination.to_s, value)
+    end
+
+    # The number of members in the set. Aliased as size or count. Redis: SCARD
+    def length
+      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?
+      length == 0
+    end
+
+    def ==(x)
+      members == x
+    end
+
+    def to_s
+      members.join(', ')
+    end
+
+    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::Set) ? set.key : set}
+    end
+  end
+end

data/lib/redis/sorted_set.rb

@@ -0,0 +1,325 @@
+require File.dirname(__FILE__) + '/enumerable_object'
+
+class Redis
+  #
+  # Class representing a sorted set.
+  #
+  class SortedSet < EnumerableObject
+    # 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)
+      allow_expiration do
+        redis.zadd(key, score, marshal(member))
+      end
+    end
+
+    # Add a list of members and their corresponding value (or a hash mapping
+    # values to scores) 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 merge(values)
+      allow_expiration do
+        vals = values.map{|v,s| [s, marshal(v)] }
+        redis.zadd(key, vals)
+      end
+    end
+    alias_method :add_all, :merge
+
+    # 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.max)
+      elsif length
+        case length <=> 0
+        when 1  then range(index, index + length - 1)
+        when 0  then []
+        when -1 then nil  # Ruby does this (a bit weird)
+        end
+      else
+        result = score(index) || 0 # handles a nil score
+      end
+    end
+    alias_method :slice, :[]
+
+    # 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)
+      result = redis.zscore(key, marshal(member))
+
+      result.to_f unless result.nil?
+    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)
+      if n = redis.zrank(key, marshal(member))
+        n.to_i
+      else
+        nil
+      end
+    end
+
+    def revrank(member)
+      if n = redis.zrevrank(key, marshal(member))
+        n.to_i
+      else
+        nil
+      end
+    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
+    alias_method :value, :members
+
+    # 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] || options[:with_scores]
+        redis.zrange(key, start_index, end_index, :with_scores => true).map{|v,s| [unmarshal(v), s] }
+      else
+        redis.zrange(key, start_index, end_index).map{|v| unmarshal(v) }
+      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] || options[:with_scores]
+        redis.zrevrange(key, start_index, end_index, :with_scores => true).map{|v,s| [unmarshal(v), s] }
+      else
+        redis.zrevrange(key, start_index, end_index).map{|v| unmarshal(v) }
+      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[:with_scores] = true if options[:withscores] || options[:with_scores]
+
+      redis.zrangebyscore(key, min, max, **args).map{|v| unmarshal(v) }
+    end
+
+    # Returns all the elements in the sorted set at key with a score between max and min
+    # (including elements with score equal to max or min). In contrary to the default ordering of sorted sets,
+    # for this command the elements are considered to be ordered from high to low scores.
+    # Options:
+    #     :count, :offset - passed to LIMIT
+    #     :withscores     - if true, scores are returned as well
+    # Redis: ZREVRANGEBYSCORE
+    def revrangebyscore(max, min, options={})
+      args = {}
+      args[:limit] = [options[:offset] || 0, options[:limit] || options[:count]] if
+                options[:offset] || options[:limit] || options[:count]
+      args[:with_scores] = true if options[:withscores] || options[:with_scores]
+
+      redis.zrevrangebyscore(key, max, min, **args).map{|v| unmarshal(v) }
+    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)
+      allow_expiration do
+        redis.zrem(key, marshal(value))
+      end
+    end
+
+    # Delete element if it matches block
+    def delete_if(&block)
+      raise ArgumentError, "Missing block to SortedSet#delete_if" unless block_given?
+      res = false
+      redis.zrange(key, 0, -1).each do |m|
+        if block.call(unmarshal(m))
+          res = redis.zrem(key, m)
+        end
+      end
+      res
+    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)
+      allow_expiration do
+        zincrby(member, by)
+      end
+    end
+    alias_method :incr, :increment
+    alias_method :incrby, :increment
+
+    # Convenience to calling increment() with a negative number.
+    def decrement(member, by=1)
+      allow_expiration do
+        zincrby(member, -by)
+      end
+    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)
+      result = nil
+      temp_key = :"#{key}:intersection:#{Time.current.to_i + rand}"
+
+      redis.multi do
+        interstore(temp_key, *sets)
+        redis.expire(temp_key, 1)
+
+        result = redis.zrange(temp_key, 0, -1)
+      end
+
+      result.value
+    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)
+      allow_expiration do
+        opts = sets.last.is_a?(Hash) ? sets.pop : {}
+        redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), **opts)
+      end
+    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)
+      result = nil
+      temp_key = :"#{key}:union:#{Time.current.to_i + rand}"
+
+      redis.multi do
+        unionstore(temp_key, *sets)
+        redis.expire(temp_key, 1)
+
+        result = redis.zrange(temp_key, 0, -1)
+      end
+
+      result.value
+    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)
+      allow_expiration do
+        opts = sets.last.is_a?(Hash) ? sets.pop : {}
+        redis.zunionstore(key_from_object(name), keys_from_objects([self] + sets), **opts)
+      end
+    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 or count. Redis: ZCARD
+    def length
+      redis.zcard(key)
+    end
+    alias_method :size, :length
+    alias_method :count, :length
+
+    # The number of members within a range of scores. Redis: ZCOUNT
+    def range_size(min, max)
+      redis.zcount(key, min, max)
+    end
+
+    # Return a boolean indicating whether +value+ is a member.
+    def member?(value)
+      !redis.zscore(key, marshal(value)).nil?
+    end
+
+    private
+    def key_from_object(set)
+      set.is_a?(Redis::SortedSet) ? set.key : set
+    end
+
+    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.is_a?(Redis::Set) ? set.key : set}
+    end
+
+    def zincrby(member, by)
+      redis.zincrby(key, by, marshal(member)).to_i
+    end
+  end
+end