bilisim_sozlugu 2.0.0 → 2.0.1

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,1150 @@
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.10.0
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
+ def should(matcher = nil, message = nil, &block); end
327
+ def should_not(matcher = nil, message = nil, &block); end
328
+ end
329
+ class RSpec::Expectations::Configuration
330
+ def add_should_and_should_not_to(*modules); end
331
+ def backtrace_formatter; end
332
+ def backtrace_formatter=(arg0); end
333
+ def color?; end
334
+ def false_positives_handler; end
335
+ def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end
336
+ def include_chain_clauses_in_custom_matcher_descriptions?; end
337
+ def initialize; end
338
+ def max_formatted_output_length=(length); end
339
+ def on_potential_false_positives; end
340
+ def on_potential_false_positives=(behavior); end
341
+ def reset_syntaxes_to_default; end
342
+ def strict_predicate_matchers; end
343
+ def strict_predicate_matchers=(flag); end
344
+ def strict_predicate_matchers?; end
345
+ def syntax; end
346
+ def syntax=(values); end
347
+ def warn_about_potential_false_positives=(boolean); end
348
+ def warn_about_potential_false_positives?; end
349
+ end
350
+ module RSpec::Expectations::Configuration::NullBacktraceFormatter
351
+ def self.format_backtrace(backtrace); end
352
+ end
353
+ class InvalidName___Class_0x00___Differ_5
354
+ end
355
+ module RSpec::Expectations::ExpectationHelper
356
+ def self.check_message(msg); end
357
+ def self.handle_failure(matcher, message, failure_message_method); end
358
+ def self.modern_matcher_from(matcher); end
359
+ def self.with_matcher(handler, matcher, message); end
360
+ end
361
+ class RSpec::Expectations::PositiveExpectationHandler
362
+ def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
363
+ def self.opposite_should_method; end
364
+ def self.should_method; end
365
+ def self.verb; end
366
+ end
367
+ class RSpec::Expectations::NegativeExpectationHandler
368
+ def self.does_not_match?(matcher, actual, &block); end
369
+ def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
370
+ def self.opposite_should_method; end
371
+ def self.should_method; end
372
+ def self.verb; end
373
+ end
374
+ class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator
375
+ def initialize(matcher); end
376
+ def self.wrap(matcher); end
377
+ end
378
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < 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
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter
384
+ def failure_message; end
385
+ def failure_message_when_negated; end
386
+ def self.interface_matches?(matcher); end
387
+ end
388
+ module RSpec::Expectations::Version
389
+ end
390
+ class RSpec::Expectations::ExpectationNotMetError < Exception
391
+ end
392
+ class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError
393
+ def aggregation_block_label; end
394
+ def aggregation_metadata; end
395
+ def all_exceptions; end
396
+ def backtrace_line(line); end
397
+ def block_description; end
398
+ def enumerated(exceptions, index_offset); end
399
+ def enumerated_errors; end
400
+ def enumerated_failures; end
401
+ def exception_count_description; end
402
+ def exclusion_patterns; end
403
+ def failures; end
404
+ def format_backtrace(backtrace); end
405
+ def indentation; end
406
+ def indented(failure_message, index); end
407
+ def index_label(index); end
408
+ def initialize(failure_aggregator); end
409
+ def longest_index_label_width; end
410
+ def message; end
411
+ def other_errors; end
412
+ def pluralize(noun, count); end
413
+ def summary; end
414
+ def width_of_label(index); end
415
+ end
416
+ class RSpec::Expectations::BlockSnippetExtractor
417
+ def beginning_line_number; end
418
+ def block_token_extractor; end
419
+ def body_content_lines; end
420
+ def file_path; end
421
+ def initialize(proc, method_name); end
422
+ def method_name; end
423
+ def proc; end
424
+ def raw_body_lines; end
425
+ def raw_body_snippet; end
426
+ def self.try_extracting_single_line_body_of(proc, method_name); end
427
+ def source; end
428
+ def source_location; end
429
+ end
430
+ class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError
431
+ end
432
+ class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error
433
+ end
434
+ class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error
435
+ end
436
+ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct
437
+ def after_beginning_of_args_state(token); end
438
+ def after_beginning_of_body_state(token); end
439
+ def after_method_call_state(token); end
440
+ def after_opener_state(token); end
441
+ def beginning_line_number; end
442
+ def beginning_line_number=(_); end
443
+ def block_locator; end
444
+ def body_tokens; end
445
+ def correct_block?(body_tokens); end
446
+ def finalize_pending_tokens!; end
447
+ def finish!; end
448
+ def finish_or_find_next_block_if_incorrect!; end
449
+ def handle_closer_token(token); end
450
+ def handle_opener_token(token); end
451
+ def initial_state(token); end
452
+ def initialize(*arg0); end
453
+ def invoke_state_handler(token); end
454
+ def method_name; end
455
+ def method_name=(_); end
456
+ def opener_token?(token); end
457
+ def opener_token_stack; end
458
+ def parse!; end
459
+ def pending_tokens; end
460
+ def pipe_token?(token); end
461
+ def self.[](*arg0); end
462
+ def self.inspect; end
463
+ def self.members; end
464
+ def self.new(*arg0); end
465
+ def source; end
466
+ def source=(_); end
467
+ def state; end
468
+ end
469
+ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct
470
+ def beginning_line_number; end
471
+ def beginning_line_number=(_); end
472
+ def block_body_node; end
473
+ def block_wrapper_node; end
474
+ def body_content_locations; end
475
+ def candidate_block_wrapper_nodes; end
476
+ def candidate_method_ident_nodes; end
477
+ def method_call_location; end
478
+ def method_ident_node; end
479
+ def method_ident_node?(node); end
480
+ def method_name; end
481
+ def method_name=(_); end
482
+ def self.[](*arg0); end
483
+ def self.inspect; end
484
+ def self.members; end
485
+ def self.new(*arg0); end
486
+ def source; end
487
+ def source=(_); end
488
+ end
489
+ class RSpec::Expectations::FailureAggregator
490
+ def aggregate; end
491
+ def assign_backtrace(failure); end
492
+ def block_label; end
493
+ def call(failure, options); end
494
+ def failures; end
495
+ def initialize(block_label, metadata); end
496
+ def metadata; end
497
+ def notify_aggregated_failures; end
498
+ def other_errors; end
499
+ end
500
+ class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher
501
+ def match(expected, actual); end
502
+ end
503
+ class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher
504
+ def description; end
505
+ def match(expected, actual); end
506
+ end
507
+ class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher
508
+ def comparable?; end
509
+ def compare; end
510
+ def description; end
511
+ def exclusive; end
512
+ def failure_message; end
513
+ def inclusive; end
514
+ def initialize(min, max); end
515
+ def matches?(actual); end
516
+ def not_comparable_clause; end
517
+ end
518
+ class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher
519
+ def failure_message; end
520
+ def failure_message_when_negated; end
521
+ def match(_, actual); end
522
+ end
523
+ class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher
524
+ def failure_message; end
525
+ def failure_message_when_negated; end
526
+ def match(_, actual); end
527
+ end
528
+ class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher
529
+ def failure_message; end
530
+ def failure_message_when_negated; end
531
+ def match(_, actual); end
532
+ end
533
+ module RSpec::Matchers::BuiltIn::BeHelpers
534
+ def args_to_s; end
535
+ def args_to_sentence; end
536
+ def expected_to_sentence; end
537
+ def inspected_args; end
538
+ def parenthesize(string); end
539
+ end
540
+ class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher
541
+ def <(operand); end
542
+ def <=(operand); end
543
+ def ==(operand); end
544
+ def ===(operand); end
545
+ def =~(operand); end
546
+ def >(operand); end
547
+ def >=(operand); end
548
+ def failure_message; end
549
+ def failure_message_when_negated; end
550
+ def initialize(*args); end
551
+ def match(_, actual); end
552
+ include RSpec::Matchers::BuiltIn::BeHelpers
553
+ end
554
+ class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher
555
+ def description; end
556
+ def does_not_match?(actual); end
557
+ def failure_message; end
558
+ def failure_message_when_negated; end
559
+ def initialize(operand, operator); end
560
+ def matches?(actual); end
561
+ def perform_match(actual); end
562
+ include RSpec::Matchers::BuiltIn::BeHelpers
563
+ end
564
+ class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher
565
+ def description; end
566
+ def does_not_match?(actual, &block); end
567
+ def expectation_of(value); end
568
+ def failure_message; end
569
+ def failure_message_expecting(value); end
570
+ def failure_message_when_negated; end
571
+ def failure_to_respond_explanation; end
572
+ def initialize(method_name, *args, &block); end
573
+ def matches?(actual, &block); end
574
+ def method_description; end
575
+ def predicate_accessible?; end
576
+ def predicate_matches?(value = nil); end
577
+ def predicate_method_name; end
578
+ def predicate_result; end
579
+ def private_predicate?; end
580
+ def root; end
581
+ def validity_message; end
582
+ include RSpec::Matchers::BuiltIn::BeHelpers
583
+ end
584
+ class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate
585
+ def predicate; end
586
+ end
587
+ class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate
588
+ def failure_to_respond_explanation; end
589
+ def predicate; end
590
+ def predicate_accessible?; end
591
+ def predicate_method_name; end
592
+ def present_tense_predicate; end
593
+ end
594
+ class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher
595
+ def description; end
596
+ def failure_message; end
597
+ def failure_message_when_negated; end
598
+ def initialize(delta); end
599
+ def matches?(actual); end
600
+ def needs_expected; end
601
+ def not_numeric_clause; end
602
+ def numeric?; end
603
+ def of(expected); end
604
+ def percent_of(expected); end
605
+ end
606
+ class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher
607
+ def by(expected_delta); end
608
+ def by_at_least(minimum); end
609
+ def by_at_most(maximum); end
610
+ def change_details; end
611
+ def description; end
612
+ def does_not_match?(event_proc); end
613
+ def failure_message; end
614
+ def failure_message_when_negated; end
615
+ def from(value); end
616
+ def initialize(receiver = nil, message = nil, &block); end
617
+ def matches?(event_proc); end
618
+ def negative_failure_reason; end
619
+ def perform_change(event_proc); end
620
+ def positive_failure_reason; end
621
+ def raise_block_syntax_error; end
622
+ def supports_block_expectations?; end
623
+ def to(value); end
624
+ end
625
+ class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher
626
+ def description; end
627
+ def does_not_match?(_event_proc); end
628
+ def failure_message; end
629
+ def failure_reason; end
630
+ def initialize(change_details, expected_delta, relativity, &comparer); end
631
+ def matches?(event_proc); end
632
+ def supports_block_expectations?; end
633
+ end
634
+ class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher
635
+ def after_value_failure; end
636
+ def before_value_failure; end
637
+ def description; end
638
+ def did_change_failure; end
639
+ def did_not_change_failure; end
640
+ def failure_message; end
641
+ def initialize(change_details, from, to); end
642
+ def matches?(event_proc); end
643
+ def matches_after?; end
644
+ def not_given_a_block_failure; end
645
+ def perform_change(event_proc); end
646
+ def supports_block_expectations?; end
647
+ end
648
+ class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
649
+ def change_description; end
650
+ def does_not_match?(event_proc); end
651
+ def failure_message_when_negated; end
652
+ def initialize(change_details, expected_before); end
653
+ def to(value); end
654
+ end
655
+ class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
656
+ def change_description; end
657
+ def does_not_match?(_event_proc); end
658
+ def from(value); end
659
+ def initialize(change_details, expected_after); end
660
+ end
661
+ class RSpec::Matchers::BuiltIn::ChangeDetails
662
+ def actual_after; end
663
+ def actual_delta; end
664
+ def changed?; end
665
+ def evaluate_value_proc; end
666
+ def extract_value_block_snippet; end
667
+ def initialize(matcher_name, receiver = nil, message = nil, &block); end
668
+ def message_notation(receiver, message); end
669
+ def perform_change(event_proc); end
670
+ def value_representation; end
671
+ end
672
+ class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher
673
+ def compound_failure_message; end
674
+ def description; end
675
+ def diffable?; end
676
+ def diffable_matcher_list; end
677
+ def diffable_matcher_list_for(matcher); end
678
+ def does_not_match?(_actual); end
679
+ def evaluator; end
680
+ def expected; end
681
+ def expects_call_stack_jump?; end
682
+ def indent_multiline_message(message); end
683
+ def initialize(matcher_1, matcher_2); end
684
+ def initialize_copy(other); end
685
+ def match(_expected, actual); end
686
+ def matcher_1; end
687
+ def matcher_1_matches?; end
688
+ def matcher_2; end
689
+ def matcher_2_matches?; end
690
+ def matcher_is_diffable?(matcher); end
691
+ def matcher_supports_block_expectations?(matcher); end
692
+ def supports_block_expectations?; end
693
+ end
694
+ class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
695
+ def initialize(actual, *arg1); end
696
+ def matcher_matches?(matcher); end
697
+ end
698
+ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
699
+ def initialize(actual, matcher_1, matcher_2); end
700
+ def inner_matcher_block(outer_args); end
701
+ def matcher_matches?(matcher); end
702
+ def order_block_matchers; end
703
+ def self.matcher_expects_call_stack_jump?(matcher); end
704
+ end
705
+ class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound
706
+ def conjunction; end
707
+ def failure_message; end
708
+ def match(*arg0); end
709
+ end
710
+ class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound
711
+ def conjunction; end
712
+ def failure_message; end
713
+ def match(*arg0); end
714
+ end
715
+ class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher
716
+ def actual_collection_line; end
717
+ def best_solution; end
718
+ def convert_actual_to_an_array; end
719
+ def describe_collection(collection, surface_descriptions = nil); end
720
+ def description; end
721
+ def expected_collection_line; end
722
+ def extra_elements_line; end
723
+ def extra_items; end
724
+ def failure_message; end
725
+ def failure_message_when_negated; end
726
+ def generate_failure_message; end
727
+ def match(_expected, _actual); end
728
+ def match_when_sorted?; end
729
+ def message_line(prefix, collection, surface_descriptions = nil); end
730
+ def missing_elements_line; end
731
+ def missing_items; end
732
+ def pairings_maximizer; end
733
+ def safe_sort(array); end
734
+ def to_a_disallowed?(object); end
735
+ end
736
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
737
+ def actual_to_expected_matched_indexes; end
738
+ def apply_pairing_to(indeterminates, original_matches, other_list_index); end
739
+ def best_solution_for_pairing(expected_index, actual_index); end
740
+ def categorize_indexes(indexes_to_categorize, other_indexes); end
741
+ def expected_to_actual_matched_indexes; end
742
+ def find_best_solution; end
743
+ def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
744
+ def reciprocal_single_match?(matches, index, other_list); end
745
+ def solution; end
746
+ end
747
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct
748
+ def +(derived_candidate_solution); end
749
+ def candidate?; end
750
+ def ideal?; end
751
+ def indeterminate_actual_indexes; end
752
+ def indeterminate_actual_indexes=(_); end
753
+ def indeterminate_expected_indexes; end
754
+ def indeterminate_expected_indexes=(_); end
755
+ def self.[](*arg0); end
756
+ def self.inspect; end
757
+ def self.members; end
758
+ def self.new(*arg0); end
759
+ def unmatched_actual_indexes; end
760
+ def unmatched_actual_indexes=(_); end
761
+ def unmatched_expected_indexes; end
762
+ def unmatched_expected_indexes=(_); end
763
+ def unmatched_item_count; end
764
+ def worse_than?(other); end
765
+ end
766
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
767
+ def self.worse_than?(_other); end
768
+ end
769
+ class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher
770
+ def does_not_match?(range); end
771
+ def initialize(*expected); end
772
+ def matches?(range); end
773
+ end
774
+ class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher
775
+ def description; end
776
+ def failure_message; end
777
+ def initialize(*expected); end
778
+ def match(_expected, actual); end
779
+ def subsets_comparable?; end
780
+ end
781
+ class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith
782
+ def element_matches?; end
783
+ def subset_matches?; end
784
+ end
785
+ class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith
786
+ def element_matches?; end
787
+ def subset_matches?; end
788
+ end
789
+ class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher
790
+ def description; end
791
+ def diffable?; end
792
+ def failure_message; end
793
+ def failure_message_when_negated; end
794
+ def match(expected, actual); end
795
+ end
796
+ class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher
797
+ def diffable?; end
798
+ def failure_message; end
799
+ def failure_message_when_negated; end
800
+ def match(expected, actual); end
801
+ end
802
+ class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher
803
+ def actual_inspected; end
804
+ def detailed_failure_message; end
805
+ def diffable?; end
806
+ def expected_is_a_literal_singleton?; end
807
+ def failure_message; end
808
+ def failure_message_when_negated; end
809
+ def inspect_object(o); end
810
+ def match(expected, actual); end
811
+ def simple_failure_message; end
812
+ end
813
+ class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher
814
+ def does_not_match?(actual); end
815
+ def failure_message; end
816
+ def failure_message_when_negated; end
817
+ def initialize(*expected); end
818
+ def matches?(actual); end
819
+ end
820
+ class Anonymous_Struct_6 < Struct
821
+ def actual; end
822
+ def actual=(_); end
823
+ def expected; end
824
+ def expected=(_); end
825
+ def self.[](*arg0); end
826
+ def self.inspect; end
827
+ def self.members; end
828
+ def self.new(*arg0); end
829
+ end
830
+ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_6
831
+ def actual_exists?; end
832
+ def deprecated(predicate, actual); end
833
+ def existence_values; end
834
+ def predicates; end
835
+ def uniq_truthy_values; end
836
+ def valid_test?; end
837
+ def validity_message; end
838
+ end
839
+ class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher
840
+ def actual; end
841
+ def actual_has_attribute?(attribute_key, attribute_value); end
842
+ def cache_all_values; end
843
+ def description; end
844
+ def diffable?; end
845
+ def does_not_match?(actual); end
846
+ def failure_message; end
847
+ def failure_message_when_negated; end
848
+ def formatted_values; end
849
+ def initialize(expected); end
850
+ def matches?(actual); end
851
+ def perform_match(predicate); end
852
+ def respond_to_attributes?; end
853
+ def respond_to_failed; end
854
+ def respond_to_failure_message_or; end
855
+ def respond_to_matcher; end
856
+ end
857
+ module RSpec::Matchers::BuiltIn::CountExpectation
858
+ def at_least(number); end
859
+ def at_most(number); end
860
+ def count_constraint_to_number(n); end
861
+ def count_expectation_description; end
862
+ def count_expectation_type; end
863
+ def count_failure_reason(action); end
864
+ def cover?(count, number); end
865
+ def exactly(number); end
866
+ def expected_count; end
867
+ def expected_count_matches?(actual_count); end
868
+ def has_expected_count?; end
869
+ def human_readable_count(count); end
870
+ def human_readable_expectation_type; end
871
+ def once; end
872
+ def raise_impossible_count_expectation(count); end
873
+ def raise_unsupported_count_expectation; end
874
+ def set_expected_count(relativity, n); end
875
+ def thrice; end
876
+ def times; end
877
+ def twice; end
878
+ def unsupported_count_expectation?(relativity); end
879
+ end
880
+ class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
881
+ def actual_collection_includes?(expected_item); end
882
+ def actual_hash_has_key?(expected_key); end
883
+ def actual_hash_includes?(expected_key, expected_value); end
884
+ def check_actual?(actual); end
885
+ def check_expected_count?; end
886
+ def comparing_hash_keys?(expected_item); end
887
+ def comparing_hash_to_a_subset?(expected_item); end
888
+ def convert_to_hash?(obj); end
889
+ def count_enumerable(expected_item); end
890
+ def count_inclusions; end
891
+ def description; end
892
+ def diff_would_wrongly_highlight_matched_item?; end
893
+ def diffable?; end
894
+ def does_not_match?(actual); end
895
+ def excluded_from_actual; end
896
+ def expected; end
897
+ def expecteds; end
898
+ def failure_message; end
899
+ def failure_message_when_negated; end
900
+ def format_failure_message(preposition); end
901
+ def initialize(*expecteds); end
902
+ def matches?(actual); end
903
+ def perform_match(&block); end
904
+ def readable_list_of(items); end
905
+ include RSpec::Matchers::BuiltIn::CountExpectation
906
+ end
907
+ class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher
908
+ def add_new_line_if_needed(message); end
909
+ def description; end
910
+ def does_not_match?(_actual); end
911
+ def failed_objects; end
912
+ def failure_message; end
913
+ def failure_message_for_item(index, failure_message); end
914
+ def indent_multiline_message(message); end
915
+ def index_failed_objects; end
916
+ def initialize(matcher); end
917
+ def initialize_copy(other); end
918
+ def iterable?; end
919
+ def match(_expected, _actual); end
920
+ def matcher; end
921
+ end
922
+ class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher
923
+ def can_safely_call_match?(expected, actual); end
924
+ def description; end
925
+ def diffable?; end
926
+ def initialize(expected); end
927
+ def match(expected, actual); end
928
+ def match_captures(expected, actual); end
929
+ def with_captures(*captures); end
930
+ end
931
+ class RSpec::Matchers::BuiltIn::ReliableMatchData
932
+ def captures; end
933
+ def initialize(match_data); end
934
+ def match_data; end
935
+ def names; end
936
+ end
937
+ class RSpec::Matchers::BuiltIn::OperatorMatcher
938
+ def !=(_expected); end
939
+ def !~(_expected); end
940
+ def <(expected); end
941
+ def <=(expected); end
942
+ def ==(expected); end
943
+ def ===(expected); end
944
+ def =~(expected); end
945
+ def >(expected); end
946
+ def >=(expected); end
947
+ def description; end
948
+ def eval_match(actual, operator, expected); end
949
+ def fail_with_message(message); end
950
+ def has_non_generic_implementation_of?(op); end
951
+ def initialize(actual); end
952
+ def self.get(klass, operator); end
953
+ def self.register(klass, operator, matcher); end
954
+ def self.registry; end
955
+ def self.unregister(klass, operator); end
956
+ def self.use_custom_matcher_or_delegate(operator); end
957
+ end
958
+ class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
959
+ def __delegate_operator(actual, operator, expected); end
960
+ end
961
+ class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
962
+ def __delegate_operator(actual, operator, expected); end
963
+ end
964
+ class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher
965
+ def actual_output_description; end
966
+ def captured?; end
967
+ def description; end
968
+ def diffable?; end
969
+ def does_not_match?(block); end
970
+ def failure_message; end
971
+ def failure_message_when_negated; end
972
+ def initialize(expected); end
973
+ def matches?(block); end
974
+ def negative_failure_reason; end
975
+ def positive_failure_reason; end
976
+ def supports_block_expectations?; end
977
+ def to_stderr; end
978
+ def to_stderr_from_any_process; end
979
+ def to_stdout; end
980
+ def to_stdout_from_any_process; end
981
+ end
982
+ module RSpec::Matchers::BuiltIn::NullCapture
983
+ def self.capture(_block); end
984
+ def self.name; end
985
+ end
986
+ module RSpec::Matchers::BuiltIn::CaptureStdout
987
+ def self.capture(block); end
988
+ def self.name; end
989
+ end
990
+ module RSpec::Matchers::BuiltIn::CaptureStderr
991
+ def self.capture(block); end
992
+ def self.name; end
993
+ end
994
+ class Anonymous_Struct_7 < Struct
995
+ def name; end
996
+ def name=(_); end
997
+ def self.[](*arg0); end
998
+ def self.inspect; end
999
+ def self.members; end
1000
+ def self.new(*arg0); end
1001
+ def stream; end
1002
+ def stream=(_); end
1003
+ end
1004
+ class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_7
1005
+ def capture(block); end
1006
+ end
1007
+ class RSpec::Matchers::BuiltIn::RaiseError
1008
+ def block_matches?; end
1009
+ def description; end
1010
+ def does_not_match?(given_proc); end
1011
+ def error_and_message_match?; end
1012
+ def eval_block; end
1013
+ def expectation_matched?; end
1014
+ def expected_error; end
1015
+ def expecting_specific_exception?; end
1016
+ def expects_call_stack_jump?; end
1017
+ def failure_message; end
1018
+ def failure_message_when_negated; end
1019
+ def format_backtrace(backtrace); end
1020
+ def given_error; end
1021
+ def handle_warning(message); end
1022
+ def initialize(expected_error_or_message, expected_message, &block); end
1023
+ def matches?(given_proc, negative_expectation = nil, &block); end
1024
+ def raise_message_already_set; end
1025
+ def ready_to_eval_block?; end
1026
+ def supports_block_expectations?; end
1027
+ def verify_message; end
1028
+ def warn_about_bare_error!; end
1029
+ def warn_about_bare_error?; end
1030
+ def warn_about_negative_false_positive!(expression); end
1031
+ def warn_about_nil_error!; end
1032
+ def warn_about_nil_error?; end
1033
+ def warn_for_negative_false_positives!; end
1034
+ def warning; end
1035
+ def with_message(expected_message); end
1036
+ include RSpec::Matchers::Composable
1037
+ end
1038
+ class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher
1039
+ def and_any_keywords; end
1040
+ def and_keywords(*keywords); end
1041
+ def and_unlimited_arguments; end
1042
+ def argument; end
1043
+ def arguments; end
1044
+ def description; end
1045
+ def does_not_match?(actual); end
1046
+ def failure_message; end
1047
+ def failure_message_when_negated; end
1048
+ def find_failing_method_names(actual, filter_method); end
1049
+ def ignoring_method_signature_failure!; end
1050
+ def initialize(*names); end
1051
+ def matches?(actual); end
1052
+ def matches_arity?(actual, name); end
1053
+ def pp_names; end
1054
+ def with(n); end
1055
+ def with_any_keywords; end
1056
+ def with_arity; end
1057
+ def with_arity_string; end
1058
+ def with_keywords(*keywords); end
1059
+ def with_keywords_string; end
1060
+ def with_unlimited_arguments; end
1061
+ end
1062
+ class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
1063
+ def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
1064
+ def matches?(actual, name); end
1065
+ def method_signature_for(actual, name); end
1066
+ def verifier_for(actual, name); end
1067
+ end
1068
+ class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher
1069
+ def block_representation; end
1070
+ def description; end
1071
+ def extract_block_snippet; end
1072
+ def failure_message; end
1073
+ def failure_message_when_negated; end
1074
+ def initialize(description = nil, &block); end
1075
+ def matches?(actual, &block); end
1076
+ end
1077
+ class RSpec::Matchers::BuiltIn::ThrowSymbol
1078
+ def actual_result; end
1079
+ def caught; end
1080
+ def description; end
1081
+ def does_not_match?(given_proc); end
1082
+ def expected(symbol_desc = nil); end
1083
+ def expects_call_stack_jump?; end
1084
+ def failure_message; end
1085
+ def failure_message_when_negated; end
1086
+ def initialize(expected_symbol = nil, expected_arg = nil); end
1087
+ def matches?(given_proc); end
1088
+ def supports_block_expectations?; end
1089
+ def throw_description(symbol, arg); end
1090
+ include RSpec::Matchers::Composable
1091
+ end
1092
+ class RSpec::Matchers::BuiltIn::YieldProbe
1093
+ def assert_used!; end
1094
+ def assert_valid_expect_block!; end
1095
+ def has_block?; end
1096
+ def initialize(block, &callback); end
1097
+ def num_yields; end
1098
+ def num_yields=(arg0); end
1099
+ def probe; end
1100
+ def self.probe(block, &callback); end
1101
+ def single_yield_args; end
1102
+ def to_proc; end
1103
+ def yielded_args; end
1104
+ def yielded_args=(arg0); end
1105
+ def yielded_once?(matcher_name); end
1106
+ end
1107
+ class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher
1108
+ def does_not_match?(block); end
1109
+ def failure_message; end
1110
+ def failure_message_when_negated; end
1111
+ def failure_reason; end
1112
+ def matches?(block); end
1113
+ def supports_block_expectations?; end
1114
+ include RSpec::Matchers::BuiltIn::CountExpectation
1115
+ end
1116
+ class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1117
+ def does_not_match?(block); end
1118
+ def failure_message; end
1119
+ def failure_message_when_negated; end
1120
+ def matches?(block); end
1121
+ def negative_failure_reason; end
1122
+ def positive_failure_reason; end
1123
+ def supports_block_expectations?; end
1124
+ end
1125
+ class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1126
+ def all_args_match?; end
1127
+ def args_currently_match?; end
1128
+ def description; end
1129
+ def does_not_match?(block); end
1130
+ def expected_arg_description; end
1131
+ def failure_message; end
1132
+ def failure_message_when_negated; end
1133
+ def initialize(*args); end
1134
+ def matches?(block); end
1135
+ def negative_failure_reason; end
1136
+ def positive_failure_reason; end
1137
+ def supports_block_expectations?; end
1138
+ end
1139
+ class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1140
+ def description; end
1141
+ def does_not_match?(block); end
1142
+ def expected_arg_description; end
1143
+ def failure_message; end
1144
+ def failure_message_when_negated; end
1145
+ def initialize(*args); end
1146
+ def matches?(block); end
1147
+ def negative_failure_reason; end
1148
+ def positive_failure_reason; end
1149
+ def supports_block_expectations?; end
1150
+ end