oxblood 0.1.0.dev7 → 0.1.0.dev8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 007983f13baaa6978b6db2a3fe4fc821abaa8f56
-  data.tar.gz: e96fbcaca9bcb69f95ddbae0d2ae606bf8fc0954
+  metadata.gz: 5de6f805e09661746b328df9a6654848a4937307
+  data.tar.gz: 8a6f7be7ff52ec6eeda55d852fbd7809c746224f
 SHA512:
-  metadata.gz: 553a57f8b85f9407758c60cab222bbbfcc7804d74d1daad993bd46aec2099449159a3f8911bcb55e4957a62ae64d945ef7e6064bb121035ed7f09f683aa95b25
-  data.tar.gz: 0f7a5078313ffde39c70c4ffc2a87089881fcf4e8968591eaaf35bf4ee93c139a505e6572c924afb59eed75fe0e9308a78692c9a9e8fdac7d3f753116885e4c6
+  metadata.gz: 34d5e0b3b3547205df5d72388b81a24f862f6887d90ff87672304fdebf62bed3eb8c5bf097274df1f5ff13aa84154eeb130f3e4768eaac3c141a2543c6a793c2
+  data.tar.gz: 74a234ad3c08837d61c6e355188190f6af04f0bb4df7245d6cf8edaecaf5b799fb49f49fdc962a22c71f13cd1e05cd9e1fc8831a53374a45b978fb16d771ab5c

data/README.md

@@ -17,21 +17,22 @@ An experimental Redis Ruby client.
 
 - Commands:
   - Cluster (0/20)
-  - Connection (4/5)
+  - Connection
   - Geo (0/6)
-  - Hashes (14/15)
+  - Hashes (14/15) (See [#3](https://github.com/etehtsea/oxblood/issues/3))
   - HyperLogLog (0/3)
-  - Keys (18/22)
-  - Lists (6/17)
+  - Keys (18/22) (See [#4], [#6], [#7], [#8])
+  - Lists (14/17) (See [#11](https://github.com/etehtsea/oxblood/issues/11))
   - Pub/Sub (0/6)
   - Scripting (0/7)
   - Server (2/31)
-  - Sets (5/15)
-  - Sorted Sets (6/21)
-  - Strings (5/24)
+  - Sets (14/15) (See [#10](https://github.com/etehtsea/oxblood/issues/10))
+  - Sorted Sets (15/21) (See [#12], [#13], [#14], [#15])
+  - Strings (23/24) (See [#16](https://github.com/etehtsea/oxblood/issues/16))
   - Transaction (0/5)
 - [Pipeling](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/Pipeline)
 - [Connection pooling](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/Pool)
+- [Connection resiliency](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/RSocket)
 
 ## Usage
 As a starting point please look at [Oxblood::Pool](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/Pool) documentation.
@@ -50,3 +51,12 @@ Bug reports and pull requests are welcome on [GitHub](https://github.com/etehtse
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[#4]: https://github.com/etehtsea/oxblood/issues/4
+[#6]: https://github.com/etehtsea/oxblood/issues/6
+[#7]: https://github.com/etehtsea/oxblood/issues/7
+[#8]: https://github.com/etehtsea/oxblood/issues/8
+[#12]: https://github.com/etehtsea/oxblood/issues/12
+[#13]: https://github.com/etehtsea/oxblood/issues/13
+[#14]: https://github.com/etehtsea/oxblood/issues/14
+[#15]: https://github.com/etehtsea/oxblood/issues/15

data/lib/oxblood/rsocket.rb

@@ -8,6 +8,15 @@ module Oxblood
   class RSocket
     TimeoutError = Class.new(RuntimeError)
 
+    # JRuby don't properly support SO_LINGER setting
+    # @see https://github.com/jruby/jruby/issues/4040
+    LINGER_OPTION = if RUBY_ENGINE == 'jruby'
+                      [Socket::SOL_SOCKET, :LINGER, 0].freeze
+                    else
+                      Socket::Option.linger(true, 0)
+                    end
+    private_constant :LINGER_OPTION
+
     # @!attribute [rw] timeout
     #   @return [Numeric] timeout in seconds
     attr_accessor :timeout
@@ -77,15 +86,15 @@ module Oxblood
     # @return [nil] always return nil
     def close
       @buffer.clear
-      socket.close
+      @socket && @socket.close
     rescue IOError
       ;
     ensure
       @socket = nil
     end
 
-    # True if connection is established
-    # @return [Boolean] connection status
+    # True if socket exists
+    # @return [Boolean] socket exists or not
     def connected?
       !!@socket
     end
@@ -124,6 +133,8 @@ module Oxblood
 
 
     def fail_with_timeout!
+      # In case of failure close socket ASAP
+      socket.setsockopt(*LINGER_OPTION)
       close
       raise TimeoutError
     end

data/lib/oxblood/session.rb

@@ -187,6 +187,78 @@ module Oxblood
     # Strings
     #
 
+    # Append a value to a key
+    # @see http://redis.io/commands/append
+    #
+    # @param [String] key
+    # @param [String] value
+    #
+    # @return [Integer] the length of the string after the append operation
+    def append(key, value)
+      run(:APPEND, key, value)
+    end
+
+    # Count set bits in a string
+    # @see http://redis.io/commands/bitcount
+    #
+    # @param [String] key
+    # @param [Array] interval to count in
+    #
+    # @return [Integer] the number of bits set to 1
+    def bitcount(key, *interval)
+      run(*interval.unshift(:BITCOUNT, key))
+    end
+
+    # Perform bitwise operations between strings
+    # @see http://redis.io/commands/bitop
+    #
+    # @param [String] operation
+    # @param [String] destkey
+    # @param [Array] keys
+    #
+    # @return [Integer] the size of the string stored in the destination key,
+    #   that is equal to the size of the longest input string
+    def bitop(operation, destkey, *keys)
+      run(*keys.unshift(:BITOP, operation, destkey))
+    end
+
+    # Find first bit set or clear in a string
+    # @see http://redis.io/commands/bitpos
+    #
+    # @param [String] key
+    # @param [Integer] bit
+    # @param [Array] interval
+    #
+    # @return [Integer] the command returns the position of the first bit set to
+    #   1 or 0 according to the request
+    def bitpos(key, bit, *interval)
+      run(*interval.unshift(:BITPOS, key, bit))
+    end
+
+    # Decrement the integer value of a key by one
+    # @see http://redis.io/commands/decr
+    #
+    # @param [String] key
+    #
+    # @return [Integer] the value of key after the decrement
+    # @return [RError] if value is not an integer or out of range
+    def decr(key)
+      run(:DECR, key)
+    end
+
+    # Decrement the integer value of a key by the given number
+    # @see http://redis.io/commands/decrby
+    #
+    # @param [String] key
+    # @param [Integer] decrement
+    #
+    # @return [Integer] the value of key after the decrement
+    # @return [RError] if the key contains a value of the wrong type or contains
+    #   a string that can not be represented as integer
+    def decrby(key, decrement)
+      run(:DECRBY, key, decrement)
+    end
+
     # Get the value of a key
     # @see http://redis.io/commands/get
     #
@@ -197,6 +269,41 @@ module Oxblood
       run(:GET, key)
     end
 
+    # Returns the bit value at offset in the string value stored at key
+    # @see http://redis.io/commands/getbit
+    #
+    # @param [String] key
+    # @param [Integer] offset
+    #
+    # @return [Integer] the bit value stored at offset
+    def getbit(key, offset)
+      run(:GETBIT, key, offset)
+    end
+
+    # Get a substring of the string stored at a key
+    # @see http://redis.io/commands/getrange
+    #
+    # @param [String] key
+    # @param [Integer] start_pos
+    # @param [Integer] end_pos
+    #
+    # @return [String] substring
+    def getrange(key, start_pos, end_pos)
+      run(:GETRANGE, key, start_pos, end_pos)
+    end
+
+    # Set the string value of a key and return its old value
+    # @see http://redis.io/commands/getset
+    #
+    # @param [String] key
+    # @param [String] value
+    #
+    # @return [String, nil] the old value stored at key, or nil when
+    #   key did not exist
+    def getset(key, value)
+      run(:GETSET, key, value)
+    end
+
     # Increment the integer value of a key by one
     # @see http://redis.io/commands/incr
     #
@@ -220,6 +327,17 @@ module Oxblood
       run(:INCRBY, key, increment)
     end
 
+    # Increment the float value of a key by the given amount
+    # @see http://redis.io/commands/incrbyfloat
+    #
+    # @param [String] key
+    # @param [Float] increment
+    #
+    # @return [String] the value of key after the increment
+    def incrbyfloat(key, increment)
+      run(:INCRBYFLOAT, key, increment)
+    end
+
     # Get the values of all the given keys
     # @see http://redis.io/commands/mget
     #
@@ -230,6 +348,39 @@ module Oxblood
       run(*keys.unshift(:MGET))
     end
 
+    # Set multiple keys to multiple values
+    # @see http://redis.io/commands/mset
+    #
+    # @param [Array] keys_and_values
+    #
+    # @return [String] 'OK'
+    def mset(*keys_and_values)
+      run(*keys_and_values.unshift(:MSET))
+    end
+
+    # Set multiple keys to multiple values, only if none of the keys exist
+    # @see http://redis.io/commands/msetnx
+    #
+    # @param [Array] keys_and_values
+    #
+    # @return [Integer] 1 if the all the keys were set, or
+    #   0 if no key was set (at least one key already existed)
+    def msetnx(*keys_and_values)
+      run(*keys_and_values.unshift(:MSETNX))
+    end
+
+    # Set the value and expiration in milliseconds of a key
+    # @see http://redis.io/commands/psetex
+    #
+    # @param [String] key
+    # @param [Integer] milliseconds expire time
+    # @param [String] value
+    #
+    # @return [String] 'OK'
+    def psetex(key, milliseconds, value)
+      run(:PSETEX, key, milliseconds, value)
+    end
+
     # Set the string value of a key
     # @see http://redis.io/commands/set
     #
@@ -244,6 +395,65 @@ module Oxblood
       run(:SET, key, value)
     end
 
+    # Set or clear the bit at offset in the string value stored at key
+    # @see http://redis.io/commands/setbit
+    #
+    # @param [String] key
+    # @param [Integer] offset
+    # @param [String] value
+    #
+    # @return [Integer] the original bit value stored at offset
+    def setbit(key, offset, value)
+      run(:SETBIT, key, offset, value)
+    end
+
+    # Set the value and expiration of a key
+    # @see http://redis.io/commands/setex
+    #
+    # @param [String] key
+    # @param [Integer] seconds expire time
+    # @param [String] value
+    #
+    # @return [String] 'OK'
+    def setex(key, seconds, value)
+      run(:SETEX, key, seconds, value)
+    end
+
+    # Set the value of a key, only if the key does not exist
+    # @see http://redis.io/commands/setnx
+    #
+    # @param [String] key
+    # @param [String] value
+    #
+    # @return [Integer] 1 if the key was set, or 0 if the key was not set
+    def setnx(key, value)
+      run(:SETNX, key, value)
+    end
+
+    # Overwrite part of a string at key starting at the specified offset
+    # @see http://redis.io/commands/setrange
+    #
+    # @param [String] key
+    # @param [Integer] offset
+    # @param [String] value
+    #
+    # @return [Integer] the length of the string after it was modified by
+    #   the command
+    def setrange(key, offset, value)
+      run(:SETRANGE, key, offset, value)
+    end
+
+    # Get the length of the value stored in a key
+    # @see http://redis.io/commands/strlen
+    #
+    # @param [String] key
+    #
+    # @return [Integer] the length of the string at key,
+    #   or 0 when key does not exist
+    def strlen(key)
+      run(:STRLEN, key)
+    end
+
     #
     # Connection
     #
@@ -304,6 +514,16 @@ module Oxblood
       run(:SELECT, index)
     end
 
+    # Close the connection
+    # @see http://redis.io/commands/quit
+    #
+    # @return [String] 'OK'
+    def quit
+      run(:QUIT)
+    ensure
+      @connection.socket.close
+    end
+
     #
     # Server
     #
@@ -543,6 +763,31 @@ module Oxblood
     # Lists
     #
 
+    # Get an element from a list by its index
+    # @see http://www.redis.io/commands/lindex
+    #
+    # @param [String] key
+    # @param [Integer] index zero-based of element in the list
+    #
+    # @return [String] the requested element, or nil when index is out of range.
+    def lindex(key, index)
+      run(:LINDEX, key, index)
+    end
+
+    # Insert an element before or after another element in a list
+    # @see http://www.redis.io/commands/linsert
+    #
+    # @param [String] key
+    # @param [Symbol] place could be :before or :after
+    # @param [String] pivot reference value
+    # @param [String] value to insert
+    #
+    # @return [Integer] the length of the list after the insert operation,
+    # or -1 when the value pivot was not found
+    def linsert(key, place, pivot, value)
+      run(:LINSERT, key, place, pivot, value)
+    end
+
     # Get the length of a list
     # @see http://redis.io/commands/llen
     #
@@ -576,6 +821,17 @@ module Oxblood
       run(*values.unshift(:LPUSH, key))
     end
 
+    # Prepend a value to a list, only if the list exists
+    # @see http://www.redis.io/commands/lpushx
+    #
+    # @param [String] key
+    # @param [String] value
+    #
+    # @return [Integer] the length of the list after the push operation
+    def lpushx(key, value)
+      run(:LPUSHX, key, value)
+    end
+
     # Get a range of elements from a list
     # @see http://redis.io/commands/lrange
     #
@@ -588,6 +844,43 @@ module Oxblood
       run(:LRANGE, key, start, stop)
     end
 
+    # Remove elements from a list
+    # @see http://www.redis.io/commands/lrem
+    #
+    # @param [String] key
+    # @param [Integer] count (please look into official docs for more info)
+    # @param [String] value to remove
+    #
+    # @return [Integer] the number of removed elements
+    def lrem(key, count, value)
+      run(:LREM, key, count, value)
+    end
+
+    # Set the value of an element in a list by its index
+    # @see http://www.redis.io/commands/lset
+    #
+    # @param [String] key
+    # @param [Integer] index
+    # @param [String] value
+    #
+    # @return [String] 'OK'
+    # @return [RError] if index is out of range
+    def lset(key, index, value)
+      run(:LSET, key, index, value)
+    end
+
+    # Trim a list to the specified range
+    # @see http://www.redis.io/commands/ltrim
+    #
+    # @param [String] key
+    # @param [Integer] start
+    # @param [Integer] stop
+    #
+    # @return [String] 'OK'
+    def ltrim(key, start, stop)
+      run(:LTRIM, key, start, stop)
+    end
+
     # Remove and get the last element in a list
     # @see http://redis.io/commands/rpop
     #
@@ -599,6 +892,18 @@ module Oxblood
       run(:RPOP, key)
     end
 
+    # Remove the last element in a list, prepend it to another list and return
+    # @see http://www.redis.io/commands/rpoplpush
+    #
+    # @param [String] source
+    # @param [String] destination
+    #
+    # @return [String, nil] the element being popped and pushed, or nil when
+    #   source does not exist
+    def rpoplpush(source, destination)
+      run(:RPOPLPUSH, source, destination)
+    end
+
     # Append one or multiple values to a list
     # @see http://redis.io/commands/rpush
     #
@@ -611,6 +916,17 @@ module Oxblood
       run(*values.unshift(:RPUSH, key))
     end
 
+    # Append a value to a list, only if the list exists
+    # @see http://www.redis.io/commands/rpushx
+    #
+    # @param [String] key
+    # @param [String] value
+    #
+    # @return [Integer] the length of the list after the push operation
+    def rpushx(key, value)
+      run(:RPUSHX, key, value)
+    end
+
     #
     # Sets
     #
@@ -638,6 +954,60 @@ module Oxblood
       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
     #
@@ -648,6 +1018,53 @@ module Oxblood
       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
     #
@@ -670,6 +1087,17 @@ module Oxblood
       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
+
     #
     # Sorted Sets
     #
@@ -701,6 +1129,44 @@ module Oxblood
       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
     #
@@ -731,15 +1197,49 @@ module Oxblood
     # Return a range of members in a sorted set, by score
     # @see http://redis.io/commands/zrangebyscore
     #
-    # @todo Support optional args (WITHSCORES/LIMIT)
-    #
     # @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 = {})
+      args = [:ZRANGEBYSCORE, key, min, max]
+      args << :WITHSCORES if opts[:withscores]
+      args.push(:LIMIT).concat(opts[:limit]) if opts[:limit].is_a?(Array)
+
+      run(*args)
+    end
+
+    # Determine the index of a member in a sorted set
+    # @see http://redis.io/commands/zrank
     #
-    # @return [Array] list of elements in the specified score range
-    def zrangebyscore(key, min, max)
-      run(:ZRANGEBYSCORE, key, min, max)
+    # @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
@@ -754,6 +1254,18 @@ module Oxblood
       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
     #
@@ -766,6 +1278,97 @@ module Oxblood
       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 = {})
+      args = [:ZREVRANGE, key, start, stop]
+      args << :WITHSCORES if opts[:withscores]
+      run(*args)
+    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 = {})
+      args = [:ZREVRANGEBYSCORE, key, min, max]
+      args << :WITHSCORES if opts[:withscores]
+      args.push(:LIMIT).concat(opts[:limit]) if opts[:limit].is_a?(Array)
+
+      run(*args)
+    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
+
     protected
 
     def serialize(*command)

data/lib/oxblood/version.rb

@@ -1,3 +1,3 @@
 module Oxblood
-  VERSION = '0.1.0.dev7'
+  VERSION = '0.1.0.dev8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oxblood
 version: !ruby/object:Gem::Version
-  version: 0.1.0.dev7
+  version: 0.1.0.dev8
 platform: ruby
 authors:
 - Konstantin Shabanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -114,7 +114,6 @@ files:
 - benchmarks/pipeline.rb
 - benchmarks/serializer.rb
 - lib/oxblood.rb
-- lib/oxblood/buffered_io.rb
 - lib/oxblood/connection.rb
 - lib/oxblood/pipeline.rb
 - lib/oxblood/pool.rb

data/lib/oxblood/buffered_io.rb

@@ -1,12 +0,0 @@
-module Oxblood
-  # @private
-  class BufferedIO
-    def initialize(socket)
-      @socket = socket
-      @buffer = String.new
-    end
-
-
-    private
-  end
-end