mudis 0.7.0 → 0.7.1

data/lib/mudis_client.rb

@@ -1,68 +1,65 @@
-# frozen_string_literal: true
-require "socket"
-require "json"
-
-class MudisClient
-  SOCKET_PATH = "/tmp/mudis.sock"
-
-  def initialize
-    @mutex = Mutex.new
-  end
-
-  def request(payload)
-    @mutex.synchronize do
-      UNIXSocket.open(SOCKET_PATH) do |sock|
-        sock.puts(JSON.dump(payload))
-        response = sock.gets
-        res = JSON.parse(response, symbolize_names: true)
-        raise res[:error] unless res[:ok]
-        res[:value]
-        
-      end
-
-    rescue Errno::ENOENT
-      warn "[MudisClient] Socket missing; master likely not running MudisServer"
-      nil
-
-    end
-
-  end
-
-  def read(key, namespace: nil)
-    request(cmd: "read", key: key, namespace: namespace)
-  end
-
-  def write(key, value, expires_in: nil, namespace: nil)
-    request(cmd: "write", key: key, value: value, ttl: expires_in, namespace: namespace)
-  end
-
-  def delete(key, namespace: nil)
-    request(cmd: "delete", key: key, namespace: namespace)
-  end
-
-  def exists?(key, namespace: nil)
-    request(cmd: "exists", key: key, namespace: namespace)
-  end
-
-  def fetch(key, expires_in: nil, namespace: nil)
-    val = read(key, namespace: namespace)
-    return val if val
-
-    new_val = yield
-    write(key, new_val, expires_in: expires_in, namespace: namespace)
-    new_val
-  end
-
-  def metrics
-    request(cmd: "metrics")
-  end
-
-  def reset_metrics!
-    request(cmd: "reset_metrics")
-  end
-
-  def reset!
-    request(cmd: "reset")
-  end
-
-end
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+
+# thread-safe client for communicating with the MudisServer via UNIX socket.
+class MudisClient
+  SOCKET_PATH = "/tmp/mudis.sock"
+
+  def initialize
+    @mutex = Mutex.new
+  end
+
+  def request(payload) # rubocop:disable Metrics/MethodLength
+    @mutex.synchronize do
+      UNIXSocket.open(SOCKET_PATH) do |sock|
+        sock.puts(JSON.dump(payload))
+        response = sock.gets
+        res = JSON.parse(response, symbolize_names: true)
+        raise res[:error] unless res[:ok] # rubocop:disable Layout/EmptyLineAfterGuardClause
+        res[:value]
+      end
+    rescue Errno::ENOENT
+      warn "[MudisClient] Socket missing; master likely not running MudisServer"
+      nil
+    end
+  end
+
+  def read(key, namespace: nil)
+    request(cmd: "read", key: key, namespace: namespace)
+  end
+
+  def write(key, value, expires_in: nil, namespace: nil)
+    request(cmd: "write", key: key, value: value, ttl: expires_in, namespace: namespace)
+  end
+
+  def delete(key, namespace: nil)
+    request(cmd: "delete", key: key, namespace: namespace)
+  end
+
+  def exists?(key, namespace: nil)
+    request(cmd: "exists", key: key, namespace: namespace)
+  end
+
+  def fetch(key, expires_in: nil, namespace: nil)
+    val = read(key, namespace: namespace)
+    return val if val
+
+    new_val = yield
+    write(key, new_val, expires_in: expires_in, namespace: namespace)
+    new_val
+  end
+
+  def metrics
+    request(cmd: "metrics")
+  end
+
+  def reset_metrics!
+    request(cmd: "reset_metrics")
+  end
+
+  def reset!
+    request(cmd: "reset")
+  end
+end

data/lib/mudis_config.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-# MudisConfig holds all configuration values for Mudis,
-# and provides defaults that can be overridden via Mudis.configure.
-class MudisConfig
-  attr_accessor :serializer,
-                :compress,
-                :max_value_bytes,
-                :hard_memory_limit,
-                :max_bytes,
-                :buckets,
-                :max_ttl,
-                :default_ttl
-
-  def initialize
-    @serializer = JSON                        # Default serialization strategy
-    @compress = false                         # Whether to compress values with Zlib
-    @max_value_bytes = nil                    # Max size per value (optional)
-    @hard_memory_limit = false                # Enforce max_bytes as hard cap
-    @max_bytes = 1_073_741_824                # 1 GB default max cache size
-    @buckets = nil                            # use nil to signal fallback to ENV or default
-    @max_ttl = nil                            # Max TTL for cache entries (optional)
-    @default_ttl = nil                        # Default TTL for cache entries (optional)
-  end
-end
+# frozen_string_literal: true
+
+# MudisConfig holds all configuration values for Mudis,
+# and provides defaults that can be overridden via Mudis.configure.
+class MudisConfig
+  attr_accessor :serializer,
+                :compress,
+                :max_value_bytes,
+                :hard_memory_limit,
+                :max_bytes,
+                :buckets,
+                :max_ttl,
+                :default_ttl
+
+  def initialize
+    @serializer = JSON                        # Default serialization strategy
+    @compress = false                         # Whether to compress values with Zlib
+    @max_value_bytes = nil                    # Max size per value (optional)
+    @hard_memory_limit = false                # Enforce max_bytes as hard cap
+    @max_bytes = 1_073_741_824                # 1 GB default max cache size
+    @buckets = nil                            # use nil to signal fallback to ENV or default
+    @max_ttl = nil                            # Max TTL for cache entries (optional)
+    @default_ttl = nil                        # Default TTL for cache entries (optional)
+  end
+end

data/lib/mudis_proxy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Optional Mudis proxy layer for IPC mode.
+#
+# To enable:
+#   require "mudis_proxy"
+#
+# The proxy will forward calls to `$mudis` (an instance of MudisClient)
+# if it is defined, otherwise fallback to standard in-process behaviour.
+
+require_relative "mudis"
+require_relative "mudis_server"
+require_relative "mudis_client"
+
+if defined?(MudisServer)
+  # In the master process — no proxy needed.
+  return
+end
+
+unless defined?(MudisClient)
+  warn "[MudisProxy] MudisClient not loaded — proxy not activated"
+  return
+end
+
+class << Mudis
+  def read(*a, **k) = $mudis.read(*a, **k) # rubocop:disable Naming/MethodParameterName,Style/GlobalVars
+  def write(*a, **k) = $mudis.write(*a, **k) # rubocop:disable Naming/MethodParameterName,Style/GlobalVars
+  def delete(*a, **k) = $mudis.delete(*a, **k) # rubocop:disable Naming/MethodParameterName,Style/GlobalVars
+  def fetch(*a, **k, &b) = $mudis.fetch(*a, **k, &b) # rubocop:disable Naming/MethodParameterName,Style/GlobalVars
+  def metrics = $mudis.metrics # rubocop:disable Style/GlobalVars
+  def reset_metrics! = $mudis.reset_metrics! # rubocop:disable Style/GlobalVars
+  def reset! = $mudis.reset! # rubocop:disable Style/GlobalVars
+end

data/lib/mudis_server.rb

@@ -1,79 +1,81 @@
-# frozen_string_literal: true
-require "socket"
-require "json"
-require_relative "mudis"
-
-class MudisServer
-  SOCKET_PATH = "/tmp/mudis.sock"
-
-  def self.start!
-    # Clean up old socket if it exists
-    File.unlink(SOCKET_PATH) if File.exist?(SOCKET_PATH)
-
-    server = UNIXServer.new(SOCKET_PATH)
-    server.listen(128)
-    puts "[MudisServer] Listening on #{SOCKET_PATH}"
-
-    Thread.new do
-      loop do
-        client = server.accept
-        Thread.new(client) do |sock|
-          handle_client(sock)
-        end
-      end
-    end
-  end
-
-  def self.handle_client(sock)
-    request_line = sock.gets
-    return unless request_line
-
-    req = JSON.parse(request_line, symbolize_names: true)
-    cmd  = req[:cmd]
-    key  = req[:key]
-    ns   = req[:namespace]
-    val  = req[:value]
-    ttl  = req[:ttl]
-
-    begin
-      case cmd
-      when "read"
-        result = Mudis.read(key, namespace: ns)
-        sock.puts(JSON.dump({ ok: true, value: result }))
-
-      when "write"
-        Mudis.write(key, val, expires_in: ttl, namespace: ns)
-        sock.puts(JSON.dump({ ok: true }))
-
-      when "delete"
-        Mudis.delete(key, namespace: ns)
-        sock.puts(JSON.dump({ ok: true }))
-
-      when "exists"
-        sock.puts(JSON.dump({ ok: true, value: Mudis.exists?(key, namespace: ns) }))
-
-      when "fetch"
-        result = Mudis.fetch(key, expires_in: ttl, namespace: ns) { req[:fallback] }
-        sock.puts(JSON.dump({ ok: true, value: result }))
-
-      when "metrics"
-        sock.puts(JSON.dump({ ok: true, value: Mudis.metrics }))
-
-      when "reset_metrics"
-        Mudis.reset_metrics!
-        sock.puts(JSON.dump({ ok: true }))
-        
-      when "reset"
-        Mudis.reset!
-        sock.puts(JSON.dump({ ok: true }))
-
-      else
-        sock.puts(JSON.dump({ ok: false, error: "unknown command: #{cmd}" }))
-      end
-    rescue => e
-      sock.puts(JSON.dump({ ok: false, error: e.message }))
-    ensure
-      sock.close
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+require_relative "mudis"
+
+# Simple UNIX socket server for handling Mudis operations via IPC mode
+class MudisServer
+  SOCKET_PATH = "/tmp/mudis.sock"
+
+  def self.start! # rubocop:disable Metrics/MethodLength
+    # Clean up old socket if it exists
+    File.unlink(SOCKET_PATH) if File.exist?(SOCKET_PATH)
+
+    server = UNIXServer.new(SOCKET_PATH)
+    server.listen(128)
+    puts "[MudisServer] Listening on #{SOCKET_PATH}"
+
+    Thread.new do
+      loop do
+        client = server.accept
+        Thread.new(client) do |sock|
+          handle_client(sock)
+        end
+      end
+    end
+  end
+
+  def self.handle_client(sock) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/MethodLength
+    request_line = sock.gets
+    return unless request_line
+
+    req = JSON.parse(request_line, symbolize_names: true)
+    cmd  = req[:cmd]
+    key  = req[:key]
+    ns   = req[:namespace]
+    val  = req[:value]
+    ttl  = req[:ttl]
+
+    begin
+      case cmd
+      when "read"
+        result = Mudis.read(key, namespace: ns)
+        sock.puts(JSON.dump({ ok: true, value: result }))
+
+      when "write"
+        Mudis.write(key, val, expires_in: ttl, namespace: ns)
+        sock.puts(JSON.dump({ ok: true }))
+
+      when "delete"
+        Mudis.delete(key, namespace: ns)
+        sock.puts(JSON.dump({ ok: true }))
+
+      when "exists"
+        sock.puts(JSON.dump({ ok: true, value: Mudis.exists?(key, namespace: ns) }))
+
+      when "fetch"
+        result = Mudis.fetch(key, expires_in: ttl, namespace: ns) { req[:fallback] }
+        sock.puts(JSON.dump({ ok: true, value: result }))
+
+      when "metrics"
+        sock.puts(JSON.dump({ ok: true, value: Mudis.metrics }))
+
+      when "reset_metrics"
+        Mudis.reset_metrics!
+        sock.puts(JSON.dump({ ok: true }))
+
+      when "reset"
+        Mudis.reset!
+        sock.puts(JSON.dump({ ok: true }))
+
+      else
+        sock.puts(JSON.dump({ ok: false, error: "unknown command: #{cmd}" }))
+      end
+    rescue StandardError => e
+      sock.puts(JSON.dump({ ok: false, error: e.message }))
+    ensure
+      sock.close
+    end
+  end
+end

