y-rb 0.5.2-x64-mingw-ucrt → 0.5.3-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94459d9d7a60d2140f298f7f0ef731e604b0c1dd12f406b154e6db2b31f05f2b
-  data.tar.gz: c82f6fd1d527fb331b6a9e9fe5bc30d28e6710090ee15f77708971fc1db91b23
+  metadata.gz: 7ddc46c1292b5d7fbe597a5ae623c32f6917aae909e1d2e34b447cc452d0eff8
+  data.tar.gz: b2a5902c89aadd5d3ebb5fda5be24f51e9185fd366fc5104bf4cecd010988aee
 SHA512:
-  metadata.gz: 5c9e5a6c49001aa243f20107716f7b8cb5aa4798a849f5c969630a02f3fb2d18c01d302db10b02f55e29c182ff0197890aeb46f07109de01f3718c011668fada
-  data.tar.gz: 5cde99834099cabe81e188346adb6d86c5a3131eddfcbabd363a3a2a7cfd8b6fe1c16001b376d2d9de60e498b29b40328ec3b03a43506a7aaf89ef7ef7cf9791
+  metadata.gz: b88834c3ce6763b1984360f28fbc5e4b96d9a74628b3dd8db41767b8fa21e2a8a666f9cc49110fdb0703f3b05f10abe3bf311cc16794087a1bbe10eddbb867ba
+  data.tar.gz: bccc0c328ca21ecabea95f3bcbf3d312bcf5863f8f67e3ccaf7d06389e758eb6e2757a998a51a0d08097c15c9956cd3be93f4979c026b80500c739599228a8cb

data/ext/yrb/Cargo.toml

@@ -1,21 +1,21 @@
 [package]
 name = "yrb"
-version = "0.5.2"
-authors = ["Hannes Moser <box@hannesmoser.at>", "Hannes Moser <hmoser@gitlab.com>"]
+version = "0.5.3"
+authors = ["Hannes Moser <box@hannesmoser.at>"]
 edition = "2021"
 homepage = "https://github.com/y-crdt/yrb"
 repository = "https://github.com/y-crdt/yrb"
 
 [dependencies]
-lib0 = "0.16.9" # must match yrs version
-magnus = "0.5.4"
-thiserror = "1.0.41"
-yrs = "=0.16.9"
+lib0 = "0.16.10" # must match yrs version
+magnus = "0.6.2"
+thiserror = "1.0.50"
+yrs = "=0.16.10"
 y-sync = "=0.3.1"
-rb-sys = "0.9.79"
+rb-sys = "0.9.82"
 
 [dev-dependencies]
-magnus = { version = "0.5.4", features = ["embed"] }
+magnus = { version = "0.6.2", features = ["embed"] }
 
 [lib]
 name = "yrb"

data/ext/yrb/src/lib.rs

@@ -9,7 +9,7 @@ use crate::ytransaction::YTransaction;
 use crate::yxml_element::YXmlElement;
 use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
-use magnus::{define_module, function, method, Error, Module, Object};
+use magnus::{class, define_module, function, method, Error, Module, Object};
 
 mod utils;
 mod yany;
