min_max 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80798043e91a2c00c6bda06b9cee1fe9544d9eb57c38d2d1ef41c4147614ff80
-  data.tar.gz: 7394b9168a389e57917780169a0a2574ea5982a4a373c67c36770bc893dfae75
+  metadata.gz: 5b1020f3ac8e632e3b2b4d99318a78edf48a06d3099e5812637d8dfd5fdf1623
+  data.tar.gz: b774055ca657edf4a01712a71020cbb55df034e38f3db676b0c85484ae1f155e
 SHA512:
-  metadata.gz: 5c746c1cbdba8f6e5e752949145bd2604eefa14b75a5c5cb6b6b1a0c81eaaa75538451438cc001769336cbdf9d2e118a2c2c9a397b3d6ea00ce70f37227de576
-  data.tar.gz: 172aa5d4652493bcfbcd92bbad0ffbd06c72910c63ddf7c59e665ed017d300ba453d18953983c44e95fb5362e4c37ebfad5d79c4167e3736deed47ebc32e0f74
+  metadata.gz: 2c7a1e0c3893382526f5c94c488618a3d01b7e19aa3a6d1b3cfc0aa012ede494bfb033c1b9544224bcfa3f9147d3d96779d11c83f2723a384c36109c5f837dba
+  data.tar.gz: 4c60344475780f72a7369cac4fc0a22e156750fee690b326a2cbc9b6d1c492446f05dbdda5e39910e9f9549b848730ade850fda8e282d418ba1fa0e8e8c19793

data/Cargo.lock

@@ -13,16 +13,16 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.66.1"
+version = "0.69.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b84e06fc203107bfbad243f4aba2af864eb7db3b1cf46ea0a023b0b433d2a7"
+checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
+ "itertools",
  "lazy_static",
  "lazycell",
- "peeking_take_while",
  "proc-macro2",
  "quote",
  "regex",
@@ -63,12 +63,27 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "either"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
+
 [[package]]
 name = "glob"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -139,6 +154,7 @@ dependencies = [
  "lazy_static",
  "magnus",
  "min-max-heap",
+ "rb-sys",
 ]
 
 [[package]]
@@ -157,12 +173,6 @@ dependencies = [
  "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"
@@ -183,18 +193,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.81"
+version = "0.9.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a57240b308b155b09dce81e32829966a99f52d1088b45957e4283e526c5317a1"
+checksum = "0d197f2c03751ef006f29d593d22aa9068c9c358e04ca503afea0329c366147c"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.81"
+version = "0.9.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f24ce877a4c5d07f06f6aa6fec3ac95e4b357b9f73b0f5445d8cbb7266d410e8"
+checksum = "2b50caf8fd028f12abe00d6debe2ae2adf6202c9ca3caa59487eda710d90fa28"
 dependencies = [
  "bindgen",
  "lazy_static",

data/ext/min_max/Cargo.toml

@@ -10,6 +10,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.6.1" }
+magnus = { version = "0.6.1"}
 min-max-heap = "1.3.0"
 lazy_static = "1.4.0"
+rb-sys = { version = "0.9.89", features=["stable-api-compiled-fallback"]}

data/ext/min_max/src/lib.rs

@@ -1,4 +1,3 @@
-use magnus::block::Proc;
 use magnus::scan_args::scan_args;
 use magnus::value::{BoxValue, ReprValue};
 use magnus::{
@@ -7,7 +6,7 @@ use magnus::{
     prelude::*,
     Error, IntoValue, RArray, Ruby, Value,
 };
-use magnus::{eval, DataTypeFunctions, RHash, RString, TypedData};
+use magnus::{DataTypeFunctions, Integer, TypedData};
 use min_max_heap::MinMaxHeap;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -36,45 +35,6 @@ lazy_static! {
     static ref MEMORY: MEM = MEM::new();
 }
 
-fn get_rb_obj(key: i64) -> Option<Value> {
-    let binding = (*MEMORY).0.read().unwrap();
-    let v = binding.get(&key).unwrap();
-    Some(**v)
-}
-
-fn pop_rb_obj(key: i64) -> 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: i64, value: Value) -> i64 {
-    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))
@@ -95,9 +55,7 @@ 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()
+                p1.eq(p2) && (v1).eq(v2)
             }
         }
     }
@@ -108,49 +66,36 @@ unsafe impl Send for RubyMinMaxHeap {}
 #[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;
-
+    fn new() -> Result<Self, Error> {
         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> {
+    fn push(&self, values: RArray) -> 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_i64().unwrap();
-            hp.push(PriorityOrderableValue(priority, push_rb_obj(key, *v)));
+        let values_vec = values.to_vec::<(i64, i64)>().unwrap();
+        values_vec.into_iter().for_each(|(priority, key)| {
+            hp.push(PriorityOrderableValue(priority, key));
         });
         Ok(())
     }
 
-    fn peek_max(&self) -> Result<Option<Value>, Error> {
+    fn peek_max(&self) -> Result<Option<i64>, Error> {
         let hp = self.heap.borrow();
         match hp.peek_max() {
-            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            Some(PriorityOrderableValue(_, value)) => Ok(Some(*value)),
             _ => Ok(None),
         }
     }
 
-    fn peek_min(&self) -> Result<Option<Value>, Error> {
+    fn peek_min(&self) -> Result<Option<i64>, Error> {
         let hp = self.heap.borrow();
         match hp.peek_min() {
-            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            Some(PriorityOrderableValue(_, value)) => Ok(Some(*value)),
             _ => Ok(None),
         }
     }
@@ -163,20 +108,20 @@ impl RubyMinMaxHeap {
             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())
-                    }
+                    Some(PriorityOrderableValue(_, value)) => result.push(Integer::from_i64(value)),
                     _ => break,
                 }
             }
             let ary = RArray::new();
             ary.cat(&result)?;
