mudis 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6207a8171eb9fd9723889d90a5a5e696dafc9a894c29d9b6f99340b7c02ec697
-  data.tar.gz: a18de4b21e8b4116c321393d0ada12da91c06682ff099907be84b6ac78c6f999
+  metadata.gz: aeea820874569fe79af99d53f2a3ae3a7a9b74dc8a2d9dccbfbaa3f4ebab3967
+  data.tar.gz: 211d8c786790478e861461aab7444bd4bd1342afa07039ef3608f66dbd401cd6
 SHA512:
-  metadata.gz: e44da4c093e85012cee92cc61be4062c48fe94fe46b22210c1433e47b8eef91755359a658f936075ee514a5adcbf5ea2dae184031042532d13907d619ab77876
-  data.tar.gz: 79c1703d2d03938d801d752c7cc3c7c98ed777933e85b091ece31180d1dd2b9eaf0af8e8b8bd30221750cd89aa5cfb2989e8914aa4ef09fe6d1316a3ee678024
+  metadata.gz: b93779c0990a328a3d24f4741b9934833e5524e099e2ddcdd2ae38f297e599f2cd49bd4fbc43d3cd1d1f81d2655220760b2573138ade72b289b785fc718c9bcd
+  data.tar.gz: bf25460f6237402793327d4bb04aef416d39f240e80350b8428433aa4245036cac0582f75e25b79c6902d21751403be9def2df01b9ebe54536ee39d229571590

data/README.md

@@ -190,6 +190,28 @@ Mudis.least_touched(5)
 # => returns top 5 least accessed keys
 ```
 
+#### `Mudis.keys(namespace:)`
+
+Returns all keys for a given namespace.
+
+```ruby
+Mudis.write("u1", "alpha", namespace: "users")
+Mudis.write("u2", "beta", namespace: "users")
+
+Mudis.keys(namespace: "users")
+# => ["u1", "u2"]
+
+```
+
+#### `Mudis.clear_namespace(namespace:)`
+
+Deletes all keys within a namespace.
+
+```ruby
+Mudis.clear_namespace("users")
+Mudis.read("u1", namespace: "users") # => nil
+```
+
 ---
 
 ## Rails Service Integration
@@ -536,7 +558,7 @@ Mudis is not intended to be a general-purpose, distributed caching platform. You
 
 #### API Enhancements
 
-- [ ] bulk_read(keys, namespace:): Batch retrieval of multiple keys with a single method call
+- [x] bulk_read(keys, namespace:): Batch retrieval of multiple keys with a single method call
 
 #### Safety & Policy Controls
 
@@ -545,7 +567,7 @@ Mudis is not intended to be a general-purpose, distributed caching platform. You
 
 #### Debugging
 
-- [ ] clear_namespace(namespace): Remove all keys in a namespace in one call
+- [x] clear_namespace(namespace): Remove all keys in a namespace in one call
 
 ---
 

data/lib/mudis/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-MUDIS_VERSION = "0.5.0"
+MUDIS_VERSION = "0.6.0"

data/lib/mudis.rb

@@ -383,6 +383,30 @@ class Mudis # rubocop:disable Metrics/ClassLength
       keys
     end
 
+    # Returns all keys in a specific namespace
+    def keys(namespace:)
+      raise ArgumentError, "namespace is required" unless namespace
+
+      prefix = "#{namespace}:"
+      all_keys.select { |key| key.start_with?(prefix) }.map { |key| key.delete_prefix(prefix) }
+    end
+
+    # Clears all keys in a specific namespace
+    def clear_namespace(namespace:)
+      raise ArgumentError, "namespace is required" unless namespace
+
+      prefix = "#{namespace}:"
+      buckets.times do |idx|
+        mutex = @mutexes[idx]
+        store = @stores[idx]
+
+        mutex.synchronize do
+          keys_to_delete = store.keys.select { |key| key.start_with?(prefix) }
+          keys_to_delete.each { |key| evict_key(idx, key) }
+        end
+      end
+    end
+
     # Returns the least-touched keys across all buckets
     def least_touched(n = 10) # rubocop:disable Metrics/MethodLength,Naming/MethodParameterName
       keys_with_touches = []

data/sig/mudis.rbs

@@ -39,6 +39,8 @@ class Mudis
   def self.clear: (String, ?namespace: String) -> void
   def self.replace: (String, untyped, ?expires_in: Integer, ?namespace: String) -> void
   def self.inspect: (String, ?namespace: String) -> Hash[Symbol, untyped]?
+  def self.keys: (?namespace: String) -> Array[String]
+  def self.clear_namespace: (?namespace: String) -> void
 
   # Introspection & management
   def self.metrics: () -> Hash[Symbol, untyped]

data/spec/eviction_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Mudis LRU Eviction" do
+  before do
+    Mudis.reset!
+    Mudis.stop_expiry_thread
+
+    Mudis.instance_variable_set(:@buckets, 1)
+    Mudis.instance_variable_set(:@stores, [{}])
+    Mudis.instance_variable_set(:@mutexes, [Mutex.new])
+    Mudis.instance_variable_set(:@lru_heads, [nil])
+    Mudis.instance_variable_set(:@lru_tails, [nil])
+    Mudis.instance_variable_set(:@lru_nodes, [{}])
+    Mudis.instance_variable_set(:@current_bytes, [0])
+    Mudis.hard_memory_limit = false
+    Mudis.instance_variable_set(:@threshold_bytes, 60)
+    Mudis.max_value_bytes = 100
+  end
+
+  it "evicts old entries when size limit is reached" do
+    Mudis.write("a", "a" * 50)
+    Mudis.write("b", "b" * 50)
+
+    expect(Mudis.read("a")).to be_nil
+    expect(Mudis.read("b")).not_to be_nil
+  end
+end

data/spec/memory_guard_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Mudis Memory Guardrails" do
+  before do
+    Mudis.reset!
+    Mudis.stop_expiry_thread
+    Mudis.instance_variable_set(:@buckets, 1)
+    Mudis.instance_variable_set(:@stores, [{}])
+    Mudis.instance_variable_set(:@mutexes, [Mutex.new])
+    Mudis.instance_variable_set(:@lru_heads, [nil])
+    Mudis.instance_variable_set(:@lru_tails, [nil])
+    Mudis.instance_variable_set(:@lru_nodes, [{}])
+    Mudis.instance_variable_set(:@current_bytes, [0])
+
+    Mudis.max_value_bytes = nil
+    Mudis.instance_variable_set(:@threshold_bytes, 1_000_000)
+    Mudis.hard_memory_limit = true
+    Mudis.instance_variable_set(:@max_bytes, 100)
+  end
+
+  it "rejects writes that exceed max memory" do
+    big_value = "a" * 90
+    Mudis.write("a", big_value)
+    expect(Mudis.read("a")).to eq(big_value)
+
+    big_value2 = "b" * 90
+    Mudis.write("b", big_value2)
+    expect(Mudis.read("b")).to be_nil
+    expect(Mudis.metrics[:rejected]).to be > 0
+  end
+end

data/spec/metrics_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe "Mudis Metrics" do # rubocop:disable Metrics/BlockLength
+  it "tracks hits and misses" do
+    Mudis.write("hit_me", "value")
+    Mudis.read("hit_me")
+    Mudis.read("miss_me")
+    metrics = Mudis.metrics
+    expect(metrics[:hits]).to eq(1)
+    expect(metrics[:misses]).to eq(1)
+  end
+
+  it "includes per-bucket stats" do
+    Mudis.write("a", "x" * 50)
+    metrics = Mudis.metrics
+    expect(metrics).to include(:buckets)
+    expect(metrics[:buckets]).to be_an(Array)
+    expect(metrics[:buckets].first).to include(:index, :keys, :memory_bytes, :lru_size)
+  end
+
+  it "resets only the metrics without clearing cache" do
+    Mudis.write("metrics_key", "value")
+    Mudis.read("metrics_key")
+    Mudis.read("missing_key")
+    expect(Mudis.metrics[:hits]).to eq(1)
+    expect(Mudis.metrics[:misses]).to eq(1)
+    Mudis.reset_metrics!
+    expect(Mudis.metrics[:hits]).to eq(0)
+    expect(Mudis.metrics[:misses]).to eq(0)
+    expect(Mudis.read("metrics_key")).to eq("value")
+  end
+end

data/spec/mudis_spec.rb

@@ -114,24 +114,6 @@ RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
     end
   end
 
-  describe "namespacing" do
-    it "uses thread-local namespace in block" do
-      Mudis.with_namespace("test") do
-        Mudis.write("foo", "bar")
-      end
-      expect(Mudis.read("foo", namespace: "test")).to eq("bar")
-      expect(Mudis.read("foo")).to be_nil
-    end
-
-    it "supports explicit namespace override" do
-      Mudis.write("x", 1, namespace: "alpha")
-      Mudis.write("x", 2, namespace: "beta")
-      expect(Mudis.read("x", namespace: "alpha")).to eq(1)
-      expect(Mudis.read("x", namespace: "beta")).to eq(2)
-      expect(Mudis.read("x")).to be_nil
-    end
-  end
-
   describe "expiry handling" do
     it "expires values after specified time" do
       Mudis.write("short_lived", "gone soon", expires_in: 1)
@@ -140,74 +122,6 @@ RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
     end
   end
 
-  describe ".metrics" do
-    it "tracks hits and misses" do
-      Mudis.write("hit_me", "value")
-      Mudis.read("hit_me")   # hit
-      Mudis.read("miss_me")  # miss
-      metrics = Mudis.metrics
-      expect(metrics[:hits]).to eq(1)
-      expect(metrics[:misses]).to eq(1)
-    end
-  end
-
-  describe "memory guards" do
-    before do
-      Mudis.stop_expiry_thread
-      Mudis.instance_variable_set(:@buckets, 1)
-      Mudis.instance_variable_set(:@stores, [{}])
-      Mudis.instance_variable_set(:@mutexes, [Mutex.new])
-      Mudis.instance_variable_set(:@lru_heads, [nil])
-      Mudis.instance_variable_set(:@lru_tails, [nil])
-      Mudis.instance_variable_set(:@lru_nodes, [{}])
-      Mudis.instance_variable_set(:@current_bytes, [0])
-
-      Mudis.max_value_bytes = nil
-      Mudis.instance_variable_set(:@threshold_bytes, 1_000_000) # optional
-      Mudis.hard_memory_limit = true
-      Mudis.instance_variable_set(:@max_bytes, 100) # artificially low
-    end
-
-    it "rejects writes that exceed max memory" do
-      big_value = "a" * 90
-      Mudis.write("a", big_value)
-      expect(Mudis.read("a")).to eq(big_value)
-
-      big_value_2 = "b" * 90 # rubocop:disable Naming/VariableNumber
-      Mudis.write("b", big_value_2)
-      expect(Mudis.read("b")).to be_nil
-      expect(Mudis.metrics[:rejected]).to be > 0
-    end
-  end
-
-  describe "LRU eviction" do
-    it "evicts old entries when size limit is reached" do
-      Mudis.stop_expiry_thread
-
-      # Force one bucket
-      Mudis.instance_variable_set(:@buckets, 1)
-      Mudis.instance_variable_set(:@stores, [{}])
-      Mudis.instance_variable_set(:@mutexes, [Mutex.new])
-      Mudis.instance_variable_set(:@lru_heads, [nil])
-      Mudis.instance_variable_set(:@lru_tails, [nil])
-      Mudis.instance_variable_set(:@lru_nodes, [{}])
-      Mudis.instance_variable_set(:@current_bytes, [0])
-      Mudis.hard_memory_limit = false
-      # Set very small threshold
-      Mudis.instance_variable_set(:@threshold_bytes, 60)
-      Mudis.max_value_bytes = 100
-
-      big_val1 = "a" * 50
-      big_val2 = "b" * 50
-
-      Mudis.write("a", big_val1)
-      Mudis.write("b", big_val2)
-
-      expect(Mudis.read("a")).to be_nil
-      expect(Mudis.read("b")).not_to be_nil
-    end
-  end
-
   describe ".all_keys" do
     it "lists all stored keys" do
       Mudis.write("k1", 1)
@@ -223,22 +137,16 @@ RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
 
   describe ".current_memory_bytes" do
     it "returns a non-zero byte count after writes" do
+      Mudis.configure do |c|
+        c.max_value_bytes = nil
+        c.hard_memory_limit = false
+      end
+
       Mudis.write("size_test", "a" * 100)
       expect(Mudis.current_memory_bytes).to be > 0
     end
   end
 
-  describe ".metrics" do
-    it "includes per-bucket stats" do
-      Mudis.write("a", "x" * 50)
-      metrics = Mudis.metrics
-
-      expect(metrics).to include(:buckets)
-      expect(metrics[:buckets]).to be_an(Array)
-      expect(metrics[:buckets].first).to include(:index, :keys, :memory_bytes, :lru_size)
-    end
-  end
-
   describe ".least_touched" do
     it "returns keys with lowest read access counts" do
       Mudis.reset!
@@ -272,43 +180,4 @@ RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
       expect(Mudis.max_bytes).to eq(987_654)
     end
   end
-
-  describe ".reset!" do
-    it "clears all stores, memory, and metrics" do
-      Mudis.write("reset_key", "value")
-      expect(Mudis.read("reset_key")).to eq("value")
-      expect(Mudis.current_memory_bytes).to be > 0
-      expect(Mudis.metrics[:hits]).to be >= 0
-
-      Mudis.reset!
-
-      metrics = Mudis.metrics
-      expect(metrics[:hits]).to eq(0)
-      expect(metrics[:misses]).to eq(0)
-      expect(metrics[:evictions]).to eq(0)
-      expect(metrics[:rejected]).to eq(0)
-      expect(Mudis.current_memory_bytes).to eq(0)
-      expect(Mudis.all_keys).to be_empty
-
-      # Optionally confirm reset_key is now gone
-      expect(Mudis.read("reset_key")).to be_nil
-    end
-  end
-
-  describe ".reset_metrics!" do
-    it "resets only the metrics without clearing cache" do
-      Mudis.write("metrics_key", "value")
-      Mudis.read("metrics_key")  # generates :hits
-      Mudis.read("missing_key")  # generates :misses
-
-      expect(Mudis.metrics[:hits]).to eq(1)
-      expect(Mudis.metrics[:misses]).to eq(1)
-
-      Mudis.reset_metrics!
-
-      expect(Mudis.metrics[:hits]).to eq(0)
-      expect(Mudis.metrics[:misses]).to eq(0)
-      expect(Mudis.read("metrics_key")).to eq("value") # still exists
-    end
-  end
 end

data/spec/namespace_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Mudis Namespace Operations" do # rubocop:disable Metrics/BlockLength
+  before(:each) do
+    Mudis.reset!
+  end
+
+  it "uses thread-local namespace in block" do
+    Mudis.with_namespace("test") do
+      Mudis.write("foo", "bar")
+    end
+    expect(Mudis.read("foo", namespace: "test")).to eq("bar")
+    expect(Mudis.read("foo")).to be_nil
+  end
+
+  it "supports explicit namespace override" do
+    Mudis.write("x", 1, namespace: "alpha")
+    Mudis.write("x", 2, namespace: "beta")
+    expect(Mudis.read("x", namespace: "alpha")).to eq(1)
+    expect(Mudis.read("x", namespace: "beta")).to eq(2)
+    expect(Mudis.read("x")).to be_nil
+  end
+
+  describe ".keys" do
+    it "returns only keys for the given namespace" do
+      Mudis.write("user:1", "Alice", namespace: "users")
+      Mudis.write("user:2", "Bob", namespace: "users")
+      Mudis.write("admin:1", "Charlie", namespace: "admins")
+
+      result = Mudis.keys(namespace: "users")
+      expect(result).to contain_exactly("user:1", "user:2")
+    end
+
+    it "returns an empty array if no keys exist for namespace" do
+      expect(Mudis.keys(namespace: "nonexistent")).to eq([])
+    end
+
+    it "raises an error if namespace is missing" do
+      expect { Mudis.keys(namespace: nil) }.to raise_error(ArgumentError, /namespace is required/)
+    end
+  end
+
+  describe ".clear_namespace" do
+    it "deletes all keys in the given namespace" do
+      Mudis.write("a", 1, namespace: "ns1")
+      Mudis.write("b", 2, namespace: "ns1")
+      Mudis.write("x", 9, namespace: "ns2")
+
+      expect(Mudis.read("a", namespace: "ns1")).to eq(1)
+      expect(Mudis.read("b", namespace: "ns1")).to eq(2)
+
+      Mudis.clear_namespace(namespace: "ns1")
+
+      expect(Mudis.read("a", namespace: "ns1")).to be_nil
+      expect(Mudis.read("b", namespace: "ns1")).to be_nil
+      expect(Mudis.read("x", namespace: "ns2")).to eq(9)
+    end
+
+    it "does nothing if namespace has no keys" do
+      expect { Mudis.clear_namespace(namespace: "ghost") }.not_to raise_error
+    end
+
+    it "raises an error if namespace is nil" do
+      expect { Mudis.clear_namespace(namespace: nil) }.to raise_error(ArgumentError, /namespace is required/)
+    end
+  end
+end

data/spec/reset_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Mudis Reset Features" do
+  before { Mudis.reset! }
+
+  describe ".reset!" do
+    it "clears all stores, memory, and metrics" do
+      Mudis.write("reset_key", "value")
+      expect(Mudis.read("reset_key")).to eq("value")
+      Mudis.reset!
+      expect(Mudis.metrics[:hits]).to eq(0)
+      expect(Mudis.all_keys).to be_empty
+      expect(Mudis.read("reset_key")).to be_nil
+    end
+  end
+
+  describe ".reset_metrics!" do
+    it "resets only the metrics without clearing cache" do
+      Mudis.write("metrics_key", "value")
+      Mudis.read("metrics_key")
+      Mudis.read("missing_key")
+      expect(Mudis.metrics[:hits]).to eq(1)
+      expect(Mudis.metrics[:misses]).to eq(1)
+      Mudis.reset_metrics!
+      expect(Mudis.metrics[:hits]).to eq(0)
+      expect(Mudis.read("metrics_key")).to eq("value")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mudis
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - kiebor81
@@ -54,8 +54,13 @@ files:
 - lib/mudis_config.rb
 - sig/mudis.rbs
 - sig/mudis_config.rbs
+- spec/eviction_spec.rb
 - spec/guardrails_spec.rb
+- spec/memory_guard_spec.rb
+- spec/metrics_spec.rb
 - spec/mudis_spec.rb
+- spec/namespace_spec.rb
+- spec/reset_spec.rb
 homepage: https://github.com/kiebor81/mudis
 licenses:
 - MIT
@@ -81,5 +86,10 @@ specification_version: 4
 summary: A fast in-memory, thread-safe and high performance Ruby LRU cache with compression
   and auto-expiry.
 test_files:
+- spec/eviction_spec.rb
 - spec/guardrails_spec.rb
+- spec/memory_guard_spec.rb
+- spec/metrics_spec.rb
 - spec/mudis_spec.rb
+- spec/namespace_spec.rb
+- spec/reset_spec.rb