y-rb 0.3.2-x64-mingw-ucrt

data/ext/yrb/src/ytext.rs

@@ -0,0 +1,204 @@
+use crate::yattrs::YAttrs;
+use crate::yvalue::YValue;
+use crate::YTransaction;
+use lib0::any::Any;
+use magnus::block::Proc;
+use magnus::value::Qnil;
+use magnus::{Error, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::Delta;
+use yrs::Text;
+
+#[magnus::wrap(class = "Y::Text")]
+pub(crate) struct YText(pub(crate) RefCell<Text>);
+
+/// 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_format(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+        attrs: RHash,
+    ) -> Result<(), Error> {
+        let a = YAttrs::from(attrs);
+        self.0
+            .borrow_mut()
+            .format(&mut *transaction.0.borrow_mut(), index, length, a.0);
+
+        Ok(())
+    }
+    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);
+
+        Ok(())
+    }
+    pub(crate) fn ytext_insert_embed(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: Value,
+    ) -> Result<(), Error> {
+        let yvalue = YValue::from(content);
+        let avalue = Any::from(yvalue);
+
+        self.0
+            .borrow_mut()
+            .insert_embed(&mut *transaction.0.borrow_mut(), index, avalue);
+
+        Ok(())
+    }
+    pub(crate) fn ytext_insert_embed_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        embed: Value,
+        attrs: RHash,
+    ) -> Result<(), Error> {
+        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(())
+    }
+    pub(crate) fn ytext_insert_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        chunk: String,
+        attrs: RHash,
+    ) -> Result<(), Error> {
+        let a = YAttrs::from(attrs);
+
+        self.0.borrow_mut().insert_with_attributes(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            &*chunk,
+            a.0,
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_length(&self) -> u32 {
+        self.0.borrow().len()
+    }
+    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) {
+        self.0
+            .borrow_mut()
+            .push(&mut *transaction.0.borrow_mut(), &*chunk);
+    }
+    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);
+
+        Ok(())
+    }
+    pub(crate) fn ytext_to_s(&self) -> String {
+        return self.0.borrow().to_string();
+    }
+    pub(crate) fn ytext_unobserve(&self, subscription_id: u32) {
+        return self.0.borrow_mut().unobserve(subscription_id);
+    }
+}

data/ext/yrb/src/ytransaction.rs

@@ -0,0 +1,55 @@
+use crate::yarray::YArray;
+use crate::ymap::YMap;
+use crate::ytext::YText;
+use crate::yxml_element::YXmlElement;
+use crate::yxml_text::YXmlText;
+use magnus::Error;
+use std::cell::RefCell;
+use yrs::updates::decoder::Decode;
+use yrs::updates::encoder::Encode;
+use yrs::{Transaction, Update};
+
+#[magnus::wrap(class = "Y::Transaction")]
+pub(crate) struct YTransaction(pub(crate) RefCell<Transaction>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YTransaction {}
+
+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"));
+    }
+    pub(crate) fn ytransaction_commit(&self) {
+        self.0.borrow_mut().commit();
+    }
+    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) -> YMap {
+        let m = self.0.borrow_mut().get_map(&*name);
+
+        YMap(RefCell::from(m))
+    }
+    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) -> YXmlElement {
+        let el = self.0.borrow_mut().get_xml_element(&*name);
+
+        YXmlElement(RefCell::new(el))
+    }
+    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_state_vector(&self) -> Vec<u8> {
+        return self.0.borrow_mut().state_vector().encode_v1();
+    }
+}

data/ext/yrb/src/yvalue.rs

