y-rb 0.6.0-x86_64-linux-gnu

data/ext/yrb/src/yvalue.rs

@@ -0,0 +1,256 @@
+use crate::{YText, YXmlElement, YXmlText};
+use magnus::r_hash::ForEach::Continue;
+use magnus::value::{Qnil, ReprValue};
+use magnus::{class, value, Float, Integer, IntoValue, RArray, RHash, RString, Symbol, Value};
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::Arc;
+use yrs::types::Value as YrsValue;
+use yrs::{
+    Any, Array, Map, TextRef as YrsText, Transact, XmlElementRef as YrsXmlElement,
+    XmlTextRef 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.into_value()))
+    }
+}
+
+impl From<bool> for YValue {
+    fn from(value: bool) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<f64> for YValue {
+    fn from(value: f64) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<i64> for YValue {
+    fn from(value: i64) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<u32> for YValue {
+    fn from(value: u32) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<String> for YValue {
+    fn from(value: String) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<RArray> for YValue {
+    fn from(value: RArray) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<RHash> for YValue {
+    fn from(value: RHash) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<Vec<u8>> for YValue {
+    fn from(value: Vec<u8>) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<YrsText> for YValue {
+    fn from(value: YrsText) -> Self {
+        YValue(RefCell::from(YText(RefCell::from(value)).into_value()))
+    }
+}
+
+impl From<YrsXmlElement> for YValue {
+    fn from(value: YrsXmlElement) -> Self {
+        YValue(RefCell::from(
+            YXmlElement(RefCell::from(value)).into_value(),
+        ))
+    }
+}
+
+impl From<YrsXmlText> for YValue {
+    fn from(value: YrsXmlText) -> Self {
+        YValue(RefCell::from(YXmlText(RefCell::from(value)).into_value()))
+    }
+}
+
+impl From<YText> for YValue {
+    fn from(value: YText) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<YXmlElement> for YValue {
+    fn from(value: YXmlElement) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<YXmlText> for YValue {
+    fn from(value: YXmlText) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
+impl From<Any> for YValue {
+    fn from(value: Any) -> Self {
+        match value {
+            Any::Null => YValue::from(value::qnil()),
+            Any::Undefined => YValue::from(value::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.to_string()),
+            Any::Buffer(v) => YValue::from(v.to_vec()),
+            Any::Array(v) => {
+                let arr = RArray::new();
+                for item in v.iter() {
+                    let val = YValue::from(item.clone());
+                    let val = *val.0.borrow();
+                    arr.push(val).expect("cannot push item event to array");
+                }
+                YValue::from(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) => {
+                let tx = val.transact();
+                let arr = RArray::new();
+                for item in val.iter(&tx) {
+                    let val = YValue::from(item.clone());
+                    let val = *val.0.borrow();
+                    arr.push(val).expect("cannot push item event to array");
+                }
+                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),
+        }
+    }
+}
+
+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(Arc::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(Arc::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(Arc::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(Arc::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 magnus::value::ReprValue;
+    use yrs::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,280 @@
+use crate::yvalue::YValue;
+use crate::yxml_fragment::YXmlFragment;
+use crate::yxml_text::YXmlText;
+use crate::YTransaction;
+use magnus::block::Proc;
+use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::Change;
+use yrs::{
+    GetString, Observable, Xml, XmlElementPrelim, XmlElementRef, XmlFragment, XmlNode,
+    XmlTextPrelim,
+};
+
+#[magnus::wrap(class = "Y::XMLElement")]
+pub(crate) struct YXmlElement(pub(crate) RefCell<XmlElementRef>);
+
+/// 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, transaction: &YTransaction) -> RHash {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        RHash::from_iter(self.0.borrow().attributes(tx))
+    }
+    pub(crate) fn yxml_element_first_child(&self, transaction: &YTransaction) -> Option<Value> {
+        self.yxml_element_get(transaction, 0)
+    }
+    pub(crate) fn yxml_element_get(&self, transaction: &YTransaction, index: u32) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get(tx, index).map(|node| match node {
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        })
+    }
+    pub(crate) fn yxml_element_get_attribute(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+    ) -> Option<String> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_attribute(tx, name.as_str())
+    }
+    pub(crate) fn yxml_element_insert_attribute(
+        &self,
+        transaction: &YTransaction,
+        name: String,
+        value: String,
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().insert_attribute(tx, name, value)
+    }
+    pub(crate) fn yxml_element_insert_element(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().insert(tx, index, node))
+    }
+    pub(crate) fn yxml_element_insert_text(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: String,
+    ) -> YXmlText {
+        let text = XmlTextPrelim::new(content.as_str());
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        YXmlText::from(self.0.borrow_mut().insert(tx, index, text))
+    }
+    pub(crate) fn yxml_element_len(&self, transaction: &YTransaction) -> u32 {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow().len(tx)
+    }
+    pub(crate) fn yxml_element_next_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().siblings(tx).next().map(|item| match item {
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        })
+    }
+    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 = RArray::new();
+                            for value in v.iter() {
+                                let value = YValue::from(value.clone());
+                                let value = *value.0.borrow();
+                                values.push(value).expect("cannot push value to array");
+                            }
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_added, 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| match item {
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        })
+    }
+    pub(crate) fn yxml_element_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0
+            .borrow()
+            .siblings(tx)
+            .next_back()
+            .map(|item| match item {
+                XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+                XmlNode::Text(text) => YXmlText::from(text).into_value(),
+            })
+    }
+    pub(crate) fn yxml_element_push_element_back(
+        &self,
+        transaction: &YTransaction,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_back(tx, node))
+    }
+    pub(crate) fn yxml_element_push_element_front(
+        &self,
+        transaction: &YTransaction,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_front(tx, node))
+    }
+    pub(crate) fn yxml_element_push_text_back(
+        &self,
+        transaction: &YTransaction,
+        content: String,
+    ) -> YXmlText {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let text = XmlTextPrelim::new(content.as_str());
+        YXmlText::from(self.0.borrow_mut().push_back(tx, text))
+    }
+    pub(crate) fn yxml_element_push_text_front(
+        &self,
+        transaction: &YTransaction,
+        content: String,
+    ) -> YXmlText {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let text = XmlTextPrelim::new(content.as_str());
+        YXmlText::from(self.0.borrow_mut().push_front(tx, text))
+    }
+    pub(crate) fn yxml_element_remove_attribute(&self, transaction: &YTransaction, name: String) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_attribute(tx, &name)
+    }
+    pub(crate) fn yxml_element_remove_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_range(tx, index, length)
+    }
+    pub(crate) fn yxml_element_siblings(&self, transaction: &YTransaction) -> RArray {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let siblings = self.0.borrow().siblings(tx).map(|item| match item {
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        });
+
+        RArray::from_iter(siblings)
+    }
+    pub(crate) fn yxml_element_size(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
+    }
+    pub(crate) fn yxml_element_tag(&self) -> String {
+        self.0.borrow().tag().to_string()
+    }
+    pub(crate) fn yxml_element_to_s(&self, transaction: &YTransaction) -> String {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_string(tx)
+    }
+    pub(crate) fn yxml_element_unobserve(&self, subscription_id: u32) {
+        self.0.borrow_mut().unobserve(subscription_id);
+    }
+}
+
+impl From<XmlElementRef> for YXmlElement {
+    fn from(v: XmlElementRef) -> Self {
+        YXmlElement(RefCell::from(v))
+    }
+}

data/ext/yrb/src/yxml_fragment.rs

@@ -0,0 +1,129 @@
+use crate::ytransaction::YTransaction;
+use crate::yxml_element::YXmlElement;
+use crate::yxml_text::YXmlText;
+use magnus::{IntoValue, RArray, Value};
+use std::cell::RefCell;
+use yrs::{GetString, XmlElementPrelim, XmlFragment, XmlFragmentRef, XmlNode};
+
+#[magnus::wrap(class = "Y::XMLFragment")]
+pub(crate) struct YXmlFragment(pub(crate) RefCell<XmlFragmentRef>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YXmlFragment {}
+
+impl YXmlFragment {
+    pub(crate) fn yxml_fragment_first_child(&self) -> Option<Value> {
+        self.0.borrow().first_child().map(|node| match node {
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        })
+    }
+
+    pub(crate) fn yxml_fragment_get(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+    ) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get(tx, index).map(|node| match node {
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        })
+    }
+
+    pub(crate) fn yxml_fragment_insert(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().insert(tx, index, node))
+    }
+
+    pub(crate) fn yxml_fragment_len(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
+    }
+
+    pub(crate) fn yxml_fragment_parent(&self) -> Option<Value> {
+        self.0.borrow().parent().map(|item| match item {
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        })
+    }
+
+    pub(crate) fn yxml_fragment_push_back(
+        &self,
+        transaction: &YTransaction,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_back(tx, node))
+    }
+
+    pub(crate) fn yxml_fragment_push_front(
+        &self,
+        transaction: &YTransaction,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_front(tx, node))
+    }
+
+    pub(crate) fn yxml_fragment_remove_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_range(tx, index, length);
+    }
+
+    pub(crate) fn yxml_fragment_successors(&self, transaction: &YTransaction) -> RArray {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let fragment = self.0.borrow();
+
+        let result = fragment.successors(tx).map(|item| match item {
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
+        });
+
+        RArray::from_iter(result)
+    }
+
+    pub(crate) fn yxml_fragment_to_s(&self, transaction: &YTransaction) -> String {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_string(tx)
+    }
+}
+
+impl From<XmlFragmentRef> for YXmlFragment {
+    fn from(v: XmlFragmentRef) -> Self {
+        YXmlFragment(RefCell::from(v))
+    }
+}