y-rb 0.1.7-x86_64-linux-musl → 0.3.0-x86_64-linux-musl

data/ext/yrb/src/yarray.rs

@@ -15,7 +15,7 @@ pub(crate) struct YArray(pub(crate) RefCell<Array>);
 unsafe impl Send for YArray {}
 
 impl YArray {
-    pub(crate) fn yarray_each(&self, block: Proc) -> () {
+    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(),);
@@ -26,37 +26,28 @@ impl YArray {
         let v = self.0.borrow().get(index).unwrap();
         YValue::from(v).into()
     }
-    pub(crate) fn yarray_insert(
-        &self,
-        transaction: &YTransaction,
-        index: u32,
-        value: Value
-    ) -> () {
+    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
-        );
+        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
-    ) -> () {
+        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
-        );
+        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();
@@ -82,30 +73,28 @@ impl YArray {
                             Change::Added(v) => {
                                 let values = v
                                     .iter()
-                                    .map(|v| {
-                                        <YValue as Into<Value>>::into(
-                                            YValue::from(v.clone())
-                                        )
-                                    })
+                                    .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))
+                            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)
+                            Err(e) => Err(e),
                         }
                     })
                     .partition(Result::is_ok);
 
-                if errors.len() == 0 {
+                if errors.is_empty() {
                     let args = (RArray::from_vec(
-                        changes.into_iter().map(Result::unwrap).collect()
+                        changes.into_iter().map(Result::unwrap).collect(),
                     ),);
                     let _ = block.call::<(RArray,), Qnil>(args);
                     // todo: make sure we respect the result and bubble up the
@@ -119,48 +108,29 @@ impl YArray {
 
         Ok(subscription_id)
     }
-    pub(crate) fn yarray_push_back(
-        &self,
-        transaction: &YTransaction,
-        value: Value
-    ) -> () {
+    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
-    ) -> () {
+    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
-    ) -> () {
+    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_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
@@ -170,9 +140,9 @@ impl YArray {
             .map(|v| YValue::from(v).into())
             .collect::<Vec<Value>>();
 
-        return RArray::from_vec(arr);
+        RArray::from_vec(arr)
     }
-    pub(crate) fn yarray_unobserve(&self, subscription_id: u32) -> () {
+    pub(crate) fn yarray_unobserve(&self, subscription_id: u32) {
         self.0.borrow_mut().unobserve(subscription_id);
     }
 }

data/ext/yrb/src/yattrs.rs

@@ -10,7 +10,7 @@ pub(crate) struct YAttrs(pub(crate) Attrs);
 
 impl From<Attrs> for YAttrs {
     fn from(value: Attrs) -> Self {
-        YAttrs { 0: value }
+        YAttrs(value)
     }
 }
 
@@ -29,7 +29,7 @@ impl From<RHash> for YAttrs {
             })
             .expect("cannot iterate attributes hash");
 
-        YAttrs { 0: attrs }
+        YAttrs(attrs)
     }
 }
 

data/ext/yrb/src/yawareness.rs

@@ -0,0 +1,155 @@
+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: &YAwarenessUpdate) -> Result<(), Error> {
+        update.decode().and_then(|value| {
+            self.0
+                .borrow_mut()
+                .apply_update(value)
+                .map_err(|_error| Error::runtime_error("cannot decode 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<YAwarenessUpdate, Error> {
+        self.0
+            .borrow_mut()
+            .update()
+            .map(YAwarenessUpdate::from)
+            .map_err(|_error| Error::runtime_error("cannot update awareness"))
+    }
+
+    pub(crate) fn yawareness_update_with_clients(
+        &self,
+        clients: Vec<ClientID>,
+    ) -> Result<YAwarenessUpdate, Error> {
+        self.0
+            .borrow_mut()
+            .update_with_clients(clients)
+            .map(YAwarenessUpdate::from)
+            .map_err(|_error| Error::runtime_error("cannot update awareness with clients"))
+    }
+}
+
+impl From<Awareness> for YAwareness {
+    fn from(value: Awareness) -> Self {
+        Self(RefCell::from(value))
+    }
+}
+
+#[magnus::wrap(class = "Y::AwarenessUpdate")]
+pub(crate) struct YAwarenessUpdate(pub(crate) Vec<u8>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YAwarenessUpdate {}
+
+impl YAwarenessUpdate {
+    pub(crate) fn decode(&self) -> Result<AwarenessUpdate, Error> {
+        AwarenessUpdate::decode_v1(self.0.borrow())
+            .map_err(|_error| Error::runtime_error("cannot decode awareness update"))
+    }
+    pub(crate) fn yawareness_update_encode(&self) -> Vec<u8> {
+        self.0.to_vec()
+    }
+}
+
+impl From<AwarenessUpdate> for YAwarenessUpdate {
+    fn from(value: AwarenessUpdate) -> Self {
+        YAwarenessUpdate(value.encode_v1())
+    }
+}
+
+impl From<Vec<u8>> for YAwarenessUpdate {
+    fn from(value: Vec<u8>) -> Self {
+        YAwarenessUpdate(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

@@ -13,8 +13,7 @@ impl YDoc {
 
         if client_id.len() == 1 {
             let value = client_id.first().unwrap();
-            options.client_id =
-                Integer::from_value(*value).unwrap().to_u64().unwrap();
+            options.client_id = Integer::from_value(*value).unwrap().to_u64().unwrap();
         }
 
         options.offset_kind = OffsetKind::Utf32;
@@ -26,14 +25,11 @@ impl YDoc {
     pub(crate) fn ydoc_transact(&self) -> YTransaction {
         let transaction = self.0.borrow().transact();
 
-        return YTransaction(RefCell::new(transaction));
+        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)
+    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"));
+            .map_err(|_e| Error::runtime_error("cannot encode diff"))
     }
 }

data/ext/yrb/src/ymap.rs

@@ -21,7 +21,7 @@ impl YMap {
     pub(crate) fn ymap_contains(&self, key: Value) -> bool {
         match indifferent_hash_key(key) {
             None => false,
-            Some(k) => self.0.borrow().contains(&*k)
+            Some(k) => self.0.borrow().contains(&*k),
         }
     }
     pub(crate) fn ymap_each(&self, proc: Proc) {
@@ -42,19 +42,17 @@ impl YMap {
         &self,
         transaction: &YTransaction,
         key: Value,
-        value: 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"
+                "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
-                );
+                self.0
+                    .borrow_mut()
+                    .insert(&mut *transaction.0.borrow_mut(), k, v);
 
                 Ok(())
             }
@@ -75,20 +73,15 @@ impl YMap {
                     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");
+                            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");
+                            changes.push(payload).expect("cannot push changes::payload");
                         }
                         EntryChange::Updated(old, new) => {
                             let values = RArray::with_capacity(2);
@@ -100,7 +93,7 @@ impl YMap {
                                 .expect("cannot push change::updated");
 
                             let h = RHash::new();
-                            h.aset(Symbol::new(&key.to_string()), values)
+                            h.aset(Symbol::new(key), values)
                                 .expect("cannot push change::updated");
 
                             let payload = RHash::new();
@@ -108,26 +101,19 @@ impl YMap {
                                 .aset(change_updated, h)
                                 .expect("cannot push change::updated");
 
-                            changes
-                                .push(payload)
-                                .expect("cannot push changes::payload");
+                            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");
+                            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");
+                            changes.push(payload).expect("cannot push changes::payload");
                         }
                     }
                 }
@@ -138,11 +124,7 @@ impl YMap {
             })
             .into()
     }
-    pub(crate) fn ymap_remove(
-        &self,
-        transaction: &YTransaction,
-        key: Value
-    ) -> Option<Value> {
+    pub(crate) fn ymap_remove(&self, transaction: &YTransaction, key: Value) -> Option<Value> {
         indifferent_hash_key(key)
             .map(|k| {
                 self.0
@@ -157,9 +139,10 @@ impl YMap {
     }
     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())
-            })
+            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) {

data/ext/yrb/src/ytext.rs

@@ -21,15 +21,12 @@ impl YText {
         transaction: &YTransaction,
         index: u32,
         length: u32,
-        attrs: RHash
+        attrs: RHash,
     ) -> Result<(), Error> {
         let a = YAttrs::from(attrs);
-        self.0.borrow_mut().format(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            length,
-            a.0
-        );
+        self.0
+            .borrow_mut()
+            .format(&mut *transaction.0.borrow_mut(), index, length, a.0);
 
         Ok(())
     }
@@ -37,13 +34,11 @@ impl YText {
         &self,
         transaction: &YTransaction,
         index: u32,
-        chunk: String
+        chunk: String,
     ) -> Result<(), Error> {
-        self.0.borrow_mut().insert(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            &*chunk
-        );
+        self.0
+            .borrow_mut()
+            .insert(&mut *transaction.0.borrow_mut(), index, &*chunk);
 
         Ok(())
     }
@@ -51,16 +46,14 @@ impl YText {
         &self,
         transaction: &YTransaction,
         index: u32,
-        content: Value
+        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
-        );
+        self.0
+            .borrow_mut()
+            .insert_embed(&mut *transaction.0.borrow_mut(), index, avalue);
 
         Ok(())
     }
@@ -69,7 +62,7 @@ impl YText {
         transaction: &YTransaction,
         index: u32,
         embed: Value,
-        attrs: RHash
+        attrs: RHash,
     ) -> Result<(), Error> {
         let yvalue = YValue::from(embed);
         let avalue = Any::from(yvalue);
@@ -80,7 +73,7 @@ impl YText {
             &mut *transaction.0.borrow_mut(),
             index,
             avalue,
-            a.0
+            a.0,
         );
 
         Ok(())
@@ -90,7 +83,7 @@ impl YText {
         transaction: &YTransaction,
         index: u32,
         chunk: String,
-        attrs: RHash
+        attrs: RHash,
     ) -> Result<(), Error> {
         let a = YAttrs::from(attrs);
 
@@ -98,7 +91,7 @@ impl YText {
             &mut *transaction.0.borrow_mut(),
             index,
             &*chunk,
-            a.0
+            a.0,
         );
 
         Ok(())
@@ -133,27 +126,19 @@ impl YText {
                                         .into_iter()
                                         .map(|(key, val)| {
                                             let yvalue = YValue::from(val);
-                                            (
-                                                key.to_string(),
-                                                yvalue.0.into_inner()
-                                            )
+                                            (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,))
+                                    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());
+                            let yvalue = YValue::from(*index);
 
                             payload
                                 .aset(delta_retain, yvalue.0.into_inner())
@@ -163,38 +148,28 @@ impl YText {
                                         .into_iter()
                                         .map(|(key, val)| {
                                             let yvalue = YValue::from(val);
-                                            (
-                                                key.to_string(),
-                                                yvalue.0.into_inner()
-                                            )
+                                            (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,))
+                                    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());
+                            let yvalue = YValue::from(*index);
 
                             payload
                                 .aset(delta_delete, yvalue.0.into_inner())
-                                .map(|()| {
-                                    block.call::<(RHash,), Qnil>((payload,))
-                                })
+                                .map(|()| block.call::<(RHash,), Qnil>((payload,)))
                         }
                     })
                     .partition(Result::is_ok);
 
-                if errors.len() > 0 {
+                if !errors.is_empty() {
                     // todo: make sure we respect errors and let the method fail by
                     //  by returning a Result containing an Error
                 }
@@ -212,13 +187,11 @@ impl YText {
         &self,
         transaction: &YTransaction,
         start: u32,
-        length: u32
+        length: u32,
     ) -> Result<(), Error> {
-        self.0.borrow_mut().remove_range(
-            &mut *transaction.0.borrow_mut(),
-            start,
-            length
-        );
+        self.0
+            .borrow_mut()
+            .remove_range(&mut *transaction.0.borrow_mut(), start, length);
 
         Ok(())
     }