schema_dot_org 1.7.1 → 1.8

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,1123 +0,0 @@
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