y-rb 0.5.6 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ba8a4ad198489874ed399d303ab720f4f86e6b9e85014ada856a874d6f23485
-  data.tar.gz: 82e9ac65ce9df4711cee24cfe176108b0871b183ec7e5b6981fb52533b594b4b
+  metadata.gz: 45cb8a4398cd5e9bcfb0cd8e3006a31e7a92212866018ef2426717ee35b27330
+  data.tar.gz: 1fbf970ce3a9353afb725e24a2d004e2715ccf13a7e02d3bd54dac9e54b6776d
 SHA512:
-  metadata.gz: 9f4134c2cfaca9b0297055156d1521020d3d890c3740bb0f6a52fa241dfdb3b310a8913ea9069ee440e8e0d1760ca4395d3ac076b84497762c8ea2b2161f1fa7
-  data.tar.gz: 7ffc794a224a373eddd35c7d020e2517634b4e0bab65a4c8c9491ffca373122f7ff9b70e2282ef2634b48233ca8b36ccf5eafa16b65f0e220aac207173e3ea66
+  metadata.gz: de3a6e0735230fd9027ae7a0219938079b6d20bb23ffffdc30da59f2f50ef1ef4226958d4669e9af5f621e5e1c638b9267bdeef3bc14c771af617e389904396e
+  data.tar.gz: b59edafb9fba969b166a9c29d47f1bc7394c58c320b5b1a25eb5e10db189c7ae0c8ab3ee662f981b1a8905d208fab5dfa1fb1aff362a11a01bfc1e838f535396

data/ext/yrb/Cargo.toml

@@ -1,20 +1,20 @@
 [package]
 name = "yrb"
-version = "0.5.6"
+version = "0.7.0"
 authors = ["Hannes Moser <box@hannesmoser.at>"]
 edition = "2021"
 homepage = "https://github.com/y-crdt/yrb"
 repository = "https://github.com/y-crdt/yrb"
 
 [dependencies]
-magnus = "=0.6.2"
-thiserror = "1.0.57"
+magnus = "0.8"
+thiserror = "2.0.17"
 yrs = "=0.17.4"
 y-sync = "=0.4.0"
-rb-sys = "0.9.90"
+rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
 
 [dev-dependencies]
-magnus = { version = "0.6.2", features = ["embed"] }
+magnus = { version = "0.8", features = ["embed"] }
 
 [lib]
 name = "yrb"

data/ext/yrb/src/lib.rs

@@ -11,7 +11,7 @@ use crate::yxml_element::YXmlElement;
 use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 
-use magnus::{class, define_module, function, method, Error, Module, Object};
+use magnus::{function, method, Error, Module, Object, Ruby};
 
 mod utils;
 mod yany;
@@ -29,11 +29,11 @@ mod yxml_fragment;
 mod yxml_text;
 
 #[magnus::init]
