Roughly porting

Author: supercaracal

.gitignore

@@ -0,0 +1,3 @@
+.bundle
+*.gem
+Gemfile.lock

.rubocop.yml

@@ -0,0 +1,37 @@
+---
+require:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-minitest
+
+# https://rubocop.readthedocs.io/en/latest/
+AllCops:
+  TargetRubyVersion: 2.7
+  DisplayCopNames: true
+  NewCops: enable
+
+Metrics/AbcSize:
+  Exclude:
+    - 'test/**/*'
+
+Metrics/ClassLength:
+  Max: 400
+
+Metrics/MethodLength:
+  Exclude:
+    - 'test/**/*'
+
+Layout/LineLength:
+  Max: 200
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Gemspec/RequiredRubyVersion:
+  Enabled: false

Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec name: 'redis-cluster-client'
+
+gem 'minitest'
+gem 'rake'
+gem 'rubocop'
+gem 'rubocop-minitest', require: false
+gem 'rubocop-performance', require: false
+gem 'rubocop-rake', require: false

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 redis-rb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,11 @@
+[![Gem Version](https://badge.fury.io/rb/redis-cluster-client.svg)](https://badge.fury.io/rb/redis-cluster-client)
+
 TODO
+===============================================================================
+
+```ruby
+cli = RedisClient.cluster(nodes: %w[redis://127.0.0.1:7000], replica: false).new_client
+
+cli.call('PING')
+#=> PONG
+```

Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+
+task default: :test
+
+desc 'execute all test'
+Rake::TestTask.new :test do |t|
+  t.libs << :test
+  t.libs << :lib
+  t.test_files = Dir['test/**/test_*.rb']
+end

bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'irb'
+require 'bundler/setup'
+require 'redis_client'
+require 'redis_cluster_client'
+
+IRB.start(File.expand_path('..', __dir__))

docs/CLASS_DIAGRAM.md

@@ -0,0 +1,250 @@
+```mermaid
+classDiagram
+  class RedisClient {
+    +self.register_driver()
+    +self.driver()
+    +self.default_driver()
+    +self.default_driver=()
+    +self.config()
+    +self.sentinel()
+    +self.new()
+    +self.register(middleware)
+    +initialize()
+    +size()
+    +with()
+    +timeout=()
+    +read_timeout=()
+    +write_timeout=()
+    +pubsub()
+    +call()
+    +call_once()
+    +blocking_call()
+    +scan()
+    +sscan()
+    +hscan()
+    +zscan()
+    +connected?()
+    +close()
+    +pipelined()
+    +multi()
+  }
+
+  class module_RedisClient_Common {
+    +config()
+    +id()
+    +connect_timeout()
+    +connect_timeout=()
+    +read_timeout()
+    +read_timeout=()
+    +write_timeout()
+    +write_timeout=()
+    +timeout=()
+  }
+
+  class RedisClient_PubSub {
+    +initialize()
+    +call()
+    +close()
+    +next_event()
+  }
+
+  class RedisClient_Multi {
+    +initialize()
+    +call()
+    +call_once()
+  }
+
+  class RedisClient_Pipeline {
+    +initialize()
+    +blocking_call()
+  }
+
+  class RedisClient_RubyConnection_BufferedIO {
+    +read_timeout()
+    +read_timeout=()
+    +write_timeout()
+    +write_timeout=()
+    +initialize()
+    +close()
+    +closed?()
+    +eof?()
+    +with_timeout()
+    +skip()
+    +write()
+    +getbyte()
+    +gets_chomp()
+    +read_chomp()
+  }
+
+  class module_RedisClient_RESP3 {
+    +self.dump()
+    +self.load()
+    +self.new_buffer()
+    +self.dump_any()
+    +self.dump_array()
+    +self.dump_set()
+    +self.dump_hash()
+    +self.dump_numeric()
+    +self.dump_string()
+    +self.parse()
+    +self.parse_string()
+    +self.parse_error()
+    +self.parse_boolean()
+    +self.parse_array()
+    +self.parse_set()
+    +self.parse_map()
+    +self.parse_push()
+    +self.parse_sequence()
+    +self.parse_integer()
+    +self.parse_double()
+    +self.parse_null()
+    +self.parse_blob()
+    +self.parse_verbatim_string()
+  }
+
+  class module_RedisClient_CommandBuilder {
+    +self.generate!()
+  }
+
+  class RedisClient_Config {
+    +host()
+    +port()
+    +path()
+    +initialize()
+  }
+
+  class module_RedisClient_Config_Common {
+    +db()
+    +username()
+    +password()
+    +id()
+    +ssl()
+    +ssl?()
+    +ssl_params()
+    +command_builder()
+    +connect_timeout()
+    +read_timeout()
+    +write_timeout()
+    +driver()
+    +connection_prelude()
+    +initialize()
+    +sentinel?()
+    +new_pool()
+    +new_client()
+    +retry_connecting?()
+    +ssl_context()
+  }
+
+  class RedisClient_SentinelConfig {
+    +initialize()
+    +sentinels()
+    +reset()
+    +host()
+    +port()
+    +path()
+    +retry_connecting?()
+    +sentinel?()
+    +check_role!()
+  }
+
+  class module_RedisClient_ConnectionMixin {
+    +call()
+    +call_pipelined()
+  }
+
+  class RedisClient_RubyConnection {
+    +self.ssl_context()
+    +initialize()
+    +connected?()
+    +close()
+    +read_timeout=()
+    +write_timeout=()
+    +write()
+    +write_multi()
+    +read()
+  }
+
+  class module_RedisClient_Decorator {
+    +self.create()
+  }
+
+  class module_RedisClient_Decorator_CommandsMixin {
+    +initialize()
+    +call()
+    +call_once()
+    +blocking_call()
+  }
+
+  class RedisClient_Decorator_Pipeline {
+  }
+
+  class RedisClient_Decorator_Client {
+    +initialize()
+    +with()
+    +pipelined()
+    +multi()
+    +close()
+    +scan()
+    +hscan()
+    +sscan()
+    +zscan()
+    +id()
+    +config()
+    +size()
+    +connect_timeout()
+    +read_timeout()
+    +write_timeout()
+    +timeout=()
+    +connect_timeout=()
+    +read_timeout=()
+    +write_timeout=()
+  }
+
+  class module_RedisClient_Middlewares {
+    +self.call()
+    +self.call_pipelined()
+  }
+
+  class RedisClient_Pooled {
+    +initialize()
+    +with()
+    +close()
+    +size()
+    +pipelined()
+    +multi()
+    +pubsub()
+    +call()
+    +call_once()
+    +blocking_call()
+    +scan()
+    +sscan()
+    +hscan()
+    +zscan()
+  }
+
+  RedisClient ..|> module_RedisClient_Common : include
+  RedisClient ..> RedisClient_PubSub : new
+  RedisClient ..> RedisClient_Multi : new
+  RedisClient ..> RedisClient_Pipeline : new
+  RedisClient ..> module_RedisClient_Middlewares : call
+  RedisClient ..> RedisClient_RubyConnection : new
+  RedisClient ..> RedisClient_Config : new
+  RedisClient ..> RedisClient_SentinelConfig : new
+  RedisClient ..> module_RedisClient_CommandBuilder : call
+  RedisClient_Multi <|.. RedisClient_Pipeline : extend
+
+  RedisClient_Config ..|> module_RedisClient_Config_Common : include
+  RedisClient_SentinelConfig ..|> module_RedisClient_Config_Common : include
+  module_RedisClient_Config_Common ..> RedisClient_Pooled : new
+
+  module_RedisClient_Decorator ..> RedisClient_Decorator_Pipeline : new
+  module_RedisClient_Decorator ..> RedisClient_Decorator_Client : new
+  RedisClient_Decorator_Pipeline ..|> module_RedisClient_Decorator_CommandsMixin : include
+  RedisClient_Decorator_Client ..|> module_RedisClient_Decorator_CommandsMixin : include
+
+  RedisClient_Pooled ..|> module_RedisClient_Common : include
+
+  RedisClient_RubyConnection ..|> module_RedisClient_ConnectionMixin : include
+  RedisClient_RubyConnection ..> RedisClient_RubyConnection_BufferedIO  : new
+  RedisClient_RubyConnection ..> module_RedisClient_RESP3 : call
+```