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

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, IntoValue, RArray, RHash, Symbol, Value};
+use magnus::{Error, IntoValue, RArray, RHash, Ruby, Value};
 use std::cell::RefCell;
 use yrs::types::Change;
 use yrs::{
@@ -19,22 +19,28 @@ unsafe impl Send for YXmlElement {}
 
 impl YXmlElement {
     pub(crate) fn yxml_element_attributes(&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().attributes(tx))
+        let hash = ruby.hash_new();
+        for (k, v) in self.0.borrow().attributes(tx) {
+            hash.aset(k, v).expect("cannot insert into hash");
+        }
+        hash
     }
     pub(crate) fn yxml_element_first_child(&self, transaction: &YTransaction) -> Option<Value> {
         self.yxml_element_get(transaction, 0)
     }
     pub(crate) fn yxml_element_get(&self, transaction: &YTransaction, index: u32) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().get(tx, index).map(|node| match node {
-            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
-            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+            XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
         })
     }
     pub(crate) fn yxml_element_get_attribute(
@@ -89,38 +95,41 @@ impl YXmlElement {
         self.0.borrow().len(tx)
     }
     pub(crate) fn yxml_element_next_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().siblings(tx).next().map(|item| match item {
-            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
-            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+            XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
         })
     }
     pub(crate) fn yxml_element_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 subscription_id = self
             .0
             .borrow_mut()
             .observe(move |transaction, xml_element_event| {
+                let ruby = unsafe { Ruby::get_unchecked() };
                 let delta = xml_element_event.delta(transaction);
-                let changes = RArray::with_capacity(delta.len());
+                let changes = ruby.ary_new_capa(delta.len());
 
                 for change in delta {
                     match change {
                         Change::Added(v) => {
-                            let values = RArray::new();
+                            let values = ruby.ary_new();
                             for value in v.iter() {
                                 let value = YValue::from(value.clone());
                                 let value = *value.0.borrow();
                                 values.push(value).expect("cannot push value to array");
                             }
 
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(change_added, values)
                                 .expect("cannot create change::added payload");
@@ -130,7 +139,7 @@ impl YXmlElement {
                                 .expect("cannot push payload to list of changes");
                         }
                         Change::Retain(position) => {
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(change_retain, *position)
                                 .expect("cannot create change::retain payload");
@@ -140,7 +149,7 @@ impl YXmlElement {
                                 .expect("cannot push payload to list of changes");
                         }
                         Change::Removed(position) => {
-                            let payload = RHash::new();
+                            let payload = ruby.hash_new();
                             payload
                                 .aset(change_removed, *position)
                                 .expect("cannot create change::removed payload");
@@ -160,13 +169,15 @@ impl YXmlElement {
         Ok(subscription_id.into())
     }
     pub(crate) fn yxml_element_parent(&self) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         self.0.borrow().parent().map(|item| match item {
-            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
-            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+            XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
         })
     }
     pub(crate) fn yxml_element_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
@@ -175,9 +186,9 @@ impl YXmlElement {
             .siblings(tx)
             .next_back()
             .map(|item| match item {
-                XmlNode::Element(el) => YXmlElement::from(el).into_value(),
-                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-                XmlNode::Text(text) => YXmlText::from(text).into_value(),
+                XmlNode::Element(el) => YXmlElement::from(el).into_value_with(&ruby),
+                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+                XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
             })
     }
     pub(crate) fn yxml_element_push_element_back(
@@ -242,16 +253,20 @@ impl YXmlElement {
         self.0.borrow_mut().remove_range(tx, index, length)
     }
     pub(crate) fn yxml_element_siblings(&self, transaction: &YTransaction) -> RArray {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
-        let siblings = self.0.borrow().siblings(tx).map(|item| match item {
-            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)
+        let array = ruby.ary_new();
+        for item in self.0.borrow().siblings(tx) {
+            let value = match item {
+                XmlNode::Element(el) => YXmlElement::from(el).into_value_with(&ruby),
+                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+                XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
+            };
+            array.push(value).expect("cannot push value to array");
+        }
+        array
     }
     pub(crate) fn yxml_element_size(&self, transaction: &YTransaction) -> u32 {
         let tx = transaction.transaction();

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::{IntoValue, RArray, Value};
+use magnus::{IntoValue, RArray, Ruby, Value};
 use std::cell::RefCell;
 use yrs::{GetString, XmlElementPrelim, XmlFragment, XmlFragmentRef, XmlNode};
 
@@ -13,10 +13,11 @@ unsafe impl Send for YXmlFragment {}
 
 impl YXmlFragment {
     pub(crate) fn yxml_fragment_first_child(&self) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         self.0.borrow().first_child().map(|node| match node {
-            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
-            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+            XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
         })
     }
 
@@ -25,13 +26,14 @@ impl YXmlFragment {
         transaction: &YTransaction,
         index: u32,
     ) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().get(tx, index).map(|node| match node {
-            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
-            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+            XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
         })
     }
 
@@ -56,10 +58,11 @@ impl YXmlFragment {
     }
 
     pub(crate) fn yxml_fragment_parent(&self) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         self.0.borrow().parent().map(|item| match item {
-            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
-            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
-            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+            XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
         })
     }
 
@@ -100,18 +103,22 @@ impl YXmlFragment {
     }
 
     pub(crate) fn yxml_fragment_successors(&self, transaction: &YTransaction) -> RArray {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         let fragment = self.0.borrow();
 
-        let result = fragment.successors(tx).map(|item| match item {
-            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)
+        let array = ruby.ary_new();
+        for item in fragment.successors(tx) {
+            let value = match item {
+                XmlNode::Element(el) => YXmlElement::from(el).into_value_with(&ruby),
+                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value_with(&ruby),
+                XmlNode::Text(text) => YXmlText::from(text).into_value_with(&ruby),
+            };
+            array.push(value).expect("cannot push value to array");
+        }
+        array
     }
 
     pub(crate) fn yxml_fragment_to_s(&self, transaction: &YTransaction) -> String {

data/ext/yrb/src/yxml_text.rs

@@ -2,7 +2,7 @@ use crate::utils::map_rhash_to_attrs;
 use crate::yvalue::YValue;
 use crate::yxml_fragment::YXmlFragment;
 use crate::{YTransaction, YXmlElement};
-use magnus::{Error, IntoValue, RHash, Value};
+use magnus::{Error, IntoValue, RHash, Ruby, Value};
 use std::cell::RefCell;
 use yrs::{Any, GetString, Text, Xml, XmlNode, XmlTextRef};
 
@@ -14,10 +14,15 @@ unsafe impl Send for YXmlText {}
 
 impl YXmlText {
     pub(crate) fn yxml_text_attributes(&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().attributes(tx))
+        let hash = ruby.hash_new();
+        for (k, v) in self.0.borrow().attributes(tx) {
+            hash.aset(k, v).expect("cannot insert into hash");
+        }
+        hash
     }
     pub(crate) fn yxml_text_format(
         &self,
@@ -115,23 +120,30 @@ impl YXmlText {
         self.0.borrow().len(tx)
     }
     pub(crate) fn yxml_text_next_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().siblings(tx).next().map(|item| match item {
-            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(),
+            XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => {
+                YXmlFragment(RefCell::from(fragment)).into_value_with(&ruby)
+            }
+            XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value_with(&ruby),
         })
     }
     pub(crate) fn yxml_text_parent(&self) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         self.0.borrow().parent().map(|item| match item {
-            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(),
+            XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value_with(&ruby),
+            XmlNode::Fragment(fragment) => {
+                YXmlFragment(RefCell::from(fragment)).into_value_with(&ruby)
+            }
+            XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value_with(&ruby),
         })
     }
     pub(crate) fn yxml_text_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let ruby = unsafe { Ruby::get_unchecked() };
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
@@ -140,9 +152,11 @@ impl YXmlText {
             .siblings(tx)
             .next_back()
             .map(|item| match item {
-                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(),
+                XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value_with(&ruby),
+                XmlNode::Fragment(fragment) => {
+                    YXmlFragment(RefCell::from(fragment)).into_value_with(&ruby)
+                }
+                XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value_with(&ruby),
             })
     }
     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.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: aarch64-linux-gnu
 authors:
 - Hannes Moser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-12 00:00:00.000000000 Z
+date: 2026-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.3.0
 description: Ruby bindings for yrs. Yrs "wires" is a Rust port of the Yjs framework.
 email:
 - hmoser@gitlab.com
@@ -95,6 +95,7 @@ files:
 - lib/3.2/yrb.so
 - lib/3.3/yrb.so
 - lib/3.4/yrb.so
+- lib/4.0/yrb.so
 - lib/y-rb.rb
 - lib/y.rb
 - lib/y/array.rb
@@ -126,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
   - - "<"
     - !ruby/object:Gem::Version
-      version: 3.5.dev
+      version: 4.1.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="