y-rb 0.6.0-aarch64-linux-gnu → 0.7.0-aarch64-linux-gnu

data/ext/yrb/src/ymap.rs

@@ -2,7 +2,7 @@ use crate::utils::{convert_yvalue_to_ruby_value, indifferent_hash_key};
 use crate::yvalue::YValue;
 use crate::YTransaction;
 use magnus::block::Proc;
-use magnus::{exception, Error, RArray, RHash, Symbol, Value};
+use magnus::{Error, RArray, RHash, Ruby, Value};
 use std::cell::RefCell;
 use yrs::types::{EntryChange, Value as YrsValue};
 use yrs::{Any, Map, MapRef, Observable};
@@ -56,12 +56,13 @@ impl YMap {
         key: Value,
         value: Value,
     ) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         let mut tx = transaction.transaction();
         let tx = tx.as_mut().unwrap();
 
         match indifferent_hash_key(key) {
             None => Err(Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 "invalid key type, make sure it is either of type Symbol or String",
             )),
             Some(k) => {
@@ -73,23 +74,25 @@ impl YMap {
         }
     }
     pub(crate) fn ymap_observe(&self, block: Proc) -> u32 {
-        let change_inserted = Symbol::new("inserted").as_static();
-        let change_updated = Symbol::new("updated").as_static();
-        let change_removed = Symbol::new("removed").as_static();
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let change_inserted = ruby.to_symbol("inserted").as_static();
+        let change_updated = ruby.to_symbol("updated").as_static();
+        let change_removed = ruby.to_symbol("removed").as_static();
         self.0
             .borrow_mut()
             .observe(move |transaction, map_event| {
+                let ruby = unsafe { Ruby::get_unchecked() };
                 let delta = map_event.keys(transaction);
-                let changes = RArray::with_capacity(delta.len());
+                let changes = ruby.ary_new_capa(delta.len());
 
                 for (key, change) in delta {
                     match change {
                         EntryChange::Inserted(v) => {
-                            let h = RHash::new();
-                            h.aset(Symbol::new(key), *YValue::from(v.clone()).0.borrow())
+                            let h = ruby.hash_new();
+                            h.aset(ruby.to_symbol(key), *YValue::from(v.clone()).0.borrow())
                                 .expect("cannot add change::inserted");
 
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(change_inserted, h)
                                 .expect("cannot add change::inserted");
@@ -97,7 +100,7 @@ impl YMap {
                             changes.push(payload).expect("cannot push changes::payload");
                         }
                         EntryChange::Updated(old, new) => {
-                            let values = RArray::with_capacity(2);
+                            let values = ruby.ary_new_capa(2);
                             values
                                 .push(*YValue::from(old.clone()).0.borrow())
                                 .expect("cannot push change::updated");
@@ -105,11 +108,11 @@ impl YMap {
                                 .push(*YValue::from(new.clone()).0.borrow())
                                 .expect("cannot push change::updated");
 
-                            let h = RHash::new();
-                            h.aset(Symbol::new(key), values)
+                            let h = ruby.hash_new();
+                            h.aset(ruby.to_symbol(key), values)
                                 .expect("cannot push change::updated");
 
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(change_updated, h)
                                 .expect("cannot push change::updated");
@@ -117,11 +120,11 @@ impl YMap {
                             changes.push(payload).expect("cannot push changes::payload");
                         }
                         EntryChange::Removed(v) => {
-                            let h = RHash::new();
-                            h.aset(Symbol::new(key), *YValue::from(v.clone()).0.borrow())
+                            let h = ruby.hash_new();
+                            h.aset(ruby.to_symbol(key), *YValue::from(v.clone()).0.borrow())
                                 .expect("cannot push change::removed");
 
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(change_removed, h)
                                 .expect("cannot push change::removed");
@@ -153,15 +156,17 @@ impl YMap {
         self.0.borrow().len(tx)
     }
     pub(crate) fn ymap_to_h(&self, transaction: &YTransaction) -> RHash {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
-        RHash::from_iter(
-            self.0
-                .borrow()
-                .iter(tx)
-                .map(move |(k, v)| (k.to_string(), *YValue::from(v).0.borrow())),
-        )
+        let hash = ruby.hash_new();
+        for (k, v) in self.0.borrow().iter(tx) {
+            let value = *YValue::from(v).0.borrow();
+            hash.aset(k.to_string(), value)
+                .expect("cannot insert into hash");
+        }
+        hash
     }
     pub(crate) fn ymap_unobserve(&self, subscription_id: u32) {
         self.0.borrow_mut().unobserve(subscription_id);

data/ext/yrb/src/ytext.rs

@@ -5,7 +5,7 @@ use crate::YTransaction;
 use magnus::block::Proc;
 use magnus::value::Qnil;
 use magnus::RArray;
-pub(crate) use magnus::{Error, IntoValue, RHash, Symbol, Value};
+pub(crate) use magnus::{Error, IntoValue, RHash, Ruby, Value};
 use std::cell::RefCell;
 use yrs::types::text::YChange;
 use yrs::types::Delta;
@@ -19,36 +19,35 @@ unsafe impl Send for YText {}
 
 impl YText {
     pub(crate) fn ytext_diff(&self, transaction: &YTransaction) -> RArray {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
-        RArray::from_iter(
-            self.0
-                .borrow()
-                .diff(tx, YChange::identity)
-                .iter()
-                .map(move |diff| {
-                    let yvalue = YValue::from(diff.insert.clone());
-                    let insert = yvalue.0.into_inner();
-                    let attributes = diff.attributes.as_ref().map_or_else(
-                        || None,
-                        |boxed_attrs| {
-                            let attributes = RHash::new();
-                            for (key, value) in boxed_attrs.iter() {
-                                let key = key.to_string();
-                                let value = YValue::from(value.clone()).0.into_inner();
-                                attributes.aset(key, value).expect("cannot add value");
-                            }
-                            Some(attributes)
-                        },
-                    );
-                    YDiff {
-                        ydiff_insert: insert,
-                        ydiff_attrs: attributes,
+        let array = ruby.ary_new();
+        for diff in self.0.borrow().diff(tx, YChange::identity).iter() {
+            let yvalue = YValue::from(diff.insert.clone());
+            let insert = yvalue.0.into_inner();
+            let attributes = diff.attributes.as_ref().map_or_else(
+                || None,
+                |boxed_attrs| {
+                    let attributes = ruby.hash_new();
+                    for (key, value) in boxed_attrs.iter() {
+                        let key = key.to_string();
+                        let value = YValue::from(value.clone()).0.into_inner();
+                        attributes.aset(key, value).expect("cannot add value");
                     }
-                    .into_value()
-                }),
-        )
+                    Some(attributes)
+                },
+            );
+            let ydiff = YDiff {
+                ydiff_insert: insert,
+                ydiff_attrs: attributes,
+            };
+            array
+                .push(ydiff.into_value_with(&ruby))
+                .expect("cannot push diff to array");
+        }
+        array
     }
     pub(crate) fn ytext_format(
         &self,
@@ -128,64 +127,68 @@ impl YText {
         self.0.borrow().len(tx)
     }
     pub(crate) fn ytext_observe(&self, block: Proc) -> Result<u32, Error> {
-        let delta_insert = Symbol::new("insert").to_static();
-        let delta_retain = Symbol::new("retain").to_static();
-        let delta_delete = Symbol::new("delete").to_static();
-        let attributes = Symbol::new("attributes").to_static();
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let delta_insert = ruby.to_symbol("insert").to_static();
+        let delta_retain = ruby.to_symbol("retain").to_static();
+        let delta_delete = ruby.to_symbol("delete").to_static();
+        let attributes = ruby.to_symbol("attributes").to_static();
 
         // let mut error: Option<Error> = None;
         let subscription_id = self
             .0
             .borrow_mut()
             .observe(move |transaction, text_event| {
+                let ruby = unsafe { Ruby::get_unchecked() };
                 let delta = text_event.delta(transaction);
                 let (_, errors): (Vec<_>, Vec<_>) = delta
                     .iter()
                     .map(|change| match change {
                         Delta::Inserted(value, attrs) => {
                             let yvalue = YValue::from(value.clone());
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(delta_insert, yvalue.0.into_inner())
                                 .map(|()| match attrs {
-                                    Some(a) => a
-                                        .clone()
-                                        .into_iter()
-                                        .map(|(key, val)| {
+                                    Some(a) => {
+                                        let attrs_hash = ruby.hash_new();
+                                        for (key, val) in a.clone().into_iter() {
                                             let yvalue = YValue::from(val);
-                                            (key.to_string(), yvalue.0.into_inner())
-                                        })
-                                        .collect::<RHash>()
-                                        .into(),
+                                            attrs_hash
+                                                .aset(key.to_string(), yvalue.0.into_inner())
+                                                .expect("cannot add attr");
+                                        }
+                                        Some(attrs_hash)
+                                    }
                                     None => None,
                                 })
                                 .map(|attrs_hash| attrs_hash.map(|v| payload.aset(attributes, v)))
                                 .map(|_| block.call::<(RHash,), Qnil>((payload,)))
                         }
                         Delta::Retain(index, attrs) => {
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
 
                             let yvalue = YValue::from(*index);
 
                             payload
                                 .aset(delta_retain, yvalue.0.into_inner())
                                 .map(|()| match attrs {
-                                    Some(a) => a
-                                        .clone()
-                                        .into_iter()
-                                        .map(|(key, val)| {
+                                    Some(a) => {
+                                        let attrs_hash = ruby.hash_new();
+                                        for (key, val) in a.clone().into_iter() {
                                             let yvalue = YValue::from(val);
-                                            (key.to_string(), yvalue.0.into_inner())
-                                        })
-                                        .collect::<RHash>()
-                                        .into(),
+                                            attrs_hash
+                                                .aset(key.to_string(), yvalue.0.into_inner())
+                                                .expect("cannot add attr");
+                                        }
+                                        Some(attrs_hash)
+                                    }
                                     None => None,
                                 })
                                 .map(|attrs_hash| attrs_hash.map(|v| payload.aset(attributes, v)))
                                 .map(|_| block.call::<(RHash,), Qnil>((payload,)))
                         }
                         Delta::Deleted(index) => {
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
 
                             let yvalue = YValue::from(*index);
 

data/ext/yrb/src/ytransaction.rs

@@ -4,7 +4,7 @@ use crate::ytext::YText;
 use crate::yxml_element::YXmlElement;
 use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
-use magnus::{exception, Error};
+use magnus::{Error, Ruby};
 use std::cell::{RefCell, RefMut};
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::Encode;
@@ -28,10 +28,11 @@ impl<'doc> From<TransactionMut<'doc>> for YTransaction {
 // API which is eventually publicly exposed
 impl YTransaction {
     pub(crate) fn ytransaction_apply_update(&self, update: Vec<u8>) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         Update::decode_v1(update.as_slice())
             .map_err(|error| {
                 Error::new(
-                    exception::runtime_error(),
+                    ruby.exception_runtime_error(),
                     format!("cannot decode update: {:?}", error),
                 )
             })
@@ -39,10 +40,11 @@ impl YTransaction {
     }
 
     pub(crate) fn ytransaction_apply_update_v2(&self, update: Vec<u8>) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
         Update::decode_v2(update.as_slice())
             .map_err(|error| {
                 Error::new(
-                    exception::runtime_error(),
+                    ruby.exception_runtime_error(),
                     format!("cannot decode update: {:?}", error),
                 )
             })

data/ext/yrb/src/yvalue.rs

@@ -1,7 +1,7 @@
 use crate::{YText, YXmlElement, YXmlText};
 use magnus::r_hash::ForEach::Continue;
 use magnus::value::{Qnil, ReprValue};
-use magnus::{class, value, Float, Integer, IntoValue, RArray, RHash, RString, Symbol, Value};
+use magnus::{Float, Integer, IntoValue, RArray, RHash, RString, Ruby, Symbol, Value};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -21,108 +21,128 @@ impl From<Value> for YValue {
 
 impl From<Qnil> for YValue {
     fn from(value: Qnil) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<bool> for YValue {
     fn from(value: bool) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<f64> for YValue {
     fn from(value: f64) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<i64> for YValue {
     fn from(value: i64) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<u32> for YValue {
     fn from(value: u32) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<String> for YValue {
     fn from(value: String) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<RArray> for YValue {
     fn from(value: RArray) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<RHash> for YValue {
     fn from(value: RHash) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<Vec<u8>> for YValue {
     fn from(value: Vec<u8>) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<YrsText> for YValue {
     fn from(value: YrsText) -> Self {
-        YValue(RefCell::from(YText(RefCell::from(value)).into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(
+            YText(RefCell::from(value)).into_value_with(&ruby),
+        ))
     }
 }
 
 impl From<YrsXmlElement> for YValue {
     fn from(value: YrsXmlElement) -> Self {
+        let ruby = unsafe { Ruby::get_unchecked() };
         YValue(RefCell::from(
-            YXmlElement(RefCell::from(value)).into_value(),
+            YXmlElement(RefCell::from(value)).into_value_with(&ruby),
         ))
     }
 }
 
 impl From<YrsXmlText> for YValue {
     fn from(value: YrsXmlText) -> Self {
-        YValue(RefCell::from(YXmlText(RefCell::from(value)).into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(
+            YXmlText(RefCell::from(value)).into_value_with(&ruby),
+        ))
     }
 }
 
 impl From<YText> for YValue {
     fn from(value: YText) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<YXmlElement> for YValue {
     fn from(value: YXmlElement) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<YXmlText> for YValue {
     fn from(value: YXmlText) -> Self {
-        YValue(RefCell::from(value.into_value()))
+        let ruby = unsafe { Ruby::get_unchecked() };
+        YValue(RefCell::from(value.into_value_with(&ruby)))
     }
 }
 
 impl From<Any> for YValue {
     fn from(value: Any) -> Self {
+        let ruby = unsafe { Ruby::get_unchecked() };
         match value {
-            Any::Null => YValue::from(value::qnil()),
-            Any::Undefined => YValue::from(value::qnil()),
+            Any::Null => YValue::from(ruby.qnil()),
+            Any::Undefined => YValue::from(ruby.qnil()),
             Any::Bool(v) => YValue::from(v),
             Any::Number(v) => YValue::from(v),
             Any::BigInt(v) => YValue::from(v),
             Any::String(v) => YValue::from(v.to_string()),
             Any::Buffer(v) => YValue::from(v.to_vec()),
             Any::Array(v) => {
-                let arr = RArray::new();
+                let arr = ruby.ary_new();
                 for item in v.iter() {
                     let val = YValue::from(item.clone());
                     let val = *val.0.borrow();
@@ -131,14 +151,14 @@ impl From<Any> for YValue {
                 YValue::from(arr)
             }
             Any::Map(v) => {
-                let map = v
-                    .iter()
-                    .map(|(key, val)| {
-                        let v = val.clone();
-                        (key.to_string(), YValue::from(v).into())
-                    })
-                    .collect::<HashMap<String, Value>>();
-                YValue::from(RHash::from_iter(map))
+                let hash = ruby.hash_new();
+                for (key, val) in v.iter() {
+                    let v = val.clone();
+                    let value: Value = YValue::from(v).into();
+                    hash.aset(key.to_string(), value)
+                        .expect("cannot insert into hash");
+                }
+                YValue::from(hash)
             }
         }
     }
@@ -146,6 +166,7 @@ impl From<Any> for YValue {
 
 impl From<YrsValue> for YValue {
     fn from(value: YrsValue) -> Self {
+        let ruby = unsafe { Ruby::get_unchecked() };
         match value {
             YrsValue::Any(val) => YValue::from(val),
             YrsValue::YText(text) => YValue::from(text),
@@ -153,7 +174,7 @@ impl From<YrsValue> for YValue {
             YrsValue::YXmlText(text) => YValue::from(text),
             YrsValue::YArray(val) => {
                 let tx = val.transact();
-                let arr = RArray::new();
+                let arr = ruby.ary_new();
                 for item in val.iter(&tx) {
                     let val = YValue::from(item.clone());
                     let val = *val.0.borrow();
@@ -163,12 +184,13 @@ impl From<YrsValue> for YValue {
             }
             YrsValue::YMap(val) => {
                 let tx = val.transact();
-                let iter = val.iter(&tx).map(|(key, val)| {
-                    let val = YValue::from(val);
+                let hash = ruby.hash_new();
+                for (key, value) in val.iter(&tx) {
+                    let val = YValue::from(value);
                     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 complex yrs values to yvalue: {:?}", v),
         }
@@ -177,36 +199,37 @@ impl From<YrsValue> for YValue {
 
 impl From<YValue> for Any {
     fn from(val: YValue) -> Self {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let value = val.0.into_inner();
         if value.is_nil() {
             Any::Null
-        } else if value.is_kind_of(class::float()) {
+        } else if value.is_kind_of(ruby.class_float()) {
             let f = Float::from_value(value).unwrap();
             Any::Number(f.to_f64())
-        } else if value.is_kind_of(class::integer()) {
+        } else if value.is_kind_of(ruby.class_integer()) {
             let i = Integer::from_value(value).unwrap();
             Any::BigInt(i.to_i64().unwrap())
-        } else if value.is_kind_of(class::symbol()) {
+        } else if value.is_kind_of(ruby.class_symbol()) {
             let s = Symbol::from_value(value).unwrap();
             Any::String(Arc::from(s.name().unwrap()))
-        } else if value.is_kind_of(class::true_class()) {
+        } else if value.is_kind_of(ruby.class_true_class()) {
             Any::Bool(true)
-        } else if value.is_kind_of(class::false_class()) {
+        } else if value.is_kind_of(ruby.class_false_class()) {
             Any::Bool(false)
-        } else if value.is_kind_of(class::string()) {
+        } else if value.is_kind_of(ruby.class_string()) {
             let s = RString::from_value(value).unwrap();
             unsafe { Any::String(Arc::from(s.as_str().unwrap().to_string())) }
-        } else if value.is_kind_of(class::array()) {
+        } else if value.is_kind_of(ruby.class_array()) {
             let arr = RArray::from_value(value).unwrap();
             let items = arr
-                .each()
+                .into_iter()
                 .map(|item| {
-                    let yvalue = YValue::from(item.unwrap());
+                    let yvalue = YValue::from(item);
                     Any::from(yvalue)
                 })
                 .collect::<Vec<Any>>();
             Any::Array(Arc::from(items))
-        } else if value.is_kind_of(class::hash()) {
+        } else if value.is_kind_of(ruby.class_hash()) {
             let map = RHash::from_value(value).unwrap();
             let mut m: HashMap<String, Any> = HashMap::new();