redstruct 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f29df0c24d1d453a2a24b5e32cf563d284e08d2
-  data.tar.gz: 26f083074180af497290197bb09a956d98e6c683
+  metadata.gz: 3e699e92aa673d70280aa80258169eaad2c8edad
+  data.tar.gz: f1de7e921d57040ae2e74d1cc1db2b481b25d5f8
 SHA512:
-  metadata.gz: 0564b2207e6b03a6e7109db3c634dd74ce33d891bfbfa23f0ad8531482c7a9ca93a02935901ef8edb4c8abaa0a9c8b7a6ff5a277ff199a95dd2d79548d59374a
-  data.tar.gz: b629606788ae08144cba7d154d9ecebe87d885f04fc74ea2472564a0b1e63559a9a50a8d44e14e583f9852341f622fe839095d3e461bf6697731462888d725b9
+  metadata.gz: d74321747fb7d5afa0d2f87ab1e7f6487b5e3a20289c071b5dd2a4ebb1068b601389de8d0e8003300436ae824331e6a5e9dc922e469503bdfb66ee6476270c37
+  data.tar.gz: 8b58b8d2c16aba6bc6efc9213b19d894fbad8a362a1466e372afa5fd448753f055219ef68596e18fc903eb929c579515bce05640c27bd50ff5d210227e78e8dd

data/README.md

@@ -1,5 +1,8 @@
 # Redstruct
 
