rspec-sorbet 1.8.1 → 1.8.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (58) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/lib/rspec/sorbet/version.rb +1 -1
  4. data/rspec-sorbet.gemspec +1 -1
  5. metadata +1 -54
  6. data/sorbet/config +0 -4
  7. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  8. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -1568
  9. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -1005
  10. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -9
  11. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  12. data/sorbet/rbi/gems/em-websocket@0.5.2.rbi +0 -8
  13. data/sorbet/rbi/gems/eventmachine@1.2.7.rbi +0 -45
  14. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +0 -3171
  15. data/sorbet/rbi/gems/ffi@1.15.4.rbi +0 -8
  16. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  17. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -31
  18. data/sorbet/rbi/gems/guard-livereload@2.5.2.rbi +0 -8
  19. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -211
  20. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -8
  21. data/sorbet/rbi/gems/http_parser.rb@0.6.0.rbi +0 -8
  22. data/sorbet/rbi/gems/listen@3.7.0.rbi +0 -8
  23. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -8
  24. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -72
  25. data/sorbet/rbi/gems/multi_json@1.15.0.rbi +0 -8
  26. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -8
  27. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -8
  28. data/sorbet/rbi/gems/parallel@1.21.0.rbi +0 -113
  29. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1189
  30. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +0 -458
  31. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -2486
  32. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  33. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -795
  34. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  35. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  36. data/sorbet/rbi/gems/rbi@0.0.6.rbi +0 -1405
  37. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  38. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  39. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2455
  40. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  41. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  42. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  43. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  44. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +0 -1938
  45. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +0 -1786
  46. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +0 -13252
  47. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  48. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -8
  49. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  50. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  51. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  52. data/sorbet/rbi/gems/spoom@1.1.5.rbi +0 -1241
  53. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +0 -98
  54. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +0 -949
  55. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -839
  56. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +0 -26
  57. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -8
  58. data/sorbet/tapioca/require.rb +0 -4
@@ -1,672 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `rexml` gem.
3
- # Please instead update this file by running `bin/tapioca gem rexml`.
4
-
5
- # typed: true
6
-
7
- class REXML::AttlistDecl < ::REXML::Child
8
- include ::Enumerable
9
-
10
- def initialize(source); end
11
-
12
- def [](key); end
13
- def each(&block); end
14
- def element_name; end
15
- def include?(key); end
16
- def node_type; end
17
- def write(out, indent = T.unsafe(nil)); end
18
- end
19
-
20
- class REXML::Attribute
21
- include ::REXML::Node
22
- include ::REXML::XMLTokens
23
- include ::REXML::Namespace
24
-
25
- def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end
26
-
27
- def ==(other); end
28
- def clone; end
29
- def doctype; end
30
- def element; end
31
- def element=(element); end
32
- def hash; end
33
- def inspect; end
34
- def namespace(arg = T.unsafe(nil)); end
35
- def node_type; end
36
- def normalized=(_arg0); end
37
- def prefix; end
38
- def remove; end
39
- def to_s; end
40
- def to_string; end
41
- def value; end
42
- def write(output, indent = T.unsafe(nil)); end
43
- def xpath; end
44
- end
45
-
46
- class REXML::Attributes < ::Hash
47
- def initialize(element); end
48
-
49
- def <<(attribute); end
50
- def [](name); end
51
- def []=(name, value); end
52
- def add(attribute); end
53
- def delete(attribute); end
54
- def delete_all(name); end
55
- def each; end
56
- def each_attribute; end
57
- def get_attribute(name); end
58
- def get_attribute_ns(namespace, name); end
59
- def length; end
60
- def namespaces; end
61
- def prefixes; end
62
- def size; end
63
- def to_a; end
64
- end
65
-
66
- class REXML::CData < ::REXML::Text
67
- def initialize(first, whitespace = T.unsafe(nil), parent = T.unsafe(nil)); end
68
-
69
- def clone; end
70
- def to_s; end
71
- def value; end
72
- def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
73
- end
74
-
75
- class REXML::Child
76
- include ::REXML::Node
77
-
78
- def initialize(parent = T.unsafe(nil)); end
79
-
80
- def bytes; end
81
- def document; end
82
- def next_sibling; end
83
- def next_sibling=(other); end
84
- def parent; end
85
- def parent=(other); end
86
- def previous_sibling; end
87
- def previous_sibling=(other); end
88
- def remove; end
89
- def replace_with(child); end
90
- end
91
-
92
- class REXML::Comment < ::REXML::Child
93
- include ::Comparable
94
-
95
- def initialize(first, second = T.unsafe(nil)); end
96
-
97
- def <=>(other); end
98
- def ==(other); end
99
- def clone; end
100
- def node_type; end
101
- def string; end
102
- def string=(_arg0); end
103
- def to_s; end
104
- def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
105
- end
106
-
107
- module REXML::DClonable; end
108
-
109
- class REXML::Declaration < ::REXML::Child
110
- def initialize(src); end
111
-
112
- def to_s; end
113
- def write(output, indent); end
114
- end
115
-
116
- class REXML::DocType < ::REXML::Parent
117
- include ::REXML::XMLTokens
118
-
119
- def initialize(first, parent = T.unsafe(nil)); end
120
-
121
- def add(child); end
122
- def attribute_of(element, attribute); end
123
- def attributes_of(element); end
124
- def clone; end
125
- def context; end
126
- def entities; end
127
- def entity(name); end
128
- def external_id; end
129
- def name; end
130
- def namespaces; end
131
- def node_type; end
132
- def notation(name); end
133
- def notations; end
134
- def public; end
135
- def system; end
136
- def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
137
- end
138
-
139
- class REXML::Document < ::REXML::Element
140
- def initialize(source = T.unsafe(nil), context = T.unsafe(nil)); end
141
-
142
- def <<(child); end
143
- def add(child); end
144
- def add_element(arg = T.unsafe(nil), arg2 = T.unsafe(nil)); end
145
- def clone; end
146
- def doctype; end
147
- def document; end
148
- def encoding; end
149
- def entity_expansion_count; end
150
- def expanded_name; end
151
- def name; end
152
- def node_type; end
153
- def record_entity_expansion; end
154
- def root; end
155
- def stand_alone?; end
156
- def version; end
157
- def write(*arguments); end
158
- def xml_decl; end
159
-
160
- private
161
-
162
- def build(source); end
163
-
164
- class << self
165
- def entity_expansion_limit; end
166
- def entity_expansion_limit=(val); end
167
- def entity_expansion_text_limit; end
168
- def entity_expansion_text_limit=(val); end
169
- def parse_stream(source, listener); end
170
- end
171
- end
172
-
173
- class REXML::Element < ::REXML::Parent
174
- include ::REXML::XMLTokens
175
- include ::REXML::Namespace
176
-
177
- def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end
178
-
179
- def [](name_or_index); end
180
- def add_attribute(key, value = T.unsafe(nil)); end
181
- def add_attributes(hash); end
182
- def add_element(element, attrs = T.unsafe(nil)); end
183
- def add_namespace(prefix, uri = T.unsafe(nil)); end
184
- def add_text(text); end
185
- def attribute(name, namespace = T.unsafe(nil)); end
186
- def attributes; end
187
- def cdatas; end
188
- def clone; end
189
- def comments; end
190
- def context; end
191
- def context=(_arg0); end
192
- def delete_attribute(key); end
193
- def delete_element(element); end
194
- def delete_namespace(namespace = T.unsafe(nil)); end
195
- def document; end
196
- def each_element(xpath = T.unsafe(nil), &block); end
197
- def each_element_with_attribute(key, value = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
198
- def each_element_with_text(text = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
199
- def elements; end
200
- def get_elements(xpath); end
201
- def get_text(path = T.unsafe(nil)); end
202
- def has_attributes?; end
203
- def has_elements?; end
204
- def has_text?; end
205
- def ignore_whitespace_nodes; end
206
- def inspect; end
207
- def instructions; end
208
- def namespace(prefix = T.unsafe(nil)); end
209
- def namespaces; end
210
- def next_element; end
211
- def node_type; end
212
- def prefixes; end
213
- def previous_element; end
214
- def raw; end
215
- def root; end
216
- def root_node; end
217
- def text(path = T.unsafe(nil)); end
218
- def text=(text); end
219
- def texts; end
220
- def whitespace; end
221
- def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
222
- def xpath; end
223
-
224
- private
225
-
226
- def __to_xpath_helper(node); end
227
- def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end
228
- end
229
-
230
- class REXML::ElementDecl < ::REXML::Declaration
231
- def initialize(src); end
232
- end
233
-
234
- class REXML::Elements
235
- include ::Enumerable
236
-
237
- def initialize(parent); end
238
-
239
- def <<(element = T.unsafe(nil)); end
240
- def [](index, name = T.unsafe(nil)); end
241
- def []=(index, element); end
242
- def add(element = T.unsafe(nil)); end
243
- def collect(xpath = T.unsafe(nil)); end
244
- def delete(element); end
245
- def delete_all(xpath); end
246
- def each(xpath = T.unsafe(nil)); end
247
- def empty?; end
248
- def index(element); end
249
- def inject(xpath = T.unsafe(nil), initial = T.unsafe(nil)); end
250
- def parent; end
251
- def size; end
252
- def to_a(xpath = T.unsafe(nil)); end
253
-
254
- private
255
-
256
- def literalize(name); end
257
- end
258
-
259
- module REXML::Encoding
260
- def decode(string); end
261
- def encode(string); end
262
- def encoding; end
263
- def encoding=(encoding); end
264
-
265
- private
266
-
267
- def find_encoding(name); end
268
- end
269
-
270
- class REXML::Entity < ::REXML::Child
271
- include ::REXML::XMLTokens
272
-
273
- def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end
274
-
275
- def external; end
276
- def name; end
277
- def ndata; end
278
- def normalized; end
279
- def pubid; end
280
- def ref; end
281
- def to_s; end
282
- def unnormalized; end
283
- def value; end
284
- def write(out, indent = T.unsafe(nil)); end
285
-
286
- class << self
287
- def matches?(string); end
288
- end
289
- end
290
-
291
- class REXML::ExternalEntity < ::REXML::Child
292
- def initialize(src); end
293
-
294
- def to_s; end
295
- def write(output, indent); end
296
- end
297
-
298
- class REXML::Formatters::Default
299
- def initialize(ie_hack = T.unsafe(nil)); end
300
-
301
- def write(node, output); end
302
-
303
- protected
304
-
305
- def write_cdata(node, output); end
306
- def write_comment(node, output); end
307
- def write_document(node, output); end
308
- def write_element(node, output); end
309
- def write_instruction(node, output); end
310
- def write_text(node, output); end
311
- end
312
-
313
- class REXML::Formatters::Pretty < ::REXML::Formatters::Default
314
- def initialize(indentation = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
315
-
316
- def compact; end
317
- def compact=(_arg0); end
318
- def width; end
319
- def width=(_arg0); end
320
-
321
- protected
322
-
323
- def write_cdata(node, output); end
324
- def write_comment(node, output); end
325
- def write_document(node, output); end
326
- def write_element(node, output); end
327
- def write_text(node, output); end
328
-
329
- private
330
-
331
- def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
332
- def wrap(string, width); end
333
- end
334
-
335
- class REXML::IOSource < ::REXML::Source
336
- def initialize(arg, block_size = T.unsafe(nil), encoding = T.unsafe(nil)); end
337
-
338
- def consume(pattern); end
339
- def current_line; end
340
- def empty?; end
341
- def match(pattern, cons = T.unsafe(nil)); end
342
- def position; end
343
- def read; end
344
- def scan(pattern, cons = T.unsafe(nil)); end
345
-
346
- private
347
-
348
- def encoding_updated; end
349
- def readline; end
350
- end
351
-
352
- class REXML::Instruction < ::REXML::Child
353
- def initialize(target, content = T.unsafe(nil)); end
354
-
355
- def ==(other); end
356
- def clone; end
357
- def content; end
358
- def content=(_arg0); end
359
- def inspect; end
360
- def node_type; end
361
- def target; end
362
- def target=(_arg0); end
363
- def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
364
- end
365
-
366
- class REXML::NotationDecl < ::REXML::Child
367
- def initialize(name, middle, pub, sys); end
368
-
369
- def name; end
370
- def public; end
371
- def public=(_arg0); end
372
- def system; end
373
- def system=(_arg0); end
374
- def to_s; end
375
- def write(output, indent = T.unsafe(nil)); end
376
- end
377
-
378
- class REXML::Output
379
- include ::REXML::Encoding
380
-
381
- def initialize(real_IO, encd = T.unsafe(nil)); end
382
-
383
- def <<(content); end
384
- def encoding; end
385
- def to_s; end
386
- end
387
-
388
- class REXML::Parent < ::REXML::Child
389
- include ::Enumerable
390
-
391
- def initialize(parent = T.unsafe(nil)); end
392
-
393
- def <<(object); end
394
- def [](index); end
395
- def []=(*args); end
396
- def add(object); end
397
- def children; end
398
- def deep_clone; end
399
- def delete(object); end
400
- def delete_at(index); end
401
- def delete_if(&block); end
402
- def each(&block); end
403
- def each_child(&block); end
404
- def each_index(&block); end
405
- def index(child); end
406
- def insert_after(child1, child2); end
407
- def insert_before(child1, child2); end
408
- def length; end
409
- def parent?; end
410
- def push(object); end
411
- def replace_child(to_replace, replacement); end
412
- def size; end
413
- def to_a; end
414
- def unshift(object); end
415
- end
416
-
417
- class REXML::ParseException < ::RuntimeError
418
- def initialize(message, source = T.unsafe(nil), parser = T.unsafe(nil), exception = T.unsafe(nil)); end
419
-
420
- def context; end
421
- def continued_exception; end
422
- def continued_exception=(_arg0); end
423
- def line; end
424
- def parser; end
425
- def parser=(_arg0); end
426
- def position; end
427
- def source; end
428
- def source=(_arg0); end
429
- def to_s; end
430
- end
431
-
432
- class REXML::Parsers::BaseParser
433
- def initialize(source); end
434
-
435
- def add_listener(listener); end
436
- def empty?; end
437
- def entity(reference, entities); end
438
- def has_next?; end
439
- def normalize(input, entities = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
440
- def peek(depth = T.unsafe(nil)); end
441
- def position; end
442
- def pull; end
443
- def source; end
444
- def stream=(source); end
445
- def unnormalize(string, entities = T.unsafe(nil), filter = T.unsafe(nil)); end
446
- def unshift(token); end
447
-
448
- private
449
-
450
- def need_source_encoding_update?(xml_declaration_encoding); end
451
- def parse_attributes(prefixes, curr_ns); end
452
- def parse_id(base_error_message, accept_external_id:, accept_public_id:); end
453
- def parse_id_invalid_details(accept_external_id:, accept_public_id:); end
454
- def parse_name(base_error_message); end
455
- def process_instruction; end
456
- def pull_event; end
457
- end
458
-
459
- REXML::Parsers::BaseParser::EXTERNAL_ID_PUBLIC = T.let(T.unsafe(nil), Regexp)
460
- REXML::Parsers::BaseParser::EXTERNAL_ID_SYSTEM = T.let(T.unsafe(nil), Regexp)
461
- REXML::Parsers::BaseParser::PUBLIC_ID = T.let(T.unsafe(nil), Regexp)
462
- REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp)
463
- REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String)
464
-
465
- class REXML::Parsers::StreamParser
466
- def initialize(source, listener); end
467
-
468
- def add_listener(listener); end
469
- def parse; end
470
- end
471
-
472
- class REXML::Parsers::TreeParser
473
- def initialize(source, build_context = T.unsafe(nil)); end
474
-
475
- def add_listener(listener); end
476
- def parse; end
477
- end
478
-
479
- class REXML::Parsers::XPathParser
480
- include ::REXML::XMLTokens
481
-
482
- def abbreviate(path); end
483
- def expand(path); end
484
- def namespaces=(namespaces); end
485
- def parse(path); end
486
- def predicate(path); end
487
- def predicate_to_string(path, &block); end
488
-
489
- private
490
-
491
- def AdditiveExpr(path, parsed); end
492
- def AndExpr(path, parsed); end
493
- def EqualityExpr(path, parsed); end
494
- def FilterExpr(path, parsed); end
495
- def FunctionCall(rest, parsed); end
496
- def LocationPath(path, parsed); end
497
- def MultiplicativeExpr(path, parsed); end
498
- def NodeTest(path, parsed); end
499
- def OrExpr(path, parsed); end
500
- def PathExpr(path, parsed); end
501
- def Predicate(path, parsed); end
502
- def PrimaryExpr(path, parsed); end
503
- def RelationalExpr(path, parsed); end
504
- def RelativeLocationPath(path, parsed); end
505
- def UnaryExpr(path, parsed); end
506
- def UnionExpr(path, parsed); end
507
- def get_group(string); end
508
- def parse_args(string); end
509
- end
510
-
511
- REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp)
512
- REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
513
-
514
- class REXML::ReferenceWriter
515
- def initialize(id_type, public_id_literal, system_literal, context = T.unsafe(nil)); end
516
-
517
- def write(output); end
518
- end
519
-
520
- class REXML::Source
521
- include ::REXML::Encoding
522
-
523
- def initialize(arg, encoding = T.unsafe(nil)); end
524
-
525
- def buffer; end
526
- def consume(pattern); end
527
- def current_line; end
528
- def empty?; end
529
- def encoding; end
530
- def encoding=(enc); end
531
- def line; end
532
- def match(pattern, cons = T.unsafe(nil)); end
533
- def match_to(char, pattern); end
534
- def match_to_consume(char, pattern); end
535
- def position; end
536
- def read; end
537
- def scan(pattern, cons = T.unsafe(nil)); end
538
-
539
- private
540
-
541
- def detect_encoding; end
542
- def encoding_updated; end
543
- end
544
-
545
- class REXML::Text < ::REXML::Child
546
- include ::Comparable
547
-
548
- def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
549
-
550
- def <<(to_append); end
551
- def <=>(other); end
552
- def clone; end
553
- def doctype; end
554
- def empty?; end
555
- def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
556
- def inspect; end
557
- def node_type; end
558
- def parent=(parent); end
559
- def raw; end
560
- def raw=(_arg0); end
561
- def to_s; end
562
- def value; end
563
- def value=(val); end
564
- def wrap(string, width, addnewline = T.unsafe(nil)); end
565
- def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
566
- def write_with_substitution(out, input); end
567
- def xpath; end
568
-
569
- private
570
-
571
- def clear_cache; end
572
-
573
- class << self
574
- def check(string, pattern, doctype); end
575
- def expand(ref, doctype, filter); end
576
- def normalize(input, doctype = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
577
- def read_with_substitution(input, illegal = T.unsafe(nil)); end
578
- def unnormalize(string, doctype = T.unsafe(nil), filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
579
- end
580
- end
581
-
582
- class REXML::UndefinedNamespaceException < ::REXML::ParseException
583
- def initialize(prefix, source, parser); end
584
- end
585
-
586
- class REXML::Validation::ValidationException < ::RuntimeError
587
- def initialize(msg); end
588
- end
589
-
590
- class REXML::XMLDecl < ::REXML::Child
591
- include ::REXML::Encoding
592
-
593
- def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end
594
-
595
- def ==(other); end
596
- def clone; end
597
- def dowrite; end
598
- def encoding=(enc); end
599
- def inspect; end
600
- def node_type; end
601
- def nowrite; end
602
- def old_enc=(encoding); end
603
- def stand_alone?; end
604
- def standalone; end
605
- def standalone=(_arg0); end
606
- def version; end
607
- def version=(_arg0); end
608
- def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
609
- def writeencoding; end
610
- def writethis; end
611
- def xmldecl(version, encoding, standalone); end
612
-
613
- private
614
-
615
- def content(enc); end
616
-
617
- class << self
618
- def default; end
619
- end
620
- end
621
-
622
- class REXML::XPathNode
623
- def initialize(node, context = T.unsafe(nil)); end
624
-
625
- def context; end
626
- def position; end
627
- def raw_node; end
628
- end
629
-
630
- class REXML::XPathParser
631
- include ::REXML::XMLTokens
632
-
633
- def initialize(strict: T.unsafe(nil)); end
634
-
635
- def []=(variable_name, value); end
636
- def first(path_stack, node); end
637
- def get_first(path, nodeset); end
638
- def match(path_stack, nodeset); end
639
- def namespaces=(namespaces = T.unsafe(nil)); end
640
- def parse(path, nodeset); end
641
- def predicate(path, nodeset); end
642
- def variables=(vars = T.unsafe(nil)); end
643
-
644
- private
645
-
646
- def child(nodeset); end
647
- def compare(a, operator, b); end
648
- def descendant(nodeset, include_self); end
649
- def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
650
- def each_unnode(nodeset); end
651
- def enter(tag, *args); end
652
- def equality_relational_compare(set1, op, set2); end
653
- def evaluate_predicate(expression, nodesets); end
654
- def expr(path_stack, nodeset, context = T.unsafe(nil)); end
655
- def filter_nodeset(nodeset); end
656
- def following(node); end
657
- def following_node_of(node); end
658
- def get_namespace(node, prefix); end
659
- def leave(tag, *args); end
660
- def next_sibling_node(node); end
661
- def node_test(path_stack, nodesets, any_type: T.unsafe(nil)); end
662
- def norm(b); end
663
- def normalize_compare_values(a, operator, b); end
664
- def preceding(node); end
665
- def preceding_node_of(node); end
666
- def sort(array_of_nodes, order); end
667
- def step(path_stack, any_type: T.unsafe(nil), order: T.unsafe(nil)); end
668
- def strict?; end
669
- def trace(*args); end
670
- def unnode(nodeset); end
671
- def value_type(value); end
672
- end