-            Ok(Some(ary.into_value()))
+            Ok(Some(ary.as_value()))
         } else {
             let mut hp = self.heap.borrow_mut();
             let val = hp.pop_max();
             match val {
-                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+                Some(PriorityOrderableValue(_, value)) => {
+                    Ok(Some(Integer::from_i64(value).as_value()))
+                }
                 _ => Ok(None),
             }
         }
@@ -189,19 +134,21 @@ impl RubyMinMaxHeap {
         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())
-                    }
+                match { self.heap.borrow_mut() }.pop_min() {
+                    Some(PriorityOrderableValue(_, value)) => result.push(Integer::from_i64(value)),
                     _ => break,
                 }
             }
             let ary = RArray::new();
             ary.cat(&result)?;
-            Ok(Some(ary.into_value()))
+            Ok(Some(ary.as_value()))
         } else {
-            match { self.heap.borrow_mut().pop_min() } {
-                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+            let mut hp = self.heap.borrow_mut();
+            let val = hp.pop_min();
+            match val {
+                Some(PriorityOrderableValue(_, value)) => {
+                    Ok(Some(Integer::from_i64(value).as_value()))
+                }
                 _ => Ok(None),
             }
         }
@@ -224,45 +171,14 @@ impl RubyMinMaxHeap {
                 .into_vec()
                 .into_iter()
                 .map(|orderable_value| match orderable_value {
-                    PriorityOrderableValue(_, value) => get_rb_obj(value).unwrap(),
+                    PriorityOrderableValue(_, value) => Integer::from_i64(value).as_value(),
                 });
             Yield::Iter(Box::new(iter))
         } else {
-            Yield::Enumerator(self.clone().into_value().enumeratorize("each", ()))
+            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();
 
@@ -273,7 +189,7 @@ impl RubyMinMaxHeap {
             .into_vec_asc()
             .iter()
             .map(|orderable_value| match orderable_value {
-                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+                PriorityOrderableValue(_, value) => Integer::from_i64(*value).as_value(),
             })
             .collect();
         ary.cat(&sorted)?;
@@ -290,7 +206,7 @@ impl RubyMinMaxHeap {
             .into_vec_desc()
             .iter()
             .map(|orderable_value| match orderable_value {
-                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+                PriorityOrderableValue(_, value) => Integer::from_i64(*value).as_value(),
             })
             .collect();
         ary.cat(&sorted)?;
@@ -305,20 +221,18 @@ impl RubyMinMaxHeap {
 #[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_singleton_method("_new", function!(RubyMinMaxHeap::new, 0))?;
+    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("_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_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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 class MinMax
-  VERSION = "0.1.1"
-
+  VERSION = "0.1.3"
 end

data/lib/min_max.rb

@@ -7,7 +7,26 @@ class MinMax
   class Error < StandardError; end
 
   def self.[](*args, &blk)
-    new(&blk).tap{|s| s.push(*args) }
+    new(*args, &blk)
+  end
+
+  def self.new(*args, &blk)
+    self._new.tap{|s|
+      s.priority_blk =(blk || proc{|x| (x.respond_to?(:priority) ? x.priority : x.to_i ) rescue 0})
+      s.push(*args)
+    }
+  end
+
+  def priority_blk=(bll)
+    @priority_blk = bll
+  end
+
+  def storage
+    @storage ||= Hash.new
+  end
+
+  def counts
+    @counts ||= Hash.new(0)
   end
 
   def mtx
@@ -15,19 +34,82 @@ class MinMax
   end
 
   def push(*args)
-    mtx.synchronize { _push(*args) }
+    mtx.synchronize do
+      mapped = args.map do |a|
+          counts[a.hash] += 1
+          storage[a.hash] = a
+          [
+            @priority_blk.call(a),
+            a.hash
+          ]
+      end
+       _push(mapped)
+    end
+    self
   end
 
   def add(*args)
-    mtx.synchronize { _push(*args) }
+    push(*args)
   end
 
   def pop_max(*args)
-    mtx.synchronize { _pop_max(*args) }
+    mtx.synchronize {
+      popped = _pop_max(*args)
+      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
+    }
   end
 
   def pop_min(*args)
-    mtx.synchronize { _pop_min(*args) }
+    mtx.synchronize {
+      popped = _pop_min(*args)
+      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
+    }
+  end
+
+  def retrieve(hash, remove=true)
+    if remove
+      if (counts[hash] -= 1) == 0
+        storage.delete(hash)
+      else
+        storage[hash]
+      end
+    else
+      storage[hash]
+    end
+  end
+
+  def peek_min(*args)
+    peeked = _peek_min(*args)
+    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  end
+
+  def peek_max(*args)
+    peeked = _peek_max(*args)
+    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  end
+
+  def each(*args, &blk)
+    if block_given?
+      mtx.synchronize { _each(*args).map{|p| blk[retrieve(p, false)] } }
+    else
+      to_enum(:each, *args)
+    end
+  end
+
+  def to_a
+    each.to_a
+  end
+
+  def to_a_asc
+    mtx.synchronize { _to_a_asc.map{|p| retrieve(p, false) } }
+  end
+
+  def to_a_desc
+    mtx.synchronize { _to_a_desc.map{|p| retrieve(p, false) } }
+  end
+
+  def inspect
+    "MinMax[#{to_a_asc.first(10).map{|v| v.to_s}.join(", ")}#{size > 10 ? ", ..." : ""}]"
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: min_max
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-24 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys