y-rb 0.1.2 → 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.
data/src/ytransaction.rs DELETED
@@ -1,102 +0,0 @@
1
- use crate::util::{convert_array_to_vecu8, convert_vecu8_to_array};
2
- use crate::yarray::ARRAY_WRAPPER;
3
- use crate::ymap::MAP_WRAPPER;
4
- use crate::ytext::TEXT_WRAPPER;
5
- use crate::yxml::{XML_ELEMENT_WRAPPER, XML_TEXT_WRAPPER};
6
- use rutie::{
7
- AnyObject, Array, Module, NilClass, Object, RString, VerifiedObject, VM,
8
- };
9
- use yrs::updates::decoder::Decode;
10
- use yrs::updates::encoder::Encode;
11
- use yrs::{Transaction, Update};
12
-
13
- wrappable_struct!(Transaction, TransactionWrapper, TRANSACTION_WRAPPER);
14
- class!(YTransaction);
15
-
16
- impl VerifiedObject for YTransaction {
17
- fn is_correct_type<T: Object>(object: &T) -> bool {
18
- object.class()
19
- == Module::from_existing("Y").get_nested_class("Transaction")
20
- }
21
-
22
- fn error_message() -> &'static str {
23
- "Error converting to YTransaction"
24
- }
25
- }
26
-
27
- methods!(
28
- YTransaction,
29
- rtself,
30
- fn ytransaction_apply_update(update: Array) -> NilClass {
31
- let u = convert_array_to_vecu8(update.unwrap());
32
-
33
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
34
- let update = Update::decode_v1(u.as_slice()).unwrap();
35
- transaction.apply_update(update);
36
-
37
- NilClass::new()
38
- },
39
- fn ytransaction_commit() -> NilClass {
40
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
41
- transaction.commit();
42
-
43
- NilClass::new()
44
- },
45
- fn ytransaction_get_array(name: RString) -> AnyObject {
46
- let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
47
-
48
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
49
- let arr = transaction.get_array(&name_str);
50
-
51
- Module::from_existing("Y")
52
- .get_nested_class("Array")
53
- .wrap_data(arr, &*ARRAY_WRAPPER)
54
- },
55
- fn ytransaction_get_map(name: RString) -> AnyObject {
56
- let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
57
-
58
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
59
- let map = transaction.get_map(&name_str);
60
-
61
- Module::from_existing("Y")
62
- .get_nested_class("Map")
63
- .wrap_data(map, &*MAP_WRAPPER)
64
- },
65
- fn ytransaction_get_text(name: RString) -> AnyObject {
66
- let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
67
-
68
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
69
- let text = transaction.get_text(&name_str);
70
-
71
- Module::from_existing("Y")
72
- .get_nested_class("Text")
73
- .wrap_data(text, &*TEXT_WRAPPER)
74
- },
75
- fn ytransaction_get_xml_element(name: RString) -> AnyObject {
76
- let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
77
-
78
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
79
- let xml_element = transaction.get_xml_element(&name_str);
80
-
81
- Module::from_existing("Y")
82
- .get_nested_class("XMLElement")
83
- .wrap_data(xml_element, &*XML_ELEMENT_WRAPPER)
84
- },
85
- fn ytransaction_get_xml_text(name: RString) -> AnyObject {
86
- let name_str = name.map_err(|e| VM::raise_ex(e)).unwrap().to_string();
87
-
88
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
89
- let xml_text = transaction.get_xml_text(&name_str);
90
-
91
- Module::from_existing("Y")
92
- .get_nested_class("XMLText")
93
- .wrap_data(xml_text, &*XML_TEXT_WRAPPER)
94
- },
95
- fn ytransaction_state_vector() -> Array {
96
- let transaction = rtself.get_data_mut(&*TRANSACTION_WRAPPER);
97
- let sv = transaction.state_vector();
98
- let payload = sv.encode_v1();
99
-
100
- convert_vecu8_to_array(payload)
101
- }
102
- );
data/src/yxml.rs DELETED
@@ -1,550 +0,0 @@
1
- use crate::util::{
2
- map_attrs_to_hash, map_hash_to_attrs, map_ruby_type_to_rust,
3
- map_yrs_value_to_ruby
4
- };
5
- use crate::ytransaction::{YTransaction, TRANSACTION_WRAPPER};
6
- use rutie::{
7
- AnyObject, Array as RArray, Fixnum, Hash, Integer, Module, NilClass,
8
- Object, Proc, RString, Symbol, VM
9
- };
10
- use yrs::types::xml::Attributes;
11
- use yrs::types::{Change, Delta};
12
- use yrs::{SubscriptionId, Xml, XmlElement, XmlText};
13
-
14
- wrappable_struct!(XmlElement, XmlElementWrapper, XML_ELEMENT_WRAPPER);
15
- class!(YXmlElement);
16
-
17
- #[rustfmt::skip]
18
- methods!(
19
- YXmlElement,
20
- rtself,
21
- fn yxml_element_attributes() -> Hash {
22
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
23
-
24
- let mut h = Hash::new();
25
-
26
- let attrs: Attributes = xml_element.attributes();
27
- for (key, val) in attrs {
28
- h.store(
29
- Symbol::new(key),
30
- RString::new_utf8(&val)
31
- );
32
- }
33
-
34
- h
35
- },
36
- fn yxml_element_first_child() -> AnyObject {
37
- let index = 0;
38
-
39
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
40
- let node = xml_element.get(index);
41
-
42
- match node {
43
- Some(Xml::Element(v)) => Module::from_existing("Y")
44
- .get_nested_class("XMLElement")
45
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
46
- Some(Xml::Text(v)) => Module::from_existing("Y")
47
- .get_nested_class("XMLText")
48
- .wrap_data(v, &*XML_TEXT_WRAPPER),
49
- None => NilClass::new().to_any_object()
50
- }
51
- },
52
- fn yxml_element_get(index: Fixnum) -> AnyObject {
53
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
54
-
55
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
56
- let node = xml_element.get(i.to_u32());
57
-
58
- match node {
59
- Some(Xml::Element(v)) => Module::from_existing("Y")
60
- .get_nested_class("XMLElement")
61
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
62
- Some(Xml::Text(v)) => Module::from_existing("Y")
63
- .get_nested_class("XMLText")
64
- .wrap_data(v, &*XML_TEXT_WRAPPER),
65
- None => NilClass::new().to_any_object()
66
- }
67
- },
68
- fn yxml_element_get_attribute(name: RString) -> AnyObject {
69
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
70
-
71
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
72
- let attr_name = xml_element.get_attribute(&n.to_string());
73
-
74
- match attr_name {
75
- Some(v) => RString::new_utf8(&v).to_any_object(),
76
- None => NilClass::new().to_any_object()
77
- }
78
- },
79
- fn yxml_element_insert_attribute(
80
- transaction: YTransaction,
81
- name: RString,
82
- value: RString) -> NilClass {
83
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
84
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
85
- let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
86
-
87
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
88
-
89
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
90
- xml_element.insert_attribute(tx, n.to_string(), v.to_string());
91
-
92
- NilClass::new()
93
- },
94
- fn yxml_element_insert_element(transaction: YTransaction, index: Fixnum, name: RString) -> AnyObject {
95
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
96
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
97
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
98
-
99
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
100
-
101
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
102
- let new_element: XmlElement = xml_element.insert_elem(tx, i.to_u32(), n.to_string());
103
-
104
- Module::from_existing("Y")
105
- .get_nested_class("XMLElement")
106
- .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
107
- },
108
- fn yxml_element_insert_text(transaction: YTransaction, index: Fixnum) -> AnyObject {
109
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
110
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
111
-
112
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
113
-
114
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
115
- let new_text = xml_element.insert_text(tx, i.to_u32());
116
-
117
- Module::from_existing("Y")
118
- .get_nested_class("XMLText")
119
- .wrap_data(new_text, &*XML_TEXT_WRAPPER)
120
- },
121
- fn yxml_element_next_sibling() -> AnyObject {
122
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
123
- let node = xml_element.next_sibling();
124
-
125
- match node {
126
- Some(Xml::Element(v)) => Module::from_existing("Y")
127
- .get_nested_class("XMLElement")
128
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
129
- Some(Xml::Text(v)) => Module::from_existing("Y")
130
- .get_nested_class("XMLText")
131
- .wrap_data(v, &*XML_TEXT_WRAPPER),
132
- None => NilClass::new().to_any_object()
133
- }
134
- },
135
- fn yxml_element_observe(callback: Proc) -> Integer {
136
- let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
137
-
138
- let xml_element: &mut XmlElement = rtself.get_data_mut(&*XML_ELEMENT_WRAPPER);
139
- let subscription_id: SubscriptionId = xml_element
140
- .observe(move |transaction, xml_element_event| {
141
- // TODO: emit attribute changes
142
- let delta = xml_element_event.delta(transaction);
143
- let mut changes: Vec<AnyObject> = Vec::with_capacity(delta.len());
144
-
145
- for change in delta {
146
- match change {
147
- Change::Added(v) => {
148
- let mut payload = Hash::new();
149
- let values = v.iter().map(|v| map_yrs_value_to_ruby(v.clone()) ).collect::<Vec<_>>();
150
- payload.store(Symbol::new("added"), RArray::from_iter(values));
151
-
152
- changes.push(payload.to_any_object());
153
- },
154
- Change::Retain(position) => {
155
- let mut payload = Hash::new();
156
- payload.store(Symbol::new("retain"), Integer::from(*position));
157
-
158
- changes.push(payload.to_any_object());
159
- },
160
- Change::Removed(position) => {
161
- let mut payload = Hash::new();
162
- payload.store(Symbol::new("removed"), Integer::from(*position));
163
-
164
- changes.push(payload.to_any_object());
165
- }
166
- }
167
- }
168
-
169
- let args = &[RArray::from_iter(changes).to_any_object()];
170
- c.call(args);
171
- })
172
- .into();
173
-
174
- Integer::from(subscription_id)
175
- },
176
- fn yxml_element_parent() -> AnyObject {
177
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
178
- let node = xml_element.parent();
179
-
180
- match node {
181
- Some(v) => Module::from_existing("Y")
182
- .get_nested_class("XMLElement")
183
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
184
- None => NilClass::new().to_any_object()
185
- }
186
- },
187
- fn yxml_element_prev_sibling() -> AnyObject {
188
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
189
- let node = xml_element.prev_sibling();
190
-
191
- match node {
192
- Some(Xml::Element(v)) => Module::from_existing("Y")
193
- .get_nested_class("XMLElement")
194
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
195
- Some(Xml::Text(v)) => Module::from_existing("Y")
196
- .get_nested_class("XMLText")
197
- .wrap_data(v, &*XML_TEXT_WRAPPER),
198
- None => NilClass::new().to_any_object()
199
- }
200
- },
201
- fn yxml_element_push_elem_back(transaction: YTransaction, name: RString) -> AnyObject {
202
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
203
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
204
-
205
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
206
-
207
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
208
- let new_element: XmlElement = xml_element.push_elem_back(tx, n.to_string());
209
-
210
- Module::from_existing("Y")
211
- .get_nested_class("XMLElement")
212
- .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
213
- },
214
- fn yxml_element_push_elem_front(transaction: YTransaction, name: RString) -> AnyObject {
215
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
216
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
217
-
218
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
219
-
220
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
221
- let new_element: XmlElement = xml_element.push_elem_front(tx, n.to_string());
222
-
223
- Module::from_existing("Y")
224
- .get_nested_class("XMLElement")
225
- .wrap_data(new_element, &*XML_ELEMENT_WRAPPER)
226
- },
227
- fn yxml_element_push_text_back(transaction: YTransaction) -> AnyObject {
228
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
229
-
230
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
231
-
232
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
233
- let new_text = xml_element.push_text_back(tx);
234
-
235
- Module::from_existing("Y")
236
- .get_nested_class("XMLText")
237
- .wrap_data(new_text, &*XML_TEXT_WRAPPER)
238
- },
239
- fn yxml_element_push_text_front(transaction: YTransaction) -> AnyObject {
240
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
241
-
242
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
243
-
244
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
245
- let new_text = xml_element.push_text_front(tx);
246
-
247
- Module::from_existing("Y")
248
- .get_nested_class("XMLText")
249
- .wrap_data(new_text, &*XML_TEXT_WRAPPER)
250
- },
251
- fn yxml_element_remove_attribute(
252
- transaction: YTransaction,
253
- name: RString) -> NilClass {
254
-
255
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
256
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
257
-
258
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
259
-
260
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
261
- xml_element.remove_attribute(tx, &n.to_string());
262
-
263
- NilClass::new()
264
- },
265
- fn yxml_element_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
266
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
267
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
268
- let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
269
-
270
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
271
-
272
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
273
- xml_element.remove_range(tx, i.to_u32(), l.to_u32());
274
-
275
- NilClass::new()
276
- },
277
- fn yxml_element_size() -> Fixnum {
278
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
279
-
280
- Fixnum::new(i64::from(xml_element.len()))
281
- },
282
- fn yxml_element_tag() -> RString {
283
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
284
-
285
- RString::new_utf8(xml_element.tag())
286
- },
287
- fn yxml_element_to_string() -> RString {
288
- let xml_element = rtself.get_data(&*XML_ELEMENT_WRAPPER);
289
-
290
- RString::new_utf8(&xml_element.to_string())
291
- },
292
- fn yxml_element_unobserve(subscription_id: Integer) -> NilClass {
293
- let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
294
-
295
- let xml_element: &mut XmlElement = rtself.get_data_mut(&*XML_ELEMENT_WRAPPER);
296
- xml_element.unobserve(s.into());
297
-
298
- NilClass::new()
299
- }
300
- );
301
-
302
- wrappable_struct!(XmlText, XmlTextWrapper, XML_TEXT_WRAPPER);
303
- class!(YXmlText);
304
-
305
- #[rustfmt::skip]
306
- methods!(
307
- YXmlText,
308
- rtself,
309
- fn yxml_text_attributes() -> Hash {
310
- let xml_element = rtself.get_data(&*XML_TEXT_WRAPPER);
311
-
312
- let mut h = Hash::new();
313
-
314
- let attrs: Attributes = xml_element.attributes();
315
- for (key, val) in attrs {
316
- h.store(
317
- Symbol::new(key),
318
- RString::new_utf8(&val)
319
- );
320
- }
321
-
322
- h
323
- },
324
- fn yxml_text_format(transaction: YTransaction, index: Fixnum, length: Fixnum, attrs: Hash) -> NilClass {
325
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
326
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
327
-
328
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
329
- let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
330
- let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
331
- let mapped_attrs = map_hash_to_attrs(a);
332
-
333
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
334
- xml_text.format(tx, i.to_u32(), l.to_u32(), mapped_attrs);
335
-
336
- NilClass::new()
337
- },
338
- fn yxml_text_get_attribute(name: RString) -> AnyObject {
339
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
340
-
341
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
342
- let attr = xml_text.get_attribute(&n.to_string());
343
-
344
- match attr {
345
- Some(v) => RString::new_utf8(&v).to_any_object(),
346
- None => NilClass::new().to_any_object()
347
- }
348
- },
349
- fn yxml_text_insert(transaction: YTransaction, index: Fixnum, content: RString) -> NilClass {
350
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
351
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
352
-
353
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
354
- let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
355
-
356
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
357
- xml_text.insert(tx, i.to_u32(),&c.to_string());
358
-
359
- NilClass::new()
360
- },
361
- fn yxml_text_insert_attribute(transaction: YTransaction, name: RString, value: RString) -> NilClass {
362
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
363
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
364
-
365
- let n = name.map_err(|e| VM::raise_ex(e)).unwrap();
366
- let v = value.map_err(|e| VM::raise_ex(e)).unwrap();
367
-
368
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
369
- xml_text.insert_attribute(tx, n.to_string(), v.to_string());
370
-
371
- NilClass::new()
372
- },
373
- fn yxml_text_insert_embed(transaction: YTransaction, index: Fixnum, content: AnyObject) -> NilClass {
374
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
375
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
376
-
377
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
378
- let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
379
- let mapped_content = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
380
-
381
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
382
- xml_text.insert_embed(tx, i.to_u32(), mapped_content);
383
-
384
- NilClass::new()
385
- },
386
- fn yxml_text_insert_embed_with_attributes(transaction: YTransaction, index: Fixnum, content: AnyObject, attrs: Hash) -> NilClass {
387
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
388
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
389
-
390
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
391
- let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
392
- let mapped_content = map_ruby_type_to_rust(c).map_err(|e| VM::raise_ex(e)).unwrap();
393
- let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
394
- let mapped_attrs = map_hash_to_attrs(a);
395
-
396
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
397
- xml_text.insert_embed_with_attributes(tx, i.to_u32(), mapped_content, mapped_attrs);
398
-
399
- NilClass::new()
400
- },
401
- fn yxml_text_insert_with_attributes(transaction: YTransaction, index: Fixnum, content: RString, attrs: Hash) -> NilClass {
402
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
403
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
404
-
405
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
406
- let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
407
- let a = attrs.map_err(|e| VM::raise_ex(e)).unwrap();
408
-
409
- let mapped_attrs = map_hash_to_attrs(a);
410
-
411
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
412
- xml_text.insert_with_attributes(tx, i.to_u32(), &c.to_string(), mapped_attrs);
413
-
414
- NilClass::new()
415
- },
416
- fn yxml_text_length() -> Fixnum {
417
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
418
- Fixnum::new(i64::from(xml_text.len()))
419
- },
420
- fn yxml_text_next_sibling() -> AnyObject {
421
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
422
- let xml = xml_text.next_sibling();
423
-
424
- match xml {
425
- Some(Xml::Element(v)) => Module::from_existing("Y")
426
- .get_nested_class("XMLElement")
427
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
428
- Some(Xml::Text(v)) => Module::from_existing("Y")
429
- .get_nested_class("XMLText")
430
- .wrap_data(v, &*XML_TEXT_WRAPPER),
431
- None => NilClass::new().to_any_object()
432
- }
433
- },
434
- fn yxml_text_observe(callback: Proc) -> Integer {
435
- let c = callback.map_err(|e| VM::raise_ex(e)).unwrap();
436
-
437
- let xml_text: &mut XmlText = rtself.get_data_mut(&*XML_TEXT_WRAPPER);
438
- let subscription_id: SubscriptionId = xml_text
439
- .observe(move |transaction, xml_text_event| {
440
- // TODO: add node changes
441
- let delta = xml_text_event.delta(transaction);
442
- for event in delta {
443
- match event {
444
- Delta::Inserted(v, attrs) => {
445
- let mut payload = Hash::new();
446
- payload.store(Symbol::new("insert"), map_yrs_value_to_ruby(v.clone()));
447
-
448
- match attrs {
449
- Some(a) => {
450
- let copy = a.clone();
451
- let result = map_attrs_to_hash(*copy).to_any_object();
452
- payload.store(Symbol::new("attributes"), result);
453
- },
454
- None => ()
455
- }
456
-
457
- let args = &[payload.to_any_object()];
458
- c.call(args);
459
- },
460
- Delta::Retain(position, attrs) => {
461
- let mut payload = Hash::new();
462
- payload.store(Symbol::new("retain"), Integer::from(*position));
463
-
464
- match attrs {
465
- Some(a) => {
466
- let copy = a.clone();
467
- let result = map_attrs_to_hash(*copy).to_any_object();
468
- payload.store(Symbol::new("attributes"), result);
469
- },
470
- None => ()
471
- }
472
-
473
- let args = &[payload.to_any_object()];
474
- c.call(args);
475
- },
476
- Delta::Deleted(position) => {
477
- let mut payload = Hash::new();
478
- payload.store(Symbol::new("delete"), Integer::from(*position));
479
-
480
- let args = &[payload.to_any_object()];
481
- c.call(args);
482
- }
483
- }
484
- }
485
- })
486
- .into();
487
-
488
- Integer::from(subscription_id)
489
- },
490
- fn yxml_text_parent() -> AnyObject {
491
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
492
- let xml_element = xml_text.parent();
493
-
494
- match xml_element {
495
- Some(v) => Module::from_existing("Y")
496
- .get_nested_class("XMLElement")
497
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
498
- None => NilClass::new().to_any_object()
499
- }
500
- },
501
- fn yxml_text_prev_sibling() -> AnyObject {
502
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
503
- let xml = xml_text.prev_sibling();
504
-
505
- match xml {
506
- Some(Xml::Element(v)) => Module::from_existing("Y")
507
- .get_nested_class("XMLElement")
508
- .wrap_data(v, &*XML_ELEMENT_WRAPPER),
509
- Some(Xml::Text(v)) => Module::from_existing("Y")
510
- .get_nested_class("XMLText")
511
- .wrap_data(v, &*XML_TEXT_WRAPPER),
512
- None => NilClass::new().to_any_object()
513
- }
514
- },
515
- fn yxml_text_push(transaction: YTransaction, content: RString) -> NilClass {
516
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
517
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
518
-
519
- let c = content.map_err(|e| VM::raise_ex(e)).unwrap();
520
-
521
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
522
- xml_text.push(tx, &c.to_string());
523
-
524
- NilClass::new()
525
- },
526
- fn yxml_text_remove_range(transaction: YTransaction, index: Fixnum, length: Fixnum) -> NilClass {
527
- let mut t = transaction.map_err(|e| VM::raise_ex(e)).unwrap();
528
- let tx = t.get_data_mut(&*TRANSACTION_WRAPPER);
529
-
530
- let i = index.map_err(|e| VM::raise_ex(e)).unwrap();
531
- let l = length.map_err(|e| VM::raise_ex(e)).unwrap();
532
-
533
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
534
- xml_text.remove_range(tx, i.to_u32(), l.to_u32());
535
-
536
- NilClass::new()
537
- },
538
- fn yxml_text_to_string() -> RString {
539
- let xml_text = rtself.get_data(&*XML_TEXT_WRAPPER);
540
- RString::new_utf8(&xml_text.to_string())
541
- },
542
- fn yxml_text_unobserve(subscription_id: Integer) -> NilClass {
543
- let s = subscription_id.map_err(|e| VM::raise_ex(e)).unwrap();
544
-
545
- let xml_text: &mut XmlText = rtself.get_data_mut(&*XML_TEXT_WRAPPER);
546
- xml_text.unobserve(s.into());
547
-
548
- NilClass::new()
549
- }
550
- );
data/y-rb.gemspec DELETED
@@ -1,44 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require_relative "lib/y/version"
4
-
5
- # rubocop:disable Metrics/BlockLength
6
- Gem::Specification.new do |spec|
7
- spec.name = "y-rb"
8
- spec.version = Y::VERSION
9
- spec.authors = ["Hannes Moser"]
10
- spec.email = %w[hmoser@gitlab.com box@hannesmoser.at]
11
-
12
- spec.summary = "Ruby bindings for yrs"
13
- spec.description = "Ruby bindings for yrs. Yrs \"wires\" is a Rust port of the Yjs framework."
14
- spec.homepage = "https://github.com/y-crdt/yrb"
15
- spec.license = "MIT"
16
- spec.required_ruby_version = ">= 2.6.0"
17
-
18
- spec.metadata["allowed_push_host"] = "https://rubygems.org"
19
-
20
- spec.metadata["homepage_uri"] = spec.homepage
21
- spec.metadata["source_code_uri"] = "https://github.com/y-crdt/yrb"
22
- spec.metadata["documentation_uri"] = "https://y-crdt.github.io/yrb/"
23
-
24
- # Specify which files should be added to the gem when it is released.
25
- # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
26
- spec.files = Dir.chdir(File.expand_path(__dir__)) do
27
- `git ls-files -z`.split("\x0").reject do |f|
28
- (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
29
- end
30
- end
31
-
32
- spec.bindir = "exe"
33
- spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
34
- spec.require_paths = ["lib"]
35
-
36
- spec.metadata["rubygems_mfa_required"] = "true"
37
-
38
- spec.add_dependency "rake", "~> 13.0"
39
- spec.add_dependency "rutie", "~> 0.0.4"
40
- spec.add_dependency "thermite", "~> 0"
41
-
42
- spec.extensions << "ext/Rakefile"
43
- end
44
- # rubocop:enable Metrics/BlockLength