y-rb 0.5.1-x64-mingw-ucrt → 0.5.3-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d44cf25ca0cfda92014d04f1a995fee0705b041b43fddf13b79d371df239022
-  data.tar.gz: 012a87a2aec89b74e3ce8c344e71974cfc85ac4fcde37d8366c69d80fdc53a0d
+  metadata.gz: 7ddc46c1292b5d7fbe597a5ae623c32f6917aae909e1d2e34b447cc452d0eff8
+  data.tar.gz: b2a5902c89aadd5d3ebb5fda5be24f51e9185fd366fc5104bf4cecd010988aee
 SHA512:
-  metadata.gz: a9c1fa0d2bb7dc0462ba7c5073de9e501d559d32cd026c83ca4888fd653c6b4f2c6c590808b4ece01f649f6f885d998863bedeebe7d91e93689f2a9f49e1c25f
-  data.tar.gz: c5f976b0deef2537f7a47f65fe5a36da6a06a3b23805489e7422da476773848b89870a8e748b43c94cdcb6fdc4a2bcd93a7d3e5cbd888bc91c95d31b534de013
+  metadata.gz: b88834c3ce6763b1984360f28fbc5e4b96d9a74628b3dd8db41767b8fa21e2a8a666f9cc49110fdb0703f3b05f10abe3bf311cc16794087a1bbe10eddbb867ba
+  data.tar.gz: bccc0c328ca21ecabea95f3bcbf3d312bcf5863f8f67e3ccaf7d06389e758eb6e2757a998a51a0d08097c15c9956cd3be93f4979c026b80500c739599228a8cb

data/ext/yrb/Cargo.toml

@@ -1,21 +1,21 @@
 [package]
 name = "yrb"
-version = "0.5.1"
-authors = ["Hannes Moser <box@hannesmoser.at>", "Hannes Moser <hmoser@gitlab.com>"]
+version = "0.5.3"
+authors = ["Hannes Moser <box@hannesmoser.at>"]
 edition = "2021"
 homepage = "https://github.com/y-crdt/yrb"
 repository = "https://github.com/y-crdt/yrb"
 
 [dependencies]
-lib0 = "0.16.5" # must match yrs version
-magnus = "0.5.2"
-thiserror = "1.0.40"
-yrs = "0.16.5"
-y-sync = "0.3.0"
-rb-sys = "0.9.71"
+lib0 = "0.16.10" # must match yrs version
+magnus = "0.6.2"
+thiserror = "1.0.50"
+yrs = "=0.16.10"
+y-sync = "=0.3.1"
+rb-sys = "0.9.82"
 
 [dev-dependencies]
-magnus = { version = "0.5.2", features = ["embed"] }
+magnus = { version = "0.6.2", features = ["embed"] }
 
 [lib]
 name = "yrb"

data/ext/yrb/src/lib.rs

@@ -9,7 +9,7 @@ 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};
+use magnus::{class, define_module, function, method, Error, Module, Object};
 
 mod utils;
 mod yany;
