cache_machines 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e553d28a185ae5660c769b7c59b71bb3732df57f3f118425b59d993db8fd75d0
+  data.tar.gz: 59cec0b71269767d0ede58db7cbb50c07421c341f99592c65ab4881b34d28e6e
+SHA512:
+  metadata.gz: 293cb97172f6518e702ae1e5bdf888d297530cf0f57f6d19b304c81a6db074768dea581f24befef6da6bbac8d3998fe61115842cfa17e5cf15755cb8e18dc1ad
+  data.tar.gz: 103b95b31c494cb70106b06746854a1f50f4595160962d0414589e823fb72fd02ac6b7357f97e4defbddea2aaef4747bf28503100cc35434e252f0bf52207747

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## [0.1.4](https://github.com/seuros/cache_machines/compare/cache_machines/v0.1.3...cache_machines/v0.1.4) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([03e3752](https://github.com/seuros/cache_machines/commit/03e375232563df5cf56b4bbe8435540048b3f2c7))
+
+## [0.1.3](https://github.com/seuros/cache_machines/compare/cache_machines/v0.1.2...cache_machines/v0.1.3) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([28635a4](https://github.com/seuros/cache_machines/commit/28635a4df2b2313914957f8cf8b068934bb35f7d))
+
+## [0.1.2](https://github.com/seuros/cache_machines/compare/cache_machines/v0.1.1...cache_machines/v0.1.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* cross builds no longer compile for the host ([33bc4f3](https://github.com/seuros/cache_machines/commit/33bc4f3fd1ba7bc19bda7930b9d998254d70f923))
+
+## [0.1.1](https://github.com/seuros/cache_machines/compare/cache_machines-v0.1.0...cache_machines/v0.1.1) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([3569bc6](https://github.com/seuros/cache_machines/commit/3569bc6ccda4ec7c7bc345ab7be84f92e8edcedd))

data/Cargo.toml

