researchable-freedcamp-api 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 (55) hide show
  1. checksums.yaml +7 -0
  2. data/.bundle/config +2 -0
  3. data/.gitignore +1 -0
  4. data/Gemfile +7 -0
  5. data/Gemfile.lock +69 -0
  6. data/LICENSE.txt +21 -0
  7. data/README.md +39 -0
  8. data/Rakefile +12 -0
  9. data/bin/console +15 -0
  10. data/bin/setup +8 -0
  11. data/lib/researchable/freedcamp_api/create_task.rb +22 -0
  12. data/lib/researchable/freedcamp_api/endpoint.rb +34 -0
  13. data/lib/researchable/freedcamp_api/list_milestones.rb +1 -0
  14. data/lib/researchable/freedcamp_api/list_projects.rb +1 -0
  15. data/lib/researchable/freedcamp_api/list_tasks.rb +36 -0
  16. data/lib/researchable/freedcamp_api/sessions/session.rb +28 -0
  17. data/lib/researchable/freedcamp_api/sessions/signed_session.rb +128 -0
  18. data/lib/researchable/freedcamp_api/sessions.rb +17 -0
  19. data/lib/researchable/freedcamp_api/structs/signature.rb +11 -0
  20. data/lib/researchable/freedcamp_api/structs/task.rb +48 -0
  21. data/lib/researchable/freedcamp_api/structs.rb +8 -0
  22. data/lib/researchable/freedcamp_api/update_task.rb +27 -0
  23. data/lib/researchable/freedcamp_api/version.rb +8 -0
  24. data/lib/researchable/freedcamp_api.rb +21 -0
  25. data/lib/researchable-freedcamp-api.rb +6 -0
  26. data/output/62d1c67bf1eebc3456f9cc8879519700b2a0fc45 +1 -0
  27. data/researchable_freedcamp_api.gemspec +44 -0
  28. data/sorbet/config +3 -0
  29. data/sorbet/rbi/gems/active_interaction.rbi +304 -0
  30. data/sorbet/rbi/gems/activemodel.rbi +342 -0
  31. data/sorbet/rbi/gems/activesupport.rbi +1023 -0
  32. data/sorbet/rbi/gems/concurrent-ruby.rbi +1662 -0
  33. data/sorbet/rbi/gems/httparty.rbi +446 -0
  34. data/sorbet/rbi/gems/i18n.rbi +133 -0
  35. data/sorbet/rbi/gems/mime-types-data.rbi +17 -0
  36. data/sorbet/rbi/gems/mime-types.rbi +225 -0
  37. data/sorbet/rbi/gems/multi_xml.rbi +35 -0
  38. data/sorbet/rbi/gems/researchable-freedcamp-api.rbi +25 -0
  39. data/sorbet/rbi/gems/rspec-core.rbi +1915 -0
  40. data/sorbet/rbi/gems/rspec-expectations.rbi +1151 -0
  41. data/sorbet/rbi/gems/rspec-mocks.rbi +1110 -0
  42. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  43. data/sorbet/rbi/gems/rspec.rbi +15 -0
  44. data/sorbet/rbi/gems/tzinfo.rbi +586 -0
  45. data/sorbet/rbi/hidden-definitions/errors.txt +4251 -0
  46. data/sorbet/rbi/hidden-definitions/hidden.rbi +8306 -0
  47. data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi +715 -0
  48. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6/activesupport.rbi +37 -0
  49. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +1850 -0
  50. data/sorbet/rbi/sorbet-typed/lib/httparty/all/httparty.rbi +566 -0
  51. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +108 -0
  52. data/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +24 -0
  53. data/sorbet/rbi/todo.rbi +7 -0
  54. data/test.rb +41 -0
  55. metadata +198 -0
@@ -0,0 +1,1662 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
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/concurrent-ruby/all/concurrent-ruby.rbi
9
+ #
10
+ # concurrent-ruby-1.1.9
11
+
12
+ module Concurrent
13
+ def abort_transaction; end
14
+ def atomically; end
15
+ def call_dataflow(method, executor, *inputs, &block); end
16
+ def dataflow!(*inputs, &block); end
17
+ def dataflow(*inputs, &block); end
18
+ def dataflow_with!(executor, *inputs, &block); end
19
+ def dataflow_with(executor, *inputs, &block); end
20
+ def leave_transaction; end
21
+ def monotonic_time; end
22
+ def self.abort_transaction; end
23
+ def self.atomically; end
24
+ def self.call_dataflow(method, executor, *inputs, &block); end
25
+ def self.create_simple_logger(level = nil, output = nil); end
26
+ def self.create_stdlib_logger(level = nil, output = nil); end
27
+ def self.dataflow!(*inputs, &block); end
28
+ def self.dataflow(*inputs, &block); end
29
+ def self.dataflow_with!(executor, *inputs, &block); end
30
+ def self.dataflow_with(executor, *inputs, &block); end
31
+ def self.disable_at_exit_handlers!; end
32
+ def self.executor(executor_identifier); end
33
+ def self.global_fast_executor; end
34
+ def self.global_immediate_executor; end
35
+ def self.global_io_executor; end
36
+ def self.global_logger; end
37
+ def self.global_logger=(value); end
38
+ def self.global_timer_set; end
39
+ def self.leave_transaction; end
40
+ def self.monotonic_time; end
41
+ def self.new_fast_executor(opts = nil); end
42
+ def self.new_io_executor(opts = nil); end
43
+ def self.physical_processor_count; end
44
+ def self.processor_count; end
45
+ def self.processor_counter; end
46
+ def self.use_simple_logger(level = nil, output = nil); end
47
+ def self.use_stdlib_logger(level = nil, output = nil); end
48
+ extend Concurrent::Concern::Deprecation
49
+ extend Concurrent::Concern::Logging
50
+ extend Concurrent::Utility::EngineDetector
51
+ extend Concurrent::Utility::NativeExtensionLoader
52
+ end
53
+ module Concurrent::Utility
54
+ end
55
+ module Concurrent::Utility::EngineDetector
56
+ def on_cruby?; end
57
+ def on_jruby?; end
58
+ def on_jruby_9000?; end
59
+ def on_linux?; end
60
+ def on_osx?; end
61
+ def on_rbx?; end
62
+ def on_truffleruby?; end
63
+ def on_windows?; end
64
+ def ruby_engine; end
65
+ def ruby_version(version = nil, comparison, major, minor, patch); end
66
+ end
67
+ module Concurrent::Synchronization
68
+ end
69
+ class Concurrent::Synchronization::AbstractObject
70
+ def full_memory_barrier; end
71
+ def initialize; end
72
+ def self.attr_volatile(*names); end
73
+ end
74
+ module Concurrent::Utility::NativeExtensionLoader
75
+ def allow_c_extensions?; end
76
+ def c_extensions_loaded?; end
77
+ def java_extensions_loaded?; end
78
+ def load_error_path(error); end
79
+ def load_native_extensions; end
80
+ def set_c_extensions_loaded; end
81
+ def set_java_extensions_loaded; end
82
+ def try_load_c_extension(path); end
83
+ end
84
+ module Concurrent::Synchronization::MriAttrVolatile
85
+ def full_memory_barrier; end
86
+ def self.included(base); end
87
+ end
88
+ module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
89
+ def attr_volatile(*names); end
90
+ end
91
+ class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject
92
+ def initialize; end
93
+ extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods
94
+ include Concurrent::Synchronization::MriAttrVolatile
95
+ end
96
+ module Concurrent::Synchronization::RbxAttrVolatile
97
+ def full_memory_barrier; end
98
+ def self.included(base); end
99
+ end
100
+ module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
101
+ def attr_volatile(*names); end
102
+ end
103
+ class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject
104
+ def initialize; end
105
+ extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
106
+ include Concurrent::Synchronization::RbxAttrVolatile
107
+ end
108
+ module Concurrent::Synchronization::TruffleRubyAttrVolatile
109
+ def full_memory_barrier; end
110
+ def self.included(base); end
111
+ end
112
+ module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
113
+ def attr_volatile(*names); end
114
+ end
115
+ class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject
116
+ def initialize; end
117
+ extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
118
+ include Concurrent::Synchronization::TruffleRubyAttrVolatile
119
+ end
120
+ class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject
121
+ def __initialize_atomic_fields__; end
122
+ def initialize; end
123
+ def self.atomic_attribute?(name); end
124
+ def self.atomic_attributes(inherited = nil); end
125
+ def self.attr_atomic(*names); end
126
+ def self.define_initialize_atomic_fields; end
127
+ def self.ensure_safe_initialization_when_final_fields_are_present; end
128
+ def self.safe_initialization!; end
129
+ def self.safe_initialization?; end
130
+ end
131
+ class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object
132
+ def ns_broadcast; end
133
+ def ns_signal; end
134
+ def ns_wait(timeout = nil); end
135
+ def ns_wait_until(timeout = nil, &condition); end
136
+ def synchronize; end
137
+ end
138
+ module Concurrent::Synchronization::ConditionSignalling
139
+ def ns_broadcast; end
140
+ def ns_signal; end
141
+ end
142
+ class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
143
+ def initialize(*defaults); end
144
+ def initialize_copy(other); end
145
+ def ns_wait(timeout = nil); end
146
+ def self.new(*args, &block); end
147
+ def synchronize; end
148
+ include Concurrent::Synchronization::ConditionSignalling
149
+ end
150
+ class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
151
+ def initialize(*defaults); end
152
+ def initialize_copy(other); end
153
+ def ns_wait(timeout = nil); end
154
+ def self.new(*args, &block); end
155
+ def synchronize; end
156
+ include Concurrent::Synchronization::ConditionSignalling
157
+ end
158
+ class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
159
+ def initialize(*defaults); end
160
+ def initialize_copy(other); end
161
+ def ns_broadcast; end
162
+ def ns_signal; end
163
+ def ns_wait(timeout = nil); end
164
+ def self.new(*args, &block); end
165
+ def synchronize(&block); end
166
+ end
167
+ class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject
168
+ def new_condition; end
169
+ end
170
+ class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject
171
+ def broadcast; end
172
+ def initialize(lock); end
173
+ def ns_broadcast; end
174
+ def ns_signal; end
175
+ def ns_wait(timeout = nil); end
176
+ def ns_wait_until(timeout = nil, &condition); end
177
+ def self.new(*args, &block); end
178
+ def self.private_new(*args, &block); end
179
+ def signal; end
180
+ def wait(timeout = nil); end
181
+ def wait_until(timeout = nil, &condition); end
182
+ end
183
+ class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject
184
+ def broadcast; end
185
+ def ns_broadcast; end
186
+ def ns_signal; end
187
+ def ns_wait(timeout = nil); end
188
+ def ns_wait_until(timeout = nil, &condition); end
189
+ def signal; end
190
+ def synchronize; end
191
+ def wait(timeout = nil); end
192
+ def wait_until(timeout = nil, &condition); end
193
+ end
194
+ module Concurrent::Collection
195
+ end
196
+ class Concurrent::Collection::NonConcurrentMapBackend
197
+ def [](key); end
198
+ def []=(key, value); end
199
+ def _get(key); end
200
+ def _set(key, value); end
201
+ def clear; end
202
+ def compute(key); end
203
+ def compute_if_absent(key); end
204
+ def compute_if_present(key); end
205
+ def delete(key); end
206
+ def delete_pair(key, value); end
207
+ def dupped_backend; end
208
+ def each_pair; end
209
+ def get_and_set(key, value); end
210
+ def get_or_default(key, default_value); end
211
+ def initialize(options = nil); end
212
+ def initialize_copy(other); end
213
+ def key?(key); end
214
+ def merge_pair(key, value); end
215
+ def pair?(key, expected_value); end
216
+ def replace_if_exists(key, new_value); end
217
+ def replace_pair(key, old_value, new_value); end
218
+ def size; end
219
+ def store_computed_value(key, new_value); end
220
+ end
221
+ class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend
222
+ def []=(key, value); end
223
+ def clear; end
224
+ def compute(key); end
225
+ def compute_if_absent(key); end
226
+ def compute_if_present(key); end
227
+ def delete(key); end
228
+ def delete_pair(key, value); end
229
+ def get_and_set(key, value); end
230
+ def initialize(options = nil); end
231
+ def merge_pair(key, value); end
232
+ def replace_if_exists(key, new_value); end
233
+ def replace_pair(key, old_value, new_value); end
234
+ end
235
+ class Concurrent::Map < Concurrent::Collection::MriMapBackend
236
+ def [](key); end
237
+ def []=(key, value); end
238
+ def each; end
239
+ def each_key; end
240
+ def each_pair; end
241
+ def each_value; end
242
+ def empty?; end
243
+ def fetch(key, default_value = nil); end
244
+ def fetch_or_store(key, default_value = nil); end
245
+ def get(key); end
246
+ def initialize(options = nil, &block); end
247
+ def initialize_copy(other); end
248
+ def inspect; end
249
+ def key(value); end
250
+ def keys; end
251
+ def marshal_dump; end
252
+ def marshal_load(hash); end
253
+ def populate_from(hash); end
254
+ def put(key, value); end
255
+ def put_if_absent(key, value); end
256
+ def raise_fetch_no_key; end
257
+ def validate_options_hash!(options); end
258
+ def value?(value); end
259
+ def values; end
260
+ end
261
+ module Concurrent::ThreadSafe
262
+ end
263
+ module Concurrent::ThreadSafe::Util
264
+ def self.make_synchronized_on_cruby(klass); end
265
+ def self.make_synchronized_on_rbx(klass); end
266
+ def self.make_synchronized_on_truffleruby(klass); end
267
+ end
268
+ class Concurrent::Hash < Hash
269
+ end
270
+ class Concurrent::Error < StandardError
271
+ end
272
+ class Concurrent::ConfigurationError < Concurrent::Error
273
+ end
274
+ class Concurrent::CancelledOperationError < Concurrent::Error
275
+ end
276
+ class Concurrent::LifecycleError < Concurrent::Error
277
+ end
278
+ class Concurrent::ImmutabilityError < Concurrent::Error
279
+ end
280
+ class Concurrent::IllegalOperationError < Concurrent::Error
281
+ end
282
+ class Concurrent::InitializationError < Concurrent::Error
283
+ end
284
+ class Concurrent::MaxRestartFrequencyError < Concurrent::Error
285
+ end
286
+ class Concurrent::MultipleAssignmentError < Concurrent::Error
287
+ def initialize(message = nil, inspection_data = nil); end
288
+ def inspect; end
289
+ def inspection_data; end
290
+ end
291
+ class Concurrent::RejectedExecutionError < Concurrent::Error
292
+ end
293
+ class Concurrent::ResourceLimitError < Concurrent::Error
294
+ end
295
+ class Concurrent::TimeoutError < Concurrent::Error
296
+ end
297
+ class Concurrent::MultipleErrors < Concurrent::Error
298
+ def errors; end
299
+ def initialize(errors, message = nil); end
300
+ end
301
+ class Concurrent::Event < Concurrent::Synchronization::LockableObject
302
+ def initialize; end
303
+ def ns_initialize; end
304
+ def ns_set; end
305
+ def reset; end
306
+ def set; end
307
+ def set?; end
308
+ def try?; end
309
+ def wait(timeout = nil); end
310
+ end
311
+ module Concurrent::Concern
312
+ end
313
+ module Concurrent::Concern::Dereferenceable
314
+ def apply_deref_options(value); end
315
+ def deref; end
316
+ def ns_set_deref_options(opts); end
317
+ def set_deref_options(opts = nil); end
318
+ def value; end
319
+ def value=(value); end
320
+ end
321
+ module Concurrent::Concern::Obligation
322
+ def compare_and_set_state(next_state, *expected_current); end
323
+ def complete?; end
324
+ def event; end
325
+ def exception(*args); end
326
+ def fulfilled?; end
327
+ def get_arguments_from(opts = nil); end
328
+ def if_state(*expected_states); end
329
+ def incomplete?; end
330
+ def init_obligation; end
331
+ def no_error!(timeout = nil); end
332
+ def ns_check_state?(expected); end
333
+ def ns_set_state(value); end
334
+ def pending?; end
335
+ def realized?; end
336
+ def reason; end
337
+ def rejected?; end
338
+ def set_state(success, value, reason); end
339
+ def state; end
340
+ def state=(value); end
341
+ def unscheduled?; end
342
+ def value!(timeout = nil); end
343
+ def value(timeout = nil); end
344
+ def wait!(timeout = nil); end
345
+ def wait(timeout = nil); end
346
+ include Concurrent::Concern::Dereferenceable
347
+ end
348
+ module Concurrent::Concern::Logging
349
+ def log(level, progname, message = nil, &block); end
350
+ include Logger::Severity
351
+ end
352
+ module Concurrent::Concern::Deprecation
353
+ def deprecated(message, strip = nil); end
354
+ def deprecated_method(old_name, new_name); end
355
+ extend Concurrent::Concern::Deprecation
356
+ include Concurrent::Concern::Logging
357
+ end
358
+ module Concurrent::ExecutorService
359
+ def <<(task); end
360
+ def can_overflow?; end
361
+ def post(*args, &task); end
362
+ def serialized?; end
363
+ include Concurrent::Concern::Logging
364
+ end
365
+ class Concurrent::AbstractExecutorService < Concurrent::Synchronization::LockableObject
366
+ def auto_terminate=(value); end
367
+ def auto_terminate?; end
368
+ def fallback_policy; end
369
+ def handle_fallback(*args); end
370
+ def initialize(opts = nil, &block); end
371
+ def kill; end
372
+ def name; end
373
+ def ns_auto_terminate?; end
374
+ def ns_execute(*args, &task); end
375
+ def ns_kill_execution; end
376
+ def ns_shutdown_execution; end
377
+ def running?; end
378
+ def shutdown; end
379
+ def shutdown?; end
380
+ def shuttingdown?; end
381
+ def to_s; end
382
+ def wait_for_termination(timeout = nil); end
383
+ include Concurrent::Concern::Deprecation
384
+ include Concurrent::ExecutorService
385
+ end
386
+ module Concurrent::SerialExecutorService
387
+ def serialized?; end
388
+ include Concurrent::ExecutorService
389
+ end
390
+ class Concurrent::ImmediateExecutor < Concurrent::AbstractExecutorService
391
+ def <<(task); end
392
+ def initialize; end
393
+ def kill; end
394
+ def post(*args, &task); end
395
+ def running?; end
396
+ def shutdown; end
397
+ def shutdown?; end
398
+ def shuttingdown?; end
399
+ def wait_for_termination(timeout = nil); end
400
+ include Concurrent::SerialExecutorService
401
+ end
402
+ class Concurrent::Delay < Concurrent::Synchronization::LockableObject
403
+ def execute_task_once; end
404
+ def initialize(opts = nil, &block); end
405
+ def ns_initialize(opts, &block); end
406
+ def reconfigure(&block); end
407
+ def value!(timeout = nil); end
408
+ def value(timeout = nil); end
409
+ def wait(timeout = nil); end
410
+ include Concurrent::Concern::Obligation
411
+ end
412
+ module Concurrent::AtomicNumericCompareAndSetWrapper
413
+ def compare_and_set(old_value, new_value); end
414
+ end
415
+ class Concurrent::MutexAtomicReference < Concurrent::Synchronization::LockableObject
416
+ def _compare_and_set(old_value, new_value); end
417
+ def compare_and_swap(old_value, new_value); end
418
+ def get; end
419
+ def get_and_set(new_value); end
420
+ def initialize(value = nil); end
421
+ def ns_initialize(value); end
422
+ def set(new_value); end
423
+ def swap(new_value); end
424
+ def value; end
425
+ def value=(new_value); end
426
+ include Concurrent::AtomicDirectUpdate
427
+ include Concurrent::AtomicNumericCompareAndSetWrapper
428
+ end
429
+ module Concurrent::AtomicDirectUpdate
430
+ def try_update!; end
431
+ def try_update; end
432
+ def update; end
433
+ end
434
+ class Concurrent::ConcurrentUpdateError < ThreadError
435
+ end
436
+ class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
437
+ def inspect; end
438
+ def to_s; end
439
+ end
440
+ class Concurrent::RubyExecutorService < Concurrent::AbstractExecutorService
441
+ def initialize(*args, &block); end
442
+ def kill; end
443
+ def ns_running?; end
444
+ def ns_shutdown?; end
445
+ def ns_shutdown_execution; end
446
+ def ns_shuttingdown?; end
447
+ def post(*args, &task); end
448
+ def shutdown; end
449
+ def stop_event; end
450
+ def stopped_event; end
451
+ def wait_for_termination(timeout = nil); end
452
+ end
453
+ class Concurrent::RubyThreadPoolExecutor < Concurrent::RubyExecutorService
454
+ def can_overflow?; end
455
+ def completed_task_count; end
456
+ def idletime; end
457
+ def initialize(opts = nil); end
458
+ def largest_length; end
459
+ def length; end
460
+ def max_length; end
461
+ def max_queue; end
462
+ def min_length; end
463
+ def ns_add_busy_worker; end
464
+ def ns_assign_worker(*args, &task); end
465
+ def ns_enqueue(*args, &task); end
466
+ def ns_execute(*args, &task); end
467
+ def ns_initialize(opts); end
468
+ def ns_kill_execution; end
469
+ def ns_limited_queue?; end
470
+ def ns_prune_pool; end
471
+ def ns_ready_worker(worker, success = nil); end
472
+ def ns_remove_busy_worker(worker); end
473
+ def ns_reset_if_forked; end
474
+ def ns_shutdown_execution; end
475
+ def ns_worker_died(worker); end
476
+ def ns_worker_not_old_enough(worker); end
477
+ def queue_length; end
478
+ def ready_worker(worker); end
479
+ def remaining_capacity; end
480
+ def remove_busy_worker(worker); end
481
+ def scheduled_task_count; end
482
+ def synchronous; end
483
+ def worker_died(worker); end
484
+ def worker_not_old_enough(worker); end
485
+ def worker_task_completed; end
486
+ end
487
+ class Concurrent::RubyThreadPoolExecutor::Worker
488
+ def <<(message); end
489
+ def create_worker(queue, pool, idletime); end
490
+ def initialize(pool, id); end
491
+ def kill; end
492
+ def run_task(pool, task, args); end
493
+ def stop; end
494
+ include Concurrent::Concern::Logging
495
+ end
496
+ class Concurrent::ThreadPoolExecutor < Concurrent::RubyThreadPoolExecutor
497
+ end
498
+ class Concurrent::CachedThreadPool < Concurrent::ThreadPoolExecutor
499
+ def initialize(opts = nil); end
500
+ def ns_initialize(opts); end
501
+ end
502
+ class Concurrent::Utility::ProcessorCounter
503
+ def compute_physical_processor_count; end
504
+ def compute_processor_count; end
505
+ def initialize; end
506
+ def physical_processor_count; end
507
+ def processor_count; end
508
+ end
509
+ class Concurrent::MutexAtomicBoolean < Concurrent::Synchronization::LockableObject
510
+ def false?; end
511
+ def initialize(initial = nil); end
512
+ def make_false; end
513
+ def make_true; end
514
+ def ns_initialize(initial); end
515
+ def ns_make_value(value); end
516
+ def true?; end
517
+ def value; end
518
+ def value=(value); end
519
+ end
520
+ class Concurrent::AtomicBoolean < Concurrent::MutexAtomicBoolean
521
+ def inspect; end
522
+ def to_s; end
523
+ end
524
+ module Concurrent::Utility::NativeInteger
525
+ def ensure_integer(value); end
526
+ def ensure_integer_and_bounds(value); end
527
+ def ensure_lower_bound(value); end
528
+ def ensure_positive(value); end
529
+ def ensure_positive_and_no_zero(value); end
530
+ def ensure_upper_bound(value); end
531
+ extend Concurrent::Utility::NativeInteger
532
+ end
533
+ class Concurrent::MutexAtomicFixnum < Concurrent::Synchronization::LockableObject
534
+ def compare_and_set(expect, update); end
535
+ def decrement(delta = nil); end
536
+ def down(delta = nil); end
537
+ def increment(delta = nil); end
538
+ def initialize(initial = nil); end
539
+ def ns_initialize(initial); end
540
+ def ns_set(value); end
541
+ def up(delta = nil); end
542
+ def update; end
543
+ def value; end
544
+ def value=(value); end
545
+ end
546
+ class Concurrent::AtomicFixnum < Concurrent::MutexAtomicFixnum
547
+ def inspect; end
548
+ def to_s; end
549
+ end
550
+ class Concurrent::CyclicBarrier < Concurrent::Synchronization::LockableObject
551
+ def broken?; end
552
+ def initialize(parties, &block); end
553
+ def ns_generation_done(generation, status, continue = nil); end
554
+ def ns_initialize(parties, &block); end
555
+ def ns_next_generation; end
556
+ def number_waiting; end
557
+ def parties; end
558
+ def reset; end
559
+ def wait(timeout = nil); end
560
+ end
561
+ class Concurrent::CyclicBarrier::Generation < Struct
562
+ def self.[](*arg0); end
563
+ def self.inspect; end
564
+ def self.members; end
565
+ def self.new(*arg0); end
566
+ def status; end
567
+ def status=(_); end
568
+ end
569
+ class Concurrent::MutexCountDownLatch < Concurrent::Synchronization::LockableObject
570
+ def count; end
571
+ def count_down; end
572
+ def initialize(count = nil); end
573
+ def ns_initialize(count); end
574
+ def wait(timeout = nil); end
575
+ end
576
+ class Concurrent::CountDownLatch < Concurrent::MutexCountDownLatch
577
+ end
578
+ class Concurrent::ReadWriteLock < Concurrent::Synchronization::Object
579
+ def acquire_read_lock; end
580
+ def acquire_write_lock; end
581
+ def has_waiters?; end
582
+ def initialize; end
583
+ def max_readers?(c = nil); end
584
+ def max_writers?(c = nil); end
585
+ def release_read_lock; end
586
+ def release_write_lock; end
587
+ def running_readers(c = nil); end
588
+ def running_readers?(c = nil); end
589
+ def running_writer?(c = nil); end
590
+ def self.new(*args, &block); end
591
+ def waiting_writer?(c = nil); end
592
+ def waiting_writers(c = nil); end
593
+ def with_read_lock; end
594
+ def with_write_lock; end
595
+ def write_locked?; end
596
+ end
597
+ class Concurrent::AbstractThreadLocalVar
598
+ def allocate_storage; end
599
+ def bind(value, &block); end
600
+ def default; end
601
+ def initialize(default = nil, &default_block); end
602
+ def value; end
603
+ def value=(value); end
604
+ end
605
+ class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
606
+ def allocate_storage; end
607
+ def get_default; end
608
+ def get_threadlocal_array(thread = nil); end
609
+ def next_index; end
610
+ def self.semi_sync(&block); end
611
+ def self.thread_finalizer(id); end
612
+ def self.thread_local_finalizer(index); end
613
+ def set_threadlocal_array(array, thread = nil); end
614
+ def value; end
615
+ def value=(value); end
616
+ def value_for(thread); end
617
+ end
618
+ class Concurrent::ThreadLocalVar < Concurrent::RubyThreadLocalVar
619
+ end
620
+ class Concurrent::ReentrantReadWriteLock < Concurrent::Synchronization::Object
621
+ def acquire_read_lock; end
622
+ def acquire_write_lock; end
623
+ def initialize; end
624
+ def max_readers?(c = nil); end
625
+ def max_writers?(c = nil); end
626
+ def release_read_lock; end
627
+ def release_write_lock; end
628
+ def running_readers(c = nil); end
629
+ def running_readers?(c = nil); end
630
+ def running_writer?(c = nil); end
631
+ def self.new(*args, &block); end
632
+ def try_read_lock; end
633
+ def try_write_lock; end
634
+ def waiting_or_running_writer?(c = nil); end
635
+ def waiting_writers(c = nil); end
636
+ def with_read_lock; end
637
+ def with_write_lock; end
638
+ end
639
+ class Concurrent::MutexSemaphore < Concurrent::Synchronization::LockableObject
640
+ def acquire(permits = nil); end
641
+ def available_permits; end
642
+ def drain_permits; end
643
+ def initialize(count); end
644
+ def ns_initialize(count); end
645
+ def reduce_permits(reduction); end
646
+ def release(permits = nil); end
647
+ def try_acquire(permits = nil, timeout = nil); end
648
+ def try_acquire_now(permits); end
649
+ def try_acquire_timed(permits, timeout); end
650
+ end
651
+ class Concurrent::Semaphore < Concurrent::MutexSemaphore
652
+ end
653
+ class Concurrent::FixedThreadPool < Concurrent::ThreadPoolExecutor
654
+ def initialize(num_threads, opts = nil); end
655
+ end
656
+ class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
657
+ def <<(task); end
658
+ def kill; end
659
+ def ns_initialize(*args); end
660
+ def post(*args, &task); end
661
+ def running?; end
662
+ def self.<<(task); end
663
+ def self.post(*args); end
664
+ def shutdown; end
665
+ def shutdown?; end
666
+ def shuttingdown?; end
667
+ def wait_for_termination(timeout = nil); end
668
+ end
669
+ class Concurrent::IndirectImmediateExecutor < Concurrent::ImmediateExecutor
670
+ def initialize; end
671
+ def post(*args, &task); end
672
+ end
673
+ class Concurrent::RubySingleThreadExecutor < Concurrent::RubyThreadPoolExecutor
674
+ def initialize(opts = nil); end
675
+ end
676
+ class Concurrent::SafeTaskExecutor < Concurrent::Synchronization::LockableObject
677
+ def execute(*args); end
678
+ def initialize(task, opts = nil); end
679
+ end
680
+ class Concurrent::SerializedExecution < Concurrent::Synchronization::LockableObject
681
+ def call_job(job); end
682
+ def initialize; end
683
+ def ns_initialize; end
684
+ def post(executor, *args, &task); end
685
+ def posts(posts); end
686
+ def work(job); end
687
+ include Concurrent::Concern::Logging
688
+ end
689
+ class Concurrent::SerializedExecution::Job < Struct
690
+ def args; end
691
+ def args=(_); end
692
+ def block; end
693
+ def block=(_); end
694
+ def call; end
695
+ def executor; end
696
+ def executor=(_); end
697
+ def self.[](*arg0); end
698
+ def self.inspect; end
699
+ def self.members; end
700
+ def self.new(*arg0); end
701
+ end
702
+ class Concurrent::SerializedExecutionDelegator < SimpleDelegator
703
+ def initialize(executor); end
704
+ def post(*args, &task); end
705
+ include Concurrent::SerialExecutorService
706
+ end
707
+ class Concurrent::SingleThreadExecutor < Concurrent::RubySingleThreadExecutor
708
+ end
709
+ class Concurrent::Collection::CopyOnWriteObserverSet < Concurrent::Synchronization::LockableObject
710
+ def add_observer(observer = nil, func = nil, &block); end
711
+ def clear_observers_and_return_old; end
712
+ def count_observers; end
713
+ def delete_observer(observer); end
714
+ def delete_observers; end
715
+ def initialize; end
716
+ def notify_and_delete_observers(*args, &block); end
717
+ def notify_observers(*args, &block); end
718
+ def notify_to(observers, *args); end
719
+ def ns_initialize; end
720
+ def observers; end
721
+ def observers=(new_set); end
722
+ end
723
+ class Concurrent::Collection::CopyOnNotifyObserverSet < Concurrent::Synchronization::LockableObject
724
+ def add_observer(observer = nil, func = nil, &block); end
725
+ def count_observers; end
726
+ def delete_observer(observer); end
727
+ def delete_observers; end
728
+ def duplicate_and_clear_observers; end
729
+ def duplicate_observers; end
730
+ def initialize; end
731
+ def notify_and_delete_observers(*args, &block); end
732
+ def notify_observers(*args, &block); end
733
+ def notify_to(observers, *args); end
734
+ def ns_initialize; end
735
+ end
736
+ module Concurrent::Concern::Observable
737
+ def add_observer(observer = nil, func = nil, &block); end
738
+ def count_observers; end
739
+ def delete_observer(observer); end
740
+ def delete_observers; end
741
+ def observers; end
742
+ def observers=(arg0); end
743
+ def with_observer(observer = nil, func = nil, &block); end
744
+ end
745
+ class Concurrent::IVar < Concurrent::Synchronization::LockableObject
746
+ def add_observer(observer = nil, func = nil, &block); end
747
+ def check_for_block_or_value!(block_given, value); end
748
+ def complete(success, value, reason); end
749
+ def complete_without_notification(success, value, reason); end
750
+ def fail(reason = nil); end
751
+ def initialize(value = nil, opts = nil, &block); end
752
+ def notify_observers(value, reason); end
753
+ def ns_complete_without_notification(success, value, reason); end
754
+ def ns_initialize(value, opts); end
755
+ def safe_execute(task, args = nil); end
756
+ def set(value = nil); end
757
+ def try_set(value = nil, &block); end
758
+ include Concurrent::Concern::Obligation
759
+ include Concurrent::Concern::Observable
760
+ end
761
+ module Concurrent::Options
762
+ def self.executor(executor_identifier); end
763
+ def self.executor_from_options(opts = nil); end
764
+ end
765
+ class Concurrent::ScheduledTask < Concurrent::IVar
766
+ def <=>(other); end
767
+ def cancel; end
768
+ def cancelled?; end
769
+ def execute; end
770
+ def executor; end
771
+ def fail(reason = nil); end
772
+ def initial_delay; end
773
+ def initialize(delay, opts = nil, &task); end
774
+ def ns_reschedule(delay); end
775
+ def ns_schedule(delay); end
776
+ def process_task; end
777
+ def processing?; end
778
+ def reschedule(delay); end
779
+ def reset; end
780
+ def schedule_time; end
781
+ def self.execute(delay, opts = nil, &task); end
782
+ def set(value = nil); end
783
+ def try_set(value = nil, &block); end
784
+ include Comparable
785
+ end
786
+ class Concurrent::Collection::RubyNonConcurrentPriorityQueue
787
+ def <<(item); end
788
+ def clear; end
789
+ def delete(item); end
790
+ def deq; end
791
+ def empty?; end
792
+ def enq(item); end
793
+ def has_priority?(item); end
794
+ def include?(item); end
795
+ def initialize(opts = nil); end
796
+ def length; end
797
+ def ordered?(x, y); end
798
+ def peek; end
799
+ def pop; end
800
+ def push(item); end
801
+ def self.from_list(list, opts = nil); end
802
+ def shift; end
803
+ def sink(k); end
804
+ def size; end
805
+ def swap(x, y); end
806
+ def swim(k); end
807
+ end
808
+ class Concurrent::Collection::NonConcurrentPriorityQueue < Concurrent::Collection::RubyNonConcurrentPriorityQueue
809
+ def <<(item); end
810
+ def deq; end
811
+ def enq(item); end
812
+ def has_priority?(item); end
813
+ def shift; end
814
+ def size; end
815
+ end
816
+ class Concurrent::TimerSet < Concurrent::RubyExecutorService
817
+ def <<(task); end
818
+ def initialize(opts = nil); end
819
+ def kill; end
820
+ def ns_initialize(opts); end
821
+ def ns_post_task(task); end
822
+ def ns_reset_if_forked; end
823
+ def ns_shutdown_execution; end
824
+ def post(delay, *args, &task); end
825
+ def post_task(task); end
826
+ def process_tasks; end
827
+ def remove_task(task); end
828
+ end
829
+ class Concurrent::AtomicMarkableReference < Concurrent::Synchronization::Object
830
+ def __initialize_atomic_fields__; end
831
+ def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
832
+ def compare_and_set_reference(expected, value); end
833
+ def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
834
+ def get; end
835
+ def immutable_array(*args); end
836
+ def initialize(value = nil, mark = nil); end
837
+ def mark; end
838
+ def marked?; end
839
+ def reference; end
840
+ def reference=(value); end
841
+ def self.new(*args, &block); end
842
+ def set(new_val, new_mark); end
843
+ def swap_reference(value); end
844
+ def try_update!; end
845
+ def try_update; end
846
+ def update; end
847
+ def update_reference(&block); end
848
+ def value; end
849
+ end
850
+ class Concurrent::Agent < Concurrent::Synchronization::LockableObject
851
+ def <<(action); end
852
+ def await; end
853
+ def await_for!(timeout); end
854
+ def await_for(timeout); end
855
+ def deref; end
856
+ def enqueue_action_job(action, args, executor); end
857
+ def enqueue_await_job(latch); end
858
+ def error; end
859
+ def error_mode; end
860
+ def execute_next_job; end
861
+ def failed?; end
862
+ def handle_error(error); end
863
+ def initialize(initial, opts = nil); end
864
+ def ns_enqueue_job(job, index = nil); end
865
+ def ns_find_last_job_for_thread; end
866
+ def ns_initialize(initial, opts); end
867
+ def ns_post_next_job; end
868
+ def ns_validate(value); end
869
+ def post(*args, &action); end
870
+ def reason; end
871
+ def restart(new_value, opts = nil); end
872
+ def self.await(*agents); end
873
+ def self.await_for!(timeout, *agents); end
874
+ def self.await_for(timeout, *agents); end
875
+ def send!(*args, &action); end
876
+ def send(*args, &action); end
877
+ def send_off!(*args, &action); end
878
+ def send_off(*args, &action); end
879
+ def send_via!(executor, *args, &action); end
880
+ def send_via(executor, *args, &action); end
881
+ def stopped?; end
882
+ def value; end
883
+ def wait(timeout = nil); end
884
+ include Concurrent::Concern::Observable
885
+ end
886
+ class Concurrent::Agent::Job < Struct
887
+ def action; end
888
+ def action=(_); end
889
+ def args; end
890
+ def args=(_); end
891
+ def caller; end
892
+ def caller=(_); end
893
+ def executor; end
894
+ def executor=(_); end
895
+ def self.[](*arg0); end
896
+ def self.inspect; end
897
+ def self.members; end
898
+ def self.new(*arg0); end
899
+ end
900
+ class Concurrent::Agent::Error < StandardError
901
+ def initialize(message = nil); end
902
+ end
903
+ class Concurrent::Agent::ValidationError < Concurrent::Agent::Error
904
+ def initialize(message = nil); end
905
+ end
906
+ class Concurrent::Atom < Concurrent::Synchronization::Object
907
+ def __initialize_atomic_fields__; end
908
+ def compare_and_set(old_value, new_value); end
909
+ def compare_and_set_value(expected, value); end
910
+ def deref; end
911
+ def initialize(value, opts = nil); end
912
+ def reset(new_value); end
913
+ def self.new(*args, &block); end
914
+ def swap(*args); end
915
+ def swap_value(value); end
916
+ def update_value(&block); end
917
+ def valid?(new_value); end
918
+ def value; end
919
+ def value=(value); end
920
+ include Concurrent::Concern::Observable
921
+ end
922
+ class Concurrent::Array < Array
923
+ end
924
+ class Concurrent::CRubySet < Set
925
+ def &(*args); end
926
+ def +(*args); end
927
+ def -(*args); end
928
+ def <(*args); end
929
+ def <<(*args); end
930
+ def <=(*args); end
931
+ def ==(*args); end
932
+ def ===(*args); end
933
+ def >(*args); end
934
+ def >=(*args); end
935
+ def ^(*args); end
936
+ def add(*args); end
937
+ def add?(*args); end
938
+ def classify(*args); end
939
+ def clear(*args); end
940
+ def collect!(*args); end
941
+ def compare_by_identity(*args); end
942
+ def compare_by_identity?(*args); end
943
+ def delete(*args); end
944
+ def delete?(*args); end
945
+ def delete_if(*args); end
946
+ def difference(*args); end
947
+ def disjoint?(*args); end
948
+ def divide(*args); end
949
+ def each(*args); end
950
+ def empty?(*args); end
951
+ def eql?(*args); end
952
+ def filter!(*args); end
953
+ def flatten!(*args); end
954
+ def flatten(*args); end
955
+ def flatten_merge(*args); end
956
+ def freeze(*args); end
957
+ def hash(*args); end
958
+ def include?(*args); end
959
+ def initialize(*args, &block); end
960
+ def initialize_copy(other); end
961
+ def inspect(*args); end
962
+ def intersect?(*args); end
963
+ def intersection(*args); end
964
+ def keep_if(*args); end
965
+ def length(*args); end
966
+ def map!(*args); end
967
+ def member?(*args); end
968
+ def merge(*args); end
969
+ def pretty_print(*args); end
970
+ def pretty_print_cycle(*args); end
971
+ def proper_subset?(*args); end
972
+ def proper_superset?(*args); end
973
+ def reject!(*args); end
974
+ def replace(*args); end
975
+ def reset(*args); end
976
+ def select!(*args); end
977
+ def size(*args); end
978
+ def subset?(*args); end
979
+ def subtract(*args); end
980
+ def superset?(*args); end
981
+ def taint(*args); end
982
+ def to_a(*args); end
983
+ def to_s(*args); end
984
+ def to_set(*args); end
985
+ def union(*args); end
986
+ def untaint(*args); end
987
+ def |(*args); end
988
+ end
989
+ class Concurrent::Set < Concurrent::CRubySet
990
+ end
991
+ class Concurrent::Tuple
992
+ def cas(i, old_value, new_value); end
993
+ def compare_and_set(i, old_value, new_value); end
994
+ def each; end
995
+ def get(i); end
996
+ def initialize(size); end
997
+ def set(i, value); end
998
+ def size; end
999
+ def volatile_get(i); end
1000
+ def volatile_set(i, value); end
1001
+ include Enumerable
1002
+ end
1003
+ module Concurrent::Async
1004
+ def async; end
1005
+ def await; end
1006
+ def call; end
1007
+ def cast; end
1008
+ def init_synchronization; end
1009
+ def self.included(base); end
1010
+ def self.validate_argc(obj, method, *args); end
1011
+ end
1012
+ module Concurrent::Async::ClassMethods
1013
+ def new(*args, &block); end
1014
+ end
1015
+ class Concurrent::Async::AsyncDelegator < Concurrent::Synchronization::LockableObject
1016
+ def initialize(delegate); end
1017
+ def method_missing(method, *args, &block); end
1018
+ def perform; end
1019
+ def reset_if_forked; end
1020
+ def respond_to_missing?(method, include_private = nil); end
1021
+ end
1022
+ class Concurrent::Async::AwaitDelegator
1023
+ def initialize(delegate); end
1024
+ def method_missing(method, *args, &block); end
1025
+ def respond_to_missing?(method, include_private = nil); end
1026
+ end
1027
+ class Concurrent::Future < Concurrent::IVar
1028
+ def cancel; end
1029
+ def cancelled?; end
1030
+ def execute; end
1031
+ def initialize(opts = nil, &block); end
1032
+ def ns_initialize(value, opts); end
1033
+ def self.execute(opts = nil, &block); end
1034
+ def set(value = nil, &block); end
1035
+ def wait_or_cancel(timeout); end
1036
+ end
1037
+ class Concurrent::DependencyCounter
1038
+ def initialize(count, &block); end
1039
+ def update(time, value, reason); end
1040
+ end
1041
+ class Concurrent::Maybe < Concurrent::Synchronization::Object
1042
+ def <=>(other); end
1043
+ def fulfilled?; end
1044
+ def initialize(just, nothing); end
1045
+ def just; end
1046
+ def just?; end
1047
+ def nothing; end
1048
+ def nothing?; end
1049
+ def or(other); end
1050
+ def reason; end
1051
+ def rejected?; end
1052
+ def self.from(*args); end
1053
+ def self.just(value); end
1054
+ def self.new(*args, &block); end
1055
+ def self.nothing(error = nil); end
1056
+ def value; end
1057
+ include Comparable
1058
+ end
1059
+ class Concurrent::AbstractExchanger < Concurrent::Synchronization::Object
1060
+ def do_exchange(value, timeout); end
1061
+ def exchange!(value, timeout = nil); end
1062
+ def exchange(value, timeout = nil); end
1063
+ def initialize; end
1064
+ def try_exchange(value, timeout = nil); end
1065
+ end
1066
+ class Concurrent::RubyExchanger < Concurrent::AbstractExchanger
1067
+ def __initialize_atomic_fields__; end
1068
+ def compare_and_set_slot(expected, value); end
1069
+ def do_exchange(value, timeout); end
1070
+ def initialize; end
1071
+ def self.new(*args, &block); end
1072
+ def slot; end
1073
+ def slot=(value); end
1074
+ def swap_slot(value); end
1075
+ def update_slot(&block); end
1076
+ end
1077
+ class Concurrent::RubyExchanger::Node < Concurrent::Synchronization::Object
1078
+ def __initialize_atomic_fields__; end
1079
+ def compare_and_set_value(expected, value); end
1080
+ def initialize(item); end
1081
+ def item; end
1082
+ def latch; end
1083
+ def self.new(*args, &block); end
1084
+ def swap_value(value); end
1085
+ def update_value(&block); end
1086
+ def value; end
1087
+ def value=(value); end
1088
+ end
1089
+ class Concurrent::Exchanger < Concurrent::RubyExchanger
1090
+ end
1091
+ module Concurrent::Synchronization::AbstractStruct
1092
+ def initialize(*values); end
1093
+ def length; end
1094
+ def members; end
1095
+ def ns_each; end
1096
+ def ns_each_pair; end
1097
+ def ns_equality(other); end
1098
+ def ns_get(member); end
1099
+ def ns_initialize_copy; end
1100
+ def ns_inspect; end
1101
+ def ns_merge(other, &block); end
1102
+ def ns_select; end
1103
+ def ns_to_h; end
1104
+ def ns_values; end
1105
+ def ns_values_at(indexes); end
1106
+ def pr_underscore(clazz); end
1107
+ def self.define_struct_class(parent, base, name, members, &block); end
1108
+ def size; end
1109
+ end
1110
+ module Concurrent::ImmutableStruct
1111
+ def ==(other); end
1112
+ def [](member); end
1113
+ def each(&block); end
1114
+ def each_pair(&block); end
1115
+ def initialize_copy(original); end
1116
+ def inspect; end
1117
+ def merge(other, &block); end
1118
+ def select(&block); end
1119
+ def self.included(base); end
1120
+ def self.new(*args, &block); end
1121
+ def to_a; end
1122
+ def to_h; end
1123
+ def to_s; end
1124
+ def values; end
1125
+ def values_at(*indexes); end
1126
+ include Concurrent::Synchronization::AbstractStruct
1127
+ end
1128
+ module Concurrent::MutableStruct
1129
+ def ==(other); end
1130
+ def [](member); end
1131
+ def []=(member, value); end
1132
+ def each(&block); end
1133
+ def each_pair(&block); end
1134
+ def initialize_copy(original); end
1135
+ def inspect; end
1136
+ def merge(other, &block); end
1137
+ def select(&block); end
1138
+ def self.new(*args, &block); end
1139
+ def to_a; end
1140
+ def to_h; end
1141
+ def to_s; end
1142
+ def values; end
1143
+ def values_at(*indexes); end
1144
+ include Concurrent::Synchronization::AbstractStruct
1145
+ end
1146
+ class Concurrent::MVar < Concurrent::Synchronization::Object
1147
+ def borrow(timeout = nil); end
1148
+ def empty?; end
1149
+ def full?; end
1150
+ def initialize(value = nil, opts = nil); end
1151
+ def modify!; end
1152
+ def modify(timeout = nil); end
1153
+ def put(value, timeout = nil); end
1154
+ def self.new(*args, &block); end
1155
+ def set!(value); end
1156
+ def synchronize(&block); end
1157
+ def take(timeout = nil); end
1158
+ def try_put!(value); end
1159
+ def try_take!; end
1160
+ def unlocked_empty?; end
1161
+ def unlocked_full?; end
1162
+ def wait_for_empty(timeout); end
1163
+ def wait_for_full(timeout); end
1164
+ def wait_while(condition, timeout); end
1165
+ include Concurrent::Concern::Dereferenceable
1166
+ end
1167
+ class Concurrent::PromiseExecutionError < StandardError
1168
+ end
1169
+ class Concurrent::Promise < Concurrent::IVar
1170
+ def catch(&block); end
1171
+ def complete(success, value, reason); end
1172
+ def execute; end
1173
+ def fail(reason = nil); end
1174
+ def flat_map(&block); end
1175
+ def initialize(opts = nil, &block); end
1176
+ def notify_child(child); end
1177
+ def ns_initialize(value, opts); end
1178
+ def on_error(&block); end
1179
+ def on_fulfill(result); end
1180
+ def on_reject(reason); end
1181
+ def on_success(&block); end
1182
+ def realize(task); end
1183
+ def rescue(&block); end
1184
+ def root?; end
1185
+ def self.aggregate(method, *promises); end
1186
+ def self.all?(*promises); end
1187
+ def self.any?(*promises); end
1188
+ def self.execute(opts = nil, &block); end
1189
+ def self.fulfill(value, opts = nil); end
1190
+ def self.reject(reason, opts = nil); end
1191
+ def self.zip(*promises); end
1192
+ def set(value = nil, &block); end
1193
+ def set_pending; end
1194
+ def set_state!(success, value, reason); end
1195
+ def synchronized_set_state!(success, value, reason); end
1196
+ def then(*args, &block); end
1197
+ def zip(*others); end
1198
+ end
1199
+ module Concurrent::SettableStruct
1200
+ def ==(other); end
1201
+ def [](member); end
1202
+ def []=(member, value); end
1203
+ def each(&block); end
1204
+ def each_pair(&block); end
1205
+ def initialize_copy(original); end
1206
+ def inspect; end
1207
+ def merge(other, &block); end
1208
+ def select(&block); end
1209
+ def self.new(*args, &block); end
1210
+ def to_a; end
1211
+ def to_h; end
1212
+ def to_s; end
1213
+ def values; end
1214
+ def values_at(*indexes); end
1215
+ include Concurrent::Synchronization::AbstractStruct
1216
+ end
1217
+ class Concurrent::TimerTask < Concurrent::RubyExecutorService
1218
+ def <<(task); end
1219
+ def execute; end
1220
+ def execute_task(completion); end
1221
+ def execution_interval; end
1222
+ def execution_interval=(value); end
1223
+ def initialize(opts = nil, &task); end
1224
+ def ns_initialize(opts, &task); end
1225
+ def ns_kill_execution; end
1226
+ def ns_shutdown_execution; end
1227
+ def post(*args, &task); end
1228
+ def running?; end
1229
+ def schedule_next_task(interval = nil); end
1230
+ def self.execute(opts = nil, &task); end
1231
+ def timeout_interval; end
1232
+ def timeout_interval=(value); end
1233
+ def timeout_task(completion); end
1234
+ include Concurrent::Concern::Dereferenceable
1235
+ include Concurrent::Concern::Observable
1236
+ end
1237
+ class Concurrent::TVar < Concurrent::Synchronization::Object
1238
+ def initialize(value); end
1239
+ def self.new(*args, &block); end
1240
+ def unsafe_increment_version; end
1241
+ def unsafe_lock; end
1242
+ def unsafe_value; end
1243
+ def unsafe_value=(value); end
1244
+ def unsafe_version; end
1245
+ def value; end
1246
+ def value=(value); end
1247
+ end
1248
+ class Concurrent::Transaction
1249
+ def abort; end
1250
+ def commit; end
1251
+ def initialize; end
1252
+ def read(tvar); end
1253
+ def self.current; end
1254
+ def self.current=(transaction); end
1255
+ def unlock; end
1256
+ def valid?; end
1257
+ def write(tvar, value); end
1258
+ end
1259
+ class Concurrent::Transaction::ReadLogEntry < Struct
1260
+ def self.[](*arg0); end
1261
+ def self.inspect; end
1262
+ def self.members; end
1263
+ def self.new(*arg0); end
1264
+ def tvar; end
1265
+ def tvar=(_); end
1266
+ def version; end
1267
+ def version=(_); end
1268
+ end
1269
+ class Concurrent::Transaction::AbortError < StandardError
1270
+ end
1271
+ class Concurrent::Transaction::LeaveError < StandardError
1272
+ end
1273
+ class Concurrent::LockFreeStack < Concurrent::Synchronization::Object
1274
+ def __initialize_atomic_fields__; end
1275
+ def clear; end
1276
+ def clear_each(&block); end
1277
+ def clear_if(head); end
1278
+ def compare_and_clear(head); end
1279
+ def compare_and_pop(head); end
1280
+ def compare_and_push(head, value); end
1281
+ def compare_and_set_head(expected, value); end
1282
+ def each(head = nil); end
1283
+ def empty?(head = nil); end
1284
+ def head; end
1285
+ def head=(value); end
1286
+ def initialize(head = nil); end
1287
+ def inspect; end
1288
+ def peek; end
1289
+ def pop; end
1290
+ def push(value); end
1291
+ def replace_if(head, new_head); end
1292
+ def self.new(*args, &block); end
1293
+ def self.of1(value); end
1294
+ def self.of2(value1, value2); end
1295
+ def swap_head(value); end
1296
+ def to_s; end
1297
+ def update_head(&block); end
1298
+ include Enumerable
1299
+ end
1300
+ class Concurrent::LockFreeStack::Node
1301
+ def initialize(value, next_node); end
1302
+ def next_node; end
1303
+ def self.[](*arg0); end
1304
+ def value; end
1305
+ def value=(arg0); end
1306
+ end
1307
+ module Concurrent::ReInclude
1308
+ def extended(base); end
1309
+ def include(*modules); end
1310
+ def included(base); end
1311
+ end
1312
+ module Concurrent::Promises
1313
+ extend Concurrent::Promises::FactoryMethods
1314
+ end
1315
+ module Concurrent::Promises::FactoryMethods
1316
+ def any(*futures_and_or_events); end
1317
+ def any_event(*futures_and_or_events); end
1318
+ def any_event_on(default_executor, *futures_and_or_events); end
1319
+ def any_fulfilled_future(*futures_and_or_events); end
1320
+ def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
1321
+ def any_resolved_future(*futures_and_or_events); end
1322
+ def any_resolved_future_on(default_executor, *futures_and_or_events); end
1323
+ def delay(*args, &task); end
1324
+ def delay_on(default_executor, *args, &task); end
1325
+ def fulfilled_future(value, default_executor = nil); end
1326
+ def future(*args, &task); end
1327
+ def future_on(default_executor, *args, &task); end
1328
+ def make_future(argument = nil, default_executor = nil); end
1329
+ def rejected_future(reason, default_executor = nil); end
1330
+ def resolvable_event; end
1331
+ def resolvable_event_on(default_executor = nil); end
1332
+ def resolvable_future; end
1333
+ def resolvable_future_on(default_executor = nil); end
1334
+ def resolved_event(default_executor = nil); end
1335
+ def resolved_future(fulfilled, value, reason, default_executor = nil); end
1336
+ def schedule(intended_time, *args, &task); end
1337
+ def schedule_on(default_executor, intended_time, *args, &task); end
1338
+ def zip(*futures_and_or_events); end
1339
+ def zip_events(*futures_and_or_events); end
1340
+ def zip_events_on(default_executor, *futures_and_or_events); end
1341
+ def zip_futures(*futures_and_or_events); end
1342
+ def zip_futures_on(default_executor, *futures_and_or_events); end
1343
+ extend Concurrent::Promises::FactoryMethods
1344
+ extend Concurrent::Promises::FactoryMethods::Configuration
1345
+ extend Concurrent::ReInclude
1346
+ include Concurrent::Promises::FactoryMethods::Configuration
1347
+ end
1348
+ module Concurrent::Promises::FactoryMethods::Configuration
1349
+ def default_executor; end
1350
+ end
1351
+ module Concurrent::Promises::InternalStates
1352
+ end
1353
+ class Concurrent::Promises::InternalStates::State
1354
+ def resolved?; end
1355
+ def to_sym; end
1356
+ end
1357
+ class Concurrent::Promises::InternalStates::Pending < Concurrent::Promises::InternalStates::State
1358
+ def resolved?; end
1359
+ def to_sym; end
1360
+ end
1361
+ class Concurrent::Promises::InternalStates::Reserved < Concurrent::Promises::InternalStates::Pending
1362
+ end
1363
+ class Concurrent::Promises::InternalStates::ResolvedWithResult < Concurrent::Promises::InternalStates::State
1364
+ def apply; end
1365
+ def fulfilled?; end
1366
+ def reason; end
1367
+ def resolved?; end
1368
+ def result; end
1369
+ def to_sym; end
1370
+ def value; end
1371
+ end
1372
+ class Concurrent::Promises::InternalStates::Fulfilled < Concurrent::Promises::InternalStates::ResolvedWithResult
1373
+ def apply(args, block); end
1374
+ def fulfilled?; end
1375
+ def initialize(value); end
1376
+ def reason; end
1377
+ def to_sym; end
1378
+ def value; end
1379
+ end
1380
+ class Concurrent::Promises::InternalStates::FulfilledArray < Concurrent::Promises::InternalStates::Fulfilled
1381
+ def apply(args, block); end
1382
+ end
1383
+ class Concurrent::Promises::InternalStates::Rejected < Concurrent::Promises::InternalStates::ResolvedWithResult
1384
+ def apply(args, block); end
1385
+ def fulfilled?; end
1386
+ def initialize(reason); end
1387
+ def reason; end
1388
+ def to_sym; end
1389
+ def value; end
1390
+ end
1391
+ class Concurrent::Promises::InternalStates::PartiallyRejected < Concurrent::Promises::InternalStates::ResolvedWithResult
1392
+ def apply(args, block); end
1393
+ def fulfilled?; end
1394
+ def initialize(value, reason); end
1395
+ def reason; end
1396
+ def to_sym; end
1397
+ def value; end
1398
+ end
1399
+ class Concurrent::Promises::AbstractEventFuture < Concurrent::Synchronization::Object
1400
+ def __initialize_atomic_fields__; end
1401
+ def add_callback(method, *args); end
1402
+ def add_callback_clear_delayed_node(node); end
1403
+ def add_callback_notify_blocked(promise, index); end
1404
+ def async_callback_on_resolution(state, executor, args, callback); end
1405
+ def blocks; end
1406
+ def call_callback(method, state, args); end
1407
+ def call_callbacks(state); end
1408
+ def callback_clear_delayed_node(state, node); end
1409
+ def callback_notify_blocked(state, promise, index); end
1410
+ def callbacks; end
1411
+ def chain(*args, &task); end
1412
+ def chain_on(executor, *args, &task); end
1413
+ def chain_resolvable(resolvable); end
1414
+ def compare_and_set_internal_state(expected, value); end
1415
+ def default_executor; end
1416
+ def initialize(promise, default_executor); end
1417
+ def inspect; end
1418
+ def internal_state; end
1419
+ def internal_state=(value); end
1420
+ def on_resolution!(*args, &callback); end
1421
+ def on_resolution(*args, &callback); end
1422
+ def on_resolution_using(executor, *args, &callback); end
1423
+ def pending?; end
1424
+ def promise; end
1425
+ def resolve_with(state, raise_on_reassign = nil, reserved = nil); end
1426
+ def resolved?; end
1427
+ def self.new(*args, &block); end
1428
+ def state; end
1429
+ def swap_internal_state(value); end
1430
+ def tangle(resolvable); end
1431
+ def to_s; end
1432
+ def touch; end
1433
+ def touched?; end
1434
+ def update_internal_state(&block); end
1435
+ def wait(timeout = nil); end
1436
+ def wait_until_resolved(timeout); end
1437
+ def waiting_threads; end
1438
+ def with_async(executor, *args, &block); end
1439
+ def with_default_executor(executor); end
1440
+ def with_hidden_resolvable; end
1441
+ include Concurrent::Promises::InternalStates
1442
+ end
1443
+ class Concurrent::Promises::Event < Concurrent::Promises::AbstractEventFuture
1444
+ def &(other); end
1445
+ def any(event_or_future); end
1446
+ def callback_on_resolution(state, args, callback); end
1447
+ def delay; end
1448
+ def rejected_resolution(raise_on_reassign, state); end
1449
+ def schedule(intended_time); end
1450
+ def then(*args, &task); end
1451
+ def to_event; end
1452
+ def to_future; end
1453
+ def with_default_executor(executor); end
1454
+ def zip(other); end
1455
+ def |(event_or_future); end
1456
+ end
1457
+ class Concurrent::Promises::Future < Concurrent::Promises::AbstractEventFuture
1458
+ def &(other); end
1459
+ def any(event_or_future); end
1460
+ def apply(args, block); end
1461
+ def async_callback_on_fulfillment(state, executor, args, callback); end
1462
+ def async_callback_on_rejection(state, executor, args, callback); end
1463
+ def callback_on_fulfillment(state, args, callback); end
1464
+ def callback_on_rejection(state, args, callback); end
1465
+ def callback_on_resolution(state, args, callback); end
1466
+ def delay; end
1467
+ def exception(*args); end
1468
+ def flat(level = nil); end
1469
+ def flat_event; end
1470
+ def flat_future(level = nil); end
1471
+ def fulfilled?; end
1472
+ def inspect; end
1473
+ def on_fulfillment!(*args, &callback); end
1474
+ def on_fulfillment(*args, &callback); end
1475
+ def on_fulfillment_using(executor, *args, &callback); end
1476
+ def on_rejection!(*args, &callback); end
1477
+ def on_rejection(*args, &callback); end
1478
+ def on_rejection_using(executor, *args, &callback); end
1479
+ def reason(timeout = nil, timeout_value = nil); end
1480
+ def rejected?; end
1481
+ def rejected_resolution(raise_on_reassign, state); end
1482
+ def rescue(*args, &task); end
1483
+ def rescue_on(executor, *args, &task); end
1484
+ def result(timeout = nil); end
1485
+ def run(run_test = nil); end
1486
+ def run_test(v); end
1487
+ def schedule(intended_time); end
1488
+ def then(*args, &task); end
1489
+ def then_on(executor, *args, &task); end
1490
+ def to_event; end
1491
+ def to_future; end
1492
+ def to_s; end
1493
+ def value!(timeout = nil, timeout_value = nil); end
1494
+ def value(timeout = nil, timeout_value = nil); end
1495
+ def wait!(timeout = nil); end
1496
+ def wait_until_resolved!(timeout = nil); end
1497
+ def with_default_executor(executor); end
1498
+ def zip(other); end
1499
+ def |(event_or_future); end
1500
+ end
1501
+ module Concurrent::Promises::Resolvable
1502
+ include Concurrent::Promises::InternalStates
1503
+ end
1504
+ class Concurrent::Promises::ResolvableEvent < Concurrent::Promises::Event
1505
+ def resolve(raise_on_reassign = nil, reserved = nil); end
1506
+ def wait(timeout = nil, resolve_on_timeout = nil); end
1507
+ def with_hidden_resolvable; end
1508
+ include Concurrent::Promises::Resolvable
1509
+ end
1510
+ class Concurrent::Promises::ResolvableFuture < Concurrent::Promises::Future
1511
+ def evaluate_to!(*args, &block); end
1512
+ def evaluate_to(*args, &block); end
1513
+ def fulfill(value, raise_on_reassign = nil, reserved = nil); end
1514
+ def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1515
+ def reject(reason, raise_on_reassign = nil, reserved = nil); end
1516
+ def resolve(fulfilled = nil, value = nil, reason = nil, raise_on_reassign = nil, reserved = nil); end
1517
+ def result(timeout = nil, resolve_on_timeout = nil); end
1518
+ def value!(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1519
+ def value(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1520
+ def wait!(timeout = nil, resolve_on_timeout = nil); end
1521
+ def wait(timeout = nil, resolve_on_timeout = nil); end
1522
+ def with_hidden_resolvable; end
1523
+ include Concurrent::Promises::Resolvable
1524
+ end
1525
+ class Concurrent::Promises::AbstractPromise < Concurrent::Synchronization::Object
1526
+ def default_executor; end
1527
+ def delayed_because; end
1528
+ def evaluate_to(*args, block); end
1529
+ def event; end
1530
+ def future; end
1531
+ def initialize(future); end
1532
+ def inspect; end
1533
+ def resolve_with(new_state, raise_on_reassign = nil); end
1534
+ def self.new(*args, &block); end
1535
+ def state; end
1536
+ def to_s; end
1537
+ def touch; end
1538
+ include Concurrent::Promises::InternalStates
1539
+ end
1540
+ class Concurrent::Promises::ResolvableEventPromise < Concurrent::Promises::AbstractPromise
1541
+ def initialize(default_executor); end
1542
+ end
1543
+ class Concurrent::Promises::ResolvableFuturePromise < Concurrent::Promises::AbstractPromise
1544
+ def evaluate_to(*args, block); end
1545
+ def initialize(default_executor); end
1546
+ end
1547
+ class Concurrent::Promises::InnerPromise < Concurrent::Promises::AbstractPromise
1548
+ end
1549
+ class Concurrent::Promises::BlockedPromise < Concurrent::Promises::InnerPromise
1550
+ def blocked_by; end
1551
+ def clear_and_propagate_touch(stack_or_element = nil); end
1552
+ def delayed_because; end
1553
+ def initialize(delayed, blockers_count, future); end
1554
+ def on_blocker_resolution(future, index); end
1555
+ def on_resolvable(resolved_future, index); end
1556
+ def process_on_blocker_resolution(future, index); end
1557
+ def resolvable?(countdown, future, index); end
1558
+ def self.add_delayed(delayed1, delayed2); end
1559
+ def self.new(*args, &block); end
1560
+ def self.new_blocked_by(blockers, *args, &block); end
1561
+ def self.new_blocked_by1(blocker, *args, &block); end
1562
+ def self.new_blocked_by2(blocker1, blocker2, *args, &block); end
1563
+ def touch; end
1564
+ end
1565
+ class Concurrent::Promises::BlockedTaskPromise < Concurrent::Promises::BlockedPromise
1566
+ def executor; end
1567
+ def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1568
+ end
1569
+ class Concurrent::Promises::ThenPromise < Concurrent::Promises::BlockedTaskPromise
1570
+ def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1571
+ def on_resolvable(resolved_future, index); end
1572
+ end
1573
+ class Concurrent::Promises::RescuePromise < Concurrent::Promises::BlockedTaskPromise
1574
+ def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1575
+ def on_resolvable(resolved_future, index); end
1576
+ end
1577
+ class Concurrent::Promises::ChainPromise < Concurrent::Promises::BlockedTaskPromise
1578
+ def on_resolvable(resolved_future, index); end
1579
+ end
1580
+ class Concurrent::Promises::ImmediateEventPromise < Concurrent::Promises::InnerPromise
1581
+ def initialize(default_executor); end
1582
+ end
1583
+ class Concurrent::Promises::ImmediateFuturePromise < Concurrent::Promises::InnerPromise
1584
+ def initialize(default_executor, fulfilled, value, reason); end
1585
+ end
1586
+ class Concurrent::Promises::AbstractFlatPromise < Concurrent::Promises::BlockedPromise
1587
+ def add_delayed_of(future); end
1588
+ def initialize(delayed_because, blockers_count, event_or_future); end
1589
+ def on_resolvable(resolved_future, index); end
1590
+ def resolvable?(countdown, future, index); end
1591
+ def touch; end
1592
+ def touched?; end
1593
+ end
1594
+ class Concurrent::Promises::FlatEventPromise < Concurrent::Promises::AbstractFlatPromise
1595
+ def initialize(delayed, blockers_count, default_executor); end
1596
+ def process_on_blocker_resolution(future, index); end
1597
+ end
1598
+ class Concurrent::Promises::FlatFuturePromise < Concurrent::Promises::AbstractFlatPromise
1599
+ def initialize(delayed, blockers_count, levels, default_executor); end
1600
+ def process_on_blocker_resolution(future, index); end
1601
+ end
1602
+ class Concurrent::Promises::RunFuturePromise < Concurrent::Promises::AbstractFlatPromise
1603
+ def initialize(delayed, blockers_count, default_executor, run_test); end
1604
+ def process_on_blocker_resolution(future, index); end
1605
+ end
1606
+ class Concurrent::Promises::ZipEventEventPromise < Concurrent::Promises::BlockedPromise
1607
+ def initialize(delayed, blockers_count, default_executor); end
1608
+ def on_resolvable(resolved_future, index); end
1609
+ end
1610
+ class Concurrent::Promises::ZipFutureEventPromise < Concurrent::Promises::BlockedPromise
1611
+ def initialize(delayed, blockers_count, default_executor); end
1612
+ def on_resolvable(resolved_future, index); end
1613
+ def process_on_blocker_resolution(future, index); end
1614
+ end
1615
+ class Concurrent::Promises::EventWrapperPromise < Concurrent::Promises::BlockedPromise
1616
+ def initialize(delayed, blockers_count, default_executor); end
1617
+ def on_resolvable(resolved_future, index); end
1618
+ end
1619
+ class Concurrent::Promises::FutureWrapperPromise < Concurrent::Promises::BlockedPromise
1620
+ def initialize(delayed, blockers_count, default_executor); end
1621
+ def on_resolvable(resolved_future, index); end
1622
+ end
1623
+ class Concurrent::Promises::ZipFuturesPromise < Concurrent::Promises::BlockedPromise
1624
+ def initialize(delayed, blockers_count, default_executor); end
1625
+ def on_resolvable(resolved_future, index); end
1626
+ def process_on_blocker_resolution(future, index); end
1627
+ end
1628
+ class Concurrent::Promises::ZipEventsPromise < Concurrent::Promises::BlockedPromise
1629
+ def initialize(delayed, blockers_count, default_executor); end
1630
+ def on_resolvable(resolved_future, index); end
1631
+ end
1632
+ class Concurrent::Promises::AbstractAnyPromise < Concurrent::Promises::BlockedPromise
1633
+ end
1634
+ class Concurrent::Promises::AnyResolvedEventPromise < Concurrent::Promises::AbstractAnyPromise
1635
+ def initialize(delayed, blockers_count, default_executor); end
1636
+ def on_resolvable(resolved_future, index); end
1637
+ def resolvable?(countdown, future, index); end
1638
+ end
1639
+ class Concurrent::Promises::AnyResolvedFuturePromise < Concurrent::Promises::AbstractAnyPromise
1640
+ def initialize(delayed, blockers_count, default_executor); end
1641
+ def on_resolvable(resolved_future, index); end
1642
+ def resolvable?(countdown, future, index); end
1643
+ end
1644
+ class Concurrent::Promises::AnyFulfilledFuturePromise < Concurrent::Promises::AnyResolvedFuturePromise
1645
+ def resolvable?(countdown, future, index); end
1646
+ end
1647
+ class Concurrent::Promises::DelayPromise < Concurrent::Promises::InnerPromise
1648
+ def delayed_because; end
1649
+ def initialize(default_executor); end
1650
+ def touch; end
1651
+ end
1652
+ class Concurrent::Promises::ScheduledPromise < Concurrent::Promises::InnerPromise
1653
+ def initialize(default_executor, intended_time); end
1654
+ def inspect; end
1655
+ def intended_time; end
1656
+ end
1657
+ class Concurrent::SynchronizedDelegator < SimpleDelegator
1658
+ def initialize(obj); end
1659
+ def method_missing(method, *args, &block); end
1660
+ def setup; end
1661
+ def teardown; end
1662
+ end