y-rb 0.1.2 → 0.1.4.alpha.1

data/src/ytransaction.rs

@@ -1,102 +0,0 @@
-use crate::util::{convert_array_to_vecu8, convert_vecu8_to_array};
-use crate::yarray::ARRAY_WRAPPER;
-use crate::ymap::MAP_WRAPPER;
-use crate::ytext::TEXT_WRAPPER;
-use crate::yxml::{XML_ELEMENT_WRAPPER, XML_TEXT_WRAPPER};
-use rutie::{
-    AnyObject, Array, Module, NilClass, Object, RString, VerifiedObject, VM,
-};
-use yrs::updates::decoder::Decode;
-use yrs::updates::encoder::Encode;
-use yrs::{Transaction, Update};
-
-wrappable_struct!(Transaction, TransactionWrapper, TRANSACTION_WRAPPER);
-class!(YTransaction);
-
-impl VerifiedObject for YTransaction {
-    fn is_correct_type<T: Object>(object: &T) -> bool {
-        object.class()
-            == Module::from_existing("Y").get_nested_class("Transaction")
-    }
-
-    fn error_message() -> &'static str {
-        "Error converting to YTransaction"
-    }
-}
-
-methods!(
-    YTransaction,
-    rtself,
-    fn ytransaction_apply_update(update: Array) -> NilClass {
-        let u = convert_array_to_vecu8(update.unwrap());
-
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let update = Update::decode_v1(u.as_slice()).unwrap();
-        transaction.apply_update(update);
-
-        NilClass::new()
-    },
-    fn ytransaction_commit() -> NilClass {
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        transaction.commit();
-
-        NilClass::new()
-    },
-    fn ytransaction_get_array(name: RString) -> AnyObject {
-        let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
-
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let arr = transaction.get_array(&name_str);
-
-        Module::from_existing("Y")
-            .get_nested_class("Array")
-            .wrap_data(arr, &*ARRAY_WRAPPER)
-    },
-    fn ytransaction_get_map(name: RString) -> AnyObject {
-        let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
-
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let map = transaction.get_map(&name_str);
-
-        Module::from_existing("Y")
-            .get_nested_class("Map")
-            .wrap_data(map, &*MAP_WRAPPER)
-    },
-    fn ytransaction_get_text(name: RString) -> AnyObject {
-        let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
-
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let text = transaction.get_text(&name_str);
-
-        Module::from_existing("Y")
-            .get_nested_class("Text")
-            .wrap_data(text, &*TEXT_WRAPPER)
-    },
-    fn ytransaction_get_xml_element(name: RString) -> AnyObject {
-        let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
-
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = transaction.get_xml_element(&name_str);
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(xml_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn ytransaction_get_xml_text(name: RString) -> AnyObject {
-        let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
-
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_text = transaction.get_xml_text(&name_str);
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(xml_text, &*XML_TEXT_WRAPPER)
-    },
-    fn ytransaction_state_vector() -> Array {
-        let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
-        let sv = transaction.state_vector();
-        let payload = sv.encode_v1();
-
-        convert_vecu8_to_array(payload)
-    }
-);

data/src/yxml.rs

@@ -1,550 +0,0 @@
-use crate::util::{
-    map_attrs_to_hash, map_hash_to_attrs, map_ruby_type_to_rust,
-    map_yrs_value_to_ruby
-};
-use crate::ytransaction::{YTransaction, TRANSACTION_WRAPPER};
-use rutie::{
-    AnyObject, Array as RArray, Fixnum, Hash, Integer, Module, NilClass,
-    Object, Proc, RString, Symbol, VM
-};
-use yrs::types::xml::Attributes;
-use yrs::types::{Change, Delta};
-use yrs::{SubscriptionId, Xml, XmlElement, XmlText};
-
-wrappable_struct!(XmlElement, XmlElementWrapper, XML_ELEMENT_WRAPPER);
-class!(YXmlElement);
-
-#[rustfmt::skip]
-methods!(
-    YXmlElement,
-    rtself,
-    fn yxml_element_attributes() -> Hash {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-
-        let mut h = Hash::new();
-
-        let attrs: Attributes = xml_element.attributes();
-        for (key, val) in attrs {
-            h.store(
-                Symbol::new(key),
-                RString::new_utf8(&val)
-            );
-        }
-
-        h
-    },
-    fn yxml_element_first_child() -> AnyObject {
-       let index = 0;
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.get(index);
-
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_get(index: Fixnum) -> AnyObject {
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.get(i.to_u32());
-
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_get_attribute(name: RString) -> AnyObject {
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let attr_name = xml_element.get_attribute(&n.to_string());
-
-        match attr_name {
-            Some(v) => RString::new_utf8(&v).to_any_object(),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_insert_attribute(
-        transaction: YTransaction,
-        name: RString,
-        value: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        xml_element.insert_attribute(tx, n.to_string(), v.to_string());
-
-        NilClass::new()
-    },
-    fn yxml_element_insert_element(transaction: YTransaction, index: Fixnum, name: RString) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_element: XmlElement = xml_element.insert_elem(tx, i.to_u32(), n.to_string());
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn yxml_element_insert_text(transaction: YTransaction, index: Fixnum) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_text = xml_element.insert_text(tx, i.to_u32());
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(new_text, &*XML_TEXT_WRAPPER)
-    },
-    fn yxml_element_next_sibling() -> AnyObject {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.next_sibling();
-
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_observe(callback: Proc) -> Integer {
-        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_element: &mut XmlElement = rtself.get_data_mut(&*XML_ELEMENT_WRAPPER);
-        let subscription_id: SubscriptionId = xml_element
-            .observe(move |transaction, xml_element_event| {
-                // TODO: emit attribute changes
-                let delta = xml_element_event.delta(transaction);
-                let mut changes: Vec<AnyObject> = Vec::with_capacity(delta.len());
-
-                for change in delta {
-                    match change {
-                        Change::Added(v) => {
-                            let mut payload = Hash::new();
-                            let values = v.iter().map(|v| map_yrs_value_to_ruby(v.clone()) ).collect::<Vec<_>>();
-                            payload.store(Symbol::new("added"), RArray::from_iter(values));
-
-                            changes.push(payload.to_any_object());
-                        },
-                        Change::Retain(position) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("retain"), Integer::from(*position));
-
-                            changes.push(payload.to_any_object());
-                        },
-                        Change::Removed(position) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("removed"), Integer::from(*position));
-
-                            changes.push(payload.to_any_object());
-                        }
-                    }
-                }
-
-                let args = &[RArray::from_iter(changes).to_any_object()];
-                c.call(args);
-            })
-            .into();
-
-        Integer::from(subscription_id)
-    },
-    fn yxml_element_parent() -> AnyObject {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.parent();
-
-        match node {
-            Some(v) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_prev_sibling() -> AnyObject {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.prev_sibling();
-
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_push_elem_back(transaction: YTransaction, name: RString) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_element: XmlElement = xml_element.push_elem_back(tx, n.to_string());
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn yxml_element_push_elem_front(transaction: YTransaction, name: RString) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_element: XmlElement = xml_element.push_elem_front(tx, n.to_string());
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn yxml_element_push_text_back(transaction: YTransaction) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_text = xml_element.push_text_back(tx);
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(new_text, &*XML_TEXT_WRAPPER)
-    },
-    fn yxml_element_push_text_front(transaction: YTransaction) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_text = xml_element.push_text_front(tx);
-
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(new_text, &*XML_TEXT_WRAPPER)
-    },
-    fn yxml_element_remove_attribute(
-        transaction: YTransaction,
-        name: RString) -> NilClass {
-
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        xml_element.remove_attribute(tx, &n.to_string());
-
-        NilClass::new()
-    },
-    fn yxml_element_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        xml_element.remove_range(tx, i.to_u32(), l.to_u32());
-
-        NilClass::new()
-    },
-    fn yxml_element_size() -> Fixnum {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-
-        Fixnum::new(i64::from(xml_element.len()))
-    },
-    fn yxml_element_tag() -> RString {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-
-        RString::new_utf8(xml_element.tag())
-    },
-    fn yxml_element_to_string() -> RString {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-
-        RString::new_utf8(&xml_element.to_string())
-    },
-    fn yxml_element_unobserve(subscription_id: Integer) -> NilClass {
-        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_element: &mut XmlElement = rtself.get_data_mut(&*XML_ELEMENT_WRAPPER);
-        xml_element.unobserve(s.into());
-
-        NilClass::new()
-    }
-);
-
-wrappable_struct!(XmlText, XmlTextWrapper, XML_TEXT_WRAPPER);
-class!(YXmlText);
-
-#[rustfmt::skip]
-methods!(
-    YXmlText,
-    rtself,
-    fn yxml_text_attributes() -> Hash {
-        let xml_element = rtself.get_data(&*XML_TEXT_WRAPPER);
-
-        let mut h = Hash::new();
-
-        let attrs: Attributes = xml_element.attributes();
-        for (key, val) in attrs {
-            h.store(
-                Symbol::new(key),
-                RString::new_utf8(&val)
-            );
-        }
-
-        h
-    },
-    fn yxml_text_format(transaction: YTransaction, index: Fixnum, length: Fixnum, attrs: Hash) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
-        let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_attrs = map_hash_to_attrs(a);
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.format(tx, i.to_u32(), l.to_u32(), mapped_attrs);
-
-        NilClass::new()
-    },
-    fn yxml_text_get_attribute(name: RString) -> AnyObject {
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let attr = xml_text.get_attribute(&n.to_string());
-
-        match attr {
-            Some(v) => RString::new_utf8(&v).to_any_object(),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_insert(transaction: YTransaction, index: Fixnum, content: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert(tx, i.to_u32(),&c.to_string());
-
-        NilClass::new()
-    },
-    fn yxml_text_insert_attribute(transaction: YTransaction, name: RString, value: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_attribute(tx, n.to_string(), v.to_string());
-
-        NilClass::new()
-    },
-    fn yxml_text_insert_embed(transaction: YTransaction, index: Fixnum, content: AnyObject) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_content = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_embed(tx, i.to_u32(), mapped_content);
-
-        NilClass::new()
-    },
-    fn yxml_text_insert_embed_with_attributes(transaction: YTransaction, index: Fixnum, content: AnyObject, attrs: Hash) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_content = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
-        let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_attrs = map_hash_to_attrs(a);
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_embed_with_attributes(tx, i.to_u32(), mapped_content, mapped_attrs);
-
-        NilClass::new()
-    },
-    fn yxml_text_insert_with_attributes(transaction: YTransaction, index: Fixnum, content: RString, attrs: Hash) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let mapped_attrs = map_hash_to_attrs(a);
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_with_attributes(tx, i.to_u32(), &c.to_string(), mapped_attrs);
-
-        NilClass::new()
-    },
-    fn yxml_text_length() -> Fixnum {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        Fixnum::new(i64::from(xml_text.len()))
-    },
-    fn yxml_text_next_sibling() -> AnyObject {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let xml = xml_text.next_sibling();
-
-        match xml {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_observe(callback: Proc) -> Integer {
-        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text: &mut XmlText = rtself.get_data_mut(&*XML_TEXT_WRAPPER);
-        let subscription_id: SubscriptionId = xml_text
-            .observe(move |transaction, xml_text_event| {
-                // TODO: add node changes
-                let delta = xml_text_event.delta(transaction);
-                for event in delta {
-                    match event {
-                        Delta::Inserted(v, attrs) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("insert"), map_yrs_value_to_ruby(v.clone()));
-
-                            match attrs {
-                                Some(a) => {
-                                    let copy = a.clone();
-                                    let result = map_attrs_to_hash(*copy).to_any_object();
-                                    payload.store(Symbol::new("attributes"), result);
-                                },
-                                None => ()
-                            }
-
-                            let args = &[payload.to_any_object()];
-                            c.call(args);
-                        },
-                        Delta::Retain(position, attrs) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("retain"), Integer::from(*position));
-
-                            match attrs {
-                                Some(a) => {
-                                    let copy = a.clone();
-                                    let result = map_attrs_to_hash(*copy).to_any_object();
-                                    payload.store(Symbol::new("attributes"), result);
-                                },
-                                None => ()
-                            }
-
-                            let args = &[payload.to_any_object()];
-                            c.call(args);
-                        },
-                        Delta::Deleted(position) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("delete"), Integer::from(*position));
-
-                            let args = &[payload.to_any_object()];
-                            c.call(args);
-                        }
-                    }
-                }
-            })
-            .into();
-
-        Integer::from(subscription_id)
-    },
-    fn yxml_text_parent() -> AnyObject {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let xml_element = xml_text.parent();
-
-        match xml_element {
-            Some(v) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_prev_sibling() -> AnyObject {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let xml = xml_text.prev_sibling();
-
-        match xml {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_push(transaction: YTransaction, content: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.push(tx, &c.to_string());
-
-        NilClass::new()
-    },
-    fn yxml_text_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.remove_range(tx, i.to_u32(), l.to_u32());
-
-        NilClass::new()
-    },
-    fn yxml_text_to_string() -> RString {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        RString::new_utf8(&xml_text.to_string())
-    },
-    fn yxml_text_unobserve(subscription_id: Integer) -> NilClass {
-        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
-
-        let xml_text: &mut XmlText = rtself.get_data_mut(&*XML_TEXT_WRAPPER);
-        xml_text.unobserve(s.into());
-
-        NilClass::new()
-    }
-);

data/y-rb.gemspec

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/y/version"
-
-# rubocop:disable Metrics/BlockLength
-Gem::Specification.new do |spec|
-  spec.name = "y-rb"
-  spec.version = Y::VERSION
-  spec.authors = ["Hannes Moser"]
-  spec.email = %w[hmoser@gitlab.com box@hannesmoser.at]
-
-  spec.summary = "Ruby bindings for yrs"
-  spec.description = "Ruby bindings for yrs. Yrs \"wires\" is a Rust port of the Yjs framework."
-  spec.homepage = "https://github.com/y-crdt/yrb"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-
-  spec.metadata["allowed_push_host"] = "https://rubygems.org"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/y-crdt/yrb"
-  spec.metadata["documentation_uri"] = "https://y-crdt.github.io/yrb/"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  spec.add_dependency "rake", "~> 13.0"
-  spec.add_dependency "rutie", "~> 0.0.4"
-  spec.add_dependency "thermite", "~> 0"
-
-  spec.extensions << "ext/Rakefile"
-end
-# rubocop:enable Metrics/BlockLength