redis-cluster 0.0.7

data/lib/redis_cluster/function.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'function/set'
+require_relative 'function/key'
+require_relative 'function/list'
+require_relative 'function/hash'
+require_relative 'function/string'
+require_relative 'function/sorted_set'
+require_relative 'function/scan'
+
+class RedisCluster
+
+  # Function include necessary redis function.
+  module Function
+    include Function::Set
+    include Function::Key
+    include Function::List
+    include Function::Hash
+    include Function::String
+    include Function::SortedSet
+    include Function::Scan
+  end
+end

data/lib/redis_cluster/function/hash.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+require 'redis'
+
+class RedisCluster
+  module Function
+
+    # Hash implement redis hashes commands. There will be some adjustment for cluster.
+    # see https://redis.io/commands#hash. Most of the code are copied from
+    # https://github.com/redis/redis-rb/blob/master/lib/redis.rb.
+    #
+    # SETTER = [:hdel, :hincrby, :hincrbyfloat, :hmset, :hset, :hsetnx]
+    # GETTER = [:hexists, :hget, :hgetall, :hkeys, :hlen, :hmget, :hstrlen, :hvals, :hscan]
+    module Hash
+
+      # Delete one or more hash fields.
+      #
+      # @param [String] key
+      # @param [String, Array<String>] field
+      # @return [Fixnum] the number of fields that were removed from the hash
+      def hdel(key, field)
+        call(key, [:hdel, key, field])
+      end
+
+      # Increment the integer value of a hash field by the given integer number.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @param [Fixnum] increment
+      # @return [Fixnum] value of the field after incrementing it
+      def hincrby(key, field, increment)
+        call(key, [:hincrby, key, field, increment])
+      end
+
+      # Increment the numeric value of a hash field by the given float number.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @param [Float] increment
+      # @return [Float] value of the field after incrementing it
+      def hincrbyfloat(key, field, increment)
+        call(key, [:hincrbyfloat, key, field, increment], transform: Redis::Floatify)
+      end
+
+      # Set one or more hash values.
+      #
+      # @example
+      #   redis.hmset("hash", "f1", "v1", "f2", "v2")
+      #     # => "OK"
+      #
+      # @param [String] key
+      # @param [Array<String>] attrs array of fields and values
+      # @return [String] `"OK"`
+      def hmset(key, *attrs)
+        call(key, [:hmset, key] + attrs)
+      end
+
+      # Set the string value of a hash field.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @param [String] value
+      # @return [Boolean] whether or not the field was **added** to the hash
+      def hset(key, field, value)
+        call(key, [:hset, key, field, value], transform: Redis::Boolify)
+      end
+
+      # Set the value of a hash field, only if the field does not exist.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @param [String] value
+      # @return [Boolean] whether or not the field was **added** to the hash
+      def hsetnx(key, field, value)
+        call(key, [:hsetnx, key, field, value], transform: Redis::Boolify)
+      end
+
+      # Determine if a hash field exists.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @return [Boolean] whether or not the field exists in the hash
+      def hexists(key, field)
+        call(key, [:hexists, key, field], transform: Redis::Boolify, read: true)
+      end
+
+      # Get the value of a hash field.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @return [String]
+      def hget(key, field)
+        call(key, [:hget, key, field], read: true)
+      end
+
+      # Get all the fields and values in a hash.
+      #
+      # @param [String] key
+      # @return [Hash<String, String>]
+      def hgetall(key)
+        call(key, [:hgetall, key], transform: Redis::Hashify, read: true)
+      end
+
+      # Get all the fields in a hash.
+      #
+      # @param [String] key
+      # @return [Array<String>]
+      def hkeys(key)
+        call(key, [:hkeys, key], read: true)
+      end
+
+      # Get all the values in a hash.
+      #
+      # @param [String] key
+      # @return [Array<String>]
+      def hvals(key)
+        call(key, [:hvals, key], read: true)
+      end
+
+      # Get the number of fields in a hash.
+      #
+      # @param [String] key
+      # @return [Fixnum] number of fields in the hash
+      def hlen(key)
+        call(key, [:hlen, key], read: true)
+      end
+
+      # Get the values of all the given hash fields.
+      #
+      # @example
+      #   redis.hmget("hash", "f1", "f2")
+      #     # => ["v1", "v2"]
+      #
+      # @param [String] key
+      # @param [Array<String>] fields array of fields
+      # @return [Array<String>] an array of values for the specified fields
+      def hmget(key, *fields)
+        call(key, [:hmget, key] + fields, read: true)
+      end
+
+      # Returns the string length of the value associated with field in the hash stored at key.
+      #
+      # @param [String] key
+      # @param [String] field
+      # @return [Fixnum] String lenght
+      def hstrlen(key, field)
+        call(key, [:hstrlen, key, field], read: true)
+      end
+    end
+  end
+end

