y-rb 0.1.0

data/src/yxml.rs

@@ -0,0 +1,550 @@
+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()
+    }
+);

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: y-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hannes Moser
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rutie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: thermite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Yrs "wires" is a Rust port of the Yjs framework.
+email:
+- hmoser@gitlab.com
+- box@hannesmoser.at
+executables: []
+extensions:
+- ext/Rakefile
+extra_rdoc_files: []
+files:
+- ".cargo/config.toml"
+- ".dockerignore"
+- ".editorconfig"
+- ".rspec"
+- ".rubocop.yml"
+- ".rustfmt.toml"
+- ".yardopts"
+- Cargo.toml
+- Cross.toml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/build.md
+- docs/decisions.md
+- docs/examples.md
+- ext/Rakefile
+- lib/y.rb
+- lib/y/array.rb
+- lib/y/doc.rb
+- lib/y/map.rb
+- lib/y/rb.rb
+- lib/y/text.rb
+- lib/y/transaction.rb
+- lib/y/version.rb
+- lib/y/xml.rb
+- lib/y_rb.so
+- src/lib.rs
+- src/util.rs
+- src/yarray.rs
+- src/ydoc.rs
+- src/ymap.rs
+- src/ytext.rs
+- src/ytransaction.rs
+- src/yxml.rs
+homepage: https://about.gitlab.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://about.gitlab.com
+  source_code_uri: https://gitlab.com/gitlab-org/incubation-engineering/real-time-editing/y-rb
+  changelog_uri: https://gitlab.com/gitlab-org/incubation-engineering/real-time-editing/y-rb
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Ruby bindings for yrs
+test_files: []