@@ -0,0 +1,23 @@
+[workspace]
+members = ["ext/cache_machines_native/core", "ext/cache_machines_native/ffi"]
+default-members = ["ext/cache_machines_native/core"]
+resolver = "3"
+[workspace.package]
+edition = "2024"
+rust-version = "1.99"
+license = "MIT"
+
+[workspace.dependencies]
+cache-machines = { path = "ext/cache_machines_native/core" }
+magnus = { version = "0.9.3", default-features = false }
+rb-sys = { version = "0.9.130", default-features = false, features = ["stable-api-compiled-fallback"] }
+
+[workspace.lints.rust]
+unsafe_code = "deny"
+unused_must_use = "warn"
+[workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "deny"
+expect_used = "deny"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdelkader Boudih
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,186 @@
+# CacheMachines
+
+> Sixty-four berths, and a hatch that asks what you've done to deserve one. 📦
+
+An admission-controlled LRU for Ruby. It keeps the most recently used keys in order, names the one it would throw out next, and refuses to throw it out for a newcomer that isn't worth more. You store the payloads and count the hits. It decides what stays.
+
+## Quick Start
+
+```bash
+gem 'cache_machines'
+```
+
+```ruby
+bay = CacheMachines::Lru.new
+
+bay.admit(42, candidate_frequency: 1, victim_frequency: 0)  # => [:inserted, nil]
+bay.admit(7,  candidate_frequency: 1, victim_frequency: 0)  # => [:inserted, nil]
+bay.access(42)                                              # => true
+bay.keys                                                    # => [42, 7]
+bay.remove(7)                                               # => true
+```
+
+Keys are Integers. Pair them with your own storage, hand the decisions to the bay, and the bay tells you what to keep.
+
+## A Message to the Resistance
+
+So you built an LRU cache. Hot rows stay, cold rows fall off the back, dashboards go green. Then the nightly export job runs. It reads every row in the table exactly once, and every one of those reads is a cache miss that inserts a key you will never ask for again.
+
+By the time the export finishes, your working set is gone. The 64 keys that got hit ten thousand times each have been shoved out by 64 keys that got hit once. Monday morning is a cold start, and the LRU did exactly what you told it to do.
+
+LRU answers "what was used least recently?" It never asks "does the newcomer deserve the slot?" This gem asks. When the bay is full, a candidate has to show up with a higher frequency than the key it would evict. Ties lose. The export job's keys never make it past the hatch.
+
+## Chapter 1: Stardate 2025.186, the AMS Denning
+
+> **AMS Denning**, NCC-4203, *Denning*-class cache tender.
+> The hold is finite. The universe of possible consignments is not.
+
+The tender has 64 berths and no more. Every consignment that arrives is logged by key, and the manifest is kept in order of last use. When the bay is full and something new arrives, the quartermaster names the berth at the back, asks how often each has been requisitioned, and only swaps if the newcomer wins outright.
+
+Somewhere in the fleet, a supply officer proposes:
+
+```ruby
+def fetch(key)
+  @cache[key] ||= load(key)     # Hash with 64 entries, oldest shifted off
+end
+```
+
+"That," says the quartermaster, "is how one inventory scan empties the bay."
+
+## The Flight Plan
+
+What happens to a key offered to `admit`:
+
+```mermaid
+stateDiagram-v2
+    [*] --> offered
+    offered --> hit: key already aboard, promoted to front
+    offered --> inserted: bay has a free berth
+    offered --> rejected: bay full, candidate frequency <= victim frequency
+    offered --> evicted: bay full, candidate frequency > victim frequency
+    evicted --> [*]: victim key returned
+    hit --> [*]
+    inserted --> [*]
+    rejected --> [*]
+```
+
+And the night of the export job:
+
+```mermaid
+sequenceDiagram
+    participant App
+    participant Bay as Lru (full)
+    participant Store as Your storage
+
+    App->>Bay: victim
+    Bay-->>App: 17 (seen 4000 times)
+    App->>Bay: admit(export row 9001, candidate 1, victim 4000)
+    Bay-->>App: [:rejected, nil]
+    Note over App: don't cache the row, serve it and move on
+
+    App->>Bay: access(17)
+    Bay-->>App: true, promoted
+
+    App->>Bay: victim
+    Bay-->>App: 23 (seen 2 times)
+    App->>Bay: admit(user 555, candidate 9, victim 2)
+    Bay-->>App: [:evicted, 23]
+    App->>Store: delete 23, store 555
+```
+
+## How the Bay Works
+
+### Admit
+
+`admit` takes the key, how often the candidate has been requested, and how often the current victim has. It returns a status and, only when something was displaced, the evicted key.
+
+```ruby
+bay = CacheMachines::Lru.new
+bay.admit(1, candidate_frequency: 5, victim_frequency: 0)  # => [:inserted, nil]
+bay.admit(1, candidate_frequency: 5, victim_frequency: 0)  # => [:hit, nil]
+```
+
+While there's a free berth, frequencies don't matter. The candidate gets in. A key already aboard is a `:hit` and moves to the front.
+
+### When the bay is full
+
+Fill all 64 berths and the frequencies start to count.
+
+```ruby
+bay = CacheMachines::Lru.new
+64.times { |key| bay.admit(key, candidate_frequency: 0, victim_frequency: 0) }
+
+bay.victim                                                     # => 0
+bay.admit(100, candidate_frequency: 9,  victim_frequency: 9)   # => [:rejected, nil]
+bay.admit(100, candidate_frequency: 8,  victim_frequency: 9)   # => [:rejected, nil]
+bay.admit(100, candidate_frequency: 10, victim_frequency: 9)   # => [:evicted, 0]
+```
+
+Equal loses. Lower loses. Only strictly higher gets a berth, and then you are told exactly which key just left so you can drop its payload.
+
+### Access
+
+A hit promotes the key to the front and returns `true`. A miss returns `false` and inserts nothing. Reading is never admitting.
+
+```ruby
+bay = CacheMachines::Lru.new
+bay.admit(1, candidate_frequency: 0, victim_frequency: 0)
+bay.admit(2, candidate_frequency: 0, victim_frequency: 0)
+
+bay.keys        # => [2, 1]
+bay.access(1)   # => true
+bay.keys        # => [1, 2]
+bay.access(9)   # => false
+bay.size        # => 2
+```
+
+### Victim
+
+`victim` is the key at the back of the line, the one `admit` would evict. It is `nil` until the bay is full. Ask for it right before you admit, look up its frequency, and pass that in.
+
+```ruby
+bay = CacheMachines::Lru.new
+bay.victim                                                   # => nil
+64.times { |key| bay.admit(key, candidate_frequency: 0, victim_frequency: 0) }
+bay.victim                                                   # => 0
+bay.access(0)
+bay.victim                                                   # => 1
+```
+
+### Remove and clear
+
+```ruby
+bay = CacheMachines::Lru.new
+bay.admit(1, candidate_frequency: 0, victim_frequency: 0)
+bay.remove(1)   # => true
+bay.remove(1)   # => false
+bay.clear       # => nil
+bay.empty?      # => true
+```
+
+`keys` is a snapshot, most recent first. Mutate the array all you like; the bay doesn't notice.
+
+## The Rules of the Tender
+
+- **Capacity is 64**, exposed as `CacheMachines::Lru::CAPACITY`. The constructor takes no arguments.
+- **Keys and frequencies are Integers** in `0..2**64-1`. Floats, strings, nil, and objects with `to_int` raise `TypeError`. Negative or too large raises `RangeError`. Bad input is rejected before anything changes.
+- **Both frequencies are keyword arguments** and both are required. Missing or extra keywords raise `ArgumentError`.
+- **Frequencies are yours.** The bay never counts hits. It compares the two numbers you give it and nothing else.
+- **Frozen means frozen.** After `freeze`, every mutator raises `FrozenError`, including a miss on `access` and a `remove` of a key that isn't there.
+
+## What You Think You're Doing vs Reality
+
+### You Think: "A bigger cache would have survived the export."
+### Reality: Any finite cache loses to a scan larger than itself.
+
+The export touches more rows than you have berths. Doubling the bay means it takes twice as long to flush, then flushes anyway. The fix is not more room. The fix is a hatch that asks whether the newcomer has earned a berth, and the answer for a row read once is no.
+
+## What's Yours
+
+The bay holds keys and order, nothing else. Payloads live in your store, and when `admit` returns `:evicted` you delete that payload yourself. Frequency counting is yours too, whether that's a counter per key, a sketch, or a column you already have. Treat `victim` then `admit` as one step in your code; the bay won't stop another thread from slipping in between.
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt) for details.
+
+**Remember: The export job will read every row once. Make sure once is not enough.**

data/ext/cache_machines_native/core/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## [0.2.2](https://github.com/seuros/cache_machines/compare/cache-machines-v0.2.1...cache-machines-v0.2.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([03e3752](https://github.com/seuros/cache_machines/commit/03e375232563df5cf56b4bbe8435540048b3f2c7))
+
+## [0.2.1](https://github.com/seuros/cache_machines/compare/cache-machines-v0.2.0...cache-machines-v0.2.1) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([28635a4](https://github.com/seuros/cache_machines/commit/28635a4df2b2313914957f8cf8b068934bb35f7d))
+
+## [0.2.0](https://github.com/seuros/cache_machines/compare/cache-machines-v0.1.0...cache-machines-v0.2.0) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([3569bc6](https://github.com/seuros/cache_machines/commit/3569bc6ccda4ec7c7bc345ab7be84f92e8edcedd))

data/ext/cache_machines_native/core/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "cache-machines"
+version = "0.2.2"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Bounded LRU policy with caller-measured frequency admission"
+readme = "README.md"
+exclude = ["src/**/tests.rs", "tests/"]
+keywords = ["cache", "lru", "admission", "eviction", "no-std"]
+categories = ["no-std", "algorithms", "caching"]
+[lints]
+workspace = true

data/ext/cache_machines_native/core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdelkader Boudih
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/cache_machines_native/core/README.md

@@ -0,0 +1,15 @@
+# cache-machines
+
+> **AMS Denning**, NCC-4203, *Denning*-class cache tender.
+
+Engine-room flight manual: choose which supplies deserve a berth in limited storage.
+
+Allocation-free `no_std` fixed-capacity LRU key policy. Hits move a key to the
+front; accepted new keys evict the least-recently-used key. When full, admission
+requires candidate frequency to exceed the victim's frequency (ties retain the
+incumbent). Frequencies are supplied by the caller, potentially using an existing
+probabilistic sketch; this is not a complete TinyLFU/W-TinyLFU implementation.
+
+Values, loading, eviction callbacks, TTLs, byte weights, synchronization, and sketch
+aging are not owned by this policy. Coordinate key-policy mutations with storage
+updates. A zero-capacity cache rejects every insertion.

data/ext/cache_machines_native/core/src/lib.rs

@@ -0,0 +1,141 @@
+#![no_std]
+#![doc = include_str!("../README.md")]
+
+/// Outcome for a key admission.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Admission<K> {
+    /// Existing key was promoted.
+    Hit,
+    /// New key was inserted into an empty slot.
+    Inserted,
+    /// The least-recently-used key was replaced.
+    Evicted(K),
+    /// Frequency policy or zero capacity rejected the candidate.
+    Rejected,
+}
+
+/// LRU keys in most-recent-first order.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Lru<K, const N: usize> {
+    keys: [Option<K>; N],
+    len: usize,
+}
+
+impl<K: Copy + Eq, const N: usize> Default for Lru<K, N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<K: Copy + Eq, const N: usize> Lru<K, N> {
+    /// Start empty.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            keys: [None; N],
+            len: 0,
+        }
+    }
+
+    /// Maximum number of keys this policy can retain.
+    #[must_use]
+    pub const fn capacity(&self) -> usize {
+        N
+    }
+
+    /// Number of retained keys.
+    #[must_use]
+    pub const fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Whether there are no retained keys.
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Retained keys in most-recent-first order.
+    pub fn keys(&self) -> impl Iterator<Item = K> + '_ {
+        self.keys[..self.len].iter().flatten().copied()
+    }
+
+    /// Forget every key.
+    pub fn clear(&mut self) {
+        self.keys.fill(None);
+        self.len = 0;
+    }
+
+    fn index(&self, key: K) -> Option<usize> {
+        self.keys[..self.len]
+            .iter()
+            .position(|value| *value == Some(key))
+    }
+
+    /// Remove a key without changing the relative order of the others.
+    #[must_use]
+    pub fn remove(&mut self, key: K) -> bool {
+        let Some(index) = self.index(key) else {
+            return false;
+        };
+        self.keys[index..self.len].rotate_left(1);
+        self.len -= 1;
+        self.keys[self.len] = None;
+        true
+    }
+
+    /// Promote a hit; misses leave the ordering unchanged.
+    #[must_use]
+    pub fn access(&mut self, key: K) -> bool {
+        let Some(index) = self.index(key) else {
+            return false;
+        };
+        self.keys[..=index].rotate_right(1);
+        true
+    }
+
+    /// Admit a key; victim frequency refers to the current `victim()` key.
+    #[must_use]
+    pub fn admit(
+        &mut self,
+        key: K,
+        candidate_frequency: u64,
+        victim_frequency: u64,
+    ) -> Admission<K> {
+        if self.access(key) {
+            return Admission::Hit;
+        }
+        if N == 0 {
+            return Admission::Rejected;
+        }
+        let outcome = if self.len == N {
+            if candidate_frequency <= victim_frequency {
+                return Admission::Rejected;
+            }
+            let Some(victim) = self.keys[N - 1] else {
+                return Admission::Rejected;
+            };
+            Admission::Evicted(victim)
+        } else {
+            self.len += 1;
+            Admission::Inserted
+        };
+        self.keys[..self.len].rotate_right(1);
+        self.keys[0] = Some(key);
+        outcome
+    }
+
+    /// Current eviction candidate, when the cache is full and nonempty.
+    #[must_use]
+    pub const fn victim(&self) -> Option<K> {
+        if N > 0 && self.len == N {
+            self.keys[N - 1]
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;

data/ext/cache_machines_native/extconf.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+load File.expand_path('ffi/extconf.rb', __dir__)

data/ext/cache_machines_native/ffi/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "cache_machines_native"
+version = "0.1.3"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Ruby bindings for bounded LRU and caller-measured frequency admission"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+test = false
+doctest = false
+
+[dependencies]
+cache-machines.workspace = true
+magnus.workspace = true
+rb-sys.workspace = true
+
+[lints]
+workspace = true

data/ext/cache_machines_native/ffi/extconf.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'pathname'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('cache_machines_native/cache_machines_native') do |extension|
+  extension.ext_dir = Pathname(__dir__).relative_path_from(Pathname(Dir.pwd)).to_s
+  extension.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', :release).to_sym
+end
+
+# rake-compiler invokes extconf from tmp/, not the extension source directory.
+makefile = File.join(Dir.pwd, 'Makefile')
+File.write(
+  makefile,
+  File.read(makefile).gsub(
+    /^RB_SYS_CARGO_MANIFEST_DIR \?=.*$/,
+    "RB_SYS_CARGO_MANIFEST_DIR ?= #{File.expand_path(__dir__)}"
+  )
+)

data/ext/cache_machines_native/ffi/src/lib.rs

@@ -0,0 +1,116 @@
+//! Thin native binding; all ordering and admission decisions belong to the core.
+
+use std::cell::RefCell;
+
+use cache_machines::{Admission, Lru};
+use magnus::scan_args::{get_kwargs, scan_args};
+use magnus::typed_data::Obj;
+use magnus::{
+    Error, Integer, RHash, Ruby, Symbol, TryConvert, Value, function, method, prelude::*,
+};
+
+const CAPACITY: usize = 64;
+
+/// Reject implicit conversions, especially Float truncation in Magnus integers.
+#[derive(Clone, Copy)]
+struct Number(u64);
+
+impl TryConvert for Number {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        if Integer::from_value(value).is_none() {
+            return Err(Error::new(
+                Ruby::get_with(value).exception_type_error(),
+                "key and frequency must be Integers",
+            ));
+        }
+        u64::try_convert(value).map(Self)
+    }
+}
+
+#[magnus::wrap(class = "CacheMachines::Lru", free_immediately, size)]
+struct Wrapper(RefCell<Lru<u64, CAPACITY>>);
+
+impl Wrapper {
+    const fn new() -> Self {
+        Self(RefCell::new(Lru::new()))
+    }
+
+    fn admit(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        args: &[Value],
+    ) -> Result<(Symbol, Option<u64>), Error> {
+        rb_self.check_frozen()?;
+        let args = scan_args::<(Number,), (), (), (), RHash, ()>(args)?;
+        let (key,) = args.required;
+        let (candidate, victim) = get_kwargs::<_, (Number, Number), (), ()>(
+            args.keywords,
+            &["candidate_frequency", "victim_frequency"],
+            &[],
+        )?
+        .required;
+        // Only native values cross the borrow; Ruby allocations happen afterwards.
+        let outcome = rb_self.0.borrow_mut().admit(key.0, candidate.0, victim.0);
+        let (status, evicted) = match outcome {
+            Admission::Hit => ("hit", None),
+            Admission::Inserted => ("inserted", None),
+            Admission::Evicted(key) => ("evicted", Some(key)),
+            Admission::Rejected => ("rejected", None),
+            _ => {
+                return Err(Error::new(
+                    ruby.exception_runtime_error(),
+                    "unknown admission",
+                ));
+            }
+        };
+        Ok((ruby.to_symbol(status), evicted))
+    }
+
+    fn access(rb_self: Obj<Self>, key: Number) -> Result<bool, Error> {
+        rb_self.check_frozen()?;
+        Ok(rb_self.0.borrow_mut().access(key.0))
+    }
+
+    fn remove(rb_self: Obj<Self>, key: Number) -> Result<bool, Error> {
+        rb_self.check_frozen()?;
+        Ok(rb_self.0.borrow_mut().remove(key.0))
+    }
+
+    fn clear(rb_self: Obj<Self>) -> Result<(), Error> {
+        rb_self.check_frozen()?;
+        rb_self.0.borrow_mut().clear();
+        Ok(())
+    }
+
+    fn keys(&self) -> Vec<u64> {
+        self.0.borrow().keys().collect()
+    }
+
+    fn len(&self) -> usize {
+        self.0.borrow().len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.0.borrow().is_empty()
+    }
+
+    fn victim(&self) -> Option<u64> {
+        self.0.borrow().victim()
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("CacheMachines")?;
+    let class = module.define_class("Lru", ruby.class_object())?;
+    class.const_set("CAPACITY", CAPACITY)?;
+    class.define_singleton_method("new", function!(Wrapper::new, 0))?;
+    class.define_method("admit", method!(Wrapper::admit, -1))?;
+    class.define_method("access", method!(Wrapper::access, 1))?;
+    class.define_method("remove", method!(Wrapper::remove, 1))?;
+    class.define_method("clear", method!(Wrapper::clear, 0))?;
+    class.define_method("keys", method!(Wrapper::keys, 0))?;
+    class.define_method("size", method!(Wrapper::len, 0))?;
+    class.define_method("empty?", method!(Wrapper::is_empty, 0))?;
+    class.define_method("victim", method!(Wrapper::victim, 0))
+}

data/lib/cache_machines/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CacheMachines
+  VERSION = '0.1.4'
+end

data/lib/cache_machines.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'cache_machines/version'
+
+# A missing extension is an installation error. There is no Ruby policy fallback.
+require 'cache_machines_native/cache_machines_native'

data/sig/cache_machines.rbs

@@ -0,0 +1,17 @@
+module CacheMachines
+  VERSION: String
+
+  class Lru
+    CAPACITY: Integer
+
+    def self.new: () -> Lru
+    def admit: (Integer key, candidate_frequency: Integer, victim_frequency: Integer) -> [Symbol, Integer?]
+    def access: (Integer key) -> bool
+    def remove: (Integer key) -> bool
+    def clear: () -> nil
+    def keys: () -> Array[Integer]
+    def size: () -> Integer
+    def empty?: () -> bool
+    def victim: () -> Integer?
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: cache_machines
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Abdelkader Boudih
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+description: A native binding to the allocation-free cache-machines Rust core. Tracks
+  numeric keys and caller-measured admission frequencies; payload storage and frequency
+  measurement remain with the caller.
+email:
+- oss@seuros.com
+executables: []
+extensions:
+- ext/cache_machines_native/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- ext/cache_machines_native/core/CHANGELOG.md
+- ext/cache_machines_native/core/Cargo.toml
+- ext/cache_machines_native/core/LICENSE
+- ext/cache_machines_native/core/README.md
+- ext/cache_machines_native/core/src/lib.rs
+- ext/cache_machines_native/extconf.rb
+- ext/cache_machines_native/ffi/Cargo.toml
+- ext/cache_machines_native/ffi/extconf.rb
+- ext/cache_machines_native/ffi/src/lib.rs
+- lib/cache_machines.rb
+- lib/cache_machines/version.rb
+- sig/cache_machines.rbs
+homepage: https://github.com/seuros/cache_machines
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/seuros/cache_machines
+  bug_tracker_uri: https://github.com/seuros/cache_machines/issues
+  rubygems_mfa_required: 'true'
+  cargo_crate_name: cache_machines_native
+  cargo_manifest_path: ext/cache_machines_native/ffi/Cargo.toml
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Bounded native LRU and admission policy for Ruby
+test_files: []