@@ -0,0 +1,231 @@
+use crate::{YText, YXmlElement, YXmlText};
+use lib0::any::Any;
+use magnus::r_hash::ForEach::Continue;
+use magnus::value::Qnil;
+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};
+
+pub(crate) struct YValue(pub(crate) RefCell<Value>);
+
+impl From<Value> for YValue {
+    fn from(value: Value) -> Self {
+        YValue(RefCell::from(value))
+    }
+}
+
+impl From<Qnil> for YValue {
+    fn from(value: Qnil) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<bool> for YValue {
+    fn from(value: bool) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<f64> for YValue {
+    fn from(value: f64) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<i64> for YValue {
+    fn from(value: i64) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<u32> for YValue {
+    fn from(value: u32) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<String> for YValue {
+    fn from(value: String) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<RArray> for YValue {
+    fn from(value: RArray) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<RHash> for YValue {
+    fn from(value: RHash) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<YrsText> for YValue {
+    fn from(value: YrsText) -> Self {
+        YValue(RefCell::from(Value::from(YText(RefCell::from(value)))))
+    }
+}
+
+impl From<YrsXmlElement> for YValue {
+    fn from(value: YrsXmlElement) -> Self {
+        YValue(RefCell::from(Value::from(YXmlElement(RefCell::from(
+            value,
+        )))))
+    }
+}
+
+impl From<YrsXmlText> for YValue {
+    fn from(value: YrsXmlText) -> Self {
+        YValue(RefCell::from(Value::from(YXmlText(RefCell::from(value)))))
+    }
+}
+
+impl From<YText> for YValue {
+    fn from(value: YText) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<YXmlElement> for YValue {
+    fn from(value: YXmlElement) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<YXmlText> for YValue {
+    fn from(value: YXmlText) -> Self {
+        YValue(RefCell::from(Value::from(value)))
+    }
+}
+
+impl From<Any> for YValue {
+    fn from(value: Any) -> Self {
+        match value {
+            Any::Null => YValue::from(QNIL),
+            Any::Undefined => YValue::from(QNIL),
+            Any::Bool(v) => YValue::from(v),
+            Any::Number(v) => YValue::from(v),
+            Any::BigInt(v) => YValue::from(v),
+            Any::String(v) => YValue::from(v.into_string()),
+            Any::Buffer(v) => YValue::from(Value::from(v.into_vec())),
+            Any::Array(v) => {
+                let arr = v
+                    .iter()
+                    .map(|i| YValue::from(i.clone()))
+                    .map(|value| *value.0.borrow())
+                    .collect::<Vec<Value>>();
+                YValue::from(RArray::from_vec(arr))
+            }
+            Any::Map(v) => {
+                let map = v
+                    .iter()
+                    .map(|(key, val)| {
+                        let v = val.clone();
+                        (key.to_string(), YValue::from(v).into())
+                    })
+                    .collect::<HashMap<String, Value>>();
+                YValue::from(RHash::from_iter(map))
+            }
+        }
+    }
+}
+
+impl From<YrsValue> for YValue {
+    fn from(value: YrsValue) -> Self {
+        match value {
+            YrsValue::Any(val) => YValue::from(val),
+            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()),
+        }
+    }
+}
+
+impl From<YValue> for Any {
+    fn from(val: YValue) -> Self {
+        let value = val.0.into_inner();
+        if value.is_nil() {
+            Any::Null
+        } else if value.is_kind_of(class::float()) {
+            let f = Float::from_value(value).unwrap();
+            Any::Number(f.to_f64())
+        } else if value.is_kind_of(class::integer()) {
+            let i = Integer::from_value(value).unwrap();
+            Any::BigInt(i.to_i64().unwrap())
+        } else if value.is_kind_of(class::symbol()) {
+            let s = Symbol::from_value(value).unwrap();
+            Any::String(Box::from(s.name().unwrap()))
+        } else if value.is_kind_of(class::true_class()) {
+            Any::Bool(true)
+        } else if value.is_kind_of(class::false_class()) {
+            Any::Bool(false)
+        } else if value.is_kind_of(class::string()) {
+            let s = RString::from_value(value).unwrap();
+            unsafe { Any::String(Box::from(s.as_str().unwrap().to_string())) }
+        } else if value.is_kind_of(class::array()) {
+            let arr = RArray::from_value(value).unwrap();
+            let items = arr
+                .each()
+                .map(|item| {
+                    let yvalue = YValue::from(item.unwrap());
+                    Any::from(yvalue)
+                })
+                .collect::<Vec<Any>>();
+            Any::Array(Box::from(items))
+        } else if value.is_kind_of(class::hash()) {
+            let map = RHash::from_value(value).unwrap();
+            let mut m: HashMap<String, Any> = HashMap::new();
+
+            // we need to map symbol keys to strings, because we can't store
+            // symbols in any of the yrs data structures
+            map.foreach(|key: Value, val: Value| {
+                let k = if let Some(converted_key) = Symbol::from_value(key) {
+                    converted_key.to_string()
+                } else {
+                    let converted_key = RString::from_value(key).unwrap();
+                    let result = converted_key.to_string();
+                    result.unwrap()
+                };
+                m.insert(k, Any::from(YValue::from(val)));
+                Ok(Continue)
+            })
+            .expect("cannot map key/value pair");
+
+            Any::Map(Box::from(m))
+        } else {
+            Any::Undefined
+        }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl Into<Value> for YValue {
+    fn into(self) -> Value {
+        self.0.into_inner()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::yvalue::YValue;
+    use lib0::any::Any;
+
+    #[test]
+    fn convert_any_to_yvalue() {
+        let _cleanup = unsafe { magnus::embed::init() };
+        let value = Any::Null;
+        let yvalue: YValue = value.into();
+
+        assert!(yvalue.0.into_inner().is_nil());
+    }
+}

data/ext/yrb/src/yxml_element.rs

@@ -0,0 +1,212 @@
+use crate::yvalue::YValue;
+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};
+
+#[magnus::wrap(class = "Y::XMLElement")]
+pub(crate) struct YXmlElement(pub(crate) RefCell<XmlElement>);
+
+/// 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_first_child(&self) -> Option<Value> {
+        self.yxml_element_get(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_attribute(&self, name: String) -> Option<String> {
+        self.0.borrow().get_attribute(&*name)
+    }
+    pub(crate) fn yxml_element_insert_attribute(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+        value: String,
+    ) {
+        self.0
+            .borrow_mut()
+            .insert_attribute(&mut *transaction.0.borrow_mut(), name, value);
+    }
+    pub(crate) fn yxml_element_insert_element(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        name: String,
+    ) -> YXmlElement {
+        let element =
+            self.0
+                .borrow_mut()
+                .insert_elem(&mut *transaction.0.borrow_mut(), index, name);
+
+        YXmlElement(RefCell::from(element))
+    }
+    pub(crate) fn yxml_element_insert_text(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+    ) -> YXmlText {
+        let text = self
+            .0
+            .borrow_mut()
+            .insert_text(&mut *transaction.0.borrow_mut(), index);
+
+        YXmlText(RefCell::from(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_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 subscription_id = self
+            .0
+            .borrow_mut()
+            .observe(move |transaction, xml_element_event| {
+                let delta = xml_element_event.delta(transaction);
+                let changes = RArray::with_capacity(delta.len());
+
+                for change in delta {
+                    match change {
+                        Change::Added(v) => {
+                            let values = v
+                                .iter()
+                                .map(|o| YValue::from(o.clone()))
+                                .map(|o| *o.0.borrow())
+                                .collect::<Vec<_>>();
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_added, RArray::from_vec(values))
+                                .expect("cannot create change::added payload");
+
+                            changes
+                                .push(payload)
+                                .expect("cannot push payload to list of changes");
+                        }
+                        Change::Retain(position) => {
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_retain, *position)
+                                .expect("cannot create change::retain payload");
+
+                            changes
+                                .push(payload)
+                                .expect("cannot push payload to list of changes");
+                        }
+                        Change::Removed(position) => {
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_removed, *position)
+                                .expect("cannot create change::removed payload");
+
+                            changes
+                                .push(payload)
+                                .expect("cannot push payload to list of changes");
+                        }
+                    }
+                }
+
+                block
+                    .call::<(RArray,), Value>((changes,))
+                    .expect("cannot call block");
+            });
+
+        Ok(subscription_id.into())
+    }
+    pub(crate) fn yxml_element_parent(&self) -> Option<Value> {
+        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))),
+        })
+    }
+    pub(crate) fn yxml_element_push_element_back(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+    ) -> YXmlElement {
+        let xml_element = self
+            .0
+            .borrow_mut()
+            .push_elem_back(&mut *transaction.0.borrow_mut(), name);
+
+        YXmlElement(RefCell::from(xml_element))
+    }
+    pub(crate) fn yxml_element_push_element_front(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+    ) -> YXmlElement {
+        let xml_element = self
+            .0
+            .borrow_mut()
+            .push_elem_front(&mut *transaction.0.borrow_mut(), name);
+
+        YXmlElement(RefCell::from(xml_element))
+    }
+    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());
+
+        YXmlText(RefCell::from(xml_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());
+
+        YXmlText(RefCell::from(xml_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());
+    }
+    pub(crate) fn yxml_element_remove_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+    ) {
+        self.0
+            .borrow_mut()
+            .remove_range(&mut *transaction.0.borrow_mut(), index, length);
+    }
+    pub(crate) fn yxml_element_size(&self) -> u32 {
+        self.0.borrow().len()
+    }
+    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_unobserve(&self, subscription_id: u32) {
+        self.0.borrow_mut().unobserve(subscription_id);
+    }
+}