y-rb 0.1.4.beta.1-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7b26ac724af9d4b0fc590d540530c7e69431d1a36733aa9177a6c1b22ccddbb
+  data.tar.gz: db1e43b3cc5a8c23cd72f3517cc6c1d694ec84dc032e89527176256c3071b2c3
+SHA512:
+  metadata.gz: 2a70dfdff926644b02d01166038d346194fa814014193ef16d592f7b40fe8a1cc16fabff1f15b526fde4ef0a3e47c57d3e8303f4c2804e7573ac0d93d139be38
+  data.tar.gz: d3ac2f35a9c9c1e0f35db7dd65f107730dfb8e68a8975d79cfcab13d4c82ac6d233f748bc1a58f00047b3fe3279e8d7031a2bbca07c3e1ef6846a3090895ad3f

data/ext/yrb/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "yrb"
+version = "0.1.4"
+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.12.0" # must match yrs version
+magnus = { git = "https://github.com/matsadler/magnus" } # waiting for release with full rb-sys backend
+yrs = "0.12.0"
+
+[dev-dependencies]
+magnus = { git = "https://github.com/matsadler/magnus", features = ["embed"] } # waiting for release with full rb-sys backend
+
+[lib]
+name = "yrb"
+crate-type = ["cdylib"]

data/ext/yrb/extconf.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("yrb") do |r|
+  if r.target&.include? "musl"
+    r.extra_rustflags = %w[-C target-feature=-crt-static]
+  end
+end

data/ext/yrb/src/lib.rs

@@ -0,0 +1,476 @@
+use crate::yarray::YArray;
+use crate::ydoc::YDoc;
+use crate::ymap::YMap;
+use crate::ytext::YText;
+use crate::ytransaction::YTransaction;
+use crate::yxml_element::YXmlElement;
+use crate::yxml_text::YXmlText;
+use magnus::{define_module, function, method, Error, Module, Object};
+
+mod utils;
+mod yany;
+mod yarray;
+mod yattrs;
+mod ydoc;
+mod ymap;
+mod ytext;
+mod ytransaction;
+mod yvalue;
+mod yxml_element;
+mod yxml_text;
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let module = define_module("Y").expect("cannot define ::Y module");
+
+    let yarray = module
+        .define_class("Array", Default::default())
+        .expect("cannot find class Y::Array");
+
+    yarray
+        .define_private_method("yarray_each", method!(YArray::yarray_each, 1))
+        .expect("cannot define private method: yarray_each");
+    yarray
+        .define_private_method("yarray_get", method!(YArray::yarray_get, 1))
+        .expect("cannot define private method: yarray_get");
+    yarray
+        .define_private_method(
+            "yarray_insert",
+            method!(YArray::yarray_insert, 3)
+        )
+        .expect("cannot define private method: yarray_insert");
+    yarray
+        .define_private_method(
+            "yarray_insert_range",
+            method!(YArray::yarray_insert_range, 3)
+        )
+        .expect("cannot define private method: yarray_insert_range");
+    yarray
+        .define_private_method(
+            "yarray_length",
+            method!(YArray::yarray_length, 0)
+        )
+        .expect("cannot define private method: yarray_length");
+    yarray
+        .define_private_method(
+            "yarray_observe",
+            method!(YArray::yarray_observe, 1)
+        )
+        .expect("cannot define private method: yarray_observe");
+    yarray
+        .define_private_method(
+            "yarray_push_back",
+            method!(YArray::yarray_push_back, 2)
+        )
+        .expect("cannot define private method: yarray_push_back");
+    yarray
+        .define_private_method(
+            "yarray_push_front",
+            method!(YArray::yarray_push_front, 2)
+        )
+        .expect("cannot define private method: yarray_push_front");
+    yarray
+        .define_private_method(
+            "yarray_remove",
+            method!(YArray::yarray_remove, 2)
+        )
+        .expect("cannot define private method: yarray_remove");
+    yarray
+        .define_private_method(
+            "yarray_remove_range",
+            method!(YArray::yarray_remove_range, 3)
+        )
+        .expect("cannot define private method: yarray_remove_range");
+    yarray
+        .define_private_method("yarray_to_a", method!(YArray::yarray_to_a, 0))
+        .expect("cannot define private method: yarray_to_a");
+    yarray
+        .define_private_method(
+            "yarray_unobserve",
+            method!(YArray::yarray_unobserve, 1)
+        )
+        .expect("cannot define private method: yarray_unobserve");
+
+    let ydoc = module
+        .define_class("Doc", Default::default())
+        .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_transact",
+        method!(YDoc::ydoc_transact, 0)
+    )
+    .expect("cannot define private method: ydoc_transact");
+    ydoc.define_private_method(
+        "ydoc_encode_diff_v1",
+        method!(YDoc::ydoc_encode_diff_v1, 1)
+    )
+    .expect("cannot define private method: ydoc_encode_diff_v1");
+
+    let ymap = module
+        .define_class("Map", Default::default())
+        .expect("cannot define class Y::Map");
+
+    ymap.define_private_method("ymap_clear", method!(YMap::ymap_clear, 1))
+        .expect("cannot define private method: ymap_clear");
+    ymap.define_private_method(
+        "ymap_contains",
+        method!(YMap::ymap_contains, 1)
+    )
+    .expect("cannot define private method: ymap_contains");
+    ymap.define_private_method("ymap_each", method!(YMap::ymap_each, 1))
+        .expect("cannot define private method: ymap_each");
+    ymap.define_private_method("ymap_get", method!(YMap::ymap_get, 1))
+        .expect("cannot define private method: ymap_get");
+    ymap.define_private_method("ymap_insert", method!(YMap::ymap_insert, 3))
+        .expect("cannot define private method: ymap_insert");
+    ymap.define_private_method("ymap_observe", method!(YMap::ymap_observe, 1))
+        .expect("cannot define private method: ymap_observe");
+    ymap.define_private_method("ymap_remove", method!(YMap::ymap_remove, 2))
+        .expect("cannot define private method: ymap_remove");
+    ymap.define_private_method("ymap_size", method!(YMap::ymap_size, 0))
+        .expect("cannot define private method: ymap_size");
+    ymap.define_private_method("ymap_to_h", method!(YMap::ymap_to_h, 0))
+        .expect("cannot define private method: ymap_to_h");
+    ymap.define_private_method(
+        "ymap_unobserve",
+        method!(YMap::ymap_unobserve, 1)
+    )
+    .expect("cannot define private method: ymap_unobserve");
+
+    let ytransaction = module
+        .define_class("Transaction", Default::default())
+        .expect("cannot define class Y::Transaction");
+
+    ytransaction
+        .define_private_method(
+            "ytransaction_apply_update",
+            method!(YTransaction::ytransaction_apply_update, 1)
+        )
+        .expect("cannot define private method: ytransaction_apply_update");
+    ytransaction
+        .define_private_method(
+            "ytransaction_commit",
+            method!(YTransaction::ytransaction_commit, 0)
+        )
+        .expect("cannot define private method: ytransaction_commit");
+    ytransaction
+        .define_private_method(
+            "ytransaction_get_array",
+            method!(YTransaction::ytransaction_get_array, 1)
+        )
+        .expect("cannot define private method: ytransaction_get_array");
+    ytransaction
+        .define_private_method(
+            "ytransaction_get_map",
+            method!(YTransaction::ytransaction_get_map, 1)
+        )
+        .expect("cannot define private method: ytransaction_get_mao");
+    ytransaction
+        .define_private_method(
+            "ytransaction_get_text",
+            method!(YTransaction::ytransaction_get_text, 1)
+        )
+        .expect("cannot define private method: ytransaction_get_text");
+    ytransaction
+        .define_private_method(
+            "ytransaction_get_xml_element",
+            method!(YTransaction::ytransaction_get_xml_element, 1)
+        )
+        .expect("cannot define private method: ytransaction_get_xml_element");
+    ytransaction
+        .define_private_method(
+            "ytransaction_get_xml_text",
+            method!(YTransaction::ytransaction_get_xml_text, 1)
+        )
+        .expect("cannot define private method: ytransaction_get_xml_text");
+    ytransaction
+        .define_private_method(
+            "ytransaction_state_vector",
+            method!(YTransaction::ytransaction_state_vector, 0)
+        )
+        .expect("cannot define private method: ytransaction_state_vector");
+
+    let ytext = module
+        .define_class("Text", Default::default())
+        .expect("cannot define class Y::Text");
+
+    ytext
+        .define_private_method("ytext_format", method!(YText::ytext_format, 4))
+        .expect("cannot define private method: ytext_format");
+    ytext
+        .define_private_method("ytext_insert", method!(YText::ytext_insert, 3))
+        .expect("cannot define private method: ytext_insert");
+    ytext
+        .define_private_method(
+            "ytext_insert_embed",
+            method!(YText::ytext_insert_embed, 3)
+        )
+        .expect("cannot define private method: ytext_insert_embed");
+    ytext
+        .define_private_method(
+            "ytext_insert_embed_with_attributes",
+            method!(YText::ytext_insert_embed_with_attributes, 4)
+        )
+        .expect(
+            "cannot define private method: ytext_insert_embed_with_attributes"
+        );
+    ytext
+        .define_private_method(
+            "ytext_insert_with_attributes",
+            method!(YText::ytext_insert_with_attributes, 4)
+        )
+        .expect("cannot define private method: ytext_insert_with_attributes");
+    ytext
+        .define_private_method("ytext_length", method!(YText::ytext_length, 0))
+        .expect("cannot define private method: ytext_length");
+    ytext
+        .define_private_method(
+            "ytext_observe",
+            method!(YText::ytext_observe, 1)
+        )
+        .expect("cannot define private method: ytext_observe");
+    ytext
+        .define_private_method("ytext_push", method!(YText::ytext_push, 2))
+        .expect("cannot define private method: ytext_push");
+    ytext
+        .define_private_method(
+            "ytext_remove_range",
+            method!(YText::ytext_remove_range, 3)
+        )
+        .expect("cannot define private method: ytext_remove_range");
+    ytext
+        .define_private_method("ytext_to_s", method!(YText::ytext_to_s, 0))
+        .expect("cannot define private method: ytext_to_s");
+    ytext
+        .define_private_method(
+            "ytext_unobserve",
+            method!(YText::ytext_unobserve, 1)
+        )
+        .expect("cannot define private method: ytext_unobserve");
+
+    let yxml_element = module
+        .define_class("XMLElement", Default::default())
+        .expect("cannot define class Y::XMLElement");
+
+    yxml_element
+        .define_private_method(
+            "yxml_element_attributes",
+            method!(YXmlElement::yxml_element_attributes, 0)
+        )
+        .expect("cannot define private method: yxml_element_attributes");
+    yxml_element
+        .define_private_method(
+            "yxml_element_first_child",
+            method!(YXmlElement::yxml_element_first_child, 0)
+        )
+        .expect("cannot define private method: yxml_element_first_child");
+    yxml_element
+        .define_private_method(
+            "yxml_element_get",
+            method!(YXmlElement::yxml_element_get, 1)
+        )
+        .expect("cannot define private method: yxml_element_get");
+    yxml_element
+        .define_private_method(
+            "yxml_element_get_attribute",
+            method!(YXmlElement::yxml_element_get_attribute, 1)
+        )
+        .expect("cannot define private method: yxml_element_get_attribute");
+    yxml_element
+        .define_private_method(
+            "yxml_element_insert_attribute",
+            method!(YXmlElement::yxml_element_insert_attribute, 3)
+        )
+        .expect("cannot define private method: yxml_element_insert_attribute");
+    yxml_element
+        .define_private_method(
+            "yxml_element_insert_element",
+            method!(YXmlElement::yxml_element_insert_element, 3)
+        )
+        .expect("cannot define private method: yxml_element_insert_element");
+    yxml_element
+        .define_private_method(
+            "yxml_element_insert_text",
+            method!(YXmlElement::yxml_element_insert_text, 2)
+        )
+        .expect("cannot define private method: yxml_element_insert_text");
+    yxml_element
+        .define_private_method(
+            "yxml_element_next_sibling",
+            method!(YXmlElement::yxml_element_next_sibling, 0)
+        )
+        .expect("cannot define private method: yxml_element_next_sibling");
+    yxml_element
+        .define_private_method(
+            "yxml_element_observe",
+            method!(YXmlElement::yxml_element_observe, 1)
+        )
+        .expect("cannot define private method: yxml_element_observe");
+    yxml_element
+        .define_private_method(
+            "yxml_element_parent",
+            method!(YXmlElement::yxml_element_parent, 0)
+        )
+        .expect("cannot define private method: yxml_element_parent");
+    yxml_element
+        .define_private_method(
+            "yxml_element_prev_sibling",
+            method!(YXmlElement::yxml_element_prev_sibling, 0)
+        )
+        .expect("cannot define private method: yxml_element_prev_sibling");
+    yxml_element
+        .define_private_method(
+            "yxml_element_push_elem_back",
+            method!(YXmlElement::yxml_element_push_element_back, 2)
+        )
+        .expect("cannot define private method: yxml_element_push_elem_back");
+    yxml_element
+        .define_private_method(
+            "yxml_element_push_elem_front",
+            method!(YXmlElement::yxml_element_push_element_front, 2)
+        )
+        .expect("cannot define private method: yxml_element_push_elem_front");
+    yxml_element
+        .define_private_method(
+            "yxml_element_push_text_back",
+            method!(YXmlElement::yxml_element_push_text_back, 1)
+        )
+        .expect("cannot define private method: yxml_element_push_text_back");
+    yxml_element
+        .define_private_method(
+            "yxml_element_push_text_front",
+            method!(YXmlElement::yxml_element_push_text_front, 1)
+        )
+        .expect("cannot define private method: yxml_element_push_text_front");
+    yxml_element
+        .define_private_method(
+            "yxml_element_remove_attribute",
+            method!(YXmlElement::yxml_element_remove_attribute, 2)
+        )
+        .expect("cannot define private method: yxml_element_remove_range");
+    yxml_element
+        .define_private_method(
+            "yxml_element_remove_range",
+            method!(YXmlElement::yxml_element_remove_range, 3)
+        )
+        .expect("cannot define private method: yxml_element_remove_range");
+    yxml_element
+        .define_private_method(
+            "yxml_element_size",
+            method!(YXmlElement::yxml_element_size, 0)
+        )
+        .expect("cannot define private method: yxml_element_size");
+    yxml_element
+        .define_private_method(
+            "yxml_element_tag",
+            method!(YXmlElement::yxml_element_tag, 0)
+        )
+        .expect("cannot define private method: yxml_element_tag");
+    yxml_element
+        .define_private_method(
+            "yxml_element_to_s",
+            method!(YXmlElement::yxml_element_to_s, 0)
+        )
+        .expect("cannot define private method: yxml_element_to_s");
+    yxml_element
+        .define_private_method(
+            "yxml_element_unobserve",
+            method!(YXmlElement::yxml_element_unobserve, 1)
+        )
+        .expect("cannot define private method: yxml_element_unobserve");
+
+    let yxml_text = module
+        .define_class("XMLText", Default::default())
+        .expect("cannot define class Y::XMLText");
+
+    yxml_text
+        .define_private_method(
+            "yxml_text_attributes",
+            method!(YXmlText::yxml_text_attributes, 0)
+        )
+        .expect("cannot define private method: yxml_text_attributes");
+    yxml_text
+        .define_private_method(
+            "yxml_text_format",
+            method!(YXmlText::yxml_text_format, 4)
+        )
+        .expect("cannot define private method: yxml_text_format");
+    yxml_text
+        .define_private_method(
+            "yxml_text_get_attribute",
+            method!(YXmlText::yxml_text_get_attribute, 1)
+        )
+        .expect("cannot define private method: yxml_text_get_attribute");
+    yxml_text
+        .define_private_method(
+            "yxml_text_insert",
+            method!(YXmlText::yxml_text_insert, 3)
+        )
+        .expect("cannot define private method: yxml_text_insert");
+    yxml_text
+        .define_private_method(
+            "yxml_text_insert_attribute",
+            method!(YXmlText::yxml_text_insert_attribute, 3)
+        )
+        .expect("cannot define private method: yxml_text_insert_attribute");
+    yxml_text.define_private_method("yxml_text_insert_embed_with_attrs", method!(YXmlText::yxml_text_insert_embed_with_attributes, 4)).expect("cannot define private method: yxml_text_insert_embed_with_attributes");
+    yxml_text
+        .define_private_method(
+            "yxml_text_insert_with_attrs",
+            method!(YXmlText::yxml_text_insert_with_attributes, 4)
+        )
+        .expect(
+            "cannot define private method: yxml_text_insert_with_attributes"
+        );
+    yxml_text
+        .define_private_method(
+            "yxml_text_insert_embed",
+            method!(YXmlText::yxml_text_insert_embed, 3)
+        )
+        .expect("cannot define private method: yxml_text_insert_embed");
+    yxml_text
+        .define_private_method(
+            "yxml_text_length",
+            method!(YXmlText::yxml_text_length, 0)
+        )
+        .expect("cannot define private method: yxml_text_length");
+    yxml_text
+        .define_private_method(
+            "yxml_text_next_sibling",
+            method!(YXmlText::yxml_text_next_sibling, 0)
+        )
+        .expect("cannot define private method: yxml_text_next_sibling");
+    yxml_text
+        .define_private_method(
+            "yxml_text_parent",
+            method!(YXmlText::yxml_text_parent, 0)
+        )
+        .expect("cannot define private method: yxml_text_parent");
+    yxml_text
+        .define_private_method(
+            "yxml_text_prev_sibling",
+            method!(YXmlText::yxml_text_prev_sibling, 0)
+        )
+        .expect("cannot define private method: yxml_text_prev_sibling");
+    yxml_text
+        .define_private_method(
+            "yxml_text_push",
+            method!(YXmlText::yxml_text_push, 2)
+        )
+        .expect("cannot define private method: yxml_text_push");
+    yxml_text
+        .define_private_method(
+            "yxml_text_remove_range",
+            method!(YXmlText::yxml_text_remove_range, 3)
+        )
+        .expect("cannot define private method: yxml_text_remove_range");
+    yxml_text
+        .define_private_method(
+            "yxml_text_to_s",
+            method!(YXmlText::yxml_text_to_s, 0)
+        )
+        .expect("cannot define private method: yxml_text_to_s");
+
+    Ok(())
+}

data/ext/yrb/src/utils.rs

@@ -0,0 +1,36 @@
+use crate::yvalue::YValue;
+use lib0::any::Any;
+use magnus::r_hash::ForEach::Continue;
+use magnus::{Error, RHash, RString, Symbol, Value};
+use std::rc::Rc;
+use yrs::types::Attrs;
+
+#[derive(Debug, Clone)]
+pub(crate) struct TypeConversionError;
+
+pub(crate) fn indifferent_hash_key(key: Value) -> Option<String> {
+    RString::from_value(key)
+        .map(|v| v.to_string().unwrap())
+        .or_else(|| {
+            Symbol::from_value(key).map(|v| v.name().unwrap().to_string())
+        })
+}
+
+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 v = Any::from(YValue::from(value));
+
+        a.insert(k, v);
+
+        Ok(Continue)
+    });
+
+    if result.is_err() {
+        return Err(Error::runtime_error("could not map hash to attrs"));
+    }
+
+    Ok(a)
+}

data/ext/yrb/src/yany.rs

@@ -0,0 +1,44 @@
+use lib0::any::Any;
+use magnus::{RArray, RHash, RString, Value, QNIL};
+use std::borrow::Borrow;
+use std::ops::{Deref, DerefMut};
+
+pub(crate) struct YAny(pub(crate) Any);
+
+impl Deref for YAny {
+    type Target = Any;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for YAny {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl TryInto<Value> for YAny {
+    type Error = ();
+
+    fn try_into(self) -> Result<Value, Self::Error> {
+        return match self.0 {
+            Any::Array(_v) => {
+                let arr = RArray::new();
+                Ok(Value::from(arr))
+            }
+            Any::Map(_v) => {
+                let hash = RHash::new();
+                Ok(Value::from(hash))
+            }
+            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.borrow()))),
+            Any::Buffer(v) => Ok(Value::from(RString::from_slice(v.borrow())))
+        };
+    }
+}