y-rb 0.1.4.alpha.1-x86_64-darwin

data/ext/yrb/src/ytransaction.rs

@@ -0,0 +1,58 @@
+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>);
+
+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);
+
+        return YArray(RefCell::from(a));
+    }
+    pub(crate) fn ytransaction_get_map(&self, name: String) -> YMap {
+        let m = self.0.borrow_mut().get_map(&*name);
+
+        return YMap(RefCell::from(m));
+    }
+    pub(crate) fn ytransaction_get_text(&self, name: String) -> YText {
+        let t = self.0.borrow_mut().get_text(&*name);
+
+        return 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);
+
+        return 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);
+
+        return 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,235 @@
+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
+        }
+    }
+}
+
+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;
+    use magnus::RArray;
+
+    #[test]
+    fn convert_any_to_yvalue() {
+        let value = Any::Null;
+        let yvalue: YValue = value.into();
+    }
+}

data/ext/yrb/src/yxml_element.rs

@@ -0,0 +1,225 @@
+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>);
+
+impl YXmlElement {
+    pub(crate) fn yxml_element_attributes(&self) -> RHash {
+        RHash::from_iter(self.0.borrow().attributes().into_iter())
+    }
+    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
+    ) {
+        self.0.borrow_mut().insert_elem(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            name
+        );
+    }
+    pub(crate) fn yxml_element_insert_text(
+        &self,
+        transaction: &YTransaction,
+        index: u32
+    ) {
+        self.0
+            .borrow_mut()
+            .insert_text(&mut *transaction.0.borrow_mut(), index);
+    }
+    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);
+    }
+}

data/ext/yrb/src/yxml_text.rs

@@ -0,0 +1,154 @@
+use crate::utils::map_rhash_to_attrs;
+use crate::yvalue::YValue;
+use crate::{YTransaction, YXmlElement};
+use lib0::any::Any;
+use magnus::{Error, RHash, Value};
+use std::cell::RefCell;
+use yrs::{Xml, XmlText};
+
+#[magnus::wrap(class = "Y::XMLText")]
+pub(crate) struct YXmlText(pub(crate) RefCell<XmlText>);
+
+impl YXmlText {
+    pub(crate) fn yxml_text_attributes(&self) -> RHash {
+        RHash::from_iter(self.0.borrow().attributes().into_iter())
+    }
+    pub(crate) fn yxml_text_format(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+        attrs: RHash
+    ) -> Result<(), Error> {
+        map_rhash_to_attrs(attrs).map(|a| {
+            self.0.borrow_mut().format(
+                &mut *transaction.0.borrow_mut(),
+                index,
+                length,
+                a
+            );
+        })
+    }
+    pub(crate) fn yxml_text_get_attribute(
+        &self,
+        name: String
+    ) -> Option<String> {
+        self.0.borrow().get_attribute(&*name)
+    }
+    pub(crate) fn yxml_text_insert(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: String
+    ) {
+        self.0.borrow_mut().insert(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            &*content
+        )
+    }
+    pub(crate) fn yxml_text_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_text_insert_embed_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: Value,
+        attrs: RHash
+    ) -> Result<(), Error> {
+        let yvalue = YValue::from(content);
+        let avalue = Any::from(yvalue);
+
+        map_rhash_to_attrs(attrs).map(|a| {
+            self.0.borrow_mut().insert_embed_with_attributes(
+                &mut *transaction.0.borrow_mut(),
+                index,
+                avalue,
+                a
+            );
+        })
+    }
+    pub(crate) fn yxml_text_insert_embed(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        embed: Value
+    ) {
+        self.0.borrow_mut().insert_embed(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            Any::from(YValue::from(embed))
+        )
+    }
+    pub(crate) fn yxml_text_insert_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: String,
+        attrs: RHash
+    ) -> Result<(), Error> {
+        map_rhash_to_attrs(attrs).map(|a| {
+            self.0.borrow_mut().insert_with_attributes(
+                &mut *transaction.0.borrow_mut(),
+                index,
+                &*content,
+                a
+            );
+        })
+    }
+    pub(crate) fn yxml_text_length(&self) -> u32 {
+        self.0.borrow().len()
+    }
+    pub(crate) fn yxml_text_next_sibling(&self) -> Option<Value> {
+        self.0.borrow().next_sibling().map(|item| match item {
+            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+        })
+    }
+    pub(crate) fn yxml_text_parent(&self) -> Option<Value> {
+        self.0
+            .borrow()
+            .parent()
+            .map(|item| Value::from(YXmlElement(RefCell::from(item))))
+    }
+    pub(crate) fn yxml_text_prev_sibling(&self) -> Option<Value> {
+        self.0.borrow().prev_sibling().map(|item| match item {
+            Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+        })
+    }
+    pub(crate) fn yxml_text_push(
+        &self,
+        transaction: &YTransaction,
+        content: String
+    ) {
+        self.0
+            .borrow_mut()
+            .push(&mut *transaction.0.borrow_mut(), &*content)
+    }
+    pub(crate) fn yxml_text_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_text_to_s(&self) -> String {
+        self.0.borrow().to_string()
+    }
+}