@@ -30,7 +30,7 @@ fn init() -> Result<(), Error> {
     let module = define_module("Y").expect("cannot define ::Y module");
 
     let yarray = module
-        .define_class("Array", Default::default())
+        .define_class("Array", class::object())
         .expect("cannot find class Y::Array");
 
     yarray
@@ -77,7 +77,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yarray_unobserve");
 
     let ydoc = module
-        .define_class("Doc", Default::default())
+        .define_class("Doc", 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");
@@ -122,7 +122,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ydoc_observe_update");
 
     let ymap = module
-        .define_class("Map", Default::default())
+        .define_class("Map", class::object())
         .expect("cannot define class Y::Map");
 
     ymap.define_private_method("ymap_clear", method!(YMap::ymap_clear, 1))
@@ -147,7 +147,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ymap_unobserve");
 
     let ytransaction = module
-        .define_class("Transaction", Default::default())
+        .define_class("Transaction", class::object())
         .expect("cannot define class Y::Transaction");
 
     ytransaction
@@ -221,7 +221,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ytransaction_state_vector_v2");
 
     let ytext = module
-        .define_class("Text", Default::default())
+        .define_class("Text", class::object())
         .expect("cannot define class Y::Text");
 
     ytext
@@ -265,7 +265,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ytext_unobserve");
 
     let yxml_element = module
-        .define_class("XMLElement", Default::default())
+        .define_class("XMLElement", class::object())
         .expect("cannot define class Y::XMLElement");
 
     yxml_element
@@ -408,7 +408,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_element_unobserve");
 
     let yxml_fragment = module
-        .define_class("XMLFragment", Default::default())
+        .define_class("XMLFragment", class::object())
         .expect("cannot define class: Y::XMLFragment");
 
     yxml_fragment
@@ -473,7 +473,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_fragment_to_s");
 
     let yxml_text = module
-        .define_class("XMLText", Default::default())
+        .define_class("XMLText", class::object())
         .expect("cannot define class Y::XMLText");
 
     yxml_text
@@ -550,7 +550,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_text_to_s");
 
     let yawareness = module
-        .define_class("Awareness", Default::default())
+        .define_class("Awareness", class::object())
         .expect("cannot define class Y::Awareness");
     yawareness
         .define_singleton_method("new", function!(YAwareness::yawareness_new, 0))
@@ -617,7 +617,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yawareness_update_with_clients");
 
     let yawareness_event = module
-        .define_class("AwarenessEvent", Default::default())
+        .define_class("AwarenessEvent", class::object())
         .expect("cannot define class Y:AwarenessEvent");
     yawareness_event
         .define_method("added", method!(YAwarenessEvent::added, 0))

data/ext/yrb/src/utils.rs

@@ -1,9 +1,10 @@
 use crate::yvalue::YValue;
 use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
-use magnus::{exception, Error, RHash, RString, Symbol, Value};
+use magnus::{exception, Error, RArray, RHash, RString, Symbol, Value};
 use std::sync::Arc;
-use yrs::types::Attrs;
+use yrs::types::{Attrs, Value as YrsValue};
+use yrs::{Array, Map, TransactionMut};
 
 #[derive(Debug, Clone)]
 pub(crate) struct TypeConversionError;
@@ -35,3 +36,30 @@ pub(crate) fn map_rhash_to_attrs(hash: RHash) -> Result<Attrs, Error> {
 
     Ok(a)
 }
+
+pub(crate) fn convert_yvalue_to_ruby_value(value: YrsValue, tx: &TransactionMut) -> YValue {
+    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();
+            for item in val.iter(tx) {
+                let val = convert_yvalue_to_ruby_value(item.clone(), tx);
+                let val = *val.0.borrow();
+                arr.push(val).expect("cannot push item event to array");
+            }
+            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 val = val.0.into_inner();
+                (key, val)
+            });
+            YValue::from(RHash::from_iter(iter))
+        }
+        v => panic!("cannot map given yrs values to yvalue: {:?}", v),
+    }
+}

data/ext/yrb/src/yany.rs

@@ -1,6 +1,7 @@
 use lib0::any::Any;
 use magnus::r_string::IntoRString;
-use magnus::{RArray, RHash, RString, Value, QNIL};
+use magnus::value::ReprValue;
+use magnus::{value, IntoValue, RArray, RHash, RString, Value};
 use std::borrow::Borrow;
 use std::ops::{Deref, DerefMut};
 
@@ -27,19 +28,19 @@ impl TryInto<Value> for YAny {
         return match self.0 {
             Any::Array(_v) => {
                 let arr = RArray::new();
-                Ok(Value::from(arr))
+                Ok(arr.as_value())
             }
             Any::Map(_v) => {
                 let hash = RHash::new();
-                Ok(Value::from(hash))
+                Ok(hash.as_value())
             }
-            Any::Null => Ok(Value::from(QNIL)),
-            Any::Undefined => Ok(Value::from(QNIL)),
-            Any::Bool(v) => Ok(Value::from(v)),
-            Any::Number(v) => Ok(Value::from(v)),
-            Any::BigInt(v) => Ok(Value::from(v)),
-            Any::String(v) => Ok(Value::from(RString::from(v.into_r_string()))),
-            Any::Buffer(v) => Ok(Value::from(RString::from_slice(v.borrow()))),
+            Any::Null => Ok(value::qnil().as_value()),
+            Any::Undefined => Ok(Value::from(value::qnil().as_value())),
+            Any::Bool(v) => Ok(v.into_value()),
+            Any::Number(v) => Ok(Value::from(v.into_value())),
+            Any::BigInt(v) => Ok(Value::from(v.into_value())),
+            Any::String(v) => Ok(RString::from(v.into_r_string()).as_value()),
+            Any::Buffer(v) => Ok(RString::from_slice(v.borrow()).as_value()),
         };
     }
 }

data/ext/yrb/src/yarray.rs

@@ -1,9 +1,10 @@
+use crate::utils::convert_yvalue_to_ruby_value;
 use crate::ytransaction::YTransaction;
 use crate::yvalue::YValue;
 use lib0::any::Any;
 use magnus::block::Proc;
 use magnus::value::Qnil;
-use magnus::{Error, RArray, RHash, Symbol, Value};
+use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use yrs::types::Change;
@@ -22,20 +23,21 @@ impl YArray {
 
         let arr = self.0.borrow();
         arr.iter(tx).for_each(|val| {
-            let yvalue = YValue::from(val);
-            let args = (yvalue.into(),);
+            let yvalue = *convert_yvalue_to_ruby_value(val, tx).0.borrow();
+            let args = (yvalue,);
             let _ = block.call::<(Value,), Qnil>(args);
         });
 
         Ok(())
     }
+
     pub(crate) fn yarray_get(&self, transaction: &YTransaction, index: u32) -> Value {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         let arr = self.0.borrow();
         let v = arr.get(tx, index).unwrap();
-        YValue::from(v).into()
+        *convert_yvalue_to_ruby_value(v, tx).0.borrow()
     }
     pub(crate) fn yarray_insert(&self, transaction: &YTransaction, index: u32, value: Value) {
         let yvalue = YValue::from(value);
@@ -98,10 +100,10 @@ impl YArray {
                                 payload.aset(change_added, values)
                             }
                             Change::Retain(position) => {
-                                payload.aset(change_retain, Value::from(*position))
+                                payload.aset(change_retain, (*position).into_value())
                             }
                             Change::Removed(position) => {
-                                payload.aset(change_removed, Value::from(*position))
+                                payload.aset(change_removed, (*position).into_value())
                             }
                         };
 

data/ext/yrb/src/ymap.rs

@@ -1,4 +1,4 @@
-use crate::utils::indifferent_hash_key;
+use crate::utils::{convert_yvalue_to_ruby_value, indifferent_hash_key};
 use crate::yvalue::YValue;
 use crate::YTransaction;
 use lib0::any::Any;
@@ -30,17 +30,18 @@ impl YMap {
             Some(k) => self.0.borrow().contains_key(tx, k.as_str()),
         }
     }
+
     pub(crate) fn ymap_each(&self, transaction: &YTransaction, proc: Proc) {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
-
         self.0.borrow().iter(tx).for_each(|(key, val)| {
             let k = key.to_string();
-            let v = *YValue::from(val).0.borrow();
+            let v = *convert_yvalue_to_ruby_value(val, tx).0.borrow();
             proc.call::<(String, Value), Value>((k, v))
                 .expect("cannot iterate map");
         })
     }
