y-rb 0.4.5-arm64-darwin → 0.5.0-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23893c6c58ab460fd08f817923cead44794af41a10843c1e47ad9a1b2f621e9b
-  data.tar.gz: cb3c6cdcdefca384dce86ff77624e817f0525508221031afa1e90dcb814bf024
+  metadata.gz: e69b5bc4c469fcec564b620a9d8fd48de458ca2596b2e32a32749fd9b4c2becb
+  data.tar.gz: 4b8c59487117ed88509daa88966a4dfeac2d376d5ae9afb815a4697ac470ddfb
 SHA512:
-  metadata.gz: a93e8bbef985be218c28f926f49c41847f3685cad6ab747bea3bd3dae342c1ff1ae074a0defcac218c2888c9e32344e77161e71c114bbb8363134d2ee6489411
-  data.tar.gz: 88acddbbbc8bf338f18f5dab25edf856ce332286716b4aa04cf4f528767551e9e95785cccf204a35057ea9d86400537eefcc6116ca36be96161610bf873a7b28
+  metadata.gz: 9910b7b0ed257ac683bd79730be3525da341cc56cd0568a32a9aa74067d064bc1c3881f230aa72cee0932298127b51d50cc5a5443f1c42db7522cb98d196d6ca
+  data.tar.gz: f1579c6f3de6b2df176e8496a1ec8b4a404b94aba9eea7da0669b7eb9ed7ebcfcda35bcd4eb61c68036901c3f66e4eb0851f47ba408f170de37d855edc855a09

data/ext/yrb/Cargo.toml

@@ -1,19 +1,20 @@
 [package]
 name = "yrb"
-version = "0.4.5"
+version = "0.5.0"
 authors = ["Hannes Moser <box@hannesmoser.at>", "Hannes Moser <hmoser@gitlab.com>"]
 edition = "2021"
 homepage = "https://github.com/y-crdt/yrb"
 repository = "https://github.com/y-crdt/yrb"
 
 [dependencies]
-lib0 = "0.16.1" # must match yrs version
-magnus = { git = "https://github.com/matsadler/magnus", rev = "ab982c3643421b38f3293f1fe014aa373abfd6dc" }
+lib0 = "0.16.2" # must match yrs version
+magnus = { git = "https://github.com/matsadler/magnus", rev = "2c2024920a403daadbe23fe63270440dfac86288" }
 thiserror = "1.0.38"
-yrs = "0.16.1"
+yrs = "0.16.2"
+y-sync = "0.2.0"
 
 [dev-dependencies]
-magnus = { git = "https://github.com/matsadler/magnus", rev = "ab982c3643421b38f3293f1fe014aa373abfd6dc", features = ["embed"] }
+magnus = { git = "https://github.com/matsadler/magnus", rev = "2c2024920a403daadbe23fe63270440dfac86288", features = ["embed"] }
 
 [lib]
 name = "yrb"

data/ext/yrb/src/lib.rs

@@ -7,10 +7,10 @@ use crate::ymap::YMap;
 use crate::ytext::YText;
 use crate::ytransaction::YTransaction;
 use crate::yxml_element::YXmlElement;
+use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 use magnus::{define_module, function, method, Error, Module, Object};
 
-mod awareness;
 mod utils;
 mod yany;
 mod yarray;
@@ -296,6 +296,12 @@ fn init() -> Result<(), Error> {
             method!(YXmlElement::yxml_element_insert_text, 3),
         )
         .expect("cannot define private method: yxml_element_insert_text");
+    yxml_element
+        .define_private_method(
+            "yxml_element_len",
+            method!(YXmlElement::yxml_element_len, 1),
+        )
+        .expect("cannot define private method: yxml_element_len");
     yxml_element
         .define_private_method(
             "yxml_element_next_sibling",
@@ -387,6 +393,71 @@ fn init() -> Result<(), Error> {
         )
         .expect("cannot define private method: yxml_element_unobserve");
 
+    let yxml_fragment = module
+        .define_class("XMLFragment", Default::default())
+        .expect("cannot define class: Y::XMLFragment");
+
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_first_child",
+            method!(YXmlFragment::yxml_fragment_first_child, 0),
+        )
+        .expect("cannot define private method: yxml_fragment_first_child");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_get",
+            method!(YXmlFragment::yxml_fragment_get, 2),
+        )
+        .expect("cannot define private method: yxml_fragment_get");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_insert",
+            method!(YXmlFragment::yxml_fragment_insert, 3),
+        )
+        .expect("cannot define private method: yxml_fragment_insert");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_len",
+            method!(YXmlFragment::yxml_fragment_len, 1),
+        )
+        .expect("cannot define private method: yxml_fragment_len");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_parent",
+            method!(YXmlFragment::yxml_fragment_parent, 0),
+        )
+        .expect("cannot define private method: yxml_fragment_parent");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_push_back",
+            method!(YXmlFragment::yxml_fragment_push_back, 2),
+        )
+        .expect("cannot define private method: yxml_fragment_push_back");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_push_front",
+            method!(YXmlFragment::yxml_fragment_push_front, 2),
+        )
+        .expect("cannot define private method: yxml_fragment_push_front");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_remove_range",
+            method!(YXmlFragment::yxml_fragment_remove_range, 3),
+        )
+        .expect("cannot define private method: yxml_fragment_remove_range");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_successors",
+            method!(YXmlFragment::yxml_fragment_successors, 1),
+        )
+        .expect("cannot define private method: yxml_fragment_successors");
+    yxml_fragment
+        .define_private_method(
+            "yxml_fragment_to_s",
+            method!(YXmlFragment::yxml_fragment_to_s, 1),
+        )
+        .expect("cannot define private method: yxml_fragment_to_s");
+
     let yxml_text = module
         .define_class("XMLText", Default::default())
         .expect("cannot define class Y::XMLText");
@@ -506,12 +577,6 @@ fn init() -> Result<(), Error> {
             method!(YAwareness::yawareness_on_update, 1),
         )
         .expect("cannot define private method: yawareness_on_update");
-    yawareness
-        .define_private_method(
-            "yawareness_remove_on_update",
-            method!(YAwareness::yawareness_remove_on_update, 1),
-        )
-        .expect("cannot define private method: yawareness_remove_on_update");
     yawareness
         .define_private_method(
             "yawareness_remove_state",

data/ext/yrb/src/yawareness.rs

@@ -1,12 +1,12 @@
-use crate::awareness::{Awareness, AwarenessUpdate, Event};
 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, Subscription};
 use yrs::block::ClientID;
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::Encode;
-use yrs::Doc;
+use yrs::{Doc, OffsetKind, Options};
 
 #[magnus::wrap(class = "Y::Awareness")]
 pub(crate) struct YAwareness(pub(crate) RefCell<Awareness>);
@@ -16,7 +16,14 @@ unsafe impl Send for YAwareness {}
 
 impl YAwareness {
     pub(crate) fn yawareness_new() -> Self {
-        let doc = Doc::new();
+        let mut options = Options {
+            offset_kind: OffsetKind::Utf32,
+            ..Default::default()
+        };
+        options.offset_kind = OffsetKind::Utf32;
+
+        let doc = Doc::with_options(options);
+
         let awareness = Awareness::new(doc);
 
         Self(RefCell::new(awareness))
@@ -48,24 +55,18 @@ impl YAwareness {
         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();
+    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");
+        });
 
-        Ok(subscription_id)
-    }
-
-    pub(crate) fn yawareness_remove_on_update(&self, subscription_id: u32) {
-        self.0.borrow_mut().remove_on_update(subscription_id)
+        // 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) {
@@ -135,3 +136,16 @@ impl From<&Event> for YAwarenessEvent {
         Self(value.clone())
     }
 }
+
+#[magnus::wrap(class = "Y::AwarenessEvent")]
+pub(crate) struct YAwarenessSubscription(Subscription<Event>);
+
+unsafe impl Send for YAwarenessSubscription {}
+
+impl YAwarenessSubscription {}
+
+impl From<Subscription<Event>> for YAwarenessSubscription {
+    fn from(v: Subscription<Event>) -> Self {
+        YAwarenessSubscription(v)
+    }
+}

data/ext/yrb/src/ydoc.rs

@@ -6,8 +6,7 @@ use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 use crate::YTransaction;
 use magnus::block::Proc;
