y-rb 0.5.4-x64-mingw-ucrt → 0.5.5-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 533da572b314fe8ef66aab7e6af8fbcc914f2c791a3bc7dc8b5657ed7c4459a3
-  data.tar.gz: ecd4094eeeb22088dd5b03b1236c4865c62402bc2bc030f39752e8ea39c56f40
+  metadata.gz: e15bade8799ed742c81744064a0e852f5f029c3c32f0029c70519df908981ab3
+  data.tar.gz: 7ace1970d7dc5340f69b5edbba3157e866f160b69cd890050915e4be9e528644
 SHA512:
-  metadata.gz: eeedc58aa1446df53c1a22adeb131177fd2b55bf74e395cd662b75ec50c9df24080628d1733bd1fabcd34c09b23d501880ee9636186609c6633927cfb8453a61
-  data.tar.gz: 2b966b2428ff44377d6e531cc4d16a6f9cc2e2d2f84c8d6c93eae4960cdeefc07c0ca879e5bd99c6af0fcea567f3b2ba5a7b0acc671b469d0d314f4bb9152b56
+  metadata.gz: a7275ef35a3676dac7d40742611641b7b342ac2920374892f041ca09384dc970b4c375fd49cca5a3ded8930435262715ee60ccca4fd55d57144d3ad8f19bdf4d
+  data.tar.gz: 194a5f363558ebc1f81843593f60dd2fdb66ad166a59a5a60ceb78eda7779d08c39ff6dc4acfc0b8c22a8e589fdb6c1f87f51a3a5398e7439239ae3d000f10ed

data/ext/yrb/Cargo.toml

@@ -1,18 +1,17 @@
 [package]
 name = "yrb"
-version = "0.5.4"
+version = "0.5.5"
 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.10" # must match yrs version
-magnus = "0.6.2"
-thiserror = "1.0.56"
-yrs = "=0.16.10"
-y-sync = "=0.3.1"
-rb-sys = "0.9.86"
+magnus = "=0.6.2"
+thiserror = "1.0.57"
+yrs = "=0.17.4"
+y-sync = "=0.4.0"
+rb-sys = "0.9.90"
 
 [dev-dependencies]
 magnus = { version = "0.6.2", features = ["embed"] }

data/ext/yrb/src/utils.rs

@@ -1,10 +1,9 @@
 use crate::yvalue::YValue;
-use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
 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};
+use yrs::{Any, Array, Map, TransactionMut};
 
 #[derive(Debug, Clone)]
 pub(crate) struct TypeConversionError;

data/ext/yrb/src/yany.rs

@@ -1,9 +1,9 @@
-use lib0::any::Any;
 use magnus::r_string::IntoRString;
 use magnus::value::ReprValue;
 use magnus::{value, IntoValue, RArray, RHash, RString, Value};
 use std::borrow::Borrow;
 use std::ops::{Deref, DerefMut};
+use yrs::Any;
 
 pub(crate) struct YAny(pub(crate) Any);
 
@@ -35,11 +35,11 @@ impl TryInto<Value> for YAny {
                 Ok(hash.as_value())
             }
             Any::Null => Ok(value::qnil().as_value()),
-            Any::Undefined => Ok(Value::from(value::qnil().as_value())),
+            Any::Undefined => Ok(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::Number(v) => Ok(v.into_value()),
+            Any::BigInt(v) => Ok(v.into_value()),
+            Any::String(v) => Ok(v.into_r_string().as_value()),
             Any::Buffer(v) => Ok(RString::from_slice(v.borrow()).as_value()),
         };
     }

data/ext/yrb/src/yarray.rs

@@ -1,13 +1,12 @@
 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, IntoValue, RArray, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::Change;
-use yrs::{Array, ArrayRef, Observable};
+use yrs::{Any, Array, ArrayRef, Observable};
 
 #[magnus::wrap(class = "Y::Array")]
 pub(crate) struct YArray(pub(crate) RefCell<ArrayRef>);