data/lib/redis_cluster/function/key.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require 'redis'
+
+class RedisCluster
+  module Function
+
+    # Key implement redis keys commands. There will be some adjustment for cluster.
+    # see https://redis.io/commands#generic. Most of the code are copied from
+    # https://github.com/redis/redis-rb/blob/master/lib/redis.rb.
+    #
+    # SETTER = [:del, :expire, :pexpire, :restore]
+    # GETTER = [:exists, :ttl, :pttl, :type]
+    module Key
+
+      # Delete one key.
+      #
+      # @param [String] key
+      # @return [Boolean] whether the key was deleted or not
+      def del(key)
+        call(key, [:del, key], transform: Redis::Boolify)
+      end
+
+      # Set a key's time to live in seconds.
+      #
+      # @param [String] key
+      # @param [Fixnum] seconds time to live
+      # @return [Boolean] whether the timeout was set or not
+      def expire(key, seconds)
+        call(key, [:expire, key, seconds], transform: Redis::Boolify)
+      end
+
+      # Set a key's time to live in milliseconds.
+      #
+      # @param [String] key
+      # @param [Fixnum] milliseconds time to live
+      # @return [Boolean] whether the timeout was set or not
+      def pexpire(key, milliseconds)
+        call(key, [:pexpire, key, milliseconds], transform: Redis::Boolify)
+      end
+
+      # Determine if a key exists.
+      #
+      # @param [String] key
+      # @return [Boolean]
+      def exists(key)
+        call(key, [:exists, key], transform: Redis::Boolify, read: true)
+      end
+
+      # Get the time to live (in seconds) for a key.
+      #
+      # @param [String] key
+      # @return [Fixnum] remaining time to live in seconds.
+      #
+      # Starting with Redis 2.8 the return value in case of error changed:
+      #
+      #     - The command returns -2 if the key does not exist.
+      #     - The command returns -1 if the key exists but has no associated expire.
+      def ttl(key)
+        call(key, [:ttl, key], read: true)
+      end
+
+      # Get the time to live (in milliseconds) for a key.
+      #
+      # @param [String] key
+      # @return [Fixnum] remaining time to live in milliseconds
+      #
+      # Starting with Redis 2.8 the return value in case of error changed:
+      #
+      #     - The command returns -2 if the key does not exist.
+      #     - The command returns -1 if the key exists but has no associated expire.
+      def pttl(key)
+        call(key, [:pttl, key], read: true)
+      end
+
+      # Determine the type stored at key.
+      #
+      # @param [String] key
+      # @return [String] `string`, `list`, `set`, `zset`, `hash` or `none`
+      def type(key)
+        call(key, [:type, key], read: true)
+      end
+
+      # Create a key using the serialized value, previously obtained using DUMP.
+      #
+      # @param [String] key
+      # @param [String] ttl
+      # @param [String] serialized_value
+      # @param [Hash] options
+      #   - `replace: true`: replace existing key
+      # @return [String] `"OK"`
+      def restore(key, ttl, serialized_value, option = {})
+        args = [:restore, key, ttl, serialized_value]
+        args << 'REPLACE' if option[:replace]
+
+        call(key, args)
+      end
+
+      # Return a serialized version of the value stored at a key.
+      #
+      # @param [String] key
+      # @return [String] serialized_value
+      def dump(key)
+        call(key, [:dump, key], read: true)
+      end
+    end
+  end
+end

data/lib/redis_cluster/function/list.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class RedisCluster
+  module Function
+
+    # List implement redis lists commands. There will be some adjustment for cluster.
+    # see https://redis.io/commands#list. Most of the code are copied from
+    # https://github.com/redis/redis-rb/blob/master/lib/redis.rb.
+    #
+    # SETTER = [:linsert, :lpop, :lpush, :lpushx, :lrem, :lset, :ltrim, :rpop, :rpush, :rpushx]
+    # GETTER = [:lindex, :llen, :lrange]
+    module List
+
+      # Get the length of a list.
+      #
+      # @param [String] key
+      # @return [Fixnum]
+      def llen(key)
+        call(key, [:llen, key], read: true)
+      end
+
+      # Prepend one or more values to a list, creating the list if it doesn't exist
+      #
+      # @param [String] key
+      # @param [String, Array] value string value, or array of string values to push
+      # @return [Fixnum] the length of the list after the push operation
+      def lpush(key, value)
+        call(key, [:lpush, key, value])
+      end
+
+      # Prepend a value to a list, only if the list exists.
+      #
+      # @param [String] key
+      # @param [String] value
+      # @return [Fixnum] the length of the list after the push operation
+      def lpushx(key, value)
+        call(key, [:lpushx, key, value])
+      end
+
+      # Append one or more values to a list, creating the list if it doesn't exist
+      #
+      # @param [String] key
+      # @param [String] value
+      # @return [Fixnum] the length of the list after the push operation
+      def rpush(key, value)
+        call(key, [:rpush, key, value])
+      end
+
+      # Append a value to a list, only if the list exists.
+      #
+      # @param [String] key
+      # @param [String] value
+      # @return [Fixnum] the length of the list after the push operation
+      def rpushx(key, value)
+        call(key, [:rpushx, key, value])
+      end
+
+      # Remove and get the first element in a list.
+      #
+      # @param [String] key
+      # @return [String]
+      def lpop(key)
+        call(key, [:lpop, key])
+      end
+
+      # Remove and get the last element in a list.
+      #
+      # @param [String] key
+      # @return [String]
+      def rpop(key)
+        call(key, [:rpop, key])
+      end
+
+      # Get an element from a list by its index.
+      #
+      # @param [String] key
+      # @param [Fixnum] index
+      # @return [String]
+      def lindex(key, index)
+        call(key, [:lindex, key, index], read: true)
+      end
+
+      # Insert an element before or after another element in a list.
+      #
+      # @param [String] key
+      # @param [String, Symbol] where `BEFORE` or `AFTER`
+      # @param [String] pivot reference element
+      # @param [String] value
+      # @return [Fixnum] length of the list after the insert operation, or `-1`
+      #   when the element `pivot` was not found
+      def linsert(key, where, pivot, value)
+        call(key, [:linsert, key, where, pivot, value])
+      end
+
+      # Get a range of elements from a list.
+      #
+      # @param [String] key
+      # @param [Fixnum] start start index
+      # @param [Fixnum] stop stop index
+      # @return [Array<String>]
+      def lrange(key, start, stop)
+        call(key, [:lrange, key, start, stop], read: true)
+      end
+
+      # Remove elements from a list.
+      #
+      # @param [String] key
+      # @param [Fixnum] count number of elements to remove. Use a positive
+      #   value to remove the first `count` occurrences of `value`. A negative
+      #   value to remove the last `count` occurrences of `value`. Or zero, to
+      #   remove all occurrences of `value` from the list.
+      # @param [String] value
+      # @return [Fixnum] the number of removed elements
+      def lrem(key, count, value)
+        call(key, [:lrem, key, count, value])
+      end
+
+      # Set the value of an element in a list by its index.
+      #
+      # @param [String] key
+      # @param [Fixnum] index
+      # @param [String] value
+      # @return [String] `OK`
+      def lset(key, index, value)
+        call(key, [:lset, key, index, value])
+      end
+
+      # Trim a list to the specified range.
+      #
+      # @param [String] key
+      # @param [Fixnum] start start index
+      # @param [Fixnum] stop stop index
+      # @return [String] `OK`
+      def ltrim(key, start, stop)
+        call(key, [:ltrim, key, start, stop])
+      end
+    end
+  end
+end

data/lib/redis_cluster/function/scan.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require 'redis'
+
+class RedisCluster
+  module Function
+
+    # Scan is a collection of redis scan functions
+    module Scan
+      HSCAN = ->(v){ [v[0], v[1].each_slice(2).to_a] }
+      ZSCAN = ->(v){ [v[0], Redis::FloatifyPairs.call(v[1])] }
+
+      # Scan a sorted set
+      #
+      # @example Retrieve the first batch of key/value pairs in a hash
+      #   redis.zscan("zset", 0)
+      #
+      # @param [String, Integer] cursor the cursor of the iteration
+      # @param [Hash] options
+      #   - `:match => String`: only return keys matching the pattern
+      #   - `:count => Integer`: return count keys at most per iteration
+      #
+      # @return [String, Array<[String, Float]>] the next cursor and all found
+      #   members and scores
+      def zscan(key, cursor, options = {})
+        args = [:zscan, key, cursor]
+        args.push('MATCH', options[:match]) if options[:match]
+        args.push('COUNT', options[:count]) if options[:count]
+
+        call(key, args, transform: ZSCAN, read: true)
+      end
+
+      # Scan a hash
+      #
+      # @example Retrieve the first batch of key/value pairs in a hash
+      #   redis.hscan("hash", 0)
+      #
+      # @param [String, Integer] cursor the cursor of the iteration
+      # @param [Hash] options
+      #   - `:match => String`: only return keys matching the pattern
+      #   - `:count => Integer`: return count keys at most per iteration
+      #
+      # @return [String, Array<[String, String]>] the next cursor and all found keys
+      def hscan(key, cursor, options = {})
+        args = [:hscan, key, cursor]
+        args.push('MATCH', options[:match]) if options[:match]
+        args.push('COUNT', options[:count]) if options[:count]
+
+        call(key, args, transform: HSCAN, read: true)
+      end
+
+      # Scan a set
+      #
+      # @example Retrieve the first batch of keys in a set
+      #   redis.sscan("set", 0)
+      #
+      # @param [String, Integer] cursor the cursor of the iteration
+      # @param [Hash] options
+      #   - `:match => String`: only return keys matching the pattern
+      #   - `:count => Integer`: return count keys at most per iteration
+      #
+      # @return [String, Array<String>] the next cursor and all found members
+      def sscan(key, cursor, options = {})
+        args = [:sscan, key, cursor]
+        args.push('MATCH', options[:match]) if options[:match]
+        args.push('COUNT', options[:count]) if options[:count]
+
+        call(key, args, read: true)
+      end
+
+      # Convenient method for iterating a hash or sorted_set.
+      #
+      # @param [String] key
+      # @param [Hash] options
+      #   - `:match => String`: only return keys matching the pattern
+      #   - `:count => Integer`: return count keys at most per iteration
+      [:zscan, :hscan, :sscan].each do |method|
+        define_method "#{method}_each" do |key, options = {}, &block|
+          return if block.nil?
+
+          cursor = '0'
+          loop do
+            cursor, values = public_send(method, key, cursor, options)
+            values.each(&block)
+            break if cursor == '0'
+          end
+        end
+      end
+    end
+  end
+end