y-rb 0.5.4-x86_64-darwin → 0.5.5-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0c5851c26f8bb996bebcfc8faddd5dea8511450b22ca737d6cab136dea3b760
-  data.tar.gz: 41d7675949a473ca6ae6bc7f47ff9c20ef804cdeca35bd693bc43bb87905ffa6
+  metadata.gz: 18f531e7e42a6c7c66abc0a3f0c5004aa914de09e63d39f219d08168612b7b43
+  data.tar.gz: cafa15eaa03f50c7c4ddd38d478eb10aeed14b7a4505284b2061104d943e1f7f
 SHA512:
-  metadata.gz: 7fab8f0e578f584f5c20d5b19a0ed685851439f75d1cccc25b7032d1f27c7fc4173c33a8b29fb6324acd126a6bc8567c0f0690e21c089945375d89c61e55b322
-  data.tar.gz: 7cee7b4d330979e07766d4f4970c7e9fec9ad5480f334e15c536b92f12b79c6cf7e859f74ab80ee7f57718b3be009c8abd2e6e7fc70273a7746e0a29c756898e
+  metadata.gz: '028d511786a26110a5b43ed9c2bd53f52629ba1bbf0f9c7c7409323d6e826aedf490d4778ed2e8400be78fc022a87087ed0910839b7d9df973c06d08f7f103e4'
+  data.tar.gz: 28cf7d3981e34bbbe7e76c0caf89df89a3991aa4f58981a2246d625ec21b48bc47a4e25f6bd42295d0ef405f96ed94680b14b29da35f5bd22a255d90eb28077e

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: x86_64-darwin
 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