@@ -175,7 +174,7 @@ impl YArray {
         let r_arr = RArray::new();
         for item in arr.iter(tx) {
             let r_val = YValue::from(item);
-            let r_val = r_val.0.borrow().clone();
+            let r_val = *r_val.0.borrow();
             r_arr.push(r_val).expect("cannot push item event to array");
         }
         r_arr

data/ext/yrb/src/yattrs.rs

@@ -1,10 +1,10 @@
 use crate::yvalue::YValue;
-use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
 use magnus::{RHash, Value};
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
 use yrs::types::Attrs;
+use yrs::Any;
 
 pub(crate) struct YAttrs(pub(crate) Attrs);
 

data/ext/yrb/src/yawareness.rs

@@ -17,10 +17,10 @@ unsafe impl Send for YAwareness {}
 impl YAwareness {
     pub(crate) fn yawareness_new() -> Self {
         let mut options = Options {
-            offset_kind: OffsetKind::Utf32,
+            offset_kind: OffsetKind::Utf16,
             ..Default::default()
         };
-        options.offset_kind = OffsetKind::Utf32;
+        options.offset_kind = OffsetKind::Utf16;
 
         let doc = Doc::with_options(options);
 

data/ext/yrb/src/ydoc.rs

@@ -25,7 +25,7 @@ impl YDoc {
             let value = client_id.first().unwrap();
             options.client_id = Integer::from_value(*value).unwrap().to_u64().unwrap();
         }
-        options.offset_kind = OffsetKind::Utf32;
+        options.offset_kind = OffsetKind::Utf16;
 
         let doc = Doc::with_options(options);
         Self(RefCell::new(doc))
@@ -89,7 +89,7 @@ impl YDoc {
         YXmlText::from(xml_text_ref)
     }
 
-    pub(crate) fn ydoc_transact<'doc>(&self) -> YTransaction {
+    pub(crate) fn ydoc_transact(&self) -> YTransaction {
         let doc = self.0.borrow();
         let transaction = doc.transact_mut();
         YTransaction::from(transaction)

data/ext/yrb/src/ymap.rs

@@ -1,12 +1,11 @@
 use crate::utils::{convert_yvalue_to_ruby_value, indifferent_hash_key};
 use crate::yvalue::YValue;
 use crate::YTransaction;
-use lib0::any::Any;
 use magnus::block::Proc;
 use magnus::{exception, Error, RArray, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::{EntryChange, Value as YrsValue};
-use yrs::{Map, MapRef, Observable};
+use yrs::{Any, Map, MapRef, Observable};
 
 #[magnus::wrap(class = "Y::Map")]
 pub(crate) struct YMap(pub(crate) RefCell<MapRef>);

data/ext/yrb/src/ytext.rs

@@ -1,13 +1,12 @@
 use crate::yattrs::YAttrs;
 use crate::yvalue::YValue;
 use crate::YTransaction;
-use lib0::any::Any;
 use magnus::block::Proc;
 use magnus::value::Qnil;
 use magnus::{Error, RHash, Symbol, Value};
 use std::cell::RefCell;
 use yrs::types::Delta;
-use yrs::{GetString, Observable, Text, TextRef};
+use yrs::{Any, GetString, Observable, Text, TextRef};
 
 #[magnus::wrap(class = "Y::Text")]
 pub(crate) struct YText(pub(crate) RefCell<TextRef>);

data/ext/yrb/src/yvalue.rs

@@ -1,13 +1,13 @@
 use crate::{YText, YXmlElement, YXmlText};
-use lib0::any::Any;
 use magnus::r_hash::ForEach::Continue;
 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 std::sync::Arc;
 use yrs::types::Value as YrsValue;
 use yrs::{
-    Array, Map, TextRef as YrsText, Transact, XmlElementRef as YrsXmlElement,
+    Any, Array, Map, TextRef as YrsText, Transact, XmlElementRef as YrsXmlElement,
     XmlTextRef as YrsXmlText,
 };
 
@@ -67,6 +67,12 @@ impl From<RHash> for YValue {
     }
 }
 
+impl From<Vec<u8>> for YValue {
+    fn from(value: Vec<u8>) -> Self {
+        YValue(RefCell::from(value.into_value()))
+    }
+}
+
 impl From<YrsText> for YValue {
     fn from(value: YrsText) -> Self {
         YValue(RefCell::from(YText(RefCell::from(value)).into_value()))
@@ -113,13 +119,13 @@ impl From<Any> for YValue {
             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(v.into_vec().into_value()),
+            Any::String(v) => YValue::from(v.to_string()),
+            Any::Buffer(v) => YValue::from(v.to_vec()),
             Any::Array(v) => {
                 let arr = RArray::new();
                 for item in v.iter() {
                     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)
@@ -146,7 +152,6 @@ 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) {
@@ -157,7 +162,6 @@ impl From<YrsValue> for YValue {
                 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);
@@ -184,14 +188,14 @@ impl From<YValue> for Any {
             Any::BigInt(i.to_i64().unwrap())
         } else if value.is_kind_of(class::symbol()) {
             let s = Symbol::from_value(value).unwrap();
-            Any::String(Box::from(s.name().unwrap()))
+            Any::String(Arc::from(s.name().unwrap()))
         } else if value.is_kind_of(class::true_class()) {
             Any::Bool(true)
         } else if value.is_kind_of(class::false_class()) {
             Any::Bool(false)
         } else if value.is_kind_of(class::string()) {
             let s = RString::from_value(value).unwrap();
-            unsafe { Any::String(Box::from(s.as_str().unwrap().to_string())) }
+            unsafe { Any::String(Arc::from(s.as_str().unwrap().to_string())) }
         } else if value.is_kind_of(class::array()) {
             let arr = RArray::from_value(value).unwrap();
             let items = arr
@@ -201,7 +205,7 @@ impl From<YValue> for Any {
                     Any::from(yvalue)
                 })
                 .collect::<Vec<Any>>();
-            Any::Array(Box::from(items))
+            Any::Array(Arc::from(items))
         } else if value.is_kind_of(class::hash()) {
             let map = RHash::from_value(value).unwrap();
             let mut m: HashMap<String, Any> = HashMap::new();
@@ -221,7 +225,7 @@ impl From<YValue> for Any {
             })
             .expect("cannot map key/value pair");
 
-            Any::Map(Box::from(m))
+            Any::Map(Arc::from(m))
         } else {
             Any::Undefined
         }
@@ -238,8 +242,8 @@ impl Into<Value> for YValue {
 #[cfg(test)]
 mod tests {
     use crate::yvalue::YValue;
-    use lib0::any::Any;
     use magnus::value::ReprValue;
+    use yrs::Any;
 
     #[test]
     fn convert_any_to_yvalue() {

data/ext/yrb/src/yxml_element.rs

@@ -116,7 +116,7 @@ impl YXmlElement {
                             let values = RArray::new();
                             for value in v.iter() {
                                 let value = YValue::from(value.clone());
-                                let value = value.0.borrow().clone();
+                                let value = *value.0.borrow();
                                 values.push(value).expect("cannot push value to array");
                             }
 

data/ext/yrb/src/yxml_text.rs

@@ -2,10 +2,9 @@ use crate::utils::map_rhash_to_attrs;
 use crate::yvalue::YValue;
 use crate::yxml_fragment::YXmlFragment;
 use crate::{YTransaction, YXmlElement};
-use lib0::any::Any;
 use magnus::{Error, IntoValue, RHash, Value};
 use std::cell::RefCell;
-use yrs::{GetString, Text, Xml, XmlNode, XmlTextRef};
+use yrs::{Any, GetString, Text, Xml, XmlNode, XmlTextRef};
 
 #[magnus::wrap(class = "Y::XMLText")]
 pub(crate) struct YXmlText(pub(crate) RefCell<XmlTextRef>);

data/lib/y/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
 platform: x64-mingw-ucrt
 authors:
 - Hannes Moser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-04 00:00:00.000000000 Z
+date: 2024-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake