valkey-glide-rb 0.9.3 → 0.9.4.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3c28ac646b9b41dc630b6a28396af105cf70e38c20cdd2e74ac7dde1245b952
-  data.tar.gz: a417f802a018a41a16c8cfbfb1a12ba68af48eb4d6e176b48e936558a87a4bcf
+  metadata.gz: 401160c962777ceb0288adb3c0f41d03e32ede8943b66571cfb14eb7107a4835
+  data.tar.gz: 0fd6b29ead5f22cb248766733bd884341262c5bb44dffa0e2ce5c407156fa8cc
 SHA512:
-  metadata.gz: '08c8c01d41da6be96ea35fbf0a582dd0676a63a96a69244d3ec14d58cbbf496935a6beafe992d750d65c100f43c54fd00bf3f0c69352b407808578821fc7eab9'
-  data.tar.gz: 606d32093482a5827a216bd77c371aec94b6de684cedcdeb9181dae117e1abef9feb6f5ff2d8ccda78c954504752d57dfed44a3296a46175fc4b709a50e45330
+  metadata.gz: de90f08d23aad6c30db2d626d4fd2314af6e4ee5845ea973f818122e175b124852e60b2dbb8e65b5aa616762ffb2aa973b193ecafe2a262ff27f5bc0d6704287
+  data.tar.gz: c47a004c384b4f05ed964cbda60ca3bc8c1d845d12cb2af7466a9abfc5ef52d6065025957c26e2a1b6ba46f691d1088047d60c983ef4ea7354aca21437a01cc7

data/.rubocop.yml

@@ -1,7 +1,7 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0
   NewCops: enable
   Exclude:
     - 'vendor/**/*'

data/AGENTS.md

@@ -1,10 +1,10 @@
 # AGENTS: Ruby Client Context for Agentic Tools
 
-This file provides AI agents and developers with the minimum but sufficient context to work productively with the Valkey GLIDE Ruby client (`valkey-rb`). It covers build commands, testing, contribution requirements, and essential guardrails specific to the Ruby implementation.
+This file provides AI agents and developers with the minimum but sufficient context to work productively with the Valkey GLIDE Ruby client (`valkey-glide-rb`). It covers build commands, testing, contribution requirements, and essential guardrails specific to the Ruby implementation.
 
 ## Repository Overview
 
