legion-cache 1.3.12 → 1.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84f54b95a9a31607080afb2afbad2e85d713cb2d24b0a126dd97cea864d443a6
-  data.tar.gz: 0be1410d11a82efb137f050b7236f6e7d8cde91d4d75cf1275c0ccc22fbc1ed7
+  metadata.gz: fa8e7d0e05c4dbdf4c720b2d431f88ed5a7efa7dcacb8220791c6b5b6044e468
+  data.tar.gz: 74bc4911f37e02ee84ef0236a5aaeb31ce40b868fb153e15b85e81479970114f
 SHA512:
-  metadata.gz: e581d3e4d49937215c091f309939985b174516a5fa78619e499bc5a2d01e6ac389c438fcf5bdc63d883ca72b08bc082e0926f88ffbc7fbae2578198ca6aad954
-  data.tar.gz: a1618ccbad942d1c73bb0f549a6485f2883371b67d9bd3beded87aa58eb71bcdf092579c1d640afa80e3e98567c49e4e5cd6e4cd40f1bc0cf179ee188f219688
+  metadata.gz: 56c3335ff659f01bc1845a2ca4ce5090e32c2fcfc79b1929d8a6ab42f0c739865d1a8f108d10536010424cfd3bfc804a5640a6ce6329a89eddf3cfaf52bd35bc
+  data.tar.gz: 5171886f497a35d5bfdd8cc98af7c2fae9742be0a5dc43ee6b6ccf2163590b85e75903c9b8e1f75d69fa4487e86551c2a587239e7b95b1cf21fb3edad17032f9

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [1.3.14] - 2026-03-24
+
+### Added
+- `username`, `password`, `db`, and `reconnect_attempts` options to Redis `client` and `build_redis_client`
+- Corresponding nil/default entries in `Settings.default` and `Settings.local`
+
+## [1.3.13] - 2026-03-24
+
+### Changed
+- Reindex docs: update CLAUDE.md and README with Memory adapter and Helper mixin docs
+
 ## [1.3.12] - 2026-03-24
 
 ### Added

data/CLAUDE.md

@@ -8,14 +8,14 @@
 Caching wrapper for the LegionIO framework. Provides a consistent interface for Memcached (via `dalli`) and Redis (via `redis` gem) with connection pooling. Driver selection is config-driven.
 
 **GitHub**: https://github.com/LegionIO/legion-cache
-**Version**: 1.3.0
+**Version**: 1.3.12
 **License**: Apache-2.0
 
 ## Architecture
 
 ```
 Legion::Cache (singleton module)
-├── .setup(**opts)          # Connect to cache backend
+├── .setup(**opts)          # Connect to cache backend (auto-detects LEGION_MODE=lite -> Memory adapter)
 ├── .get(key)               # Retrieve cached value
 ├── .fetch(key, ttl)        # Get with block/TTL support (Memcached only; alias for get on Redis)
 ├── .set(key, value, ttl)   # Store value with optional TTL (positional on Memcached, keyword on Redis)
@@ -25,9 +25,10 @@ Legion::Cache (singleton module)
 ├── .size                   # Total pool connections
 ├── .available              # Idle pool connections
 ├── .restart(**opts)        # Close and reconnect pool with optional new opts
-├── .shutdown               # Close connections, mark disconnected
+├── .shutdown               # Close connections, mark disconnected (handles Memory adapter)
 ├── .local                  # Accessor for Legion::Cache::Local
 ├── .using_local?           # Whether fallback to local is active
+├── .using_memory?          # Whether Memory adapter (lite mode) is active
 │
 ├── Memcached               # Dalli-based Memcached driver (default)
 │   └── Uses connection_pool for thread safety
@@ -35,6 +36,9 @@ Legion::Cache (singleton module)
 ├── Redis                   # Redis driver
 │   └── Uses connection_pool for thread safety
 │   └── Default pool_size is 20 (Memcached default is 10)
+├── Memory                  # Lite mode adapter: pure in-memory cache, TTL expiry, Mutex thread-safety
+│   └── Activated by LEGION_MODE=lite env var; no Redis/Memcached required
+├── Helper                  # Injectable cache mixin for LEX extensions (namespaced cache_*/local_cache_*)
 ├── Local                   # Local cache tier (localhost Redis/Memcached, fallback target)
 │   ├── .setup              # Connect to local cache server (auto-detect driver)
 │   ├── .shutdown           # Close local connection
@@ -124,9 +128,11 @@ Dalli enforces a 1MB client-side limit by default (`value_max_bytes: 1_048_576`)
 
 | Path | Purpose |
 |------|---------|
-| `lib/legion/cache.rb` | Module entry, driver selection, setup/shutdown, fallback wiring |
+| `lib/legion/cache.rb` | Module entry, driver selection, setup/shutdown, fallback wiring, Memory adapter activation |
 | `lib/legion/cache/memcached.rb` | Dalli/Memcached driver implementation |
 | `lib/legion/cache/redis.rb` | Redis driver implementation |
+| `lib/legion/cache/memory.rb` | Lite mode Memory adapter: in-memory store with TTL + Mutex thread-safety |
+| `lib/legion/cache/helper.rb` | Injectable cache mixin for LEX extensions |
 | `lib/legion/cache/local.rb` | Local cache tier (localhost, fallback target) |
 | `lib/legion/cache/pool.rb` | Connection pool management |
 | `lib/legion/cache/settings.rb` | Default configuration + local defaults |

data/README.md

@@ -2,7 +2,7 @@
 
 Caching wrapper for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Provides a consistent interface for Memcached (via `dalli`) and Redis (via `redis` gem) with connection pooling. Driver selection is config-driven.
 
-**Version**: 1.3.2
+**Version**: 1.3.12
 
 ## Installation
 
@@ -40,6 +40,20 @@ Legion::Cache.flush            # flushdb
 Legion::Cache.shutdown
 ```
 
