y-rb 0.4.4-x86_64-linux → 0.4.6-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ebf18fc5902f1b8e0fe5d5c4e85c29c4c1b09d9f1ff2116ad06943857904d01
-  data.tar.gz: e465d7c4c62e1171baa8f47e13f484f983623927e406cb7505c03624af20eabb
+  metadata.gz: 0c5deaf53bc4859a4f4765b0e263d4c5993b0f707529e20e8d61ea5ad1eecea0
+  data.tar.gz: 004320cb2be843111b9243f5ac3d93ce1a5165d58754c9d3a217c832e191a2ee
 SHA512:
-  metadata.gz: a7eaaaf8ee2bb6c5faae8e07742c459fdbd92f321bfa4076cba5cc479f3a0e0d53620c9c2c57f922d783723d430c983213bf44206438ba6dc17b6859c2a27737
-  data.tar.gz: a89cca84db136ebdf64e4492d64bfe5dc3ae23efbc604ef102610474c3b80031cf2adf87eaa138bf4df4299fd63edbfcff79da69c8a463033a62f290f5ae8fac
+  metadata.gz: 6bbdcf2ca893466bae039dd257103529aab5b71d622c0bf1075c06a90c95a3970f00613138bcf2e90588263f55186d1f0b08105daef2d9584490c73533a6f87c
+  data.tar.gz: c2744c9f4fd20d97751edce6feb0e030e1f0a5ff4b7407ae85464bf13917c79e7a45a253210e11822fb730865e20d21cf43de3be71083c9e62af0fbee9065086

data/ext/yrb/Cargo.toml

@@ -1,19 +1,19 @@
 [package]
 name = "yrb"
-version = "0.4.4"
+version = "0.4.6"
 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.0" # 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.0"
+yrs = "0.16.2"
 
 [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,6 +7,7 @@ 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};
 
@@ -296,6 +297,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 +394,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");

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

@@ -56,8 +56,11 @@ module Y
     #
     # @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
@@ -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

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

data/lib/y/text.rb

@@ -225,7 +225,7 @@ module Y
     # @return [void]
     def slice!(*args)
       document.current_transaction do |tx|
-        if args.size.zero?
+        if args.empty?
           raise ArgumentError,
                 "Provide one of `index`, `range`, `start, length` as arguments"
         end

data/lib/y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Y
-  VERSION = "0.4.4"
+  VERSION = "0.4.6"
 end

data/lib/y/xml.rb

@@ -31,7 +31,7 @@ module Y
     # Retrieve node at index
     #
     # @param index [Integer]
-    # @return [Y::XMLElement|nil]
+    # @return [Y::XMLElement, nil]
     def [](index)
       node = document.current_transaction { |tx| yxml_element_get(tx, index) }
       node&.document = document
@@ -76,7 +76,7 @@ module Y
     # Optional input is pushed to the text if provided
     #
     # @param index [Integer]
-    # @param input [String|nil]
+    # @param input [String, nil]
     # @return [Y::XMLText]
     def insert_text(index, input = "")
       text = document.current_transaction do |tx|
@@ -88,7 +88,7 @@ module Y
 
     # Retrieve element or text adjacent (next) to this element
     #
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
     def next_sibling
       node = document.current_transaction { |tx| yxml_element_next_sibling(tx) }
       node&.document = document
@@ -120,7 +120,7 @@ module Y
 
     # Retrieve parent element
     #
-    # @return [Y::XMLElement|nil]
+    # @return [Y::XMLElement, nil]
     def parent
       node = yxml_element_parent
       node.document = document
@@ -129,7 +129,7 @@ module Y
 
     # Retrieve element or text adjacent (previous) to this element
     #
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
     def prev_sibling
       node = document.current_transaction { |tx| yxml_element_prev_sibling(tx) }
       node&.document = document
@@ -199,7 +199,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
@@ -349,26 +349,26 @@ module Y
     # @!method yxml_element_first_child(tx)
     #
     # @param tx [Y::Transaction]
-    # @return [Y::XMLElement|Y::XMLText]
+    # @return [Y::XMLElement, Y::XMLText]
 
     # @!method yxml_element_get_attribute(tx, name)
     #
     # @param tx [Y::Transaction]
     # @param name [String]
-    # @return [String|nil]
+    # @return [String, nil]
 
     # @!method yxml_element_get(tx, index)
     #
     # @param tx [Y::Transaction]
     # @param index [Integer]
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
 
     # @!method yxml_element_insert_attribute(tx, name, value)
     #
     # @param tx [Y::Transaction]
     # @param name [String]
     # @param value [String]
-    # @return [String|nil]
+    # @return [String, nil]
 
     # @!method yxml_element_insert_element(tx, index, name)
     # Insert XML element into this XML element
@@ -389,7 +389,7 @@ module Y
     # @!method yxml_element_next_sibling(tx)
     #
     # @param tx [Y::Transaction]
-    # @return [Y::XMLElement|XMLText|nil]
+    # @return [Y::XMLElement, XMLText, nil]
 
     # @!method yxml_element_observe(callback)
     #
@@ -398,12 +398,12 @@ module Y
 
     # @!method yxml_element_parent()
     #
-    # @return [Y::XMLElement|nil]
+    # @return [Y::XMLElement, nil]
 
     # @!method yxml_element_prev_sibling(tx)
     #
     # @param tx [Y::Transaction]
-    # @return [Y::XMLElement|XMLText|nil]
+    # @return [Y::XMLElement, XMLText, nil]
 
     # @!method yxml_element_push_element_back(tx, name)
     #
@@ -562,7 +562,7 @@ module Y
     #
     # @param index [Integer]
     # @param value [String, Float, Integer, Array, Hash, Boolean]
-    # @param attrs [Hash|nil]
+    # @param attrs [Hash, nil]
     # @return [void]
     def insert(index, value, attrs = nil)
       document.current_transaction do |tx|
@@ -604,7 +604,7 @@ module Y
 
     # Return adjacent XMLElement or XMLText node (next)
     #
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
     def next_sibling
       node = document.current_transaction { |tx| yxml_text_next_sibling(tx) }
       node.document = document
@@ -613,7 +613,7 @@ module Y
 
     # Return parent XMLElement
     #
-    # @return [Y::XMLElement|nil]
+    # @return [Y::XMLElement, nil]
     def parent
       node = yxml_text_parent
       node.document = document
@@ -622,7 +622,7 @@ module Y
 
     # Return adjacent XMLElement or XMLText node (prev)
     #
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
     def prev_sibling
       node = document.current_transaction { |tx| yxml_text_prev_sibling(tx) }
       node&.document = document
@@ -682,7 +682,7 @@ module Y
     # @return [void]
     def slice!(*args)
       document.current_transaction do |tx|
-        if args.size.zero?
+        if args.empty?
           raise ArgumentError,
                 "Provide one of `index`, `range`, `start, length` as arguments"
         end
@@ -742,7 +742,7 @@ module Y
       setter = method_name
       setter += "=" unless is_setter
       getter = method_name
-      getter = getter.to_s.slice(0...-1).to_sym if is_setter
+      getter = getter.to_s.slice(0...-1)&.to_sym if is_setter
 
       define_singleton_method(setter.to_sym) do |new_val|
         document.current_transaction do |tx|
@@ -803,7 +803,7 @@ module Y
     #
     # @param tx [Y::Transaction]
     # @param name [String]
-    # @return [String|nil]
+    # @return [String, nil]
 
     # @!method yxml_text_insert(tx, index, str)
     #
@@ -838,7 +838,7 @@ module Y
     #
     # @param tx [Y::Transaction]
     # @param index [Integer]
-    # @param value [true|false|Float|Integer|Array|Hash]
+    # @param value [true, false, Float, Integer, Array, Hash]
     # @param attrs [Hash]
     # @return [void]
 
@@ -850,7 +850,7 @@ module Y
     # @!method yxml_text_next_sibling(tx)
     #
     # @param tx [Y::Transaction]
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
 
     # @!method yxml_text_observe(callback)
     #
@@ -859,12 +859,12 @@ module Y
 
     # @!method yxml_text_parent
     #
-    # @return [Y::XMLElement|nil]
+    # @return [Y::XMLElement, nil]
 
     # @!method yxml_text_prev_sibling(tx)
     #
     # @param tx [Y::Transaction]
-    # @return [Y::XMLElement|Y::XMLText|nil]
+    # @return [Y::XMLElement, Y::XMLText, nil]
 
     # @!method yxml_text_push(tx, str)
     #
@@ -896,6 +896,245 @@ module Y
     #
     # @return [Y::Doc] The document this array belongs to
     attr_accessor :document
+
+    # Create a new XMLElement instance
+    #
+    # @param doc [Y::Doc]
+    def initialize(doc = nil)
+      @document = doc || Y::Doc.new
+
+      super()
+    end
+
+    # Retrieve node at index
+    #
+    # @param index [Integer]
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+    def [](index)
+      node = document.current_transaction { |tx| yxml_fragment_get(tx, index) }
+      node&.document = document
+      node
+    end
+
+    # Create a node at index
+    #
+    # @param index [Integer]
+    # @param name [String] Name of node, e.g. `<p />`
+    # @return [Y::XMLElement]
+    # rubocop:disable Lint/Void
+    def []=(index, name)
+      node = document.current_transaction do |tx|
+        yxml_fragment_insert(tx, index, name)
+      end
+      node.document = document
+      node
+    end
+    # rubocop:enable Lint/Void
+
+    # Retrieve first child
+    #
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+    def first_child
+      node = yxml_fragment_first_child
+      node&.document = document
+      node
+    end
+
+    # Retrieve child at index
+    #
+    # @param [Integer] index
+    # @param [String] tag
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+    def insert(index, tag)
+      document.current_transaction { |tx| yxml_fragment_insert(tx, index, tag) }
+    end
+
+    # Length of the fragment
+    #
+    # @return [Integer]
+    def length
+      document.current_transaction { |tx| yxml_fragment_len(tx) }
+    end
+
+    alias size length
+
+    # Retrieve parent element
+    #
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+    def parent
+      node = yxml_fragment_parent
+      node.document = document
+      node
+    end
+
+    # Creates a new child an inserts at the end of the children list
+    #
+    # @param name [String]
+    # @return [Y::XMLElement]
+    def <<(name)
+      xml_element = document.current_transaction do |tx|
+        yxml_fragment_push_back(tx, name)
+      end
+      xml_element.document = document
+      xml_element
+    end
+
+    alias push <<
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    # Removes one or more children from XML Fragment
+    #
+    # @example Removes a single element
+    #   doc = Y::Doc.new
+    #
+    #   xml_fragment = doc.get_xml_fragment("my xml fragment")
+    #   xml_fragment << "A"
+    #   xml_fragment << "B"
+    #   xml_fragment << "C"
+    #
+    #   xml_fragment.slice!(1)
+    #
+    #   xml_fragment.to_s # <UNDEFINED><A></A><C></C></UNDEFINED>
+    #
+    # @overload slice!(n)
+    #   Removes nth node from child list
+    #
+    # @overload slice!(start, length)
+    #   Removes a range of nodes
+    #
+    # @overload slice!(range)
+    #   Removes a range of nodes
+    #
+    # @return [void]
+    def slice!(*args)
+      document.current_transaction do |tx| # rubocop:disable Metrics/BlockLength
+        if args.empty?
+          raise ArgumentError,
+                "Provide one of `index`, `range`, `start, length` as arguments"
+        end
+
+        if args.size == 1
+          arg = args.first
+
+          if arg.is_a?(Range)
+            if arg.exclude_end?
+              yxml_fragment_remove_range(tx, arg.first,
+                                         arg.last - arg.first)
+            end
+            unless arg.exclude_end?
+              yxml_fragment_remove_range(tx, arg.first,
+                                         arg.last + 1 - arg.first)
+            end
+            return nil
+          end
+
+          if arg.is_a?(Numeric)
+            yxml_fragment_remove_range(tx, arg.to_int, 1)
+            return nil
+          end
+        end
+
+        if args.size == 2
+          first, second = args
+
+          if first.is_a?(Numeric) && second.is_a?(Numeric)
+            yxml_fragment_remove_range(tx, first, second)
+            return nil
+          end
+        end
+
+        raise ArgumentError, "Please check your arguments, can't slice."
+      end
+    end
+
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    # Traverse over the successors of the current XML element and return
+    # a flat representation of all successors.
+    #
+    # @return [Array<Y::XMLElement, Y::XMLFragment, Y::XMLText]
+    def successors
+      document.current_transaction { |tx| yxml_fragment_successors(tx) }
+    end
+
+    # Returns string representation of XMLFragment
+    #
+    # @return [String]
+    def to_s
+      document.current_transaction { |tx| yxml_fragment_to_s(tx) }
+    end
+
+    # Creates a new node and puts it in front of the child list
+    #
+    # @param name [String]
+    # @return [Y::XMLElement]
+    def unshift(name)
+      xml_element = document.current_transaction do |tx|
+        yxml_fragment_push_front(tx, name)
+      end
+      xml_element.document = document
+      xml_element
+    end
+
+    # @!method yxml_fragment_first_child
+    #
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+
+    # @!method yxml_fragment_get(tx, index)
+    #
+    # @param [Y::Transaction] tx
+    # @param [Integer] index
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+
+    # @!method yxml_fragment_insert(tx, index, tag)
+    #
+    # @param tx [Y::Transaction]
+    # @param [Integer] index
+    # @param [String] tag
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+
+    # @!method yxml_fragment_len(tx)
+    #
+    # @param tx [Y::Transaction]
+    # @return [Integer]
+
+    # @!method yxml_fragment_parent
+    #
+    # @return [Y::XMLElement, Y::XMLFragment, Y::XMLText, nil]
+
+    # @!method yxml_fragment_push_back(tx, tag)
+    #
+    # @param tx [Y::Transaction]
+    # @param [String] tag
+    # @return [Y::XMLElement]
+
+    # @!method yxml_fragment_push_front(tx, tag)
+    #
+    # @param tx [Y::Transaction]
+    # @param [String] tag
+    # @return [Y::XMLElement]
+
+    # @!method yxml_fragment_remove(tx, index)
+    #
+    # @param tx [Y::Transaction]
+    # @param [Integer] index
+
+    # @!method yxml_fragment_remove_range(tx, index, length)
+    #
+    # @param tx [Y::Transaction]
+    # @param [Integer] index
+    # @param [Integer] length
+
+    # @!method yxml_fragment_successors(tx)
+    #
+    # @param tx [Y::Transaction]
+    # @return [Array<Y::XMLElement, Y::XMLFragment, Y::XMLText>]
+
+    # @!method yxml_fragment_to_s(tx)
+    #
+    # @param tx [Y::Transaction]
+    # @return [String]
   end
 
   # rubocop:enable Metrics/ClassLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: x86_64-linux
 authors:
 - Hannes Moser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-31 00:00:00.000000000 Z
+date: 2023-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake