y-rb 0.3.2-x64-mingw32 → 0.4.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f36fedaf73d9ee6ca57cdffd3aaa8ab929125ddcb02dbf4f2f8ef9d955fc3ff
-  data.tar.gz: 33ee25caaad2fba8502209f1b9235c910fb9824c2dbd02fff3de0fee1370d07b
+  metadata.gz: 1a67092ecdf07eb9effa218788d4338aeb4096d7ad26a255d495ffa58fc612bf
+  data.tar.gz: d124feed46dcf3c74e0364c768b6079c223da718a250ae95596a1305a57e7aca
 SHA512:
-  metadata.gz: 0e2731b2d8ccf556eb1b326102dd91f72b607bb952eb90f64b120d5cab753803a9670733d8ce1d6f6eb0e96e49492200588ae85877a955193b2b114be2710604
-  data.tar.gz: ebc4756e03e9757e2e38269f393733fe6852e62939636b28adc4091912f8a320b95f811c57c6da05993b46f11e810bdf74c43fc4aca485108fb1e9325a69d3f6
+  metadata.gz: 469dd22f4fd99a6178be2bb2115fe90f7af5b22f386ff65abf05b29eaa6db6c65d87e50f472f2a56a00af144cd6b914cace7450c960b21e8f50fea270fe3b3ea
+  data.tar.gz: 1dd48fbe469733abb838b7a7318d1ad67c48d533c5e4b2e84220bfcc6b5293566a36badf2c8993be5feb0397bba23c78dee8af058e14211db856971fc5cce983

data/ext/yrb/Cargo.toml

@@ -1,20 +1,19 @@
 [package]
 name = "yrb"
-version = "0.3.2"
+version = "0.4.0"
 authors = ["Hannes Moser <box@hannesmoser.at>", "Hannes Moser <hmoser@gitlab.com>"]
 edition = "2021"
 homepage = "https://github.com/y-crdt/yrb"
 repository = "https://github.com/y-crdt/yrb"
 
 [dependencies]
-lib0 = "0.12.2" # must match yrs version
-magnus = { git = "https://github.com/matsadler/magnus", rev = "4c9857cecabec2df6cc230763560815520de20b7"} # waiting for release with full rb-sys backend
-rb-sys = { version = "~0.9.35", features = ["link-ruby"] }
+lib0 = "0.14.1" # must match yrs version
+magnus = { version = "0.4.3" }
 thiserror = "1.0.37"
-yrs = "0.12.2"
+yrs = "0.14.1"
 
 [dev-dependencies]
-magnus = { git = "https://github.com/matsadler/magnus", rev = "4c9857cecabec2df6cc230763560815520de20b7", features = ["embed"] } # waiting for release with full rb-sys backend
+magnus = { version = "0.4.3", features = ["embed"] }
 
 [lib]
 name = "yrb"

data/ext/yrb/src/awareness.rs

