y-rb 0.3.2-x86_64-linux → 0.4.1-x86_64-linux

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 magnus::{exception, 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();
+
+        StateVector::decode_v1(state_vector.borrow())
+            .map(|sv| tx.encode_diff_v1(&sv))
+            .map_err(|_e| Error::new(exception::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()
+    }
 
-        YTransaction(RefCell::new(transaction))
+    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_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))
-            .map_err(|_e| Error::runtime_error("cannot encode diff"))
+
+    pub(crate) fn ydoc_transact<'doc>(&self) -> YTransaction {
+        let doc = self.0.borrow();
+        let transaction = doc.transact_mut();
+        YTransaction::from(transaction)
     }
 }

data/ext/yrb/src/ymap.rs

@@ -3,38 +3,50 @@ use crate::yvalue::YValue;
 use crate::YTransaction;
 use lib0::any::Any;
 use magnus::block::Proc;
-use magnus::{Error, RArray, RHash, Symbol, Value};
+use magnus::{exception, Error, RArray, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::{EntryChange, Value as YrsValue};
-use yrs::Map;
+use yrs::{Map, MapRef, Observable};
 
 #[magnus::wrap(class = "Y::Map")]
-pub(crate) struct YMap(pub(crate) RefCell<Map>);
+pub(crate) struct YMap(pub(crate) RefCell<MapRef>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YMap {}
 
 impl YMap {
     pub(crate) fn ymap_clear(&self, transaction: &YTransaction) {
-        self.0.borrow_mut().clear(&mut *transaction.0.borrow_mut());
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().clear(tx)
     }
-    pub(crate) fn ymap_contains(&self, key: Value) -> bool {
+    pub(crate) fn ymap_contains(&self, transaction: &YTransaction, key: Value) -> bool {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
         match indifferent_hash_key(key) {
             None => false,
-            Some(k) => self.0.borrow().contains(&*k),
+            Some(k) => self.0.borrow().contains(tx, k.as_str()),
         }
     }
-    pub(crate) fn ymap_each(&self, proc: Proc) {
-        self.0.borrow().iter().for_each(|(key, val)| {
+    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();
             proc.call::<(String, Value), Value>((k, v))
                 .expect("cannot iterate map");
-        });
+        })
     }
-    pub(crate) fn ymap_get(&self, key: Value) -> Option<Value> {
+    pub(crate) fn ymap_get(&self, transaction: &YTransaction, key: Value) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
         indifferent_hash_key(key)
-            .map(|k| self.0.borrow().get(&*k))
+            .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())
     }
@@ -44,15 +56,17 @@ impl YMap {
         key: Value,
         value: Value,
     ) -> Result<(), Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         match indifferent_hash_key(key) {
-            None => Err(Error::runtime_error(
-                "invalid key type, make sure it is either a Symbol or a String",
+            None => Err(Error::new(
+                exception::runtime_error(),
+                "invalid key type, make sure it is either of type Symbol or String",
             )),
             Some(k) => {
                 let v = Any::from(YValue::from(value));
-                self.0
-                    .borrow_mut()
-                    .insert(&mut *transaction.0.borrow_mut(), k, v);
+                self.0.borrow_mut().insert(tx, k, v);
 
                 Ok(())
             }
@@ -62,7 +76,6 @@ impl YMap {
         let change_inserted = Symbol::new("inserted").as_static();
         let change_updated = Symbol::new("updated").as_static();
         let change_removed = Symbol::new("removed").as_static();
-
         self.0
             .borrow_mut()
             .observe(move |transaction, map_event| {
@@ -125,23 +138,28 @@ impl YMap {
             .into()
     }
     pub(crate) fn ymap_remove(&self, transaction: &YTransaction, key: Value) -> Option<Value> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         indifferent_hash_key(key)
-            .map(|k| {
-                self.0
-                    .borrow()
-                    .remove(&mut *transaction.0.borrow_mut(), &*k)
-            })
+            .map(|k| self.0.borrow().remove(tx, k.as_str()))
             .map(|v| v.unwrap_or(YrsValue::Any(Any::Undefined)))
             .map(|v| *YValue::from(v).0.borrow())
     }
-    pub(crate) fn ymap_size(&self) -> u32 {
-        self.0.borrow().len()
+    pub(crate) fn ymap_size(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
     }
-    pub(crate) fn ymap_to_h(&self) -> RHash {
+    pub(crate) fn ymap_to_h(&self, transaction: &YTransaction) -> RHash {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
         RHash::from_iter(
             self.0
                 .borrow()
-                .iter()
+                .iter(tx)
                 .map(move |(k, v)| (k.to_string(), *YValue::from(v).0.borrow())),
         )
     }
@@ -149,3 +167,9 @@ impl YMap {
         self.0.borrow_mut().unobserve(subscription_id);
     }
 }
+
+impl From<MapRef> for YMap {
+    fn from(v: MapRef) -> Self {
+        YMap(RefCell::from(v))
+    }
+}

data/ext/yrb/src/ytext.rs

@@ -7,10 +7,10 @@ use magnus::value::Qnil;
 use magnus::{Error, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::Delta;
-use yrs::Text;
+use yrs::{GetString, Observable, Text, TextRef};
 
 #[magnus::wrap(class = "Y::Text")]
-pub(crate) struct YText(pub(crate) RefCell<Text>);
+pub(crate) struct YText(pub(crate) RefCell<TextRef>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YText {}
@@ -22,40 +22,33 @@ impl YText {
         index: u32,
         length: u32,
         attrs: RHash,
-    ) -> Result<(), Error> {
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         let a = YAttrs::from(attrs);
-        self.0
-            .borrow_mut()
-            .format(&mut *transaction.0.borrow_mut(), index, length, a.0);
 
-        Ok(())
+        self.0.borrow_mut().format(tx, index, length, a.0)
     }
-    pub(crate) fn ytext_insert(
-        &self,
-        transaction: &YTransaction,
-        index: u32,
-        chunk: String,
-    ) -> Result<(), Error> {
-        self.0
-            .borrow_mut()
-            .insert(&mut *transaction.0.borrow_mut(), index, &*chunk);
+    pub(crate) fn ytext_insert(&self, transaction: &YTransaction, index: u32, chunk: String) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        Ok(())
+        self.0.borrow_mut().insert(tx, index, chunk.as_str())
     }
     pub(crate) fn ytext_insert_embed(
         &self,
         transaction: &YTransaction,
         index: u32,
         content: Value,
-    ) -> Result<(), Error> {
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         let yvalue = YValue::from(content);
         let avalue = Any::from(yvalue);
 
-        self.0
-            .borrow_mut()
-            .insert_embed(&mut *transaction.0.borrow_mut(), index, avalue);
-
-        Ok(())
+        self.0.borrow_mut().insert_embed(tx, index, avalue)
     }
     pub(crate) fn ytext_insert_embed_with_attributes(
         &self,
@@ -63,20 +56,18 @@ impl YText {
         index: u32,
         embed: Value,
         attrs: RHash,
-    ) -> Result<(), Error> {
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
         let yvalue = YValue::from(embed);
         let avalue = Any::from(yvalue);
 
         let a = YAttrs::from(attrs);
 
-        self.0.borrow_mut().insert_embed_with_attributes(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            avalue,
-            a.0,
-        );
-
-        Ok(())
+        self.0
+            .borrow_mut()
+            .insert_embed_with_attributes(tx, index, avalue, a.0)
     }
     pub(crate) fn ytext_insert_with_attributes(
         &self,
@@ -84,20 +75,21 @@ impl YText {
         index: u32,
         chunk: String,
         attrs: RHash,
-    ) -> Result<(), Error> {
-        let a = YAttrs::from(attrs);
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        self.0.borrow_mut().insert_with_attributes(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            &*chunk,
-            a.0,
-        );
+        let a = YAttrs::from(attrs);
 
-        Ok(())
+        self.0
+            .borrow_mut()
+            .insert_with_attributes(tx, index, chunk.as_str(), a.0)
     }
-    pub(crate) fn ytext_length(&self) -> u32 {
-        self.0.borrow().len()
+    pub(crate) fn ytext_length(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
     }
     pub(crate) fn ytext_observe(&self, block: Proc) -> Result<u32, Error> {
         let delta_insert = Symbol::new("insert").to_static();
@@ -106,7 +98,6 @@ impl YText {
         let attributes = Symbol::new("attributes").to_static();
 
         // let mut error: Option<Error> = None;
-
         let subscription_id = self
             .0
             .borrow_mut()
@@ -179,26 +170,30 @@ impl YText {
         Ok(subscription_id)
     }
     pub(crate) fn ytext_push(&self, transaction: &YTransaction, chunk: String) {
-        self.0
-            .borrow_mut()
-            .push(&mut *transaction.0.borrow_mut(), &*chunk);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().push(tx, chunk.as_str())
     }
-    pub(crate) fn ytext_remove_range(
-        &self,
-        transaction: &YTransaction,
-        start: u32,
-        length: u32,
-    ) -> Result<(), Error> {
-        self.0
-            .borrow_mut()
-            .remove_range(&mut *transaction.0.borrow_mut(), start, length);
+    pub(crate) fn ytext_remove_range(&self, transaction: &YTransaction, start: u32, length: u32) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
 
-        Ok(())
+        self.0.borrow_mut().remove_range(tx, start, length)
     }
-    pub(crate) fn ytext_to_s(&self) -> String {
-        return self.0.borrow().to_string();
+    pub(crate) fn ytext_to_s(&self, transaction: &YTransaction) -> String {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow().get_string(tx)
     }
     pub(crate) fn ytext_unobserve(&self, subscription_id: u32) {
-        return self.0.borrow_mut().unobserve(subscription_id);
+        self.0.borrow_mut().unobserve(subscription_id);
+    }
+}
+
+impl From<TextRef> for YText {
+    fn from(v: TextRef) -> Self {
+        YText(RefCell::from(v))
     }
 }

data/ext/yrb/src/ytransaction.rs

@@ -2,54 +2,107 @@ 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 magnus::Error;
-use std::cell::RefCell;
+use magnus::{exception, Error};
+use std::cell::{RefCell, RefMut};
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::Encode;
-use yrs::{Transaction, Update};
+use yrs::{ReadTxn, TransactionMut, Update};
 
 #[magnus::wrap(class = "Y::Transaction")]
-pub(crate) struct YTransaction(pub(crate) RefCell<Transaction>);
+pub(crate) struct YTransaction(pub(crate) RefCell<Option<TransactionMut<'static>>>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YTransaction {}
 
+impl YTransaction {}
+
+impl<'doc> From<TransactionMut<'doc>> for YTransaction {
+    fn from(txn: TransactionMut<'doc>) -> Self {
+        let txn: TransactionMut<'static> = unsafe { std::mem::transmute(txn) };
+        YTransaction(RefCell::from(Some(txn)))
+    }
+}
+
+// API which is eventually publicly exposed
 impl YTransaction {
     pub(crate) fn ytransaction_apply_update(&self, update: Vec<u8>) -> Result<(), Error> {
-        return Update::decode_v1(update.as_slice())
-            .map(|u| self.0.borrow_mut().apply_update(u))
-            .map_err(|_e| Error::runtime_error("cannot apply update"));
+        Update::decode_v1(update.as_slice())
+            .map_err(|error| {
+                Error::new(
+                    exception::runtime_error(),
+                    format!("cannot decode update: {:?}", error),
+                )
+            })
+            .map(|u| self.transaction().as_mut().unwrap().apply_update(u))
     }
+
     pub(crate) fn ytransaction_commit(&self) {
-        self.0.borrow_mut().commit();
+        self.transaction().as_mut().unwrap().commit();
+    }
+
+    pub(crate) fn ytransaction_get_array(&self, name: String) -> Option<YArray> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_array(name.as_str())
+            .map(YArray::from)
     }
-    pub(crate) fn ytransaction_get_array(&self, name: String) -> YArray {
-        let a = self.0.borrow_mut().get_array(&*name);
 
-        YArray(RefCell::from(a))
+    pub(crate) fn ytransaction_get_map(&self, name: String) -> Option<YMap> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_map(name.as_str())
+            .map(YMap::from)
     }
-    pub(crate) fn ytransaction_get_map(&self, name: String) -> YMap {
-        let m = self.0.borrow_mut().get_map(&*name);
 
-        YMap(RefCell::from(m))
+    pub(crate) fn ytransaction_get_text(&self, name: String) -> Option<YText> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_text(name.as_str())
+            .map(YText::from)
     }
-    pub(crate) fn ytransaction_get_text(&self, name: String) -> YText {
-        let t = self.0.borrow_mut().get_text(&*name);
 
-        YText(RefCell::new(t))
+    pub(crate) fn ytransaction_get_xml_element(&self, name: String) -> Option<YXmlElement> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_xml_element(name.as_str())
+            .map(YXmlElement::from)
     }
-    pub(crate) fn ytransaction_get_xml_element(&self, name: String) -> YXmlElement {
-        let el = self.0.borrow_mut().get_xml_element(&*name);
 
-        YXmlElement(RefCell::new(el))
+    pub(crate) fn ytransaction_get_xml_fragment(&self, name: String) -> Option<YXmlFragment> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_xml_fragment(name.as_str())
+            .map(YXmlFragment::from)
     }
-    pub(crate) fn ytransaction_get_xml_text(&self, name: String) -> YXmlText {
-        let t = self.0.borrow_mut().get_xml_text(&*name);
 
-        YXmlText(RefCell::new(t))
+    pub(crate) fn ytransaction_get_xml_text(&self, name: String) -> Option<YXmlText> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_xml_text(name.as_str())
+            .map(YXmlText::from)
     }
+
     pub(crate) fn ytransaction_state_vector(&self) -> Vec<u8> {
-        return self.0.borrow_mut().state_vector().encode_v1();
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .state_vector()
+            .encode_v1()
+    }
+
+    pub(crate) fn ytransaction_free(&self) {
+        self.0.replace(None);
+    }
+
+    pub(crate) fn transaction(&self) -> RefMut<'_, Option<TransactionMut<'static>>> {
+        self.0.borrow_mut()
     }
 }

data/ext/yrb/src/yvalue.rs

@@ -6,7 +6,10 @@ use magnus::{class, Float, Integer, RArray, RHash, RString, Symbol, Value, QNIL}
 use std::cell::RefCell;
 use std::collections::HashMap;
 use yrs::types::Value as YrsValue;
-use yrs::{Text as YrsText, XmlElement as YrsXmlElement, XmlText as YrsXmlText};
+use yrs::{
+    Array, Map, TextRef as YrsText, Transact, XmlElementRef as YrsXmlElement,
+    XmlTextRef as YrsXmlText,
+};
 
 pub(crate) struct YValue(pub(crate) RefCell<Value>);
 
@@ -141,12 +144,28 @@ impl From<YrsValue> for YValue {
             YrsValue::YText(text) => YValue::from(text),
             YrsValue::YXmlElement(el) => YValue::from(el),
             YrsValue::YXmlText(text) => YValue::from(text),
-            // YrsValue::YArray(val) => YValue::from(RArray::from_vec(val.iter().map(|item| {
-            //     let yvalue = YValue::from(item);
-            //     *yvalue.0
-            // }))),
-            // YrsValue::YMap(val) => YValue::from(RHash::from_iter(val.iter())),
-            v => panic!("cannot map complex yrs values to yvalue: {}", v.to_string()),
+            YrsValue::YArray(val) => {
+                let tx = val.transact();
+                let arr = RArray::from_vec(
+                    val.iter(&tx)
+                        .map(|item| {
+                            let yvalue = YValue::from(item);
+                            yvalue.0.into_inner()
+                        })
+                        .collect(),
+                );
+                YValue::from(arr)
+            }
+            YrsValue::YMap(val) => {
+                let tx = val.transact();
+                let iter = val.iter(&tx).map(|(key, val)| {
+                    let val = YValue::from(val);
+                    let val = val.0.into_inner();
+                    (key, val)
+                });
+                YValue::from(RHash::from_iter(iter))
+            }
+            v => panic!("cannot map complex yrs values to yvalue: {:?}", v),
         }
     }
 }