ultra-smart-kit 0.0.1

data/redis-5.4.1/lib/redis/errors.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Redis
+  # Base error for all redis-rb errors.
+  class BaseError < StandardError
+  end
+
+  # Raised by the connection when a protocol error occurs.
+  class ProtocolError < BaseError
+    def initialize(reply_type)
+      super(<<-EOS.gsub(/(?:^|\n)\s*/, " "))
+        Got '#{reply_type}' as initial reply byte.
+        If you're in a forking environment, such as Unicorn, you need to
+        connect to Redis after forking.
+      EOS
+    end
+  end
+
+  # Raised by the client when command execution returns an error reply.
+  class CommandError < BaseError
+  end
+
+  class PermissionError < CommandError
+  end
+
+  class WrongTypeError < CommandError
+  end
+
+  class OutOfMemoryError < CommandError
+  end
+
+  if defined?(RedisClient::NoScriptError)
+    class NoScriptError < CommandError
+    end
+  end
+
+  # Base error for connection related errors.
+  class BaseConnectionError < BaseError
+  end
+
+  # Raised when connection to a Redis server cannot be made.
+  class CannotConnectError < BaseConnectionError
+  end
+
+  # Raised when connection to a Redis server is lost.
+  class ConnectionError < BaseConnectionError
+  end
+
+  # Raised when performing I/O times out.
+  class TimeoutError < BaseConnectionError
+  end
+
+  # Raised when the connection was inherited by a child process.
+  class InheritedError < BaseConnectionError
+  end
+
+  # Generally raised during Redis failover scenarios
+  class ReadOnlyError < BaseConnectionError
+  end
+
+  # Raised when client options are invalid.
+  class InvalidClientOptionError < BaseError
+  end
+
+  class SubscriptionError < BaseError
+  end
+end

data/redis-5.4.1/lib/redis/hash_ring.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'digest/md5'
+
+class Redis
+  class HashRing
+    POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+    attr_reader :ring, :sorted_keys, :replicas, :nodes
+
+    # nodes is a list of objects that have a proper to_s representation.
+    # replicas indicates how many virtual points should be used pr. node,
+    # replicas are required to improve the distribution.
+    def initialize(nodes = [], replicas = POINTS_PER_SERVER)
+      @replicas = replicas
+      @ring = {}
+      @nodes = []
+      @sorted_keys = []
+      nodes.each do |node|
+        add_node(node)
+      end
+    end
+
+    # Adds a `node` to the hash ring (including a number of replicas).
+    def add_node(node)
+      @nodes << node
+      @replicas.times do |i|
+        key = server_hash_for("#{node.id}:#{i}")
+        @ring[key] = node
+        @sorted_keys << key
+      end
+      @sorted_keys.sort!
+    end
+
+    def remove_node(node)
+      @nodes.reject! { |n| n.id == node.id }
+      @replicas.times do |i|
+        key = server_hash_for("#{node.id}:#{i}")
+        @ring.delete(key)
+        @sorted_keys.reject! { |k| k == key }
+      end
+    end
+
+    # get the node in the hash ring for this key
+    def get_node(key)
+      hash = hash_for(key)
+      idx = binary_search(@sorted_keys, hash)
+      @ring[@sorted_keys[idx]]
+    end
+
+    def iter_nodes(key)
+      return [nil, nil] if @ring.empty?
+
+      crc = hash_for(key)
+      pos = binary_search(@sorted_keys, crc)
+      @ring.size.times do |n|
+        yield @ring[@sorted_keys[(pos + n) % @ring.size]]
+      end
+    end
+
+    private
+
+    def hash_for(key)
+      Zlib.crc32(key)
+    end
+
+    def server_hash_for(key)
+      Digest::MD5.digest(key).unpack1("L>")
+    end
+
+    # Find the closest index in HashRing with value <= the given value
+    def binary_search(ary, value)
+      upper = ary.size
+      lower = 0
+
+      while lower < upper
+        mid = (lower + upper) / 2
+        if ary[mid] > value
+          upper = mid
+        else
+          lower = mid + 1
+        end
+      end
+
+      upper - 1
+    end
+  end
+end

