thread_weaver 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.
Files changed (53) hide show
  1. checksums.yaml +7 -0
  2. data/.github/workflows/main.yml +19 -0
  3. data/.gitignore +59 -0
  4. data/.rspec +3 -0
  5. data/.vscode/settings.json +14 -0
  6. data/CHANGELOG.md +7 -0
  7. data/Gemfile +17 -0
  8. data/LICENSE +21 -0
  9. data/README.md +37 -0
  10. data/Rakefile +13 -0
  11. data/bin/console +15 -0
  12. data/bin/gem_smoke_test +10 -0
  13. data/bin/setup +8 -0
  14. data/examples/always_deadlocks.rb +15 -0
  15. data/examples/takes_a_while.rb +7 -0
  16. data/examples/thread_safe_nonblocking_run_at_most_once.rb +23 -0
  17. data/examples/thread_safe_run_at_most_once.rb +19 -0
  18. data/examples/thread_unsafe_run_at_most_once.rb +17 -0
  19. data/lib/thread_weaver.rb +15 -0
  20. data/lib/thread_weaver/controllable_thread.rb +177 -0
  21. data/lib/thread_weaver/iterative_race_detector.rb +178 -0
  22. data/lib/thread_weaver/thread_instruction.rb +68 -0
  23. data/lib/thread_weaver/version.rb +6 -0
  24. data/sorbet/config +2 -0
  25. data/sorbet/rbi/gems/ast.rbi +48 -0
  26. data/sorbet/rbi/gems/coderay.rbi +285 -0
  27. data/sorbet/rbi/gems/method_source.rbi +64 -0
  28. data/sorbet/rbi/gems/parallel.rbi +83 -0
  29. data/sorbet/rbi/gems/parser.rbi +1510 -0
  30. data/sorbet/rbi/gems/pry-nav.rbi +29 -0
  31. data/sorbet/rbi/gems/pry.rbi +1965 -0
  32. data/sorbet/rbi/gems/rainbow.rbi +118 -0
  33. data/sorbet/rbi/gems/rake.rbi +645 -0
  34. data/sorbet/rbi/gems/regexp_parser.rbi +920 -0
  35. data/sorbet/rbi/gems/rexml.rbi +589 -0
  36. data/sorbet/rbi/gems/rspec-core.rbi +1893 -0
  37. data/sorbet/rbi/gems/rspec-expectations.rbi +1148 -0
  38. data/sorbet/rbi/gems/rspec-mocks.rbi +1091 -0
  39. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  40. data/sorbet/rbi/gems/rspec.rbi +15 -0
  41. data/sorbet/rbi/gems/rubocop-ast.rbi +1351 -0
  42. data/sorbet/rbi/gems/rubocop-performance.rbi +471 -0
  43. data/sorbet/rbi/gems/rubocop.rbi +7510 -0
  44. data/sorbet/rbi/gems/ruby-progressbar.rbi +305 -0
  45. data/sorbet/rbi/gems/standard.rbi +141 -0
  46. data/sorbet/rbi/gems/unicode-display_width.rbi +17 -0
  47. data/sorbet/rbi/hidden-definitions/errors.txt +4309 -0
  48. data/sorbet/rbi/hidden-definitions/hidden.rbi +8622 -0
  49. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
  50. data/sorbet/rbi/sorbet-typed/lib/rubocop-performance/~>1.6/rubocop-performance.rbi +149 -0
  51. data/sorbet/rbi/todo.rbi +6 -0
  52. data/thread_weaver.gemspec +34 -0
  53. metadata +111 -0
