y-rb 0.6.0-x86_64-linux-gnu

data/ext/yrb/src/utils.rs

@@ -0,0 +1,64 @@
+use crate::yvalue::YValue;
+use magnus::r_hash::ForEach::Continue;
+use magnus::{exception, Error, RArray, RHash, RString, Symbol, Value};
+use std::sync::Arc;
+use yrs::types::{Attrs, Value as YrsValue};
+use yrs::{Any, Array, Map, TransactionMut};
+
+#[derive(Debug, Clone)]
+pub(crate) struct TypeConversionError;
+
+pub(crate) fn indifferent_hash_key(key: Value) -> Option<String> {
+    RString::from_value(key)
+        .map(|v| v.to_string().unwrap())
+        .or_else(|| Symbol::from_value(key).map(|v| v.name().unwrap().to_string()))
+}
+
+pub(crate) fn map_rhash_to_attrs(hash: RHash) -> Result<Attrs, Error> {
+    let mut a: Attrs = Default::default();
+
+    let result = hash.foreach(|key: Value, value: Value| {
+        let k = Arc::from(key.to_string());
+        let v = Any::from(YValue::from(value));
+
+        a.insert(k, v);
+
+        Ok(Continue)
+    });
+
+    if result.is_err() {
+        return Err(Error::new(
+            exception::runtime_error(),
+            "could not map hash to attrs",
+        ));
+    }
+
+    Ok(a)
+}
+
+pub(crate) fn convert_yvalue_to_ruby_value(value: YrsValue, tx: &TransactionMut) -> YValue {
+    match value {
+        YrsValue::Any(val) => YValue::from(val),
+        YrsValue::YText(text) => YValue::from(text),
+        YrsValue::YXmlElement(el) => YValue::from(el),
+        YrsValue::YXmlText(text) => YValue::from(text),
+        YrsValue::YArray(val) => {
+            let arr = RArray::new();
+            for item in val.iter(tx) {
+                let val = convert_yvalue_to_ruby_value(item.clone(), tx);
+                let val = *val.0.borrow();
+                arr.push(val).expect("cannot push item event to array");
+            }
+            YValue::from(arr)
+        }
+        YrsValue::YMap(val) => {
+            let iter = val.iter(tx).map(|(key, val)| {
+                let val = convert_yvalue_to_ruby_value(val.clone(), tx);
+                let val = val.0.into_inner();
+                (key, val)
+            });
+            YValue::from(RHash::from_iter(iter))
+        }
+        v => panic!("cannot map given yrs values to yvalue: {:?}", v),
+    }
+}

data/ext/yrb/src/yany.rs