+## Lite Mode (No Infrastructure)
+
+When `LEGION_MODE=lite` is set, `Legion::Cache` activates the pure in-memory `Memory` adapter, bypassing Redis and Memcached entirely:
+
+```ruby
+ENV['LEGION_MODE'] = 'lite'
+Legion::Cache.setup
+Legion::Cache.using_memory?   # => true
+Legion::Cache.set('key', 'value', 60)
+Legion::Cache.get('key')      # => 'value'
+```
+
+The Memory adapter is thread-safe (Mutex), supports TTL expiry, and exposes the same `get`/`set`/`fetch`/`delete`/`flush` interface. Shutdown cleanly tears it down.
+
 ## Two-Tier Cache
 
 Legion::Cache supports a two-tier architecture: a shared remote cluster and a local per-machine cache. If the shared cluster is unreachable at setup, all operations transparently fall back to local.

data/lib/legion/cache/redis.rb

@@ -11,7 +11,8 @@ module Legion
       include Legion::Cache::Pool
       extend self
 
-      def client(pool_size: 20, timeout: 5, server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil, **) # rubocop:disable Metrics/ParameterLists
+      def client(pool_size: 20, timeout: 5, server: nil, servers: [], cluster: nil, replica: false, # rubocop:disable Metrics/ParameterLists
+                 fixed_hostname: nil, username: nil, password: nil, db: nil, reconnect_attempts: 1, **)
         return @client unless @client.nil?
 
         @pool_size = pool_size
@@ -20,26 +21,34 @@ module Legion
 
         @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
           build_redis_client(server: server, servers: servers, cluster: cluster,
-                             replica: replica, fixed_hostname: fixed_hostname)
+                             replica: replica, fixed_hostname: fixed_hostname,
+                             username: username, password: password, db: db,
+                             reconnect_attempts: reconnect_attempts)
         end
         @connected = true
         Legion::Logging.info "Redis connected to #{resolved_redis_address(server: server, servers: servers, cluster: cluster)}" if defined?(Legion::Logging)
         @client
       end
 
-      def build_redis_client(server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil)
+      def build_redis_client(server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil, # rubocop:disable Metrics/ParameterLists
+                             username: nil, password: nil, db: nil, reconnect_attempts: 1)
         nodes = Array(cluster).compact
         if nodes.any?
-          opts = { cluster: nodes }
+          opts = { cluster: nodes, reconnect_attempts: reconnect_attempts }
           opts[:replica] = true if replica
           opts[:fixed_hostname] = fixed_hostname unless fixed_hostname.nil?
+          opts[:username] = username unless username.nil?
+          opts[:password] = password unless password.nil?
           ::Redis.new(**opts)
         else
           resolved = Legion::Cache::Settings.resolve_servers(
             driver: 'redis', server: server, servers: servers
           )
           host, port = resolved.first.split(':')
-          redis_opts = { host: host, port: port.to_i }
+          redis_opts = { host: host, port: port.to_i, reconnect_attempts: reconnect_attempts }
+          redis_opts[:username] = username unless username.nil?
+          redis_opts[:password] = password unless password.nil?
+          redis_opts[:db] = db unless db.nil?
           redis_opts.merge!(redis_tls_options(port: port.to_i))
           ::Redis.new(**redis_opts)
         end

data/lib/legion/cache/settings.rb

@@ -13,40 +13,48 @@ module Legion
       Legion::Settings.merge_settings(:cache_local, local) if Legion::Settings.method_defined? :merge_settings
       def self.default
         {
-          driver:         driver,
-          servers:        resolve_servers(driver: driver),
-          connected:      false,
-          enabled:        true,
-          namespace:      'legion',
-          compress:       false,
-          failover:       true,
-          threadsafe:     true,
-          expires_in:     0,
-          cache_nils:     false,
-          pool_size:      10,
-          timeout:        5,
-          serializer:     Legion::JSON,
-          cluster:        nil,
-          replica:        false,
-          fixed_hostname: nil
+          driver:             driver,
+          servers:            resolve_servers(driver: driver),
+          connected:          false,
+          enabled:            true,
+          namespace:          'legion',
+          compress:           false,
+          failover:           true,
+          threadsafe:         true,
+          expires_in:         0,
+          cache_nils:         false,
+          pool_size:          10,
+          timeout:            5,
+          serializer:         Legion::JSON,
+          cluster:            nil,
+          replica:            false,
+          fixed_hostname:     nil,
+          username:           nil,
+          password:           nil,
+          db:                 nil,
+          reconnect_attempts: 1
         }
       end
 
       def self.local
         {
-          driver:     driver,
-          servers:    resolve_servers(driver: driver),
-          connected:  false,
-          enabled:    true,
-          namespace:  'legion_local',
-          compress:   false,
-          failover:   true,
-          threadsafe: true,
-          expires_in: 0,
-          cache_nils: false,
-          pool_size:  5,
-          timeout:    3,
-          serializer: Legion::JSON
+          driver:             driver,
+          servers:            resolve_servers(driver: driver),
+          connected:          false,
+          enabled:            true,
+          namespace:          'legion_local',
+          compress:           false,
+          failover:           true,
+          threadsafe:         true,
+          expires_in:         0,
+          cache_nils:         false,
+          pool_size:          5,
+          timeout:            3,
+          serializer:         Legion::JSON,
+          username:           nil,
+          password:           nil,
+          db:                 nil,
+          reconnect_attempts: 1
         }
       end
 

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.3.12'
+    VERSION = '1.3.14'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-cache
 version: !ruby/object:Gem::Version
-  version: 1.3.12
+  version: 1.3.14
 platform: ruby
 authors:
 - Esity