@@ -0,0 +1,589 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strict
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rexml/all/rexml.rbi
9
+ #
10
+ # rexml-3.2.4
11
+
12
+ module REXML
13
+ end
14
+ module REXML::Security
15
+ def self.entity_expansion_limit; end
16
+ def self.entity_expansion_limit=(val); end
17
+ def self.entity_expansion_text_limit; end
18
+ def self.entity_expansion_text_limit=(val); end
19
+ end
20
+ class REXML::ParseException < RuntimeError
21
+ def context; end
22
+ def continued_exception; end
23
+ def continued_exception=(arg0); end
24
+ def initialize(message, source = nil, parser = nil, exception = nil); end
25
+ def line; end
26
+ def parser; end
27
+ def parser=(arg0); end
28
+ def position; end
29
+ def source; end
30
+ def source=(arg0); end
31
+ def to_s; end
32
+ end
33
+ module REXML::Formatters
34
+ end
35
+ class REXML::Formatters::Default
36
+ def initialize(ie_hack = nil); end
37
+ def write(node, output); end
38
+ def write_cdata(node, output); end
39
+ def write_comment(node, output); end
40
+ def write_document(node, output); end
41
+ def write_element(node, output); end
42
+ def write_instruction(node, output); end
43
+ def write_text(node, output); end
44
+ end
45
+ class REXML::Formatters::Pretty < REXML::Formatters::Default
46
+ def compact; end
47
+ def compact=(arg0); end
48
+ def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
49
+ def initialize(indentation = nil, ie_hack = nil); end
50
+ def width; end
51
+ def width=(arg0); end
52
+ def wrap(string, width); end
53
+ def write_cdata(node, output); end
54
+ def write_comment(node, output); end
55
+ def write_document(node, output); end
56
+ def write_element(node, output); end
57
+ def write_text(node, output); end
58
+ end
59
+ module REXML::Node
60
+ def each_recursive(&block); end
61
+ def find_first_recursive(&block); end
62
+ def indent(to, ind); end
63
+ def index_in_parent; end
64
+ def next_sibling_node; end
65
+ def parent?; end
66
+ def previous_sibling_node; end
67
+ def to_s(indent = nil); end
68
+ end
69
+ class REXML::Child
70
+ def bytes; end
71
+ def document; end
72
+ def initialize(parent = nil); end
73
+ def next_sibling; end
74
+ def next_sibling=(other); end
75
+ def parent; end
76
+ def parent=(other); end
77
+ def previous_sibling; end
78
+ def previous_sibling=(other); end
79
+ def remove; end
80
+ def replace_with(child); end
81
+ include REXML::Node
82
+ end
83
+ class REXML::Parent < REXML::Child
84
+ def <<(object); end
85
+ def [](index); end
86
+ def []=(*args); end
87
+ def add(object); end
88
+ def children; end
89
+ def deep_clone; end
90
+ def delete(object); end
91
+ def delete_at(index); end
92
+ def delete_if(&block); end
93
+ def each(&block); end
94
+ def each_child(&block); end
95
+ def each_index(&block); end
96
+ def index(child); end
97
+ def initialize(parent = nil); end
98
+ def insert_after(child1, child2); end
99
+ def insert_before(child1, child2); end
100
+ def length; end
101
+ def parent?; end
102
+ def push(object); end
103
+ def replace_child(to_replace, replacement); end
104
+ def size; end
105
+ def to_a; end
106
+ def unshift(object); end
107
+ include Enumerable
108
+ end
109
+ module REXML::XMLTokens
110
+ end
111
+ module REXML::Namespace
112
+ def expanded_name; end
113
+ def fully_expanded_name; end
114
+ def has_name?(other, ns = nil); end
115
+ def local_name; end
116
+ def name; end
117
+ def name=(name); end
118
+ def prefix; end
119
+ def prefix=(arg0); end
120
+ include REXML::XMLTokens
121
+ end
122
+ module REXML::Encoding
123
+ def decode(string); end
124
+ def encode(string); end
125
+ def encoding; end
126
+ def encoding=(encoding); end
127
+ def find_encoding(name); end
128
+ end
129
+ class REXML::SourceFactory
130
+ def self.create_from(arg); end
131
+ end
132
+ class REXML::Source
133
+ def buffer; end
134
+ def consume(pattern); end
135
+ def current_line; end
136
+ def detect_encoding; end
137
+ def empty?; end
138
+ def encoding; end
139
+ def encoding=(enc); end
140
+ def encoding_updated; end
141
+ def initialize(arg, encoding = nil); end
142
+ def line; end
143
+ def match(pattern, cons = nil); end
144
+ def match_to(char, pattern); end
145
+ def match_to_consume(char, pattern); end
146
+ def position; end
147
+ def read; end
148
+ def scan(pattern, cons = nil); end
149
+ include REXML::Encoding
150
+ end
151
+ class REXML::IOSource < REXML::Source
152
+ def consume(pattern); end
153
+ def current_line; end
154
+ def empty?; end
155
+ def encoding_updated; end
156
+ def initialize(arg, block_size = nil, encoding = nil); end
157
+ def match(pattern, cons = nil); end
158
+ def position; end
159
+ def read; end
160
+ def readline; end
161
+ def scan(pattern, cons = nil); end
162
+ end
163
+ class REXML::Entity < REXML::Child
164
+ def external; end
165
+ def initialize(stream, value = nil, parent = nil, reference = nil); end
166
+ def name; end
167
+ def ndata; end
168
+ def normalized; end
169
+ def pubid; end
170
+ def ref; end
171
+ def self.matches?(string); end
172
+ def to_s; end
173
+ def unnormalized; end
174
+ def value; end
175
+ def write(out, indent = nil); end
176
+ include REXML::XMLTokens
177
+ end
178
+ module REXML::EntityConst
179
+ end
180
+ class REXML::AttlistDecl < REXML::Child
181
+ def [](key); end
182
+ def each(&block); end
183
+ def element_name; end
184
+ def include?(key); end
185
+ def initialize(source); end
186
+ def node_type; end
187
+ def write(out, indent = nil); end
188
+ include Enumerable
189
+ end
190
+ class REXML::DocType < REXML::Parent
191
+ def add(child); end
192
+ def attribute_of(element, attribute); end
193
+ def attributes_of(element); end
194
+ def clone; end
195
+ def context; end
196
+ def entities; end
197
+ def entity(name); end
198
+ def external_id; end
199
+ def initialize(first, parent = nil); end
200
+ def name; end
201
+ def namespaces; end
202
+ def node_type; end
203
+ def notation(name); end
204
+ def notations; end
205
+ def public; end
206
+ def strip_quotes(quoted_string); end
207
+ def system; end
208
+ def write(output, indent = nil, transitive = nil, ie_hack = nil); end
209
+ include REXML::XMLTokens
210
+ end
211
+ class REXML::Declaration < REXML::Child
212
+ def initialize(src); end
213
+ def to_s; end
214
+ def write(output, indent); end
215
+ end
216
+ class REXML::ElementDecl < REXML::Declaration
217
+ def initialize(src); end
218
+ end
219
+ class REXML::ExternalEntity < REXML::Child
220
+ def initialize(src); end
221
+ def to_s; end
222
+ def write(output, indent); end
223
+ end
224
+ class REXML::NotationDecl < REXML::Child
225
+ def initialize(name, middle, pub, sys); end
226
+ def name; end
227
+ def public; end
228
+ def public=(arg0); end
229
+ def system; end
230
+ def system=(arg0); end
231
+ def to_s; end
232
+ def write(output, indent = nil); end
233
+ end
234
+ class REXML::Text < REXML::Child
235
+ def <<(to_append); end
236
+ def <=>(other); end
237
+ def clear_cache; end
238
+ def clone; end
239
+ def doctype; end
240
+ def empty?; end
241
+ def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
242
+ def initialize(arg, respect_whitespace = nil, parent = nil, raw = nil, entity_filter = nil, illegal = nil); end
243
+ def inspect; end
244
+ def node_type; end
245
+ def parent=(parent); end
246
+ def raw; end
247
+ def raw=(arg0); end
248
+ def self.check(string, pattern, doctype); end
249
+ def self.expand(ref, doctype, filter); end
250
+ def self.normalize(input, doctype = nil, entity_filter = nil); end
251
+ def self.read_with_substitution(input, illegal = nil); end
252
+ def self.unnormalize(string, doctype = nil, filter = nil, illegal = nil); end
253
+ def to_s; end
254
+ def value; end
255
+ def value=(val); end
256
+ def wrap(string, width, addnewline = nil); end
257
+ def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
258
+ def write_with_substitution(out, input); end
259
+ def xpath; end
260
+ include Comparable
261
+ end
262
+ class REXML::Attribute
263
+ def ==(other); end
264
+ def clone; end
265
+ def doctype; end
266
+ def element; end
267
+ def element=(element); end
268
+ def hash; end
269
+ def initialize(first, second = nil, parent = nil); end
270
+ def inspect; end
271
+ def namespace(arg = nil); end
272
+ def node_type; end
273
+ def normalized=(arg0); end
274
+ def prefix; end
275
+ def remove; end
276
+ def to_s; end
277
+ def to_string; end
278
+ def value; end
279
+ def write(output, indent = nil); end
280
+ def xpath; end
281
+ include REXML::Namespace
282
+ include REXML::Node
283
+ end
284
+ class REXML::CData < REXML::Text
285
+ def clone; end
286
+ def initialize(first, whitespace = nil, parent = nil); end
287
+ def to_s; end
288
+ def value; end
289
+ def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
290
+ end
291
+ module REXML::Functions
292
+ end
293
+ module REXML::Parsers
294
+ end
295
+ class REXML::Parsers::XPathParser
296
+ def AdditiveExpr(path, parsed); end
297
+ def AndExpr(path, parsed); end
298
+ def EqualityExpr(path, parsed); end
299
+ def FilterExpr(path, parsed); end
300
+ def FunctionCall(rest, parsed); end
301
+ def LocationPath(path, parsed); end
302
+ def MultiplicativeExpr(path, parsed); end
303
+ def NodeTest(path, parsed); end
304
+ def OrExpr(path, parsed); end
305
+ def PathExpr(path, parsed); end
306
+ def Predicate(path, parsed); end
307
+ def PrimaryExpr(path, parsed); end
308
+ def RelationalExpr(path, parsed); end
309
+ def RelativeLocationPath(path, parsed); end
310
+ def UnaryExpr(path, parsed); end
311
+ def UnionExpr(path, parsed); end
312
+ def abbreviate(path); end
313
+ def expand(path); end
314
+ def get_group(string); end
315
+ def namespaces=(namespaces); end
316
+ def parse(path); end
317
+ def parse_args(string); end
318
+ def predicate(path); end
319
+ def predicate_to_string(path, &block); end
320
+ include REXML::XMLTokens
321
+ end
322
+ class Object < BasicObject
323
+ def dclone; end
324
+ end
325
+ class Symbol
326
+ def dclone; end
327
+ end
328
+ class Integer < Numeric
329
+ def dclone; end
330
+ end
331
+ class Float < Numeric
332
+ def dclone; end
333
+ end
334
+ class Array
335
+ def dclone; end
336
+ end
337
+ class REXML::XPathParser
338
+ def []=(variable_name, value); end
339
+ def child(nodeset); end
340
+ def compare(a, operator, b); end
341
+ def descendant(nodeset, include_self); end
342
+ def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
343
+ def each_unnode(nodeset); end
344
+ def enter(tag, *args); end
345
+ def equality_relational_compare(set1, op, set2); end
346
+ def evaluate_predicate(expression, nodesets); end
347
+ def expr(path_stack, nodeset, context = nil); end
348
+ def filter_nodeset(nodeset); end
349
+ def first(path_stack, node); end
350
+ def following(node); end
351
+ def following_node_of(node); end
352
+ def get_first(path, nodeset); end
353
+ def get_namespace(node, prefix); end
354
+ def initialize(strict: nil); end
355
+ def leave(tag, *args); end
356
+ def match(path_stack, nodeset); end
357
+ def namespaces=(namespaces = nil); end
358
+ def next_sibling_node(node); end
359
+ def node_test(path_stack, nodesets, any_type: nil); end
360
+ def norm(b); end
361
+ def normalize_compare_values(a, operator, b); end
362
+ def parse(path, nodeset); end
363
+ def preceding(node); end
364
+ def preceding_node_of(node); end
365
+ def predicate(path, nodeset); end
366
+ def sort(array_of_nodes, order); end
367
+ def step(path_stack, any_type: nil, order: nil); end
368
+ def strict?; end
369
+ def trace(*args); end
370
+ def unnode(nodeset); end
371
+ def value_type(value); end
372
+ def variables=(vars = nil); end
373
+ include REXML::XMLTokens
374
+ end
375
+ class REXML::XPathNode
376
+ def context; end
377
+ def initialize(node, context = nil); end
378
+ def position; end
379
+ def raw_node; end
380
+ end
381
+ class REXML::XPath
382
+ def self.each(element, path = nil, namespaces = nil, variables = nil, options = nil, &block); end
383
+ def self.first(element, path = nil, namespaces = nil, variables = nil, options = nil); end
384
+ def self.match(element, path = nil, namespaces = nil, variables = nil, options = nil); end
385
+ include REXML::Functions
386
+ end
387
+ class REXML::Element < REXML::Parent
388
+ def [](name_or_index); end
389
+ def __to_xpath_helper(node); end
390
+ def add_attribute(key, value = nil); end
391
+ def add_attributes(hash); end
392
+ def add_element(element, attrs = nil); end
393
+ def add_namespace(prefix, uri = nil); end
394
+ def add_text(text); end
395
+ def attribute(name, namespace = nil); end
396
+ def attributes; end
397
+ def cdatas; end
398
+ def clone; end
399
+ def comments; end
400
+ def context; end
401
+ def context=(arg0); end
402
+ def delete_attribute(key); end
403
+ def delete_element(element); end
404
+ def delete_namespace(namespace = nil); end
405
+ def document; end
406
+ def each_element(xpath = nil, &block); end
407
+ def each_element_with_attribute(key, value = nil, max = nil, name = nil, &block); end
408
+ def each_element_with_text(text = nil, max = nil, name = nil, &block); end
409
+ def each_with_something(test, max = nil, name = nil); end
410
+ def elements; end
411
+ def get_elements(xpath); end
412
+ def get_text(path = nil); end
413
+ def has_attributes?; end
414
+ def has_elements?; end
415
+ def has_text?; end
416
+ def ignore_whitespace_nodes; end
417
+ def initialize(arg = nil, parent = nil, context = nil); end
418
+ def inspect; end
419
+ def instructions; end
420
+ def namespace(prefix = nil); end
421
+ def namespaces; end
422
+ def next_element; end
423
+ def node_type; end
424
+ def prefixes; end
425
+ def previous_element; end
426
+ def raw; end
427
+ def root; end
428
+ def root_node; end
429
+ def text(path = nil); end
430
+ def text=(text); end
431
+ def texts; end
432
+ def whitespace; end
433
+ def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
434
+ def xpath; end
435
+ include REXML::Namespace
436
+ end
437
+ class REXML::Elements
438
+ def <<(element = nil); end
439
+ def [](index, name = nil); end
440
+ def []=(index, element); end
441
+ def add(element = nil); end
442
+ def collect(xpath = nil); end
443
+ def delete(element); end
444
+ def delete_all(xpath); end
445
+ def each(xpath = nil); end
446
+ def empty?; end
447
+ def index(element); end
448
+ def initialize(parent); end
449
+ def inject(xpath = nil, initial = nil); end
450
+ def literalize(name); end
451
+ def size; end
452
+ def to_a(xpath = nil); end
453
+ include Enumerable
454
+ end
455
+ class REXML::Attributes < Hash
456
+ def <<(attribute); end
457
+ def [](name); end
458
+ def []=(name, value); end
459
+ def add(attribute); end
460
+ def delete(attribute); end
461
+ def delete_all(name); end
462
+ def each; end
463
+ def each_attribute; end
464
+ def get_attribute(name); end
465
+ def get_attribute_ns(namespace, name); end
466
+ def initialize(element); end
467
+ def length; end
468
+ def namespaces; end
469
+ def prefixes; end
470
+ def size; end
471
+ def to_a; end
472
+ end
473
+ class REXML::XMLDecl < REXML::Child
474
+ def ==(other); end
475
+ def clone; end
476
+ def content(enc); end
477
+ def dowrite; end
478
+ def encoding=(enc); end
479
+ def initialize(version = nil, encoding = nil, standalone = nil); end
480
+ def inspect; end
481
+ def node_type; end
482
+ def nowrite; end
483
+ def old_enc=(encoding); end
484
+ def self.default; end
485
+ def stand_alone?; end
486
+ def standalone; end
487
+ def standalone=(arg0); end
488
+ def version; end
489
+ def version=(arg0); end
490
+ def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
491
+ def writeencoding; end
492
+ def writethis; end
493
+ def xmldecl(version, encoding, standalone); end
494
+ include REXML::Encoding
495
+ end
496
+ class REXML::Comment < REXML::Child
497
+ def <=>(other); end
498
+ def ==(other); end
499
+ def clone; end
500
+ def initialize(first, second = nil); end
501
+ def node_type; end
502
+ def string; end
503
+ def string=(arg0); end
504
+ def to_s; end
505
+ def write(output, indent = nil, transitive = nil, ie_hack = nil); end
506
+ include Comparable
507
+ end
508
+ class REXML::Instruction < REXML::Child
509
+ def ==(other); end
510
+ def clone; end
511
+ def content; end
512
+ def content=(arg0); end
513
+ def initialize(target, content = nil); end
514
+ def inspect; end
515
+ def node_type; end
516
+ def target; end
517
+ def target=(arg0); end
518
+ def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
519
+ end
520
+ class REXML::Output
521
+ def <<(content); end
522
+ def encoding; end
523
+ def initialize(real_IO, encd = nil); end
524
+ def to_s; end
525
+ include REXML::Encoding
526
+ end
527
+ class REXML::UndefinedNamespaceException < REXML::ParseException
528
+ def initialize(prefix, source, parser); end
529
+ end
530
+ class REXML::Parsers::BaseParser
531
+ def add_listener(listener); end
532
+ def empty?; end
533
+ def entity(reference, entities); end
534
+ def has_next?; end
535
+ def initialize(source); end
536
+ def need_source_encoding_update?(xml_declaration_encoding); end
537
+ def normalize(input, entities = nil, entity_filter = nil); end
538
+ def parse_attributes(prefixes, curr_ns); end
539
+ def peek(depth = nil); end
540
+ def position; end
541
+ def process_instruction; end
542
+ def pull; end
543
+ def pull_event; end
544
+ def source; end
545
+ def stream=(source); end
546
+ def unnormalize(string, entities = nil, filter = nil); end
547
+ def unshift(token); end
548
+ end
549
+ class REXML::Parsers::StreamParser
550
+ def add_listener(listener); end
551
+ def initialize(source, listener); end
552
+ def parse; end
553
+ end
554
+ module REXML::Validation
555
+ end
556
+ class REXML::Validation::ValidationException < RuntimeError
557
+ def initialize(msg); end
558
+ end
559
+ class REXML::Parsers::TreeParser
560
+ def add_listener(listener); end
561
+ def initialize(source, build_context = nil); end
562
+ def parse; end
563
+ end
564
+ class REXML::Document < REXML::Element
565
+ def <<(child); end
566
+ def add(child); end
567
+ def add_element(arg = nil, arg2 = nil); end
568
+ def build(source); end
569
+ def clone; end
570
+ def doctype; end
571
+ def document; end
572
+ def encoding; end
573
+ def entity_expansion_count; end
574
+ def expanded_name; end
575
+ def initialize(source = nil, context = nil); end
576
+ def name; end
577
+ def node_type; end
578
+ def record_entity_expansion; end
579
+ def root; end
580
+ def self.entity_expansion_limit; end
581
+ def self.entity_expansion_limit=(val); end
582
+ def self.entity_expansion_text_limit; end
583
+ def self.entity_expansion_text_limit=(val); end
584
+ def self.parse_stream(source, listener); end
585
+ def stand_alone?; end
586
+ def version; end
587
+ def write(*arguments); end
588
+ def xml_decl; end
589
+ end