@@ -0,0 +1,46 @@
+use magnus::r_string::IntoRString;
+use magnus::value::ReprValue;
+use magnus::{value, IntoValue, RArray, RHash, RString, Value};
+use std::borrow::Borrow;
+use std::ops::{Deref, DerefMut};
+use yrs::Any;
+
+pub(crate) struct YAny(pub(crate) Any);
+
+impl Deref for YAny {
+    type Target = Any;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for YAny {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl TryInto<Value> for YAny {
+    type Error = ();
+
+    fn try_into(self) -> Result<Value, Self::Error> {
+        return match self.0 {
+            Any::Array(_v) => {
+                let arr = RArray::new();
+                Ok(arr.as_value())
+            }
+            Any::Map(_v) => {
+                let hash = RHash::new();
+                Ok(hash.as_value())
+            }
+            Any::Null => Ok(value::qnil().as_value()),
+            Any::Undefined => Ok(value::qnil().as_value()),
+            Any::Bool(v) => Ok(v.into_value()),
+            Any::Number(v) => Ok(v.into_value()),
+            Any::BigInt(v) => Ok(v.into_value()),
+            Any::String(v) => Ok(v.into_r_string().as_value()),
+            Any::Buffer(v) => Ok(RString::from_slice(v.borrow()).as_value()),
+        };
+    }
+}

data/ext/yrb/src/yarray.rs

@@ -0,0 +1,191 @@
+use crate::utils::convert_yvalue_to_ruby_value;
+use crate::ytransaction::YTransaction;
+use crate::yvalue::YValue;
+use magnus::block::Proc;
+use magnus::value::Qnil;
+use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
+use std::cell::RefCell;
+use yrs::types::Change;
+use yrs::{Any, Array, ArrayRef, Observable};
+
+#[magnus::wrap(class = "Y::Array")]
+pub(crate) struct YArray(pub(crate) RefCell<ArrayRef>);
+
+/// 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, transaction: &YTransaction, block: Proc) -> Result<(), Error> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let arr = self.0.borrow();
+        arr.iter(tx).for_each(|val| {
+            let yvalue = *convert_yvalue_to_ruby_value(val, tx).0.borrow();
+            let args = (yvalue,);
+            let _ = block.call::<(Value,), Qnil>(args);
+        });
+
+        Ok(())
+    }
+
+    pub(crate) fn yarray_get(&self, transaction: &YTransaction, index: u32) -> Value {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let arr = self.0.borrow();
+        let v = arr.get(tx, index).unwrap();
+        *convert_yvalue_to_ruby_value(v, tx).0.borrow()
+    }
+    pub(crate) fn yarray_insert(&self, transaction: &YTransaction, index: u32, value: Value) {
+        let yvalue = YValue::from(value);
+        let avalue = Any::from(yvalue);
+
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.insert(tx, index, avalue);
+    }
+    pub(crate) fn yarray_insert_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        values: RArray,
+    ) {
+        let arr = self.0.borrow_mut();
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let add_values: Vec<Any> = values
+            .each()
+            .into_iter()
+            .map(|value| YValue::from(value.unwrap()).into())
+            .collect();
+
+        arr.insert_range(tx, index, add_values)
+    }
+    pub(crate) fn yarray_length(&self, transaction: &YTransaction) -> u32 {
+        let arr = self.0.borrow();
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        arr.len(tx)
+    }
+    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, (*position).into_value())
+                            }
+                            Change::Removed(position) => {
+                                payload.aset(change_removed, (*position).into_value())
+                            }
+                        };
+
+                        match result {
+                            Ok(()) => Ok(payload),
+                            Err(e) => Err(e),
+                        }
+                    })
+                    .partition(Result::is_ok);
+
+                if errors.is_empty() {
+                    let args_changes = RArray::new();
+                    for change in changes.iter() {
+                        let c = *change.as_ref().unwrap();
+                        args_changes
+                            .push(c)
+                            .expect("cannot push change event to args");
+                    }
+
+                    let args = (args_changes,);
+                    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);
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().push_back(tx, avalue);
+    }
+    pub(crate) fn yarray_push_front(&self, transaction: &YTransaction, value: Value) {
+        let yvalue = YValue::from(value);
+        let avalue = Any::from(yvalue);
+
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.push_front(tx, avalue);
+    }
+    pub(crate) fn yarray_remove(&self, transaction: &YTransaction, index: u32) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.remove(tx, index)
+    }
+    pub(crate) fn yarray_remove_range(&self, transaction: &YTransaction, index: u32, len: u32) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let arr = self.0.borrow_mut();
+        arr.remove_range(tx, index, len)
+    }
+    pub(crate) fn yarray_to_a(&self, transaction: &YTransaction) -> RArray {
+        let arr = self.0.borrow();
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let r_arr = RArray::new();
+        for item in arr.iter(tx) {
+            let r_val = YValue::from(item);
+            let r_val = *r_val.0.borrow();
+            r_arr.push(r_val).expect("cannot push item event to array");
+        }
+        r_arr
+    }
+    pub(crate) fn yarray_unobserve(&self, subscription_id: u32) {
+        self.0.borrow_mut().unobserve(subscription_id);
+    }
+}
+
+impl From<ArrayRef> for YArray {
+    fn from(v: ArrayRef) -> Self {
+        YArray(RefCell::from(v))
+    }
+}

data/ext/yrb/src/yattrs.rs

@@ -0,0 +1,39 @@
+use crate::yvalue::YValue;
+use magnus::r_hash::ForEach::Continue;
+use magnus::{RHash, Value};
+use std::cell::RefCell;
+use std::sync::Arc;
+use yrs::types::Attrs;
+use yrs::Any;
+
+#[magnus::wrap(class = "Y::Attrs")]
+#[derive(Clone)]
+pub(crate) struct YAttrs(pub(crate) RefCell<Attrs>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YAttrs {}
+
+impl From<Attrs> for YAttrs {
+    fn from(value: Attrs) -> Self {
+        YAttrs(RefCell::from(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(Arc::from(k), avalue);
+
+                Ok(Continue)
+            })
+            .expect("cannot iterate attributes hash");
+
+        YAttrs(RefCell::from(attrs))
+    }
+}

data/ext/yrb/src/yawareness.rs

@@ -0,0 +1,151 @@
+use magnus::{block::Proc, exception, Error, Value};
+use std::borrow::Borrow;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use y_sync::awareness::{Awareness, AwarenessUpdate, Event, UpdateSubscription};
+use yrs::block::ClientID;
+use yrs::updates::decoder::Decode;
+use yrs::updates::encoder::Encode;
+use yrs::{Doc, OffsetKind, Options};
+
+#[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 mut options = Options {
+            offset_kind: OffsetKind::Utf16,
+            ..Default::default()
+        };
+        options.offset_kind = OffsetKind::Utf16;
+
+        let doc = Doc::with_options(options);
+
+        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::new(exception::runtime_error(), "cannot decode update"))
+            .and_then(|value| {
+                self.0.borrow_mut().apply_update(value).map_err(|_error| {
+                    Error::new(exception::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) -> YAwarenessSubscription {
+        let subscription = 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");
+        });
+
+        // we need to make sure the event handler "survives" and is not being
+        // dropped after leaving this scope, so we pass it back to Ruby.
+        YAwarenessSubscription::from(subscription)
+    }
+
+    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::new(
+                    exception::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::new(
+                    exception::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())
+    }
+}
+
+#[magnus::wrap(class = "Y::AwarenessEvent")]
+pub(crate) struct YAwarenessSubscription(UpdateSubscription);
+
+unsafe impl Send for YAwarenessSubscription {}
+
+impl YAwarenessSubscription {}
+
+impl From<UpdateSubscription> for YAwarenessSubscription {
+    fn from(v: UpdateSubscription) -> Self {
+        YAwarenessSubscription(v)
+    }
+}

data/ext/yrb/src/ydiff.rs

@@ -0,0 +1,19 @@
+use magnus::{IntoValue, RHash, Value};
+
+unsafe impl Send for YDiff {}
+
+#[magnus::wrap(class = "Y::Diff")]
+pub(crate) struct YDiff {
+    pub(crate) ydiff_insert: Value,
+    pub(crate) ydiff_attrs: Option<RHash>,
+}
+
+impl YDiff {
+    pub(crate) fn ydiff_insert(&self) -> Value {
+        self.ydiff_insert
+    }
+
+    pub(crate) fn ydiff_attrs(&self) -> Option<Value> {
+        self.ydiff_attrs.as_ref().map(|value| value.into_value())
+    }
+}

data/ext/yrb/src/ydoc.rs

@@ -0,0 +1,113 @@
+use crate::yarray::YArray;
+use crate::ymap::YMap;
+use crate::ytext::YText;
+use crate::yxml_element::YXmlElement;
+use crate::yxml_fragment::YXmlFragment;
+use crate::yxml_text::YXmlText;
+use crate::YTransaction;
+use magnus::block::Proc;
+use magnus::{exception::runtime_error, Error, Integer, RArray, Value};
+use std::borrow::Borrow;
+use std::cell::RefCell;
+use yrs::updates::decoder::Decode;
+use yrs::updates::encoder::{Encoder, EncoderV2};
+use yrs::{Doc, OffsetKind, Options, ReadTxn, StateVector, SubscriptionId, Transact};
+
+#[magnus::wrap(class = "Y::Doc")]
+pub(crate) struct YDoc(pub(crate) RefCell<Doc>);
+
+unsafe impl Send for YDoc {}
+
+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::Utf16;
+
+        let doc = Doc::with_options(options);
+        Self(RefCell::new(doc))
+    }
+
+    pub(crate) fn ydoc_encode_diff_v1(
+        &self,
+        transaction: &YTransaction,
+        state_vector: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        StateVector::decode_v1(state_vector.borrow())
+            .map(|sv| tx.encode_diff_v1(&sv))
+            .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
+    }
+
+    pub(crate) fn ydoc_encode_diff_v2(
+        &self,
+        transaction: &YTransaction,
+        state_vector: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+        let mut encoder = EncoderV2::new();
+
+        StateVector::decode_v2(state_vector.borrow())
+            .map(|sv| tx.encode_diff(&sv, &mut encoder))
+            .map(|_| encoder.to_vec())
+            .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
+    }
+
+    pub(crate) fn ydoc_get_or_insert_array(&self, name: String) -> YArray {
+        let array_ref = self.0.borrow().get_or_insert_array(name.as_str());
+        YArray::from(array_ref)
+    }
+
+    pub(crate) fn ydoc_get_or_insert_map(&self, name: String) -> YMap {
+        let map_ref = self.0.borrow().get_or_insert_map(name.as_str());
+        YMap::from(map_ref)
+    }
+
+    pub(crate) fn ydoc_get_or_insert_text(&self, name: String) -> YText {
+        let text_ref = self.0.borrow().get_or_insert_text(name.as_str());
+        YText::from(text_ref)
+    }
+
+    pub(crate) fn ydoc_get_or_insert_xml_element(&self, name: String) -> YXmlElement {
+        let xml_element_ref = self.0.borrow_mut().get_or_insert_xml_element(name.as_str());
+        YXmlElement::from(xml_element_ref) // ::into() maps to YXmlFragment instead of YXmlElement :-(
+    }
+
+    pub(crate) fn ydoc_get_or_insert_xml_fragment(&self, name: String) -> YXmlFragment {
+        let xml_fragment_ref = self.0.borrow().get_or_insert_xml_fragment(name.as_str());
+        YXmlFragment::from(xml_fragment_ref)
+    }
+
+    pub(crate) fn ydoc_get_or_insert_xml_text(&self, name: String) -> YXmlText {
+        let xml_text_ref = self.0.borrow().get_or_insert_xml_text(name.as_str());
+        YXmlText::from(xml_text_ref)
+    }
+
+    pub(crate) fn ydoc_transact(&self) -> YTransaction {
+        let doc = self.0.borrow();
+        let transaction = doc.transact_mut();
+        YTransaction::from(transaction)
+    }
+
+    pub(crate) fn ydoc_observe_update(&self, block: Proc) -> Result<SubscriptionId, Error> {
+        self.0
+            .borrow()
+            .observe_update_v1(move |_tx, update_event| {
+                let update = update_event.update.to_vec();
+                let update = RArray::from_vec(update);
+
+                let args: (RArray,) = (update,);
+                block
+                    .call::<(RArray,), Value>(args)
+                    .expect("cannot call update block");
+            })
+            .map(|v| v.into())
+            .map_err(|err| Error::new(runtime_error(), err.to_string()))
+    }
+}