data/sig/mudis.rbs

@@ -1,56 +1,56 @@
-class Mudis
-  # Configuration
-  class << self
-    attr_accessor serializer : Object
-    attr_accessor compress : bool
-    attr_accessor hard_memory_limit : bool
-    attr_reader max_bytes : Integer
-    attr_reader max_value_bytes : Integer?
-    attr_accessor max_ttl: Integer?
-    attr_accessor default_ttl: Integer?
-    
-    def configure: () { (config: MudisConfig) -> void } -> void
-    def config: () -> MudisConfig
-    def apply_config!: () -> void
-    def validate_config!: () -> void
-
-    def buckets: () -> Integer
-  end
-
-  # Lifecycle
-  def self.start_expiry_thread: (?interval: Integer) -> void
-  def self.stop_expiry_thread: () -> void
-
-  # Core operations
-  def self.write: (String, untyped, ?expires_in: Integer, ?namespace: String) -> void
-  def self.read: (String, ?namespace: String) -> untyped?
-  def self.update: (String, ?namespace: String) { (untyped) -> untyped } -> void
-  def self.delete: (String, ?namespace: String) -> void
-  def self.exists?: (String, ?namespace: String) -> bool
-
-  # DSL & Helpers
-  def self.fetch: (
-    String,
-    ?expires_in: Integer,
-    ?force: bool,
-    ?namespace: String
-  ) { () -> untyped } -> untyped
-
-  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]
-  def self.cleanup_expired!: () -> void
-  def self.all_keys: () -> Array[String]
-  def self.current_memory_bytes: () -> Integer
-  def self.max_memory_bytes: () -> Integer
-  def self.least_touched: (?Integer) -> Array[[String, Integer]]
-
-  # State reset
-  def self.reset!: () -> void
-  def self.reset_metrics!: () -> void
-end
+class Mudis
+  # Configuration
+  class << self
+    attr_accessor serializer : Object
+    attr_accessor compress : bool
+    attr_accessor hard_memory_limit : bool
+    attr_reader max_bytes : Integer
+    attr_reader max_value_bytes : Integer?
+    attr_accessor max_ttl: Integer?
+    attr_accessor default_ttl: Integer?
+    
+    def configure: () { (config: MudisConfig) -> void } -> void
+    def config: () -> MudisConfig
+    def apply_config!: () -> void
+    def validate_config!: () -> void
+
+    def buckets: () -> Integer
+  end
+
+  # Lifecycle
+  def self.start_expiry_thread: (?interval: Integer) -> void
+  def self.stop_expiry_thread: () -> void
+
+  # Core operations
+  def self.write: (String, untyped, ?expires_in: Integer, ?namespace: String) -> void
+  def self.read: (String, ?namespace: String) -> untyped?
+  def self.update: (String, ?namespace: String) { (untyped) -> untyped } -> void
+  def self.delete: (String, ?namespace: String) -> void
+  def self.exists?: (String, ?namespace: String) -> bool
+
+  # DSL & Helpers
+  def self.fetch: (
+    String,
+    ?expires_in: Integer,
+    ?force: bool,
+    ?namespace: String
+  ) { () -> untyped } -> untyped
+
+  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]
+  def self.cleanup_expired!: () -> void
+  def self.all_keys: () -> Array[String]
+  def self.current_memory_bytes: () -> Integer
+  def self.max_memory_bytes: () -> Integer
+  def self.least_touched: (?Integer) -> Array[[String, Integer]]
+
+  # State reset
+  def self.reset!: () -> void
+  def self.reset_metrics!: () -> void
+end

data/sig/mudis_client.rbs

@@ -0,0 +1,23 @@
+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
+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_server.rbs

@@ -0,0 +1,7 @@
+class MudisServer
+  SOCKET_PATH: String
+
+  def self.start!: () -> void
+
+  def self.handle_client: (sock: UNIXSocket) -> void
+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