y-rb 0.1.2 → 0.1.4.alpha.1

data/docs/decisions.md

@@ -1,64 +0,0 @@
-# Decision log
-
-## 2022-05-12
-
-### Transactions do not always commit automatically
-
-In `yrs`, the lifetime of a transaction is determined automatically. This can
-lead to an interesting situation in Ruby, where we attach a listener to receive
-changes, never commit a transaction explicitly and where the transaction gets
-dropped automatically. I believe we still maintain a pointer to the transaction
-that no longer exists, and therefore we receive a segfault.
-
-## 2022-05-12
-
-### Add event-driven approach to receive changes
-
-It is not clear if this ends up being the final API to receive changes, but
-it is the one that is supported in one or the other way across all `yrs`
-implementations. It might be beneficial to add a synchronous API in the future,
-but this isn't supported right away. All common styles of closure like behavior
-are supported: `Proc`, `Lambda` and `Block`.
-
-## 2022-05-09
-
-### Supported operations on data types are either read-only or mutable
-
-In a meeting with the wider `y-crdt` group on May 6th, 2022, it became clear
-that the cost of creating a new instance of a data type is common operation in
-many languages (Python, Ruby, …), but it is not something we should to support.
-This pattern leads to all sort of problems, mostly because it contradicts the
-common usage pattern of replicating changes between two or more clients.
-
-Instead, the API should be explicit about this fact and should not make it too
-easy to do that.
-
-## 2022-05-06
-
-### Transactions are implicit by default
-
-The developer should not be exposed to transactions until they need to
-change the default logic in any way. If someone creates a structure and inserts,
-removes, this should be part of the same transaction until stated otherwise.
-
-### Synchronisation happens at the document level
-
-It might be interesting to sync at a more granular level, but for the sake of
-simplicity, the first iteration of this library will only support
-synchronization of the complete document.
-
-## 2022-05-05
-
-### No direct exposure of internal API
-
-The internal API (`y-crdt`) is subject to constant changes and does not
-necessarily offer an idiomatic Ruby interface. Therefore, the public API of
-`y-rb` does not follow the `y-crdt` API, but prefers familiar Ruby idioms when
-possible and might even require libraries where it makes sense (e.g. `nokogiri` for XML).
-
-### Rutie is a temporary dependency
-
-The Ruby<->Rust binding feels immature. But it is not the goal of this project
-to fix this immediately. The long-term vision is to replace this part by
-something more lightweight and opinionated that could be part of the Rust
-codebase of this project.

data/docs/examples.md

@@ -1,16 +0,0 @@
-# Examples
-
-> Usage patterns
-
-## Send a full document update to a client
-
-```ruby
-doc = Y::Doc.new
-text = doc.get_text("about")
-text << "My name is, my name is, my name is … Slim Shady"
-
-zero = Y::Doc.new
-update = doc.diff(zero.state)
-
-transfer update
-```

data/docs/release.md

@@ -1,9 +0,0 @@
-# Release
-
-## Steps
-
-1. Make sure CI is green
-2. Update version in `Cargo.toml`
-3. Update version in `lib/y/version.rb`
-4. Create a tag matching the version `git tag -a v0.1.1 -m "Release version v0.1.1"` 
-5. Push tag to GitLab repo

data/ext/Rakefile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "thermite/tasks"
-
-project_dir = File.dirname(File.dirname(__FILE__))
-Thermite::Tasks.new(cargo_project_path: project_dir,
-                    ruby_project_path: project_dir)
-
-task default: %w[thermite:build]

data/lib/y/rb.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "rutie"
-require_relative "array"
-require_relative "doc"
-require_relative "map"
-require_relative "text"
-require_relative "transaction"
-require_relative "version"
-require_relative "xml"
-
-module Y
-  Rutie.new(:y_rb).init(
-    "Init_yrb",
-    File.join(__dir__, "..")
-  )
-end

data/src/lib.rs

@@ -1,248 +0,0 @@
-mod util;
-mod yarray;
-mod ydoc;
-mod ymap;
-mod ytext;
-mod ytransaction;
-mod yxml;
-
-#[macro_use]
-extern crate rutie;
-
-use rutie::{Module, Object};
-
-module!(Y);
-
-#[allow(non_snake_case)]
-#[no_mangle]
-pub extern "C" fn Init_yrb() {
-    Module::new("Y").define(|module| {
-        module.define_nested_class("Array", None).define(|klass| {
-            klass.def_private("yarray_each", yarray::yarray_each);
-            klass.def_private("yarray_get", yarray::yarray_get);
-            klass.def_private("yarray_insert", yarray::yarray_insert);
-            klass.def_private(
-                "yarray_insert_range",
-                yarray::yarray_insert_range
-            );
-            klass.def_private("yarray_length", yarray::yarray_length);
-            klass.def_private("yarray_observe", yarray::yarray_observe);
-            klass.def_private("yarray_push_back", yarray::yarray_push_back);
-            klass.def_private("yarray_push_front", yarray::yarray_push_front);
-            klass.def_private("yarray_remove", yarray::yarray_remove);
-            klass.def_private(
-                "yarray_remove_range",
-                yarray::yarray_remove_range
-            );
-            klass.def_private("yarray_to_a", yarray::yarray_to_a);
-            klass.def_private("yarray_unobserve", yarray::yarray_unobserve);
-        });
-
-        module.define_nested_class("Doc", None).define(|klass| {
-            klass.def_self("new", ydoc::ydoc_new);
-            klass.def_private("ydoc_transact", ydoc::ydoc_transact);
-            klass.def_private("ydoc_encode_diff_v1", ydoc::ydoc_encode_diff_v1);
-        });
-
-        module.define_nested_class("Map", None).define(|klass| {
-            klass.def_private("ymap_clear", ymap::ymap_clear);
-            klass.def_private("ymap_contains", ymap::ymap_contains);
-            klass.def_private("ymap_each", ymap::ymap_each);
-            klass.def_private("ymap_get", ymap::ymap_get);
-            klass.def_private("ymap_insert", ymap::ymap_insert);
-            klass.def_private("ymap_observe", ymap::ymap_observe);
-            klass.def_private("ymap_remove", ymap::ymap_remove);
-            klass.def_private("ymap_size", ymap::ymap_size);
-            klass.def_private("ymap_to_h", ymap::ymap_to_hash);
-            klass.def_private("ymap_unobserve", ymap::ymap_unobserve);
-        });
-
-        module
-            .define_nested_class("SubscriptionID", None)
-            .define(|_klass| {});
-
-        module.define_nested_class("Text", None).define(|klass| {
-            klass.def_private("ytext_insert", ytext::ytext_insert);
-            klass.def_private("ytext_insert_embed", ytext::ytext_insert_embed);
-            klass.def_private(
-                "ytext_insert_embed_with_attrs",
-                ytext::ytext_insert_embed_with_attributes
-            );
-            klass.def_private(
-                "ytext_insert_with_attrs",
-                ytext::ytext_insert_with_attributes
-            );
-            klass.def_private("ytext_remove_range", ytext::ytext_remove_range);
-            klass.def_private("ytext_format", ytext::ytext_format);
-            klass.def_private("ytext_length", ytext::ytext_length);
-            klass.def_private("ytext_observe", ytext::ytext_observe);
-            klass.def_private("ytext_push", ytext::ytext_push);
-            klass.def_private("ytext_to_s", ytext::ytext_to_string);
-            klass.def_private("ytext_unobserve", ytext::ytext_unobserve);
-        });
-
-        module
-            .define_nested_class("Transaction", None)
-            .define(|klass| {
-                klass.def_private(
-                    "ytransaction_apply_update",
-                    ytransaction::ytransaction_apply_update
-                );
-                klass.def_private(
-                    "ytransaction_commit",
-                    ytransaction::ytransaction_commit
-                );
-                klass.def_private(
-                    "ytransaction_get_array",
-                    ytransaction::ytransaction_get_array
-                );
-                klass.def_private(
-                    "ytransaction_get_map",
-                    ytransaction::ytransaction_get_map
-                );
-                klass.def_private(
-                    "ytransaction_get_text",
-                    ytransaction::ytransaction_get_text
-                );
-                klass.def_private(
-                    "ytransaction_get_xml_element",
-                    ytransaction::ytransaction_get_xml_element
-                );
-                klass.def_private(
-                    "ytransaction_get_xml_text",
-                    ytransaction::ytransaction_get_xml_text
-                );
-                klass.def_private(
-                    "ytransaction_state_vector",
-                    ytransaction::ytransaction_state_vector
-                );
-            });
-
-        module
-            .define_nested_class("XMLElement", None)
-            .define(|klass| {
-                klass.def_private(
-                    "yxml_element_attributes",
-                    yxml::yxml_element_attributes
-                );
-                klass.def_private(
-                    "yxml_element_first_child",
-                    yxml::yxml_element_first_child
-                );
-                klass.def_private("yxml_element_get", yxml::yxml_element_get);
-                klass.def_private(
-                    "yxml_element_get_attribute",
-                    yxml::yxml_element_get_attribute
-                );
-                klass.def_private(
-                    "yxml_element_insert_attribute",
-                    yxml::yxml_element_insert_attribute
-                );
-                klass.def_private(
-                    "yxml_element_insert_element",
-                    yxml::yxml_element_insert_element
-                );
-                klass.def_private(
-                    "yxml_element_insert_text",
-                    yxml::yxml_element_insert_text
-                );
-                klass.def_private(
-                    "yxml_element_next_sibling",
-                    yxml::yxml_element_next_sibling
-                );
-                klass.def_private(
-                    "yxml_element_observe",
-                    yxml::yxml_element_observe
-                );
-                klass.def_private(
-                    "yxml_element_parent",
-                    yxml::yxml_element_parent
-                );
-                klass.def_private(
-                    "yxml_element_prev_sibling",
-                    yxml::yxml_element_prev_sibling
-                );
-                klass.def_private(
-                    "yxml_element_push_elem_back",
-                    yxml::yxml_element_push_elem_back
-                );
-                klass.def_private(
-                    "yxml_element_push_elem_front",
-                    yxml::yxml_element_push_elem_front
-                );
-                klass.def_private(
-                    "yxml_element_push_text_back",
-                    yxml::yxml_element_push_text_back
-                );
-                klass.def_private(
-                    "yxml_element_push_text_front",
-                    yxml::yxml_element_push_text_front
-                );
-                klass.def_private(
-                    "yxml_element_remove_attribute",
-                    yxml::yxml_element_remove_attribute
-                );
-                klass.def_private(
-                    "yxml_element_remove_range",
-                    yxml::yxml_element_remove_range
-                );
-                klass.def_private("yxml_element_size", yxml::yxml_element_size);
-                klass.def_private("yxml_element_tag", yxml::yxml_element_tag);
-                klass.def_private(
-                    "yxml_element_to_s",
-                    yxml::yxml_element_to_string
-                );
-                klass.def_private(
-                    "yxml_element_unobserve",
-                    yxml::yxml_element_unobserve
-                );
-            });
-
-        module.define_nested_class("XMLText", None).define(|klass| {
-            klass.def_private(
-                "yxml_text_attributes",
-                yxml::yxml_text_attributes
-            );
-            klass.def_private("yxml_text_format", yxml::yxml_text_format);
-            klass.def_private(
-                "yxml_text_get_attribute",
-                yxml::yxml_text_get_attribute
-            );
-            klass.def_private("yxml_text_insert", yxml::yxml_text_insert);
-            klass.def_private(
-                "yxml_text_insert_attribute",
-                yxml::yxml_text_insert_attribute
-            );
-            klass.def_private(
-                "yxml_text_insert_embed",
-                yxml::yxml_text_insert_embed
-            );
-            klass.def_private(
-                "yxml_text_insert_embed_with_attrs",
-                yxml::yxml_text_insert_embed_with_attributes
-            );
-            klass.def_private(
-                "yxml_text_insert_with_attrs",
-                yxml::yxml_text_insert_with_attributes
-            );
-            klass.def_private("yxml_text_length", yxml::yxml_text_length);
-            klass.def_private(
-                "yxml_text_next_sibling",
-                yxml::yxml_text_next_sibling
-            );
-            klass.def_private("yxml_text_observe", yxml::yxml_text_observe);
-            klass.def_private("yxml_text_parent", yxml::yxml_text_parent);
-            klass.def_private(
-                "yxml_text_prev_sibling",
-                yxml::yxml_text_prev_sibling
-            );
-            klass.def_private("yxml_text_push", yxml::yxml_text_push);
-            klass.def_private(
-                "yxml_text_remove_range",
-                yxml::yxml_text_remove_range
-            );
-            klass.def_private("yxml_text_to_s", yxml::yxml_text_to_string);
-            klass.def_private("yxml_text_unobserve", yxml::yxml_text_unobserve);
-        });
-    });
-}

data/src/util.rs

@@ -1,146 +0,0 @@
-use crate::ymap::MAP_WRAPPER;
-use crate::ytext::TEXT_WRAPPER;
-use crate::yxml::{XML_ELEMENT_WRAPPER, XML_TEXT_WRAPPER};
-use lib0::any::Any;
-use rutie::{
-    AnyException, AnyObject, Array, Boolean, Exception, Fixnum, Float, Hash,
-    Integer, Module, NilClass, Object, RString, Symbol
-};
-use std::borrow::Borrow;
-use std::collections::HashMap;
-use std::convert::TryFrom;
-use std::rc::Rc;
-use yrs::types::{Attrs, Value};
-
-pub(crate) fn convert_vecu8_to_array(vec: Vec<u8>) -> Array {
-    let mut array = Array::new();
-
-    for i in vec {
-        array.push(Fixnum::new(i64::from(i)));
-    }
-
-    array
-}
-
-pub(crate) fn convert_array_to_vecu8(arr: Array) -> Vec<u8> {
-    arr.into_iter()
-        .map(|val| val.try_convert_to::<Fixnum>().unwrap().to_u32())
-        .map(|val| u8::try_from(val).unwrap())
-        .collect()
-}
-
-pub(crate) fn map_any_type_to_ruby(input: &Any) -> AnyObject {
-    match input {
-        Any::Null => NilClass::new().to_any_object(),
-        Any::Undefined => NilClass::new().to_any_object(),
-        Any::Bool(b) => Boolean::new(*b).to_any_object(),
-        Any::Number(f) => Float::new(*f).to_any_object(),
-        Any::BigInt(i) => Integer::new(*i).to_any_object(),
-        Any::String(s) => RString::new_utf8(s.as_ref()).to_any_object(),
-        // TODO convert buffer into an array of Fixnum
-        Any::Buffer(_b) => Array::new().to_any_object(),
-        Any::Array(a) => {
-            let values = a.iter().map(|n| map_any_type_to_ruby(n));
-            Array::from_iter(values).to_any_object()
-        }
-        Any::Map(m) => {
-            let mut h = Hash::new();
-            m.iter().for_each(|(k, v)| {
-                let key = Symbol::new(k.as_ref());
-                let val = map_any_type_to_ruby(v);
-                h.store(key, val);
-            });
-            h.to_any_object()
-        }
-    }
-}
-
-pub(crate) fn map_yrs_value_to_ruby(value: Value) -> AnyObject {
-    match value {
-        Value::Any(v) => map_any_type_to_ruby(v.borrow()),
-        Value::YArray(a) => {
-            let values = a.iter().map(|n| map_yrs_value_to_ruby(n));
-            Array::from_iter(values).to_any_object()
-        }
-        Value::YMap(m) => Module::from_existing("Y")
-            .get_nested_class("Text")
-            .wrap_data(m, &*MAP_WRAPPER),
-        Value::YText(t) => Module::from_existing("Y")
-            .get_nested_class("Text")
-            .wrap_data(t, &*TEXT_WRAPPER),
-        Value::YXmlElement(x) => Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(x, &*XML_ELEMENT_WRAPPER),
-        Value::YXmlText(x) => Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(x, &*XML_TEXT_WRAPPER)
-    }
-}
-
-pub(crate) fn map_ruby_type_to_rust(
-    input: AnyObject
-) -> Result<Any, AnyException> {
-    if let Ok(_v) = input.try_convert_to::<NilClass>() {
-        return Ok(Any::Null);
-    } else if let Ok(v) = input.try_convert_to::<Boolean>() {
-        return Ok(Any::Bool(v.to_bool()));
-    } else if let Ok(v) = input.try_convert_to::<Float>() {
-        return Ok(Any::Number(v.to_f64()));
-    } else if let Ok(v) = input.try_convert_to::<Fixnum>() {
-        return Ok(Any::BigInt(v.to_i64()));
-    } else if let Ok(v) = input.try_convert_to::<Integer>() {
-        return Ok(Any::BigInt(v.to_i64()));
-    } else if let Ok(v) = input.try_convert_to::<RString>() {
-        return Ok(Any::String(Box::from(v.to_str())));
-    } else if let Ok(v) = input.try_convert_to::<Array>() {
-        let arr: Vec<Any> = v
-            .into_iter()
-            .map(|value| map_ruby_type_to_rust(value).unwrap())
-            .collect();
-        return Ok(Any::Array(arr.into_boxed_slice()));
-    } else if let Ok(v) = input.try_convert_to::<Hash>() {
-        let m = map_hash_to_rust(v);
-        return Ok(Any::Map(Box::from(m)));
-    }
-
-    Err(AnyException::new(
-        "TypeError",
-        Some("cannot map input type")
-    ))
-}
-
-// This function gets reported as unused.
-pub(crate) fn map_hash_to_rust(input: Hash) -> HashMap<String, Any> {
-    let mut m = HashMap::with_capacity(input.length());
-    input.each(|key, value| {
-        if let Ok(v) = map_ruby_type_to_rust(value) {
-            if let Ok(k) = key.try_convert_to::<RString>() {
-                m.insert(k.to_string(), v);
-            } else if let Ok(k) = key.try_convert_to::<Symbol>() {
-                m.insert(k.to_string(), v);
-            }
-        }
-    });
-    m
-}
-
-pub(crate) fn map_hash_to_attrs(input: Hash) -> Attrs {
-    let attributes = map_hash_to_rust(input);
-    let mut attrs = Attrs::with_capacity(attributes.len());
-    for (k, v) in attributes {
-        attrs.insert(Rc::from(k), v);
-    }
-    attrs
-}
-
-pub(crate) fn map_attrs_to_hash(attrs: Attrs) -> Hash {
-    let mut h = Hash::new();
-
-    for (key, val) in attrs {
-        let key = Symbol::new(key.as_ref());
-        let value = map_any_type_to_ruby(val.borrow());
-        h.store(key, value);
-    }
-
-    h
-}