legion-cache 1.3.11 → 1.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6290bf41f9c5aad922d9ff00e8fe1cac6f6ac5118757ffc1acc55b0aaac05a18
-  data.tar.gz: da4e9d085dd567bb262a58be3d08cf81de1575ddc9b0a0d7db569dc67d81c923
+  metadata.gz: bb361d980bfc1761a6ea272c5225a1a1c33389ea8a15f87a1496354fb6f62390
+  data.tar.gz: f70347db3d1b7c2e849d7b31b3c456c992f776d9db0f16d801d1c0cb824160bb
 SHA512:
-  metadata.gz: aba95d900562d5f09c9ff9283e4306c5f66c0e56b66bea60b4720eacaa4744239f6a758dca1061f3e18053ecd9df45b386ad986ba91e228a5ffdb750f32b5068
-  data.tar.gz: 3a1e54d25d17354b4c3a6ec30e2f977bf36e2d89efd2b16d483e86a4a0cf47ad115497b865706060f5f309941135f028d8331dd05178e54fc616da19b5465b88
+  metadata.gz: 4b96a2ebb1066ace5026f7376e3c6e2788d9a744dd28e675d01e37539b02ad9cad5e18b9dd69172f2986b28742659b205d9e23708b0c1d0885a64149a1e80a4f
+  data.tar.gz: 4b45f7bc7d8ccca724d41e86899365db9ee08e1357052e70b46620752e0a91916f47372c33d11ae6ab38967c8f3ea028c2f25ee3687a29dfc0560bfb49e84f9b

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [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
+- `Legion::Cache::Memory` adapter module for lite mode: pure in-memory cache with TTL expiry and thread-safe Mutex synchronization
+- Cache `setup` auto-detects `LEGION_MODE=lite` and activates Memory adapter, skipping Redis/Memcached
+- `@using_memory` flag routes `get`/`set`/`fetch`/`delete`/`flush` through Memory adapter
+- `shutdown` cleanly tears down Memory adapter when active
+
 ## [1.3.11] - 2026-03-22
 
 ### 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/memory.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Cache
+    module Memory
+      extend self
+
+      @store = {}
+      @expiry = {}
+      @mutex = Mutex.new
+      @connected = false
+
+      def setup(**)
+        @connected = true
+      end
+
+      def client(**) = self
+
+      def connected?
+        @connected
+      end
+
+      def get(key)
+        @mutex.synchronize do
+          expire_if_needed(key)
+          @store[key]
+        end
+      end
+
+      def set(key, value, ttl = nil)
+        @mutex.synchronize do
+          @store[key] = value
+          @expiry[key] = Time.now + ttl if ttl&.positive?
+          value
+        end
+      end
+
+      def fetch(key, ttl = nil)
+        val = get(key)
+        return val unless val.nil?
+
+        val = yield if block_given?
+        set(key, val, ttl)
+        val
+      end
+
+      def delete(key)
+        @mutex.synchronize do
+          @store.delete(key)
+          @expiry.delete(key)
+        end
+      end
+
+      def flush(_delay = 0)
+        @mutex.synchronize do
+          @store.clear
+          @expiry.clear
+        end
+      end
+
+      def close = nil
+
+      def shutdown
+        flush
+        @connected = false
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @store.clear
+          @expiry.clear
+          @connected = false
+        end
+      end
+
+      def size = 1
+      def available = 1
+
+      private
+
+      def expire_if_needed(key)
+        return unless @expiry.key?(key) && Time.now > @expiry[key]
+
+        @store.delete(key)
+        @expiry.delete(key)
+      end
+    end
+  end
+end

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.3.11'
+    VERSION = '1.3.13'
   end
 end

data/lib/legion/cache.rb

@@ -6,6 +6,7 @@ require 'legion/cache/cacheable'
 
 require 'legion/cache/memcached'
 require 'legion/cache/redis'
+require 'legion/cache/memory'
 require 'legion/cache/local'
 require 'legion/cache/helper'
 
@@ -21,15 +22,29 @@ module Legion
       def setup(**)
         return Legion::Settings[:cache][:connected] = true if connected?
 
+        if ENV['LEGION_MODE'] == 'lite'
+          Legion::Cache::Memory.setup
+          @using_memory = true
+          @connected = true
+          Legion::Settings[:cache][:connected] = true
+          Legion::Logging.info 'Legion::Cache using in-memory adapter (lite mode)' if defined?(Legion::Logging)
+          return
+        end
+
         setup_local
         setup_shared(**)
       end
 
       def shutdown
         Legion::Logging.info 'Shutting down Legion::Cache'
-        close unless @using_local
-        Legion::Cache::Local.shutdown if Legion::Cache::Local.connected?
+        if @using_memory
+          Legion::Cache::Memory.shutdown
+        else
+          close unless @using_local
+          Legion::Cache::Local.shutdown if Legion::Cache::Local.connected?
+        end
         @using_local = false
+        @using_memory = false
         @connected = false
         Legion::Settings[:cache][:connected] = false
       end
@@ -43,30 +58,35 @@ module Legion
       end
 
       def get(key)
+        return Legion::Cache::Memory.get(key) if @using_memory
         return Legion::Cache::Local.get(key) if @using_local
 
         super
       end
 
       def set(key, value, ttl = 180)
+        return Legion::Cache::Memory.set(key, value, ttl) if @using_memory
         return Legion::Cache::Local.set(key, value, ttl) if @using_local
 
         super
       end
 
       def fetch(key, ttl = nil)
+        return Legion::Cache::Memory.fetch(key, ttl) if @using_memory
         return Legion::Cache::Local.fetch(key, ttl) if @using_local
 
         super
       end
 
       def delete(key)
+        return Legion::Cache::Memory.delete(key) if @using_memory
         return Legion::Cache::Local.delete(key) if @using_local
 
         super
       end
 
       def flush(delay = 0)
+        return Legion::Cache::Memory.flush(delay) if @using_memory
         return Legion::Cache::Local.flush(delay) if @using_local
 
         super

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-cache
 version: !ruby/object:Gem::Version
-  version: 1.3.11
+  version: 1.3.13
 platform: ruby
 authors:
 - Esity
@@ -104,6 +104,7 @@ files:
 - lib/legion/cache/helper.rb
 - lib/legion/cache/local.rb
 - lib/legion/cache/memcached.rb
+- lib/legion/cache/memory.rb
 - lib/legion/cache/pool.rb
 - lib/legion/cache/redis.rb
 - lib/legion/cache/settings.rb