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

data/ext/yrb/src/yarray.rs

@@ -0,0 +1,175 @@
+use crate::yvalue::YValue;
+use crate::YTransaction;
+use lib0::any::Any;
+use magnus::block::Proc;
+use magnus::value::Qnil;
+use magnus::{Error, RArray, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::Change;
+use yrs::Array;
+
+#[magnus::wrap(class = "Y::Array")]
+pub(crate) struct YArray(pub(crate) RefCell<Array>);
+
+impl YArray {
+    pub(crate) fn yarray_each(&self, block: Proc) -> () {
+        self.0.borrow_mut().iter().for_each(|val| {
+            let yvalue = YValue::from(val);
+            let args = (yvalue.into(),);
+            let _ = block.call::<(Value,), Qnil>(args);
+        });
+    }
+    pub(crate) fn yarray_get(&self, index: u32) -> Value {
+        let v = self.0.borrow().get(index).unwrap();
+        YValue::from(v).into()
+    }
+    pub(crate) fn yarray_insert(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        value: Value
+    ) -> () {
+        let yvalue = YValue::from(value);
+        let avalue = Any::from(yvalue);
+        self.0.borrow_mut().insert(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            avalue
+        );
+    }
+    pub(crate) fn yarray_insert_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        values: RArray
+    ) -> () {
+        let arr: Vec<Any> = values
+            .each()
+            .into_iter()
+            .map(|value| YValue::from(value.unwrap()).into())
+            .collect();
+
+        self.0.borrow_mut().insert_range(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            arr
+        );
+    }
+    pub(crate) fn yarray_length(&self) -> u32 {
+        return self.0.borrow().len();
+    }
+    pub(crate) fn yarray_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 mut error: Option<Error> = None;
+
+        let subscription_id = self
+            .0
+            .borrow_mut()
+            .observe(move |transaction, array_event| {
+                let delta = array_event.delta(transaction);
+                // let mut changes = RArray::with_capacity(delta.len());
+                let (changes, errors): (Vec<_>, Vec<_>) = delta
+                    .iter()
+                    .map(|change| {
+                        let payload = RHash::new();
+                        let result = match change {
+                            Change::Added(v) => {
+                                let values = v
+                                    .iter()
+                                    .map(|v| {
+                                        <YValue as Into<Value>>::into(
+                                            YValue::from(v.clone())
+                                        )
+                                    })
+                                    .collect::<RArray>();
+                                payload.aset(change_added, values)
+                            }
+                            Change::Retain(position) => payload
+                                .aset(change_retain, Value::from(*position)),
+                            Change::Removed(position) => payload
+                                .aset(change_removed, Value::from(*position))
+                        };
+
+                        match result {
+                            Ok(()) => Ok(payload),
+                            Err(e) => Err(e)
+                        }
+                    })
+                    .partition(Result::is_ok);
+
+                if errors.len() == 0 {
+                    let args = (RArray::from_vec(
+                        changes.into_iter().map(Result::unwrap).collect()
+                    ),);
+                    let _ = block.call::<(RArray,), Qnil>(args);
+                    // todo: make sure we respect the result and bubble up the
+                    //  error so that we can return as part of the Result
+                }
+
+                // todo: make sure we respect errors and let the method fail by
+                //  by returning a Result containing an Error
+            })
+            .into();
+
+        Ok(subscription_id)
+    }
+    pub(crate) fn yarray_push_back(
+        &self,
+        transaction: &YTransaction,
+        value: Value
+    ) -> () {
+        let yvalue = YValue::from(value);
+        let avalue = Any::from(yvalue);
+        self.0
+            .borrow_mut()
+            .push_back(&mut *transaction.0.borrow_mut(), avalue)
+    }
+    pub(crate) fn yarray_push_front(
+        &self,
+        transaction: &YTransaction,
+        value: Value
+    ) -> () {
+        let yvalue = YValue::from(value);
+        let avalue = Any::from(yvalue);
+        self.0
+            .borrow_mut()
+            .push_front(&mut *transaction.0.borrow_mut(), avalue)
+    }
+    pub(crate) fn yarray_remove(
+        &self,
+        transaction: &YTransaction,
+        index: u32
+    ) -> () {
+        self.0
+            .borrow_mut()
+            .remove(&mut transaction.0.borrow_mut(), index)
+    }
+    pub(crate) fn yarray_remove_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        len: u32
+    ) -> () {
+        self.0.borrow_mut().remove_range(
+            &mut transaction.0.borrow_mut(),
+            index,
+            len
+        )
+    }
+    pub(crate) fn yarray_to_a(&self) -> RArray {
+        let arr = self
+            .0
+            .borrow_mut()
+            .iter()
+            .map(|v| YValue::from(v).into())
+            .collect::<Vec<Value>>();
+
+        return RArray::from_vec(arr);
+    }
+    pub(crate) fn yarray_unobserve(&self, subscription_id: u32) -> () {
+        self.0.borrow_mut().unobserve(subscription_id);
+    }
+}

data/ext/yrb/src/yattrs.rs

@@ -0,0 +1,48 @@
+use crate::yvalue::YValue;
+use lib0::any::Any;
+use magnus::r_hash::ForEach::Continue;
+use magnus::{RHash, Value};
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+use yrs::types::Attrs;
+
+pub(crate) struct YAttrs(pub(crate) Attrs);
+
+impl From<Attrs> for YAttrs {
+    fn from(value: Attrs) -> Self {
+        YAttrs { 0: value }
+    }
+}
+
+impl From<RHash> for YAttrs {
+    fn from(value: RHash) -> Self {
+        let mut attrs = Attrs::new();
+
+        value
+            .foreach(|key: Value, value: Value| {
+                let k = key.to_string();
+                let yvalue = YValue::from(value);
+                let avalue = Any::from(yvalue);
+                attrs.insert(Rc::from(k), avalue);
+
+                Ok(Continue)
+            })
+            .expect("cannot iterate attributes hash");
+
+        YAttrs { 0: attrs }
+    }
+}
+
+impl Deref for YAttrs {
+    type Target = Attrs;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for YAttrs {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

data/ext/yrb/src/ydoc.rs

@@ -0,0 +1,39 @@
+use crate::YTransaction;
+use magnus::{Error, Integer, Value};
+use std::cell::RefCell;
+use yrs::updates::decoder::Decode;
+use yrs::{Doc, OffsetKind, Options, StateVector};
+
+#[magnus::wrap(class = "Y::Doc")]
+pub(crate) struct YDoc(pub(crate) RefCell<Doc>);
+
+impl YDoc {
+    pub(crate) fn ydoc_new(client_id: &[Value]) -> Self {
+        let mut options = Options::default();
+
+        if client_id.len() == 1 {
+            let value = client_id.first().unwrap();
+            options.client_id =
+                Integer::from_value(*value).unwrap().to_u64().unwrap();
+        }
+
+        options.offset_kind = OffsetKind::Utf32;
+
+        let doc = Doc::with_options(options);
+        Self(RefCell::new(doc))
+    }
+
+    pub(crate) fn ydoc_transact(&self) -> YTransaction {
+        let transaction = self.0.borrow().transact();
+
+        return YTransaction(RefCell::new(transaction));
+    }
+    pub(crate) fn ydoc_encode_diff_v1(
+        &self,
+        state_vector: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        return StateVector::decode_v1(&*state_vector)
+            .map(|sv| self.0.borrow().encode_state_as_update_v1(&sv))
+            .map_err(|_e| Error::runtime_error("cannot encode diff"));
+    }
+}

data/ext/yrb/src/ymap.rs

@@ -0,0 +1,165 @@
+use crate::utils::indifferent_hash_key;
+use crate::yvalue::YValue;
+use crate::YTransaction;
+use lib0::any::Any;
+use magnus::block::Proc;
+use magnus::{Error, RArray, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::{EntryChange, Value as YrsValue};
+use yrs::Map;
+
+#[magnus::wrap(class = "Y::Map")]
+pub(crate) struct YMap(pub(crate) RefCell<Map>);
+
+impl YMap {
+    pub(crate) fn ymap_clear(&self, transaction: &YTransaction) {
+        self.0.borrow_mut().clear(&mut *transaction.0.borrow_mut());
+    }
+    pub(crate) fn ymap_contains(&self, key: Value) -> bool {
+        match indifferent_hash_key(key) {
+            None => false,
+            Some(k) => self.0.borrow().contains(&*k)
+        }
+    }
+    pub(crate) fn ymap_each(&self, proc: Proc) {
+        self.0.borrow().iter().for_each(|(key, val)| {
+            let k = key.to_string();
+            let v = *YValue::from(val).0.borrow();
+            proc.call::<(String, Value), Value>((k, v))
+                .expect("cannot iterate map");
+        });
+    }
+    pub(crate) fn ymap_get(&self, key: Value) -> Option<Value> {
+        indifferent_hash_key(key)
+            .map(|k| self.0.borrow().get(&*k))
+            .map(|v| v.unwrap_or(YrsValue::Any(Any::Undefined)))
+            .map(|v| *YValue::from(v).0.borrow())
+    }
+    pub(crate) fn ymap_insert(
+        &self,
+        transaction: &YTransaction,
+        key: Value,
+        value: Value
+    ) -> Result<(), Error> {
+        match indifferent_hash_key(key) {
+            None => Err(Error::runtime_error(
+                "invalid key type, make sure it is either a Symbol or a String"
+            )),
+            Some(k) => {
+                let v = Any::from(YValue::from(value));
+                self.0.borrow_mut().insert(
+                    &mut *transaction.0.borrow_mut(),
+                    k,
+                    v
+                );
+
+                Ok(())
+            }
+        }
+    }
+    pub(crate) fn ymap_observe(&self, block: Proc) -> u32 {
+        let change_inserted = Symbol::new("inserted").as_static();
+        let change_updated = Symbol::new("updated").as_static();
+        let change_removed = Symbol::new("removed").as_static();
+
+        self.0
+            .borrow_mut()
+            .observe(move |transaction, map_event| {
+                let delta = map_event.keys(transaction);
+                let changes = RArray::with_capacity(delta.len());
+
+                for (key, change) in delta {
+                    match change {
+                        EntryChange::Inserted(v) => {
+                            let h = RHash::new();
+                            h.aset(
+                                Symbol::new(&key.to_string()),
+                                *YValue::from(v.clone()).0.borrow()
+                            )
+                            .expect("cannot add change::inserted");
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_inserted, h)
+                                .expect("cannot add change::inserted");
+
+                            changes
+                                .push(payload)
+                                .expect("cannot push changes::payload");
+                        }
+                        EntryChange::Updated(old, new) => {
+                            let values = RArray::with_capacity(2);
+                            values
+                                .push(*YValue::from(old.clone()).0.borrow())
+                                .expect("cannot push change::updated");
+                            values
+                                .push(*YValue::from(new.clone()).0.borrow())
+                                .expect("cannot push change::updated");
+
+                            let h = RHash::new();
+                            h.aset(Symbol::new(&key.to_string()), values)
+                                .expect("cannot push change::updated");
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_updated, h)
+                                .expect("cannot push change::updated");
+
+                            changes
+                                .push(payload)
+                                .expect("cannot push changes::payload");
+                        }
+                        EntryChange::Removed(v) => {
+                            let h = RHash::new();
+                            h.aset(
+                                Symbol::new(&key.to_string()),
+                                *YValue::from(v.clone()).0.borrow()
+                            )
+                            .expect("cannot push change::removed");
+
+                            let payload = RHash::new();
+                            payload
+                                .aset(change_removed, h)
+                                .expect("cannot push change::removed");
+
+                            changes
+                                .push(payload)
+                                .expect("cannot push changes::payload");
+                        }
+                    }
+                }
+
+                block
+                    .call::<(RArray,), Value>((changes,))
+                    .expect("cannot call block");
+            })
+            .into()
+    }
+    pub(crate) fn ymap_remove(
+        &self,
+        transaction: &YTransaction,
+        key: Value
+    ) -> Option<Value> {
+        indifferent_hash_key(key)
+            .map(|k| {
+                self.0
+                    .borrow()
+                    .remove(&mut *transaction.0.borrow_mut(), &*k)
+            })
+            .map(|v| v.unwrap_or(YrsValue::Any(Any::Undefined)))
+            .map(|v| *YValue::from(v).0.borrow())
+    }
+    pub(crate) fn ymap_size(&self) -> u32 {
+        self.0.borrow().len()
+    }
+    pub(crate) fn ymap_to_h(&self) -> RHash {
+        RHash::from_iter(
+            self.0.borrow().iter().map(move |(k, v)| {
+                (k.to_string(), *YValue::from(v).0.borrow())
+            })
+        )
+    }
+    pub(crate) fn ymap_unobserve(&self, subscription_id: u32) {
+        self.0.borrow_mut().unobserve(subscription_id);
+    }
+}

data/ext/yrb/src/ytext.rs

@@ -0,0 +1,228 @@
+use crate::yattrs::YAttrs;
+use crate::yvalue::YValue;
+use crate::YTransaction;
+use lib0::any::Any;
+use magnus::block::Proc;
+use magnus::value::Qnil;
+use magnus::{Error, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::Delta;
+use yrs::Text;
+
+#[magnus::wrap(class = "Y::Text")]
+pub(crate) struct YText(pub(crate) RefCell<Text>);
+
+impl YText {
+    pub(crate) fn ytext_format(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+        attrs: RHash
+    ) -> Result<(), Error> {
+        let a = YAttrs::from(attrs);
+        self.0.borrow_mut().format(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            length,
+            a.0
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_insert(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        chunk: String
+    ) -> Result<(), Error> {
+        self.0.borrow_mut().insert(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            &*chunk
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_insert_embed(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        content: Value
+    ) -> Result<(), Error> {
+        let yvalue = YValue::from(content);
+        let avalue = Any::from(yvalue);
+
+        self.0.borrow_mut().insert_embed(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            avalue
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_insert_embed_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        embed: Value,
+        attrs: RHash
+    ) -> Result<(), Error> {
+        let yvalue = YValue::from(embed);
+        let avalue = Any::from(yvalue);
+
+        let a = YAttrs::from(attrs);
+
+        self.0.borrow_mut().insert_embed_with_attributes(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            avalue,
+            a.0
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_insert_with_attributes(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        chunk: String,
+        attrs: RHash
+    ) -> Result<(), Error> {
+        let a = YAttrs::from(attrs);
+
+        self.0.borrow_mut().insert_with_attributes(
+            &mut *transaction.0.borrow_mut(),
+            index,
+            &*chunk,
+            a.0
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_length(&self) -> u32 {
+        self.0.borrow().len()
+    }
+    pub(crate) fn ytext_observe(&self, block: Proc) -> Result<u32, Error> {
+        let delta_insert = Symbol::new("insert").to_static();
+        let delta_retain = Symbol::new("retain").to_static();
+        let delta_delete = Symbol::new("delete").to_static();
+        let attributes = Symbol::new("attributes").to_static();
+
+        // let mut error: Option<Error> = None;
+
+        let subscription_id = self
+            .0
+            .borrow_mut()
+            .observe(move |transaction, text_event| {
+                let delta = text_event.delta(transaction);
+                let (_, errors): (Vec<_>, Vec<_>) = delta
+                    .iter()
+                    .map(|change| match change {
+                        Delta::Inserted(value, attrs) => {
+                            let yvalue = YValue::from(value.clone());
+                            let payload = RHash::new();
+                            payload
+                                .aset(delta_insert, yvalue.0.into_inner())
+                                .map(|()| match attrs {
+                                    Some(a) => a
+                                        .clone()
+                                        .into_iter()
+                                        .map(|(key, val)| {
+                                            let yvalue = YValue::from(val);
+                                            (
+                                                key.to_string(),
+                                                yvalue.0.into_inner()
+                                            )
+                                        })
+                                        .collect::<RHash>()
+                                        .into(),
+                                    None => None
+                                })
+                                .map(|attrs_hash| {
+                                    attrs_hash
+                                        .map(|v| payload.aset(attributes, v))
+                                })
+                                .map(|_| {
+                                    block.call::<(RHash,), Qnil>((payload,))
+                                })
+                        }
+                        Delta::Retain(index, attrs) => {
+                            let payload = RHash::new();
+
+                            let yvalue = YValue::from(index.clone());
+
+                            payload
+                                .aset(delta_retain, yvalue.0.into_inner())
+                                .map(|()| match attrs {
+                                    Some(a) => a
+                                        .clone()
+                                        .into_iter()
+                                        .map(|(key, val)| {
+                                            let yvalue = YValue::from(val);
+                                            (
+                                                key.to_string(),
+                                                yvalue.0.into_inner()
+                                            )
+                                        })
+                                        .collect::<RHash>()
+                                        .into(),
+                                    None => None
+                                })
+                                .map(|attrs_hash| {
+                                    attrs_hash
+                                        .map(|v| payload.aset(attributes, v))
+                                })
+                                .map(|_| {
+                                    block.call::<(RHash,), Qnil>((payload,))
+                                })
+                        }
+                        Delta::Deleted(index) => {
+                            let payload = RHash::new();
+
+                            let yvalue = YValue::from(index.clone());
+
+                            payload
+                                .aset(delta_delete, yvalue.0.into_inner())
+                                .map(|()| {
+                                    block.call::<(RHash,), Qnil>((payload,))
+                                })
+                        }
+                    })
+                    .partition(Result::is_ok);
+
+                if errors.len() > 0 {
+                    // todo: make sure we respect errors and let the method fail by
+                    //  by returning a Result containing an Error
+                }
+            })
+            .into();
+
+        Ok(subscription_id)
+    }
+    pub(crate) fn ytext_push(&self, transaction: &YTransaction, chunk: String) {
+        self.0
+            .borrow_mut()
+            .push(&mut *transaction.0.borrow_mut(), &*chunk);
+    }
+    pub(crate) fn ytext_remove_range(
+        &self,
+        transaction: &YTransaction,
+        start: u32,
+        length: u32
+    ) -> Result<(), Error> {
+        self.0.borrow_mut().remove_range(
+            &mut *transaction.0.borrow_mut(),
+            start,
+            length
+        );
+
+        Ok(())
+    }
+    pub(crate) fn ytext_to_s(&self) -> String {
+        return self.0.borrow().to_string();
+    }
+    pub(crate) fn ytext_unobserve(&self, subscription_id: u32) {
+        return self.0.borrow_mut().unobserve(subscription_id);
+    }
+}