mudis 0.8.0 → 0.9.0

data/sig/mudis_client.rbs

@@ -1,23 +1,25 @@
-class MudisClient
-  SOCKET_PATH: String
-
-  def initialize: () -> void
-
-  def request: (payload: { cmd: String, key?: String, value?: untyped, ttl?: Integer?, namespace?: String? }) -> untyped
-
-  def read: (key: String, namespace?: String?) -> untyped
-
-  def write: (key: String, value: untyped, expires_in?: Integer?, namespace?: String?) -> untyped
-
-  def delete: (key: String, namespace?: String?) -> untyped
-
-  def exists?: (key: String, namespace?: String?) -> bool
-
-  def fetch: (key: String, expires_in?: Integer?, namespace?: String?, &block: { () -> untyped }) -> untyped
-
-  def metrics: () -> { reads: Integer, writes: Integer, deletes: Integer, exists: Integer }
-
-  def reset_metrics!: () -> void
-
-  def reset!: () -> void
+class MudisClient
+  include MudisIPCConfig
+
+  def initialize: () -> void
+
+  def open_connection: () -> (TCPSocket | UNIXSocket)
+
+  def request: (payload: { cmd: String, key?: String, value?: untyped, ttl?: Integer?, namespace?: String? }) -> untyped
+
+  def read: (key: String, namespace?: String?) -> untyped
+
+  def write: (key: String, value: untyped, expires_in?: Integer?, namespace?: String?) -> untyped
+
+  def delete: (key: String, namespace?: String?) -> untyped
+
+  def exists?: (key: String, namespace?: String?) -> bool
+
+  def fetch: (key: String, expires_in?: Integer?, namespace?: String?, &block: { () -> untyped }) -> untyped
+
+  def metrics: () -> { reads: Integer, writes: Integer, deletes: Integer, exists: Integer }
+
+  def reset_metrics!: () -> void
+
+  def reset!: () -> void
 end

data/sig/mudis_config.rbs

@@ -1,10 +1,10 @@
-class MudisConfig
-  attr_accessor serializer: Object
-  attr_accessor compress: bool
-  attr_accessor max_value_bytes: Integer?
-  attr_accessor hard_memory_limit: bool
-  attr_accessor max_bytes: Integer
-  attr_accessor max_ttl: Integer?
-  attr_accessor default_ttl: Integer?
-  attr_accessor buckets: Integer?
-end
+class MudisConfig
+  attr_accessor serializer: Object
+  attr_accessor compress: bool
+  attr_accessor max_value_bytes: Integer?
+  attr_accessor hard_memory_limit: bool
+  attr_accessor max_bytes: Integer
+  attr_accessor max_ttl: Integer?
+  attr_accessor default_ttl: Integer?
+  attr_accessor buckets: Integer?
+end

data/sig/mudis_expiry.rbs

@@ -0,0 +1,13 @@
+class Mudis
+  module Expiry
+    def start_expiry_thread: (?interval: Integer) -> void
+
+    def stop_expiry_thread: () -> void
+
+    def cleanup_expired!: () -> void
+
+    private
+
+    def effective_ttl: (?expires_in: Integer?) -> Integer?
+  end
+end

data/sig/mudis_ipc_config.rbs

@@ -0,0 +1,10 @@
+# Shared configuration for IPC mode (server and client)
+module MudisIPCConfig
+  SOCKET_PATH: String
+
+  TCP_HOST: String
+
+  TCP_PORT: Integer
+
+  def self.use_tcp?: () -> bool
+end

data/sig/mudis_lru.rbs

@@ -0,0 +1,21 @@
+class Mudis
+  class LRUNode
+    attr_accessor key: String
+    attr_accessor prev: LRUNode?
+    attr_accessor next: LRUNode?
+
+    def initialize: (String) -> void
+  end
+
+  module LRU
+    private
+
+    def evict_key: (Integer, String) -> void
+
+    def insert_lru: (Integer, LRUNode) -> void
+
+    def promote_lru: (Integer, String) -> void
+
+    def remove_node: (Integer, LRUNode) -> void
+  end
+end

data/sig/mudis_metrics.rbs

@@ -0,0 +1,11 @@
+class Mudis
+  module Metrics
+    def metrics: () -> Hash[Symbol, untyped]
+
+    def reset_metrics!: () -> void
+
+    private
+
+    def metric: (Symbol) -> void
+  end
+end

data/sig/mudis_namespace.rbs

@@ -0,0 +1,13 @@
+class Mudis
+  module Namespace
+    def keys: (namespace: String) -> Array[String]
+
+    def clear_namespace: (namespace: String) -> void
+
+    def with_namespace: (namespace: String) { () -> untyped } -> untyped
+
+    private
+
+    def namespaced_key: (String, ?namespace: String?) -> String
+  end
+end

data/sig/mudis_persistence.rbs

@@ -0,0 +1,19 @@
+class Mudis
+  module Persistence
+    def save_snapshot!: () -> void
+
+    def load_snapshot!: () -> void
+
+    def install_persistence_hook!: () -> void
+
+    private
+
+    def snapshot_dump: () -> Hash[String, untyped]
+
+    def snapshot_restore: (Hash[String, untyped]) -> void
+
+    def safe_write_snapshot: (Hash[String, untyped]) -> void
+
+    def read_snapshot: () -> Hash[String, untyped]
+  end
+end

data/sig/mudis_server.rbs

@@ -1,7 +1,17 @@
-class MudisServer
-  SOCKET_PATH: String
-
-  def self.start!: () -> void
-
-  def self.handle_client: (sock: UNIXSocket) -> void
+class MudisServer
+  include MudisIPCConfig
+
+  def self.start!: () -> void
+
+  def self.start_tcp_server!: () -> void
+
+  def self.start_unix_server!: () -> void
+
+  def self.accept_connections: (server: (TCPServer | UNIXServer)) -> void
+
+  def self.handle_client: (socket: (TCPSocket | UNIXSocket)) -> void
+
+  def self.process_request: (req: Hash[String, untyped]) -> Hash[Symbol, untyped]
+
+  def self.write_response: (socket: (TCPSocket | UNIXSocket), payload: Hash[Symbol, untyped]) -> void
 end

data/spec/api_compatibility_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe "Mudis Public API" do
+  describe "ensures no breaking changes" do
+    it "exposes all core cache operations" do
+      expect(Mudis).to respond_to(:read)
+      expect(Mudis).to respond_to(:write)
+      expect(Mudis).to respond_to(:delete)
+      expect(Mudis).to respond_to(:exists?)
+      expect(Mudis).to respond_to(:update)
+      expect(Mudis).to respond_to(:fetch)
+      expect(Mudis).to respond_to(:clear)
+      expect(Mudis).to respond_to(:replace)
+      expect(Mudis).to respond_to(:inspect)
+    end
+
+    it "exposes all configuration methods" do
+      expect(Mudis).to respond_to(:configure)
+      expect(Mudis).to respond_to(:config)
+      expect(Mudis).to respond_to(:serializer)
+      expect(Mudis).to respond_to(:serializer=)
+      expect(Mudis).to respond_to(:compress)
+      expect(Mudis).to respond_to(:compress=)
+      expect(Mudis).to respond_to(:max_bytes)
+      expect(Mudis).to respond_to(:max_bytes=)
+      expect(Mudis).to respond_to(:max_value_bytes)
+      expect(Mudis).to respond_to(:max_value_bytes=)
+      expect(Mudis).to respond_to(:hard_memory_limit)
+      expect(Mudis).to respond_to(:hard_memory_limit=)
+      expect(Mudis).to respond_to(:max_ttl)
+      expect(Mudis).to respond_to(:max_ttl=)
+      expect(Mudis).to respond_to(:default_ttl)
+      expect(Mudis).to respond_to(:default_ttl=)
+    end
+
+    it "exposes all metrics methods" do
+      expect(Mudis).to respond_to(:metrics)
+      expect(Mudis).to respond_to(:reset_metrics!)
+    end
+
+    it "exposes all expiry methods" do
+      expect(Mudis).to respond_to(:start_expiry_thread)
+      expect(Mudis).to respond_to(:stop_expiry_thread)
+      expect(Mudis).to respond_to(:cleanup_expired!)
+    end
+
+    it "exposes all namespace methods" do
+      expect(Mudis).to respond_to(:keys)
+      expect(Mudis).to respond_to(:clear_namespace)
+      expect(Mudis).to respond_to(:with_namespace)
+    end
+
+    it "exposes all persistence methods" do
+      expect(Mudis).to respond_to(:save_snapshot!)
+      expect(Mudis).to respond_to(:load_snapshot!)
+    end
+
+    it "exposes all utility methods" do
+      expect(Mudis).to respond_to(:reset!)
+      expect(Mudis).to respond_to(:all_keys)
+      expect(Mudis).to respond_to(:current_memory_bytes)
+      expect(Mudis).to respond_to(:max_memory_bytes)
+      expect(Mudis).to respond_to(:least_touched)
+      expect(Mudis).to respond_to(:buckets)
+    end
+
+    it "maintains backward compatibility with method signatures" do
+      # Core operations accept namespace parameter
+      expect(Mudis.method(:read).parameters).to include([:key, :namespace])
+      expect(Mudis.method(:write).parameters).to include([:key, :namespace])
+      expect(Mudis.method(:delete).parameters).to include([:key, :namespace])
+      expect(Mudis.method(:exists?).parameters).to include([:key, :namespace])
+      
+      # Fetch accepts expires_in, force, and namespace
+      expect(Mudis.method(:fetch).parameters).to include([:key, :expires_in])
+      expect(Mudis.method(:fetch).parameters).to include([:key, :force])
+      expect(Mudis.method(:fetch).parameters).to include([:key, :namespace])
+    end
+
+    it "verifies LRUNode class is still accessible" do
+      expect(defined?(Mudis::LRUNode)).to be_truthy
+      node = Mudis::LRUNode.new("test_key")
+      expect(node).to respond_to(:key)
+      expect(node).to respond_to(:prev)
+      expect(node).to respond_to(:next)
+    end
+
+    it "verifies all public methods work correctly" do
+      Mudis.reset!
+      
+      # Write and read
+      Mudis.write("test", "value")
+      expect(Mudis.read("test")).to eq("value")
+      
+      # Exists
+      expect(Mudis.exists?("test")).to be true
+      
+      # Update
+      Mudis.update("test") { |v| v.upcase }
+      expect(Mudis.read("test")).to eq("VALUE")
+      
+      # Fetch
+      result = Mudis.fetch("new_key") { "new_value" }
+      expect(result).to eq("new_value")
+      
+      # Replace
+      Mudis.replace("test", "replaced")
+      expect(Mudis.read("test")).to eq("replaced")
+      
+      # Inspect
+      meta = Mudis.inspect("test")
+      expect(meta).to include(:key, :bucket, :created_at, :size_bytes)
+      
+      # Namespace operations
+      Mudis.write("k1", "v1", namespace: "ns1")
+      expect(Mudis.keys(namespace: "ns1")).to include("k1")
+      
+      Mudis.with_namespace("ns2") do
+        Mudis.write("k2", "v2")
+      end
+      expect(Mudis.keys(namespace: "ns2")).to include("k2")
+      
+      # Clear namespace
+      Mudis.clear_namespace(namespace: "ns1")
+      expect(Mudis.keys(namespace: "ns1")).to be_empty
+      
+      # Metrics
+      metrics = Mudis.metrics
+      expect(metrics).to include(:hits, :misses, :evictions, :total_memory, :buckets)
+      
+      # Least touched
+      touched = Mudis.least_touched(5)
+      expect(touched).to be_an(Array)
+      
+      # All keys
+      keys = Mudis.all_keys
+      expect(keys).to be_an(Array)
+      
+      # Memory tracking
+      expect(Mudis.current_memory_bytes).to be > 0
+      expect(Mudis.max_memory_bytes).to be > 0
+      
+      # Delete
+      Mudis.delete("test")
+      expect(Mudis.exists?("test")).to be false
+      
+      # Clear (alias for delete)
+      Mudis.write("to_clear", "value")
+      Mudis.clear("to_clear")
+      expect(Mudis.exists?("to_clear")).to be false
+    end
+  end
+end

data/spec/eviction_spec.rb

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