RubyGems - y-rb - Versions diffs - 0.1.3 → 0.1.4.alpha.1 - Mend

y-rb 0.1.3 → 0.1.4.alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

checksums.yaml +4 -4
data/ext/yrb/Cargo.lock +623 -0
data/ext/yrb/Cargo.toml +17 -0
data/ext/yrb/extconf.rb +6 -0
data/ext/yrb/src/lib.rs +476 -0
data/ext/yrb/src/utils.rs +36 -0
data/ext/yrb/src/yany.rs +44 -0
data/ext/yrb/src/yarray.rs +175 -0
data/ext/yrb/src/yattrs.rs +48 -0
data/ext/yrb/src/ydoc.rs +39 -0
data/ext/yrb/src/ymap.rs +165 -0
data/ext/yrb/src/ytext.rs +228 -0
data/ext/yrb/src/ytransaction.rs +58 -0
data/ext/yrb/src/yvalue.rs +235 -0
data/ext/yrb/src/yxml_element.rs +225 -0
data/ext/yrb/src/yxml_text.rs +154 -0
data/lib/y/doc.rb +2 -2
data/lib/y/text.rb +9 -7
data/lib/y/version.rb +1 -1
data/lib/y.rb +16 -0
metadata +48 -50
data/.dockerignore +0 -5
data/.editorconfig +0 -16
data/.rspec +0 -3
data/.rubocop.yml +0 -23
data/.rustfmt.toml +0 -74
data/.yardopts +0 -2
data/Cargo.toml +0 -29
data/Cross.toml +0 -17
data/Gemfile +0 -13
data/Gemfile.lock +0 -93
data/LICENSE.txt +0 -21
data/README.md +0 -102
data/Rakefile +0 -39
data/bin/console +0 -15
data/bin/setup +0 -8
data/build/Dockerfile +0 -18
data/build/build.rb +0 -105
data/build/entrypoint.sh +0 -3
data/docs/decisions.md +0 -64
data/docs/examples.md +0 -16
data/docs/release.md +0 -36
data/ext/Rakefile +0 -9
data/lib/y/rb.rb +0 -27
data/src/lib.rs +0 -248
data/src/util.rs +0 -146
data/src/yarray.rs +0 -184
data/src/ydoc.rs +0 -71
data/src/ymap.rs +0 -199
data/src/ytext.rs +0 -204
data/src/ytransaction.rs +0 -102
data/src/yxml.rs +0 -550

data/src/yxml.rs DELETED Viewed

@@ -1,550 +0,0 @@
-use crate::util::{
-    map_attrs_to_hash, map_hash_to_attrs, 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, Module, NilClass,
-    Object, Proc, RString, Symbol, VM
-};
-use yrs::types::xml::Attributes;
-use yrs::types::{Change, Delta};
-use yrs::{SubscriptionId, Xml, XmlElement, XmlText};
-wrappable_struct!(XmlElement, XmlElementWrapper, XML_ELEMENT_WRAPPER);
-class!(YXmlElement);
-#[rustfmt::skip]
-methods!(
-    YXmlElement,
-    rtself,
-    fn yxml_element_attributes() -> Hash {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let mut h = Hash::new();
-        let attrs: Attributes = xml_element.attributes();
-        for (key, val) in attrs {
-            h.store(
-                Symbol::new(key),
-                RString::new_utf8(&val)
-            );
-        }
-        h
-    },
-    fn yxml_element_first_child() -> AnyObject {
-       let index = 0;
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.get(index);
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_get(index: Fixnum) -> AnyObject {
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.get(i.to_u32());
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_get_attribute(name: RString) -> AnyObject {
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let attr_name = xml_element.get_attribute(&n.to_string());
-        match attr_name {
-            Some(v) => RString::new_utf8(&v).to_any_object(),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_insert_attribute(
-        transaction: YTransaction,
-        name: RString,
-        value: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        xml_element.insert_attribute(tx, n.to_string(), v.to_string());
-        NilClass::new()
-    },
-    fn yxml_element_insert_element(transaction: YTransaction, index: Fixnum, name: RString) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_element: XmlElement = xml_element.insert_elem(tx, i.to_u32(), n.to_string());
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn yxml_element_insert_text(transaction: YTransaction, index: Fixnum) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_text = xml_element.insert_text(tx, i.to_u32());
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(new_text, &*XML_TEXT_WRAPPER)
-    },
-    fn yxml_element_next_sibling() -> AnyObject {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.next_sibling();
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_observe(callback: Proc) -> Integer {
-        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_element: &mut XmlElement = rtself.get_data_mut(&*XML_ELEMENT_WRAPPER);
-        let subscription_id: SubscriptionId = xml_element
-            .observe(move |transaction, xml_element_event| {
-                // TODO: emit attribute changes
-                let delta = xml_element_event.delta(transaction);
-                let mut changes: Vec<AnyObject> = Vec::with_capacity(delta.len());
-                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 yxml_element_parent() -> AnyObject {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.parent();
-        match node {
-            Some(v) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_prev_sibling() -> AnyObject {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let node = xml_element.prev_sibling();
-        match node {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_element_push_elem_back(transaction: YTransaction, name: RString) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_element: XmlElement = xml_element.push_elem_back(tx, n.to_string());
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn yxml_element_push_elem_front(transaction: YTransaction, name: RString) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_element: XmlElement = xml_element.push_elem_front(tx, n.to_string());
-        Module::from_existing("Y")
-            .get_nested_class("XMLElement")
-            .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
-    },
-    fn yxml_element_push_text_back(transaction: YTransaction) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_text = xml_element.push_text_back(tx);
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(new_text, &*XML_TEXT_WRAPPER)
-    },
-    fn yxml_element_push_text_front(transaction: YTransaction) -> AnyObject {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        let new_text = xml_element.push_text_front(tx);
-        Module::from_existing("Y")
-            .get_nested_class("XMLText")
-            .wrap_data(new_text, &*XML_TEXT_WRAPPER)
-    },
-    fn yxml_element_remove_attribute(
-        transaction: YTransaction,
-        name: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        xml_element.remove_attribute(tx, &n.to_string());
-        NilClass::new()
-    },
-    fn yxml_element_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        xml_element.remove_range(tx, i.to_u32(), l.to_u32());
-        NilClass::new()
-    },
-    fn yxml_element_size() -> Fixnum {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        Fixnum::new(i64::from(xml_element.len()))
-    },
-    fn yxml_element_tag() -> RString {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        RString::new_utf8(xml_element.tag())
-    },
-    fn yxml_element_to_string() -> RString {
-        let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
-        RString::new_utf8(&xml_element.to_string())
-    },
-    fn yxml_element_unobserve(subscription_id: Integer) -> NilClass {
-        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_element: &mut XmlElement = rtself.get_data_mut(&*XML_ELEMENT_WRAPPER);
-        xml_element.unobserve(s.into());
-        NilClass::new()
-    }
-);
-wrappable_struct!(XmlText, XmlTextWrapper, XML_TEXT_WRAPPER);
-class!(YXmlText);
-#[rustfmt::skip]
-methods!(
-    YXmlText,
-    rtself,
-    fn yxml_text_attributes() -> Hash {
-        let xml_element = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let mut h = Hash::new();
-        let attrs: Attributes = xml_element.attributes();
-        for (key, val) in attrs {
-            h.store(
-                Symbol::new(key),
-                RString::new_utf8(&val)
-            );
-        }
-        h
-    },
-    fn yxml_text_format(transaction: YTransaction, index: Fixnum, length: Fixnum, attrs: Hash) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.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 a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_attrs = map_hash_to_attrs(a);
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.format(tx, i.to_u32(), l.to_u32(), mapped_attrs);
-        NilClass::new()
-    },
-    fn yxml_text_get_attribute(name: RString) -> AnyObject {
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let attr = xml_text.get_attribute(&n.to_string());
-        match attr {
-            Some(v) => RString::new_utf8(&v).to_any_object(),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_insert(transaction: YTransaction, index: Fixnum, content: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert(tx, i.to_u32(),&c.to_string());
-        NilClass::new()
-    },
-    fn yxml_text_insert_attribute(transaction: YTransaction, name: RString, value: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
-        let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_attribute(tx, n.to_string(), v.to_string());
-        NilClass::new()
-    },
-    fn yxml_text_insert_embed(transaction: YTransaction, index: Fixnum, content: AnyObject) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_content = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_embed(tx, i.to_u32(), mapped_content);
-        NilClass::new()
-    },
-    fn yxml_text_insert_embed_with_attributes(transaction: YTransaction, index: Fixnum, content: AnyObject, attrs: Hash) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_content = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
-        let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_attrs = map_hash_to_attrs(a);
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_embed_with_attributes(tx, i.to_u32(), mapped_content, mapped_attrs);
-        NilClass::new()
-    },
-    fn yxml_text_insert_with_attributes(transaction: YTransaction, index: Fixnum, content: RString, attrs: Hash) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
-        let mapped_attrs = map_hash_to_attrs(a);
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.insert_with_attributes(tx, i.to_u32(), &c.to_string(), mapped_attrs);
-        NilClass::new()
-    },
-    fn yxml_text_length() -> Fixnum {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        Fixnum::new(i64::from(xml_text.len()))
-    },
-    fn yxml_text_next_sibling() -> AnyObject {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let xml = xml_text.next_sibling();
-        match xml {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_observe(callback: Proc) -> Integer {
-        let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text: &mut XmlText = rtself.get_data_mut(&*XML_TEXT_WRAPPER);
-        let subscription_id: SubscriptionId = xml_text
-            .observe(move |transaction, xml_text_event| {
-                // TODO: add node changes
-                let delta = xml_text_event.delta(transaction);
-                for event in delta {
-                    match event {
-                        Delta::Inserted(v, attrs) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("insert"), map_yrs_value_to_ruby(v.clone()));
-                            match attrs {
-                                Some(a) => {
-                                    let copy = a.clone();
-                                    let result = map_attrs_to_hash(*copy).to_any_object();
-                                    payload.store(Symbol::new("attributes"), result);
-                                },
-                                None => ()
-                            }
-                            let args = &[payload.to_any_object()];
-                            c.call(args);
-                        },
-                        Delta::Retain(position, attrs) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("retain"), Integer::from(*position));
-                            match attrs {
-                                Some(a) => {
-                                    let copy = a.clone();
-                                    let result = map_attrs_to_hash(*copy).to_any_object();
-                                    payload.store(Symbol::new("attributes"), result);
-                                },
-                                None => ()
-                            }
-                            let args = &[payload.to_any_object()];
-                            c.call(args);
-                        },
-                        Delta::Deleted(position) => {
-                            let mut payload = Hash::new();
-                            payload.store(Symbol::new("delete"), Integer::from(*position));
-                            let args = &[payload.to_any_object()];
-                            c.call(args);
-                        }
-                    }
-                }
-            })
-            .into();
-        Integer::from(subscription_id)
-    },
-    fn yxml_text_parent() -> AnyObject {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let xml_element = xml_text.parent();
-        match xml_element {
-            Some(v) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_prev_sibling() -> AnyObject {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        let xml = xml_text.prev_sibling();
-        match xml {
-            Some(Xml::Element(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLElement")
-                .wrap_data(v, &*XML_ELEMENT_WRAPPER),
-            Some(Xml::Text(v)) => Module::from_existing("Y")
-                .get_nested_class("XMLText")
-                .wrap_data(v, &*XML_TEXT_WRAPPER),
-            None => NilClass::new().to_any_object()
-        }
-    },
-    fn yxml_text_push(transaction: YTransaction, content: RString) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
-        let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.push(tx, &c.to_string());
-        NilClass::new()
-    },
-    fn yxml_text_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
-        let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
-        let tx = t.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 xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        xml_text.remove_range(tx, i.to_u32(), l.to_u32());
-        NilClass::new()
-    },
-    fn yxml_text_to_string() -> RString {
-        let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
-        RString::new_utf8(&xml_text.to_string())
-    },
-    fn yxml_text_unobserve(subscription_id: Integer) -> NilClass {
-        let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
-        let xml_text: &mut XmlText = rtself.get_data_mut(&*XML_TEXT_WRAPPER);
-        xml_text.unobserve(s.into());
-        NilClass::new()
-    }
-);