legion-cache 1.3.18 → 1.3.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aded92a74b60ff3cae8cab7d33d38f147bf17ac308dfd78695b2e6e2ed70298e
-  data.tar.gz: 244c88d6428745bd91d949dc7738cf65392e644d2143b3c092ab9b84fc610cd2
+  metadata.gz: d491473adc0cc25e2737e471f1dbc644544e2bbc25c67d9ab8e1402836c9f9a7
+  data.tar.gz: dd72aaf34ad2f97c37117a9b882a9cf76a34a4bd6d1701316a42eff5dafb1317
 SHA512:
-  metadata.gz: d6b790d262f8d9735c7d3a31a5222b449408deb00126f5184b8404fafbfa95a30a2eb3826a1cff5c0a44420fe0510399ff47c002ec816b65f596079977d00e4b
-  data.tar.gz: 774eb4fd9532934894e4d38ab52cba094e5fbab03c33eeb12f9aae0a244efebfddf3eea454a97445598143de680e2eac01ddd6b4f256b4ce116408e398c07e50
+  metadata.gz: 756116bb625d9aafc055c12c835777e91d1defbe9cc1308a1021789ac27a64382fcc1fb5378d78afb365cc96f0f6a403330d2c4694d151be2bd2c13631303f4c
+  data.tar.gz: 117f46e60ca535ee8ce0c4080e3a6f8c71e2cade0ea023ff6edd1fff6ad96cce2ee43448184400f90d5ce58980f58a54f00dc710c5f1fd53127e9a59745a624c

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [1.3.19] - 2026-03-31
+
+### Added
+- `cache_mget` / `cache_mset` (and `local_cache_mget` / `local_cache_mset`) on `Helper` mixin — delegates to Redis batch ops, falls back to sequential get/set on Memcached (closes #3)
+- `cache_hset`, `cache_hgetall`, `cache_hdel`, `cache_zadd`, `cache_zrangebyscore`, `cache_zrem`, `cache_expire` on `Helper` mixin — delegates to `RedisHash` with namespace prefixing; hash ops fall back to JSON-serialized Memcached values, sorted-set ops raise `NotImplementedError`, expire is a no-op on Memcached (closes #4)
+
 ## [1.3.18] - 2026-03-29
 
 ### Added

data/Gemfile

@@ -8,5 +8,6 @@ group :test do
   gem 'rspec'
   gem 'rspec_junit_formatter'
   gem 'rubocop'
+  gem 'rubocop-legion'
   gem 'simplecov'
 end

data/lib/legion/cache/helper.rb

@@ -54,6 +54,162 @@ module Legion
         !Legion::Cache.get(cache_namespace + key).nil?
       end
 
+      # --- Batch Operations (shared tier) ---
+      # Issue #3: mget/mset with Memcached safety
+
+      # Returns a Hash of { key => value } pairs. Prefixes all keys with cache_namespace.
+      # Delegates to Legion::Cache.mget on Redis; falls back to sequential gets on Memcached.
+      def cache_mget(*keys)
+        keys = keys.flatten
+        return {} if keys.empty?
+
+        namespaced = keys.map { |k| cache_namespace + k }
+
+        if cache_redis?
+          raw = Legion::Cache.mget(*namespaced)
+          keys.to_h { |k| [k, raw[cache_namespace + k]] }
+        else
+          keys.to_h { |k| [k, Legion::Cache.get(cache_namespace + k)] }
+        end
+      rescue StandardError => e
+        log_cache_error('cache_mget', e)
+        {}
+      end
+
+      # Stores multiple key-value pairs. Accepts a Hash of { key => value }.
+      # TTL follows the same resolution chain as cache_set.
+      # Delegates to Legion::Cache.mset on Redis; falls back to sequential sets on Memcached.
+      def cache_mset(hash, ttl: nil)
+        return true if hash.empty?
+
+        effective_ttl = ttl || cache_default_ttl
+
+        if cache_redis?
+          namespaced = hash.transform_keys { |k| cache_namespace + k }
+          Legion::Cache.mset(namespaced)
+        else
+          hash.each { |k, v| Legion::Cache.set(cache_namespace + k, v, effective_ttl) }
+          true
+        end
+      rescue StandardError => e
+        log_cache_error('cache_mset', e)
+        false
+      end
+
+      # --- Batch Operations (local tier) ---
+
+      def local_cache_mget(*keys)
+        keys = keys.flatten
+        return {} if keys.empty?
+
+        if local_cache_redis?
+          namespaced = keys.map { |k| cache_namespace + k }
+          raw = Legion::Cache::Local.mget(*namespaced)
+          keys.to_h { |k| [k, raw[cache_namespace + k]] }
+        else
+          keys.to_h { |k| [k, Legion::Cache::Local.get(cache_namespace + k)] }
+        end
+      rescue StandardError => e
+        log_cache_error('local_cache_mget', e)
+        {}
+      end
+
+      def local_cache_mset(hash, ttl: nil)
+        return true if hash.empty?
+
+        effective_ttl = ttl || local_cache_default_ttl
+
+        if local_cache_redis?
+          namespaced = hash.transform_keys { |k| cache_namespace + k }
+          Legion::Cache::Local.mset(namespaced)
+        else
+          hash.each { |k, v| Legion::Cache::Local.set(cache_namespace + k, v, effective_ttl) }
+          true
+        end
+      rescue StandardError => e
+        log_cache_error('local_cache_mset', e)
+        false
+      end
+
+      # --- RedisHash Helpers (shared tier) ---
+      # Issue #4: namespaced wrappers for RedisHash operations with Memcached fallback
+
+      def cache_hset(key, hash)
+        if cache_redis?
+          Legion::Cache::RedisHash.hset(cache_namespace + key, hash)
+        else
+          memcached_hash_merge(cache_namespace + key, hash)
+        end
+      rescue StandardError => e
+        log_cache_error('cache_hset', e)
+        false
+      end
+
+      def cache_hgetall(key)
+        if cache_redis?
+          Legion::Cache::RedisHash.hgetall(cache_namespace + key)
+        else
+          memcached_hash_load(cache_namespace + key)
+        end
+      rescue StandardError => e
+        log_cache_error('cache_hgetall', e)
+        nil
+      end
+
+      def cache_hdel(key, *fields)
+        if cache_redis?
+          Legion::Cache::RedisHash.hdel(cache_namespace + key, *fields)
+        else
+          memcached_hash_delete_fields(cache_namespace + key, fields)
+        end
+      rescue StandardError => e
+        log_cache_error('cache_hdel', e)
+        0
+      end
+
+      def cache_zadd(key, score, member)
+        raise_sorted_set_unsupported('cache_zadd') unless cache_redis?
+
+        Legion::Cache::RedisHash.zadd(cache_namespace + key, score, member)
+      rescue NotImplementedError
+        raise
+      rescue StandardError => e
+        log_cache_error('cache_zadd', e)
+        false
+      end
+
+      def cache_zrangebyscore(key, min, max, limit: nil)
+        raise_sorted_set_unsupported('cache_zrangebyscore') unless cache_redis?
+
+        Legion::Cache::RedisHash.zrangebyscore(cache_namespace + key, min, max, limit: limit)
+      rescue NotImplementedError
+        raise
+      rescue StandardError => e
+        log_cache_error('cache_zrangebyscore', e)
+        []
+      end
+
+      def cache_zrem(key, member)
+        raise_sorted_set_unsupported('cache_zrem') unless cache_redis?
+
+        Legion::Cache::RedisHash.zrem(cache_namespace + key, member)
+      rescue NotImplementedError
+        raise
+      rescue StandardError => e
+        log_cache_error('cache_zrem', e)
+        false
+      end
+
+      # Sets TTL on a key. No-op on Memcached (TTL is set at write time).
+      def cache_expire(key, seconds)
+        return false unless cache_redis?
+
+        Legion::Cache::RedisHash.expire(cache_namespace + key, seconds)
+      rescue StandardError => e
+        log_cache_error('cache_expire', e)
+        false
+      end
+
       # --- Core Operations (local tier) ---
 
       def local_cache_set(key, value, ttl: nil, phi: false)
@@ -147,6 +303,56 @@ module Legion
               .gsub(/([a-z\d])([A-Z])/, '\1_\2')
               .downcase
       end
+
+      def cache_redis?
+        Legion::Cache::RedisHash.redis_available?
+      end
+
+      def local_cache_redis?
+        defined?(Legion::Cache::Local) &&
+          Legion::Cache::Local.respond_to?(:mget) &&
+          Legion::Cache::Local.connected?
+      end
+
+      def memcached_hash_merge(full_key, new_fields)
+        current = memcached_hash_load(full_key) || {}
+        merged = current.merge(new_fields.transform_keys(&:to_s))
+        Legion::Cache.set(full_key, Legion::JSON.dump(merged), cache_default_ttl)
+        true
+      end
+
+      def memcached_hash_load(full_key)
+        raw = Legion::Cache.get(full_key)
+        return nil if raw.nil?
+
+        parsed = Legion::JSON.load(raw)
+        # Legion::JSON.load returns symbol keys; convert to string keys to mirror Redis hgetall
+        parsed.transform_keys(&:to_s)
+      rescue StandardError
+        nil
+      end
+
+      def memcached_hash_delete_fields(full_key, fields)
+        current = memcached_hash_load(full_key)
+        return 0 if current.nil?
+
+        str_fields = fields.map(&:to_s)
+        removed = str_fields.count { |f| current.key?(f) }
+        str_fields.each { |f| current.delete(f) }
+        Legion::Cache.set(full_key, Legion::JSON.dump(current), cache_default_ttl)
+        removed
+      end
+
+      def raise_sorted_set_unsupported(method)
+        raise NotImplementedError,
+              "#{method} requires a Redis backend — sorted sets are not supported on Memcached"
+      end
+
+      def log_cache_error(method, error)
+        return unless defined?(Legion::Logging)
+
+        Legion::Logging.warn "[cache:helper] #{method} failed: #{error.class} — #{error.message}"
+      end
     end
   end
 end

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.3.18'
+    VERSION = '1.3.19'
   end
 end

metadata

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