y-rb 0.5.4-x86_64-linux-musl → 0.5.6-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 788558d1de7d84c49f497c1e5a29cec59993e961d54d2c61a528a12d68b5f3cc
-  data.tar.gz: 07e32965a915851316a07face32dad338b3ef7e9eafd2ceff624b095ef52c00f
+  metadata.gz: d25aad2a9891584f1bf7b38ae079d545865e01f78801833e724a0ccfa687a48e
+  data.tar.gz: 3d36b2d52e4de1d41fac2bb1c61ce32e989dae6bff229ddcd6064142038ca944
 SHA512:
-  metadata.gz: 0c02c5edc430897380f0209a3da94b2f722cac47aebf82c6e4862a3ec0655d0681e8dbe8eb1dc94294800c6f73ca53630d3e648b5bd8463d86144bdc5771139e
-  data.tar.gz: fb48828b396c7ab4c76b31a0af97f91100f66d86c91096c694bc7a78f3ec8784c24f130bc9253b5e74ee266cb6ac1550b3321431f0db1d0e2130355d150e81db
+  metadata.gz: b4e2481156a59a31d1f29428385d5fba09789d3a50f15d875263cb97281f41449da844bb013f351e9516c76048ffe7aabe318aa304fa8acf50bb16016b04634c
+  data.tar.gz: 8be31c22d073f042d9864fb1d4e917879357256454aab8c362a86eb51b3fd95b0430fdeb6bdb3ba2a913a464d434919635549d50604d3df2dd187e83c1d5ff71

data/ext/yrb/Cargo.toml

@@ -1,18 +1,17 @@
 [package]
 name = "yrb"
-version = "0.5.4"
+version = "0.5.6"
 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/lib.rs

@@ -2,6 +2,7 @@ extern crate core;
 
 use crate::yarray::YArray;
 use crate::yawareness::{YAwareness, YAwarenessEvent};
+use crate::ydiff::YDiff;
 use crate::ydoc::YDoc;
 use crate::ymap::YMap;
 use crate::ytext::YText;
@@ -9,6 +10,7 @@ use crate::ytransaction::YTransaction;
 use crate::yxml_element::YXmlElement;
 use crate::yxml_fragment::YXmlFragment;
 use crate::yxml_text::YXmlText;
+
 use magnus::{class, define_module, function, method, Error, Module, Object};
 
 mod utils;
@@ -16,6 +18,7 @@ mod yany;
 mod yarray;
 mod yattrs;
 mod yawareness;
+mod ydiff;
 mod ydoc;
 mod ymap;
 mod ytext;
@@ -224,6 +227,9 @@ fn init() -> Result<(), Error> {
         .define_class("Text", class::object())
         .expect("cannot define class Y::Text");
 
+    ytext
+        .define_private_method("ytext_diff", method!(YText::ytext_diff, 1))
+        .expect("cannot define private method: ytext_diff");
     ytext
         .define_private_method("ytext_format", method!(YText::ytext_format, 4))
         .expect("cannot define private method: ytext_format");
@@ -618,7 +624,7 @@ fn init() -> Result<(), Error> {
 
     let yawareness_event = module
         .define_class("AwarenessEvent", class::object())
-        .expect("cannot define class Y:AwarenessEvent");
+        .expect("cannot define class Y::AwarenessEvent");
     yawareness_event
         .define_method("added", method!(YAwarenessEvent::added, 0))
         .expect("cannot define private method: added");
@@ -629,5 +635,15 @@ fn init() -> Result<(), Error> {
         .define_method("removed", method!(YAwarenessEvent::removed, 0))
         .expect("cannot define private method: removed");
 
+    let ydiff = module
+        .define_class("Diff", class::object())
+        .expect("cannot define class Y::Diff");
+    ydiff
+        .define_private_method("ydiff_insert", method!(YDiff::ydiff_insert, 0))
+        .expect("cannot define private method: insert");
+    ydiff
+        .define_private_method("ydiff_attrs", method!(YDiff::ydiff_attrs, 0))
+        .expect("cannot define private method: attrs");
+
     Ok(())
 }

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,16 +1,21 @@
 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::cell::RefCell;
 use std::sync::Arc;
 use yrs::types::Attrs;
+use yrs::Any;
 
-pub(crate) struct YAttrs(pub(crate) Attrs);
+#[magnus::wrap(class = "Y::Attrs")]
+#[derive(Clone)]
+pub(crate) struct YAttrs(pub(crate) RefCell<Attrs>);
+
+/// SAFETY: This is safe because we only access this data when the GVL is held.
+unsafe impl Send for YAttrs {}
 
 impl From<Attrs> for YAttrs {
     fn from(value: Attrs) -> Self {
-        YAttrs(value)
+        YAttrs(RefCell::from(value))
     }
 }
 
@@ -29,20 +34,6 @@ impl From<RHash> for YAttrs {
             })
             .expect("cannot iterate attributes hash");
 
-        YAttrs(attrs)
-    }
-}
-
-impl Deref for YAttrs {
-    type Target = Attrs;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for YAttrs {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
+        YAttrs(RefCell::from(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/ydiff.rs

@@ -0,0 +1,19 @@
+use magnus::{IntoValue, RHash, Value};
+
+unsafe impl Send for YDiff {}
+
+#[magnus::wrap(class = "Y::Diff")]
+pub(crate) struct YDiff {
+    pub(crate) ydiff_insert: Value,
+    pub(crate) ydiff_attrs: Option<RHash>,
+}
+
+impl YDiff {
+    pub(crate) fn ydiff_insert(&self) -> Value {
+        self.ydiff_insert
+    }
+
+    pub(crate) fn ydiff_attrs(&self) -> Option<Value> {
+        self.ydiff_attrs.as_ref().map(|value| value.into_value())
+    }
+}

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,15 @@
 use crate::yattrs::YAttrs;
+use crate::ydiff::YDiff;
 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 magnus::RArray;
+pub(crate) use magnus::{Error, IntoValue, RHash, Symbol, Value};
 use std::cell::RefCell;
+use yrs::types::text::YChange;
 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>);
@@ -16,6 +18,38 @@ pub(crate) struct YText(pub(crate) RefCell<TextRef>);
 unsafe impl Send for YText {}
 
 impl YText {
+    pub(crate) fn ytext_diff(&self, transaction: &YTransaction) -> RArray {
+        let tx = transaction.transaction();
+        let tx = tx.as_ref().unwrap();
+
+        RArray::from_iter(
+            self.0
+                .borrow()
+                .diff(tx, YChange::identity)
+                .iter()
+                .map(move |diff| {
+                    let yvalue = YValue::from(diff.insert.clone());
+                    let insert = yvalue.0.into_inner();
+                    let attributes = diff.attributes.as_ref().map_or_else(
+                        || None,
+                        |boxed_attrs| {
+                            let attributes = RHash::new();
+                            for (key, value) in boxed_attrs.iter() {
+                                let key = key.to_string();
+                                let value = YValue::from(value.clone()).0.into_inner();
+                                attributes.aset(key, value).expect("cannot add value");
+                            }
+                            Some(attributes)
+                        },
+                    );
+                    YDiff {
+                        ydiff_insert: insert,
+                        ydiff_attrs: attributes,
+                    }
+                    .into_value()
+                }),
+        )
+    }
     pub(crate) fn ytext_format(
         &self,
         transaction: &YTransaction,
@@ -28,7 +62,9 @@ impl YText {
 
         let a = YAttrs::from(attrs);
 
-        self.0.borrow_mut().format(tx, index, length, a.0)
+        self.0
+            .borrow_mut()
+            .format(tx, index, length, a.0.into_inner())
     }
     pub(crate) fn ytext_insert(&self, transaction: &YTransaction, index: u32, chunk: String) {
         let mut tx = transaction.transaction();
@@ -67,7 +103,7 @@ impl YText {
 
         self.0
             .borrow_mut()
-            .insert_embed_with_attributes(tx, index, avalue, a.0);
+            .insert_embed_with_attributes(tx, index, avalue, a.0.into_inner());
     }
     pub(crate) fn ytext_insert_with_attributes(
         &self,
@@ -83,7 +119,7 @@ impl YText {
 
         self.0
             .borrow_mut()
-            .insert_with_attributes(tx, index, chunk.as_str(), a.0)
+            .insert_with_attributes(tx, index, chunk.as_str(), a.0.into_inner())
     }
     pub(crate) fn ytext_length(&self, transaction: &YTransaction) -> u32 {
         let tx = transaction.transaction();

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/array.rb

@@ -115,8 +115,8 @@ module Y
     end
 
     # @return [void]
-    def each(&block)
-      document.current_transaction { |tx| yarray_each(tx, &block) }
+    def each(...)
+      document.current_transaction { |tx| yarray_each(tx, ...) }
     end
 
     # Check if the array is empty

data/lib/y/diff.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Y
+  # A representation of an uniformly-formatted chunk of rich context stored by
+  # Text or XmlText. It contains a value (which could be a string, embedded
+  # object or another shared type) with optional formatting attributes wrapping
+  # around this chunk.
+  class Diff
+    # @return [Object]
+    def insert
+      ydiff_insert
+    end
+
+    # @return [Hash]
+    def attrs
+      ydiff_attrs
+    end
+
+    # Convert the diff to a Hash representation
+    #
+    # @return [Hash]
+    def to_h
+      {
+        insert: ydiff_insert,
+        attrs: ydiff_attrs
+      }
+    end
+
+    # @!method ydiff_insert()
+    #   Returns string representation of text
+    #
+    # @return [Object]
+
+    # @!method ydiff_attrs()
+    #
+    # @return [Hash]
+  end
+end

data/lib/y/text.rb

@@ -80,6 +80,15 @@ module Y
       ytext_unobserve(subscription_id)
     end
 
+    # Diff
+    #
+    # @return[Array<YDiff>]
+    def diff
+      document.current_transaction do |tx|
+        ytext_diff(tx)
+      end
+    end
+
     # Checks if text is empty
     #
     # @example Check if text is empty
@@ -284,6 +293,12 @@ module Y
         value.is_a?(Hash)
     end
 
+    # @!method ytext_diff(tx)
+    #   Returns text changes as list of diffs
+    #
+    # @param transaction [Y::Transaction]
+    # @return [Array<YDiff>]
+
     # @!method ytext_insert(tx, index, chunk)
     #   Insert into text at position
     #

data/lib/y/version.rb

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

data/lib/y-rb.rb

@@ -11,6 +11,7 @@ end
 
 require_relative "y/array"
 require_relative "y/awareness"
+require_relative "y/diff"
 require_relative "y/doc"
 require_relative "y/map"
 require_relative "y/text"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.6
 platform: x86_64-linux-musl
 authors:
 - Hannes Moser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-04 00:00:00.000000000 Z
+date: 2024-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -84,6 +84,7 @@ files:
 - ext/yrb/src/yarray.rs
 - ext/yrb/src/yattrs.rs
 - ext/yrb/src/yawareness.rs
+- ext/yrb/src/ydiff.rs
 - ext/yrb/src/ydoc.rs
 - ext/yrb/src/ymap.rs
 - ext/yrb/src/ytext.rs
@@ -100,6 +101,7 @@ files:
 - lib/y.rb
 - lib/y/array.rb
 - lib/y/awareness.rb
+- lib/y/diff.rb
 - lib/y/doc.rb
 - lib/y/map.rb
 - lib/y/text.rb
@@ -132,6 +134,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: 3.3.22
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
 requirements: []
 rubygems_version: 3.4.4
 signing_key: