y-rb 0.1.0

data/lib/y.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Y
+end

data/src/lib.rs

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,148 @@
+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()
+        }
+    }
+}
+
+// This function gets reported as unused.
+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
+}

data/src/yarray.rs

@@ -0,0 +1,184 @@
+use crate::util::{map_ruby_type_to_rust, map_yrs_value_to_ruby};
+use crate::ytransaction::{YTransaction, TRANSACTION_WRAPPER};
+use rutie::{
+    AnyObject, Array as RArray, Fixnum, Hash, Integer, NilClass, Object, Proc,
+    Symbol, VM,
+};
+use yrs::types::{Change, Value};
+use yrs::{Array, SubscriptionId};
+
+wrappable_struct!(Array, ArrayWrapper, ARRAY_WRAPPER);
+class!(YArray);
+
+#[rustfmt::skip]
+methods!(
+    YArray,
+    rtself,
+    fn yarray_each(block: Proc) -> NilClass {
+        let b = block.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let a: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+
+        a
+            .iter()
+            .for_each(|val| {
+                let args = [map_yrs_value_to_ruby(val)];
+                b.call(&args);
+            });
+
+        NilClass::new()
+    },
+    fn yarray_get(index: Fixnum) -> AnyObject {
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        let val = arr.get(i.to_u32());
+
+        map_yrs_value_to_ruby(val.unwrap())
+    },
+    fn yarray_insert(
+        transaction: YTransaction,
+        index: Fixnum,
+        value: AnyObject) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let val = value.map_err(|e| VM::raise_ex(e)).unwrap();
+        let v = map_ruby_type_to_rust(val).unwrap();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        arr.insert(tx, i.to_u32(), v);
+
+        NilClass::new()
+    },
+    fn yarray_insert_range(
+        transaction: YTransaction,
+        index: Fixnum,
+        values: RArray) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let values = values.map_err(|e| VM::raise_ex(e)).unwrap();
+        let mapped_values = values
+            .into_iter()
+            .map(|value| map_ruby_type_to_rust(value).unwrap() )
+            .collect::<Vec<_>>();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        arr.insert_range(tx, i.to_u32(), mapped_values);
+
+        NilClass::new()
+    },
+    fn yarray_length() -> Fixnum {
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        Fixnum::new(i64::from(arr.len()))
+    },
+    fn yarray_observe(callback: Proc) -> Integer {
+        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let arr: &mut Array = rtself.get_data_mut(&*ARRAY_WRAPPER);
+        let subscription_id: SubscriptionId = arr
+            .observe(move |transaction, array_event| {
+                let delta = array_event.delta(transaction);
+                let mut changes: Vec<AnyObject> = Vec::new();
+
+                for change in delta {
+                    match change {
+                        Change::Added(v) => {
+                            let mut payload = Hash::new();
+                            let values = v.iter().map(|v| map_yrs_value_to_ruby(v.clone()) ).collect::<Vec<_>>();
+                            payload.store(Symbol::new("added"), RArray::from_iter(values));
+
+                            changes.push(payload.to_any_object());
+                        },
+                        Change::Retain(position) => {
+                            let mut payload = Hash::new();
+                            payload.store(Symbol::new("retain"), Integer::from(*position));
+
+                            changes.push(payload.to_any_object());
+                        },
+                        Change::Removed(position) => {
+                            let mut payload = Hash::new();
+                            payload.store(Symbol::new("removed"), Integer::from(*position));
+
+                            changes.push(payload.to_any_object());
+                        }
+                    }
+                }
+
+                let args = &[RArray::from_iter(changes).to_any_object()];
+                c.call(args);
+            })
+            .into();
+
+        Integer::from(subscription_id)
+    },
+    fn yarray_push_back(transaction: YTransaction, value: AnyObject) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let val = value.map_err(|e| VM::raise_ex(e)).unwrap();
+        let v = map_ruby_type_to_rust(val).unwrap();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        arr.push_back(tx, v);
+
+        NilClass::new()
+    },
+    fn yarray_push_front(transaction: YTransaction, value: AnyObject) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let val = value.map_err(|e| VM::raise_ex(e)).unwrap();
+        let v = map_ruby_type_to_rust(val).unwrap();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        arr.push_front(tx, v);
+
+        NilClass::new()
+    },
+    fn yarray_remove(transaction: YTransaction, index: Fixnum) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        arr.remove(tx, i.to_u32());
+
+        NilClass::new()
+    },
+    fn yarray_remove_range(
+        transaction: YTransaction,
+        index: Fixnum,
+        length: Fixnum) -> NilClass {
+        let mut txn = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
+        let tx = txn.get_data_mut(&*TRANSACTION_WRAPPER);
+
+        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
+        let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let arr: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        arr.remove_range(tx, i.to_u32(), l.to_u32());
+
+        NilClass::new()
+    },
+    fn yarray_to_a() -> RArray {
+        let v: &Array = rtself.get_data(&*ARRAY_WRAPPER);
+        map_yrs_value_to_ruby(Value::YArray(v.clone()))
+            .try_convert_to::<RArray>()
+            .unwrap()
+    }
+    fn yarray_unobserve(subscription_id: Integer) -> NilClass {
+        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
+
+        let arr: &mut Array = rtself.get_data_mut(&*ARRAY_WRAPPER);
+        arr.unobserve(s.into());
+
+        NilClass::new()
+    }
+);

data/src/ydoc.rs

@@ -0,0 +1,65 @@
+use crate::util::{convert_array_to_vecu8, convert_vecu8_to_array};
+use crate::ytransaction::TRANSACTION_WRAPPER;
+use rutie::rubysys::class;
+use rutie::types::{Argc, Value};
+use rutie::util::str_to_cstring;
+use rutie::{AnyObject, Array, Integer, Module, Object};
+use std::mem;
+use yrs::updates::decoder::Decode;
+use yrs::{Doc, OffsetKind, Options, StateVector};
+
+wrappable_struct!(Doc, DocWrapper, DOC_WRAPPER);
+class!(YDoc);
+
+methods!(
+    YDoc,
+    rtself,
+    fn ydoc_transact() -> AnyObject {
+        let doc = rtself.get_data(&*DOC_WRAPPER);
+        let transaction = doc.transact();
+
+        Module::from_existing("Y")
+            .get_nested_class("Transaction")
+            .wrap_data(transaction, &*TRANSACTION_WRAPPER)
+    },
+    fn ydoc_encode_diff_v1(state_vector: Array) -> Array {
+        let mut doc: &Doc = rtself.get_data_mut(&*DOC_WRAPPER);
+        let state_vector_encoded: Vec<u8> =
+            convert_array_to_vecu8(state_vector.unwrap());
+        let sv = &StateVector::decode_v1(state_vector_encoded.as_slice());
+
+        let update = doc.encode_state_as_update_v1(sv);
+
+        convert_vecu8_to_array(update)
+    }
+);
+
+pub extern "C" fn ydoc_new(
+    argc: Argc,
+    argv: *const AnyObject,
+    _rtself: AnyObject,
+) -> AnyObject {
+    let args = Value::from(0);
+
+    unsafe {
+        let p_argv: *const Value = mem::transmute(argv);
+
+        class::rb_scan_args(argc, p_argv, str_to_cstring("*").as_ptr(), &args)
+    };
+
+    let arguments = Array::from(args);
+    let client_id = arguments.at(0).try_convert_to::<Integer>();
+
+    let mut options = Options::default();
+    if let Ok(c_id) = client_id {
+        options.client_id = c_id.into();
+    };
+    // make sure we treat offsets for codepoints not bytes
+    options.offset_kind = OffsetKind::Utf32;
+
+    let doc = Doc::with_options(options);
+
+    Module::from_existing("Y")
+        .get_nested_class("Doc")
+        .wrap_data(doc, &*DOC_WRAPPER)
+}