-This is the **Ruby client** for Valkey GLIDE, published as the `valkey-rb` gem. It provides a synchronous, redis-rb-compatible API on top of the Rust GLIDE core via FFI.
+This is the **Ruby client** for Valkey GLIDE, published as the `valkey-glide-rb` gem. It provides a synchronous API on top of the Rust GLIDE core via FFI.
 
 **Primary Languages:** Ruby, Rust (FFI native library, built separately from [valkey-glide](https://github.com/valkey-io/valkey-glide))
 
@@ -20,7 +20,7 @@ This is the **Ruby client** for Valkey GLIDE, published as the `valkey-rb` gem.
 - `lib/valkey/opentelemetry.rb` — Native OTel configuration
 - `test/valkey/` — Standalone integration tests
 - `test/cluster/` — Cluster integration tests
-- `test/lint/` — redis-rb compatibility lint suites
+- `test/lint/` — Lint suites
 
 ## Architecture Quick Facts
 
@@ -28,7 +28,7 @@ This is the **Ruby client** for Valkey GLIDE, published as the `valkey-rb` gem.
 
 **Client Types:** `Valkey` — standalone or cluster (`cluster_mode: true`)
 
-**API Style:** Synchronous, blocking calls (redis-rb style)
+**API Style:** Synchronous, blocking calls.
 
 **Communication:** Direct FFI (`Bindings.command`, `Bindings.batch`)
 
@@ -38,9 +38,9 @@ This is the **Ruby client** for Valkey GLIDE, published as the `valkey-rb` gem.
 - Alpine Linux 3.18+ (x86_64, aarch64) — musl libc
 - macOS: 13.7+ (x86_64), 14.7+ (aarch64)
 
-**Ruby Versions:** 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4, JRuby (CI matrix)
+**Ruby Versions:** 3.0, 3.1, 3.2, 3.3, 3.4, JRuby (CI matrix)
 
-**Gem name:** `valkey-rb` on RubyGems
+**Gem name:** `valkey-glide-rb` on RubyGems
 
 ## Build and Test Rules (Agents)
 
@@ -83,10 +83,26 @@ RUBYOPT="-I$(pwd)/lib" ruby -r valkey -e 'p Valkey.new.ping'
 | Suite | Server requirement |
 |-------|-------------------|
 | `test:standalone` | Standalone Valkey/Redis on `localhost:6379` (DB 15) |
-| `test:cluster` | 6-node cluster on `127.0.0.1:7000`–`7005` |
-| SSL tests | TLS Valkey on port `6380` + certs in `test/fixtures/ssl/` |
+| `test:cluster` | 6-node cluster on `127.0.0.1:7000`–`7005` (auto-started by the suite) |
+| SSL tests | TLS Valkey on port `6380` + `export TLS_CERT_DIR=...` (or `SKIP_TLS_TESTS=true`) |
 | Module tests | JSON, Bloom, Search modules loaded (see CI workflow) |
 
+Start test servers with `cluster_manager.py` (matching CI). The cluster is
+auto-started by the suite; standalone and TLS are started manually:
+
+```bash
+# Standalone on :6379
+python3 valkey-glide/utils/cluster_manager.py start -r 0 -p 6379 --prefix standalone
+
+# TLS on :6380 (generates certs in valkey-glide/utils/tls_crts/)
+python3 valkey-glide/utils/cluster_manager.py --tls start -r 0 -p 6380 --prefix tls-standalone
+export TLS_CERT_DIR=$(pwd)/valkey-glide/utils/tls_crts   # required for TLS tests
+
+# Stop when done
+python3 valkey-glide/utils/cluster_manager.py stop --prefix standalone
+python3 valkey-glide/utils/cluster_manager.py --tls stop --prefix tls-standalone
+```
+
 ### Rebuild Native FFI (when changing glide-core)
 
 ```bash
@@ -141,15 +157,15 @@ cargo fmt --manifest-path ./Cargo.toml --all
 - `*.gem` — built gem packages
 - `coverage/` — coverage reports
 - `tmp/`, `test/tmp/` — temporary test artifacts
-- Regenerated SSL certs unless intentionally updated (`test/fixtures/ssl/*.pem` may be committed for CI)
+- SSL certs — never commit them; TLS tests read certs from `TLS_CERT_DIR` (generated by `cluster_manager.py --tls`)
 - Wrong-platform `libglide_ffi` binaries (build per OS/arch)
 
 ### Ruby-Specific Rules
 
-- **Ruby 2.6+ Required:** Minimum per `valkey.gemspec`
+- **Ruby 3.0+ Required:** Minimum per `valkey.gemspec`
 - **FFI dependency:** `ffi ~> 1.17.0` — do not break ABI without rebuilding native lib
 - **Synchronous only:** No async client in this repo; do not add EventMachine/async patterns without design review
-- **redis-rb compatibility:** Prefer matching redis-rb method signatures and return types when implementing commands
+- **redis-rb conventions:** Prefer matching redis-rb method signatures and return types when implementing commands for familiarity.
 - **Command args:** All FFI args are strings; convert types in Ruby before `send_command`
 - **Pipeline transactions:** `MULTI`/`EXEC`/`DISCARD` in `pipelined` use sequential fallback — do not remove without fixing FFI batch stability
 - **OpenTelemetry:** Init once per process via `Valkey::OpenTelemetry.init`; spans created in FFI layer
@@ -185,7 +201,7 @@ valkey-glide-ruby/
 ├── test/lint/            # shared lint
 ├── valkey.gemspec
 ├── Rakefile
-└── .github/workflows/CI.yml
+└── .github/workflows/ci.yml
 ```
 
 ## Quality Gates (Agent Checklist)
@@ -203,11 +219,11 @@ valkey-glide-ruby/
 
 ## Quick Facts for Reasoners
 
-**Package:** `valkey-rb` on RubyGems  
-**API Style:** Synchronous, redis-rb-compatible  
+**Package:** `valkey-glide-rb` on RubyGems  
+**API Style:** Synchronous. 
 **Client:** `Valkey.new` — standalone or `cluster_mode: true`  
 **Key Features:** Pipelining, OpenTelemetry (native), statistics, TLS, URL parsing, cluster routing  
-**Testing:** Minitest + rake tasks; lint suites for redis-rb parity  
+**Testing:** Minitest + rake tasks; lint suites.
 **Core repo:** [valkey-glide](https://github.com/valkey-io/valkey-glide) (`ffi/`, `glide-core/`)  
 **This repo:** [valkey-glide-ruby](https://github.com/valkey-io/valkey-glide-ruby)
 

data/CHANGELOG.md

@@ -2,7 +2,16 @@
 
 ## Pending
 
+### Fixes
+
+* Ruby: Fix `blpop`, `brpop`, `blmove`, `rpoplpush` and `brpoplpush`, all of which were non-functional. `blpop`/`brpop` called a non-existent `send_blocking_command` helper, `blmove` leaked the command name into argv, and `rpoplpush`/`brpoplpush` dispatched `RequestType::RPOPLPUSH`/`BRPOPLPUSH`, for which glide-core has no command mapping. Since Valkey defines `RPOPLPUSH src dst` as exactly `LMOVE src dst RIGHT LEFT` (and `BRPOPLPUSH src dst timeout` as `BLMOVE src dst RIGHT LEFT timeout`), `rpoplpush`/`brpoplpush` are now fixed-argument facades over `lmove`/`blmove`. Both remain deprecated as of Redis 6.2; prefer `lmove`/`blmove` in new code. The unusable `RequestType::RPOPLPUSH`/`BRPOPLPUSH` constants were removed.
+
 ### Changes
 
+* Ruby: fixed cd workflow to correctly build the ffi with **glibc 2.17** ([#223](https://github.com/valkey-io/valkey-glide-ruby/issues/223))
+* Ruby: scripting commands now dispatch real `EVAL` / `EVALSHA` / `SCRIPT LOAD` to the server instead of a client-side script container ([#213](https://github.com/valkey-io/valkey-glide-ruby/issues/213)). Three behavior changes:
+  * `eval` / `evalsha` (and the `_ro` variants) now accept the standard integer key-count form used by `valkey-cli` and the Valkey docs — `eval(script, 1, "mykey", "myarg")`. It previously made the count `KEYS[1]`, shifted the real key into `ARGV[1]`, and dropped the remaining arguments without raising.
+  * `script_load` now really sends `SCRIPT LOAD`, so the returned SHA1 is known to the server and usable by `evalsha` from any other client or process. `script_exists` previously reported `false` for a just-loaded script.
+  * `evalsha` on a flushed or never-loaded SHA now raises `Valkey::CommandError` (NOSCRIPT) instead of silently re-uploading the script and succeeding, so `script_flush` is no longer quietly undone. Callers relying on the old auto-reload must load the script again after a flush, or use `eval`.
 * Ruby: Add Alpine Linux (musl libc) support for x86_64 and aarch64 — runtime detection of musl libc, CI/CD pipeline for native builds, and prebuilt `libglide_ffi.so` for musl targets ([#143](https://github.com/valkey-io/valkey-glide-ruby/pull/143))
 * Ruby: Add distributed tracing support — `Valkey::OpenTelemetry.set_parent_span_context_provider` (and `init(parent_span_context_provider:)`) let an app propagate its current W3C trace context into command/pipeline spans, so they become children of the app's trace instead of independent root spans, matching the Node.js client's `parentSpanContextProvider` behavior.

data/CLAUDE.md

@@ -1,6 +1,6 @@
 # CLAUDE.md
 
-Valkey GLIDE Ruby (`valkey-rb`) is the official Ruby binding for Valkey and Redis OSS. It uses the shared Rust **glide-core** driver via the **glide-ffi** C library, with a redis-rb-compatible Ruby API. This repository is separate from the [valkey-glide](https://github.com/valkey-io/valkey-glide) mono-repo (Python, Java, Node, Go).
+Valkey GLIDE Ruby (`valkey-glide-rb`) is the official Ruby binding for Valkey and Redis OSS. It uses the shared Rust **glide-core** driver via the **glide-ffi** C library. This repository is separate from the [valkey-glide](https://github.com/valkey-io/valkey-glide) mono-repo (Python, Java, Node, Go).
 
 ## Hard Constraints (non-negotiable)
 

data/CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing Guidelines
 
-Thank you for your interest in contributing to Valkey GLIDE for Ruby (`valkey-rb`). Whether it's a bug report, new feature, correction, or documentation, we value feedback from the community.
+Thank you for your interest in contributing to Valkey GLIDE for Ruby (`valkey-glide-rb`). Whether it's a bug report, new feature, correction, or documentation, we value feedback from the community.
 
 Please read this document before submitting issues or pull requests.
 
@@ -11,7 +11,7 @@ Use the [GitHub issue tracker](https://github.com/valkey-io/valkey-glide-ruby/is
 Before creating a new issue:
 
 1. Search [existing issues](https://github.com/valkey-io/valkey-glide-ruby/issues) to avoid duplicates.
-2. Include Ruby version, OS/architecture, `valkey-rb` version, and Valkey/Redis server version.
+2. Include Ruby version, OS/architecture, `valkey-glide-rb` version, and Valkey/Redis server version.
 3. For connection problems, note standalone vs cluster and whether TLS is enabled.
 4. Provide a minimal reproduction script when possible.
 
@@ -39,7 +39,7 @@ For issues that affect the shared Rust core or other language clients, consider
    ```
    Configure automatic signoff: `git config --global format.signOff true`
 
-5. Open a PR and respond to CI feedback (RuboCop + test matrix in `.github/workflows/CI.yml`).
+5. Open a PR and respond to CI feedback (RuboCop + test matrix in `.github/workflows/ci.yml`).
 
 GitHub guides: [fork a repo](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo), [create a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
 

data/DEVELOPER.md

@@ -1,6 +1,6 @@
 # Developer Guide
 
-This document describes how to set up your development environment to build and test the Valkey GLIDE Ruby client (`valkey-rb`).
+This document describes how to set up your development environment to build and test the Valkey GLIDE Ruby client (`valkey-glide-rb`).
 
 ## Development Overview
 
@@ -43,7 +43,7 @@ valkey-glide-ruby/
 │   ├── setup                     # bundle install
 │   └── console                   # IRB with gem loaded
 ├── .github/workflows/
-│   ├── CI.yml                    # RuboCop + test matrix
+│   ├── ci.yml                    # RuboCop + test matrix
 │   └── cd.yml                    # Build and publish gem
 ├── valkey.gemspec
 ├── Gemfile
@@ -54,7 +54,7 @@ valkey-glide-ruby/
 
 ### Software Dependencies
 
-- **Ruby** 2.6+ (3.x recommended for development)
+- **Ruby** 3.0+
 - **Bundler**
 - **git**
 - **Valkey** or Redis OSS (for integration tests)
@@ -226,13 +226,14 @@ CI=1 bundle exec rake test:standalone
 
 ### SSL Tests
 
-The preferred approach (matching CI and all other GLIDE clients) uses `cluster_manager.py`:
+TLS tests require a TLS server plus `TLS_CERT_DIR` pointing at its certs. Use
+`cluster_manager.py --tls` which will prepare a self-sign certs for use:
 
 ```bash
 # Start a TLS-only server on port 6380 (generates certs in valkey-glide/utils/tls_crts/)
 python3 valkey-glide/utils/cluster_manager.py --tls start -r 0 -p 6380 --prefix tls-standalone
 
-# Point tests at the generated certs
+# Point tests at the generated certs (required — the TLS tests raise if unset)
 export TLS_CERT_DIR=$(pwd)/valkey-glide/utils/tls_crts
 
 # Run tests
@@ -242,12 +243,8 @@ bundle exec rake test:standalone
 python3 valkey-glide/utils/cluster_manager.py --tls stop --prefix tls-standalone
 ```
 
-Alternatively, for local development without Python, generate certs and start manually:
-
-```bash
-ruby test/fixtures/ssl/generate_certs.rb
-# Then start a TLS Valkey server on port 6380 using those certs
-```
+If you don't want to run the TLS tests, set `SKIP_TLS_TESTS=true` and they are
+skipped gracefully (this is what macOS CI does).
 
 ### Module Tests (JSON, Bloom, Search)
 
@@ -270,7 +267,7 @@ VALKEY_PORT=6379 TIMEOUT=10 bundle exec rake test:standalone
 bundle exec rubocop
 ```
 
-CI runs RuboCop on every push and pull request (see `.github/workflows/CI.yml`).
+CI runs RuboCop on every push and pull request (see `.github/workflows/ci.yml`).
 
 Auto-correct safe offenses:
 
@@ -350,13 +347,13 @@ bundle exec ruby test/valkey/test_opentelemetry.rb
 
 ## CI Overview
 
-GitHub Actions (`.github/workflows/CI.yml`):
+GitHub Actions (`.github/workflows/ci.yml`):
 
 | Job | Matrix |
 |-----|--------|
 | `lint` | Ruby 3.3, RuboCop |
-| `standalone` | Ruby 2.6–3.4 + JRuby; Valkey 7.2, 8, 8.1 |
-| `cluster` | Ruby 2.6–3.4; grokzen/redis-cluster |
+| `standalone` | Ruby 3.0–3.4 + JRuby; Valkey 7.2, 8, 8.1 |
+| `cluster` | Ruby 3.0–3.4; grokzen/redis-cluster |
 
 ## Building the Gem Locally
 
@@ -375,7 +372,7 @@ rake native:package
 gem build valkey.gemspec
 
 # 4. Install locally
-gem install ./valkey-rb-*.gem
+gem install ./valkey-glide-rb-*.gem
 ```
 
 ### What `rake native:package` Does
@@ -409,18 +406,18 @@ To build for a different platform, you must build on that platform (or use cross
 
 ```bash
 # Unpack and inspect
-gem unpack valkey-rb-*.gem --target=gem-contents
+gem unpack valkey-glide-rb-*.gem --target=gem-contents
 find gem-contents -name "libglide_ffi.*"
 
 # Or list files in the gem
-gem spec valkey-rb-*.gem files
+gem spec valkey-glide-rb-*.gem files
 ```
 
 ### Install and Test
 
 ```bash
 # Install the locally built gem
-gem install ./valkey-rb-*.gem
+gem install ./valkey-glide-rb-*.gem
 
 # Test it works (requires Valkey running)
 ruby -e "require 'valkey'; c = Valkey.new; puts c.ping; c.close"
@@ -443,7 +440,7 @@ ruby -e "require 'valkey'; c = Valkey.new; puts c.ping; c.close"
 | `LoadError` / FFI library not found | Confirm `lib/valkey/libglide_ffi.{so,dylib}` exists and matches your OS/arch. |
 | Wrong architecture after FFI rebuild | Rebuild `glide-ffi` on the target platform; do not copy Linux `.so` to macOS. |
 | Cluster tests flaky | Wait for `cluster_state:ok`; increase `TIMEOUT` env var. |
-| SSL test failures | Use `cluster_manager.py --tls` (see SSL Tests above), or regenerate local certs: `ruby test/fixtures/ssl/generate_certs.rb`. |
+| SSL test failures / `TLS_CERT_DIR is not set` | Start a TLS server via `cluster_manager.py --tls` and `export TLS_CERT_DIR=...` (see SSL Tests above), or set `SKIP_TLS_TESTS=true`. |
 | Pipeline / MULTI crashes | Transaction commands in `pipelined` use sequential fallback by design. |
 
 ## Recommended Editor Extensions

data/README.md

@@ -1,6 +1,7 @@
+
 # Valkey GLIDE for Ruby
 
-Valkey General Language Independent Driver for the Enterprise (GLIDE) is the official open-source Valkey client library, proudly part of the [Valkey](https://valkey.io) organization. The Ruby gem (`valkey-rb`) wraps [Valkey GLIDE Core](https://github.com/valkey-io/valkey-glide) (Rust) and aims to be a **drop-in replacement for [redis-rb](https://github.com/redis/redis-rb)** while delivering GLIDE performance, reliability, and enterprise features.
+Valkey General Language Independent Driver for the Enterprise (GLIDE) is the official open-source Valkey client library, proudly part of the [Valkey](https://valkey.io) organization. The Ruby gem (`valkey-glide-rb`) wraps [Valkey GLIDE Core](https://github.com/valkey-io/valkey-glide), delivering GLIDE performance, reliability, and enterprise features.
 
 ## Why Choose Valkey GLIDE?
 
@@ -9,7 +10,6 @@ Valkey General Language Independent Driver for the Enterprise (GLIDE) is the off
 - **Performance**: Optimized for high performance and low latency via the Rust-based GLIDE core.
 - **High Availability**: Cluster-aware routing, reconnection, and fault tolerance.
 - **Cross-Language Consistency**: Same core driver as Python, Java, Node.js, and Go clients.
-- **Drop-in Replacement**: Familiar redis-rb-style API (`Valkey.new`, command methods, `pipelined`, URL parsing).
 - **Observability**: Native OpenTelemetry tracing and client statistics.
 
 ## Documentation
@@ -30,41 +30,31 @@ Valkey General Language Independent Driver for the Enterprise (GLIDE) is the off
 
 ### System Requirements
 
-The release of Valkey GLIDE Ruby was tested on the following platforms:
-
-**Linux:**
-
-- Ubuntu 20+ (x86_64/amd64 and arm64/aarch64)
-- Amazon Linux 2 (AL2) and 2023 (AL2023) (x86_64)
-- Alpine Linux 3.18+ (x86_64 and arm64/aarch64) — musl libc
-
-**macOS:**
+- glibc 2.17+ or musl 1.2.3+
+- Ruby 3.0+
 
-- macOS 14.7+ (Apple silicon / aarch64)
-- macOS 13.7+ (x86_64 / amd64)
+#### Supported OS
 
-### Ruby Supported Versions
+The following platforms are tested in CI:
+- Ubuntu 24 (x86_64 and arm64)
+- Alpine Linux 3 (x86_64 and arm64, via musl targets)
+- macOS 14+ (Apple silicon / arm64)
 
-| Ruby Version | MRI | JRuby |
-|--------------|-----|-------|
-| 2.6          | ✓   | -     |
-| 2.7          | ✓   | -     |
-| 3.0 – 3.4    | ✓   | ✓     |
-
-Minimum Ruby version: **2.6.0** (see `valkey.gemspec`).
+**Notes:** valkey-glide-rb gem only support ARM MacOS. For Intel Mac users
+you will need to build the client locally.
 
 ### Installation and Setup
 
 Install from RubyGems:
 
 ```bash
-gem install valkey-rb
+gem install valkey-glide-rb
 ```
 
 Or add to your `Gemfile`:
 
 ```ruby
-gem "valkey-rb"
+gem "valkey-glide-rb"
 ```
 
 Verify installation:
@@ -93,16 +83,25 @@ client.get("mykey")
 client.close
 ```
 
-### Standalone with URL (redis-rb compatible)
+### Standalone with URL
+
+Accepted URL schemes: `redis://`, `rediss://` (TLS), `valkey://`, `valkeys://` (TLS).
 
 ```ruby
 client = Valkey.new(url: "redis://localhost:6379/0")
-# TLS: rediss://user:password@localhost:6380/0
+# Valkey-native scheme (matches valkey-cli -u):
+#   valkey://localhost:6379/0
+# TLS variants:
+#   rediss://user:password@localhost:6380/0
+#   valkeys://user:password@localhost:6380/0
 
 client.ping
 # => "PONG"
 ```
 
+Unparseable URLs, unsupported schemes, and URLs without a host raise
+`ArgumentError` — they no longer fall back to `127.0.0.1:6379` silently.
+
 ### Cluster Mode
 
 ```ruby
@@ -175,27 +174,28 @@ client.call("SET", "k", "v", nx: false, ex: nil)
 `call_v` takes the whole command as a single Array (no keyword flags) — useful when the command is
 built dynamically. Both return the raw reply with no type-casting based on the command name.
 
-### Connection Options (redis-rb compatible)
+### Connection Options
 
 | Option | Description |
 |--------|-------------|
 | `host`, `port` | Server address (default `127.0.0.1:6379`) |
-| `url` | `redis://` or `rediss://` URI (merged with explicit options) |
+| `url` | `redis://`, `rediss://`, `valkey://`, or `valkeys://` URI (merged with explicit options) |
 | `db` | Database index (standalone only) |
 | `password`, `username` | Authentication |
 | `timeout` | Request timeout in seconds (default `5.0`) |
 | `connect_timeout` | Connection timeout in seconds |
-| `ssl`, `ssl_params` | TLS (`ca_file`, `cert`, `key`, `ca_path`, `root_certs`) |
+| `ssl`| Enable TLS if true |
+| `ssl_params` | TLS options {`ca_file`, `cert`, `key`, `ca_path`, `root_certs`} |
 | `cluster_mode` | Enable cluster client |
 | `nodes` | Array of `{ host:, port: }` hashes |
 | `protocol` | `:resp2` (default) or `:resp3` |
 | `client_name` | `CLIENT SETNAME` value |
 | `reconnect_attempts`, `reconnect_delay`, `reconnect_delay_max` | Connection retry strategy |
-| `read_from` *(GLIDE-native)* | Read routing: `:primary`, `:prefer_replica`, `:az_affinity`, `:az_affinity_replicas_and_primary` symbols, the exact-match GLIDE strings (e.g. `"PreferReplica"`), or the `Valkey::ReadFrom::*` constants (e.g. `Valkey::ReadFrom::PREFER_REPLICA`). `:az_affinity`/`:az_affinity_replicas_and_primary` require `client_az` to also be set. `LowestLatency` is a valid GLIDE value but not yet usable via the vendored native library. |
-| `client_az` *(GLIDE-native)* | Availability-zone identifier for `:az_affinity` / `:az_affinity_replicas_and_primary` routing (e.g. `"us-west-2a"`) |
-| `inflight_requests_limit` *(GLIDE-native)* | Maximum concurrent in-flight requests (non-negative integer) |
-| `lazy_connect` *(GLIDE-native)* | Delay the actual connection until the first command is sent |
-| `periodic_checks` *(GLIDE-native)* | Cluster topology health checks: `{ manual_interval: { duration_in_sec: N } }` or `{ disabled: true }`. Accepted (as a no-op) on standalone connections. |
+| `read_from` | Read routing: the `Valkey::ReadFrom::*` constants: `PRIMARY`, `PREFER_REPLICA`, `AZ_AFFINITY`, `AZ_AFFINITY_REPLICAS_AND_PRIMARY`.`AZ_AFFINITY`/`AZ_AFFINITY_REPLICAS_AND_PRIMARY` require `client_az` to also be set. |
+| `client_az` | Availability-zone identifier for `AZ_AFFINITY` / `AZ_AFFINITY_REPLICAS_AND_PRIMARY` routing (e.g. `"us-west-2a"`) |
+| `inflight_requests_limit`  | Maximum concurrent in-flight requests (non-negative integer) |
+| `lazy_connect` | Delay the actual connection until the first command is sent |
+| `periodic_checks` | Cluster topology health checks: `{ manual_interval: { duration_in_sec: N } }` or `{ disabled: true }`. Accepted (as a no-op) on standalone connections. |
 
 ```ruby
 client = Valkey.new(
@@ -311,8 +311,8 @@ Available keys: `:total_connections`, `:total_clients`, `:total_values_compresse
 
 ## Pub/Sub
 
-Pub/Sub uses a native callback registered at connection time. Configure subscriptions via command modules (`subscribe`, `psubscribe`, etc.). See [DEVELOPER.md](./DEVELOPER.md) and integration tests in `test/valkey/pubsub_commands_test.rb` for details.
-
+Pub/Sub is currently not supported and is not ready for use and is planned for future release.
+See https://github.com/valkey-io/valkey-glide-ruby/issues/135
 ## Layout of Ruby Code
 
 | Path | Purpose |
@@ -324,17 +324,17 @@ Pub/Sub uses a native callback registered at connection time. Configure subscrip
 | `lib/valkey/pipeline.rb` | Pipeline command batching |
 | `test/valkey/` | Standalone integration tests |
 | `test/cluster/` | Cluster integration tests |
-| `test/lint/` | Shared lint tests (redis-rb compatibility patterns) |
+| `test/lint/` | Shared lint tests (redis-rb convention patterns) |
 
-## redis-rb Compatibility
+## API Conventions
 
-This client mirrors redis-rb conventions where possible:
+This client is **not** a drop-in replacement for redis-rb, but it follows familiar Ruby conventions to ease adoption:
 
 - `Valkey.new` with `url`, `host`, `port`, `db`, `ssl_params`
-- Command method names and argument ordering aligned with redis-rb
+- Conventional command method names and argument ordering
 - `pipelined`, `multi` / `exec`, `disconnect!` (alias of `close`)
 
-Not every redis-rb API is implemented yet. See the [command implementation wiki](https://github.com/valkey-io/valkey-glide-ruby/wiki/The-implementation-status-of-the-Valkey-commands) for coverage.
+APIs and behavior may differ from redis-rb; verify against your usage. See the [command implementation wiki](https://github.com/valkey-io/valkey-glide-ruby/wiki/The-implementation-status-of-the-Valkey-commands) for coverage.
 
 ## Building and Testing
 

data/Rakefile

@@ -125,9 +125,12 @@ namespace :test do
   # Exclude module directories (valkey/, lint/) from lost_tests check
   # These contain reusable test modules, not standalone test files
   module_dirs = %w[valkey lint]
+  # Standalone scripts run directly (not via a test group) — see cd.yml
+  standalone_scripts = %w[test/smoke_test.rb]
   lost_tests = Dir["test/**/*_test.rb"] -
                groups.map { |g| Dir["test/#{g}/**/*_test.rb"] }.flatten -
-               module_dirs.map { |d| Dir["test/#{d}/**/*_test.rb"] }.flatten
+               module_dirs.map { |d| Dir["test/#{d}/**/*_test.rb"] }.flatten -
+               standalone_scripts
   abort "The following test files are in no group:\n#{lost_tests.join("\n")}" unless lost_tests.empty?
 end
 

data/lib/valkey/commands/cluster_commands.rb

@@ -124,10 +124,9 @@ class Valkey
 
       # Get information about the cluster.
       #
-      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Hash<String, String>] cluster information
-      def cluster_info(route: nil)
-        send_command(RequestType::CLUSTER_INFO, [], route: route) do |reply|
+      def cluster_info
+        send_command(RequestType::CLUSTER_INFO, []) do |reply|
           if reply.is_a?(Hash)
             reply.transform_values { |v| Utils::HashifyInfo.call(v) }
           else
@@ -146,10 +145,9 @@ class Valkey
 
       # Get information about cluster links.
       #
-      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Array<Hash>] array of link information
-      def cluster_links(route: nil)
-        send_command(RequestType::CLUSTER_LINKS, [], route: route)
+      def cluster_links
+        send_command(RequestType::CLUSTER_LINKS, [])
       end
 
       # Meet another node in the cluster.
@@ -163,26 +161,23 @@ class Valkey
 
       # Get the ID of the current node.
       #
-      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [String] node ID
-      def cluster_myid(route: nil)
-        send_command(RequestType::CLUSTER_MY_ID, [], route: route)
+      def cluster_myid
+        send_command(RequestType::CLUSTER_MY_ID, [])
       end
 
       # Get the shard ID of the current node.
       #
-      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [String] shard ID
-      def cluster_myshardid(route: nil)
-        send_command(RequestType::CLUSTER_MY_SHARD_ID, [], route: route)
+      def cluster_myshardid
+        send_command(RequestType::CLUSTER_MY_SHARD_ID, [])
       end
 
       # Get information about all nodes in the cluster.
       #
-      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Array<Hash>] array of node information
-      def cluster_nodes(route: nil)
-        send_command(RequestType::CLUSTER_NODES, [], route: route) do |reply|
+      def cluster_nodes
+        send_command(RequestType::CLUSTER_NODES, []) do |reply|
           if reply.is_a?(Hash)
             reply.transform_values { |v| Utils::HashifyClusterNodes.call(v) }
           else
@@ -248,10 +243,9 @@ class Valkey
 
       # Get information about cluster shards.
       #
-      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Array<Hash>] array of shard information
-      def cluster_shards(route: nil)
-        send_command(RequestType::CLUSTER_SHARDS, [], route: route)
+      def cluster_shards
+        send_command(RequestType::CLUSTER_SHARDS, [])
       end
 
       # Get information about slave nodes (deprecated, use cluster_replicas).