@@ -30,7 +30,7 @@ fn init() -> Result<(), Error> {
     let module = define_module("Y").expect("cannot define ::Y module");
 
     let yarray = module
-        .define_class("Array", Default::default())
+        .define_class("Array", class::object())
         .expect("cannot find class Y::Array");
 
     yarray
@@ -77,12 +77,14 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yarray_unobserve");
 
     let ydoc = module
-        .define_class("Doc", Default::default())
+        .define_class("Doc", class::object())
         .expect("cannot define class Y::Doc");
     ydoc.define_singleton_method("new", function!(YDoc::ydoc_new, -1))
         .expect("cannot define singleton method: ydoc_new");
     ydoc.define_private_method("ydoc_encode_diff_v1", method!(YDoc::ydoc_encode_diff_v1, 2))
         .expect("cannot define private method: ydoc_encode_diff_v1");
+    ydoc.define_private_method("ydoc_encode_diff_v2", method!(YDoc::ydoc_encode_diff_v2, 2))
+        .expect("cannot define private method: ydoc_encode_diff_v2");
     ydoc.define_private_method(
         "ydoc_get_or_insert_array",
         method!(YDoc::ydoc_get_or_insert_array, 1),
@@ -120,7 +122,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ydoc_observe_update");
 
     let ymap = module
-        .define_class("Map", Default::default())
+        .define_class("Map", class::object())
         .expect("cannot define class Y::Map");
 
     ymap.define_private_method("ymap_clear", method!(YMap::ymap_clear, 1))
@@ -145,7 +147,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ymap_unobserve");
 
     let ytransaction = module
-        .define_class("Transaction", Default::default())
+        .define_class("Transaction", class::object())
         .expect("cannot define class Y::Transaction");
 
     ytransaction
@@ -154,6 +156,12 @@ fn init() -> Result<(), Error> {
             method!(YTransaction::ytransaction_apply_update, 1),
         )
         .expect("cannot define private method: ytransaction_apply_update");
+    ytransaction
+        .define_private_method(
+            "ytransaction_apply_update_v2",
+            method!(YTransaction::ytransaction_apply_update_v2, 1),
+        )
+        .expect("cannot define private method: ytransaction_apply_update_v2");
     ytransaction
         .define_private_method(
             "ytransaction_commit",
@@ -205,9 +213,15 @@ fn init() -> Result<(), Error> {
             method!(YTransaction::ytransaction_state_vector, 0),
         )
         .expect("cannot define private method: ytransaction_state_vector");
+    ytransaction
+        .define_private_method(
+            "ytransaction_state_vector_v2",
+            method!(YTransaction::ytransaction_state_vector_v2, 0),
+        )
+        .expect("cannot define private method: ytransaction_state_vector_v2");
 
     let ytext = module
-        .define_class("Text", Default::default())
+        .define_class("Text", class::object())
         .expect("cannot define class Y::Text");
 
     ytext
@@ -251,7 +265,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: ytext_unobserve");
 
     let yxml_element = module
-        .define_class("XMLElement", Default::default())
+        .define_class("XMLElement", class::object())
         .expect("cannot define class Y::XMLElement");
 
     yxml_element
@@ -394,7 +408,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_element_unobserve");
 
     let yxml_fragment = module
-        .define_class("XMLFragment", Default::default())
+        .define_class("XMLFragment", class::object())
         .expect("cannot define class: Y::XMLFragment");
 
     yxml_fragment
@@ -459,7 +473,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_fragment_to_s");
 
     let yxml_text = module
-        .define_class("XMLText", Default::default())
+        .define_class("XMLText", class::object())
         .expect("cannot define class Y::XMLText");
 
     yxml_text
@@ -536,7 +550,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yxml_text_to_s");
 
     let yawareness = module
-        .define_class("Awareness", Default::default())
+        .define_class("Awareness", class::object())
         .expect("cannot define class Y::Awareness");
     yawareness
         .define_singleton_method("new", function!(YAwareness::yawareness_new, 0))
@@ -603,7 +617,7 @@ fn init() -> Result<(), Error> {
         .expect("cannot define private method: yawareness_update_with_clients");
 
     let yawareness_event = module
-        .define_class("AwarenessEvent", Default::default())
+        .define_class("AwarenessEvent", class::object())
         .expect("cannot define class Y:AwarenessEvent");
     yawareness_event
         .define_method("added", method!(YAwarenessEvent::added, 0))

data/ext/yrb/src/utils.rs

@@ -1,9 +1,10 @@
 use crate::yvalue::YValue;
 use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
-use magnus::{exception, Error, RHash, RString, Symbol, Value};
-use std::rc::Rc;
-use yrs::types::Attrs;
+use magnus::{exception, Error, RArray, RHash, RString, Symbol, Value};
+use std::sync::Arc;
+use yrs::types::{Attrs, Value as YrsValue};
+use yrs::{Array, Map, TransactionMut};
 
 #[derive(Debug, Clone)]
 pub(crate) struct TypeConversionError;
@@ -18,7 +19,7 @@ pub(crate) fn map_rhash_to_attrs(hash: RHash) -> Result<Attrs, Error> {
     let mut a: Attrs = Default::default();
 
     let result = hash.foreach(|key: Value, value: Value| {
-        let k = Rc::from(key.to_string());
+        let k = Arc::from(key.to_string());
         let v = Any::from(YValue::from(value));
 
         a.insert(k, v);
@@ -35,3 +36,30 @@ pub(crate) fn map_rhash_to_attrs(hash: RHash) -> Result<Attrs, Error> {
 
     Ok(a)
 }
+
+pub(crate) fn convert_yvalue_to_ruby_value(value: YrsValue, tx: &TransactionMut) -> YValue {
+    match value {
+        YrsValue::Any(val) => YValue::from(val),
+        YrsValue::YText(text) => YValue::from(text),
+        YrsValue::YXmlElement(el) => YValue::from(el),
+        YrsValue::YXmlText(text) => YValue::from(text),
+        YrsValue::YArray(val) => {
+            let arr = RArray::new();
+            for item in val.iter(tx) {
+                let val = convert_yvalue_to_ruby_value(item.clone(), tx);
+                let val = *val.0.borrow();
+                arr.push(val).expect("cannot push item event to array");
+            }
+            YValue::from(arr)
+        }
+        YrsValue::YMap(val) => {
+            let iter = val.iter(tx).map(|(key, val)| {
+                let val = convert_yvalue_to_ruby_value(val.clone(), tx);
+                let val = val.0.into_inner();
+                (key, val)
+            });
+            YValue::from(RHash::from_iter(iter))
+        }
+        v => panic!("cannot map given yrs values to yvalue: {:?}", v),
+    }
+}

data/ext/yrb/src/yany.rs

@@ -1,6 +1,7 @@
 use lib0::any::Any;
 use magnus::r_string::IntoRString;
-use magnus::{RArray, RHash, RString, Value, QNIL};
+use magnus::value::ReprValue;
+use magnus::{value, IntoValue, RArray, RHash, RString, Value};
 use std::borrow::Borrow;
 use std::ops::{Deref, DerefMut};
 
@@ -27,19 +28,19 @@ impl TryInto<Value> for YAny {
         return match self.0 {
             Any::Array(_v) => {
                 let arr = RArray::new();
-                Ok(Value::from(arr))
+                Ok(arr.as_value())
             }
             Any::Map(_v) => {
                 let hash = RHash::new();
-                Ok(Value::from(hash))
+                Ok(hash.as_value())
             }
-            Any::Null => Ok(Value::from(QNIL)),
-            Any::Undefined => Ok(Value::from(QNIL)),
-            Any::Bool(v) => Ok(Value::from(v)),
-            Any::Number(v) => Ok(Value::from(v)),
-            Any::BigInt(v) => Ok(Value::from(v)),
-            Any::String(v) => Ok(Value::from(RString::from(v.into_r_string()))),
-            Any::Buffer(v) => Ok(Value::from(RString::from_slice(v.borrow()))),
+            Any::Null => Ok(value::qnil().as_value()),
+            Any::Undefined => Ok(Value::from(value::qnil().as_value())),
+            Any::Bool(v) => Ok(v.into_value()),
+            Any::Number(v) => Ok(Value::from(v.into_value())),
+            Any::BigInt(v) => Ok(Value::from(v.into_value())),
+            Any::String(v) => Ok(RString::from(v.into_r_string()).as_value()),
+            Any::Buffer(v) => Ok(RString::from_slice(v.borrow()).as_value()),
         };
     }
 }

data/ext/yrb/src/yarray.rs

@@ -1,9 +1,10 @@
+use crate::utils::convert_yvalue_to_ruby_value;
 use crate::ytransaction::YTransaction;
 use crate::yvalue::YValue;
 use lib0::any::Any;
 use magnus::block::Proc;
 use magnus::value::Qnil;
-use magnus::{Error, RArray, RHash, Symbol, Value};
+use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use yrs::types::Change;
@@ -22,20 +23,21 @@ impl YArray {
 
         let arr = self.0.borrow();
         arr.iter(tx).for_each(|val| {
-            let yvalue = YValue::from(val);
-            let args = (yvalue.into(),);
+            let yvalue = *convert_yvalue_to_ruby_value(val, tx).0.borrow();
+            let args = (yvalue,);
             let _ = block.call::<(Value,), Qnil>(args);
         });
 
         Ok(())
     }
+
     pub(crate) fn yarray_get(&self, transaction: &YTransaction, index: u32) -> Value {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
 
         let arr = self.0.borrow();
         let v = arr.get(tx, index).unwrap();
-        YValue::from(v).into()
+        *convert_yvalue_to_ruby_value(v, tx).0.borrow()
     }
     pub(crate) fn yarray_insert(&self, transaction: &YTransaction, index: u32, value: Value) {
         let yvalue = YValue::from(value);
@@ -98,10 +100,10 @@ impl YArray {
                                 payload.aset(change_added, values)
                             }
                             Change::Retain(position) => {
-                                payload.aset(change_retain, Value::from(*position))
+                                payload.aset(change_retain, (*position).into_value())
                             }
                             Change::Removed(position) => {
-                                payload.aset(change_removed, Value::from(*position))
+                                payload.aset(change_removed, (*position).into_value())
                             }
                         };
 

data/ext/yrb/src/yattrs.rs

@@ -3,7 +3,7 @@ use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
 use magnus::{RHash, Value};
 use std::ops::{Deref, DerefMut};
-use std::rc::Rc;
+use std::sync::Arc;
 use yrs::types::Attrs;
 
 pub(crate) struct YAttrs(pub(crate) Attrs);
@@ -23,7 +23,7 @@ impl From<RHash> for YAttrs {
                 let k = key.to_string();
                 let yvalue = YValue::from(value);
                 let avalue = Any::from(yvalue);
-                attrs.insert(Rc::from(k), avalue);
+                attrs.insert(Arc::from(k), avalue);
 
                 Ok(Continue)
             })

data/ext/yrb/src/yawareness.rs

@@ -2,7 +2,7 @@ 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 y_sync::awareness::{Awareness, AwarenessUpdate, Event, UpdateSubscription};
 use yrs::block::ClientID;
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::Encode;
@@ -138,14 +138,14 @@ impl From<&Event> for YAwarenessEvent {
 }
 
 #[magnus::wrap(class = "Y::AwarenessEvent")]
-pub(crate) struct YAwarenessSubscription(Subscription<Event>);
+pub(crate) struct YAwarenessSubscription(UpdateSubscription);
 
 unsafe impl Send for YAwarenessSubscription {}
 
 impl YAwarenessSubscription {}
 
-impl From<Subscription<Event>> for YAwarenessSubscription {
-    fn from(v: Subscription<Event>) -> Self {
+impl From<UpdateSubscription> for YAwarenessSubscription {
+    fn from(v: UpdateSubscription) -> Self {
         YAwarenessSubscription(v)
     }
 }

data/ext/yrb/src/ydoc.rs

@@ -10,6 +10,7 @@ use magnus::{exception::runtime_error, Error, Integer, RArray, Value};
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use yrs::updates::decoder::Decode;
+use yrs::updates::encoder::{Encoder, EncoderV2};
 use yrs::{Doc, OffsetKind, Options, ReadTxn, StateVector, SubscriptionId, Transact};
 
 #[magnus::wrap(class = "Y::Doc")]
@@ -43,6 +44,21 @@ impl YDoc {
             .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
     }
 
+    pub(crate) fn ydoc_encode_diff_v2(
+        &self,
+        transaction: &YTransaction,
+        state_vector: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        let mut tx = transaction.transaction();
+        let tx = tx.as_mut().unwrap();
+        let mut encoder = EncoderV2::new();
+
+        StateVector::decode_v2(state_vector.borrow())
+            .map(|sv| tx.encode_diff(&sv, &mut encoder))
+            .map(|_| encoder.to_vec())
+            .map_err(|_e| Error::new(runtime_error(), "cannot encode diff"))
+    }
+
     pub(crate) fn ydoc_get_or_insert_array(&self, name: String) -> YArray {
         let array_ref = self.0.borrow().get_or_insert_array(name.as_str());
         YArray::from(array_ref)

data/ext/yrb/src/ymap.rs

@@ -1,4 +1,4 @@
-use crate::utils::indifferent_hash_key;
+use crate::utils::{convert_yvalue_to_ruby_value, indifferent_hash_key};
 use crate::yvalue::YValue;
 use crate::YTransaction;
 use lib0::any::Any;
@@ -30,17 +30,18 @@ impl YMap {
             Some(k) => self.0.borrow().contains_key(tx, k.as_str()),
         }
     }
+
     pub(crate) fn ymap_each(&self, transaction: &YTransaction, proc: Proc) {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
-
         self.0.borrow().iter(tx).for_each(|(key, val)| {
             let k = key.to_string();
-            let v = *YValue::from(val).0.borrow();
+            let v = *convert_yvalue_to_ruby_value(val, tx).0.borrow();
             proc.call::<(String, Value), Value>((k, v))
                 .expect("cannot iterate map");
         })
     }
+
     pub(crate) fn ymap_get(&self, transaction: &YTransaction, key: Value) -> Option<Value> {
         let tx = transaction.transaction();
         let tx = tx.as_ref().unwrap();
@@ -48,7 +49,7 @@ impl YMap {
         indifferent_hash_key(key)
             .map(|k| self.0.borrow().get(tx, k.as_str()))
             .map(|v| v.unwrap_or(YrsValue::Any(Any::Undefined)))
-            .map(|v| *YValue::from(v).0.borrow())
+            .map(|v| *convert_yvalue_to_ruby_value(v, tx).0.borrow())
     }
     pub(crate) fn ymap_insert(
         &self,

data/ext/yrb/src/ytransaction.rs

@@ -38,6 +38,17 @@ impl YTransaction {
             .map(|u| self.transaction().as_mut().unwrap().apply_update(u))
     }
 
+    pub(crate) fn ytransaction_apply_update_v2(&self, update: Vec<u8>) -> Result<(), Error> {
+        Update::decode_v2(update.as_slice())
+            .map_err(|error| {
+                Error::new(
+                    exception::runtime_error(),
+                    format!("cannot decode update: {:?}", error),
+                )
+            })
+            .map(|u| self.transaction().as_mut().unwrap().apply_update(u))
+    }
+
     pub(crate) fn ytransaction_commit(&self) {
         self.transaction().as_mut().unwrap().commit();
     }
@@ -98,6 +109,14 @@ impl YTransaction {
             .encode_v1()
     }
 
+    pub(crate) fn ytransaction_state_vector_v2(&self) -> Vec<u8> {
+        self.transaction()
+            .as_ref()
+            .unwrap()
+            .state_vector()
+            .encode_v2()
+    }
+
     pub(crate) fn ytransaction_free(&self) {
         self.0.replace(None);
     }

data/ext/yrb/src/yvalue.rs

@@ -1,8 +1,8 @@
 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::value::{Qnil, ReprValue};
+use magnus::{class, value, Float, Integer, IntoValue, RArray, RHash, RString, Symbol, Value};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use yrs::types::Value as YrsValue;
@@ -21,100 +21,100 @@ impl From<Value> for YValue {
 
 impl From<Qnil> for YValue {
     fn from(value: Qnil) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<bool> for YValue {
     fn from(value: bool) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<f64> for YValue {
     fn from(value: f64) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<i64> for YValue {
     fn from(value: i64) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<u32> for YValue {
     fn from(value: u32) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<String> for YValue {
     fn from(value: String) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<RArray> for YValue {
     fn from(value: RArray) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<RHash> for YValue {
     fn from(value: RHash) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<YrsText> for YValue {
     fn from(value: YrsText) -> Self {
-        YValue(RefCell::from(Value::from(YText(RefCell::from(value)))))
+        YValue(RefCell::from(YText(RefCell::from(value)).into_value()))
     }
 }
 
 impl From<YrsXmlElement> for YValue {
     fn from(value: YrsXmlElement) -> Self {
-        YValue(RefCell::from(Value::from(YXmlElement(RefCell::from(
-            value,
-        )))))
+        YValue(RefCell::from(
+            YXmlElement(RefCell::from(value)).into_value(),
+        ))
     }
 }
 
 impl From<YrsXmlText> for YValue {
     fn from(value: YrsXmlText) -> Self {
-        YValue(RefCell::from(Value::from(YXmlText(RefCell::from(value)))))
+        YValue(RefCell::from(YXmlText(RefCell::from(value)).into_value()))
     }
 }
 
 impl From<YText> for YValue {
     fn from(value: YText) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<YXmlElement> for YValue {
     fn from(value: YXmlElement) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<YXmlText> for YValue {
     fn from(value: YXmlText) -> Self {
-        YValue(RefCell::from(Value::from(value)))
+        YValue(RefCell::from(value.into_value()))
     }
 }
 
 impl From<Any> for YValue {
     fn from(value: Any) -> Self {
         match value {
-            Any::Null => YValue::from(QNIL),
-            Any::Undefined => YValue::from(QNIL),
+            Any::Null => YValue::from(value::qnil()),
+            Any::Undefined => YValue::from(value::qnil()),
             Any::Bool(v) => YValue::from(v),
             Any::Number(v) => YValue::from(v),
             Any::BigInt(v) => YValue::from(v),
             Any::String(v) => YValue::from(v.into_string()),
-            Any::Buffer(v) => YValue::from(Value::from(v.into_vec())),
+            Any::Buffer(v) => YValue::from(v.into_vec().into_value()),
             Any::Array(v) => {
                 let arr = RArray::new();
                 for item in v.iter() {
@@ -146,16 +146,18 @@ impl From<YrsValue> for YValue {
             YrsValue::YXmlElement(el) => YValue::from(el),
             YrsValue::YXmlText(text) => YValue::from(text),
             YrsValue::YArray(val) => {
+                print!("try to acquire transaction");
                 let tx = val.transact();
                 let arr = RArray::new();
                 for item in val.iter(&tx) {
                     let val = YValue::from(item.clone());
-                    let val = val.0.borrow().clone();
+                    let val = *val.0.borrow();
                     arr.push(val).expect("cannot push item event to array");
                 }
                 YValue::from(arr)
             }
             YrsValue::YMap(val) => {
+                print!("try to acquire transaction");
                 let tx = val.transact();
                 let iter = val.iter(&tx).map(|(key, val)| {
                     let val = YValue::from(val);
@@ -237,6 +239,7 @@ impl Into<Value> for YValue {
 mod tests {
     use crate::yvalue::YValue;
     use lib0::any::Any;
+    use magnus::value::ReprValue;
 
     #[test]
     fn convert_any_to_yvalue() {

data/ext/yrb/src/yxml_element.rs

@@ -3,7 +3,7 @@ use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
 use crate::YTransaction;
 use magnus::block::Proc;
-use magnus::{Error, RArray, RHash, Symbol, Value};
+use magnus::{Error, IntoValue, RArray, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::Change;
 use yrs::{
@@ -32,9 +32,9 @@ impl YXmlElement {
         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)),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
     pub(crate) fn yxml_element_get_attribute(
@@ -93,9 +93,9 @@ impl YXmlElement {
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().siblings(tx).next().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)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
     pub(crate) fn yxml_element_observe(&self, block: Proc) -> Result<u32, Error> {
@@ -161,9 +161,9 @@ impl YXmlElement {
     }
     pub(crate) fn yxml_element_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)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
     pub(crate) fn yxml_element_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
@@ -175,9 +175,9 @@ impl YXmlElement {
             .siblings(tx)
             .next_back()
             .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)),
+                XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+                XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+                XmlNode::Text(text) => YXmlText::from(text).into_value(),
             })
     }
     pub(crate) fn yxml_element_push_element_back(
@@ -246,9 +246,9 @@ impl YXmlElement {
         let tx = tx.as_ref().unwrap();
 
         let siblings = self.0.borrow().siblings(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)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         });
 
         RArray::from_iter(siblings)

data/ext/yrb/src/yxml_fragment.rs

@@ -1,7 +1,7 @@
 use crate::ytransaction::YTransaction;
 use crate::yxml_element::YXmlElement;
 use crate::yxml_text::YXmlText;
-use magnus::{RArray, Value};
+use magnus::{IntoValue, RArray, Value};
 use std::cell::RefCell;
 use yrs::{GetString, XmlElementPrelim, XmlFragment, XmlFragmentRef, XmlNode};
 
@@ -14,9 +14,9 @@ unsafe impl Send for 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)),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
 
@@ -29,9 +29,9 @@ impl YXmlFragment {
         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)),
+            XmlNode::Element(element) => YXmlElement::from(element).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
 
@@ -57,9 +57,9 @@ impl YXmlFragment {
 
     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)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         })
     }
 
@@ -106,9 +106,9 @@ impl YXmlFragment {
         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)),
+            XmlNode::Element(el) => YXmlElement::from(el).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment::from(fragment).into_value(),
+            XmlNode::Text(text) => YXmlText::from(text).into_value(),
         });
 
         RArray::from_iter(result)

data/ext/yrb/src/yxml_text.rs

@@ -3,7 +3,7 @@ use crate::yvalue::YValue;
 use crate::yxml_fragment::YXmlFragment;
 use crate::{YTransaction, YXmlElement};
 use lib0::any::Any;
-use magnus::{Error, RHash, Value};
+use magnus::{Error, IntoValue, RHash, Value};
 use std::cell::RefCell;
 use yrs::{GetString, Text, Xml, XmlNode, XmlTextRef};
 
@@ -120,16 +120,16 @@ impl YXmlText {
         let tx = tx.as_ref().unwrap();
 
         self.0.borrow().siblings(tx).next().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment(RefCell::from(fragment))),
-            XmlNode::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+            XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment(RefCell::from(fragment)).into_value(),
+            XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value(),
         })
     }
     pub(crate) fn yxml_text_parent(&self) -> Option<Value> {
         self.0.borrow().parent().map(|item| match item {
-            XmlNode::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-            XmlNode::Fragment(fragment) => Value::from(YXmlFragment(RefCell::from(fragment))),
-            XmlNode::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+            XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value(),
+            XmlNode::Fragment(fragment) => YXmlFragment(RefCell::from(fragment)).into_value(),
+            XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value(),
         })
     }
     pub(crate) fn yxml_text_prev_sibling(&self, transaction: &YTransaction) -> Option<Value> {
@@ -141,9 +141,9 @@ impl YXmlText {
             .siblings(tx)
             .next_back()
             .map(|item| match item {
-                XmlNode::Element(el) => Value::from(YXmlElement(RefCell::from(el))),
-                XmlNode::Fragment(fragment) => Value::from(YXmlFragment(RefCell::from(fragment))),
-                XmlNode::Text(text) => Value::from(YXmlText(RefCell::from(text))),
+                XmlNode::Element(el) => YXmlElement(RefCell::from(el)).into_value(),
+                XmlNode::Fragment(fragment) => YXmlFragment(RefCell::from(fragment)).into_value(),
+                XmlNode::Text(text) => YXmlText(RefCell::from(text)).into_value(),
             })
     }
     pub(crate) fn yxml_text_push(&self, transaction: &YTransaction, content: String) {

data/lib/y/doc.rb

@@ -19,6 +19,9 @@ module Y
     ZERO_STATE = [0].freeze
     private_constant :ZERO_STATE
 
+    ZERO_STATE_V2 = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0].freeze
+    private_constant :ZERO_STATE_V2
+
     # Attach a listener to document changes. If one of the data structures is
     # changes, the block is called with the update as its only argument.
     #
@@ -55,6 +58,16 @@ module Y
       current_transaction { |tx| ydoc_encode_diff_v1(tx, state) }
     end
 
+    # Create a v2 diff between this document and another document. The diff is
+    # created based on a state vector provided by the other document. It only
+    # returns the missing blocks, as binary encoded sequence.
+    #
+    # @param state [::Array<Integer>] The state to create the diff against
+    # @return [::Array<Integer>] Binary encoded diff
+    def diff_v2(state = ZERO_STATE_V2)
+      current_transaction { |tx| ydoc_encode_diff_v2(tx, state) }
+    end
+
     # Creates a full diff for the current document. It is similar to {#diff},
     # but does not take a state. Instead it creates an empty state and passes it
     # to the encode_diff function.
@@ -152,6 +165,14 @@ module Y
       current_transaction(&:state)
     end
 
+    # Creates a v2 state vector of this document. This can be used to compare
+    # the state of two documents with each other and to later on sync them.
+    #
+    # @return [::Array<Integer>] Binary encoded state vector
+    def state_v2
+      current_transaction(&:state_v2)
+    end
+
     # Synchronizes this document with the diff from another document
     #
     # @param diff [::Array<Integer>] Binary encoded update
@@ -160,6 +181,14 @@ module Y
       current_transaction { |tx| tx.apply(diff) }
     end
 
+    # Synchronizes this document with the v2 diff from another document
+    #
+    # @param diff [::Array<Integer>] Binary encoded update
+    # @return [void]
+    def sync_v2(diff)
+      current_transaction { |tx| tx.apply_v2(diff) }
+    end
+
     # Restores a specific document from an update that contains full state
     #
     # This is doing the same as {#sync}, but it exists to be explicit about
@@ -211,6 +240,17 @@ module Y
     # @return [Array<Integer>] Binary encoded update
     # @!visibility private
 
+    # @!method ydoc_encode_diff_v2(tx, state_vector)
+    #   Encodes the diff of current document state vs provided state in the v2
+    #   format
+    #
+    #   @example Create transaction on doc
+    #     doc = Y::Doc.new
+    #     tx = doc.ydoc_encode_diff_v2(other_state)
+    #
+    # @return [Array<Integer>] Binary encoded update
+    # @!visibility private
+
     # @!method ydoc_transact
     #   Creates a new transaction for the document
     #

data/lib/y/transaction.rb

@@ -22,6 +22,15 @@ module Y
       ytransaction_apply_update(update)
     end
 
+    # Applies the v2 encoded update on this document. This will bring the
+    # the document to the same state as the one the update is from.
+    #
+    # @param update [::Array<Integer>]
+    # @return [void]
+    def apply_v2(update)
+      ytransaction_apply_update_v2(update)
+    end
+
     # Commits transaction
     #
     # @return [void]
@@ -89,15 +98,29 @@ module Y
       xml_text
     end
 
-    # Return state vector for transaction
+    # Return a state vector for this transaction
     #
     # @return [::Array<Integer>]
     def state
       ytransaction_state_vector
     end
 
+    # Returns a v2 state vector for this transaction
+    #
+    # @return [::Array<Integer>]
+    def state_v2
+      ytransaction_state_vector_v2
+    end
+
     # @!method ytransaction_apply_update(update)
-    #   Returns or creates an array by name
+    #   Apply the encoded update within current transaction
+    #
+    # @param update [::Array<Integer>]
+    # @return [void]
+    # @!visibility private
+
+    # @!method ytransaction_apply_update_v2(update)
+    #   Apply the v2 encoded update within current transaction
     #
     # @param update [::Array<Integer>]
     # @return [void]
@@ -157,5 +180,10 @@ module Y
     #
     # @return [Array<Integer>]
     # @!visibility private
+
+    # @!method ytransaction_state_vector_v2
+    #
+    # @return [Array<Integer>]
+    # @!visibility private
   end
 end

data/lib/y/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: x64-mingw-ucrt
 authors:
 - Hannes Moser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-07 00:00:00.000000000 Z
+date: 2023-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -129,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.21
+      version: 3.3.22
 requirements: []
 rubygems_version: 3.4.4
 signing_key: