min_max 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1111038380ae3a10c7d27e970e3f689243adaf93a0d56341f7838a8edb6e70df
+  data.tar.gz: 9cfcbcd91ff7676988c18f3abff722a28f2ca22f1f5e78daaf55e090219db37b
+SHA512:
+  metadata.gz: dae2da6ad5bb703b5aca311f80b9af0254c8adc746e406870600a4f343892225edc2a8dd598de08b407926a23bd053eecca900c7cf4265679af4158ac112cbe1
+  data.tar.gz: 264f99dd737e0e0a3592c94c9007d03f5fd7cc3838dd91a9ca479bcb79faf2ea10276bce9dad98b9ccd1b2fca12a097dee90683fcf6671006f58c7f753d2c9bd

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Cargo.lock

@@ -0,0 +1,304 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.66.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b84e06fc203107bfbad243f4aba2af864eb7db3b1cf46ea0a023b0b433d2a7"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "lazy_static",
+ "lazycell",
+ "peeking_take_while",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "magnus"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516897a45f8ce8270a8910bcb94cd83538b19b6ae3a0c281a765df170b64695"
+dependencies = [
+ "magnus-macros",
+ "rb-sys",
+ "rb-sys-env",
+ "seq-macro",
+]
+
+[[package]]
+name = "magnus-macros"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "min-max-heap"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2687e6cf9c00f48e9284cf9fd15f2ef341d03cc7743abf9df4c5f07fdee50b18"
+
+[[package]]
+name = "min_max"
+version = "0.1.0"
+dependencies = [
+ "lazy_static",
+ "magnus",
+ "min-max-heap",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rb-sys"
+version = "0.9.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a57240b308b155b09dce81e32829966a99f52d1088b45957e4283e526c5317a1"
+dependencies = [
+ "rb-sys-build",
+]
+
+[[package]]
+name = "rb-sys-build"
+version = "0.9.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f24ce877a4c5d07f06f6aa6fec3ac95e4b357b9f73b0f5445d8cbb7266d410e8"
+dependencies = [
+ "bindgen",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "shell-words",
+ "syn",
+]
+
+[[package]]
+name = "rb-sys-env"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+
+[[package]]
+name = "regex"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81bc1d4caf89fac26a70747fe603c130093b53c773888797a6329091246d651a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed1ceff11a1dddaee50c9dc8e4938bd106e9d89ae372f192311e7da498e3b69"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
+
+[[package]]
+name = "shell-words"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+
+[[package]]
+name = "shlex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+
+[[package]]
+name = "syn"
+version = "2.0.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

data/Cargo.toml

@@ -0,0 +1,12 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/min_max"]
+resolver = "2"
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Wouter Coppieters
+
+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,87 @@
+# MinMax
+
+The MinMax gem provides a high-performance minmax heap implementation for Ruby, written in Rust. 
+This gem allows for the creation of a min-max-heap and supporting operations like pushing and popping multiple items, iterating over heap items, and converting heaps to arrays. 
+
+## Features
+
+- MinMax heap implementation.
+- Sorts according to #priority or #to_i by default. Can be overridden using a custom priority block.
+- Efficient push and pop operations for single or multiple items.
+- Iteration support with `#each`.
+- Convert heap to array with `#to_a`, `#to_a_asc` and `#to_a_desc`.
+
+## Prequisites
+- You must have a working Rust compiler installed on your system. 
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | 
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'min_max'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+```bash
+gem install min_max
+```
+
+## Usage
+
+Instantiate a heap
+```ruby
+heap = MinMax.new
+# Alternate syntax
+heap = MinMax[6,3,2,6]
+
+# Custom priority block
+heap = MinMax.new{|x| -x }
+heap = MinMax[1,4,5,-43]{|x| -x }
+
+```
+
+### Adding items
+```ruby
+heap.push(5, 3, 7, 1)
+```
+
+### Popping items
+```ruby
+heap.pop_max    # => 7
+heap.pop_min(3) # => [1, 3, 5]
+```
+
+## Iterating over heap items
+```ruby
+heap.each.with_index { |item, i| puts "#{i}: #{item}" }
+```
+
+## To array
+```ruby
+heap.to_a_asc  # => [1, 3, 5]
+heap.to_a_desc # => [5, 3, 1]
+heap.to_a # => Heap order
+```
+
+## Size
+```ruby
+heap.size # => 4
+heap.length # Alias for size
+```
+
+## Clear
+```ruby
+heap.clear
+```
+
+

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rb_sys/extensiontask"
+
+task build: :compile
+
+RbSys::ExtensionTask.new("min_max") do |ext|
+  ext.lib_dir = "lib/min_max"
+end
+
+task default: :compile

data/ext/min_max/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "min_max"
+version = "0.1.0"
+edition = "2021"
+authors = ["Wouter Coppieters <wc@pico.net.nz>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.6.1" }
+min-max-heap = "1.3.0"
+lazy_static = "1.4.0"

data/ext/min_max/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("min_max/min_max")

data/ext/min_max/src/lib.rs

@@ -0,0 +1,324 @@
+use magnus::block::Proc;
+use magnus::scan_args::scan_args;
+use magnus::value::{BoxValue, ReprValue};
+use magnus::{
+    block::{block_given, Yield},
+    define_class, function, method,
+    prelude::*,
+    Error, IntoValue, RArray, Ruby, Value,
+};
+use magnus::{eval, DataTypeFunctions, RHash, RString, TypedData};
+use min_max_heap::MinMaxHeap;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+#[derive(Debug, Clone)]
+struct PriorityOrderableValue(i64, usize);
+
+#[macro_use]
+extern crate lazy_static;
+
+struct MEM(
+    RwLock<HashMap<usize, BoxValue<Value>>>,
+    RwLock<HashMap<usize, RefCell<usize>>>,
+);
+
+impl MEM {
+    fn new() -> Self {
+        MEM(RwLock::new(HashMap::new()), RwLock::new(HashMap::new()))
+    }
+}
+
+unsafe impl Sync for MEM {}
+
+lazy_static! {
+    static ref MEMORY: MEM = MEM::new();
+}
+
+fn get_rb_obj(key: usize) -> Option<Value> {
+    let binding = (*MEMORY).0.read().unwrap();
+    let v = binding.get(&key).unwrap();
+    Some(**v)
+}
+
+fn pop_rb_obj(key: usize) -> Option<Value> {
+    let binding = (*MEMORY).1.read().unwrap();
+    let mut count = binding.get(&key).unwrap().borrow_mut();
+    if *count == 0 {
+        return None;
+    }
+    *count -= 1;
+    let res = if *count == 0 {
+        let val = (*MEMORY).0.write().unwrap().remove(&key).unwrap();
+        Some(*val)
+    } else {
+        let binding = (*MEMORY).0.read().unwrap();
+        let v = binding.get(&key).unwrap();
+        Some(**v)
+    };
+    res
+}
+
+fn push_rb_obj(key: usize, value: Value) -> usize {
+    let mut binding = (*MEMORY).1.write().unwrap();
+    let mut count = binding.entry(key).or_insert(RefCell::new(0)).borrow_mut();
+
+    *count += 1;
+    if *count == 1 {
+        (*MEMORY)
+            .0
+            .write()
+            .unwrap()
+            .insert(key, BoxValue::new(value));
+    };
+    return key;
+}
+
+impl PartialOrd for PriorityOrderableValue {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for PriorityOrderableValue {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match (self, other) {
+            (PriorityOrderableValue(p1, _), PriorityOrderableValue(p2, _)) => p1.cmp(p2),
+        }
+    }
+}
+
+impl Eq for PriorityOrderableValue {}
+
+impl PartialEq for PriorityOrderableValue {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (PriorityOrderableValue(p1, v1), PriorityOrderableValue(p2, v2)) => {
+                let v1_obj = get_rb_obj(*v1).unwrap();
+                let v2_obj = get_rb_obj(*v2).unwrap();
+                p1.eq(p2) && (v1_obj).eql(v2_obj).unwrap_or_default()
+            }
+        }
+    }
+}
+
+unsafe impl Send for RubyMinMaxHeap {}
+#[derive(DataTypeFunctions, TypedData, Clone)]
+#[magnus(class = "MinMax", size, free_immediately, mark)]
+struct RubyMinMaxHeap {
+    heap: Arc<RefCell<MinMaxHeap<PriorityOrderableValue>>>,
+    priority_proc: Arc<Proc>,
+}
+
+impl RubyMinMaxHeap {
+    fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::<(), (), (), (), RHash, Option<Proc>>(args)?;
+        let prc: Option<Proc> = args.block;
+
+        Ok(RubyMinMaxHeap {
+            heap: Arc::new(RefCell::new(MinMaxHeap::new())),
+            priority_proc: prc
+                .unwrap_or_else(|| {
+                    let value: Value =
+                        eval("Proc.new {|x| x.respond_to?(:priority) ? x.priority : x.to_i }")
+                            .unwrap();
+                    Proc::from_value(value).unwrap()
+                })
+                .into(),
+        })
+    }
+
+    fn push(&self, value: &[Value]) -> Result<(), Error> {
+        let mut hp = self.heap.borrow_mut();
+        value.iter().for_each(|v| {
+            let priority: i64 = (*self.priority_proc).call([*v]).unwrap_or_default();
+            let key = v.hash().unwrap().to_usize().unwrap();
+            hp.push(PriorityOrderableValue(priority, push_rb_obj(key, *v)));
+        });
+        Ok(())
+    }
+
+    fn peek_max(&self) -> Result<Option<Value>, Error> {
+        let hp = self.heap.borrow();
+        match hp.peek_max() {
+            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            _ => Ok(None),
+        }
+    }
+
+    fn peek_min(&self) -> Result<Option<Value>, Error> {
+        let hp = self.heap.borrow();
+        match hp.peek_min() {
+            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            _ => Ok(None),
+        }
+    }
+
+    fn pop_max(&self, args: &[Value]) -> Result<Option<Value>, Error> {
+        let args = scan_args::<(), (Option<i32>,), (), (), (), ()>(args)?;
+        let (count,): (Option<i32>,) = args.optional;
+
+        if let Some(c) = count {
+            let mut result = vec![];
+            for _ in 0..c {
+                match { self.heap.borrow_mut() }.pop_max() {
+                    Some(PriorityOrderableValue(_, value)) => {
+                        result.push(pop_rb_obj(value).unwrap())
+                    }
+                    _ => break,
+                }
+            }
+            let ary = RArray::new();
+            ary.cat(&result)?;
+            Ok(Some(ary.into_value()))
+        } else {
+            let mut hp = self.heap.borrow_mut();
+            let val = hp.pop_max();
+            match val {
+                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+                _ => Ok(None),
+            }
+        }
+    }
+
+    fn pop_min(&self, args: &[Value]) -> Result<Option<Value>, Error> {
+        let args = scan_args::<(), (Option<i32>,), (), (), (), ()>(args)?;
+        let (count,): (Option<i32>,) = args.optional;
+
+        if let Some(c) = count {
+            let mut result = vec![];
+            for _ in 0..c {
+                match { self.heap.borrow_mut().pop_min() } {
+                    Some(PriorityOrderableValue(_, value)) => {
+                        result.push(pop_rb_obj(value).unwrap())
+                    }
+                    _ => break,
+                }
+            }
+            let ary = RArray::new();
+            ary.cat(&result)?;
+            Ok(Some(ary.into_value()))
+        } else {
+            match { self.heap.borrow_mut().pop_min() } {
+                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+                _ => Ok(None),
+            }
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.heap.borrow().is_empty()
+    }
+
+    fn size(&self) -> usize {
+        self.heap.borrow().len()
+    }
+
+    fn each(&self) -> Yield<Box<dyn Iterator<Item = Value>>> {
+        if block_given() {
+            let iter = self
+                .heap
+                .borrow()
+                .clone()
+                .into_vec()
+                .into_iter()
+                .map(|orderable_value| match orderable_value {
+                    PriorityOrderableValue(_, value) => get_rb_obj(value).unwrap(),
+                });
+            Yield::Iter(Box::new(iter))
+        } else {
+            Yield::Enumerator(self.clone().into_value().enumeratorize("each", ()))
+        }
+    }
+
+    fn to_a(&self) -> Result<RArray, Error> {
+        let each: Value = self.clone().into_value().funcall("each", ())?;
+        Ok(each.funcall("to_a", ())?)
+    }
+
+    fn inspect(&self) -> Result<RString, Error> {
+        let mut visited = std::collections::HashSet::new();
+        Ok(self.build_inspect(&mut visited)?)
+    }
+
+    fn build_inspect(
+        &self,
+        visited: &mut std::collections::HashSet<*const Self>,
+    ) -> Result<RString, Error> {
+        // Check for circular reference
+        if !visited.insert(self as *const Self) {
+            return Ok(RString::new("[Circular Reference Detected]"));
+        }
+
+        let to_a: Value = self.to_a()?.into_value();
+        let r: String = match to_a.funcall("inspect", ()) {
+            Ok(inspect_value) => inspect_value,
+            Err(_) => return Ok(RString::new("[Error inspecting array]")),
+        };
+
+        // Ensure the current object is removed from the visited set to allow re-visiting in future calls
+        visited.remove(&(self as *const Self));
+
+        Ok(RString::new(&format!("MinMax{}", r)))
+    }
+
+    fn to_a_asc(&self) -> Result<RArray, Error> {
+        let ary = RArray::new();
+
+        let sorted: Vec<Value> = self
+            .heap
+            .borrow()
+            .clone()
+            .into_vec_asc()
+            .iter()
+            .map(|orderable_value| match orderable_value {
+                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+            })
+            .collect();
+        ary.cat(&sorted)?;
+        Ok(ary)
+    }
+
+    fn to_a_desc(&self) -> Result<RArray, Error> {
+        let ary = RArray::new();
+
+        let sorted: Vec<Value> = self
+            .heap
+            .borrow()
+            .clone()
+            .into_vec_desc()
+            .iter()
+            .map(|orderable_value| match orderable_value {
+                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+            })
+            .collect();
+        ary.cat(&sorted)?;
+        Ok(ary)
+    }
+
+    fn clear(&self) -> Option<()> {
+        Some(self.heap.borrow_mut().clear())
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let rb_c_min_max = define_class("MinMax", ruby.class_object())?;
+    rb_c_min_max.define_singleton_method("new", function!(RubyMinMaxHeap::new, -1))?;
+    rb_c_min_max.define_method("_push", method!(RubyMinMaxHeap::push, -1))?;
+    rb_c_min_max.define_method("_pop_max", method!(RubyMinMaxHeap::pop_max, -1))?;
+    rb_c_min_max.define_method("_pop_min", method!(RubyMinMaxHeap::pop_min, -1))?;
+    rb_c_min_max.define_method("empty?", method!(RubyMinMaxHeap::is_empty, 0))?;
+    rb_c_min_max.define_method("each", method!(RubyMinMaxHeap::each, 0))?;
+    rb_c_min_max.define_method("peek_min", method!(RubyMinMaxHeap::peek_min, 0))?;
+    rb_c_min_max.define_method("peek_max", method!(RubyMinMaxHeap::peek_max, 0))?;
+    rb_c_min_max.define_method("to_a", method!(RubyMinMaxHeap::to_a, 0))?;
+    rb_c_min_max.define_method("to_a_asc", method!(RubyMinMaxHeap::to_a_asc, 0))?;
+    rb_c_min_max.define_method("to_a_desc", method!(RubyMinMaxHeap::to_a_desc, 0))?;
+    rb_c_min_max.define_method("clear", method!(RubyMinMaxHeap::clear, 0))?;
+    rb_c_min_max.define_method("size", method!(RubyMinMaxHeap::size, 0))?;
+    rb_c_min_max.define_method("length", method!(RubyMinMaxHeap::size, 0))?;
+    rb_c_min_max.define_method("inspect", method!(RubyMinMaxHeap::inspect, 0))?;
+    Ok(())
+}

data/lib/min_max/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class MinMax
+  VERSION = "0.1.0"
+
+end

data/lib/min_max.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "min_max/version"
+require_relative "min_max/min_max"
+
+class MinMax
+  class Error < StandardError; end
+
+  def self.[](*args, &blk)
+    new(&blk).tap{|s| s.push(*args) }
+  end
+
+  def mtx
+    @_mtx  ||= Mutex.new
+  end
+
+  def push(*args)
+    mtx.synchronize { _push(*args) }
+  end
+
+  def add(*args)
+    mtx.synchronize { _push(*args) }
+  end
+
+  def pop_max(*args)
+    mtx.synchronize { _pop_max(*args) }
+  end
+
+  def pop_min(*args)
+    mtx.synchronize { _pop_min(*args) }
+  end
+end
+

data/min_max.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "lib/min_max/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "min_max"
+  spec.version = MinMax::VERSION
+  spec.authors = ["Wouter Coppieters"]
+  spec.email = ["wc@pico.net.nz"]
+
+  spec.summary = "A min max heap extension for Ruby"
+  spec.description = "A min max heap extension for Ruby"
+  spec.homepage = "https://github.com/wouterken/min_max"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_rubygems_version = ">= 3.3.11"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/min_max/extconf.rb"]
+
+  # needed until rubygems supports Rust support is out of beta
+  spec.add_dependency "rb_sys", "~> 0.9.39"
+
+  # only needed when developing or packaging your gem
+  spec.add_development_dependency "rake-compiler", "~> 1.2.0"
+  spec.add_development_dependency "rspec"
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: min_max
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wouter Coppieters
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-02-24 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.39
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.39
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A min max heap extension for Ruby
+email:
+- wc@pico.net.nz
+executables: []
+extensions:
+- ext/min_max/extconf.rb
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/min_max/Cargo.toml
+- ext/min_max/extconf.rb
+- ext/min_max/src/lib.rs
+- lib/min_max.rb
+- lib/min_max/version.rb
+- min_max.gemspec
+homepage: https://github.com/wouterken/min_max
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/wouterken/min_max
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: A min max heap extension for Ruby
+test_files: []