oxblood 0.1.0.dev8 → 0.1.0.dev9

data/lib/oxblood/commands/sets.rb

@@ -0,0 +1,172 @@
+module Oxblood
+  module Commands
+    module Sets
+      # Add one or more members to a set
+      # @see http://redis.io/commands/sadd
+      #
+      # @param [String] key under which store set
+      # @param [String, Array<String>] members to store
+      #
+      # @return [Integer] the number of elements that were added to the set,
+      #   not including all the elements already present into the set.
+      def sadd(key, *members)
+        run(*members.unshift(:SADD, key))
+      end
+
+      # Get the number of members in a set
+      # @see http://redis.io/commands/scard
+      #
+      # @param [String] key
+      #
+      # @return [Integer] the cardinality (number of elements) of the set, or 0 if
+      #   key does not exist
+      def scard(key)
+        run(:SCARD, key)
+      end
+
+      # Subtract multiple sets
+      # @see http://redis.io/commands/sdiff
+      #
+      # @param [String, Array<String>] keys
+      #
+      # @return [Array] array with members of the resulting set
+      def sdiff(*keys)
+        run(*keys.unshift(:SDIFF))
+      end
+
+      # Subtract multiple sets and store the resulting set in a key
+      # @see http://redis.io/commands/sdiffstore
+      #
+      # @param [String] destination key
+      # @param [String, Array<String>] keys of sets to diff
+      #
+      # @return [Integer] the number of elements in the resulting set
+      def sdiffstore(destination, *keys)
+        run(*keys.unshift(:SDIFFSTORE, destination))
+      end
+
+      # Intersect multiple sets
+      # @see http://redis.io/commands/sinter
+      #
+      # @param [String, Array<String>] keys to intersect
+      #
+      # @return [Array] array with members of the resulting set
+      def sinter(*keys)
+        run(*keys.unshift(:SINTER))
+      end
+
+      # Intersect multiple sets and store the resulting key in a key
+      # @see http://redis.io/commands/sinterstore
+      #
+      # @param [String] destination key
+      # @param [String, Array<String>] keys of sets to intersect
+      #
+      # @return [Integer] the number of elements in the resulting set
+      def sinterstore(destination, *keys)
+        run(*keys.unshift(:SINTERSTORE, destination))
+      end
+
+      # Determine if a given value is a member of a set
+      # @see http://redis.io/commands/sismember
+      #
+      # @param [String] key
+      # @param [String] member
+      #
+      # @return [Integer] 1 if the element is a member of the set or
+      #   0 if the element is not a member of the set, or if key does not exist
+      def sismember(key, member)
+        run(:SISMEMBER, key, member)
+      end
+
+      # Get all the members in a set
+      # @see http://redis.io/commands/smembers
+      #
+      # @param [String] key
+      #
+      # @return [Array] all elements of the set
+      def smembers(key)
+        run(:SMEMBERS, key)
+      end
+
+      # Move a member from one set to another
+      # @see http://redis.io/commands/smove
+      #
+      # @param [String] source
+      # @param [String] destination
+      # @param [String] member
+      #
+      # @return [Integer] 1 if the element is moved, or 0 if the element is not
+      #   a member of source and no operation was performed
+      def smove(source, destination, member)
+        run(:SMOVE, source, destination, member)
+      end
+
+      # Remove and return one or multiple random members from a set
+      # @see http://redis.io/commands/spop
+      #
+      # @param [String] key
+      # @param [Integer] count
+      #
+      # @return [String] without the additional count argument the command returns
+      #   the removed element, or nil when key does not exist
+      # @return [Array] when the additional count argument is passed the command
+      #   returns an array of removed elements, or an empty array when key does
+      #   not exist.
+      def spop(key, count = nil)
+        args = [:SPOP, key]
+        args << count if count
+        run(*args)
+      end
+
+      # Get one or multiple random members from a set
+      # @see http://redis.io/commands/srandmember
+      #
+      # @param [String] key
+      # @param [Integer] count
+      #
+      # @return [String, nil] without the additional count argument the command
+      #   returns string with the randomly selected element, or nil when key
+      #   does not exist
+      # @return [Array] when the additional count argument is passed the command
+      #   returns an array of elements, or an empty array when key does not exist
+      def srandmember(key, count = nil)
+        args = [:SRANDMEMBER, key]
+        args << count if count
+        run(*args)
+      end
+
+      # Remove one or more members from a set
+      # @see http://redis.io/commands/srem
+      #
+      # @param [String] key
+      # @param [Array] members to remove
+      #
+      # @return [Integer] the number of members that were removed from the set,
+      #   not including non existing members
+      def srem(key, *members)
+        run(*members.unshift(:SREM, key))
+      end
+
+      # Add multiple sets
+      # @see http://redis.io/commands/sunion
+      #
+      # @param [String, Array<String>] keys
+      #
+      # @return [Array] list with members of the resulting set
+      def sunion(*keys)
+        run(*keys.unshift(:SUNION))
+      end
+
+      # Add multipe sets and store the resulting set in a key
+      # @see http://redis.io/commands/sunionstore
+      #
+      # @param [String] destination
+      # @param [String, Array<String>] keys
+      #
+      # @return [Integer] the number of elements in the resulting set
+      def sunionstore(destination, *keys)
+        run(*keys.unshift(:SUNIONSTORE, destination))
+      end
+    end
+  end
+end

data/lib/oxblood/commands/sorted_sets.rb

@@ -0,0 +1,276 @@
+module Oxblood
+  module Commands
+    module SortedSets
+      # Add one or more members to a sorted set, or update its score if it already
+      # exists.
+      # @see http://redis.io/commands/zadd
+      #
+      # @todo Add support for zadd options
+      #   http://redis.io/commands/zadd#zadd-options-redis-302-or-greater
+      #
+      # @param [String] key under which store set
+      # @param [[Float, String], Array<[Float, String]>] args scores and members
+      #
+      # @return [Integer] The number of elements added to the sorted sets, not
+      #   including elements already existing for which the score was updated
+      def zadd(key, *args)
+        run(*args.unshift(:ZADD, key))
+      end
+
+      # Get the number of members in a sorted set
+      # @see http://redis.io/commands/zcard
+      #
+      # @param [String] key
+      #
+      # @return [Integer] the cardinality (number of elements) of the sorted set,
+      #   or 0 if key does not exists
+      def zcard(key)
+        run(:ZCARD, key)
+      end
+
+      # Count the members in a sorted set with scores within the given values
+      # @see http://redis.io/commands/zcount
+      #
+      # @param [String] key
+      # @param [String] min
+      # @param [String] max
+      #
+      # @return [Integer] the number of elements in the specified score range
+      def zcount(key, min, max)
+        run(:ZCOUNT, key, min, max)
+      end
+
+      # Increment the score of a member in a sorted set
+      # @see http://redis.io/commands/zincrby
+      #
+      # @param [String] key
+      # @param [Float] increment
+      # @param [String] member
+      #
+      # @return [String] the new score of member (a double precision floating
+      #   point number), represented as string
+      def zincrby(key, increment, member)
+        run(:ZINCRBY, key, increment, member)
+      end
+
+      # Count the number of members in a sorted set between a given
+      # lexicographical range
+      # @see http://redis.io/commands/zlexcount
+      #
+      # @param [String] key
+      # @param [String] min
+      # @param [String] max
+      #
+      # @return the number of elements in the specified score range
+      def zlexcount(key, min, max)
+        run(:ZLEXCOUNT, key, min, max)
+      end
+
+      # Return a range of members in a sorted set, by index
+      # @see http://redis.io/commands/zrange
+      #
+      # @example
+      #   session.zrange('myzset', 0, -1)
+      #   # => ['one', 'two']
+      #
+      # @example
+      #   session.zrange('myzset', 0, -1, withscores: true)
+      #   # => [['one', '1'], ['two', '2']]
+      #
+      # @param [String] key
+      # @param [Integer] start index
+      # @param [Integer] stop index
+      # @param [Hash] opts
+      #
+      # @option opts [Boolean] :withscores (false) Return the scores of
+      #   the elements together with the elements
+      #
+      # @return [Array] list of elements in the specified range (optionally with
+      #   their scores, in case the :withscores option is given)
+      def zrange(key, start, stop, opts = {})
+        common_range(:ZRANGE, key, start, stop, opts)
+      end
+
+      # Return a range of members in a sorted set, by score
+      # @see http://redis.io/commands/zrangebyscore
+      #
+      # @param [String] key under which set is stored
+      # @param [String] min score
+      # @param [String] max score
+      # @param [Hash] opts
+      #
+      # @option opts [Boolean] :withscores (false) Return the scores of
+      #   the elements together with the elements
+      # @option opts [Array<Integer, Integer>] :limit Get a range of the matching
+      #   elements (similar to SELECT LIMIT offset, count in SQL)
+      #
+      # @example
+      #   session.zrangebyscore('myzset', '-inf', '+inf')
+      #   # => ['one', 'two', 'three']
+      #
+      # @example
+      #   session.zrangebyscore('myzset', '(1', 2, withscores: true)
+      #   # => [['two', '2']]
+      #
+      # @example
+      #   opts = { withscores: true, limit: [1, 1] }
+      #   session.zrangebyscore('myzset', '-inf', '+inf', opts)
+      #   # => [['two', '2']]
+      #
+      # @return [Array] list of elements in the specified score range (optionally
+      #   with their scores, in case the :withscores option is given)
+      def zrangebyscore(key, min, max, opts = {})
+        common_rangebyscore(:ZRANGEBYSCORE, key, min, max, opts)
+      end
+
+      # Determine the index of a member in a sorted set
+      # @see http://redis.io/commands/zrank
+      #
+      # @param [String] key
+      # @param [String] member
+      #
+      # @return [Integer, nil] the rank of member or nil if member does not exist
+      # in the sorted set or key does not exist
+      def zrank(key, member)
+        run(:ZRANK, key, member)
+      end
+
+      # Remove one or more members from a sorted set
+      # @see http://redis.io/commands/zrem
+      #
+      # @param [String] key
+      # @param [Array<String>] members to delete
+      #
+      # @return [Integer] number of deleted members
+      # @return [RError] when key exists and does not hold a sorted set.
+      def zrem(key, *members)
+        run(*members.unshift(:ZREM, key))
+      end
+
+      # Remove all members in a sorted set within the given indexes
+      # @see http://redis.io/commands/zremrangebyrank
+      #
+      # @param [String] key
+      # @param [String] start
+      # @param [String] stop
+      #
+      # @return [Integer] the number of elements removed
+      def zremrangebyrank(key, start, stop)
+        run(:ZREMRANGEBYRANK, key, start, stop)
+      end
+
+      # Remove all members in a sorted set within the given scores
+      # @see http://redis.io/commands/zremrangebyscore
+      #
+      # @param [String] key
+      # @param [String] min score
+      # @param [String] max score
+      #
+      # @return [Integer] the number of elements removed
+      def zremrangebyscore(key, min, max)
+        run(:ZREMRANGEBYSCORE, key, min, max)
+      end
+
+      # Return a range of members in a sorted set, by index, with scores ordered
+      # from high to low
+      # @see http://redis.io/commands/zrevrange
+      #
+      # @example
+      #   session.zrevrange('myzset', 0, -1)
+      #   # => ['two', 'one']
+      #
+      # @example
+      #   session.zrevrange('myzset', 0, -1, withscores: true)
+      #   # => [['two', '2'], ['one', '1']]
+      #
+      # @param [String] key
+      # @param [Integer] start index
+      # @param [Integer] stop index
+      # @param [Hash] opts
+      #
+      # @option opts [Boolean] :withscores (false) Return the scores of
+      #   the elements together with the elements
+      #
+      # @return [Array] list of elements in the specified range (optionally with
+      #   their scores, in case the :withscores option is given)
+      def zrevrange(key, start, stop, opts = {})
+        common_range(:ZREVRANGE, key, start, stop, opts)
+      end
+
+      # Return a range of members in a sorted set, by score, with scores ordered
+      # from high to low
+      # @see http://redis.io/commands/zrevrangebyscore
+      #
+      # @param [String] key under which set is stored
+      # @param [String] min score
+      # @param [String] max score
+      # @param [Hash] opts
+      #
+      # @option opts [Boolean] :withscores (false) Return the scores of
+      #   the elements together with the elements
+      # @option opts [Array<Integer, Integer>] :limit Get a range of the matching
+      #   elements (similar to SELECT LIMIT offset, count in SQL)
+      #
+      # @example
+      #   session.zrevrangebyscore('myzset', '+inf', '-inf')
+      #   # => ['three', 'two', 'one']
+      #
+      # @example
+      #   session.zrevrangebyscore('myzset', 2, '(1', withscores: true)
+      #   # => [['two', '2']]
+      #
+      # @example
+      #   opts = { withscores: true, limit: [1, 1] }
+      #   session.zrevrangebyscore('myzset', '+inf', '-inf', opts)
+      #   # => [['two', '2']]
+      #
+      # @return [Array] list of elements in the specified score range (optionally
+      #   with their scores, in case the :withscores option is given)
+      def zrevrangebyscore(key, min, max, opts = {})
+        common_rangebyscore(:ZREVRANGEBYSCORE, key, min, max, opts)
+      end
+
+      # Determine the index of a member in a sorted set, with scores ordered from
+      # high to low
+      # @see http://redis.io/commands/zrevrank
+      #
+      # @param [String] key
+      # @param [String] member
+      #
+      # @return [Integer, nil] the rank of member, or nil if member does not
+      # exists in the sorted set or key does not exists
+      def zrevrank(key, member)
+        run(:ZREVRANK, key, member)
+      end
+
+      # Get the score associated with the given member in a sorted set
+      # @see http://redis.io/commands/zscore
+      #
+      # @param [String] key
+      # @param [String] member
+      #
+      # @return [String, nil] the score of member (a double precision floating
+      # point number), represented as string, or nil if member does not exist in
+      # the sorted set, or key does not exists
+      def zscore(key, member)
+        run(:ZSCORE, key, member)
+      end
+
+      private
+
+      def common_rangebyscore(command_name, key, min, max, opts)
+        args = [command_name, key, min, max]
+        args << :WITHSCORES if opts[:withscores]
+        args.push(:LIMIT).concat(opts[:limit]) if opts[:limit].is_a?(Array)
+
+        run(*args)
+      end
+
+      def common_range(command_name, key, start, stop, opts)
+        args = [command_name, key, start, stop]
+        args << :WITHSCORES if opts[:withscores]
+        run(*args)
+      end
+    end
+  end
+end