-fn init() -> Result<(), Error> {
-    let module = define_module("Y").expect("cannot define ::Y module");
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Y").expect("cannot define ::Y module");
 
     let yarray = module
-        .define_class("Array", class::object())
+        .define_class("Array", ruby.class_object())
         .expect("cannot find class Y::Array");
 
     yarray
@@ -80,7 +80,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yarray_unobserve");
 
     let ydoc = module
-        .define_class("Doc", class::object())
+        .define_class("Doc", ruby.class_object())
         .expect("cannot define class Y::Doc");
     ydoc.define_singleton_method("new", function!(YDoc::ydoc_new, -1))
         .expect("cannot define singleton method: ydoc_new");
@@ -125,7 +125,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ydoc_observe_update");
 
     let ymap = module
-        .define_class("Map", class::object())
+        .define_class("Map", ruby.class_object())
         .expect("cannot define class Y::Map");
 
     ymap.define_private_method("ymap_clear", method!(YMap::ymap_clear, 1))
@@ -150,7 +150,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ymap_unobserve");
 
     let ytransaction = module
-        .define_class("Transaction", class::object())
+        .define_class("Transaction", ruby.class_object())
         .expect("cannot define class Y::Transaction");
 
     ytransaction
@@ -224,7 +224,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ytransaction_state_vector_v2");
 
     let ytext = module
-        .define_class("Text", class::object())
+        .define_class("Text", ruby.class_object())
         .expect("cannot define class Y::Text");
 
     ytext
@@ -271,7 +271,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ytext_unobserve");
 
     let yxml_element = module
-        .define_class("XMLElement", class::object())
+        .define_class("XMLElement", ruby.class_object())
         .expect("cannot define class Y::XMLElement");
 
     yxml_element
@@ -414,7 +414,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_element_unobserve");
 
     let yxml_fragment = module
-        .define_class("XMLFragment", class::object())
+        .define_class("XMLFragment", ruby.class_object())
         .expect("cannot define class: Y::XMLFragment");
 
     yxml_fragment
@@ -479,7 +479,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_fragment_to_s");
 
     let yxml_text = module
-        .define_class("XMLText", class::object())
+        .define_class("XMLText", ruby.class_object())
         .expect("cannot define class Y::XMLText");
 
     yxml_text
@@ -556,7 +556,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_text_to_s");
 
     let yawareness = module
-        .define_class("Awareness", class::object())
+        .define_class("Awareness", ruby.class_object())
         .expect("cannot define class Y::Awareness");
     yawareness
         .define_singleton_method("new", function!(YAwareness::yawareness_new, 0))
@@ -623,7 +623,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yawareness_update_with_clients");
 
     let yawareness_event = module
-        .define_class("AwarenessEvent", class::object())
+        .define_class("AwarenessEvent", ruby.class_object())
         .expect("cannot define class Y::AwarenessEvent");
     yawareness_event
         .define_method("added", method!(YAwarenessEvent::added, 0))
@@ -636,7 +636,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: removed");
 
     let ydiff = module
-        .define_class("Diff", class::object())
+        .define_class("Diff", ruby.class_object())
         .expect("cannot define class Y::Diff");
     ydiff
         .define_private_method("ydiff_insert", method!(YDiff::ydiff_insert, 0))

data/ext/yrb/src/utils.rs

@@ -1,10 +1,11 @@
 use crate::yvalue::YValue;
 use magnus::r_hash::ForEach::Continue;
-use magnus::{exception, Error, RArray, RHash, RString, Symbol, Value};
+use magnus::{Error, RHash, RString, Ruby, Symbol, Value};
 use std::sync::Arc;
 use yrs::types::{Attrs, Value as YrsValue};
 use yrs::{Any, Array, Map, TransactionMut};
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 pub(crate) struct TypeConversionError;
 
@@ -27,8 +28,9 @@ pub(crate) fn map_rhash_to_attrs(hash: RHash) -> Result<Attrs, Error> {
     });
 
     if result.is_err() {
+        let ruby = Ruby::get().unwrap();
         return Err(Error::new(
-            exception::runtime_error(),
+            ruby.exception_runtime_error(),
             "could not map hash to attrs",
         ));
     }
@@ -37,13 +39,14 @@ pub(crate) fn map_rhash_to_attrs(hash: RHash) -> Result<Attrs, Error> {
 }
 
 pub(crate) fn convert_yvalue_to_ruby_value(value: YrsValue, tx: &TransactionMut) -> YValue {
+    let ruby = unsafe { Ruby::get_unchecked() };
     match value {
         YrsValue::Any(val) => YValue::from(val),
         YrsValue::YText(text) => YValue::from(text),
         YrsValue::YXmlElement(el) => YValue::from(el),
         YrsValue::YXmlText(text) => YValue::from(text),
         YrsValue::YArray(val) => {
-            let arr = RArray::new();
+            let arr = ruby.ary_new();
             for item in val.iter(tx) {
                 let val = convert_yvalue_to_ruby_value(item.clone(), tx);
                 let val = *val.0.borrow();
@@ -52,12 +55,13 @@ pub(crate) fn convert_yvalue_to_ruby_value(value: YrsValue, tx: &TransactionMut)
             YValue::from(arr)
         }
         YrsValue::YMap(val) => {
-            let iter = val.iter(tx).map(|(key, val)| {
-                let val = convert_yvalue_to_ruby_value(val.clone(), tx);
+            let hash = ruby.hash_new();
+            for (key, value) in val.iter(tx) {
+                let val = convert_yvalue_to_ruby_value(value.clone(), tx);
                 let val = val.0.into_inner();
-                (key, val)
-            });
-            YValue::from(RHash::from_iter(iter))
+                hash.aset(key, val).expect("cannot insert into hash");
+            }
+            YValue::from(hash)
         }
         v => panic!("cannot map given yrs values to yvalue: {:?}", v),
     }

data/ext/yrb/src/yany.rs

@@ -1,10 +1,11 @@
 use magnus::r_string::IntoRString;
 use magnus::value::ReprValue;
-use magnus::{value, IntoValue, RArray, RHash, RString, Value};
+use magnus::{IntoValue, Ruby, Value};
 use std::borrow::Borrow;
 use std::ops::{Deref, DerefMut};
 use yrs::Any;
 
+#[allow(dead_code)]
 pub(crate) struct YAny(pub(crate) Any);
 
 impl Deref for YAny {
@@ -25,22 +26,23 @@ impl TryInto<Value> for YAny {
     type Error = ();
 
     fn try_into(self) -> Result<Value, Self::Error> {
-        return match self.0 {
+        let ruby = Ruby::get().unwrap();
+        match self.0 {
             Any::Array(_v) => {
-                let arr = RArray::new();
+                let arr = ruby.ary_new();
                 Ok(arr.as_value())
             }
             Any::Map(_v) => {
-                let hash = RHash::new();
+                let hash = ruby.hash_new();
                 Ok(hash.as_value())
             }
-            Any::Null => Ok(value::qnil().as_value()),
-            Any::Undefined => Ok(value::qnil().as_value()),
-            Any::Bool(v) => Ok(v.into_value()),
-            Any::Number(v) => Ok(v.into_value()),
-            Any::BigInt(v) => Ok(v.into_value()),
-            Any::String(v) => Ok(v.into_r_string().as_value()),
-            Any::Buffer(v) => Ok(RString::from_slice(v.borrow()).as_value()),
-        };
+            Any::Null => Ok(ruby.qnil().as_value()),
+            Any::Undefined => Ok(ruby.qnil().as_value()),
+            Any::Bool(v) => Ok(v.into_value_with(&ruby)),
+            Any::Number(v) => Ok(v.into_value_with(&ruby)),
+            Any::BigInt(v) => Ok(v.into_value_with(&ruby)),
+            Any::String(v) => Ok(v.into_r_string_with(&ruby).as_value()),
+            Any::Buffer(v) => Ok(ruby.str_from_slice(v.borrow()).as_value()),
+        }
     }
 }

data/ext/yrb/src/yarray.rs

@@ -3,7 +3,7 @@ use crate::ytransaction::YTransaction;
 use crate::yvalue::YValue;
 use magnus::block::Proc;
 use magnus::value::Qnil;
-use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
+use magnus::{Error, IntoValue, RArray, Ruby, Value};
 use std::cell::RefCell;
 use yrs::types::Change;
 use yrs::{Any, Array, ArrayRef, Observable};
@@ -58,9 +58,8 @@ impl YArray {
         let tx = tx.as_mut().unwrap();
 
         let add_values: Vec<Any> = values
-            .each()
             .into_iter()
-            .map(|value| YValue::from(value.unwrap()).into())
+            .map(|value| YValue::from(value).into())
             .collect();
 
         arr.insert_range(tx, index, add_values)
@@ -73,64 +72,66 @@ impl YArray {
         arr.len(tx)
     }
     pub(crate) fn yarray_observe(&self, block: Proc) -> Result<u32, Error> {
-        let change_added = Symbol::new("added").to_static();
-        let change_retain = Symbol::new("retain").to_static();
-        let change_removed = Symbol::new("removed").to_static();
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let change_added = ruby.to_symbol("added").to_static();
+        let change_retain = ruby.to_symbol("retain").to_static();
+        let change_removed = ruby.to_symbol("removed").to_static();
 
         // let mut error: Option<Error> = None;
 
-        let subscription_id = self
-            .0
-            .borrow_mut()
-            .observe(move |transaction, array_event| {
-                let delta = array_event.delta(transaction);
-                // let mut changes = RArray::with_capacity(delta.len());
-                let (changes, errors): (Vec<_>, Vec<_>) = delta
-                    .iter()
-                    .map(|change| {
-                        let payload = RHash::new();
-                        let result = match change {
-                            Change::Added(v) => {
-                                let values = v
-                                    .iter()
-                                    .map(|v| <YValue as Into<Value>>::into(YValue::from(v.clone())))
-                                    .collect::<RArray>();
-                                payload.aset(change_added, values)
+        let subscription_id =
+            self.0
+                .borrow_mut()
+                .observe(move |transaction, array_event| {
+                    let ruby = unsafe { Ruby::get_unchecked() };
+                    let delta = array_event.delta(transaction);
+                    // let mut changes = RArray::with_capacity(delta.len());
+                    let (changes, errors): (Vec<_>, Vec<_>) = delta
+                        .iter()
+                        .map(|change| {
+                            let payload = ruby.hash_new();
+                            let result =
+                                match change {
+                                    Change::Added(v) => {
+                                        let values = ruby.ary_new();
+                                        for val in v.iter() {
+                                            let value: Value = YValue::from(val.clone()).into();
+                                            values.push(value).expect("cannot push value to array");
+                                        }
+                                        payload.aset(change_added, values)
+                                    }
+                                    Change::Retain(position) => payload
+                                        .aset(change_retain, (*position).into_value_with(&ruby)),
+                                    Change::Removed(position) => payload
+                                        .aset(change_removed, (*position).into_value_with(&ruby)),
+                                };
+
+                            match result {
+                                Ok(()) => Ok(payload),
+                                Err(e) => Err(e),
                             }
-                            Change::Retain(position) => {
-                                payload.aset(change_retain, (*position).into_value())
-                            }
-                            Change::Removed(position) => {
-                                payload.aset(change_removed, (*position).into_value())
-                            }
-                        };
-
-                        match result {
-                            Ok(()) => Ok(payload),
-                            Err(e) => Err(e),
+                        })
+                        .partition(Result::is_ok);
+
+                    if errors.is_empty() {
+                        let args_changes = ruby.ary_new();
+                        for change in changes.iter() {
+                            let c = *change.as_ref().unwrap();
+                            args_changes
+                                .push(c)
+                                .expect("cannot push change event to args");
                         }
-                    })
-                    .partition(Result::is_ok);
-
-                if errors.is_empty() {
-                    let args_changes = RArray::new();
-                    for change in changes.iter() {
-                        let c = *change.as_ref().unwrap();
-                        args_changes
-                            .push(c)
-                            .expect("cannot push change event to args");
-                    }
 
-                    let args = (args_changes,);
-                    let _ = block.call::<(RArray,), Qnil>(args);
-                    // todo: make sure we respect the result and bubble up the
-                    //  error so that we can return as part of the Result
-                }
+                        let args = (args_changes,);
+                        let _ = block.call::<(RArray,), Qnil>(args);
+                        // todo: make sure we respect the result and bubble up the
+                        //  error so that we can return as part of the Result
+                    }
 
-                // todo: make sure we respect errors and let the method fail by
-                //  by returning a Result containing an Error
-            })
-            .into();
+                    // todo: make sure we respect errors and let the method fail by
+                    //  by returning a Result containing an Error
+                })
+                .into();
 
         Ok(subscription_id)
     }
@@ -167,11 +168,12 @@ impl YArray {
         arr.remove_range(tx, index, len)
     }
     pub(crate) fn yarray_to_a(&self, transaction: &YTransaction) -> RArray {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let arr = self.0.borrow();
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
-        let r_arr = RArray::new();
+        let r_arr = ruby.ary_new();
         for item in arr.iter(tx) {
             let r_val = YValue::from(item);
             let r_val = *r_val.0.borrow();

data/ext/yrb/src/yawareness.rs

@@ -1,4 +1,4 @@
-use magnus::{block::Proc, exception, Error, Value};
+use magnus::{block::Proc, Error, Ruby, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -30,11 +30,15 @@ impl YAwareness {
     }
 
     pub(crate) fn yawareness_apply_update(&self, update: Vec<u8>) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         AwarenessUpdate::decode_v1(update.as_slice())
-            .map_err(|_error| Error::new(exception::runtime_error(), "cannot decode update"))
+            .map_err(|_error| Error::new(ruby.exception_runtime_error(), "cannot decode update"))
             .and_then(|value| {
                 self.0.borrow_mut().apply_update(value).map_err(|_error| {
-                    Error::new(exception::runtime_error(), "cannot apply awareness update")
+                    Error::new(
+                        ruby.exception_runtime_error(),
+                        "cannot apply awareness update",
+                    )
                 })
             })
     }
@@ -78,13 +82,14 @@ impl YAwareness {
     }
 
     pub(crate) fn yawareness_update(&self) -> Result<Vec<u8>, Error> {
+        let ruby = Ruby::get().unwrap();
         self.0
             .borrow_mut()
             .update()
             .map(|update| update.encode_v1())
             .map_err(|_error| {
                 Error::new(
-                    exception::runtime_error(),
+                    ruby.exception_runtime_error(),
                     "cannot create update for current state",
                 )
             })
@@ -94,13 +99,14 @@ impl YAwareness {
         &self,
         clients: Vec<ClientID>,
     ) -> Result<Vec<u8>, Error> {
+        let ruby = Ruby::get().unwrap();
         self.0
             .borrow_mut()
             .update_with_clients(clients)
             .map(|update| update.encode_v1())
             .map_err(|_error| {
                 Error::new(
-                    exception::runtime_error(),
+                    ruby.exception_runtime_error(),
                     "cannot create update for current state and given clients",
                 )
             })
@@ -137,6 +143,7 @@ impl From<&Event> for YAwarenessEvent {
     }
 }
 
+#[allow(dead_code)]
 #[magnus::wrap(class = "Y::AwarenessEvent")]
 pub(crate) struct YAwarenessSubscription(UpdateSubscription);
 

data/ext/yrb/src/ydiff.rs

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, RHash, Value};
+use magnus::{IntoValue, RHash, Ruby, Value};
 
 unsafe impl Send for YDiff {}
 
@@ -14,6 +14,9 @@ impl YDiff {
     }
 
     pub(crate) fn ydiff_attrs(&self) -> Option<Value> {
-        self.ydiff_attrs.as_ref().map(|value| value.into_value())
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.ydiff_attrs
+            .as_ref()
+            .map(|value| value.into_value_with(&ruby))
     }
 }

data/ext/yrb/src/ydoc.rs

@@ -6,7 +6,7 @@ use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 use crate::YTransaction;
 use magnus::block::Proc;
-use magnus::{exception::runtime_error, Error, Integer, RArray, Value};
+use magnus::{Error, Integer, RArray, Ruby, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use yrs::updates::decoder::Decode;
@@ -36,12 +36,13 @@ impl YDoc {
         transaction: &YTransaction,
         state_vector: Vec<u8>,
     ) -> Result<Vec<u8>, Error> {
+        let ruby = Ruby::get().unwrap();
         let mut tx = transaction.transaction();
         let tx = tx.as_mut().unwrap();
 
         StateVector::decode_v1(state_vector.borrow())
             .map(|sv| tx.encode_diff_v1(&sv))
-            .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
+            .map_err(|_e| Error::new(ruby.exception_runtime_error(), "cannot encode diff"))
     }
 
     pub(crate) fn ydoc_encode_diff_v2(
@@ -49,6 +50,7 @@ impl YDoc {
         transaction: &YTransaction,
         state_vector: Vec<u8>,
     ) -> Result<Vec<u8>, Error> {
+        let ruby = Ruby::get().unwrap();
         let mut tx = transaction.transaction();
         let tx = tx.as_mut().unwrap();
         let mut encoder = EncoderV2::new();
@@ -56,7 +58,7 @@ impl YDoc {
         StateVector::decode_v2(state_vector.borrow())
             .map(|sv| tx.encode_diff(&sv, &mut encoder))
             .map(|_| encoder.to_vec())
-            .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
+            .map_err(|_e| Error::new(ruby.exception_runtime_error(), "cannot encode diff"))
     }
 
     pub(crate) fn ydoc_get_or_insert_array(&self, name: String) -> YArray {
@@ -96,11 +98,13 @@ impl YDoc {
     }
 
     pub(crate) fn ydoc_observe_update(&self, block: Proc) -> Result<SubscriptionId, Error> {
+        let ruby = Ruby::get().unwrap();
         self.0
             .borrow()
             .observe_update_v1(move |_tx, update_event| {
+                let ruby = unsafe { Ruby::get_unchecked() };
                 let update = update_event.update.to_vec();
-                let update = RArray::from_vec(update);
+                let update = ruby.ary_from_vec(update);
 
                 let args: (RArray,) = (update,);
                 block
@@ -108,6 +112,6 @@ impl YDoc {
                     .expect("cannot call update block");
             })
             .map(|v| v.into())
-            .map_err(|err| Error::new(runtime_error(), err.to_string()))
+            .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
     }
 }