y-rb 0.6.0-x86_64-linux-gnu

data/ext/yrb/src/ymap.rs

@@ -0,0 +1,175 @@
+use crate::utils::{convert_yvalue_to_ruby_value, indifferent_hash_key};
+use crate::yvalue::YValue;
+use crate::YTransaction;
+use magnus::block::Proc;
+use magnus::{exception, Error, RArray, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::{EntryChange, Value as YrsValue};
+use yrs::{Any, Map, MapRef, Observable};
+
+#[magnus::wrap(class = "Y::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) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().clear(tx)
+    }
+    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_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 = *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();
+
+        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| *convert_yvalue_to_ruby_value(v, tx).0.borrow())
+    }
+    pub(crate) fn ymap_insert(
+        &self,
+        transaction: &YTransaction,
+        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::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(tx, k, v);
+
+                Ok(())
+            }
+        }
+    }
+    pub(crate) fn ymap_observe(&self, block: Proc) -> u32 {
+        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| {
+                let delta = map_event.keys(transaction);
+                let changes = RArray::with_capacity(delta.len());
+
+                for (key, change) in delta {
+                    match change {
+                        EntryChange::Inserted(v) => {
+                            let h = RHash::new();
+                            h.aset(Symbol::new(key), *YValue::from(v.clone()).0.borrow())
+                                .expect("cannot add change::inserted");
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_inserted, h)
+                                .expect("cannot add change::inserted");
+
+                            changes.push(payload).expect("cannot push changes::payload");
+                        }
+                        EntryChange::Updated(old, new) => {
+                            let values = RArray::with_capacity(2);
+                            values
+                                .push(*YValue::from(old.clone()).0.borrow())
+                                .expect("cannot push change::updated");
+                            values
+                                .push(*YValue::from(new.clone()).0.borrow())
+                                .expect("cannot push change::updated");
+
+                            let h = RHash::new();
+                            h.aset(Symbol::new(key), values)
+                                .expect("cannot push change::updated");
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_updated, h)
+                                .expect("cannot push change::updated");
+
+                            changes.push(payload).expect("cannot push changes::payload");
+                        }
+                        EntryChange::Removed(v) => {
+                            let h = RHash::new();
+                            h.aset(Symbol::new(key), *YValue::from(v.clone()).0.borrow())
+                                .expect("cannot push change::removed");
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_removed, h)
+                                .expect("cannot push change::removed");
+
+                            changes.push(payload).expect("cannot push changes::payload");
+                        }
+                    }
+                }
+
+                block
+                    .call::<(RArray,), Value>((changes,))
+                    .expect("cannot call block");
+            })
+            .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(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, 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, transaction: &YTransaction) -> RHash {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        RHash::from_iter(
+            self.0
+                .borrow()
+                .iter(tx)
+                .map(move |(k, v)| (k.to_string(), *YValue::from(v).0.borrow())),
+        )
+    }
+    pub(crate) fn ymap_unobserve(&self, subscription_id: u32) {
+        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

@@ -0,0 +1,235 @@
+use crate::yattrs::YAttrs;
+use crate::ydiff::YDiff;
+use crate::yvalue::YValue;
+use crate::YTransaction;
+use magnus::block::Proc;
+use magnus::value::Qnil;
+use magnus::RArray;
+pub(crate) use magnus::{Error, IntoValue, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::text::YChange;
+use yrs::types::Delta;
+use yrs::{Any, GetString, Observable, Text, TextRef};
+
+#[magnus::wrap(class = "Y::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 {}
+
+impl YText {
+    pub(crate) fn ytext_diff(&self, transaction: &YTransaction) -> RArray {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        RArray::from_iter(
+            self.0
+                .borrow()
+                .diff(tx, YChange::identity)
+                .iter()
+                .map(move |diff| {
+                    let yvalue = YValue::from(diff.insert.clone());
+                    let insert = yvalue.0.into_inner();
+                    let attributes = diff.attributes.as_ref().map_or_else(
+                        || None,
+                        |boxed_attrs| {
+                            let attributes = RHash::new();
+                            for (key, value) in boxed_attrs.iter() {
+                                let key = key.to_string();
+                                let value = YValue::from(value.clone()).0.into_inner();
+                                attributes.aset(key, value).expect("cannot add value");
+                            }
+                            Some(attributes)
+                        },
+                    );
+                    YDiff {
+                        ydiff_insert: insert,
+                        ydiff_attrs: attributes,
+                    }
+                    .into_value()
+                }),
+        )
+    }
+    pub(crate) fn ytext_format(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+        attrs: RHash,
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let a = YAttrs::from(attrs);
+
+        self.0
+            .borrow_mut()
+            .format(tx, index, length, a.0.into_inner())
+    }
+    pub(crate) fn ytext_insert(&self, transaction: &YTransaction, index: u32, chunk: String) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().insert(tx, index, chunk.as_str())
+    }
+    pub(crate) fn ytext_insert_embed(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: Value,
+    ) {
+        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(tx, index, avalue);
+    }
+    pub(crate) fn ytext_insert_embed_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        embed: Value,
+        attrs: RHash,
+    ) {
+        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(tx, index, avalue, a.0.into_inner());
+    }
+    pub(crate) fn ytext_insert_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        chunk: String,
+        attrs: RHash,
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let a = YAttrs::from(attrs);
+
+        self.0
+            .borrow_mut()
+            .insert_with_attributes(tx, index, chunk.as_str(), a.0.into_inner())
+    }
+    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();
+        let delta_retain = Symbol::new("retain").to_static();
+        let delta_delete = Symbol::new("delete").to_static();
+        let attributes = Symbol::new("attributes").to_static();
+
+        // let mut error: Option<Error> = None;
+        let subscription_id = self
+            .0
+            .borrow_mut()
+            .observe(move |transaction, text_event| {
+                let delta = text_event.delta(transaction);
+                let (_, errors): (Vec<_>, Vec<_>) = delta
+                    .iter()
+                    .map(|change| match change {
+                        Delta::Inserted(value, attrs) => {
+                            let yvalue = YValue::from(value.clone());
+                            let payload = RHash::new();
+                            payload
+                                .aset(delta_insert, yvalue.0.into_inner())
+                                .map(|()| match attrs {
+                                    Some(a) => a
+                                        .clone()
+                                        .into_iter()
+                                        .map(|(key, val)| {
+                                            let yvalue = YValue::from(val);
+                                            (key.to_string(), yvalue.0.into_inner())
+                                        })
+                                        .collect::<RHash>()
+                                        .into(),
+                                    None => None,
+                                })
+                                .map(|attrs_hash| attrs_hash.map(|v| payload.aset(attributes, v)))
+                                .map(|_| block.call::<(RHash,), Qnil>((payload,)))
+                        }
+                        Delta::Retain(index, attrs) => {
+                            let payload = RHash::new();
+
+                            let yvalue = YValue::from(*index);
+
+                            payload
+                                .aset(delta_retain, yvalue.0.into_inner())
+                                .map(|()| match attrs {
+                                    Some(a) => a
+                                        .clone()
+                                        .into_iter()
+                                        .map(|(key, val)| {
+                                            let yvalue = YValue::from(val);
+                                            (key.to_string(), yvalue.0.into_inner())
+                                        })
+                                        .collect::<RHash>()
+                                        .into(),
+                                    None => None,
+                                })
+                                .map(|attrs_hash| attrs_hash.map(|v| payload.aset(attributes, v)))
+                                .map(|_| block.call::<(RHash,), Qnil>((payload,)))
+                        }
+                        Delta::Deleted(index) => {
+                            let payload = RHash::new();
+
+                            let yvalue = YValue::from(*index);
+
+                            payload
+                                .aset(delta_delete, yvalue.0.into_inner())
+                                .map(|()| block.call::<(RHash,), Qnil>((payload,)))
+                        }
+                    })
+                    .partition(Result::is_ok);
+
+                if !errors.is_empty() {
+                    // todo: make sure we respect errors and let the method fail by
+                    //  by returning a Result containing an Error
+                }
+            })
+            .into();
+
+        Ok(subscription_id)
+    }
+    pub(crate) fn ytext_push(&self, transaction: &YTransaction, chunk: String) {
+        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) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_range(tx, start, length)
+    }
+    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) {
+        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

@@ -0,0 +1,127 @@
+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::{exception, Error};
+use std::cell::{RefCell, RefMut};
+use yrs::updates::decoder::Decode;
+use yrs::updates::encoder::Encode;
+use yrs::{ReadTxn, TransactionMut, Update};
+
+#[magnus::wrap(class = "Y::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> {
+        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_apply_update_v2(&self, update: Vec<u8>) -> Result<(), Error> {
+        Update::decode_v2(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.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_map(&self, name: String) -> Option<YMap> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .get_map(name.as_str())
+            .map(YMap::from)
+    }
+
+    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_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_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) -> 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> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .state_vector()
+            .encode_v1()
+    }
+
+    pub(crate) fn ytransaction_state_vector_v2(&self) -> Vec<u8> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .state_vector()
+            .encode_v2()
+    }
+
+    pub(crate) fn ytransaction_free(&self) {
+        self.0.replace(None);
+    }
+
+    pub(crate) fn transaction(&self) -> RefMut<'_, Option<TransactionMut<'static>>> {
+        self.0.borrow_mut()
+    }
+}