y-rb 0.1.0

data/src/ymap.rs

@@ -0,0 +1,199 @@
+use crate::util::{map_ruby_type_to_rust, map_yrs_value_to_ruby};
+use crate::ytransaction::{YTransaction, TRANSACTION_WRAPPER};
+use lib0::any::Any;
+use rutie::{
+    AnyObject, Array, Boolean, Class, Fixnum, Hash, Integer, NilClass, Object,
+    Proc, RString, Symbol, VM,
+};
+use std::rc::Rc;
+use yrs::types::EntryChange;
+use yrs::{Map, SubscriptionId};
+
+wrappable_struct!(Map, MapWrapper, MAP_WRAPPER);
+class!(YMap);
+
+#[rustfmt::skip]
+methods!(
+    YMap,
+    rtself,
+    fn ymap_clear(transaction: YTransaction) -> NilClass {
+        let mut tx = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let txn = tx.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+        m.clear(txn);
+
+        NilClass::new()
+    },
+    fn ymap_contains(key: AnyObject) -> Boolean {
+        let k = key.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let k2 = if let Ok(t) = k.try_convert_to::<Symbol>() {
+            t.to_string()
+        } else if let Ok(t) = k.try_convert_to::<RString>() {
+            t.to_string()
+        } else {
+            VM::raise(Class::from_existing("IllegalArgumentError"), "Only strings and symbols are supported as map keys.");
+            return Boolean::new(false);
+        };
+
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+        let result = m.contains(&k2);
+
+        Boolean::new(result)
+    },
+    fn ymap_each(block: Proc) -> NilClass {
+        let b = block.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+
+        m
+            .iter()
+            .for_each(|(key, val)| {
+                let args = [
+                    RString::new_utf8(key).to_any_object(),
+                    map_yrs_value_to_ruby(val)
+                ];
+                b.call(&args);
+            });
+
+        NilClass::new()
+    },
+    fn ymap_get(key: AnyObject) -> AnyObject {
+        let k = key.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let k2 = if let Ok(t) = k.try_convert_to::<Symbol>() {
+            t.to_string()
+        } else if let Ok(t) = k.try_convert_to::<RString>() {
+            t.to_string()
+        } else {
+            VM::raise(Class::from_existing("IllegalArgumentError"), "Only strings and symbols are supported as map keys.");
+            return NilClass::new().to_any_object();
+        };
+
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+        let result = m.get(&k2);
+
+        map_yrs_value_to_ruby(result.unwrap_or(yrs::types::Value::Any(Any::Null)))
+    },
+    fn ymap_insert(transaction: YTransaction, key: AnyObject, value: AnyObject) -> AnyObject {
+        let mut tx = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let k = key.map_err(|e| VM::raise_ex(e)).unwrap();
+        let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let k2 = if let Ok(t) = k.try_convert_to::<Symbol>() {
+            t.to_string()
+        } else if let Ok(t) = k.try_convert_to::<RString>() {
+            t.to_string()
+        } else {
+            VM::raise(Class::from_existing("IllegalArgumentError"), "Only strings and symbols are supported as map keys.");
+            return NilClass::new().to_any_object();
+        };
+
+        let txn = tx.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+
+        let result = m.insert(
+            txn,
+            Rc::from(k2),
+            map_ruby_type_to_rust(v).unwrap()
+        );
+
+        map_yrs_value_to_ruby(result.unwrap_or(yrs::types::Value::Any(Any::Null)))
+    },
+    fn ymap_observe(callback: Proc) -> Integer {
+        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let map: &mut Map = rtself.get_data_mut(&*MAP_WRAPPER);
+        let subscription_id: SubscriptionId = map
+            .observe(move |transaction, map_event| {
+                let delta = map_event.keys(transaction);
+                let mut changes: Vec<AnyObject> = Vec::new();
+
+                for (key, change) in delta {
+                    match change {
+                        EntryChange::Inserted(v) => {
+                            let mut h = Hash::new();
+                            h.store(Symbol::new(&key.to_string()), map_yrs_value_to_ruby(v.clone()));
+
+                            let mut payload = Hash::new();
+                            payload.store(Symbol::new("inserted"), h);
+
+                            changes.push(payload.to_any_object());
+                        },
+                        EntryChange::Updated(old, new) => {
+                            let mut values = Array::with_capacity(2);
+                            values.push(map_yrs_value_to_ruby(old.clone()));
+                            values.push(map_yrs_value_to_ruby(new.clone()));
+
+                            let mut h = Hash::new();
+                            h.store(Symbol::new(&key.to_string()), values);
+
+                            let mut payload = Hash::new();
+                            payload.store(Symbol::new("updated"), h);
+
+                            changes.push(payload.to_any_object());
+                        },
+                        EntryChange::Removed(v) => {
+                            let mut h = Hash::new();
+                            h.store(Symbol::new(&key.to_string()), map_yrs_value_to_ruby(v.clone()));
+
+                            let mut payload = Hash::new();
+                            payload.store(Symbol::new("removed"), h);
+
+                            changes.push(payload.to_any_object());
+                        }
+                    }
+                }
+
+                let args = &[Array::from_iter(changes).to_any_object()];
+                c.call(args);
+            })
+            .into();
+
+        Integer::from(subscription_id)
+    },
+    fn ymap_remove(transaction: YTransaction, key: AnyObject) -> AnyObject {
+        let mut tx = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let k = key.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let k2 = if let Ok(t) = k.try_convert_to::<Symbol>() {
+            t.to_string()
+        } else if let Ok(t) = k.try_convert_to::<RString>() {
+            t.to_string()
+        } else {
+            VM::raise(Class::from_existing("IllegalArgumentError"), "Only strings and symbols are supported as map keys.");
+            return NilClass::new().to_any_object();
+        };
+
+        let txn = tx.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+        let result = m.remove(txn, &k2);
+
+        map_yrs_value_to_ruby(result.unwrap_or(yrs::types::Value::Any(Any::Null)))
+    },
+    fn ymap_size() -> Fixnum {
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+        Fixnum::new(i64::from(m.len()))
+    },
+    fn ymap_to_hash() -> Hash {
+        let m: &Map = rtself.get_data(&*MAP_WRAPPER);
+        let mut h = Hash::new();
+
+        for (key, val) in m.iter() {
+            h.store(Symbol::new(key), map_yrs_value_to_ruby(val));
+        }
+
+        h
+    },
+    fn ymap_unobserve(subscription_id: Integer) -> NilClass {
+        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let map: &mut Map = rtself.get_data_mut(&*MAP_WRAPPER);
+        map.unobserve(s.into());
+
+        NilClass::new()
+    }
+);

data/src/ytext.rs

@@ -0,0 +1,204 @@
+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, Fixnum, Hash, Integer, NilClass, Object, Proc, RString, Symbol,
+    VM,
+};
+use yrs::types::Delta;
+use yrs::{SubscriptionId, Text};
+
+wrappable_struct!(Text, TextWrapper, TEXT_WRAPPER);
+class!(YText);
+
+#[rustfmt::skip]
+methods!(
+    YText,
+    rtself,
+    fn ytext_insert(transaction: YTransaction, index: Fixnum, chunk: RString) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let c = chunk.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
+
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text: &Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.insert(tx, i.to_u32(), &c);
+
+        NilClass::new()
+    },
+    fn ytext_insert_embed(
+        transaction: YTransaction,
+        index: Fixnum,
+        content: AnyObject) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
+        let v = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text: &Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.insert_embed(tx, i.to_u32(), v);
+
+        NilClass::new()
+    }
+    fn ytext_insert_embed_with_attributes(
+        transaction: YTransaction,
+        index: Fixnum,
+        embed: AnyObject,
+        attrs: Hash) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let c = embed.map_err(|e| VM::raise_ex(e)).unwrap();
+        let v = 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 tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text: &Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.insert_embed_with_attributes(tx, i.to_u32(), v, mapped_attrs);
+
+        NilClass::new()
+    }
+    fn ytext_insert_with_attributes(
+        transaction: YTransaction,
+        index: Fixnum,
+        chunk: RString,
+        attrs: Hash) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let c = chunk.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
+
+        let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
+        let mapped_attrs = map_hash_to_attrs(a);
+
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text: &Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.insert_with_attributes(tx, i.to_u32(), &c, mapped_attrs);
+
+        NilClass::new()
+    },
+    fn ytext_length() -> Fixnum {
+        let text = rtself.get_data(&*TEXT_WRAPPER);
+
+        Fixnum::new(i64::from(text.len()))
+    }
+    fn ytext_push(transaction: YTransaction, value: RString) -> NilClass {
+        let value_str = value.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
+
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let t = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.push(t, &value_str);
+
+        NilClass::new()
+    },
+    fn ytext_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
+        let mut txn = 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 = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text: &Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.remove_range(tx, i.to_u32(), l.to_u32());
+
+        NilClass::new()
+    },
+    fn ytext_format(transaction: YTransaction, index: Fixnum, length: Fixnum, attrs: Hash) -> NilClass {
+        let mut txn = 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 a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
+        let mapped_attrs = map_hash_to_attrs(a);
+
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+        let text: &Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+
+        text.format(tx, i.to_u32(), l.to_u32(), mapped_attrs);
+
+        NilClass::new()
+    },
+    fn ytext_observe(callback: Proc) -> Integer {
+        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let text: &mut Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+        let subscription_id: SubscriptionId = text
+            .observe(move |transaction, text_event| {
+                let delta = 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 ytext_to_string() -> RString {
+        let text = rtself.get_data(&*TEXT_WRAPPER);
+
+        RString::new_utf8(&text.to_string())
+    },
+    fn ytext_unobserve(subscription_id: Integer) -> NilClass {
+        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let text: &mut Text = rtself.get_data_mut(&*TEXT_WRAPPER);
+        text.unobserve(s.into());
+
+        NilClass::new()
+    }
+);

data/src/ytransaction.rs

@@ -0,0 +1,101 @@
+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);
+        transaction.apply_update(Update::decode_v1(u.as_slice()));
+
+        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)
+    }
+);