+[![Build Status](https://travis-ci.org/npepinpe/redstruct.svg?branch=master)](https://travis-ci.org/npepinpe/redstruct)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/a97a31e37fa4432d8836169fa1999d34)](https://www.codacy.com/app/n.pepinpe/redstruct?utm_source=github.com&utm_medium=referral&utm_content=npepinpe/redstruct&utm_campaign=Badge_Grade)
+
 Provides higher level data structures in Ruby using standard Redis commands. Also provides basic object mapping for pre-existing types.
 
 ## Installation
@@ -34,17 +37,18 @@ Avoid using transactions; the Redis documentation suggests using Lua scripts whe
 
 ## TODO
 
-[x] Implement counters
-[x] Implement locks (blocking/non-blocking)
-[x] Implement queues
-[x] Implement basic types (set, string, list, hash)
-[ ] Implement SortedSet
-[ ] Implement stacks
-[ ] Discuss supporting pipelining vs. just using lua scripts (better interface for scripted extensions?)
-[ ] Design/discuss stored factory meta-data (i.e. keep track of created objects, clear said objects, etc.)
-[ ] Implement/redesign factory such that types, hls, etc., packages add methods as necessary (or not? discuss)
-[ ] Implement collections to leverage redis commands such as mget, mset, etc.
-[ ] Implement value transformers (read and write) to make reusing types with specially encoded objects easy
+- [x] Implement factory
+- [x] Implement counter
+- [x] Implement lock (blocking/non-blocking)
+- [x] Implement string
+- [x] Implement hash
+- [x] Implement set
+- [x] Implement list
+- [x] Implement script
+- [x] Implement sorted set
+- [ ] Design/discuss stored factory meta-data (i.e. keep track of created objects, clear said objects, etc.)
+- [ ] Implement collections to leverage redis commands such as mget, mset, etc.
+- [ ] Implement value transformers (read and write) to make reusing types with specially encoded objects easy
 
 
 ## Contributing

data/Rakefile

@@ -1,7 +1,6 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
-
-Bundler.require(:default, :development)
+Bundler.require(:default, :rake)
 
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
@@ -11,8 +10,9 @@ end
 
 task default: :test
 
-require 'yard/defscript_handler'
 YARD::Rake::YardocTask.new do |t|
-  t.files   = ['lib/**/*.rb']
-  t.options = ['--output-dir=./docs']
+  require 'yard/defscript_handler'
+  t.files   = ['lib/redstruct/*.rb']
+  t.options = ['--output-dir=./docs', '--no-private']
+  t.stats_options = ['--list-undoc']
 end

data/lib/redstruct/all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Convenience file to include the gem + all known structs
+require 'redstruct'
+
+# Structs; when creating a new one, add it here!
+require 'redstruct/counter'
+require 'redstruct/hash'
+require 'redstruct/list'
+require 'redstruct/lock'
+require 'redstruct/set'
+require 'redstruct/sorted_set'
+require 'redstruct/sorted_set/slice'
+require 'redstruct/string'

data/lib/redstruct/configuration.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 module Redstruct
+  # Simple class holding the Redstruct configuration
   class Configuration
-    # @return [ConnectionPool] The Redis-rb connection pool to use
-    attr_accessor :connection_pool
+    # @return [ConnectionPool, Redis] the default redis-rb connection, or a pool of said connections
+    attr_accessor :default_connection
 
-    # @return [::String] Default namespace for factories
-    attr_accessor :namespace
+    # @return [String] Default namespace for factories
+    attr_accessor :default_namespace
 
     def initialize
-      @connection_pool = nil
-      @namespace = nil
+      @default_connection = nil
+      @default_namespace = nil
     end
   end
 end

data/lib/redstruct/connection_proxy.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'redis'
+require 'connection_pool'
+require 'redstruct/utils/inspectable'
+require 'redstruct/error'
+
+module Redstruct
+  # Connection proxy class for the ConnectionPool
+  class ConnectionProxy
+    include Redstruct::Utils::Inspectable
+
+    # @return [Array<Symbol>] List of methods from the Redis class that we don't want to proxy
+    NON_COMMAND_METHODS = %i[[] []= _eval _scan method_missing call dup inspect to_s].freeze
+
+    # @param [Redis, ConnectionPool<Redis>] pool_or_conn a redis connection, or a pool of redis connections
+    # @raise [ArgumentError] raises an exception if the argument is not one of the required classes
+    def initialize(pool_or_conn)
+      case pool_or_conn
+      when ConnectionPool
+        @pool = pool_or_conn
+      when Redis
+        @redis = pool_or_conn
+      else
+        raise(ArgumentError, 'requires an instance of ConnectionPool or Redis to proxy to')
+      end
+    end
+
+    # Executes the given block by first fixing a thread local connection from the pool,
+    # such that all redis commands executed within the block are on the same connection.
+    # This is necessary when doing pipelining, or multi/exec stuff
+    # @yield [Redis] a direct redis connection
+    # @return [Object] whatever the passed block evaluates to, nil otherwise
+    def with(&_block)
+      unless block_given?
+        Redstruct.logger.warn('do not Redstruct::ConnectionProxy#with with no block')
+        return
+      end
+
+      connection = @redis || Thread.current[:__redstruct_connection]
+      result = if connection.nil?
+        @pool.with do |c|
+          begin
+            Thread.current[:__redstruct_connection] = c
+            yield(c)
+          ensure
+            Thread.current[:__redstruct_connection] = nil
+          end
+        end
+      else
+        yield(connection)
+      end
+
+      return result
+    end
+
+    # While slower on load, defining all methods that we want to pipe to one of the connections results in
+    # faster calls at runtime, and gives us the convenience of not going through the pool.with everytime.
+    Redis.public_instance_methods(false).each do |method|
+      next if NON_COMMAND_METHODS.include?(method) || method_defined?(method)
+      class_eval <<~METHOD, __FILE__, __LINE__ + 1
+        # Proxy method for Redis##{method} to work with a connection pool
+        # Uses Redstruct::ConnectionProxy#with to obtain a connection (or the connection) and executes the method on it
+        def #{method}(*args, &block)
+          with { |c| c.#{method}(*args, &block) }
+        end
+      METHOD
+    end
+
+    # @!group redis-rb polyfills
+    # The following methods are methods not currently implemented in redis-rb,
+    # or only in trunk; they should be remove once support is wide-spread
+
+    # see: https://redis.io/commands/zlexcount
+    # zlexcount is not supported as of redis-rb 3.3.2
+    def zlexcount(key, min, max)
+      with do |c|
+        c.synchronize do |client|
+          client.call([:zlexcount, key, min, max])
+        end
+      end
+    end
+
+    # @!endgroup
+
+    # Necessary when overwriting method_missing, so that respond_to? work properly
+    # @param [String, Symbol] _method the method name
+    # @param [Boolean] _include_private if true, also looks up private methods
+    # @return [Boolean] true if responding through method_missing, false otherwise
+    def respond_to_missing?(_method, _include_private = false)
+      true
+    end
+    private :respond_to_missing?
+
+    # Fallback when calling methods we may not have dynamically created above
+    # @param [String, Symbol] method the called method name
+    # @param [Array<Object>] args the arguments it was called with
+    # @param [Proc] block optionally, the block it was called with
+    # @return [Object] whatever the method returns
+    def method_missing(method, *args, &block)
+      with do |c|
+        if c.respond_to?(method)
+          c.public_send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    # @!visibility private
+    def inspectable_attributes # :nodoc:
+      transport = if !@pool.nil?
+        'connection_pool'
+      elsif !@redis.nil?
+        'redis'
+      else
+        'nothing'
+      end
+
+      return { transport: transport }
+    end
+  end
+end

data/lib/redstruct/counter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'redstruct/string'
+
+module Redstruct
+  # Additional counter operations, using redis string values.
+  class Counter < Redstruct::String
+    # @return [Integer] the default increment value of the counter, defaults to 1
+    attr_reader :default_increment
+
+    # @return [Integer] the default maximum value of the counter, leave nil unless you want the cycle effect
+    attr_reader :max
+
+    # @param [Integer] by the default increment value
+    # @param [Integer, nil] max the default max value of the counter, leave nil unless you want cyclical counters
+    def initialize(by: 1, max: nil, **options)
+      super(**options)
+      @default_increment = by
+      @max = max
+    end
+
+    # @return [Integer] the stored value as an integer
+    def get
+      return super.to_i
+    end
+
+    # Sets the new value, converting it to int first
+    # @see Redstruct::String#set
+    # @param [#to_i] value the updated counter value
+    # @return [Boolean] True if set, false otherwise
+    def set(value, **options)
+      super(value.to_i, **options)
+    end
+
+    # @param [#to_i] value the object to store
+    # @return [Integer] the old value before setting it
+    def getset(value)
+      return super(value.to_i).to_i
+    end
+
+    # Increments the counter by the given value. If max is given, will loop around and start again from 0 (will increment by (current_value + by) % max).
+    # @param [Integer, nil] by defaults to @increment, used to increment the underlying counter
+    # @param [Integer, nil] max if non-nil, the counter will loop and start over from 0 when it reaches max
+    # @example
+    #   pry> counter.increment(by: 10, max: 5) # returns 0, since 10 % 5 == 0
+    #   pry> counter.increment(by: 9, max: 5) # returns 4
+    # @return [Integer] the updated value
+    def increment(by: nil, max: nil)
+      by ||= @default_increment
+      max ||= @max
+
+      value = if max.nil?
+        self.connection.incrby(@key, by.to_i).to_i
+      else
+        ring_increment_script(keys: @key, argv: [by.to_i, max.to_i]).to_i
+      end
+
+      return value
+    end
+
+    # Decrements the counter by the given value. If max is given, will loop around and start again from 0 (will decrement by (current_value + by) % max).
+    # @param [Integer, nil] by defaults to @increment, used to increment the underlying counter
+    # @param [Integer, nil] max if non-nil, the counter will loop and start over from 0 when it reaches max
+    # @example
+    #   pry> counter.decrement(by: 10, max: 5) # returns 0, since 10 % 5 == 0
+    #   pry> counter.decrement(by: 9, max: 5) # returns -4
+    # @return [Integer] the updated value
+    def decrement(by: nil, max: nil)
+      by ||= @default_increment
+      by = -by.to_i
+
+      max ||= @max
+      max = -max unless max.nil?
+
+      return increment(by: by, max: max)
+    end
+
+    defscript :ring_increment_script, <<~LUA
+      local by = tonumber(ARGV[1])
+      local max = tonumber(ARGV[2])
+      local current = redis.call('get', KEYS[1])
+      local value = current and tonumber(current) or 0
+
+      value = (value + by) % max
+      redis.call('set', KEYS[1], value)
+
+      return value
+    LUA
+    protected :ring_increment_script
+
+    # @!visibility private
+    def inspectable_attributes
+      super.merge(max: @max, by: @default_increment)
+    end
+  end
+end

data/lib/redstruct/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Redstruct
   # Used to provide a single base error type to filter all errors coming from the gem.
   class Error < StandardError

data/lib/redstruct/factory/object.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'redstruct/utils/inspectable'
+
+module Redstruct
+  class Factory
+    # Base class for all objects a factory can produce
+    class Object
+      include Redstruct::Utils::Inspectable
+
+      # @return [Redstruct::Factory] factory which was used to create the object
+      attr_reader :factory
+
+      # @param [Redstruct::Factory] factory the factory which produced the object
+      def initialize(factory:)
+        @factory = factory
+      end
+
+      # Convenience accessor for the factory's connection
+      # @return [Redstruct::ConnectionProxy]
+      def connection
+        return @factory.connection
+      end
+
+      # # @!visibility private
+      def inspectable_attributes
+        { factory: @factory }
+      end
+    end
+  end
+end

data/lib/redstruct/factory.rb

@@ -1,85 +1,124 @@
 # frozen_string_literal: true
+
+require 'redstruct/error'
+require 'redstruct/connection_proxy'
+require 'redstruct/utils/inspectable'
+require 'redstruct/utils/iterable'
+
+# Default objects; the rest you have to require
+require 'redstruct/factory/object'
+require 'redstruct/struct'
+require 'redstruct/script'
+
 module Redstruct
   # Main interface of the gem; this class should be used to build all Redstruct
   # objects, even when deserializing them.
   class Factory
-    include Redstruct::Utils::Inspectable, Redstruct::Factory::Creation
-    extend Redstruct::Factory::Deserialization
+    include Redstruct::Utils::Inspectable
+    include Redstruct::Utils::Iterable
+
+    # @return [String] namespace used to prefix the keys of all objects created by this factory
+    attr_reader :namespace
 
-    # @return [Connection] The connection proxy to use when executing commands. Shared by all factory produced objects.
+    # @return [Redstruct::ConnectionProxy] connection proxy used to execute commands
     attr_reader :connection
 
-    # @param [Redstruct::Connection] connection connection to use for all objects built by the factory
-    # @param [ConnectionPool] pool pool to use to build a connection from if no connection param given
-    # @param [::String] namespace all objects build from the factory will have their keys namespaced under this one
-    # @return [Factory]
-    def initialize(connection: nil, pool: nil, namespace: nil)
-      namespace ||= Redstruct.config.namespace
-
-      if connection.nil?
-        pool ||= Redstruct.config.connection_pool
-        raise(Redstruct::Error, 'A connection pool is required to create a factory, but none was given') if pool.nil?
-        connection = Redstruct::Connection.new(pool)
-      end
+    # @param [Redstruct::ConnectionProxy] connection connection to use for all objects built by the factory
+    # @param [String] namespace optional; all objects built from the factory will have their keys prefixed with this
+    # @raise [ArgumentError] raised if connection is not nil, and not a Redstruct::ConnectionProxy
+    # @return [Redstruct::Factory]
+    def initialize(connection: nil, namespace: nil)
+      namespace ||= Redstruct.config.default_namespace
+      connection ||= Redstruct::ConnectionProxy.new(Redstruct.config.default_connection)
+
+      raise ArgumentError, 'connection should be a Redstruct::ConnectionProxy' unless connection.is_a?(Redstruct::ConnectionProxy)
 
       @connection = connection
-      @namespace = namespace
-      @script_cache = {}.tap { |hash| hash.extend(MonitorMixin) }
+      @namespace = namespace.to_s
     end
 
     # Returns a namespaced version of the key (unless already namespaced)
-    # @param [String] key the key to isolate/namespace
+    # @param [String] key the key to namespace
     # @return [String] namespaced version of the key (or the key itself if already namespaced)
-    def isolate(key)
-      return @namespace.nil? || key.start_with?(@namespace) ? key : "#{@namespace}:#{key}"
-    end
+    def prefix(key)
+      prefixed = key
+      prefixed = "#{@namespace}:#{key}" unless @namespace.empty? || key.start_with?("#{@namespace}:")
 
-    # Iterates over the keys of this factory using the Redis scan command
-    # For more about the scan command, see https://redis.io/commands/scan
-    # @param [String] match will prepend the factory namespace to the match string; see the redis documentation for the syntax
-    # @param [Integer] count maximum number of items returned per iteration
-    # @param [Integer] max maximum number of iterations; if none given, could potentially never terminate
-    # @return [Enumerator::Lazy] if no block given, returns an enumerator that you can chain with others
-    def each(match: '*', count: nil, max: 10_000, &block)
-      options = { match: isolate(match) }
-      options[:count] = count.to_i unless count.nil?
-
-      enumerator = @connection.scan_each(options)
-      enumerator = enumerator.each_slice(count) unless count.nil?
-
-      # creates a temporary enumerator which limits the number of possible iterations, ensuring this eventually finishes
-      unless max.nil?
-        unbounded_enumerator = enumerator
-        enumerator = Enumerator.new do |yielder|
-          iterations = 0
-          loop do
-            yielder << unbounded_enumerator.next
-            iterations += 1
-            raise StopIteration if iterations == max
-          end
-        end
-      end
+      return prefixed
+    end
 
-      return enumerator unless block_given?
-      return enumerator.each(&block)
+    # Use redis-rb scan_each method to iterate over particular keys
+    # @
+    # @return [Enumerator] base enumerator to iterate of the namespaced keys
+    def to_enum(match: '*', count: 10)
+      return @connection.scan_each(match: prefix(match), count: count)
     end
 
     # Deletes all keys created by the factory. By defaults will iterate at most of 500 million keys
     # @param [Hash] options accepts the options as given in each
     # @see Redstruct::Factory#each
-    def delete_all(options = {})
-      return each({ match: '*', count: 500, max: 1_000_000 }.merge(options)) do |keys|
+    def delete(options = {})
+      return each({ match: '*', count: 500, max_iterations: 1_000_000, batch_size: 500 }.merge(options)) do |keys|
         @connection.del(*keys)
       end
     end
 
-    # :nocov:
+    # @!group Factory methods
 
-    # Helper method for serialization
-    def inspectable_attributes
-      return { namespace: @namespace, script_cache: @script_cache.keys }
+    # Returns a factory for a sub namespace.
+    # @example Given a factory `f` with namespace fact:first
+    #   f.factory('second') # => Redstruct::Factory: namespace: <"fact:first:second">>
+    # @return [Factory] namespaced factory
+    def factory(namespace)
+      return self.class.new(connection: @connection, namespace: prefix(namespace))
+    end
+
+    # Creates using this factory's connection
+    # @see Redstruct::Script#new
+    # @return [Redstruct::Script] script sharing the factory connection
+    def script(script, **options)
+      return Redstruct::Script.new(script: script, connection: @connection, **options)
     end
 
-    # :nocov:
+    # Creates a lock for the given resource within this factory
+    # @see Redstruct::Lock#new
+    # @return [Redstruct::Lock] lock for the given resource within this factory
+    def lock(resource, **options)
+      return Redstruct::Lock.new(resource, factory: self, **options)
+    end
+
+    # Factory methods for struct classes
+    {
+      Counter: :counter,
+      Hash: :hashmap,
+      List: :list,
+      Set: :set,
+      SortedSet: :sorted_set,
+      String: :string,
+      Struct: :struct
+    }.each do |class_name, method_name|
+      unless defined?(class_name)
+        Redstruct.logger.warn("cannot define factory method #{method_name} for non-existing class Redstruct::#{class_name}")
+        next
+      end
+
+      if method_defined?(method_name)
+        Redstruct.logger.warn("trying to redefine Redstruct::Factory##{method_name}; already defined?")
+        next
+      end
+
+      class_eval <<~METHOD, __FILE__, __LINE__ + 1
+        def #{method_name}(key, **options)
+          return Redstruct::#{class_name}.new(key: prefix(key), factory: self, **options)
+        end
+      METHOD
+    end
+
+    # @!endgroup
+
+    # # @!visibility private
+    def inspectable_attributes
+      return { namespace: @namespace, connection: @connection }
+    end
   end
 end

data/lib/redstruct/hash.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'redstruct/struct'
+require 'redstruct/utils/iterable'
+
+module Redstruct
+  # Class to manipulate redis hashes, modeled after Ruby's Hash class.
+  class Hash < Redstruct::Struct
+    include Redstruct::Utils::Iterable
+
+    # Returns the value at key
+    # @param [#to_s] key the hash key
+    # @return [nil, String] the value at key, or nil if nothing
+    def [](key)
+      return self.connection.hget(@key, key)
+    end
+
+    # Returns the value at key
+    # @param [Array<#to_s>] keys a list of keys to fetch; can be only one
+    # @return [Hash<String, String>] if only one key was passed, then return the value for it; otherwise returns a Ruby hash
+    #                                where each key in the `keys` is mapped to the value returned by redis
+    def get(*keys)
+      return self.connection.hget(@key, keys.first) if keys.size == 1
+      return self.connection.mapped_hmget(@key, *keys).reject { |_, v| v.nil? }
+    end
+
+    # Sets or updates the value at key
+    # @param [#to_s] key the hash key
+    # @param [#to_s] value the new value to set
+    # @return [Boolean] true if the field was set (not updated!), false otherwise
+    def []=(key, value)
+      set(key, value, overwrite: true)
+    end
+
+    # Sets or updates the value at key
+    # @param [#to_s] key the hash key
+    # @param [#to_s] value the new value to set
+    # @return [Boolean] true if the field was set (not updated!), false otherwise
+    def set(key, value, overwrite: true)
+      result = if overwrite
+        self.connection.hset(@key, key, value)
+      else
+        self.connection.hsetnx(@key, key, value)
+      end
+
+      return coerce_bool(result)
+    end
+
+    # Updates the underlying redis hash using the given Ruby hash's key/value mapping
+    # @param [Hash] hash the key/value mapping to use
+    # @return [Boolean] true if updated, false otherwise
+    def update(hash)
+      coerce_bool(self.connection.mapped_hmset(@key, hash))
+    end
+
+    # Removes all items for the given keys
+    # @param [Array<#to_s>] keys the list of keys to remove
+    # @return [Integer] the number of keys removed
+    def remove(*keys)
+      return self.connection.hdel(@key, keys)
+    end
+
+    # Checks if a key has a value
+    # @param [#to_s] key the key to check for
+    # @return [Boolean] true if the key has a value associated, false otherwise
+    def key?(key)
+      return coerce_bool(self.connection.hexists(@key, key))
+    end
+
+    # Increments the value at the given key
+    # @param [#to_s] key the hash key
+    # @param [Integer, Float] by defaults to 1
+    # @return [Integer, Float] returns the incremented value
+    def increment(key, by: 1)
+      if by.is_a?(Float)
+        self.connection.hincrbyfloat(@key, key, by.to_f).to_f
+      else
+        self.connection.hincrby(@key, key, by.to_i).to_i
+      end
+    end
+
+    # Decrements the value at the given key
+    # @param [#to_s] key the hash key
+    # @param [Integer, Float] by defaults to 1
+    # @return [Integer, Float] returns the decremented value
+    def decrement(key, by: 1)
+      return increment(key, by: -by)
+    end
+
+    # @return [Boolean] true if the hash contains no elements
+    def empty?
+      return !exists?
+    end
+
+    # Loads all the hash members in memory
+    # NOTE: if the hash is expected to be large, use to_enum
+    # @return [Hash<String, String>] all key value pairs stored on redis
+    def to_h
+      return self.connection.hgetall(@key)
+    end
+
+    # @return [Array<String>] a list of all hash keys with values associated
+    def keys
+      return self.connection.hkeys(@key)
+    end
+
+    # @return [Array<Strign>] a list of all hash values
+    def values
+      return self.connection.hvals(@key)
+    end
+
+    # @return [Integer] the number of key value pairs stored for this hash
+    def size
+      return self.connection.hlen(@key)
+    end
+
+    # Use redis-rb hscan_each method to iterate over particular keys
+    # @return [Enumerator] base enumerator to iterate of the namespaced keys
+    def to_enum(match: '*', count: 10)
+      return self.connection.hscan_each(@key, match: match, count: count)
+    end
+  end
+end