@@ -64,7 +64,7 @@ impl Awareness {
 
     /// Returns a globally unique client ID of an underlying [Doc].
     pub fn client_id(&self) -> ClientID {
-        self.doc.client_id
+        self.doc.client_id()
     }
 
     /// Returns a state map of all of the clients tracked by current [Awareness] instance. Those
@@ -76,7 +76,7 @@ impl Awareness {
 
     /// Returns a JSON string state representation of a current [Awareness] instance.
     pub fn local_state(&self) -> Option<&str> {
-        Some(self.states.get(&self.doc.client_id)?.as_str())
+        Some(self.states.get(&self.doc.client_id())?.as_str())
     }
 
     /// Sets a current [Awareness] instance state to a corresponding JSON string. This state will
@@ -84,7 +84,7 @@ impl Awareness {
     /// to be emitted if current instance was created using [Awareness::with_observer] method.
     ///
     pub fn set_local_state<S: Into<String>>(&mut self, json: S) {
-        let client_id = self.doc.client_id;
+        let client_id = self.doc.client_id();
         self.update_meta(client_id);
         let new: String = json.into();
         match self.states.entry(client_id) {
@@ -120,7 +120,7 @@ impl Awareness {
     /// Clears out a state of a current client (see: [Awareness::client_id]),
     /// effectively marking it as disconnected.
     pub fn clean_local_state(&mut self) {
-        let client_id = self.doc.client_id;
+        let client_id = self.doc.client_id();
         self.remove_state(client_id);
     }
 
@@ -192,7 +192,7 @@ impl Awareness {
                     if is_new || is_removed {
                         if is_null {
                             // never let a remote client remove this local state
-                            if client_id == self.doc.client_id
+                            if client_id == self.doc.client_id()
                                 && self.states.get(&client_id).is_some()
                             {
                                 // remote client removed the local state. Do not remote state. Broadcast a message indicating

data/ext/yrb/src/lib.rs

@@ -22,6 +22,7 @@ mod ytext;
 mod ytransaction;
 mod yvalue;
 mod yxml_element;
+mod yxml_fragment;
 mod yxml_text;
 
 #[magnus::init]
@@ -33,10 +34,10 @@ fn init() -> Result<(), Error> {
         .expect("cannot find class Y::Array");
 
     yarray
-        .define_private_method("yarray_each", method!(YArray::yarray_each, 1))
+        .define_private_method("yarray_each", method!(YArray::yarray_each, 2))
         .expect("cannot define private method: yarray_each");
     yarray
-        .define_private_method("yarray_get", method!(YArray::yarray_get, 1))
+        .define_private_method("yarray_get", method!(YArray::yarray_get, 2))
         .expect("cannot define private method: yarray_get");
     yarray
         .define_private_method("yarray_insert", method!(YArray::yarray_insert, 3))
@@ -48,7 +49,7 @@ fn init() -> Result<(), Error> {
         )
         .expect("cannot define private method: yarray_insert_range");
     yarray
-        .define_private_method("yarray_length", method!(YArray::yarray_length, 0))
+        .define_private_method("yarray_length", method!(YArray::yarray_length, 1))
         .expect("cannot define private method: yarray_length");
     yarray
         .define_private_method("yarray_observe", method!(YArray::yarray_observe, 1))
@@ -69,7 +70,7 @@ fn init() -> Result<(), Error> {
         )
         .expect("cannot define private method: yarray_remove_range");
     yarray
-        .define_private_method("yarray_to_a", method!(YArray::yarray_to_a, 0))
+        .define_private_method("yarray_to_a", method!(YArray::yarray_to_a, 1))
         .expect("cannot define private method: yarray_to_a");
     yarray
         .define_private_method("yarray_unobserve", method!(YArray::yarray_unobserve, 1))
@@ -80,10 +81,40 @@ fn init() -> Result<(), Error> {
         .expect("cannot define class Y::Doc");
     ydoc.define_singleton_method("new", function!(YDoc::ydoc_new, -1))
         .expect("cannot define singleton method: ydoc_new");
+    ydoc.define_private_method("ydoc_encode_diff_v1", method!(YDoc::ydoc_encode_diff_v1, 2))
+        .expect("cannot define private method: ydoc_encode_diff_v1");
+    ydoc.define_private_method(
+        "ydoc_get_or_insert_array",
+        method!(YDoc::ydoc_get_or_insert_array, 1),
+    )
+    .expect("cannot define private method: ydoc_get_or_insert_array");
+    ydoc.define_private_method(
+        "ydoc_get_or_insert_map",
+        method!(YDoc::ydoc_get_or_insert_map, 1),
+    )
+    .expect("cannot define private method: ydoc_get_or_insert_map");
+    ydoc.define_private_method(
+        "ydoc_get_or_insert_text",
+        method!(YDoc::ydoc_get_or_insert_text, 1),
+    )
+    .expect("cannot define private method: ydoc_get_or_insert_text");
+    ydoc.define_private_method(
+        "ydoc_get_or_insert_xml_element",
+        method!(YDoc::ydoc_get_or_insert_xml_element, 1),
+    )
+    .expect("cannot define private method: ydoc_get_or_insert_xml_element");
+    ydoc.define_private_method(
+        "ydoc_get_or_insert_xml_fragment",
+        method!(YDoc::ydoc_get_or_insert_xml_fragment, 1),
+    )
+    .expect("cannot define private method: ydoc_get_or_insert_xml_fragment");
+    ydoc.define_private_method(
+        "ydoc_get_or_insert_xml_text",
+        method!(YDoc::ydoc_get_or_insert_xml_text, 1),
+    )
+    .expect("cannot define private method: ydoc_get_or_insert_xml_text");
     ydoc.define_private_method("ydoc_transact", method!(YDoc::ydoc_transact, 0))
         .expect("cannot define private method: ydoc_transact");
-    ydoc.define_private_method("ydoc_encode_diff_v1", method!(YDoc::ydoc_encode_diff_v1, 1))
-        .expect("cannot define private method: ydoc_encode_diff_v1");
 
     let ymap = module
         .define_class("Map", Default::default())
@@ -91,11 +122,11 @@ fn init() -> Result<(), Error> {
 
     ymap.define_private_method("ymap_clear", method!(YMap::ymap_clear, 1))
         .expect("cannot define private method: ymap_clear");
-    ymap.define_private_method("ymap_contains", method!(YMap::ymap_contains, 1))
+    ymap.define_private_method("ymap_contains", method!(YMap::ymap_contains, 2))
         .expect("cannot define private method: ymap_contains");
-    ymap.define_private_method("ymap_each", method!(YMap::ymap_each, 1))
+    ymap.define_private_method("ymap_each", method!(YMap::ymap_each, 2))
         .expect("cannot define private method: ymap_each");
-    ymap.define_private_method("ymap_get", method!(YMap::ymap_get, 1))
+    ymap.define_private_method("ymap_get", method!(YMap::ymap_get, 2))
         .expect("cannot define private method: ymap_get");
     ymap.define_private_method("ymap_insert", method!(YMap::ymap_insert, 3))
         .expect("cannot define private method: ymap_insert");
@@ -103,9 +134,9 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ymap_observe");
     ymap.define_private_method("ymap_remove", method!(YMap::ymap_remove, 2))
         .expect("cannot define private method: ymap_remove");
-    ymap.define_private_method("ymap_size", method!(YMap::ymap_size, 0))
+    ymap.define_private_method("ymap_size", method!(YMap::ymap_size, 1))
         .expect("cannot define private method: ymap_size");
-    ymap.define_private_method("ymap_to_h", method!(YMap::ymap_to_h, 0))
+    ymap.define_private_method("ymap_to_h", method!(YMap::ymap_to_h, 1))
         .expect("cannot define private method: ymap_to_h");
     ymap.define_private_method("ymap_unobserve", method!(YMap::ymap_unobserve, 1))
         .expect("cannot define private method: ymap_unobserve");
@@ -126,6 +157,9 @@ fn init() -> Result<(), Error> {
             method!(YTransaction::ytransaction_commit, 0),
         )
         .expect("cannot define private method: ytransaction_commit");
+    ytransaction
+        .define_method("free", method!(YTransaction::ytransaction_free, 0))
+        .expect("");
     ytransaction
         .define_private_method(
             "ytransaction_get_array",
@@ -137,7 +171,7 @@ fn init() -> Result<(), Error> {
             "ytransaction_get_map",
             method!(YTransaction::ytransaction_get_map, 1),
         )
-        .expect("cannot define private method: ytransaction_get_mao");
+        .expect("cannot define private method: ytransaction_get_map");
     ytransaction
         .define_private_method(
             "ytransaction_get_text",
@@ -150,6 +184,12 @@ fn init() -> Result<(), Error> {
             method!(YTransaction::ytransaction_get_xml_element, 1),
         )
         .expect("cannot define private method: ytransaction_get_xml_element");
+    ytransaction
+        .define_private_method(
+            "ytransaction_get_xml_fragment",
+            method!(YTransaction::ytransaction_get_xml_fragment, 1),
+        )
+        .expect("cannot define private method: ytransaction_get_xml_fragment");
     ytransaction
         .define_private_method(
             "ytransaction_get_xml_text",
@@ -189,7 +229,7 @@ fn init() -> Result<(), Error> {
         )
         .expect("cannot define private method: ytext_insert_with_attributes");
     ytext
-        .define_private_method("ytext_length", method!(YText::ytext_length, 0))
+        .define_private_method("ytext_length", method!(YText::ytext_length, 1))
         .expect("cannot define private method: ytext_length");
     ytext
         .define_private_method("ytext_observe", method!(YText::ytext_observe, 1))
@@ -201,7 +241,7 @@ fn init() -> Result<(), Error> {
         .define_private_method("ytext_remove_range", method!(YText::ytext_remove_range, 3))
         .expect("cannot define private method: ytext_remove_range");
     ytext
-        .define_private_method("ytext_to_s", method!(YText::ytext_to_s, 0))
+        .define_private_method("ytext_to_s", method!(YText::ytext_to_s, 1))
         .expect("cannot define private method: ytext_to_s");
     ytext
         .define_private_method("ytext_unobserve", method!(YText::ytext_unobserve, 1))
@@ -214,25 +254,25 @@ fn init() -> Result<(), Error> {
     yxml_element
         .define_private_method(
             "yxml_element_attributes",
-            method!(YXmlElement::yxml_element_attributes, 0),
+            method!(YXmlElement::yxml_element_attributes, 1),
         )
         .expect("cannot define private method: yxml_element_attributes");
     yxml_element
         .define_private_method(
             "yxml_element_first_child",
-            method!(YXmlElement::yxml_element_first_child, 0),
+            method!(YXmlElement::yxml_element_first_child, 1),
         )
         .expect("cannot define private method: yxml_element_first_child");
     yxml_element
         .define_private_method(
             "yxml_element_get",
-            method!(YXmlElement::yxml_element_get, 1),
+            method!(YXmlElement::yxml_element_get, 2),
         )
         .expect("cannot define private method: yxml_element_get");
     yxml_element
         .define_private_method(
             "yxml_element_get_attribute",
-            method!(YXmlElement::yxml_element_get_attribute, 1),
+            method!(YXmlElement::yxml_element_get_attribute, 2),
         )
         .expect("cannot define private method: yxml_element_get_attribute");
     yxml_element
@@ -250,13 +290,13 @@ fn init() -> Result<(), Error> {
     yxml_element
         .define_private_method(
             "yxml_element_insert_text",
-            method!(YXmlElement::yxml_element_insert_text, 2),
+            method!(YXmlElement::yxml_element_insert_text, 3),
         )
         .expect("cannot define private method: yxml_element_insert_text");
     yxml_element
         .define_private_method(
             "yxml_element_next_sibling",
-            method!(YXmlElement::yxml_element_next_sibling, 0),
+            method!(YXmlElement::yxml_element_next_sibling, 1),
         )
         .expect("cannot define private method: yxml_element_next_sibling");
     yxml_element
@@ -274,31 +314,31 @@ fn init() -> Result<(), Error> {
     yxml_element
         .define_private_method(
             "yxml_element_prev_sibling",
-            method!(YXmlElement::yxml_element_prev_sibling, 0),
+            method!(YXmlElement::yxml_element_prev_sibling, 1),
         )
         .expect("cannot define private method: yxml_element_prev_sibling");
     yxml_element
         .define_private_method(
-            "yxml_element_push_elem_back",
+            "yxml_element_push_element_back",
             method!(YXmlElement::yxml_element_push_element_back, 2),
         )
-        .expect("cannot define private method: yxml_element_push_elem_back");
+        .expect("cannot define private method: yxml_element_push_element_back");
     yxml_element
         .define_private_method(
-            "yxml_element_push_elem_front",
+            "yxml_element_push_element_front",
             method!(YXmlElement::yxml_element_push_element_front, 2),
         )
-        .expect("cannot define private method: yxml_element_push_elem_front");
+        .expect("cannot define private method: yxml_element_push_element_front");
     yxml_element
         .define_private_method(
             "yxml_element_push_text_back",
-            method!(YXmlElement::yxml_element_push_text_back, 1),
+            method!(YXmlElement::yxml_element_push_text_back, 2),
         )
         .expect("cannot define private method: yxml_element_push_text_back");
     yxml_element
         .define_private_method(
             "yxml_element_push_text_front",
-            method!(YXmlElement::yxml_element_push_text_front, 1),
+            method!(YXmlElement::yxml_element_push_text_front, 2),
         )
         .expect("cannot define private method: yxml_element_push_text_front");
     yxml_element
@@ -313,10 +353,16 @@ fn init() -> Result<(), Error> {
             method!(YXmlElement::yxml_element_remove_range, 3),
         )
         .expect("cannot define private method: yxml_element_remove_range");
+    yxml_element
+        .define_private_method(
+            "yxml_element_siblings",
+            method!(YXmlElement::yxml_element_siblings, 1),
+        )
+        .expect("cannot define private method: yxml_element_siblings");
     yxml_element
         .define_private_method(
             "yxml_element_size",
-            method!(YXmlElement::yxml_element_size, 0),
+            method!(YXmlElement::yxml_element_size, 1),
         )
         .expect("cannot define private method: yxml_element_size");
     yxml_element
@@ -328,7 +374,7 @@ fn init() -> Result<(), Error> {
     yxml_element
         .define_private_method(
             "yxml_element_to_s",
-            method!(YXmlElement::yxml_element_to_s, 0),
+            method!(YXmlElement::yxml_element_to_s, 1),
         )
         .expect("cannot define private method: yxml_element_to_s");
     yxml_element
@@ -345,7 +391,7 @@ fn init() -> Result<(), Error> {
     yxml_text
         .define_private_method(
             "yxml_text_attributes",
-            method!(YXmlText::yxml_text_attributes, 0),
+            method!(YXmlText::yxml_text_attributes, 1),
         )
         .expect("cannot define private method: yxml_text_attributes");
     yxml_text
@@ -354,7 +400,7 @@ fn init() -> Result<(), Error> {
     yxml_text
         .define_private_method(
             "yxml_text_get_attribute",
-            method!(YXmlText::yxml_text_get_attribute, 1),
+            method!(YXmlText::yxml_text_get_attribute, 2),
         )
         .expect("cannot define private method: yxml_text_get_attribute");
     yxml_text
@@ -385,12 +431,12 @@ fn init() -> Result<(), Error> {
         )
         .expect("cannot define private method: yxml_text_insert_embed");
     yxml_text
-        .define_private_method("yxml_text_length", method!(YXmlText::yxml_text_length, 0))
+        .define_private_method("yxml_text_length", method!(YXmlText::yxml_text_length, 1))
         .expect("cannot define private method: yxml_text_length");
     yxml_text
         .define_private_method(
             "yxml_text_next_sibling",
-            method!(YXmlText::yxml_text_next_sibling, 0),
+            method!(YXmlText::yxml_text_next_sibling, 1),
         )
         .expect("cannot define private method: yxml_text_next_sibling");
     yxml_text
@@ -399,7 +445,7 @@ fn init() -> Result<(), Error> {
     yxml_text
         .define_private_method(
             "yxml_text_prev_sibling",
-            method!(YXmlText::yxml_text_prev_sibling, 0),
+            method!(YXmlText::yxml_text_prev_sibling, 1),
         )
         .expect("cannot define private method: yxml_text_prev_sibling");
     yxml_text
@@ -412,7 +458,7 @@ fn init() -> Result<(), Error> {
         )
         .expect("cannot define private method: yxml_text_remove_range");
     yxml_text
-        .define_private_method("yxml_text_to_s", method!(YXmlText::yxml_text_to_s, 0))
+        .define_private_method("yxml_text_to_s", method!(YXmlText::yxml_text_to_s, 1))
         .expect("cannot define private method: yxml_text_to_s");
 
     let yawareness = module

data/ext/yrb/src/yarray.rs

@@ -1,37 +1,50 @@
+use crate::ytransaction::YTransaction;
 use crate::yvalue::YValue;
-use crate::YTransaction;
 use lib0::any::Any;
 use magnus::block::Proc;
 use magnus::value::Qnil;
 use magnus::{Error, RArray, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::Change;
-use yrs::Array;
+use yrs::{Array, ArrayRef, Observable};
 
 #[magnus::wrap(class = "Y::Array")]
-pub(crate) struct YArray(pub(crate) RefCell<Array>);
+pub(crate) struct YArray(pub(crate) RefCell<ArrayRef>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YArray {}
 
 impl YArray {
-    pub(crate) fn yarray_each(&self, block: Proc) {
-        self.0.borrow_mut().iter().for_each(|val| {
+    pub(crate) fn yarray_each(&self, transaction: &YTransaction, block: Proc) -> Result<(), Error> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let arr = self.0.borrow();
+        arr.iter(tx).for_each(|val| {
             let yvalue = YValue::from(val);
             let args = (yvalue.into(),);
             let _ = block.call::<(Value,), Qnil>(args);
         });
+
+        Ok(())
     }
-    pub(crate) fn yarray_get(&self, index: u32) -> Value {
-        let v = self.0.borrow().get(index).unwrap();
+    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()
     }
     pub(crate) fn yarray_insert(&self, transaction: &YTransaction, index: u32, value: Value) {
         let yvalue = YValue::from(value);
         let avalue = Any::from(yvalue);
-        self.0
-            .borrow_mut()
-            .insert(&mut *transaction.0.borrow_mut(), index, avalue);
+
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.insert(tx, index, avalue);
     }
     pub(crate) fn yarray_insert_range(
         &self,
@@ -39,18 +52,24 @@ impl YArray {
         index: u32,
         values: RArray,
     ) {
-        let arr: Vec<Any> = values
+        let arr = self.0.borrow_mut();
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let add_values: Vec<Any> = values
             .each()
             .into_iter()
             .map(|value| YValue::from(value.unwrap()).into())
             .collect();
 
-        self.0
-            .borrow_mut()
-            .insert_range(&mut *transaction.0.borrow_mut(), index, arr);
+        arr.insert_range(tx, index, add_values)
     }
-    pub(crate) fn yarray_length(&self) -> u32 {
-        return self.0.borrow().len();
+    pub(crate) fn yarray_length(&self, transaction: &YTransaction) -> u32 {
+        let arr = self.0.borrow();
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        arr.len(tx)
     }
     pub(crate) fn yarray_observe(&self, block: Proc) -> Result<u32, Error> {
         let change_added = Symbol::new("added").to_static();
@@ -111,32 +130,42 @@ impl YArray {
     pub(crate) fn yarray_push_back(&self, transaction: &YTransaction, value: Value) {
         let yvalue = YValue::from(value);
         let avalue = Any::from(yvalue);
-        self.0
-            .borrow_mut()
-            .push_back(&mut *transaction.0.borrow_mut(), avalue)
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().push_back(tx, avalue);
     }
     pub(crate) fn yarray_push_front(&self, transaction: &YTransaction, value: Value) {
         let yvalue = YValue::from(value);
         let avalue = Any::from(yvalue);
-        self.0
-            .borrow_mut()
-            .push_front(&mut *transaction.0.borrow_mut(), avalue)
+
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.push_front(tx, avalue)
     }
     pub(crate) fn yarray_remove(&self, transaction: &YTransaction, index: u32) {
-        self.0
-            .borrow_mut()
-            .remove(&mut transaction.0.borrow_mut(), index)
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.remove(tx, index)
     }
     pub(crate) fn yarray_remove_range(&self, transaction: &YTransaction, index: u32, len: u32) {
-        self.0
-            .borrow_mut()
-            .remove_range(&mut transaction.0.borrow_mut(), index, len)
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.remove_range(tx, index, len)
     }
-    pub(crate) fn yarray_to_a(&self) -> RArray {
-        let arr = self
-            .0
-            .borrow_mut()
-            .iter()
+    pub(crate) fn yarray_to_a(&self, transaction: &YTransaction) -> RArray {
+        let arr = self.0.borrow();
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let arr = arr
+            .iter(tx)
             .map(|v| YValue::from(v).into())
             .collect::<Vec<Value>>();
 
@@ -146,3 +175,9 @@ impl YArray {
         self.0.borrow_mut().unobserve(subscription_id);
     }
 }
+
+impl From<ArrayRef> for YArray {
+    fn from(v: ArrayRef) -> Self {
+        YArray(RefCell::from(v))
+    }
+}

data/ext/yrb/src/ydoc.rs

@@ -1,35 +1,78 @@
+use crate::yarray::YArray;
+use crate::ymap::YMap;
+use crate::ytext::YText;
+use crate::yxml_element::YXmlElement;
+use crate::yxml_fragment::YXmlFragment;
+use crate::yxml_text::YXmlText;
 use crate::YTransaction;
 use magnus::{Error, Integer, Value};
+use std::borrow::Borrow;
 use std::cell::RefCell;
 use yrs::updates::decoder::Decode;
-use yrs::{Doc, OffsetKind, Options, StateVector};
+use yrs::{Doc, OffsetKind, Options, ReadTxn, StateVector, Transact};
 
 #[magnus::wrap(class = "Y::Doc")]
 pub(crate) struct YDoc(pub(crate) RefCell<Doc>);
 
+unsafe impl Send for YDoc {}
+
 impl YDoc {
     pub(crate) fn ydoc_new(client_id: &[Value]) -> Self {
         let mut options = Options::default();
-
         if client_id.len() == 1 {
             let value = client_id.first().unwrap();
             options.client_id = Integer::from_value(*value).unwrap().to_u64().unwrap();
         }
-
         options.offset_kind = OffsetKind::Utf32;
 
         let doc = Doc::with_options(options);
         Self(RefCell::new(doc))
     }
 
-    pub(crate) fn ydoc_transact(&self) -> YTransaction {
-        let transaction = self.0.borrow().transact();
+    pub(crate) fn ydoc_encode_diff_v1(
+        &self,
+        transaction: &YTransaction,
+        state_vector: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        YTransaction(RefCell::new(transaction))
-    }
-    pub(crate) fn ydoc_encode_diff_v1(&self, state_vector: Vec<u8>) -> Result<Vec<u8>, Error> {
-        StateVector::decode_v1(&*state_vector)
-            .map(|sv| self.0.borrow().encode_state_as_update_v1(&sv))
+        StateVector::decode_v1(state_vector.borrow())
+            .map(|sv| tx.encode_diff_v1(&sv))
             .map_err(|_e| Error::runtime_error("cannot encode diff"))
     }
+
+    pub(crate) fn ydoc_get_or_insert_array(&self, name: String) -> YArray {
+        self.0.borrow().get_or_insert_array(name.as_str()).into()
+    }
+
+    pub(crate) fn ydoc_get_or_insert_map(&self, name: String) -> YMap {
+        self.0.borrow().get_or_insert_map(name.as_str()).into()
+    }
+
+    pub(crate) fn ydoc_get_or_insert_text(&self, name: String) -> YText {
+        self.0.borrow().get_or_insert_text(name.as_str()).into()
+    }
+
+    pub(crate) fn ydoc_get_or_insert_xml_element(&self, name: String) -> YXmlElement {
+        let xml_element_ref = self.0.borrow_mut().get_or_insert_xml_element(name.as_str());
+        YXmlElement::from(xml_element_ref) // ::into() maps to YXmlFragment instead of YXmlElement :-(
+    }
+
+    pub(crate) fn ydoc_get_or_insert_xml_fragment(&self, name: String) -> YXmlFragment {
+        self.0
+            .borrow()
+            .get_or_insert_xml_fragment(name.as_str())
+            .into()
+    }
+
+    pub(crate) fn ydoc_get_or_insert_xml_text(&self, name: String) -> YXmlText {
+        self.0.borrow().get_or_insert_xml_text(name.as_str()).into()
+    }
+
+    pub(crate) fn ydoc_transact<'doc>(&self) -> YTransaction {
+        let doc = self.0.borrow();
+        let transaction = doc.transact_mut();
+        YTransaction::from(transaction)
+    }
 }