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

data/ext/yrb/src/ytransaction.rs

@@ -16,10 +16,7 @@ pub(crate) struct YTransaction(pub(crate) RefCell<Transaction>);
 unsafe impl Send for YTransaction {}
 
 impl YTransaction {
-    pub(crate) fn ytransaction_apply_update(
-        &self,
-        update: Vec<u8>
-    ) -> Result<(), Error> {
+    pub(crate) fn ytransaction_apply_update(&self, update: Vec<u8>) -> Result<(), Error> {
         return Update::decode_v1(update.as_slice())
             .map(|u| self.0.borrow_mut().apply_update(u))
             .map_err(|_e| Error::runtime_error("cannot apply update"));
@@ -30,30 +27,27 @@ impl YTransaction {
     pub(crate) fn ytransaction_get_array(&self, name: String) -> YArray {
         let a = self.0.borrow_mut().get_array(&*name);
 
-        return YArray(RefCell::from(a));
+        YArray(RefCell::from(a))
     }
     pub(crate) fn ytransaction_get_map(&self, name: String) -> YMap {
         let m = self.0.borrow_mut().get_map(&*name);
 
-        return YMap(RefCell::from(m));
+        YMap(RefCell::from(m))
     }
     pub(crate) fn ytransaction_get_text(&self, name: String) -> YText {
         let t = self.0.borrow_mut().get_text(&*name);
 
-        return YText(RefCell::new(t));
+        YText(RefCell::new(t))
     }
-    pub(crate) fn ytransaction_get_xml_element(
-        &self,
-        name: String
-    ) -> YXmlElement {
+    pub(crate) fn ytransaction_get_xml_element(&self, name: String) -> YXmlElement {
         let el = self.0.borrow_mut().get_xml_element(&*name);
 
-        return YXmlElement(RefCell::new(el));
+        YXmlElement(RefCell::new(el))
     }
     pub(crate) fn ytransaction_get_xml_text(&self, name: String) -> YXmlText {
         let t = self.0.borrow_mut().get_xml_text(&*name);
 
-        return YXmlText(RefCell::new(t));
+        YXmlText(RefCell::new(t))
     }
     pub(crate) fn ytransaction_state_vector(&self) -> Vec<u8> {
         return self.0.borrow_mut().state_vector().encode_v1();

data/ext/yrb/src/yvalue.rs

@@ -2,15 +2,11 @@ use crate::{YText, YXmlElement, YXmlText};
 use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
 use magnus::value::Qnil;
-use magnus::{
-    class, Float, Integer, RArray, RHash, RString, Symbol, Value, QNIL
-};
+use magnus::{class, Float, Integer, RArray, RHash, RString, Symbol, Value, QNIL};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use yrs::types::Value as YrsValue;
-use yrs::{
-    Text as YrsText, XmlElement as YrsXmlElement, XmlText as YrsXmlText
-};
+use yrs::{Text as YrsText, XmlElement as YrsXmlElement, XmlText as YrsXmlText};
 
 pub(crate) struct YValue(pub(crate) RefCell<Value>);
 
@@ -77,7 +73,7 @@ impl From<YrsText> for YValue {
 impl From<YrsXmlElement> for YValue {
     fn from(value: YrsXmlElement) -> Self {
         YValue(RefCell::from(Value::from(YXmlElement(RefCell::from(
-            value
+            value,
         )))))
     }
 }
@@ -150,10 +146,7 @@ impl From<YrsValue> for YValue {
             //     *yvalue.0
             // }))),
             // YrsValue::YMap(val) => YValue::from(RHash::from_iter(val.iter())),
-            v => panic!(
-                "cannot map complex yrs values to yvalue: {}",
-                v.to_string()
-            )
+            v => panic!("cannot map complex yrs values to yvalue: {}", v.to_string()),
         }
     }
 }
@@ -215,6 +208,7 @@ impl From<YValue> for Any {
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl Into<Value> for YValue {
     fn into(self) -> Value {
         self.0.into_inner()

data/ext/yrb/src/yxml_element.rs

@@ -15,7 +15,7 @@ unsafe impl Send for YXmlElement {}
 
 impl YXmlElement {
     pub(crate) fn yxml_element_attributes(&self) -> RHash {
-        RHash::from_iter(self.0.borrow().attributes().into_iter())
+        RHash::from_iter(self.0.borrow().attributes())
     }
     pub(crate) fn yxml_element_first_child(&self) -> Option<Value> {
         self.yxml_element_get(0)
@@ -23,45 +23,39 @@ impl YXmlElement {
     pub(crate) fn yxml_element_get(&self, index: u32) -> Option<Value> {
         self.0.borrow().get(index).map(|node| match node {
             Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
         })
     }
-    pub(crate) fn yxml_element_get_attribute(
-        &self,
-        name: String
-    ) -> Option<String> {
+    pub(crate) fn yxml_element_get_attribute(&self, name: String) -> Option<String> {
         self.0.borrow().get_attribute(&*name)
     }
     pub(crate) fn yxml_element_insert_attribute(
         &self,
         transaction: &YTransaction,
         name: String,
-        value: String
+        value: String,
     ) {
-        self.0.borrow_mut().insert_attribute(
-            &mut *transaction.0.borrow_mut(),
-            name,
-            value
-        );
+        self.0
+            .borrow_mut()
+            .insert_attribute(&mut *transaction.0.borrow_mut(), name, value);
     }
     pub(crate) fn yxml_element_insert_element(
         &self,
         transaction: &YTransaction,
         index: u32,
-        name: String
+        name: String,
     ) -> YXmlElement {
-        let element = self.0.borrow_mut().insert_elem(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            name
-        );
+        let element =
+            self.0
+                .borrow_mut()
+                .insert_elem(&mut *transaction.0.borrow_mut(), index, name);
 
         YXmlElement(RefCell::from(element))
     }
     pub(crate) fn yxml_element_insert_text(
         &self,
         transaction: &YTransaction,
-        index: u32
+        index: u32,
     ) -> YXmlText {
         let text = self
             .0
@@ -73,19 +67,18 @@ impl YXmlElement {
     pub(crate) fn yxml_element_next_sibling(&self) -> Option<Value> {
         self.0.borrow().next_sibling().map(|item| match item {
             Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
         })
     }
-    pub(crate) fn yxml_element_observe(
-        &self,
-        block: Proc
-    ) -> Result<u32, Error> {
+    pub(crate) fn yxml_element_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 subscription_id = self.0.borrow_mut().observe(
-            move |transaction, xml_element_event| {
+        let subscription_id = self
+            .0
+            .borrow_mut()
+            .observe(move |transaction, xml_element_event| {
                 let delta = xml_element_event.delta(transaction);
                 let changes = RArray::with_capacity(delta.len());
 
@@ -103,9 +96,9 @@ impl YXmlElement {
                                 .aset(change_added, RArray::from_vec(values))
                                 .expect("cannot create change::added payload");
 
-                            changes.push(payload).expect(
-                                "cannot push payload to list of changes"
-                            );
+                            changes
+                                .push(payload)
+                                .expect("cannot push payload to list of changes");
                         }
                         Change::Retain(position) => {
                             let payload = RHash::new();
@@ -113,19 +106,19 @@ impl YXmlElement {
                                 .aset(change_retain, *position)
                                 .expect("cannot create change::retain payload");
 
-                            changes.push(payload).expect(
-                                "cannot push payload to list of changes"
-                            );
+                            changes
+                                .push(payload)
+                                .expect("cannot push payload to list of changes");
                         }
                         Change::Removed(position) => {
                             let payload = RHash::new();
-                            payload.aset(change_removed, *position).expect(
-                                "cannot create change::removed payload"
-                            );
+                            payload
+                                .aset(change_removed, *position)
+                                .expect("cannot create change::removed payload");
 
-                            changes.push(payload).expect(
-                                "cannot push payload to list of changes"
-                            );
+                            changes
+                                .push(payload)
+                                .expect("cannot push payload to list of changes");
                         }
                     }
                 }
@@ -133,8 +126,7 @@ impl YXmlElement {
                 block
                     .call::<(RArray,), Value>((changes,))
                     .expect("cannot call block");
-            }
-        );
+            });
 
         Ok(subscription_id.into())
     }
@@ -147,13 +139,13 @@ impl YXmlElement {
     pub(crate) fn yxml_element_prev_sibling(&self) -> Option<Value> {
         self.0.borrow().prev_sibling().map(|item| match item {
             Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
         })
     }
     pub(crate) fn yxml_element_push_element_back(
         &self,
         transaction: &YTransaction,
-        name: String
+        name: String,
     ) -> YXmlElement {
         let xml_element = self
             .0
@@ -165,7 +157,7 @@ impl YXmlElement {
     pub(crate) fn yxml_element_push_element_front(
         &self,
         transaction: &YTransaction,
-        name: String
+        name: String,
     ) -> YXmlElement {
         let xml_element = self
             .0
@@ -174,10 +166,7 @@ impl YXmlElement {
 
         YXmlElement(RefCell::from(xml_element))
     }
-    pub(crate) fn yxml_element_push_text_back(
-        &self,
-        transaction: &YTransaction
-    ) -> YXmlText {
+    pub(crate) fn yxml_element_push_text_back(&self, transaction: &YTransaction) -> YXmlText {
         let xml_text = self
             .0
             .borrow_mut()
@@ -185,10 +174,7 @@ impl YXmlElement {
 
         YXmlText(RefCell::from(xml_text))
     }
-    pub(crate) fn yxml_element_push_text_front(
-        &self,
-        transaction: &YTransaction
-    ) -> YXmlText {
+    pub(crate) fn yxml_element_push_text_front(&self, transaction: &YTransaction) -> YXmlText {
         let xml_text = self
             .0
             .borrow_mut()
@@ -196,27 +182,20 @@ impl YXmlElement {
 
         YXmlText(RefCell::from(xml_text))
     }
-    pub(crate) fn yxml_element_remove_attribute(
-        &self,
-        transaction: &YTransaction,
-        name: String
-    ) {
-        self.0.borrow_mut().remove_attribute::<&str>(
-            &mut *transaction.0.borrow_mut(),
-            &name.as_str()
-        );
+    pub(crate) fn yxml_element_remove_attribute(&self, transaction: &YTransaction, name: String) {
+        self.0
+            .borrow_mut()
+            .remove_attribute::<&str>(&mut *transaction.0.borrow_mut(), &name.as_str());
     }
     pub(crate) fn yxml_element_remove_range(
         &self,
         transaction: &YTransaction,
         index: u32,
-        length: u32
+        length: u32,
     ) {
-        self.0.borrow_mut().remove_range(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            length
-        );
+        self.0
+            .borrow_mut()
+            .remove_range(&mut *transaction.0.borrow_mut(), index, length);
     }
     pub(crate) fn yxml_element_size(&self) -> u32 {
         self.0.borrow().len()

data/ext/yrb/src/yxml_text.rs

@@ -14,60 +14,45 @@ unsafe impl Send for YXmlText {}
 
 impl YXmlText {
     pub(crate) fn yxml_text_attributes(&self) -> RHash {
-        RHash::from_iter(self.0.borrow().attributes().into_iter())
+        RHash::from_iter(self.0.borrow().attributes())
     }
     pub(crate) fn yxml_text_format(
         &self,
         transaction: &YTransaction,
         index: u32,
         length: u32,
-        attrs: RHash
+        attrs: RHash,
     ) -> Result<(), Error> {
         map_rhash_to_attrs(attrs).map(|a| {
-            self.0.borrow_mut().format(
-                &mut *transaction.0.borrow_mut(),
-                index,
-                length,
-                a
-            );
+            self.0
+                .borrow_mut()
+                .format(&mut *transaction.0.borrow_mut(), index, length, a);
         })
     }
-    pub(crate) fn yxml_text_get_attribute(
-        &self,
-        name: String
-    ) -> Option<String> {
+    pub(crate) fn yxml_text_get_attribute(&self, name: String) -> Option<String> {
         self.0.borrow().get_attribute(&*name)
     }
-    pub(crate) fn yxml_text_insert(
-        &self,
-        transaction: &YTransaction,
-        index: u32,
-        content: String
-    ) {
-        self.0.borrow_mut().insert(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            &*content
-        )
+    pub(crate) fn yxml_text_insert(&self, transaction: &YTransaction, index: u32, content: String) {
+        self.0
+            .borrow_mut()
+            .insert(&mut *transaction.0.borrow_mut(), index, &*content)
     }
     pub(crate) fn yxml_text_insert_attribute(
         &self,
         transaction: &YTransaction,
         name: String,
-        value: String
+        value: String,
     ) {
-        self.0.borrow_mut().insert_attribute(
-            &mut *transaction.0.borrow_mut(),
-            name,
-            value
-        )
+        self.0
+            .borrow_mut()
+            .insert_attribute(&mut *transaction.0.borrow_mut(), name, value)
     }
     pub(crate) fn yxml_text_insert_embed_with_attributes(
         &self,
         transaction: &YTransaction,
         index: u32,
         content: Value,
-        attrs: RHash
+        attrs: RHash,
     ) -> Result<(), Error> {
         let yvalue = YValue::from(content);
         let avalue = Any::from(yvalue);
@@ -77,7 +62,7 @@ impl YXmlText {
                 &mut *transaction.0.borrow_mut(),
                 index,
                 avalue,
-                a
+                a,
             );
         })
     }
@@ -85,12 +70,12 @@ impl YXmlText {
         &self,
         transaction: &YTransaction,
         index: u32,
-        embed: Value
+        embed: Value,
     ) {
         self.0.borrow_mut().insert_embed(
             &mut *transaction.0.borrow_mut(),
             index,
-            Any::from(YValue::from(embed))
+            Any::from(YValue::from(embed)),
         )
     }
     pub(crate) fn yxml_text_insert_with_attributes(
@@ -98,14 +83,14 @@ impl YXmlText {
         transaction: &YTransaction,
         index: u32,
         content: String,
-        attrs: RHash
+        attrs: RHash,
     ) -> Result<(), Error> {
         map_rhash_to_attrs(attrs).map(|a| {
             self.0.borrow_mut().insert_with_attributes(
                 &mut *transaction.0.borrow_mut(),
                 index,
                 &*content,
-                a
+                a,
             );
         })
     }
@@ -115,7 +100,7 @@ impl YXmlText {
     pub(crate) fn yxml_text_next_sibling(&self) -> Option<Value> {
         self.0.borrow().next_sibling().map(|item| match item {
             Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
         })
     }
     pub(crate) fn yxml_text_parent(&self) -> Option<Value> {
@@ -127,14 +112,10 @@ impl YXmlText {
     pub(crate) fn yxml_text_prev_sibling(&self) -> Option<Value> {
         self.0.borrow().prev_sibling().map(|item| match item {
             Xml::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text)))
+            Xml::Text(text) => Value::from(YXmlText(RefCell::from(text))),
         })
     }
-    pub(crate) fn yxml_text_push(
-        &self,
-        transaction: &YTransaction,
-        content: String
-    ) {
+    pub(crate) fn yxml_text_push(&self, transaction: &YTransaction, content: String) {
         self.0
             .borrow_mut()
             .push(&mut *transaction.0.borrow_mut(), &*content)
@@ -143,13 +124,11 @@ impl YXmlText {
         &self,
         transaction: &YTransaction,
         index: u32,
-        length: u32
+        length: u32,
     ) {
-        self.0.borrow_mut().remove_range(
-            &mut *transaction.0.borrow_mut(),
-            index,
-            length
-        );
+        self.0
+            .borrow_mut()
+            .remove_range(&mut *transaction.0.borrow_mut(), index, length);
     }
     pub(crate) fn yxml_text_to_s(&self) -> String {
         self.0.borrow().to_string()

data/lib/y/array.rb

@@ -20,6 +20,8 @@ module Y
   #
   #   array.to_a == [1, 2, 3, 4, 5] # true
   class Array
+    include Enumerable
+
     # @!attribute [r] document
     #
     # @return [Y::Doc] The document this array belongs to

data/lib/y/awareness.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Y
+  class Awareness
+    def apply_update(update)
+      yawareness_apply_update(update)
+    end
+
+    def clean_local_state
+      yawareness_clean_local_state
+    end
+
+    def client_id
+      yawareness_client_id
+    end
+
+    def clients
+      yawareness_clients
+    end
+
+    def local_state
+      yawareness_local_state
+    end
+
+    def local_state=(json)
+      yawareness_set_local_state(json)
+    end
+
+    def attach(callback, &block)
+      return yawareness_on_update(callback) unless callback.nil?
+
+      yawareness_on_update(block.to_proc) unless block.nil?
+    end
+
+    def detach(subscription_id)
+      yawareness_remove_on_update(subscription_id)
+    end
+
+    def remove_state(client_id)
+      yawareness_remove_state(client_id)
+    end
+
+    def update
+      yawareness_update
+    end
+
+    def update_with_clients(clients)
+      yawareness_update_with_clients(clients)
+    end
+
+    # rubocop:disable Lint/UselessAccessModifier
+    private
+
+    # @!method yawareness_apply_update(update)
+    #   Applies an update
+    #
+    # @param [Y::AwarenessUpdate] A structure that represents an encodable state
+    #   of an Awareness struct.
+
+    # @!method yawareness_clean_local_state
+    #   Clears out a state of a current client , effectively marking it as
+    #   disconnected.
+
+    # @!method yawareness_client_id
+    #   Returns a globally unique client ID of an underlying Doc.
+    # @return [Integer] The Client ID
+
+    # @!method yawareness_clients
+    #   Returns a state map of all of the clients
+    #   tracked by current Awareness instance. Those states are identified by
+    #   their corresponding ClientIDs. The associated state is represented and
+    #   replicated to other clients as a JSON string.
+    #
+    # @return [Hash<Integer, String>] Map of clients
+
+    # @!method yawareness_local_state
+    #
+    # @return [String|nil] Returns a JSON string state representation of a
+    #   current Awareness instance.
+
+    # @!method yawareness_on_update(callback, &block)
+    #
+    # @param [Proc] A callback handler for updates
+    # @return [Integer] The subscription ID
+
+    # @!method yawareness_remove_on_update(subscription_id)
+    #
+    # @param [Integer] subscription_id The subscription id to remove
+
+    # @!method yawareness_remove_state(client_id)
+    #   Clears out a state of a given client, effectively marking it as
+    #   disconnected.
+    #
+    # @param [Integer] A Client ID
+    # @return [String|nil] Returns a JSON string state representation of a
+    #   current Awareness instance.
+
+    # @!method yawareness_set_local_state(state)
+    #   Sets a current Awareness instance state to a corresponding JSON string.
+    #   This state will be replicated to other clients as part of the
+    #   AwarenessUpdate and it will trigger an event to be emitted if current
+    #   instance was created using [Awareness::with_observer] method.
+    #
+    # @param [String] Returns a state map of all of the clients tracked by
+    #   current Awareness instance. Those states are identified by their
+    #   corresponding ClientIDs. The associated state is represented and
+    #   replicated to other clients as a JSON string.
+
+    # @!method yawareness_update
+    #   Returns a serializable update object which is representation of a
+    #   current Awareness state.
+    #
+    # @return [Y::AwarenessUpdate] The update object
+
+    # @!method yawareness_update_with_clients(clients)
+    #   Returns a serializable update object which is representation of a
+    #   current Awareness state. Unlike [Y::Awareness#update], this method
+    #   variant allows to prepare update only for a subset of known clients.
+    #   These clients must all be known to a current Awareness instance,
+    #   otherwise an error will be returned.
+    #
+    # @param [Array<Integer>]
+    # @return [Y::AwarenessUpdate] The update object
+
+    # rubocop:enable Lint/UselessAccessModifier
+  end
+
+  # rubocop:disable Lint/UselessAccessModifier
+  class AwarenessEvent
+    private
+
+    # @!method added
+    # @return [Array<Integer>] Added clients
+
+    # @!method updated
+    # @return [Array<Integer>] Updated clients
+
+    # @!method removed
+    # @return [Array<Integer>] Removed clients
+  end
+  # rubocop:enable Lint/UselessAccessModifier
+
+  # rubocop:disable Lint/UselessAccessModifier
+  class AwarenessUpdate
+    def encode
+      yawareness_update_encode
+    end
+
+    private
+
+    # @!method yawareness_update_encode
+    #   Encode the awareness state for simple transport
+    #
+    # @return [Array<Integer>] Encoded update
+  end
+  # rubocop:enable Lint/UselessAccessModifier
+end

data/lib/y/doc.rb

@@ -113,7 +113,7 @@ module Y
     # @return [Y::XMLElement]
     def get_xml_element(name)
       xml_element = current_transaction.get_xml_element(name)
-      xml_element.document = self
+      xml_element&.document = self
       xml_element
     end
 

data/lib/y/map.rb

@@ -18,6 +18,8 @@ module Y
   #   map[:hello] = "world"
   #   puts map[:hello]
   class Map
+    include Enumerable
+
     # @!attribute [r] document
     #
     # @return [Y::Doc] The document this map belongs to

data/lib/y/text.rb

@@ -115,7 +115,7 @@ module Y
     # - Hash (where the the types of key and values must be supported)
     #
     # @param [Integer] index
-    # @param [String, Float, Array, Hash] value
+    # @param [String, Numeric, Array, Hash] value
     # @param [Hash|nil] attrs
     # @return [void]
     def insert(index, value, attrs = nil)