y-rb 0.1.0

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/yxml.rs ADDED
@@ -0,0 +1,550 @@
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
+ );
metadata ADDED
@@ -0,0 +1,130 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: y-rb
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.1.0
5
+ platform: ruby
6
+ authors:
7
+ - Hannes Moser
8
+ autorequire:
9
+ bindir: exe
10
+ cert_chain: []
11
+ date: 2022-05-24 00:00:00.000000000 Z
12
+ dependencies:
13
+ - !ruby/object:Gem::Dependency
14
+ name: rake
15
+ requirement: !ruby/object:Gem::Requirement
16
+ requirements:
17
+ - - "~>"
18
+ - !ruby/object:Gem::Version
19
+ version: '13.0'
20
+ type: :runtime
21
+ prerelease: false
22
+ version_requirements: !ruby/object:Gem::Requirement
23
+ requirements:
24
+ - - "~>"
25
+ - !ruby/object:Gem::Version
26
+ version: '13.0'
27
+ - !ruby/object:Gem::Dependency
28
+ name: rutie
29
+ requirement: !ruby/object:Gem::Requirement
30
+ requirements:
31
+ - - "~>"
32
+ - !ruby/object:Gem::Version
33
+ version: 0.0.4
34
+ type: :runtime
35
+ prerelease: false
36
+ version_requirements: !ruby/object:Gem::Requirement
37
+ requirements:
38
+ - - "~>"
39
+ - !ruby/object:Gem::Version
40
+ version: 0.0.4
41
+ - !ruby/object:Gem::Dependency
42
+ name: thermite
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - "~>"
46
+ - !ruby/object:Gem::Version
47
+ version: '0'
48
+ type: :runtime
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - "~>"
53
+ - !ruby/object:Gem::Version
54
+ version: '0'
55
+ description: Yrs "wires" is a Rust port of the Yjs framework.
56
+ email:
57
+ - hmoser@gitlab.com
58
+ - box@hannesmoser.at
59
+ executables: []
60
+ extensions:
61
+ - ext/Rakefile
62
+ extra_rdoc_files: []
63
+ files:
64
+ - ".cargo/config.toml"
65
+ - ".dockerignore"
66
+ - ".editorconfig"
67
+ - ".rspec"
68
+ - ".rubocop.yml"
69
+ - ".rustfmt.toml"
70
+ - ".yardopts"
71
+ - Cargo.toml
72
+ - Cross.toml
73
+ - Gemfile
74
+ - Gemfile.lock
75
+ - LICENSE.txt
76
+ - README.md
77
+ - Rakefile
78
+ - bin/console
79
+ - bin/setup
80
+ - docs/build.md
81
+ - docs/decisions.md
82
+ - docs/examples.md
83
+ - ext/Rakefile
84
+ - lib/y.rb
85
+ - lib/y/array.rb
86
+ - lib/y/doc.rb
87
+ - lib/y/map.rb
88
+ - lib/y/rb.rb
89
+ - lib/y/text.rb
90
+ - lib/y/transaction.rb
91
+ - lib/y/version.rb
92
+ - lib/y/xml.rb
93
+ - lib/y_rb.so
94
+ - src/lib.rs
95
+ - src/util.rs
96
+ - src/yarray.rs
97
+ - src/ydoc.rs
98
+ - src/ymap.rs
99
+ - src/ytext.rs
100
+ - src/ytransaction.rs
101
+ - src/yxml.rs
102
+ homepage: https://about.gitlab.com
103
+ licenses:
104
+ - MIT
105
+ metadata:
106
+ allowed_push_host: https://rubygems.org
107
+ homepage_uri: https://about.gitlab.com
108
+ source_code_uri: https://gitlab.com/gitlab-org/incubation-engineering/real-time-editing/y-rb
109
+ changelog_uri: https://gitlab.com/gitlab-org/incubation-engineering/real-time-editing/y-rb
110
+ rubygems_mfa_required: 'true'
111
+ post_install_message:
112
+ rdoc_options: []
113
+ require_paths:
114
+ - lib
115
+ required_ruby_version: !ruby/object:Gem::Requirement
116
+ requirements:
117
+ - - ">="
118
+ - !ruby/object:Gem::Version
119
+ version: 2.6.0
120
+ required_rubygems_version: !ruby/object:Gem::Requirement
121
+ requirements:
122
+ - - ">="
123
+ - !ruby/object:Gem::Version
124
+ version: '0'
125
+ requirements: []
126
+ rubygems_version: 3.2.32
127
+ signing_key:
128
+ specification_version: 4
129
+ summary: Ruby bindings for yrs
130
+ test_files: []