-use magnus::exception::runtime_error;
-use magnus::{exception, Error, Integer, RArray, Value};
+use magnus::{exception::runtime_error, Error, Integer, RArray, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use yrs::updates::decoder::Decode;
@@ -41,19 +40,22 @@ impl YDoc {
 
         StateVector::decode_v1(state_vector.borrow())
             .map(|sv| tx.encode_diff_v1(&sv))
-            .map_err(|_e| Error::new(exception::runtime_error(), "cannot encode diff"))
+            .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
     }
 
     pub(crate) fn ydoc_get_or_insert_array(&self, name: String) -> YArray {
-        self.0.borrow().get_or_insert_array(name.as_str()).into()
+        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 {
-        self.0.borrow().get_or_insert_map(name.as_str()).into()
+        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 {
-        self.0.borrow().get_or_insert_text(name.as_str()).into()
+        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 {
@@ -62,14 +64,13 @@ impl YDoc {
     }
 
     pub(crate) fn ydoc_get_or_insert_xml_fragment(&self, name: String) -> YXmlFragment {
-        self.0
-            .borrow()
-            .get_or_insert_xml_fragment(name.as_str())
-            .into()
+        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 {
-        self.0.borrow().get_or_insert_xml_text(name.as_str()).into()
+        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<'doc>(&self) -> YTransaction {

data/ext/yrb/src/yxml_element.rs

@@ -82,6 +82,12 @@ impl YXmlElement {
 
         YXmlText::from(self.0.borrow_mut().insert(tx, index, text))
     }
+    pub(crate) fn yxml_element_len(&self, transaction: &YTransaction) -> u32 {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow().len(tx)
+    }
     pub(crate) fn yxml_element_next_sibling(&self, transaction: &YTransaction) -> Option<Value> {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();

data/ext/yrb/src/yxml_fragment.rs

@@ -1,5 +1,9 @@
+use crate::ytransaction::YTransaction;
+use crate::yxml_element::YXmlElement;
+use crate::yxml_text::YXmlText;
+use magnus::{RArray, Value};
 use std::cell::RefCell;
-use yrs::XmlFragmentRef;
+use yrs::{GetString, XmlElementPrelim, XmlFragment, XmlFragmentRef, XmlNode};
 
 #[magnus::wrap(class = "Y::XMLFragment")]
 pub(crate) struct YXmlFragment(pub(crate) RefCell<XmlFragmentRef>);
@@ -7,7 +11,116 @@ pub(crate) struct YXmlFragment(pub(crate) RefCell<XmlFragmentRef>);
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for YXmlFragment {}
 
-impl YXmlFragment {}
+impl YXmlFragment {
+    pub(crate) fn yxml_fragment_first_child(&self) -> Option<Value> {
+        self.0.borrow().first_child().map(|node| match node {
+            XmlNode::Element(element) => Value::from(YXmlElement::from(element)),
+            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
+            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+        })
+    }
+
+    pub(crate) fn yxml_fragment_get(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+    ) -> Option<Value> {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get(tx, index).map(|node| match node {
+            XmlNode::Element(element) => Value::from(YXmlElement::from(element)),
+            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
+            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+        })
+    }
+
+    pub(crate) fn yxml_fragment_insert(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().insert(tx, index, node))
+    }
+
+    pub(crate) fn yxml_fragment_len(&self, transaction: &YTransaction) -> u32 {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().len(tx)
+    }
+
+    pub(crate) fn yxml_fragment_parent(&self) -> Option<Value> {
+        self.0.borrow().parent().map(|item| match item {
+            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
+            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
+            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+        })
+    }
+
+    pub(crate) fn yxml_fragment_push_back(
+        &self,
+        transaction: &YTransaction,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_back(tx, node))
+    }
+
+    pub(crate) fn yxml_fragment_push_front(
+        &self,
+        transaction: &YTransaction,
+        tag: String,
+    ) -> YXmlElement {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        let node = XmlElementPrelim::empty(tag);
+        YXmlElement::from(self.0.borrow_mut().push_front(tx, node))
+    }
+
+    pub(crate) fn yxml_fragment_remove_range(
+        &self,
+        transaction: &YTransaction,
+        index: u32,
+        length: u32,
+    ) {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+
+        self.0.borrow_mut().remove_range(tx, index, length);
+    }
+
+    pub(crate) fn yxml_fragment_successors(&self, transaction: &YTransaction) -> RArray {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        let fragment = self.0.borrow();
+
+        let result = fragment.successors(tx).map(|item| match item {
+            XmlNode::Element(el) => Value::from(YXmlElement::from(el)),
+            XmlNode::Fragment(fragment) => Value::from(YXmlFragment::from(fragment)),
+            XmlNode::Text(text) => Value::from(YXmlText::from(text)),
+        });
+
+        RArray::from_iter(result)
+    }
+
+    pub(crate) fn yxml_fragment_to_s(&self, transaction: &YTransaction) -> String {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        self.0.borrow().get_string(tx)
+    }
+}
 
 impl From<XmlFragmentRef> for YXmlFragment {
     fn from(v: XmlFragmentRef) -> Self {

data/lib/y/array.rb

@@ -38,7 +38,7 @@ module Y
 
     # Retrieves element at position
     #
-    # @return [true|false|Float|Integer|String|Array|Hash]
+    # @return [true, false, Float, Integer, String, Array, Hash]
     def [](index)
       document.current_transaction { |tx| yarray_get(tx, index) }
     end
@@ -46,7 +46,7 @@ module Y
     # Inserts value at position
     #
     # @param index [Integer]
-    # @param value [true|false|Float|Integer|String|Array|Hash]
+    # @param value [true, false, Float, Integer, String, Array, Hash]
     # @return [void]
     def []=(index, value)
       document.current_transaction { |tx| yarray_insert(tx, index, value) }
@@ -54,10 +54,13 @@ module Y
 
     # Adds an element to the end of the array
     #
-    # @param value [true|false|Float|Integer|String|::Array|Hash]
+    # @param value [true, false, Float, Integer, String, ::Array, Hash]
     # @return [void]
-    def <<(value)
-      document.current_transaction { |tx| yarray_push_back(tx, value) }
+    def <<(value, *values)
+      document.current_transaction do |tx|
+        yarray_push_back(tx, value)
+        values.each { |v| yarray_push_back(tx, v) }
+      end
     end
 
     # Attach listener to array changes
@@ -118,21 +121,21 @@ module Y
 
     # Check if the array is empty
     #
-    # @return [true|false]
+    # @return [true, false]
     def empty?
       size.zero?
     end
 
     # Returns first element in array if there is at least one
     #
-    # @return [true|false|Float|Integer|String|::Array|Hash|nil]
+    # @return [true, false, Float, Integer, String, ::Array, Hash, nil]
     def first
       document.current_transaction { |tx| yarray_get(tx, 0) }
     end
 
     # Returns last element in array if there is at least one element
     #
-    # @return [true|false|Float|Integer|String|::Array|Hash|nil]
+    # @return [true, false, Float, Integer, String, ::Array, Hash, nil]
     def last
       document.current_transaction do |tx|
         len = yarray_length(tx)
@@ -146,7 +149,7 @@ module Y
 
     # Removes last (n) element(s) from array
     #
-    # @param n [Integer|nil] Number of elements to remove
+    # @param n [Integer, nil] Number of elements to remove
     # @return [void]
     def pop(n = nil)
       document.current_transaction do |tx|
@@ -164,7 +167,7 @@ module Y
 
     # Removes first (n) element(s) from array
     #
-    # @param n [Integer|nil] Number of elements to remove
+    # @param n [Integer, nil] Number of elements to remove
     # @return [void]
     def shift(n = nil)
       document.current_transaction do |tx|
@@ -218,7 +221,7 @@ module Y
     # @return [void]
     def slice!(*args)
       document.current_transaction do |tx| # rubocop:disable Metrics/BlockLength
-        if args.size.zero?
+        if args.empty?
           raise ArgumentError,
                 "Provide one of `index`, `range`, `start, length` as arguments"
         end
@@ -261,7 +264,7 @@ module Y
 
     # Convert this array to a Ruby Array
     #
-    # @return [Array<true|false|Float|Integer|String|::Array|Hash>]
+    # @return [Array<true, false, Float, Integer, String, ::Array, Hash>]
     def to_a
       document.current_transaction { |tx| yarray_to_a(tx) }
     end
@@ -303,7 +306,7 @@ module Y
     #
     # @param transaction [Y::Transaction]
     # @param index [Integer]
-    # @param arr [Array<Boolean|Float|Integer|Array|Hash|Text>]
+    # @param arr [Array<Boolean, Float, Integer, Array, Hash, Text>]
     # @return [void]
     # @!visibility private
 

data/lib/y/awareness.rb

@@ -93,25 +93,28 @@ module Y
     #
     # @return [Hash] All clients and their current state
     def clients
-      yawareness_clients
+      transform = yawareness_clients.map do |client_id, state|
+        [client_id, JSON.parse!(state)]
+      end
+      transform.to_h
     end
 
-    # Returns a JSON string state representation of a current Awareness
-    # instance.
+    # Returns the state of the local Awareness instance.
     #
     # @example Create local state and inspect it
     #   local_state = {
     #     editing: { field: "description", pos: 0 },
     #     name: "Hannes Moser"
-    #   }.to_json
+    #   }
     #
     #   awareness = Y::Awareness.new
     #   awareness.local_state = local_state
-    #   local_state # "{\"editing\":{\"field\":\"description\",\"pos\":0}, …
+    #   awareness.local_state # {  editing: { field: "description", ...
     #
     # @return [String] The current state of the local client
     def local_state
-      yawareness_local_state
+      json = yawareness_local_state
+      JSON.parse!(json) if json
     end
 
     # Sets a current Awareness instance state to a corresponding JSON string.
@@ -127,28 +130,23 @@ module Y
     #   awareness = Y::Awareness.new
     #   awareness.local_state = local_state
     #
+    # @param [#to_json] state
     # @return [void]
-    def local_state=(json)
-      yawareness_set_local_state(json)
+    def local_state=(state)
+      raise "state cannot be encoded to JSON" unless state.respond_to? :to_json
+
+      yawareness_set_local_state(state.to_json)
     end
 
     # Subscribes to changes
     #
     # @return [Integer] The subscription ID
-    def attach(callback, &block)
+    def attach(callback = nil, &block)
       return yawareness_on_update(callback) unless callback.nil?
 
       yawareness_on_update(block.to_proc) unless block.nil?
     end
 
-    # Unsubscribe from changes
-    #
-    # @param subscription_id [Integer]
-    # @return [void]
-    def detach(subscription_id)
-      yawareness_remove_on_update(subscription_id)
-    end
-
     # Clears out a state of a given client, effectively marking it as
     # disconnected.
     #
@@ -216,7 +214,7 @@ module Y
 
     # @!method yawareness_local_state
     #
-    # @return [String|nil] Returns a JSON string state representation of a
+    # @return [String, nil] Returns a JSON string state representation of a
     #   current Awareness instance.
     # @!visibility private
 
@@ -236,7 +234,7 @@ module Y
     #   disconnected.
     #
     # @param client_id [Integer] A Client ID
-    # @return [String|nil] Returns a JSON string state representation of a
+    # @return [String, nil] Returns a JSON string state representation of a
     #   current Awareness instance.
     # @!visibility private
 

data/lib/y/doc.rb

@@ -221,26 +221,51 @@ module Y
     # @return [Y::Transaction] The transaction object
     # @!visibility private
 
+    # @!method ydoc_get_or_insert_array(name)
+    #   Creates a new array for the document
+    #
+    # @param [String] name
+    # @return [Y::Array]
+    # @!visibility private
+
+    # @!method ydoc_get_or_insert_map(name)
+    #   Creates a new map for the document
+    #
+    # @param [String] name
+    # @return [Y::Map]
+    # @!visibility private
+
+    # @!method ydoc_get_or_insert_text(name)
+    #   Creates a new text for the document
+    #
+    # @param [String] name
+    # @return [Y::Text]
+    # @!visibility private
+
     # @!method ydoc_get_or_insert_xml_element(name)
     #   Creates a new XMLText for the document
     #
+    # @param [String] name
     # @return [Y::XMLElement]
     # @!visibility private
 
     # @!method ydoc_get_or_insert_xml_fragment(name)
     #   Creates a new XMLFragment for the document
     #
+    # @param [String] name
     # @return [Y::XMLFragment]
     # @!visibility private
 
     # @!method ydoc_get_or_insert_xml_text(name)
     #   Creates a new XMLText for the document
     #
+    # @param [String] name
     # @return [Y::XMLText]
     # @!visibility private
 
     # @!method ydoc_observe_update(block)
     #   Creates a subscription to observe changes to the document
+    #
     # @param [Proc] block
     # @return [Integer]
     # @!visibility private