data/redis-5.4.1/lib/redis/pipeline.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+class Redis
+  class PipelinedConnection
+    attr_accessor :db
+
+    def initialize(pipeline, futures = [], exception: true)
+      @pipeline = pipeline
+      @futures = futures
+      @exception = exception
+    end
+
+    include Commands
+
+    def pipelined
+      yield self
+    end
+
+    def multi
+      transaction = MultiConnection.new(@pipeline, @futures)
+      send_command([:multi])
+      size = @futures.size
+      yield transaction
+      multi_future = MultiFuture.new(@futures[size..-1])
+      @pipeline.call_v([:exec]) do |result|
+        multi_future._set(result)
+      end
+      @futures << multi_future
+      multi_future
+    end
+
+    private
+
+    def synchronize
+      yield self
+    end
+
+    def send_command(command, &block)
+      future = Future.new(command, block, @exception)
+      @pipeline.call_v(command) do |result|
+        future._set(result)
+      end
+      @futures << future
+      future
+    end
+
+    def send_blocking_command(command, timeout, &block)
+      future = Future.new(command, block, @exception)
+      @pipeline.blocking_call_v(timeout, command) do |result|
+        future._set(result)
+      end
+      @futures << future
+      future
+    end
+  end
+
+  class MultiConnection < PipelinedConnection
+    def multi
+      raise Redis::BaseError, "Can't nest multi transaction"
+    end
+
+    private
+
+    # Blocking commands inside transaction behave like non-blocking.
+    # It shouldn't be done though.
+    # https://redis.io/commands/blpop/#blpop-inside-a-multi--exec-transaction
+    def send_blocking_command(command, _timeout, &block)
+      send_command(command, &block)
+    end
+  end
+
+  class FutureNotReady < RuntimeError
+    def initialize
+      super("Value will be available once the pipeline executes.")
+    end
+  end
+
+  class Future < BasicObject
+    FutureNotReady = ::Redis::FutureNotReady.new
+
+    def initialize(command, coerce, exception)
+      @command = command
+      @object = FutureNotReady
+      @coerce = coerce
+      @exception = exception
+    end
+
+    def inspect
+      "<Redis::Future #{@command.inspect}>"
+    end
+
+    def _set(object)
+      @object = @coerce ? @coerce.call(object) : object
+      value
+    end
+
+    def value
+      ::Kernel.raise(@object) if @exception && @object.is_a?(::StandardError)
+      @object
+    end
+
+    def is_a?(other)
+      self.class.ancestors.include?(other)
+    end
+
+    def class
+      Future
+    end
+  end
+
+  class MultiFuture < Future
+    def initialize(futures)
+      @futures = futures
+      @command = [:exec]
+      @object = FutureNotReady
+    end
+
+    def _set(replies)
+      @object = if replies
+        @futures.map.with_index do |future, index|
+          future._set(replies[index])
+          future.value
+        end
+      else
+        replies
+      end
+    end
+  end
+end

data/redis-5.4.1/lib/redis/subscribe.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+class Redis
+  class SubscribedClient
+    def initialize(client)
+      @client = client
+      @write_monitor = Monitor.new
+    end
+
+    def call_v(command)
+      @write_monitor.synchronize do
+        @client.call_v(command)
+      end
+    end
+
+    def subscribe(*channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block)
+    end
+
+    def subscribe_with_timeout(timeout, *channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block, timeout)
+    end
+
+    def psubscribe(*channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block)
+    end
+
+    def psubscribe_with_timeout(timeout, *channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block, timeout)
+    end
+
+    def ssubscribe(*channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block)
+    end
+
+    def ssubscribe_with_timeout(timeout, *channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block, timeout)
+    end
+
+    def unsubscribe(*channels)
+      call_v([:unsubscribe, *channels])
+    end
+
+    def punsubscribe(*channels)
+      call_v([:punsubscribe, *channels])
+    end
+
+    def sunsubscribe(*channels)
+      call_v([:sunsubscribe, *channels])
+    end
+
+    def close
+      @client.close
+    end
+
+    protected
+
+    def subscription(start, stop, channels, block, timeout = 0)
+      sub = Subscription.new(&block)
+
+      case start
+      when "ssubscribe" then channels.each { |c| call_v([start, c]) } # avoid cross-slot keys
+      else call_v([start, *channels])
+      end
+
+      while event = @client.next_event(timeout)
+        if event.is_a?(::RedisClient::CommandError)
+          raise Client::ERROR_MAPPING.fetch(event.class), event.message
+        end
+
+        type, *rest = event
+        if callback = sub.callbacks[type]
+          callback.call(*rest)
+        end
+        break if type == stop && rest.last == 0
+      end
+      # No need to unsubscribe here. The real client closes the connection
+      # whenever an exception is raised (see #ensure_connected).
+    end
+  end
+
+  class Subscription
+    attr :callbacks
+
+    def initialize
+      @callbacks = {}
+      yield(self)
+    end
+
+    def subscribe(&block)
+      @callbacks["subscribe"] = block
+    end
+
+    def unsubscribe(&block)
+      @callbacks["unsubscribe"] = block
+    end
+
+    def message(&block)
+      @callbacks["message"] = block
+    end
+
+    def psubscribe(&block)
+      @callbacks["psubscribe"] = block
+    end
+
+    def punsubscribe(&block)
+      @callbacks["punsubscribe"] = block
+    end
+
+    def pmessage(&block)
+      @callbacks["pmessage"] = block
+    end
+
+    def ssubscribe(&block)
+      @callbacks["ssubscribe"] = block
+    end
+
+    def sunsubscribe(&block)
+      @callbacks["sunsubscribe"] = block
+    end
+
+    def smessage(&block)
+      @callbacks["smessage"] = block
+    end
+  end
+end

data/redis-5.4.1/lib/redis/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Redis
+  VERSION = '5.4.1'
+end

data/redis-5.4.1/lib/redis.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "redis-client"
+
+require "monitor"
+require "redis/errors"
+require "redis/commands"
+
+class Redis
+  BASE_PATH = __dir__
+  Deprecated = Class.new(StandardError)
+
+  class << self
+    attr_accessor :silence_deprecations, :raise_deprecations
+
+    def deprecate!(message)
+      unless silence_deprecations
+        if raise_deprecations
+          raise Deprecated, message
+        else
+          ::Kernel.warn(message)
+        end
+      end
+    end
+  end
+
+  # soft-deprecated
+  # We added this back for older sidekiq releases
+  module Connection
+    class << self
+      def drivers
+        [RedisClient.default_driver]
+      end
+    end
+  end
+
+  include Commands
+
+  SERVER_URL_OPTIONS = %i(url host port path).freeze
+
+  # Create a new client instance
+  #
+  # @param [Hash] options
+  # @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection:
+  #   `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket
+  #    connection: `unix://[path to Redis socket]`. This overrides all other options.
+  # @option options [String] :host ("127.0.0.1") server hostname
+  # @option options [Integer] :port (6379) server port
+  # @option options [String] :path path to server socket (overrides host and port)
+  # @option options [Float] :timeout (1.0) timeout in seconds
+  # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
+  # @option options [String] :username Username to authenticate against server
+  # @option options [String] :password Password to authenticate against server
+  # @option options [Integer] :db (0) Database to select after connect and on reconnects
+  # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`
+  # @option options [String] :id ID for the client connection, assigns name to current connection by sending
+  #   `CLIENT SETNAME`
+  # @option options [Integer, Array<Integer, Float>] :reconnect_attempts Number of attempts trying to connect,
+  #   or a list of sleep duration between attempts.
+  # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
+  # @option options [String] :name The name of the server group to connect to.
+  # @option options [Array] :sentinels List of sentinels to contact
+  #
+  # @return [Redis] a new client instance
+  def initialize(options = {})
+    @monitor = Monitor.new
+    @options = options.dup
+    @options[:reconnect_attempts] = 1 unless @options.key?(:reconnect_attempts)
+    if ENV["REDIS_URL"] && SERVER_URL_OPTIONS.none? { |o| @options.key?(o) }
+      @options[:url] = ENV["REDIS_URL"]
+    end
+    inherit_socket = @options.delete(:inherit_socket)
+    @subscription_client = nil
+
+    @client = initialize_client(@options)
+    @client.inherit_socket! if inherit_socket
+  end
+
+  # Run code without the client reconnecting
+  def without_reconnect(&block)
+    @client.disable_reconnection(&block)
+  end
+
+  # Test whether or not the client is connected
+  def connected?
+    @client.connected? || @subscription_client&.connected?
+  end
+
+  # Disconnect the client as quickly and silently as possible.
+  def close
+    @client.close
+    @subscription_client&.close
+  end
+  alias disconnect! close
+
+  def with
+    yield self
+  end
+
+  def _client
+    @client
+  end
+
+  def pipelined(exception: true)
+    synchronize do |client|
+      client.pipelined(exception: exception) do |raw_pipeline|
+        yield PipelinedConnection.new(raw_pipeline, exception: exception)
+      end
+    end
+  end
+
+  def id
+    @client.id || @client.server_url
+  end
+
+  def inspect
+    "#<Redis client v#{Redis::VERSION} for #{id}>"
+  end
+
+  def dup
+    self.class.new(@options)
+  end
+
+  def connection
+    {
+      host: @client.host,
+      port: @client.port,
+      db: @client.db,
+      id: id,
+      location: "#{@client.host}:#{@client.port}"
+    }
+  end
+
+  private
+
+  def initialize_client(options)
+    if options.key?(:cluster)
+      raise "Redis Cluster support was moved to the `redis-clustering` gem."
+    end
+
+    if options.key?(:sentinels)
+      Client.sentinel(**options).new_client
+    else
+      Client.config(**options).new_client
+    end
+  end
+
+  def synchronize
+    @monitor.synchronize { yield(@client) }
+  end
+
+  def send_command(command, &block)
+    @monitor.synchronize do
+      @client.call_v(command, &block)
+    end
+  rescue ::RedisClient::Error => error
+    Client.translate_error!(error)
+  end
+
+  def send_blocking_command(command, timeout, &block)
+    @monitor.synchronize do
+      @client.blocking_call_v(timeout, command, &block)
+    end
+  end
+
+  def _subscription(method, timeout, channels, block)
+    if block
+      if @subscription_client
+        raise SubscriptionError, "This client is already subscribed"
+      end
+
+      begin
+        @subscription_client = SubscribedClient.new(@client.pubsub)
+        if timeout > 0
+          @subscription_client.send(method, timeout, *channels, &block)
+        else
+          @subscription_client.send(method, *channels, &block)
+        end
+      ensure
+        @subscription_client&.close
+        @subscription_client = nil
+      end
+    else
+      unless @subscription_client
+        raise SubscriptionError, "This client is not subscribed"
+      end
+
+      @subscription_client.call_v([method].concat(channels))
+    end
+  end
+end
+
+require "redis/version"
+require "redis/client"
+require "redis/pipeline"
+require "redis/subscribe"

data/ultra-smart-kit.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "ultra-smart-kit"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on redis"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/ultra-smart-kit" }
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: ultra-smart-kit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on redis
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- redis-5.4.1/CHANGELOG.md
+- redis-5.4.1/LICENSE
+- redis-5.4.1/README.md
+- redis-5.4.1/lib/redis.rb
+- redis-5.4.1/lib/redis/client.rb
+- redis-5.4.1/lib/redis/commands.rb
+- redis-5.4.1/lib/redis/commands/bitmaps.rb
+- redis-5.4.1/lib/redis/commands/cluster.rb
+- redis-5.4.1/lib/redis/commands/connection.rb
+- redis-5.4.1/lib/redis/commands/geo.rb
+- redis-5.4.1/lib/redis/commands/hashes.rb
+- redis-5.4.1/lib/redis/commands/hyper_log_log.rb
+- redis-5.4.1/lib/redis/commands/keys.rb
+- redis-5.4.1/lib/redis/commands/lists.rb
+- redis-5.4.1/lib/redis/commands/pubsub.rb
+- redis-5.4.1/lib/redis/commands/scripting.rb
+- redis-5.4.1/lib/redis/commands/server.rb
+- redis-5.4.1/lib/redis/commands/sets.rb
+- redis-5.4.1/lib/redis/commands/sorted_sets.rb
+- redis-5.4.1/lib/redis/commands/streams.rb
+- redis-5.4.1/lib/redis/commands/strings.rb
+- redis-5.4.1/lib/redis/commands/transactions.rb
+- redis-5.4.1/lib/redis/distributed.rb
+- redis-5.4.1/lib/redis/errors.rb
+- redis-5.4.1/lib/redis/hash_ring.rb
+- redis-5.4.1/lib/redis/pipeline.rb
+- redis-5.4.1/lib/redis/subscribe.rb
+- redis-5.4.1/lib/redis/version.rb
+- ultra-smart-kit.gemspec
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Andrey78/ultra-smart-kit
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []