y-rb 0.3.2-x64-mingw-ucrt

data/ext/yrb/src/yarray.rs

@@ -0,0 +1,148 @@
+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>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YArray {}
+
+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.is_empty() {
+                    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>>();
+
+        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(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(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/yawareness.rs

@@ -0,0 +1,131 @@
+use crate::awareness::{Awareness, AwarenessUpdate, Event};
+use magnus::block::Proc;
+use magnus::{Error, Value};
+use std::borrow::Borrow;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use yrs::block::ClientID;
+use yrs::updates::decoder::Decode;
+use yrs::updates::encoder::Encode;
+use yrs::Doc;
+
+#[magnus::wrap(class = "Y::Awareness")]
+pub(crate) struct YAwareness(pub(crate) RefCell<Awareness>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YAwareness {}
+
+impl YAwareness {
+    pub(crate) fn yawareness_new() -> Self {
+        let doc = Doc::new();
+        let awareness = Awareness::new(doc);
+
+        Self(RefCell::new(awareness))
+    }
+
+    pub(crate) fn yawareness_apply_update(&self, update: Vec<u8>) -> Result<(), Error> {
+        AwarenessUpdate::decode_v1(update.as_slice())
+            .map_err(|_error| Error::runtime_error("cannot decode update"))
+            .and_then(|value| {
+                self.0
+                    .borrow_mut()
+                    .apply_update(value)
+                    .map_err(|_error| Error::runtime_error("cannot apply awareness update"))
+            })
+    }
+
+    pub(crate) fn yawareness_clean_local_state(&self) {
+        self.0.borrow_mut().clean_local_state();
+    }
+
+    pub(crate) fn yawareness_client_id(&self) -> ClientID {
+        self.0.borrow().client_id()
+    }
+
+    pub(crate) fn yawareness_clients(&self) -> HashMap<ClientID, String> {
+        self.0.borrow().clients().to_owned()
+    }
+
+    pub(crate) fn yawareness_local_state(&self) -> Option<String> {
+        self.0.borrow().local_state().map(|value| value.to_string())
+    }
+
+    pub(crate) fn yawareness_on_update(&self, block: Proc) -> Result<u32, Error> {
+        let subscription_id = self
+            .0
+            .borrow_mut()
+            .on_update(move |_awareness, event| {
+                let awareness_event = YAwarenessEvent::from(event);
+                let args = (awareness_event,);
+                block
+                    .call::<(YAwarenessEvent,), Value>(args)
+                    .expect("cannot call block: on_update");
+            })
+            .into();
+
+        Ok(subscription_id)
+    }
+
+    pub(crate) fn yawareness_remove_on_update(&self, subscription_id: u32) {
+        self.0.borrow_mut().remove_on_update(subscription_id)
+    }
+
+    pub(crate) fn yawareness_remove_state(&self, client_id: ClientID) {
+        self.0.borrow_mut().remove_state(client_id)
+    }
+
+    pub(crate) fn yawareness_set_local_state(&self, json: String) {
+        self.0.borrow_mut().set_local_state(json)
+    }
+
+    pub(crate) fn yawareness_update(&self) -> Result<Vec<u8>, Error> {
+        self.0
+            .borrow_mut()
+            .update()
+            .map(|update| update.encode_v1())
+            .map_err(|_error| Error::runtime_error("cannot create update for current state"))
+    }
+
+    pub(crate) fn yawareness_update_with_clients(
+        &self,
+        clients: Vec<ClientID>,
+    ) -> Result<Vec<u8>, Error> {
+        self.0
+            .borrow_mut()
+            .update_with_clients(clients)
+            .map(|update| update.encode_v1())
+            .map_err(|_error| {
+                Error::runtime_error("cannot create update for current state and given clients")
+            })
+    }
+}
+
+impl From<Awareness> for YAwareness {
+    fn from(value: Awareness) -> Self {
+        Self(RefCell::from(value))
+    }
+}
+
+#[magnus::wrap(class = "Y::AwarenessEvent")]
+pub(crate) struct YAwarenessEvent(Event);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YAwarenessEvent {}
+
+impl YAwarenessEvent {
+    pub(crate) fn added(&self) -> Vec<ClientID> {
+        self.0.borrow().added().to_vec()
+    }
+    pub(crate) fn updated(&self) -> Vec<ClientID> {
+        self.0.borrow().updated().to_vec()
+    }
+    pub(crate) fn removed(&self) -> Vec<ClientID> {
+        self.0.borrow().removed().to_vec()
+    }
+}
+
+impl From<&Event> for YAwarenessEvent {
+    fn from(value: &Event) -> Self {
+        Self(value.clone())
+    }
+}

data/ext/yrb/src/ydoc.rs

@@ -0,0 +1,35 @@
+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();
+
+        YTransaction(RefCell::new(transaction))
+    }
+    pub(crate) fn ydoc_encode_diff_v1(&self, state_vector: Vec<u8>) -> Result<Vec<u8>, Error> {
+        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,151 @@
+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>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YMap {}
+
+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), *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), 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), *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);
+    }
+}