+
     pub(crate) fn ymap_get(&self, transaction: &YTransaction, key: Value) -> Option<Value> {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
@@ -48,7 +49,7 @@ impl YMap {
         indifferent_hash_key(key)
             .map(|k| self.0.borrow().get(tx, k.as_str()))
             .map(|v| v.unwrap_or(YrsValue::Any(Any::Undefined)))
-            .map(|v| *YValue::from(v).0.borrow())
+            .map(|v| *convert_yvalue_to_ruby_value(v, tx).0.borrow())
     }
     pub(crate) fn ymap_insert(
         &self,

data/ext/yrb/src/yvalue.rs

@@ -1,8 +1,8 @@
 use crate::{YText, YXmlElement, YXmlText};
 use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
-use magnus::value::Qnil;
-use magnus::{class, Float, Integer, RArray, RHash, RString, Symbol, Value, QNIL};
+use magnus::value::{Qnil, ReprValue};
+use magnus::{class, value, Float, Integer, IntoValue, RArray, RHash, RString, Symbol, Value};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use yrs::types::Value as YrsValue;
@@ -21,100 +21,100 @@ impl From<Value> for YValue {
 
 impl From<Qnil> for YValue {
     fn from(value: Qnil) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<bool> for YValue {
     fn from(value: bool) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<f64> for YValue {
     fn from(value: f64) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<i64> for YValue {
     fn from(value: i64) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<u32> for YValue {
     fn from(value: u32) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<String> for YValue {
     fn from(value: String) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<RArray> for YValue {
     fn from(value: RArray) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<RHash> for YValue {
     fn from(value: RHash) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<YrsText> for YValue {
     fn from(value: YrsText) -> Self {
-        YValue(RefCell::from(Value::from(YText(RefCell::from(value)))))
+        YValue(RefCell::from(YText(RefCell::from(value)).into_value()))
     }
 }
 
 impl From<YrsXmlElement> for YValue {
     fn from(value: YrsXmlElement) -> Self {
-        YValue(RefCell::from(Value::from(YXmlElement(RefCell::from(
-            value,
-        )))))
+        YValue(RefCell::from(
+            YXmlElement(RefCell::from(value)).into_value(),
+        ))
     }
 }
 
 impl From<YrsXmlText> for YValue {
     fn from(value: YrsXmlText) -> Self {
-        YValue(RefCell::from(Value::from(YXmlText(RefCell::from(value)))))
+        YValue(RefCell::from(YXmlText(RefCell::from(value)).into_value()))
     }
 }
 
 impl From<YText> for YValue {
     fn from(value: YText) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<YXmlElement> for YValue {
     fn from(value: YXmlElement) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<YXmlText> for YValue {
     fn from(value: YXmlText) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<Any> for YValue {
     fn from(value: Any) -> Self {
         match value {
-            Any::Null => YValue::from(QNIL),
-            Any::Undefined => YValue::from(QNIL),
+            Any::Null => YValue::from(value::qnil()),
+            Any::Undefined => YValue::from(value::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.into_string()),
-            Any::Buffer(v) => YValue::from(Value::from(v.into_vec())),
+            Any::Buffer(v) => YValue::from(v.into_vec().into_value()),
             Any::Array(v) => {
                 let arr = RArray::new();
                 for item in v.iter() {
@@ -146,16 +146,18 @@ impl From<YrsValue> for YValue {
             YrsValue::YXmlElement(el) => YValue::from(el),
             YrsValue::YXmlText(text) => YValue::from(text),
             YrsValue::YArray(val) => {
+                print!("try to acquire transaction");
                 let tx = val.transact();
                 let arr = RArray::new();
                 for item in val.iter(&tx) {
                     let val = YValue::from(item.clone());
-                    let val = val.0.borrow().clone();
+                    let val = *val.0.borrow();
                     arr.push(val).expect("cannot push item event to array");
                 }
                 YValue::from(arr)
             }
             YrsValue::YMap(val) => {
+                print!("try to acquire transaction");
                 let tx = val.transact();
                 let iter = val.iter(&tx).map(|(key, val)| {
                     let val = YValue::from(val);
@@ -237,6 +239,7 @@ impl Into<Value> for YValue {
 mod tests {
     use crate::yvalue::YValue;
     use lib0::any::Any;
+    use magnus::value::ReprValue;
 
     #[test]
     fn convert_any_to_yvalue() {

data/ext/yrb/src/yxml_element.rs

@@ -3,7 +3,7 @@ use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 use crate::YTransaction;
 use magnus::block::Proc;
-use magnus::{Error, RArray, RHash, Symbol, Value};
+use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::Change;
 use yrs::{
@@ -32,9 +32,9 @@ impl YXmlElement {
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().get(tx, index).map(|node| match node {
-            XmlNode::Element(element) => Value::from(YXmlElement::from(element)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
     pub(crate) fn yxml_element_get_attribute(
@@ -93,9 +93,9 @@ impl YXmlElement {
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().siblings(tx).next().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
     pub(crate) fn yxml_element_observe(&self, block: Proc) -> Result<u32, Error> {
@@ -161,9 +161,9 @@ impl YXmlElement {
     }
     pub(crate) fn yxml_element_parent(&self) -> Option<Value> {
         self.0.borrow().parent().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
     pub(crate) fn yxml_element_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
@@ -175,9 +175,9 @@ impl YXmlElement {
             .siblings(tx)
             .next_back()
             .map(|item| match item {
-                XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
-                XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-                XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+                XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+                XmlNode::Text(text) => YXmlText::from(text).into_value(),
             })
     }
     pub(crate) fn yxml_element_push_element_back(
@@ -246,9 +246,9 @@ impl YXmlElement {
         let tx = tx.as_ref().unwrap();
 
         let siblings = self.0.borrow().siblings(tx).map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         });
 
         RArray::from_iter(siblings)

data/ext/yrb/src/yxml_fragment.rs

@@ -1,7 +1,7 @@
 use crate::ytransaction::YTransaction;
 use crate::yxml_element::YXmlElement;
 use crate::yxml_text::YXmlText;
-use magnus::{RArray, Value};
+use magnus::{IntoValue, RArray, Value};
 use std::cell::RefCell;
 use yrs::{GetString, XmlElementPrelim, XmlFragment, XmlFragmentRef, XmlNode};
 
@@ -14,9 +14,9 @@ unsafe impl Send for YXmlFragment {}
 impl YXmlFragment {
     pub(crate) fn yxml_fragment_first_child(&self) -> Option<Value> {
         self.0.borrow().first_child().map(|node| match node {
-            XmlNode::Element(element) => Value::from(YXmlElement::from(element)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
 
@@ -29,9 +29,9 @@ impl YXmlFragment {
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().get(tx, index).map(|node| match node {
-            XmlNode::Element(element) => Value::from(YXmlElement::from(element)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
 
@@ -57,9 +57,9 @@ impl YXmlFragment {
 
     pub(crate) fn yxml_fragment_parent(&self) -> Option<Value> {
         self.0.borrow().parent().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
 
@@ -106,9 +106,9 @@ impl YXmlFragment {
         let fragment = self.0.borrow();
 
         let result = fragment.successors(tx).map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
-            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         });
 
         RArray::from_iter(result)

data/ext/yrb/src/yxml_text.rs

@@ -3,7 +3,7 @@ use crate::yvalue::YValue;
 use crate::yxml_fragment::YXmlFragment;
 use crate::{YTransaction, YXmlElement};
 use lib0::any::Any;
-use magnus::{Error, RHash, Value};
+use magnus::{Error, IntoValue, RHash, Value};
 use std::cell::RefCell;
 use yrs::{GetString, Text, Xml, XmlNode, XmlTextRef};
 
@@ -120,16 +120,16 @@ impl YXmlText {
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().siblings(tx).next().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment(RefCell::from(fragment))),
-            XmlNode::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+            XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment(RefCell::from(fragment)).into_value(),
+            XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value(),
         })
     }
     pub(crate) fn yxml_text_parent(&self) -> Option<Value> {
         self.0.borrow().parent().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment(RefCell::from(fragment))),
-            XmlNode::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+            XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment(RefCell::from(fragment)).into_value(),
+            XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value(),
         })
     }
     pub(crate) fn yxml_text_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
@@ -141,9 +141,9 @@ impl YXmlText {
             .siblings(tx)
             .next_back()
             .map(|item| match item {
-                XmlNode::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-                XmlNode::Fragment(fragment) => Value::from(YXmlFragment(RefCell::from(fragment))),
-                XmlNode::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+                XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value(),
+                XmlNode::Fragment(fragment) => YXmlFragment(RefCell::from(fragment)).into_value(),
+                XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value(),
             })
     }
     pub(crate) fn yxml_text_push(&self, transaction: &YTransaction, content: String) {

data/lib/y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Y
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: x64-mingw-ucrt
 authors:
 - Hannes Moser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-06 00:00:00.000000000 Z
+date: 2023-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake