oxblood 0.1.0.dev8 → 0.1.0.dev9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5de6f805e09661746b328df9a6654848a4937307
-  data.tar.gz: 8a6f7be7ff52ec6eeda55d852fbd7809c746224f
+  metadata.gz: ef39e93b7bf0f2dc011433a59874028fcc1e49e6
+  data.tar.gz: f9c730aac3b62cc6e4cfb3d76bd0fb29d87bcc76
 SHA512:
-  metadata.gz: 34d5e0b3b3547205df5d72388b81a24f862f6887d90ff87672304fdebf62bed3eb8c5bf097274df1f5ff13aa84154eeb130f3e4768eaac3c141a2543c6a793c2
-  data.tar.gz: 74a234ad3c08837d61c6e355188190f6af04f0bb4df7245d6cf8edaecaf5b799fb49f49fdc962a22c71f13cd1e05cd9e1fc8831a53374a45b978fb16d771ab5c
+  metadata.gz: e22b6aea29ce947a9f735ab788a29e14d1ada26cdb411cd3970e1b703fa62b3b14d59b83829edecc46f1eec3539b8538313fb3182758096adf7d0d07adbcd7a9
+  data.tar.gz: b32802b13c4569f8b7cc164b2a2ee5d0a0932b9320788626e95bc025e557b828b3046798d49a55b302fc1e271c4796dd900358c6cf9213349bb73f2f0f6912c1

data/.travis.yml

@@ -6,7 +6,7 @@ rvm:
   - 2.2.5
   - 2.3.1
   - jruby-9.0.5.0
-  - jruby-9.1.2.0
+  - jruby-9.1.5.0
 
 services:
   - redis-server

data/README.md

@@ -29,7 +29,7 @@ An experimental Redis Ruby client.
   - 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)
+  - Transaction (3/5) (See [#19])
 - [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)
@@ -60,3 +60,4 @@ The gem is available as open source under the terms of the [MIT License](http://
 [#13]: https://github.com/etehtsea/oxblood/issues/13
 [#14]: https://github.com/etehtsea/oxblood/issues/14
 [#15]: https://github.com/etehtsea/oxblood/issues/15
+[#19]: https://github.com/etehtsea/oxblood/issues/19

data/lib/oxblood/commands/connection.rb

@@ -0,0 +1,59 @@
+module Oxblood
+  module Commands
+    module Connection
+      # Authenticate to the server
+      # @see http://redis.io/commands/auth
+      #
+      # @param [String] password
+      #
+      # @return [String] 'OK'
+      # @return [RError] if wrong password was passed or server does not require
+      #   password
+      def auth(password)
+        run(:AUTH, password)
+      end
+
+      # Echo the given string
+      # @see http://redis.io/commands/echo
+      #
+      # @param [String] message
+      #
+      # @return [String] given string
+      def echo(message)
+        run(:ECHO, message)
+      end
+
+      # Returns PONG if no argument is provided, otherwise return a copy of
+      # the argument as a bulk
+      # @see http://redis.io/commands/ping
+      #
+      # @param [String] message to return
+      #
+      # @return [String] message passed as argument
+      def ping(message = nil)
+        message ? run(:PING, message) : run(:PING)
+      end
+
+      # Change the selected database for the current connection
+      # @see http://redis.io/commands/select
+      #
+      # @param [Integer] index database to switch
+      #
+      # @return [String] 'OK'
+      # @return [RError] if wrong index was passed
+      def select(index)
+        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
+    end
+  end
+end

data/lib/oxblood/commands/hashes.rb

@@ -0,0 +1,174 @@
+module Oxblood
+  module Commands
+    module Hashes
+      QUEUED = 'QUEUED'.freeze
+      private_constant :QUEUED
+
+      # Removes the specified fields from the hash stored at key
+      # @see http://redis.io/commands/hdel
+      #
+      # @param [String] key under which hash is stored
+      # @param [Array<#to_s>] fields to delete
+      #
+      # @return [Integer] the number of fields that were removed from the hash
+      def hdel(key, fields)
+        run(:HDEL, key, fields)
+      end
+
+      # Returns if field is an existing field in the hash stored at key
+      # @see http://redis.io/commands/hexists
+      #
+      # @param [String] key under which hash is stored
+      # @param [String] field to check for existence
+      #
+      # @return [Boolean] do hash contains field or not
+      def hexists(key, field)
+        1 == run(:HEXISTS, key, field)
+      end
+
+      # Get the value of a hash field
+      # @see http://redis.io/commands/hget
+      #
+      # @param [String] key under which hash is stored
+      # @param [String] field name
+      #
+      # @return [String, nil] the value associated with field
+      #   or nil when field is not present in the hash or key does not exist.
+      def hget(key, field)
+        run(:HGET, key, field)
+      end
+
+      # Get all the fields and values in a hash
+      # @see http://redis.io/commands/hgetall
+      #
+      # @param [String] key under which hash is stored
+      #
+      # @return [Hash] of fields and their values
+      def hgetall(key)
+        response = run(:HGETALL, key)
+        response == 'QUEUED' ? response : Hash[*response]
+      end
+
+      # Increment the integer value of a hash field by the given number
+      # @see http://redis.io/commands/hincrby
+      #
+      # @param [String] key under which hash is stored
+      # @param [String] field to increment
+      # @param [Integer] increment by value
+      #
+      # @return [Integer] the value at field after the increment operation
+      def hincrby(key, field, increment)
+        run(:HINCRBY, key, field, increment)
+      end
+
+      # Increment the float value of a hash field by the given number
+      # @see http://redis.io/commands/hincrby
+      #
+      # @param [String] key under which hash is stored
+      # @param [String] field to increment
+      # @param [Integer] increment by value
+      #
+      # @return [String] the value of field after the increment
+      # @return [RError] field contains a value of the wrong type (not a string).
+      #   Or the current field content or the specified increment are not parsable
+      #   as a double precision floating point number.
+      def hincrbyfloat(key, field, increment)
+        run(:HINCRBYFLOAT, key, field, increment)
+      end
+
+      # Get all the keys in a hash
+      # @see http://redis.io/commands/hkeys
+      #
+      # @param [String] key
+      #
+      # @return [Array] list of fields in the hash, or an empty list when
+      #   key does not exist.
+      def hkeys(key)
+        run(:HKEYS, key)
+      end
+
+      # Get the number of keys in a hash
+      # @see http://redis.io/commands/hlen
+      #
+      # @param [String] key
+      #
+      # @return [Integer] number of fields in the hash, or 0 when
+      #   key does not exist.
+      def hlen(key)
+        run(:HLEN, key)
+      end
+
+      # Get the field values of all given hash fields
+      # @see http://redis.io/commands/hmget
+      #
+      # @param [String] key under which hash is stored
+      # @param [String, Array<String>] fields to get
+      #
+      # @return [Array] list of values associated with the given fields,
+      #   in the same order as they are requested.
+      def hmget(key, *fields)
+        run(*fields.unshift(:HMGET, key))
+      end
+
+      # Set multiple hash fields to multiple values
+      # @see http://redis.io/commands/hmset
+      #
+      # @param [String] key under which store hash
+      # @param [[String, String], Array<[String, String]>] args fields and values
+      #
+      # @return [String] 'OK'
+      def hmset(key, *args)
+        run(*args.unshift(:HMSET, key))
+      end
+
+      # Set the string value of a hash field
+      # @see http://redis.io/commands/hset
+      #
+      # @param [String] key
+      # @param [String] field
+      # @param [String] value
+      #
+      # @return [Integer] 1 if field is a new field in the hash and value was set.
+      #   0 if field already exists in the hash and the value was updated.
+      def hset(key, field, value)
+        run(:HSET, key, field, value)
+      end
+
+      # Set the value of a hash field, only if the field does not exist
+      # @see http://redis.io/commands/hsetnx
+      #
+      # @param [String] key
+      # @param [String] field
+      # @param [String] value
+      #
+      # @return [Integer] 1 if field is a new field in the hash and value was set.
+      #   0 if field already exists in the hash and no operation was performed.
+      def hsetnx(key, field, value)
+        run(:HSETNX, key, field, value)
+      end
+
+      # Get the length of the value of a hash field
+      # @see http://redis.io/commands/hstrlen
+      #
+      # @param [String] key
+      # @param [String] field
+      #
+      # @return [Integer] the string length of the value associated with field,
+      #   or 0 when field is not present in the hash or key does not exist at all.
+      def hstrlen(key, field)
+        run(:HSTRLEN, key, field)
+      end
+
+      # Get all values in a hash
+      # @see http://redis.io/commands/hvals
+      #
+      # @param [String] key
+      #
+      # @return [Array] list of values in the hash, or an empty list when
+      #   key does not exist
+      def hvals(key)
+        run(:HVALS, key)
+      end
+    end
+  end
+end

data/lib/oxblood/commands/keys.rb

@@ -0,0 +1,213 @@
+module Oxblood
+  module Commands
+    module Keys
+      # Delete a key
+      # @see http://redis.io/commands/del
+      #
+      # @param [String, Array<String>] keys to delete
+      #
+      # @return [Integer] the number of keys that were removed
+      def del(*keys)
+        run(*keys.unshift(:DEL))
+      end
+
+      # Return a serialized version of the value stored at specified key.
+      # @see http://redis.io/commands/dump
+      #
+      # @param [String] key
+      #
+      # @return [String] serialized value
+      def dump(key)
+        run(:DUMP, key)
+      end
+
+      # Determine if a key exists
+      # @see http://redis.io/commands/exists
+      #
+      # @param [String, Array<String>] keys to check
+      #
+      # @return [Integer] the number of keys existing among the ones specified as
+      #   arguments. Keys mentioned multiple times and existing are counted
+      #   multiple times.
+      def exists(*keys)
+        run(*keys.unshift(:EXISTS))
+      end
+
+      # Set a key's time to live in seconds
+      # @see http://redis.io/commands/expire
+      #
+      # @param [String] key to expire
+      # @param [Integer] seconds number of seconds
+      #
+      # @return [Integer] 1 if the timeout was set. 0 if key does not exist or
+      #   the timeout could not be set.
+      def expire(key, seconds)
+        run(:EXPIRE, key, seconds)
+      end
+
+      # Set the expiration for a key as a UNIX timestamp
+      # @see http://redis.io/commands/expireat
+      #
+      # @param [String] key
+      # @param [Integer] timestamp in UNIX format
+      #
+      # @return [Integer] 1 if the timeout was set. 0 if key does not exist or
+      #   the timeout could not be set.
+      def expireat(key, timestamp)
+        run(:EXPIREAT, key, timestamp)
+      end
+
+      # Find all keys matching the given pattern
+      # @see http://redis.io/commands/keys
+      #
+      # @param [String] pattern used to match keys
+      def keys(pattern)
+        run(:KEYS, pattern)
+      end
+
+      # Move a key to another database
+      # @see http://redis.io/commands/move
+      #
+      # @param [String] key
+      # @param [Integer] db index
+      #
+      # @return [Integer] 1 if key was moved and 0 otherwise.
+      def move(key, db)
+        run(:MOVE, key, db)
+      end
+
+      # Inspect the internals of Redis objects
+      # @see http://redis.io/commands/object
+      #
+      # @param [String] subcommand `REFCOUNT`, `ENCODING`, `IDLETIME`
+      # @param [String] key
+      #
+      # @return [Integer] in case of `REFCOUNT` and `IDLETIME` subcommands
+      # @return [String] in case of `ENCODING` subcommand
+      # @return [nil] if object you try to inspect is missing
+      def object(subcommand, key)
+        run(:OBJECT, subcommand, key)
+      end
+
+      # Remove expiration from a key
+      # @see http://redis.io/commands/persist
+      # @param [String] key
+      #
+      # @return [Integer] 1 if the timeout was removed and 0 otherwise
+      def persist(key)
+        run(:PERSIST, key)
+      end
+
+      # Set a key's time to live in milliseconds
+      # @see http://redis.io/commands/pexpire
+      #
+      # @param [String] key
+      # @param [Integer] milliseconds
+      #
+      # @return [Integer] 1 if the timeout was set and 0 otherwise
+      def pexpire(key, milliseconds)
+        run(:PEXPIRE, key, milliseconds)
+      end
+
+      # Set the expiration for a key as a UNIX timestamp specified in milliseconds
+      # @see http://redis.io/commands/pexpireat
+      #
+      # @param [String] key
+      # @param [Integer] timestamp in milliseconds
+      #
+      # @return [Integer] 1 if the timeout was set and 0 otherwise
+      def pexpireat(key, timestamp)
+        run(:PEXPIREAT, key, timestamp)
+      end
+
+      # Get the time to live for a key in milliseconds
+      # @see http://redis.io/commands/pttl
+      #
+      # @param [String] key
+      #
+      # @return [Integer] TTL in milliseconds, or a negative value in order to
+      #   signal an error
+      def pttl(key)
+        run(:PTTL, key)
+      end
+
+      # Return a random key from the keyspace
+      # @see http://redis.io/commands/randomkey
+      #
+      # @return [String] the random key
+      # @return [nil] if database is empty
+      def randomkey
+        run(:RANDOMKEY)
+      end
+
+      # Rename a key
+      # @see http://redis.io/commands/rename
+      #
+      # @param [String] key to rename
+      # @param [String] newkey
+      #
+      # @return [String] OK in case of success
+      # @return [RError] if key does not exist. Before Redis 3.2.0, an error is
+      #   returned if source and destination names are the same.
+      def rename(key, newkey)
+        run(:RENAME, key, newkey)
+      end
+
+      # Rename a key, only if the new key does not exist
+      # @see http://redis.io/commands/renamenx
+      #
+      # @param [String] key to rename
+      # @param [String] newkey
+      #
+      # @return [Integer] 1 if key was renamed to newkey. 0 if newkey already
+      #   exists.
+      # @return [RError] if key does not exist. Before Redis 3.2.0, an error is
+      #   returned if source and destination names are the same.
+      def renamenx(key, newkey)
+        run(:RENAMENX, key, newkey)
+      end
+
+      # Create a key using the provided serialized value, previously obtained
+      # using DUMP
+      # @see http://redis.io/commands/restore
+      #
+      # @param [String] key
+      # @param [Integer] ttl expire time in milliseconds
+      # @param [String] serialized_value obtained using DUMP command
+      # @param [Hash] opts
+      #
+      # @option opts [Boolean] :replace (false) Override key if it already exists
+      #
+      # @return [String] OK on success
+      # @return [RError] if replace is false and key already exists or RDB version
+      #   and data checksum don't match.
+      def restore(key, ttl, serialized_value, opts = {})
+        args = [:RESTORE, key, ttl, serialized_value]
+        args << :REPLACE if opts[:replace]
+
+        run(*args)
+      end
+
+      # Get the time to live for a key
+      # @see http://redis.io/commands/ttl
+      #
+      # @param [String] key
+      #
+      # @return [Integer] TTL in seconds, or a negative value in order to signal
+      #   an error
+      def ttl(key)
+        run(:TTL, key)
+      end
+
+      # Determine the type stored at key
+      # @see http://redis.io/commands/type
+      #
+      # @param [String] key
+      #
+      # @return [String] type of key, or none when key does not exist.
+      def type(key)
+        run(:TYPE, key)
+      end
+    end
+  end
+end

data/lib/oxblood/commands/lists.rb

@@ -0,0 +1,169 @@
+module Oxblood
+  module Commands
+    module 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
+      #
+      # @param [String] key
+      #
+      # @return [Integer] the length of the list at key
+      # @return [RError] if the value stored at key is not a list
+      def llen(key)
+        run(:LLEN, key)
+      end
+
+      # Remove and get the first element in a list
+      # @see http://redis.io/commands/lpop
+      #
+      # @param [String] key
+      #
+      # @return [String, nil] the value of the first element,
+      #   or nil when key does not exist.
+      def lpop(key)
+        run(:LPOP, key)
+      end
+
+      # Prepend one or multiple values to a list
+      # @see http://redis.io/commands/lpush
+      #
+      # @param [String] key
+      # @param [Array] values to prepend
+      #
+      # @return [Integer] the length of the list after the push operations
+      def lpush(key, *values)
+        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
+      #
+      # @param [String] key
+      # @param [Integer] start index
+      # @param [Integer] stop index
+      #
+      # @return [Array] list of elements in the specified range
+      def lrange(key, start, stop)
+        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
+      #
+      # @param [String] key
+      #
+      # @return [String, nil] the value of the last element, or nil when key does
+      #   not exist
+      def rpop(key)
+        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
+      #
+      # @param [String] key
+      # @param [Array] values to add
+      #
+      # @return [Integer] the length of the list after the push operation
+      # @return [RError] if key holds a value that is not a list
+      def rpush(key, *values)
+        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
+    end
+  end
+end

data/lib/oxblood/commands/server.rb

@@ -0,0 +1,24 @@
+module Oxblood
+  module Commands
+    module Server
+      # Remove all keys from the current database
+      # @see http://redis.io/commands/flushdb
+      #
+      # @return [String] should always return 'OK'
+      def flushdb
+        run(:FLUSHDB)
+      end
+
+      # Returns information and statistics about the server in a format that is
+      # simple to parse by computers and easy to read by humans
+      # @see http://redis.io/commands/info
+      #
+      # @param [String] section used to select a specific section of information
+      #
+      # @return [String] raw redis server response as a collection of text lines.
+      def info(section = nil)
+        section ? run(:INFO, section) : run(:INFO)
+      end
+    end
+  end
+end