y-rb 0.3.2-x64-mingw-ucrt → 0.4.0-x64-mingw-ucrt

data/ext/yrb/src/yxml_element.rs

@@ -1,33 +1,51 @@
 use crate::yvalue::YValue;
+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 std::cell::RefCell;
 use yrs::types::Change;
-use yrs::{Xml, XmlElement};
+use yrs::{
+    GetString, Observable, Xml, XmlElementPrelim, XmlElementRef, XmlFragment, XmlNode,
+    XmlTextPrelim,
+};
 
 #[magnus::wrap(class = "Y::XMLElement")]
-pub(crate) struct YXmlElement(pub(crate) RefCell<XmlElement>);
+pub(crate) struct YXmlElement(pub(crate) RefCell<XmlElementRef>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YXmlElement {}
 
 impl YXmlElement {
-    pub(crate) fn yxml_element_attributes(&self) -> RHash {
-        RHash::from_iter(self.0.borrow().attributes())
+    pub(crate) fn yxml_element_attributes(&self, transaction: &YTransaction) -> RHash {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        RHash::from_iter(self.0.borrow().attributes(tx))
     }
-    pub(crate) fn yxml_element_first_child(&self) -> Option<Value> {
-        self.yxml_element_get(0)
+    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, index: u32) -> Option<Value> {
-        self.0.borrow().get(index).map(|node| match node {
-            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+    pub(crate) fn yxml_element_get(&self, transaction: &YTransaction, index: u32) -> Option<Value> {
+        let tx = transaction.transaction();
+        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)),
         })
     }
-    pub(crate) fn yxml_element_get_attribute(&self, name: String) -> Option<String> {
-        self.0.borrow().get_attribute(&*name)
+    pub(crate) fn yxml_element_get_attribute(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+    ) -> Option<String> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_attribute(tx, name.as_str())
     }
     pub(crate) fn yxml_element_insert_attribute(
         &self,
@@ -35,39 +53,43 @@ impl YXmlElement {
         name: String,
         value: String,
     ) {
-        self.0
-            .borrow_mut()
-            .insert_attribute(&mut *transaction.0.borrow_mut(), name, value);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().insert_attribute(tx, name, value)
     }
     pub(crate) fn yxml_element_insert_element(
         &self,
         transaction: &YTransaction,
         index: u32,
-        name: String,
+        tag: String,
     ) -> YXmlElement {
-        let element =
-            self.0
-                .borrow_mut()
-                .insert_elem(&mut *transaction.0.borrow_mut(), index, name);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YXmlElement(RefCell::from(element))
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().insert(tx, index, node))
     }
     pub(crate) fn yxml_element_insert_text(
         &self,
         transaction: &YTransaction,
         index: u32,
+        content: String,
     ) -> YXmlText {
-        let text = self
-            .0
-            .borrow_mut()
-            .insert_text(&mut *transaction.0.borrow_mut(), index);
+        let text = XmlTextPrelim(content.as_str());
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YXmlText(RefCell::from(text))
+        YXmlText::from(self.0.borrow_mut().insert(tx, index, text))
     }
-    pub(crate) fn yxml_element_next_sibling(&self) -> Option<Value> {
-        self.0.borrow().next_sibling().map(|item| match item {
-            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+    pub(crate) fn yxml_element_next_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let tx = transaction.transaction();
+        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)),
         })
     }
     pub(crate) fn yxml_element_observe(&self, block: Proc) -> Result<u32, Error> {
@@ -131,61 +153,75 @@ impl YXmlElement {
         Ok(subscription_id.into())
     }
     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)),
+        })
+    }
+    pub(crate) fn yxml_element_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
         self.0
             .borrow()
-            .parent()
-            .map(|item| Value::from(YXmlElement(RefCell::from(item))))
-    }
-    pub(crate) fn yxml_element_prev_sibling(&self) -> Option<Value> {
-        self.0.borrow().prev_sibling().map(|item| match item {
-            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
-        })
+            .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)),
+            })
     }
     pub(crate) fn yxml_element_push_element_back(
         &self,
         transaction: &YTransaction,
-        name: String,
+        tag: String,
     ) -> YXmlElement {
-        let xml_element = self
-            .0
-            .borrow_mut()
-            .push_elem_back(&mut *transaction.0.borrow_mut(), name);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YXmlElement(RefCell::from(xml_element))
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_back(tx, node))
     }
     pub(crate) fn yxml_element_push_element_front(
         &self,
         transaction: &YTransaction,
-        name: String,
+        tag: String,
     ) -> YXmlElement {
-        let xml_element = self
-            .0
-            .borrow_mut()
-            .push_elem_front(&mut *transaction.0.borrow_mut(), name);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YXmlElement(RefCell::from(xml_element))
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_front(tx, node))
     }
