mudis 0.8.0 → 0.8.1

data/spec/mudis_spec.rb

@@ -1,183 +1,183 @@
-# frozen_string_literal: true
-
-require_relative "spec_helper"
-
-RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
-  before(:each) do
-    Mudis.stop_expiry_thread
-    Mudis.instance_variable_set(:@buckets, nil)
-    Mudis.instance_variable_set(:@stores, Array.new(Mudis.buckets) { {} })
-    Mudis.instance_variable_set(:@mutexes, Array.new(Mudis.buckets) { Mutex.new })
-    Mudis.instance_variable_set(:@lru_heads, Array.new(Mudis.buckets) { nil })
-    Mudis.instance_variable_set(:@lru_tails, Array.new(Mudis.buckets) { nil })
-    Mudis.instance_variable_set(:@lru_nodes, Array.new(Mudis.buckets) { {} })
-    Mudis.instance_variable_set(:@current_bytes, Array.new(Mudis.buckets, 0))
-    Mudis.instance_variable_set(:@metrics, { hits: 0, misses: 0, evictions: 0, rejected: 0 })
-    Mudis.serializer = JSON
-    Mudis.compress = false
-    Mudis.max_value_bytes = nil
-  end
-
-  describe ".write and .read" do
-    it "writes and reads a value" do
-      Mudis.write("foo", { bar: "baz" })
-      result = Mudis.read("foo")
-      expect(result).to eq({ "bar" => "baz" })
-    end
-
-    it "returns nil for non-existent keys" do
-      expect(Mudis.read("nope")).to be_nil
-    end
-  end
-
-  describe ".exists?" do
-    it "returns true if key exists" do
-      Mudis.write("check", [1, 2, 3])
-      expect(Mudis.exists?("check")).to be true
-    end
-
-    it "returns false if key does not exist" do
-      expect(Mudis.exists?("missing")).to be false
-    end
-  end
-
-  describe ".delete" do
-    it "deletes a key" do
-      Mudis.write("temp", 42)
-      Mudis.delete("temp")
-      expect(Mudis.read("temp")).to be_nil
-    end
-  end
-
-  describe ".update" do
-    it "updates a cached value" do
-      Mudis.write("counter", 5)
-      Mudis.update("counter") { |v| v + 1 }
-      expect(Mudis.read("counter")).to eq(6)
-    end
-  end
-
-  describe ".fetch" do
-    it "returns cached value if exists" do
-      Mudis.write("k", 123)
-      result = Mudis.fetch("k", expires_in: 60) { 999 } # fix: use keyword arg
-      expect(result).to eq(123)
-    end
-
-    it "writes and returns block result if missing" do
-      Mudis.delete("k")
-      result = Mudis.fetch("k", expires_in: 60) { 999 } # fix
-      expect(result).to eq(999)
-      expect(Mudis.read("k")).to eq(999)
-    end
-
-    it "forces overwrite if force: true" do
-      Mudis.write("k", 100)
-      result = Mudis.fetch("k", force: true) { 200 } # fix
-      expect(result).to eq(200)
-    end
-  end
-
-  describe ".clear" do
-    it "removes a key from the cache" do
-      Mudis.write("to_clear", 123)
-      expect(Mudis.read("to_clear")).to eq(123)
-      Mudis.clear("to_clear")
-      expect(Mudis.read("to_clear")).to be_nil
-    end
-  end
-
-  describe ".replace" do
-    it "replaces value only if key exists" do
-      Mudis.write("to_replace", 100)
-      Mudis.replace("to_replace", 200)
-      expect(Mudis.read("to_replace")).to eq(200)
-
-      Mudis.delete("to_replace")
-      Mudis.replace("to_replace", 300)
-      expect(Mudis.read("to_replace")).to be_nil
-    end
-  end
-
-  describe ".inspect" do
-    it "returns metadata for a cached key" do
-      Mudis.write("key1", "abc", expires_in: 60)
-      meta = Mudis.inspect("key1")
-
-      expect(meta).to include(:key, :bucket, :expires_at, :created_at, :size_bytes, :compressed)
-      expect(meta[:key]).to eq("key1")
-      expect(meta[:compressed]).to eq(false)
-    end
-
-    it "returns nil for missing key" do
-      expect(Mudis.inspect("unknown")).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)
-      sleep 2
-      expect(Mudis.read("short_lived")).to be_nil
-    end
-  end
-
-  describe ".all_keys" do
-    it "lists all stored keys" do
-      Mudis.write("k1", 1)
-      Mudis.write("k2", 2)
-      expect(Mudis.all_keys).to include("k1", "k2")
-    end
-  end
-
-  it "respects max_bytes when updated externally" do
-    Mudis.max_bytes = 100
-    expect(Mudis.send(:max_bytes)).to eq(100)
-  end
-
-  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 ".least_touched" do
-    it "returns keys with lowest read access counts" do
-      Mudis.reset!
-      Mudis.write("a", 1)
-      Mudis.write("b", 2)
-      Mudis.write("c", 3)
-
-      Mudis.read("a")
-      Mudis.read("a")
-      Mudis.read("b")
-
-      least = Mudis.least_touched(2)
-      expect(least.map(&:first)).to include("c") # Never read
-      expect(least.first.last).to eq(0)
-    end
-  end
-
-  describe ".configure" do
-    it "applies configuration settings correctly" do
-      Mudis.configure do |c|
-        c.serializer = JSON
-        c.compress = true
-        c.max_value_bytes = 12_345
-        c.hard_memory_limit = true
-        c.max_bytes = 987_654
-      end
-
-      expect(Mudis.compress).to eq(true)
-      expect(Mudis.max_value_bytes).to eq(12_345)
-      expect(Mudis.hard_memory_limit).to eq(true)
-      expect(Mudis.max_bytes).to eq(987_654)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
+  before(:each) do
+    Mudis.stop_expiry_thread
+    Mudis.instance_variable_set(:@buckets, nil)
+    Mudis.instance_variable_set(:@stores, Array.new(Mudis.buckets) { {} })
+    Mudis.instance_variable_set(:@mutexes, Array.new(Mudis.buckets) { Mutex.new })
+    Mudis.instance_variable_set(:@lru_heads, Array.new(Mudis.buckets) { nil })
+    Mudis.instance_variable_set(:@lru_tails, Array.new(Mudis.buckets) { nil })
+    Mudis.instance_variable_set(:@lru_nodes, Array.new(Mudis.buckets) { {} })
+    Mudis.instance_variable_set(:@current_bytes, Array.new(Mudis.buckets, 0))
+    Mudis.instance_variable_set(:@metrics, { hits: 0, misses: 0, evictions: 0, rejected: 0 })
+    Mudis.serializer = JSON
+    Mudis.compress = false
+    Mudis.max_value_bytes = nil
+  end
+
+  describe ".write and .read" do
+    it "writes and reads a value" do
+      Mudis.write("foo", { bar: "baz" })
+      result = Mudis.read("foo")
+      expect(result).to eq({ "bar" => "baz" })
+    end
+
+    it "returns nil for non-existent keys" do
+      expect(Mudis.read("nope")).to be_nil
+    end
+  end
+
+  describe ".exists?" do
+    it "returns true if key exists" do
+      Mudis.write("check", [1, 2, 3])
+      expect(Mudis.exists?("check")).to be true
+    end
+
+    it "returns false if key does not exist" do
+      expect(Mudis.exists?("missing")).to be false
+    end
+  end
+
+  describe ".delete" do
+    it "deletes a key" do
+      Mudis.write("temp", 42)
+      Mudis.delete("temp")
+      expect(Mudis.read("temp")).to be_nil
+    end
+  end
+
+  describe ".update" do
+    it "updates a cached value" do
+      Mudis.write("counter", 5)
+      Mudis.update("counter") { |v| v + 1 }
+      expect(Mudis.read("counter")).to eq(6)
+    end
+  end
+
+  describe ".fetch" do
+    it "returns cached value if exists" do
+      Mudis.write("k", 123)
+      result = Mudis.fetch("k", expires_in: 60) { 999 } # fix: use keyword arg
+      expect(result).to eq(123)
+    end
+
+    it "writes and returns block result if missing" do
+      Mudis.delete("k")
+      result = Mudis.fetch("k", expires_in: 60) { 999 } # fix
+      expect(result).to eq(999)
+      expect(Mudis.read("k")).to eq(999)
+    end
+
+    it "forces overwrite if force: true" do
+      Mudis.write("k", 100)
+      result = Mudis.fetch("k", force: true) { 200 } # fix
+      expect(result).to eq(200)
+    end
+  end
+
+  describe ".clear" do
+    it "removes a key from the cache" do
+      Mudis.write("to_clear", 123)
+      expect(Mudis.read("to_clear")).to eq(123)
+      Mudis.clear("to_clear")
+      expect(Mudis.read("to_clear")).to be_nil
+    end
+  end
+
+  describe ".replace" do
+    it "replaces value only if key exists" do
+      Mudis.write("to_replace", 100)
+      Mudis.replace("to_replace", 200)
+      expect(Mudis.read("to_replace")).to eq(200)
+
+      Mudis.delete("to_replace")
+      Mudis.replace("to_replace", 300)
+      expect(Mudis.read("to_replace")).to be_nil
+    end
+  end
+
+  describe ".inspect" do
+    it "returns metadata for a cached key" do
+      Mudis.write("key1", "abc", expires_in: 60)
+      meta = Mudis.inspect("key1")
+
+      expect(meta).to include(:key, :bucket, :expires_at, :created_at, :size_bytes, :compressed)
+      expect(meta[:key]).to eq("key1")
+      expect(meta[:compressed]).to eq(false)
+    end
+
+    it "returns nil for missing key" do
+      expect(Mudis.inspect("unknown")).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)
+      sleep 2
+      expect(Mudis.read("short_lived")).to be_nil
+    end
+  end
+
+  describe ".all_keys" do
+    it "lists all stored keys" do
+      Mudis.write("k1", 1)
+      Mudis.write("k2", 2)
+      expect(Mudis.all_keys).to include("k1", "k2")
+    end
+  end
+
+  it "respects max_bytes when updated externally" do
+    Mudis.max_bytes = 100
+    expect(Mudis.send(:max_bytes)).to eq(100)
+  end
+
+  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 ".least_touched" do
+    it "returns keys with lowest read access counts" do
+      Mudis.reset!
+      Mudis.write("a", 1)
+      Mudis.write("b", 2)
+      Mudis.write("c", 3)
+
+      Mudis.read("a")
+      Mudis.read("a")
+      Mudis.read("b")
+
+      least = Mudis.least_touched(2)
+      expect(least.map(&:first)).to include("c") # Never read
+      expect(least.first.last).to eq(0)
+    end
+  end
+
+  describe ".configure" do
+    it "applies configuration settings correctly" do
+      Mudis.configure do |c|
+        c.serializer = JSON
+        c.compress = true
+        c.max_value_bytes = 12_345
+        c.hard_memory_limit = true
+        c.max_bytes = 987_654
+      end
+
+      expect(Mudis.compress).to eq(true)
+      expect(Mudis.max_value_bytes).to eq(12_345)
+      expect(Mudis.hard_memory_limit).to eq(true)
+      expect(Mudis.max_bytes).to eq(987_654)
+    end
+  end
+end

data/spec/namespace_spec.rb

@@ -1,69 +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
+# 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/persistence_spec.rb

@@ -1,37 +1,38 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "fileutils"
-
-RSpec.describe "Mudis soft persistence" do
-  let(:path) { "tmp/test_mudis_snapshot.dump" }
-
-  before do
-    FileUtils.rm_f(path)
-    Mudis.reset!
-    Mudis.configure do |c|
-      c.persistence_enabled = true
-      c.persistence_path    = path
-      c.persistence_format  = :marshal
-    end
-  end
-
-  it "saves on exit and loads on next boot" do
-    Mudis.write("k1", "v1", expires_in: 60)
-    # simulate shutdown
-    Mudis.save_snapshot!
-    Mudis.reset!
-
-    # simulate fresh boot (apply config + load)
-    Mudis.apply_config! # if not public, re-configure to trigger load
-    Mudis.load_snapshot!
-
-    expect(Mudis.read("k1")).to eq("v1")
-  end
-
-  it "does nothing when file missing" do
-    Mudis.reset!
-    Mudis.configure { |c| c.persistence_enabled = true; c.persistence_path = path }
-    Mudis.load_snapshot! # no file
-    expect(Mudis.read("any")).to be_nil
-  end
-end
+# frozen_string_literal: true
+
+require "spec_helper"
+require "fileutils"
+
+RSpec.describe "Mudis soft persistence" do
+  let(:path) { "tmp/test_mudis_snapshot.dump" }
+
+  before do
+    FileUtils.rm_f(path)
+    Mudis.reset!
+    Mudis.configure do |c|
+      c.persistence_enabled = true
+      c.persistence_path    = path
+      c.persistence_format  = :marshal
+    end
+  end
+
+  it "saves on exit and loads on next boot" do
+    Mudis.write("k1", "v1", expires_in: 60)
+    # simulate shutdown
+    Mudis.save_snapshot!
+    Mudis.reset!
+
+    # simulate fresh boot (apply config + load)
+    Mudis.apply_config! # if not public, re-configure to trigger load
+    Mudis.load_snapshot!
+
+    expect(Mudis.read("k1")).to eq("v1")
+  end
+
+  it "does nothing when file missing" do
+    Mudis.reset!
+    Mudis.configure { |c| c.persistence_enabled = true; c.persistence_path = path } # rubocop:disable Style/Semicolon
+    Mudis.load_snapshot! # no file
+    expect(Mudis.read("any")).to be_nil
+  end
+end

data/spec/reset_spec.rb

@@ -1,31 +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
+# 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