non_empty_array 1.0.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,1123 @@
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/rspec-expectations/all/rspec-expectations.rbi
9
+ #
10
+ # rspec-expectations-3.9.2
11
+
12
+ module RSpec
13
+ end
14
+ module RSpec::Matchers
15
+ def a_block_changing(*args, &block); end
16
+ def a_block_outputting(*args, &block); end
17
+ def a_block_raising(*args, &block); end
18
+ def a_block_throwing(*args, &block); end
19
+ def a_block_yielding_control(*args, &block); end
20
+ def a_block_yielding_successive_args(*args, &block); end
21
+ def a_block_yielding_with_args(*args, &block); end
22
+ def a_block_yielding_with_no_args(*args, &block); end
23
+ def a_collection_containing_exactly(*args, &block); end
24
+ def a_collection_ending_with(*args, &block); end
25
+ def a_collection_including(*args, &block); end
26
+ def a_collection_starting_with(*args, &block); end
27
+ def a_falsey_value(*args, &block); end
28
+ def a_falsy_value(*args, &block); end
29
+ def a_hash_including(*args, &block); end
30
+ def a_kind_of(*args, &block); end
31
+ def a_nil_value(*args, &block); end
32
+ def a_range_covering(*args, &block); end
33
+ def a_string_ending_with(*args, &block); end
34
+ def a_string_including(*args, &block); end
35
+ def a_string_matching(*args, &block); end
36
+ def a_string_starting_with(*args, &block); end
37
+ def a_truthy_value(*args, &block); end
38
+ def a_value(*args, &block); end
39
+ def a_value_between(*args, &block); end
40
+ def a_value_within(*args, &block); end
41
+ def aggregate_failures(label = nil, metadata = nil, &block); end
42
+ def all(expected); end
43
+ def an_instance_of(*args, &block); end
44
+ def an_object_eq_to(*args, &block); end
45
+ def an_object_eql_to(*args, &block); end
46
+ def an_object_equal_to(*args, &block); end
47
+ def an_object_existing(*args, &block); end
48
+ def an_object_having_attributes(*args, &block); end
49
+ def an_object_matching(*args, &block); end
50
+ def an_object_responding_to(*args, &block); end
51
+ def an_object_satisfying(*args, &block); end
52
+ def be(*args); end
53
+ def be_a(klass); end
54
+ def be_a_kind_of(expected); end
55
+ def be_an(klass); end
56
+ def be_an_instance_of(expected); end
57
+ def be_between(min, max); end
58
+ def be_falsey; end
59
+ def be_falsy(*args, &block); end
60
+ def be_instance_of(expected); end
61
+ def be_kind_of(expected); end
62
+ def be_nil; end
63
+ def be_truthy; end
64
+ def be_within(delta); end
65
+ def change(receiver = nil, message = nil, &block); end
66
+ def changing(*args, &block); end
67
+ def contain_exactly(*items); end
68
+ def containing_exactly(*args, &block); end
69
+ def cover(*values); end
70
+ def covering(*args, &block); end
71
+ def end_with(*expected); end
72
+ def ending_with(*args, &block); end
73
+ def eq(expected); end
74
+ def eq_to(*args, &block); end
75
+ def eql(expected); end
76
+ def eql_to(*args, &block); end
77
+ def equal(expected); end
78
+ def equal_to(*args, &block); end
79
+ def exist(*args); end
80
+ def existing(*args, &block); end
81
+ def expect(value = nil, &block); end
82
+ def have_attributes(expected); end
83
+ def having_attributes(*args, &block); end
84
+ def include(*expected); end
85
+ def including(*args, &block); end
86
+ def match(expected); end
87
+ def match_array(items); end
88
+ def match_regex(*args, &block); end
89
+ def matching(*args, &block); end
90
+ def method_missing(method, *args, &block); end
91
+ def output(expected = nil); end
92
+ def raise_error(error = nil, message = nil, &block); end
93
+ def raise_exception(error = nil, message = nil, &block); end
94
+ def raising(*args, &block); end
95
+ def respond_to(*names); end
96
+ def respond_to_missing?(method, *arg1); end
97
+ def responding_to(*args, &block); end
98
+ def satisfy(description = nil, &block); end
99
+ def satisfying(*args, &block); end
100
+ def self.alias_matcher(*args, &block); end
101
+ def self.clear_generated_description; end
102
+ def self.configuration; end
103
+ def self.generated_description; end
104
+ def self.is_a_describable_matcher?(obj); end
105
+ def self.is_a_matcher?(obj); end
106
+ def self.last_description; end
107
+ def self.last_expectation_handler; end
108
+ def self.last_expectation_handler=(arg0); end
109
+ def self.last_matcher; end
110
+ def self.last_matcher=(arg0); end
111
+ def start_with(*expected); end
112
+ def starting_with(*args, &block); end
113
+ def throw_symbol(expected_symbol = nil, expected_arg = nil); end
114
+ def throwing(*args, &block); end
115
+ def within(*args, &block); end
116
+ def yield_control; end
117
+ def yield_successive_args(*args); end
118
+ def yield_with_args(*args); end
119
+ def yield_with_no_args; end
120
+ def yielding_control(*args, &block); end
121
+ def yielding_successive_args(*args, &block); end
122
+ def yielding_with_args(*args, &block); end
123
+ def yielding_with_no_args(*args, &block); end
124
+ extend RSpec::Matchers::DSL
125
+ end
126
+ module RSpec::Matchers::EnglishPhrasing
127
+ def self.list(obj); end
128
+ def self.split_words(sym); end
129
+ end
130
+ module RSpec::Matchers::Composable
131
+ def &(matcher); end
132
+ def ===(value); end
133
+ def and(matcher); end
134
+ def description_of(object); end
135
+ def or(matcher); end
136
+ def self.should_enumerate?(item); end
137
+ def self.surface_descriptions_in(item); end
138
+ def self.unreadable_io?(object); end
139
+ def should_enumerate?(item); end
140
+ def surface_descriptions_in(item); end
141
+ def unreadable_io?(object); end
142
+ def values_match?(expected, actual); end
143
+ def with_matchers_cloned(object); end
144
+ def |(matcher); end
145
+ end
146
+ class RSpec::Matchers::Composable::DescribableItem < Struct
147
+ def inspect; end
148
+ def item; end
149
+ def item=(_); end
150
+ def pretty_print(pp); end
151
+ def self.[](*arg0); end
152
+ def self.inspect; end
153
+ def self.members; end
154
+ def self.new(*arg0); end
155
+ end
156
+ module RSpec::Matchers::BuiltIn
157
+ end
158
+ class RSpec::Matchers::BuiltIn::BaseMatcher
159
+ def actual; end
160
+ def actual_formatted; end
161
+ def assert_ivars(*expected_ivars); end
162
+ def description; end
163
+ def diffable?; end
164
+ def expected; end
165
+ def expected_formatted; end
166
+ def expects_call_stack_jump?; end
167
+ def initialize(expected = nil); end
168
+ def match_unless_raises(*exceptions); end
169
+ def matcher_name; end
170
+ def matcher_name=(arg0); end
171
+ def matches?(actual); end
172
+ def present_ivars; end
173
+ def rescued_exception; end
174
+ def self.matcher_name; end
175
+ def self.underscore(camel_cased_word); end
176
+ def supports_block_expectations?; end
177
+ include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
178
+ include RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
179
+ include RSpec::Matchers::Composable
180
+ end
181
+ module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
182
+ def improve_hash_formatting(inspect_string); end
183
+ def self.improve_hash_formatting(inspect_string); end
184
+ end
185
+ module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
186
+ def failure_message; end
187
+ def failure_message_when_negated; end
188
+ def self.has_default_failure_messages?(matcher); end
189
+ end
190
+ module RSpec::Matchers::DSL
191
+ def alias_matcher(new_name, old_name, options = nil, &description_override); end
192
+ def define(name, &declarations); end
193
+ def define_negated_matcher(negated_name, base_name, &description_override); end
194
+ def matcher(name, &declarations); end
195
+ def warn_about_block_args(name, declarations); end
196
+ end
197
+ module RSpec::Matchers::DSL::Macros
198
+ def assign_attributes(attr_names); end
199
+ def chain(method_name, *attr_names, &definition); end
200
+ def define_user_override(method_name, user_def, &our_def); end
201
+ def description(&definition); end
202
+ def diffable; end
203
+ def failure_message(&definition); end
204
+ def failure_message_when_negated(&definition); end
205
+ def match(options = nil, &match_block); end
206
+ def match_unless_raises(expected_exception = nil, &match_block); end
207
+ def match_when_negated(options = nil, &match_block); end
208
+ def supports_block_expectations; end
209
+ end
210
+ module RSpec::Matchers::DSL::Macros::Deprecated
211
+ def failure_message_for_should(&definition); end
212
+ def failure_message_for_should_not(&definition); end
213
+ def match_for_should(&definition); end
214
+ def match_for_should_not(&definition); end
215
+ end
216
+ module RSpec::Matchers::DSL::DefaultImplementations
217
+ def chained_method_clause_sentences; end
218
+ def description; end
219
+ def diffable?; end
220
+ def expects_call_stack_jump?; end
221
+ def supports_block_expectations?; end
222
+ include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
223
+ end
224
+ class RSpec::Matchers::DSL::Matcher
225
+ def actual; end
226
+ def actual_arg_for(block); end
227
+ def block_arg; end
228
+ def expected; end
229
+ def expected_as_array; end
230
+ def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
231
+ def inspect; end
232
+ def method_missing(method, *args, &block); end
233
+ def name; end
234
+ def rescued_exception; end
235
+ def respond_to_missing?(method, include_private = nil); end
236
+ extend RSpec::Matchers::DSL::Macros
237
+ extend RSpec::Matchers::DSL::Macros::Deprecated
238
+ include RSpec::Matchers
239
+ include RSpec::Matchers::Composable
240
+ include RSpec::Matchers::DSL::DefaultImplementations
241
+ end
242
+ class RSpec::Matchers::MatcherDelegator
243
+ def base_matcher; end
244
+ def initialize(base_matcher); end
245
+ def initialize_copy(other); end
246
+ def method_missing(*args, &block); end
247
+ def respond_to_missing?(name, include_all = nil); end
248
+ include RSpec::Matchers::Composable
249
+ end
250
+ class RSpec::Matchers::AliasedMatcher < RSpec::Matchers::MatcherDelegator
251
+ def description; end
252
+ def failure_message; end
253
+ def failure_message_when_negated; end
254
+ def initialize(base_matcher, description_block); end
255
+ def method_missing(*arg0); end
256
+ end
257
+ class RSpec::Matchers::AliasedMatcherWithOperatorSupport < RSpec::Matchers::AliasedMatcher
258
+ end
259
+ class RSpec::Matchers::AliasedNegatedMatcher < RSpec::Matchers::AliasedMatcher
260
+ def does_not_match?(*args, &block); end
261
+ def failure_message; end
262
+ def failure_message_when_negated; end
263
+ def matches?(*args, &block); end
264
+ def optimal_failure_message(same, inverted); end
265
+ end
266
+ class RSpec::Matchers::ExpectedsForMultipleDiffs
267
+ def diffs(differ, actual); end
268
+ def initialize(expected_list); end
269
+ def message_with_diff(message, differ, actual); end
270
+ def self.diff_label_for(matcher); end
271
+ def self.for_many_matchers(matchers); end
272
+ def self.from(expected); end
273
+ def self.truncated(description); end
274
+ end
275
+ module RSpec::Support
276
+ def self.require_rspec_expectations(f); end
277
+ def self.require_rspec_matchers(f); end
278
+ end
279
+ module RSpec::Expectations
280
+ def self.configuration; end
281
+ def self.differ; end
282
+ def self.fail_with(message, expected = nil, actual = nil); end
283
+ end
284
+ class RSpec::Expectations::ExpectationTarget
285
+ def initialize(value); end
286
+ def self.for(value, block); end
287
+ def target; end
288
+ include RSpec::Expectations::ExpectationTarget::InstanceMethods
289
+ end
290
+ module RSpec::Expectations::ExpectationTarget::UndefinedValue
291
+ end
292
+ module RSpec::Expectations::ExpectationTarget::InstanceMethods
293
+ def not_to(matcher = nil, message = nil, &block); end
294
+ def prevent_operator_matchers(verb); end
295
+ def to(matcher = nil, message = nil, &block); end
296
+ def to_not(matcher = nil, message = nil, &block); end
297
+ end
298
+ class RSpec::Expectations::BlockExpectationTarget < RSpec::Expectations::ExpectationTarget
299
+ def enforce_block_expectation(matcher); end
300
+ def not_to(matcher, message = nil, &block); end
301
+ def supports_block_expectations?(matcher); end
302
+ def to(matcher, message = nil, &block); end
303
+ def to_not(matcher, message = nil, &block); end
304
+ end
305
+ module RSpec::Expectations::Syntax
306
+ def default_should_host; end
307
+ def disable_expect(syntax_host = nil); end
308
+ def disable_should(syntax_host = nil); end
309
+ def enable_expect(syntax_host = nil); end
310
+ def enable_should(syntax_host = nil); end
311
+ def expect_enabled?(syntax_host = nil); end
312
+ def self.default_should_host; end
313
+ def self.disable_expect(syntax_host = nil); end
314
+ def self.disable_should(syntax_host = nil); end
315
+ def self.enable_expect(syntax_host = nil); end
316
+ def self.enable_should(syntax_host = nil); end
317
+ def self.expect_enabled?(syntax_host = nil); end
318
+ def self.should_enabled?(syntax_host = nil); end
319
+ def self.warn_about_should!; end
320
+ def self.warn_about_should_unless_configured(method_name); end
321
+ def should_enabled?(syntax_host = nil); end
322
+ def warn_about_should!; end
323
+ def warn_about_should_unless_configured(method_name); end
324
+ end
325
+ class BasicObject
326
+ end
327
+ class RSpec::Expectations::Configuration
328
+ def add_should_and_should_not_to(*modules); end
329
+ def backtrace_formatter; end
330
+ def backtrace_formatter=(arg0); end
331
+ def color?; end
332
+ def false_positives_handler; end
333
+ def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end
334
+ def include_chain_clauses_in_custom_matcher_descriptions?; end
335
+ def initialize; end
336
+ def max_formatted_output_length=(length); end
337
+ def on_potential_false_positives; end
338
+ def on_potential_false_positives=(behavior); end
339
+ def reset_syntaxes_to_default; end
340
+ def syntax; end
341
+ def syntax=(values); end
342
+ def warn_about_potential_false_positives=(boolean); end
343
+ def warn_about_potential_false_positives?; end
344
+ end
345
+ module RSpec::Expectations::Configuration::NullBacktraceFormatter
346
+ def self.format_backtrace(backtrace); end
347
+ end
348
+ class InvalidName___Class_0x00___Differ_1
349
+ end
350
+ module RSpec::Expectations::ExpectationHelper
351
+ def self.check_message(msg); end
352
+ def self.handle_failure(matcher, message, failure_message_method); end
353
+ def self.modern_matcher_from(matcher); end
354
+ def self.with_matcher(handler, matcher, message); end
355
+ end
356
+ class RSpec::Expectations::PositiveExpectationHandler
357
+ def self.handle_matcher(actual, initial_matcher, message = nil, &block); end
358
+ def self.opposite_should_method; end
359
+ def self.should_method; end
360
+ def self.verb; end
361
+ end
362
+ class RSpec::Expectations::NegativeExpectationHandler
363
+ def self.does_not_match?(matcher, actual, &block); end
364
+ def self.handle_matcher(actual, initial_matcher, message = nil, &block); end
365
+ def self.opposite_should_method; end
366
+ def self.should_method; end
367
+ def self.verb; end
368
+ end
369
+ class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator
370
+ def initialize(matcher); end
371
+ def self.wrap(matcher); end
372
+ end
373
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter
374
+ def failure_message; end
375
+ def failure_message_when_negated; end
376
+ def self.interface_matches?(matcher); end
377
+ end
378
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter
379
+ def failure_message; end
380
+ def failure_message_when_negated; end
381
+ def self.interface_matches?(matcher); end
382
+ end
383
+ module RSpec::Expectations::Version
384
+ end
385
+ class RSpec::Expectations::ExpectationNotMetError < Exception
386
+ end
387
+ class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError
388
+ def aggregation_block_label; end
389
+ def aggregation_metadata; end
390
+ def all_exceptions; end
391
+ def block_description; end
392
+ def enumerated(exceptions, index_offset); end
393
+ def enumerated_errors; end
394
+ def enumerated_failures; end
395
+ def exception_count_description; end
396
+ def failures; end
397
+ def indentation; end
398
+ def indented(failure_message, index); end
399
+ def index_label(index); end
400
+ def initialize(failure_aggregator); end
401
+ def longest_index_label_width; end
402
+ def message; end
403
+ def other_errors; end
404
+ def pluralize(noun, count); end
405
+ def summary; end
406
+ def width_of_label(index); end
407
+ end
408
+ class RSpec::Expectations::BlockSnippetExtractor
409
+ def beginning_line_number; end
410
+ def block_token_extractor; end
411
+ def body_content_lines; end
412
+ def file_path; end
413
+ def initialize(proc, method_name); end
414
+ def method_name; end
415
+ def proc; end
416
+ def raw_body_lines; end
417
+ def raw_body_snippet; end
418
+ def self.try_extracting_single_line_body_of(proc, method_name); end
419
+ def source; end
420
+ def source_location; end
421
+ end
422
+ class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError
423
+ end
424
+ class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error
425
+ end
426
+ class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error
427
+ end
428
+ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct
429
+ def after_beginning_of_args_state(token); end
430
+ def after_beginning_of_body_state(token); end
431
+ def after_method_call_state(token); end
432
+ def after_opener_state(token); end
433
+ def beginning_line_number; end
434
+ def beginning_line_number=(_); end
435
+ def block_locator; end
436
+ def body_tokens; end
437
+ def correct_block?(body_tokens); end
438
+ def finalize_pending_tokens!; end
439
+ def finish!; end
440
+ def finish_or_find_next_block_if_incorrect!; end
441
+ def handle_closer_token(token); end
442
+ def handle_opener_token(token); end
443
+ def initial_state(token); end
444
+ def initialize(*arg0); end
445
+ def invoke_state_handler(token); end
446
+ def method_name; end
447
+ def method_name=(_); end
448
+ def opener_token?(token); end
449
+ def opener_token_stack; end
450
+ def parse!; end
451
+ def pending_tokens; end
452
+ def pipe_token?(token); end
453
+ def self.[](*arg0); end
454
+ def self.inspect; end
455
+ def self.members; end
456
+ def self.new(*arg0); end
457
+ def source; end
458
+ def source=(_); end
459
+ def state; end
460
+ end
461
+ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct
462
+ def beginning_line_number; end
463
+ def beginning_line_number=(_); end
464
+ def block_body_node; end
465
+ def block_wrapper_node; end
466
+ def body_content_locations; end
467
+ def candidate_block_wrapper_nodes; end
468
+ def candidate_method_ident_nodes; end
469
+ def method_call_location; end
470
+ def method_ident_node; end
471
+ def method_ident_node?(node); end
472
+ def method_name; end
473
+ def method_name=(_); end
474
+ def self.[](*arg0); end
475
+ def self.inspect; end
476
+ def self.members; end
477
+ def self.new(*arg0); end
478
+ def source; end
479
+ def source=(_); end
480
+ end
481
+ class RSpec::Expectations::FailureAggregator
482
+ def aggregate; end
483
+ def assign_backtrace(failure); end
484
+ def block_label; end
485
+ def call(failure, options); end
486
+ def failures; end
487
+ def initialize(block_label, metadata); end
488
+ def metadata; end
489
+ def notify_aggregated_failures; end
490
+ def other_errors; end
491
+ end
492
+ class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher
493
+ def match(expected, actual); end
494
+ end
495
+ class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher
496
+ def description; end
497
+ def match(expected, actual); end
498
+ end
499
+ class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher
500
+ def comparable?; end
501
+ def compare; end
502
+ def description; end
503
+ def exclusive; end
504
+ def failure_message; end
505
+ def inclusive; end
506
+ def initialize(min, max); end
507
+ def matches?(actual); end
508
+ def not_comparable_clause; end
509
+ end
510
+ class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher
511
+ def failure_message; end
512
+ def failure_message_when_negated; end
513
+ def match(_, actual); end
514
+ end
515
+ class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher
516
+ def failure_message; end
517
+ def failure_message_when_negated; end
518
+ def match(_, actual); end
519
+ end
520
+ class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher
521
+ def failure_message; end
522
+ def failure_message_when_negated; end
523
+ def match(_, actual); end
524
+ end
525
+ module RSpec::Matchers::BuiltIn::BeHelpers
526
+ def args_to_s; end
527
+ def args_to_sentence; end
528
+ def expected_to_sentence; end
529
+ def inspected_args; end
530
+ def parenthesize(string); end
531
+ end
532
+ class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher
533
+ def <(operand); end
534
+ def <=(operand); end
535
+ def ==(operand); end
536
+ def ===(operand); end
537
+ def =~(operand); end
538
+ def >(operand); end
539
+ def >=(operand); end
540
+ def failure_message; end
541
+ def failure_message_when_negated; end
542
+ def initialize(*args); end
543
+ def match(_, actual); end
544
+ include RSpec::Matchers::BuiltIn::BeHelpers
545
+ end
546
+ class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher
547
+ def description; end
548
+ def failure_message; end
549
+ def failure_message_when_negated; end
550
+ def initialize(operand, operator); end
551
+ def matches?(actual); end
552
+ include RSpec::Matchers::BuiltIn::BeHelpers
553
+ end
554
+ class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::BaseMatcher
555
+ def description; end
556
+ def does_not_match?(actual, &block); end
557
+ def failure_message; end
558
+ def failure_message_expecting(value); end
559
+ def failure_message_when_negated; end
560
+ def initialize(*args, &block); end
561
+ def matches?(actual, &block); end
562
+ def parse_expected(expected); end
563
+ def predicate; end
564
+ def predicate_accessible?; end
565
+ def predicate_matches?; end
566
+ def prefix_and_expected(symbol); end
567
+ def prefix_to_sentence; end
568
+ def present_tense_predicate; end
569
+ def private_predicate?; end
570
+ def validity_message; end
571
+ include RSpec::Matchers::BuiltIn::BeHelpers
572
+ end
573
+ class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher
574
+ def description; end
575
+ def failure_message; end
576
+ def failure_message_when_negated; end
577
+ def initialize(delta); end
578
+ def matches?(actual); end
579
+ def needs_expected; end
580
+ def not_numeric_clause; end
581
+ def numeric?; end
582
+ def of(expected); end
583
+ def percent_of(expected); end
584
+ end
585
+ class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher
586
+ def by(expected_delta); end
587
+ def by_at_least(minimum); end
588
+ def by_at_most(maximum); end
589
+ def change_details; end
590
+ def description; end
591
+ def does_not_match?(event_proc); end
592
+ def failure_message; end
593
+ def failure_message_when_negated; end
594
+ def from(value); end
595
+ def initialize(receiver = nil, message = nil, &block); end
596
+ def matches?(event_proc); end
597
+ def negative_failure_reason; end
598
+ def perform_change(event_proc); end
599
+ def positive_failure_reason; end
600
+ def raise_block_syntax_error; end
601
+ def supports_block_expectations?; end
602
+ def to(value); end
603
+ end
604
+ class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher
605
+ def description; end
606
+ def does_not_match?(_event_proc); end
607
+ def failure_message; end
608
+ def failure_reason; end
609
+ def initialize(change_details, expected_delta, relativity, &comparer); end
610
+ def matches?(event_proc); end
611
+ def supports_block_expectations?; end
612
+ end
613
+ class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher
614
+ def after_value_failure; end
615
+ def before_value_failure; end
616
+ def description; end
617
+ def did_change_failure; end
618
+ def did_not_change_failure; end
619
+ def failure_message; end
620
+ def initialize(change_details, from, to); end
621
+ def matches?(event_proc); end
622
+ def matches_after?; end
623
+ def not_given_a_block_failure; end
624
+ def perform_change(event_proc); end
625
+ def supports_block_expectations?; end
626
+ end
627
+ class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
628
+ def change_description; end
629
+ def does_not_match?(event_proc); end
630
+ def failure_message_when_negated; end
631
+ def initialize(change_details, expected_before); end
632
+ def to(value); end
633
+ end
634
+ class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
635
+ def change_description; end
636
+ def does_not_match?(_event_proc); end
637
+ def from(value); end
638
+ def initialize(change_details, expected_after); end
639
+ end
640
+ class RSpec::Matchers::BuiltIn::ChangeDetails
641
+ def actual_after; end
642
+ def actual_delta; end
643
+ def changed?; end
644
+ def evaluate_value_proc; end
645
+ def extract_value_block_snippet; end
646
+ def initialize(matcher_name, receiver = nil, message = nil, &block); end
647
+ def message_notation(receiver, message); end
648
+ def perform_change(event_proc); end
649
+ def value_representation; end
650
+ end
651
+ class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher
652
+ def compound_failure_message; end
653
+ def description; end
654
+ def diffable?; end
655
+ def diffable_matcher_list; end
656
+ def diffable_matcher_list_for(matcher); end
657
+ def does_not_match?(_actual); end
658
+ def evaluator; end
659
+ def expected; end
660
+ def expects_call_stack_jump?; end
661
+ def indent_multiline_message(message); end
662
+ def initialize(matcher_1, matcher_2); end
663
+ def initialize_copy(other); end
664
+ def match(_expected, actual); end
665
+ def matcher_1; end
666
+ def matcher_1_matches?; end
667
+ def matcher_2; end
668
+ def matcher_2_matches?; end
669
+ def matcher_is_diffable?(matcher); end
670
+ def matcher_supports_block_expectations?(matcher); end
671
+ def supports_block_expectations?; end
672
+ end
673
+ class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
674
+ def initialize(actual, *arg1); end
675
+ def matcher_matches?(matcher); end
676
+ end
677
+ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
678
+ def initialize(actual, matcher_1, matcher_2); end
679
+ def inner_matcher_block(outer_args); end
680
+ def matcher_matches?(matcher); end
681
+ def order_block_matchers; end
682
+ def self.matcher_expects_call_stack_jump?(matcher); end
683
+ end
684
+ class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound
685
+ def conjunction; end
686
+ def failure_message; end
687
+ def match(*arg0); end
688
+ end
689
+ class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound
690
+ def conjunction; end
691
+ def failure_message; end
692
+ def match(*arg0); end
693
+ end
694
+ class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher
695
+ def actual_collection_line; end
696
+ def best_solution; end
697
+ def convert_actual_to_an_array; end
698
+ def describe_collection(collection, surface_descriptions = nil); end
699
+ def description; end
700
+ def expected_collection_line; end
701
+ def extra_elements_line; end
702
+ def extra_items; end
703
+ def failure_message; end
704
+ def failure_message_when_negated; end
705
+ def generate_failure_message; end
706
+ def match(_expected, _actual); end
707
+ def match_when_sorted?; end
708
+ def message_line(prefix, collection, surface_descriptions = nil); end
709
+ def missing_elements_line; end
710
+ def missing_items; end
711
+ def pairings_maximizer; end
712
+ def safe_sort(array); end
713
+ def to_a_disallowed?(object); end
714
+ end
715
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
716
+ def actual_to_expected_matched_indexes; end
717
+ def apply_pairing_to(indeterminates, original_matches, other_list_index); end
718
+ def best_solution_for_pairing(expected_index, actual_index); end
719
+ def categorize_indexes(indexes_to_categorize, other_indexes); end
720
+ def expected_to_actual_matched_indexes; end
721
+ def find_best_solution; end
722
+ def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
723
+ def reciprocal_single_match?(matches, index, other_list); end
724
+ def solution; end
725
+ end
726
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct
727
+ def +(derived_candidate_solution); end
728
+ def candidate?; end
729
+ def ideal?; end
730
+ def indeterminate_actual_indexes; end
731
+ def indeterminate_actual_indexes=(_); end
732
+ def indeterminate_expected_indexes; end
733
+ def indeterminate_expected_indexes=(_); end
734
+ def self.[](*arg0); end
735
+ def self.inspect; end
736
+ def self.members; end
737
+ def self.new(*arg0); end
738
+ def unmatched_actual_indexes; end
739
+ def unmatched_actual_indexes=(_); end
740
+ def unmatched_expected_indexes; end
741
+ def unmatched_expected_indexes=(_); end
742
+ def unmatched_item_count; end
743
+ def worse_than?(other); end
744
+ end
745
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
746
+ def self.worse_than?(_other); end
747
+ end
748
+ class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher
749
+ def does_not_match?(range); end
750
+ def initialize(*expected); end
751
+ def matches?(range); end
752
+ end
753
+ class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher
754
+ def description; end
755
+ def failure_message; end
756
+ def initialize(*expected); end
757
+ def match(_expected, actual); end
758
+ def subsets_comparable?; end
759
+ end
760
+ class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith
761
+ def element_matches?; end
762
+ def subset_matches?; end
763
+ end
764
+ class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith
765
+ def element_matches?; end
766
+ def subset_matches?; end
767
+ end
768
+ class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher
769
+ def description; end
770
+ def diffable?; end
771
+ def failure_message; end
772
+ def failure_message_when_negated; end
773
+ def match(expected, actual); end
774
+ end
775
+ class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher
776
+ def diffable?; end
777
+ def failure_message; end
778
+ def failure_message_when_negated; end
779
+ def match(expected, actual); end
780
+ end
781
+ class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher
782
+ def actual_inspected; end
783
+ def detailed_failure_message; end
784
+ def diffable?; end
785
+ def expected_is_a_literal_singleton?; end
786
+ def failure_message; end
787
+ def failure_message_when_negated; end
788
+ def inspect_object(o); end
789
+ def match(expected, actual); end
790
+ def simple_failure_message; end
791
+ end
792
+ class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher
793
+ def does_not_match?(actual); end
794
+ def failure_message; end
795
+ def failure_message_when_negated; end
796
+ def initialize(*expected); end
797
+ def matches?(actual); end
798
+ end
799
+ class Anonymous_Struct_2 < Struct
800
+ def actual; end
801
+ def actual=(_); end
802
+ def expected; end
803
+ def expected=(_); end
804
+ def self.[](*arg0); end
805
+ def self.inspect; end
806
+ def self.members; end
807
+ def self.new(*arg0); end
808
+ end
809
+ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_2
810
+ def actual_exists?; end
811
+ def deprecated(predicate, actual); end
812
+ def existence_values; end
813
+ def predicates; end
814
+ def uniq_truthy_values; end
815
+ def valid_test?; end
816
+ def validity_message; end
817
+ end
818
+ class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::BaseMatcher
819
+ def args_description; end
820
+ def description; end
821
+ def does_not_match?(actual, &block); end
822
+ def failure_message; end
823
+ def failure_message_args_description; end
824
+ def failure_message_when_negated; end
825
+ def initialize(method_name, *args, &block); end
826
+ def matches?(actual, &block); end
827
+ def method_description; end
828
+ def predicate; end
829
+ def predicate_accessible?; end
830
+ def predicate_exists?; end
831
+ def predicate_matches?; end
832
+ def private_predicate?; end
833
+ def validity_message; end
834
+ end
835
+ class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher
836
+ def actual; end
837
+ def actual_has_attribute?(attribute_key, attribute_value); end
838
+ def cache_all_values; end
839
+ def description; end
840
+ def diffable?; end
841
+ def does_not_match?(actual); end
842
+ def failure_message; end
843
+ def failure_message_when_negated; end
844
+ def formatted_values; end
845
+ def initialize(expected); end
846
+ def matches?(actual); end
847
+ def perform_match(predicate); end
848
+ def respond_to_attributes?; end
849
+ def respond_to_failed; end
850
+ def respond_to_failure_message_or; end
851
+ def respond_to_matcher; end
852
+ end
853
+ class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
854
+ def actual_collection_includes?(expected_item); end
855
+ def actual_hash_has_key?(expected_key); end
856
+ def actual_hash_includes?(expected_key, expected_value); end
857
+ def comparing_hash_keys?(expected_item); end
858
+ def comparing_hash_to_a_subset?(expected_item); end
859
+ def convert_to_hash?(obj); end
860
+ def description; end
861
+ def diff_would_wrongly_highlight_matched_item?; end
862
+ def diffable?; end
863
+ def does_not_match?(actual); end
864
+ def excluded_from_actual; end
865
+ def expected; end
866
+ def expecteds; end
867
+ def failure_message; end
868
+ def failure_message_when_negated; end
869
+ def format_failure_message(preposition); end
870
+ def initialize(*expecteds); end
871
+ def matches?(actual); end
872
+ def perform_match(actual, &block); end
873
+ def readable_list_of(items); end
874
+ end
875
+ class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher
876
+ def add_new_line_if_needed(message); end
877
+ def description; end
878
+ def does_not_match?(_actual); end
879
+ def failed_objects; end
880
+ def failure_message; end
881
+ def failure_message_for_item(index, failure_message); end
882
+ def indent_multiline_message(message); end
883
+ def index_failed_objects; end
884
+ def initialize(matcher); end
885
+ def initialize_copy(other); end
886
+ def iterable?; end
887
+ def match(_expected, _actual); end
888
+ def matcher; end
889
+ end
890
+ class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher
891
+ def can_safely_call_match?(expected, actual); end
892
+ def description; end
893
+ def diffable?; end
894
+ def initialize(expected); end
895
+ def match(expected, actual); end
896
+ def match_captures(expected, actual); end
897
+ def with_captures(*captures); end
898
+ end
899
+ class RSpec::Matchers::BuiltIn::ReliableMatchData
900
+ def captures; end
901
+ def initialize(match_data); end
902
+ def match_data; end
903
+ def names; end
904
+ end
905
+ class RSpec::Matchers::BuiltIn::OperatorMatcher
906
+ def !=(_expected); end
907
+ def !~(_expected); end
908
+ def <(expected); end
909
+ def <=(expected); end
910
+ def ==(expected); end
911
+ def ===(expected); end
912
+ def =~(expected); end
913
+ def >(expected); end
914
+ def >=(expected); end
915
+ def description; end
916
+ def eval_match(actual, operator, expected); end
917
+ def fail_with_message(message); end
918
+ def has_non_generic_implementation_of?(op); end
919
+ def initialize(actual); end
920
+ def self.get(klass, operator); end
921
+ def self.register(klass, operator, matcher); end
922
+ def self.registry; end
923
+ def self.unregister(klass, operator); end
924
+ def self.use_custom_matcher_or_delegate(operator); end
925
+ end
926
+ class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
927
+ def __delegate_operator(actual, operator, expected); end
928
+ end
929
+ class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
930
+ def __delegate_operator(actual, operator, expected); end
931
+ end
932
+ class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher
933
+ def actual_output_description; end
934
+ def captured?; end
935
+ def description; end
936
+ def diffable?; end
937
+ def does_not_match?(block); end
938
+ def failure_message; end
939
+ def failure_message_when_negated; end
940
+ def initialize(expected); end
941
+ def matches?(block); end
942
+ def negative_failure_reason; end
943
+ def positive_failure_reason; end
944
+ def supports_block_expectations?; end
945
+ def to_stderr; end
946
+ def to_stderr_from_any_process; end
947
+ def to_stdout; end
948
+ def to_stdout_from_any_process; end
949
+ end
950
+ module RSpec::Matchers::BuiltIn::NullCapture
951
+ def self.capture(_block); end
952
+ def self.name; end
953
+ end
954
+ module RSpec::Matchers::BuiltIn::CaptureStdout
955
+ def self.capture(block); end
956
+ def self.name; end
957
+ end
958
+ module RSpec::Matchers::BuiltIn::CaptureStderr
959
+ def self.capture(block); end
960
+ def self.name; end
961
+ end
962
+ class Anonymous_Struct_3 < Struct
963
+ def name; end
964
+ def name=(_); end
965
+ def self.[](*arg0); end
966
+ def self.inspect; end
967
+ def self.members; end
968
+ def self.new(*arg0); end
969
+ def stream; end
970
+ def stream=(_); end
971
+ end
972
+ class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_3
973
+ def capture(block); end
974
+ end
975
+ class RSpec::Matchers::BuiltIn::RaiseError
976
+ def block_matches?; end
977
+ def description; end
978
+ def does_not_match?(given_proc); end
979
+ def error_and_message_match?; end
980
+ def eval_block; end
981
+ def expectation_matched?; end
982
+ def expected_error; end
983
+ def expecting_specific_exception?; end
984
+ def expects_call_stack_jump?; end
985
+ def failure_message; end
986
+ def failure_message_when_negated; end
987
+ def format_backtrace(backtrace); end
988
+ def given_error; end
989
+ def handle_warning(message); end
990
+ def initialize(expected_error_or_message = nil, expected_message = nil, &block); end
991
+ def matches?(given_proc, negative_expectation = nil, &block); end
992
+ def raise_message_already_set; end
993
+ def ready_to_eval_block?; end
994
+ def supports_block_expectations?; end
995
+ def verify_message; end
996
+ def warn_about_bare_error; end
997
+ def warn_about_negative_false_positive(expression); end
998
+ def warn_for_false_positives; end
999
+ def warning; end
1000
+ def warning_about_bare_error; end
1001
+ def with_message(expected_message); end
1002
+ include RSpec::Matchers::Composable
1003
+ end
1004
+ class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher
1005
+ def and_any_keywords; end
1006
+ def and_keywords(*keywords); end
1007
+ def and_unlimited_arguments; end
1008
+ def argument; end
1009
+ def arguments; end
1010
+ def description; end
1011
+ def does_not_match?(actual); end
1012
+ def failure_message; end
1013
+ def failure_message_when_negated; end
1014
+ def find_failing_method_names(actual, filter_method); end
1015
+ def ignoring_method_signature_failure!; end
1016
+ def initialize(*names); end
1017
+ def matches?(actual); end
1018
+ def matches_arity?(actual, name); end
1019
+ def method_signature_for(actual, name); end
1020
+ def pp_names; end
1021
+ def setup_method_signature_expectation; end
1022
+ def with(n); end
1023
+ def with_any_keywords; end
1024
+ def with_arity; end
1025
+ def with_arity_string; end
1026
+ def with_keywords(*keywords); end
1027
+ def with_keywords_string; end
1028
+ def with_unlimited_arguments; end
1029
+ end
1030
+ class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher
1031
+ def block_representation; end
1032
+ def description; end
1033
+ def extract_block_snippet; end
1034
+ def failure_message; end
1035
+ def failure_message_when_negated; end
1036
+ def initialize(description = nil, &block); end
1037
+ def matches?(actual, &block); end
1038
+ end
1039
+ class RSpec::Matchers::BuiltIn::ThrowSymbol
1040
+ def actual_result; end
1041
+ def caught; end
1042
+ def description; end
1043
+ def does_not_match?(given_proc); end
1044
+ def expected(symbol_desc = nil); end
1045
+ def expects_call_stack_jump?; end
1046
+ def failure_message; end
1047
+ def failure_message_when_negated; end
1048
+ def initialize(expected_symbol = nil, expected_arg = nil); end
1049
+ def matches?(given_proc); end
1050
+ def supports_block_expectations?; end
1051
+ def throw_description(symbol, arg); end
1052
+ include RSpec::Matchers::Composable
1053
+ end
1054
+ class RSpec::Matchers::BuiltIn::YieldProbe
1055
+ def assert_used!; end
1056
+ def assert_valid_expect_block!; end
1057
+ def has_block?; end
1058
+ def initialize(block, &callback); end
1059
+ def num_yields; end
1060
+ def num_yields=(arg0); end
1061
+ def probe; end
1062
+ def self.probe(block, &callback); end
1063
+ def single_yield_args; end
1064
+ def to_proc; end
1065
+ def yielded_args; end
1066
+ def yielded_args=(arg0); end
1067
+ def yielded_once?(matcher_name); end
1068
+ end
1069
+ class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher
1070
+ def at_least(number); end
1071
+ def at_most(number); end
1072
+ def count_constraint_to_number(n); end
1073
+ def does_not_match?(block); end
1074
+ def exactly(number); end
1075
+ def failure_message; end
1076
+ def failure_message_when_negated; end
1077
+ def failure_reason; end
1078
+ def human_readable_count(count); end
1079
+ def human_readable_expectation_type; end
1080
+ def initialize; end
1081
+ def matches?(block); end
1082
+ def once; end
1083
+ def set_expected_yields_count(relativity, n); end
1084
+ def supports_block_expectations?; end
1085
+ def thrice; end
1086
+ def times; end
1087
+ def twice; end
1088
+ end
1089
+ class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1090
+ def does_not_match?(block); end
1091
+ def failure_message; end
1092
+ def failure_message_when_negated; end
1093
+ def matches?(block); end
1094
+ def negative_failure_reason; end
1095
+ def positive_failure_reason; end
1096
+ def supports_block_expectations?; end
1097
+ end
1098
+ class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1099
+ def all_args_match?; end
1100
+ def args_currently_match?; end
1101
+ def description; end
1102
+ def does_not_match?(block); end
1103
+ def expected_arg_description; end
1104
+ def failure_message; end
1105
+ def failure_message_when_negated; end
1106
+ def initialize(*args); end
1107
+ def matches?(block); end
1108
+ def negative_failure_reason; end
1109
+ def positive_failure_reason; end
1110
+ def supports_block_expectations?; end
1111
+ end
1112
+ class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1113
+ def description; end
1114
+ def does_not_match?(block); end
1115
+ def expected_arg_description; end
1116
+ def failure_message; end
1117
+ def failure_message_when_negated; end
1118
+ def initialize(*args); end
1119
+ def matches?(block); end
1120
+ def negative_failure_reason; end
1121
+ def positive_failure_reason; end
1122
+ def supports_block_expectations?; end
1123
+ end