-    pub(crate) fn yxml_element_push_text_back(&self, transaction: &YTransaction) -> YXmlText {
-        let xml_text = self
-            .0
-            .borrow_mut()
-            .push_text_back(&mut *transaction.0.borrow_mut());
+    pub(crate) fn yxml_element_push_text_back(
+        &self,
+        transaction: &YTransaction,
+        content: String,
+    ) -> YXmlText {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YXmlText(RefCell::from(xml_text))
+        let text = XmlTextPrelim(content.as_str());
+        YXmlText::from(self.0.borrow_mut().push_back(tx, text))
     }
-    pub(crate) fn yxml_element_push_text_front(&self, transaction: &YTransaction) -> YXmlText {
-        let xml_text = self
-            .0
-            .borrow_mut()
-            .push_text_front(&mut *transaction.0.borrow_mut());
+    pub(crate) fn yxml_element_push_text_front(
+        &self,
+        transaction: &YTransaction,
+        content: String,
+    ) -> YXmlText {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YXmlText(RefCell::from(xml_text))
+        let text = XmlTextPrelim(content.as_str());
+        YXmlText::from(self.0.borrow_mut().push_front(tx, text))
     }
     pub(crate) fn yxml_element_remove_attribute(&self, transaction: &YTransaction, name: String) {
-        self.0
-            .borrow_mut()
-            .remove_attribute::<&str>(&mut *transaction.0.borrow_mut(), &name.as_str());
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_attribute(tx, &name)
     }
     pub(crate) fn yxml_element_remove_range(
         &self,
@@ -193,20 +229,45 @@ impl YXmlElement {
         index: u32,
         length: u32,
     ) {
-        self.0
-            .borrow_mut()
-            .remove_range(&mut *transaction.0.borrow_mut(), index, length);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_range(tx, index, length)
+    }
+    pub(crate) fn yxml_element_siblings(&self, transaction: &YTransaction) -> RArray {
+        let tx = transaction.transaction();
+        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)),
+        });
+
+        RArray::from_iter(siblings)
     }
-    pub(crate) fn yxml_element_size(&self) -> u32 {
-        self.0.borrow().len()
+    pub(crate) fn yxml_element_size(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
     }
     pub(crate) fn yxml_element_tag(&self) -> String {
         self.0.borrow().tag().to_string()
     }
-    pub(crate) fn yxml_element_to_s(&self) -> String {
-        self.0.borrow().to_string()
+    pub(crate) fn yxml_element_to_s(&self, transaction: &YTransaction) -> String {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_string(tx)
     }
     pub(crate) fn yxml_element_unobserve(&self, subscription_id: u32) {
         self.0.borrow_mut().unobserve(subscription_id);
     }
 }
+
+impl From<XmlElementRef> for YXmlElement {
+    fn from(v: XmlElementRef) -> Self {
+        YXmlElement(RefCell::from(v))
+    }
+}

data/ext/yrb/src/yxml_fragment.rs

@@ -0,0 +1,16 @@
+use std::cell::RefCell;
+use yrs::XmlFragmentRef;
+
+#[magnus::wrap(class = "Y::XMLFragment")]
+pub(crate) struct YXmlFragment(pub(crate) RefCell<XmlFragmentRef>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YXmlFragment {}
+
+impl YXmlFragment {}
+
+impl From<XmlFragmentRef> for YXmlFragment {
+    fn from(v: XmlFragmentRef) -> Self {
+        YXmlFragment(RefCell::from(v))
+    }
+}

data/ext/yrb/src/yxml_text.rs

@@ -1,20 +1,24 @@
 use crate::utils::map_rhash_to_attrs;
 use crate::yvalue::YValue;
+use crate::yxml_fragment::YXmlFragment;
 use crate::{YTransaction, YXmlElement};
 use lib0::any::Any;
 use magnus::{Error, RHash, Value};
 use std::cell::RefCell;
-use yrs::{Xml, XmlText};
+use yrs::{GetString, Text, Xml, XmlNode, XmlTextRef};
 
 #[magnus::wrap(class = "Y::XMLText")]
-pub(crate) struct YXmlText(pub(crate) RefCell<XmlText>);
+pub(crate) struct YXmlText(pub(crate) RefCell<XmlTextRef>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YXmlText {}
 
 impl YXmlText {
-    pub(crate) fn yxml_text_attributes(&self) -> RHash {
-        RHash::from_iter(self.0.borrow().attributes())
+    pub(crate) fn yxml_text_attributes(&self, transaction: &YTransaction) -> RHash {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        RHash::from_iter(self.0.borrow().attributes(tx))
     }
     pub(crate) fn yxml_text_format(
         &self,
@@ -23,19 +27,26 @@ impl YXmlText {
         length: u32,
         attrs: RHash,
     ) -> Result<(), Error> {
-        map_rhash_to_attrs(attrs).map(|a| {
-            self.0
-                .borrow_mut()
-                .format(&mut *transaction.0.borrow_mut(), index, length, a);
-        })
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        map_rhash_to_attrs(attrs).map(|a| self.0.borrow_mut().format(tx, index, length, a))
     }
-    pub(crate) fn yxml_text_get_attribute(&self, name: String) -> Option<String> {
-        self.0.borrow().get_attribute(&*name)
+    pub(crate) fn yxml_text_get_attribute(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+    ) -> Option<String> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_attribute(tx, name.as_str())
     }
     pub(crate) fn yxml_text_insert(&self, transaction: &YTransaction, index: u32, content: String) {
-        self.0
-            .borrow_mut()
-            .insert(&mut *transaction.0.borrow_mut(), index, &*content)
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().insert(tx, index, content.as_str())
     }
     pub(crate) fn yxml_text_insert_attribute(
         &self,
@@ -43,9 +54,10 @@ impl YXmlText {
         name: String,
         value: String,
     ) {
-        self.0
-            .borrow_mut()
-            .insert_attribute(&mut *transaction.0.borrow_mut(), name, value)
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().insert_attribute(tx, name, value)
     }
     pub(crate) fn yxml_text_insert_embed_with_attributes(
         &self,
@@ -54,16 +66,16 @@ impl YXmlText {
         content: Value,
         attrs: RHash,
     ) -> Result<(), Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         let yvalue = YValue::from(content);
         let avalue = Any::from(yvalue);
 
         map_rhash_to_attrs(attrs).map(|a| {
-            self.0.borrow_mut().insert_embed_with_attributes(
-                &mut *transaction.0.borrow_mut(),
-                index,
-                avalue,
-                a,
-            );
+            self.0
+                .borrow_mut()
+                .insert_embed_with_attributes(tx, index, avalue, a)
         })
     }
     pub(crate) fn yxml_text_insert_embed(
@@ -72,11 +84,12 @@ impl YXmlText {
         index: u32,
         embed: Value,
     ) {
-        self.0.borrow_mut().insert_embed(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            Any::from(YValue::from(embed)),
-        )
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0
+            .borrow_mut()
+            .insert_embed(tx, index, Any::from(YValue::from(embed)))
     }
     pub(crate) fn yxml_text_insert_with_attributes(
         &self,
@@ -85,40 +98,57 @@ impl YXmlText {
         content: String,
         attrs: RHash,
     ) -> Result<(), Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         map_rhash_to_attrs(attrs).map(|a| {
-            self.0.borrow_mut().insert_with_attributes(
-                &mut *transaction.0.borrow_mut(),
-                index,
-                &*content,
-                a,
-            );
+            self.0
+                .borrow_mut()
+                .insert_with_attributes(tx, index, content.as_str(), a);
         })
     }
-    pub(crate) fn yxml_text_length(&self) -> u32 {
-        self.0.borrow().len()
+    pub(crate) fn yxml_text_length(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
     }
-    pub(crate) fn yxml_text_next_sibling(&self) -> Option<Value> {
-        self.0.borrow().next_sibling().map(|item| match item {
-            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+    pub(crate) fn yxml_text_next_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let tx = transaction.transaction();
+        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))),
         })
     }
     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))),
+        })
+    }
+    pub(crate) fn yxml_text_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
         self.0
             .borrow()
-            .parent()
-            .map(|item| Value::from(YXmlElement(RefCell::from(item))))
-    }
-    pub(crate) fn yxml_text_prev_sibling(&self) -> Option<Value> {
-        self.0.borrow().prev_sibling().map(|item| match item {
-            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
-        })
+            .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))),
+            })
     }
     pub(crate) fn yxml_text_push(&self, transaction: &YTransaction, content: String) {
-        self.0
-            .borrow_mut()
-            .push(&mut *transaction.0.borrow_mut(), &*content)
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().push(tx, content.as_str())
     }
     pub(crate) fn yxml_text_remove_range(
         &self,
@@ -126,11 +156,21 @@ impl YXmlText {
         index: u32,
         length: u32,
     ) {
-        self.0
-            .borrow_mut()
-            .remove_range(&mut *transaction.0.borrow_mut(), index, length);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_range(tx, index, length)
+    }
+    pub(crate) fn yxml_text_to_s(&self, transaction: &YTransaction) -> String {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_string(tx)
     }
-    pub(crate) fn yxml_text_to_s(&self) -> String {
-        self.0.borrow().to_string()
+}
+
+impl From<XmlTextRef> for YXmlText {
+    fn from(v: XmlTextRef) -> Self {
+        YXmlText(RefCell::from(v))
     }
 }