sorbet-struct-comparable 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (52) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +47 -52
  3. data/.gitignore +3 -0
  4. data/CHANGELOG.md +4 -0
  5. data/Gemfile +3 -8
  6. data/lib/sorbet-struct-comparable/version.rb +1 -1
  7. data/lib/t/struct/acts_as_comparable.rb +5 -0
  8. data/nix/sources.json +14 -0
  9. data/nix/sources.nix +174 -0
  10. data/run_ci.sh +6 -0
  11. data/shell.nix +20 -0
  12. data/sorbet/config +2 -0
  13. data/sorbet/rbi/gems/ast@2.4.2.rbi +54 -0
  14. data/sorbet/rbi/gems/byebug@11.1.3.rbi +1568 -0
  15. data/sorbet/rbi/gems/coderay@1.1.3.rbi +1005 -0
  16. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +8 -0
  17. data/sorbet/rbi/gems/docile@1.4.0.rbi +54 -0
  18. data/sorbet/rbi/gems/method_source@1.0.0.rbi +72 -0
  19. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +1188 -0
  20. data/sorbet/rbi/gems/pry-byebug@3.9.0.rbi +461 -0
  21. data/sorbet/rbi/gems/{pry.rbi → pry@0.13.1.rbi} +2308 -1706
  22. data/sorbet/rbi/{sorbet-typed/lib/rake/all/rake.rbi → gems/rake@13.0.6.rbi} +580 -430
  23. data/sorbet/rbi/gems/rbi@0.0.6.rbi +1405 -0
  24. data/sorbet/rbi/gems/{rspec-core.rbi → rspec-core@3.10.1.rbi} +2303 -1735
  25. data/sorbet/rbi/gems/{rspec-expectations.rbi → rspec-expectations@3.10.1.rbi} +1133 -707
  26. data/sorbet/rbi/gems/{rspec-mocks.rbi → rspec-mocks@3.10.2.rbi} +1299 -937
  27. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +509 -0
  28. data/sorbet/rbi/gems/rspec@3.10.0.rbi +38 -0
  29. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +89 -0
  30. data/sorbet/rbi/gems/{simplecov.rbi → simplecov@0.21.2.rbi} +451 -293
  31. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +8 -0
  32. data/sorbet/rbi/gems/spoom@1.1.5.rbi +1241 -0
  33. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +949 -0
  34. data/sorbet/rbi/gems/thor@1.1.0.rbi +839 -0
  35. data/sorbet/rbi/gems/unparser@0.6.0.rbi +8 -0
  36. metadata +34 -29
  37. data/.ruby-version +0 -1
  38. data/sorbet/rbi/gems/byebug.rbi +0 -1041
  39. data/sorbet/rbi/gems/coderay.rbi +0 -92
  40. data/sorbet/rbi/gems/docile.rbi +0 -36
  41. data/sorbet/rbi/gems/listen.rbi +0 -301
  42. data/sorbet/rbi/gems/method_source.rbi +0 -64
  43. data/sorbet/rbi/gems/pry-byebug.rbi +0 -155
  44. data/sorbet/rbi/gems/rake.rbi +0 -642
  45. data/sorbet/rbi/gems/rspec-support.rbi +0 -280
  46. data/sorbet/rbi/gems/rspec.rbi +0 -15
  47. data/sorbet/rbi/gems/simplecov-html.rbi +0 -35
  48. data/sorbet/rbi/gems/simplecov_json_formatter.rbi +0 -45
  49. data/sorbet/rbi/hidden-definitions/errors.txt +0 -2742
  50. data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -6540
  51. data/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +0 -1891
  52. data/sorbet/rbi/todo.rbi +0 -6
@@ -1,17 +1,313 @@
1
- # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
- # srb rbi gems
1
+ # DO NOT EDIT MANUALLY
2
+ # This is an autogenerated file for types exported from the `rspec-expectations` gem.
3
+ # Please instead update this file by running `bin/tapioca gem rspec-expectations`.
3
4
 
4
5
  # 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.1
11
6
 
12
- module RSpec
7
+ module RSpec::Expectations
8
+ class << self
9
+ def configuration; end
10
+ def differ; end
11
+ def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
12
+ end
13
+ end
14
+
15
+ class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
16
+ def not_to(matcher, message = T.unsafe(nil), &block); end
17
+ def to(matcher, message = T.unsafe(nil), &block); end
18
+ def to_not(matcher, message = T.unsafe(nil), &block); end
19
+
20
+ private
21
+
22
+ def enforce_block_expectation(matcher); end
23
+ def supports_block_expectations?(matcher); end
24
+ end
25
+
26
+ class RSpec::Expectations::BlockSnippetExtractor
27
+ def initialize(proc, method_name); end
28
+
29
+ def body_content_lines; end
30
+ def method_name; end
31
+ def proc; end
32
+
33
+ private
34
+
35
+ def beginning_line_number; end
36
+ def block_token_extractor; end
37
+ def file_path; end
38
+ def raw_body_lines; end
39
+ def raw_body_snippet; end
40
+ def source; end
41
+ def source_location; end
42
+
43
+ class << self
44
+ def try_extracting_single_line_body_of(proc, method_name); end
45
+ end
46
+ end
47
+
48
+ class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
49
+
50
+ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
51
+ def beginning_line_number; end
52
+ def beginning_line_number=(_); end
53
+ def body_content_locations; end
54
+ def method_call_location; end
55
+ def method_name; end
56
+ def method_name=(_); end
57
+ def source; end
58
+ def source=(_); end
59
+
60
+ private
61
+
62
+ def block_body_node; end
63
+ def block_wrapper_node; end
64
+ def candidate_block_wrapper_nodes; end
65
+ def candidate_method_ident_nodes; end
66
+ def method_ident_node; end
67
+ def method_ident_node?(node); end
68
+
69
+ class << self
70
+ def [](*_arg0); end
71
+ def inspect; end
72
+ def members; end
73
+ def new(*_arg0); end
74
+ end
75
+ end
76
+
77
+ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
78
+ def initialize(*_arg0); end
79
+
80
+ def beginning_line_number; end
81
+ def beginning_line_number=(_); end
82
+ def body_tokens; end
83
+ def method_name; end
84
+ def method_name=(_); end
85
+ def source; end
86
+ def source=(_); end
87
+ def state; end
88
+
89
+ private
90
+
91
+ def after_beginning_of_args_state(token); end
92
+ def after_beginning_of_body_state(token); end
93
+ def after_method_call_state(token); end
94
+ def after_opener_state(token); end
95
+ def block_locator; end
96
+ def correct_block?(body_tokens); end
97
+ def finalize_pending_tokens!; end
98
+ def finish!; end
99
+ def finish_or_find_next_block_if_incorrect!; end
100
+ def handle_closer_token(token); end
101
+ def handle_opener_token(token); end
102
+ def initial_state(token); end
103
+ def invoke_state_handler(token); end
104
+ def opener_token?(token); end
105
+ def opener_token_stack; end
106
+ def parse!; end
107
+ def pending_tokens; end
108
+ def pipe_token?(token); end
109
+
110
+ class << self
111
+ def [](*_arg0); end
112
+ def inspect; end
113
+ def members; end
114
+ def new(*_arg0); end
115
+ end
116
+ end
117
+
118
+ class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end
119
+ class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
120
+
121
+ class RSpec::Expectations::Configuration
122
+ def initialize; end
123
+
124
+ def add_should_and_should_not_to(*modules); end
125
+ def backtrace_formatter; end
126
+ def backtrace_formatter=(_arg0); end
127
+ def color?; end
128
+ def false_positives_handler; end
129
+ def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end
130
+ def include_chain_clauses_in_custom_matcher_descriptions?; end
131
+ def max_formatted_output_length=(length); end
132
+ def on_potential_false_positives; end
133
+ def on_potential_false_positives=(behavior); end
134
+ def reset_syntaxes_to_default; end
135
+ def strict_predicate_matchers; end
136
+ def strict_predicate_matchers=(flag); end
137
+ def strict_predicate_matchers?; end
138
+ def syntax; end
139
+ def syntax=(values); end
140
+ def warn_about_potential_false_positives=(boolean); end
141
+ def warn_about_potential_false_positives?; end
142
+ end
143
+
144
+ RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)
145
+
146
+ module RSpec::Expectations::Configuration::NullBacktraceFormatter
147
+ class << self
148
+ def format_backtrace(backtrace); end
149
+ end
150
+ end
151
+
152
+ module RSpec::Expectations::ExpectationHelper
153
+ class << self
154
+ def check_message(msg); end
155
+ def handle_failure(matcher, message, failure_message_method); end
156
+ def modern_matcher_from(matcher); end
157
+ def with_matcher(handler, matcher, message); end
158
+ end
159
+ end
160
+
161
+ class RSpec::Expectations::ExpectationNotMetError < ::Exception; end
162
+
163
+ class RSpec::Expectations::ExpectationTarget
164
+ include ::RSpec::Expectations::ExpectationTarget::InstanceMethods
165
+
166
+ def initialize(value); end
167
+
168
+ def target; end
169
+
170
+ class << self
171
+ def for(value, block); end
172
+ end
173
+ end
174
+
175
+ module RSpec::Expectations::ExpectationTarget::InstanceMethods
176
+ def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
177
+ def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
178
+ def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
179
+
180
+ private
181
+
182
+ def prevent_operator_matchers(verb); end
183
+ end
184
+
185
+ module RSpec::Expectations::ExpectationTarget::UndefinedValue; end
186
+
187
+ class RSpec::Expectations::FailureAggregator
188
+ def initialize(block_label, metadata); end
189
+
190
+ def aggregate; end
191
+ def block_label; end
192
+ def call(failure, options); end
193
+ def failures; end
194
+ def metadata; end
195
+ def other_errors; end
196
+
197
+ private
198
+
199
+ def assign_backtrace(failure); end
200
+ def notify_aggregated_failures; end
201
+ end
202
+
203
+ RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
204
+
205
+ class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
206
+ def initialize(matcher); end
207
+
208
+ class << self
209
+ def wrap(matcher); end
210
+ end
211
+ end
212
+
213
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
214
+ def failure_message; end
215
+ def failure_message_when_negated; end
216
+
217
+ class << self
218
+ def interface_matches?(matcher); end
219
+ end
220
+ end
221
+
222
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
223
+ def failure_message; end
224
+ def failure_message_when_negated; end
225
+
226
+ class << self
227
+ def interface_matches?(matcher); end
228
+ end
229
+ end
230
+
231
+ class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
232
+ def initialize(failure_aggregator); end
233
+
234
+ def aggregation_block_label; end
235
+ def aggregation_metadata; end
236
+ def all_exceptions; end
237
+ def exception_count_description; end
238
+ def failures; end
239
+ def message; end
240
+ def other_errors; end
241
+ def summary; end
242
+
243
+ private
244
+
245
+ def backtrace_line(line); end
246
+ def block_description; end
247
+ def enumerated(exceptions, index_offset); end
248
+ def enumerated_errors; end
249
+ def enumerated_failures; end
250
+ def exclusion_patterns; end
251
+ def format_backtrace(backtrace); end
252
+ def indentation; end
253
+ def indented(failure_message, index); end
254
+ def index_label(index); end
255
+ def longest_index_label_width; end
256
+ def pluralize(noun, count); end
257
+ def width_of_label(index); end
258
+ end
259
+
260
+ class RSpec::Expectations::NegativeExpectationHandler
261
+ class << self
262
+ def does_not_match?(matcher, actual, &block); end
263
+ def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
264
+ def opposite_should_method; end
265
+ def should_method; end
266
+ def verb; end
267
+ end
268
+ end
269
+
270
+ class RSpec::Expectations::PositiveExpectationHandler
271
+ class << self
272
+ def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
273
+ def opposite_should_method; end
274
+ def should_method; end
275
+ def verb; end
276
+ end
277
+ end
278
+
279
+ module RSpec::Expectations::Syntax
280
+ private
281
+
282
+ def default_should_host; end
283
+ def disable_expect(syntax_host = T.unsafe(nil)); end
284
+ def disable_should(syntax_host = T.unsafe(nil)); end
285
+ def enable_expect(syntax_host = T.unsafe(nil)); end
286
+ def enable_should(syntax_host = T.unsafe(nil)); end
287
+ def expect_enabled?(syntax_host = T.unsafe(nil)); end
288
+ def should_enabled?(syntax_host = T.unsafe(nil)); end
289
+ def warn_about_should!; end
290
+ def warn_about_should_unless_configured(method_name); end
291
+
292
+ class << self
293
+ def default_should_host; end
294
+ def disable_expect(syntax_host = T.unsafe(nil)); end
295
+ def disable_should(syntax_host = T.unsafe(nil)); end
296
+ def enable_expect(syntax_host = T.unsafe(nil)); end
297
+ def enable_should(syntax_host = T.unsafe(nil)); end
298
+ def expect_enabled?(syntax_host = T.unsafe(nil)); end
299
+ def should_enabled?(syntax_host = T.unsafe(nil)); end
300
+ def warn_about_should!; end
301
+ def warn_about_should_unless_configured(method_name); end
302
+ end
13
303
  end
304
+
305
+ module RSpec::Expectations::Version; end
306
+ RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String)
307
+
14
308
  module RSpec::Matchers
309
+ extend ::RSpec::Matchers::DSL
310
+
15
311
  def a_block_changing(*args, &block); end
16
312
  def a_block_outputting(*args, &block); end
17
313
  def a_block_raising(*args, &block); end
@@ -38,7 +334,7 @@ module RSpec::Matchers
38
334
  def a_value(*args, &block); end
39
335
  def a_value_between(*args, &block); end
40
336
  def a_value_within(*args, &block); end
41
- def aggregate_failures(label = nil, metadata = nil, &block); end
337
+ def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
42
338
  def all(expected); end
43
339
  def an_instance_of(*args, &block); end
44
340
  def an_object_eq_to(*args, &block); end
@@ -62,7 +358,7 @@ module RSpec::Matchers
62
358
  def be_nil; end
63
359
  def be_truthy; end
64
360
  def be_within(delta); end
65
- def change(receiver = nil, message = nil, &block); end
361
+ def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
66
362
  def changing(*args, &block); end
67
363
  def contain_exactly(*items); end
68
364
  def containing_exactly(*args, &block); end
@@ -78,7 +374,7 @@ module RSpec::Matchers
78
374
  def equal_to(*args, &block); end
79
375
  def exist(*args); end
80
376
  def existing(*args, &block); end
81
- def expect(value = nil, &block); end
377
+ def expect(value = T.unsafe(nil), &block); end
82
378
  def have_attributes(expected); end
83
379
  def having_attributes(*args, &block); end
84
380
  def include(*expected); end
@@ -87,30 +383,17 @@ module RSpec::Matchers
87
383
  def match_array(items); end
88
384
  def match_regex(*args, &block); end
89
385
  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
386
+ def output(expected = T.unsafe(nil)); end
387
+ def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
388
+ def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
94
389
  def raising(*args, &block); end
95
390
  def respond_to(*names); end
96
- def respond_to_missing?(method, *arg1); end
97
391
  def responding_to(*args, &block); end
98
- def satisfy(description = nil, &block); end
392
+ def satisfy(description = T.unsafe(nil), &block); end
99
393
  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
394
  def start_with(*expected); end
112
395
  def starting_with(*args, &block); end
113
- def throw_symbol(expected_symbol = nil, expected_arg = nil); end
396
+ def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
114
397
  def throwing(*args, &block); end
115
398
  def within(*args, &block); end
116
399
  def yield_control; end
@@ -121,628 +404,473 @@ module RSpec::Matchers
121
404
  def yielding_successive_args(*args, &block); end
122
405
  def yielding_with_args(*args, &block); end
123
406
  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
407
+
408
+ private
409
+
410
+ def method_missing(method, *args, &block); end
411
+ def respond_to_missing?(method, *_arg1); end
412
+
413
+ class << self
414
+ def alias_matcher(*args, &block); end
415
+ def clear_generated_description; end
416
+ def configuration; end
417
+ def generated_description; end
418
+ def is_a_describable_matcher?(obj); end
419
+ def is_a_matcher?(obj); end
420
+ def last_description; end
421
+ def last_expectation_handler; end
422
+ def last_expectation_handler=(_arg0); end
423
+ def last_matcher; end
424
+ def last_matcher=(_arg0); end
425
+ end
129
426
  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
427
+
428
+ class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
429
+ def initialize(base_matcher, description_block); end
430
+
431
+ def description; end
432
+ def failure_message; end
433
+ def failure_message_when_negated; end
434
+ def method_missing(*_arg0); end
145
435
  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
436
+
437
+ class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end
438
+
439
+ class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher
440
+ def does_not_match?(*args, &block); end
441
+ def failure_message; end
442
+ def failure_message_when_negated; end
443
+ def matches?(*args, &block); end
444
+
445
+ private
446
+
447
+ def optimal_failure_message(same, inverted); end
155
448
  end
156
- module RSpec::Matchers::BuiltIn
449
+
450
+ RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
451
+ RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp)
452
+ module RSpec::Matchers::BuiltIn; end
453
+
454
+ class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher
455
+ def initialize(matcher); end
456
+
457
+ def description; end
458
+ def does_not_match?(_actual); end
459
+ def failed_objects; end
460
+ def failure_message; end
461
+ def matcher; end
462
+
463
+ private
464
+
465
+ def add_new_line_if_needed(message); end
466
+ def failure_message_for_item(index, failure_message); end
467
+ def indent_multiline_message(message); end
468
+ def index_failed_objects; end
469
+ def initialize_copy(other); end
470
+ def iterable?; end
471
+ def match(_expected, _actual); end
157
472
  end
473
+
158
474
  class RSpec::Matchers::BuiltIn::BaseMatcher
475
+ include ::RSpec::Matchers::Composable
476
+ include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
477
+ include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
478
+
479
+ def initialize(expected = T.unsafe(nil)); end
480
+
159
481
  def actual; end
160
482
  def actual_formatted; end
161
- def assert_ivars(*expected_ivars); end
162
483
  def description; end
163
484
  def diffable?; end
164
485
  def expected; end
165
486
  def expected_formatted; end
166
487
  def expects_call_stack_jump?; end
167
- def initialize(expected = nil); end
168
488
  def match_unless_raises(*exceptions); end
169
489
  def matcher_name; end
170
- def matcher_name=(arg0); end
490
+ def matcher_name=(_arg0); end
171
491
  def matches?(actual); end
172
492
  def present_ivars; end
173
493
  def rescued_exception; end
174
- def self.matcher_name; end
175
- def self.underscore(camel_cased_word); end
176
494
  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
495
+
496
+ private
497
+
498
+ def assert_ivars(*expected_ivars); end
499
+
500
+ class << self
501
+ def matcher_name; end
502
+
503
+ private
504
+
505
+ def underscore(camel_cased_word); end
506
+ end
184
507
  end
508
+
185
509
  module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
186
510
  def failure_message; end
187
511
  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 strict_predicate_matchers; end
341
- def strict_predicate_matchers=(flag); end
342
- def strict_predicate_matchers?; end
343
- def syntax; end
344
- def syntax=(values); end
345
- def warn_about_potential_false_positives=(boolean); end
346
- def warn_about_potential_false_positives?; end
347
- end
348
- module RSpec::Expectations::Configuration::NullBacktraceFormatter
349
- def self.format_backtrace(backtrace); end
350
- end
351
- class InvalidName___Class_0x00___Differ_1
352
- end
353
- module RSpec::Expectations::ExpectationHelper
354
- def self.check_message(msg); end
355
- def self.handle_failure(matcher, message, failure_message_method); end
356
- def self.modern_matcher_from(matcher); end
357
- def self.with_matcher(handler, matcher, message); end
358
- end
359
- class RSpec::Expectations::PositiveExpectationHandler
360
- def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
361
- def self.opposite_should_method; end
362
- def self.should_method; end
363
- def self.verb; end
364
- end
365
- class RSpec::Expectations::NegativeExpectationHandler
366
- def self.does_not_match?(matcher, actual, &block); end
367
- def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
368
- def self.opposite_should_method; end
369
- def self.should_method; end
370
- def self.verb; end
371
- end
372
- class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator
373
- def initialize(matcher); end
374
- def self.wrap(matcher); end
512
+
513
+ class << self
514
+ def has_default_failure_messages?(matcher); end
515
+ end
375
516
  end
376
- class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter
377
- def failure_message; end
378
- def failure_message_when_negated; end
379
- def self.interface_matches?(matcher); end
517
+
518
+ module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
519
+ private
520
+
521
+ def improve_hash_formatting(inspect_string); end
522
+
523
+ class << self
524
+ def improve_hash_formatting(inspect_string); end
525
+ end
380
526
  end
381
- class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter
527
+
528
+ RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)
529
+
530
+ class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher
531
+ include ::RSpec::Matchers::BuiltIn::BeHelpers
532
+
533
+ def initialize(*args); end
534
+
535
+ def <(operand); end
536
+ def <=(operand); end
537
+ def ==(operand); end
538
+ def ===(operand); end
539
+ def =~(operand); end
540
+ def >(operand); end
541
+ def >=(operand); end
382
542
  def failure_message; end
383
543
  def failure_message_when_negated; end
384
- def self.interface_matches?(matcher); end
385
- end
386
- module RSpec::Expectations::Version
387
- end
388
- class RSpec::Expectations::ExpectationNotMetError < Exception
389
- end
390
- class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError
391
- def aggregation_block_label; end
392
- def aggregation_metadata; end
393
- def all_exceptions; end
394
- def backtrace_line(line); end
395
- def block_description; end
396
- def enumerated(exceptions, index_offset); end
397
- def enumerated_errors; end
398
- def enumerated_failures; end
399
- def exception_count_description; end
400
- def exclusion_patterns; end
401
- def failures; end
402
- def format_backtrace(backtrace); end
403
- def indentation; end
404
- def indented(failure_message, index); end
405
- def index_label(index); end
406
- def initialize(failure_aggregator); end
407
- def longest_index_label_width; end
408
- def message; end
409
- def other_errors; end
410
- def pluralize(noun, count); end
411
- def summary; end
412
- def width_of_label(index); end
413
- end
414
- class RSpec::Expectations::BlockSnippetExtractor
415
- def beginning_line_number; end
416
- def block_token_extractor; end
417
- def body_content_lines; end
418
- def file_path; end
419
- def initialize(proc, method_name); end
420
- def method_name; end
421
- def proc; end
422
- def raw_body_lines; end
423
- def raw_body_snippet; end
424
- def self.try_extracting_single_line_body_of(proc, method_name); end
425
- def source; end
426
- def source_location; end
427
- end
428
- class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError
429
- end
430
- class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error
431
- end
432
- class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error
433
- end
434
- class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct
435
- def after_beginning_of_args_state(token); end
436
- def after_beginning_of_body_state(token); end
437
- def after_method_call_state(token); end
438
- def after_opener_state(token); end
439
- def beginning_line_number; end
440
- def beginning_line_number=(_); end
441
- def block_locator; end
442
- def body_tokens; end
443
- def correct_block?(body_tokens); end
444
- def finalize_pending_tokens!; end
445
- def finish!; end
446
- def finish_or_find_next_block_if_incorrect!; end
447
- def handle_closer_token(token); end
448
- def handle_opener_token(token); end
449
- def initial_state(token); end
450
- def initialize(*arg0); end
451
- def invoke_state_handler(token); end
452
- def method_name; end
453
- def method_name=(_); end
454
- def opener_token?(token); end
455
- def opener_token_stack; end
456
- def parse!; end
457
- def pending_tokens; end
458
- def pipe_token?(token); end
459
- def self.[](*arg0); end
460
- def self.inspect; end
461
- def self.members; end
462
- def self.new(*arg0); end
463
- def source; end
464
- def source=(_); end
465
- def state; end
466
- end
467
- class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct
468
- def beginning_line_number; end
469
- def beginning_line_number=(_); end
470
- def block_body_node; end
471
- def block_wrapper_node; end
472
- def body_content_locations; end
473
- def candidate_block_wrapper_nodes; end
474
- def candidate_method_ident_nodes; end
475
- def method_call_location; end
476
- def method_ident_node; end
477
- def method_ident_node?(node); end
478
- def method_name; end
479
- def method_name=(_); end
480
- def self.[](*arg0); end
481
- def self.inspect; end
482
- def self.members; end
483
- def self.new(*arg0); end
484
- def source; end
485
- def source=(_); end
486
- end
487
- class RSpec::Expectations::FailureAggregator
488
- def aggregate; end
489
- def assign_backtrace(failure); end
490
- def block_label; end
491
- def call(failure, options); end
492
- def failures; end
493
- def initialize(block_label, metadata); end
494
- def metadata; end
495
- def notify_aggregated_failures; end
496
- def other_errors; end
544
+
545
+ private
546
+
547
+ def match(_, actual); end
497
548
  end
498
- class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher
549
+
550
+ class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
551
+ private
552
+
499
553
  def match(expected, actual); end
500
554
  end
501
- class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher
555
+
556
+ class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
502
557
  def description; end
558
+
559
+ private
560
+
503
561
  def match(expected, actual); end
504
562
  end
505
- class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher
506
- def comparable?; end
507
- def compare; end
563
+
564
+ class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher
565
+ def initialize(min, max); end
566
+
508
567
  def description; end
509
568
  def exclusive; end
510
569
  def failure_message; end
511
570
  def inclusive; end
512
- def initialize(min, max); end
513
571
  def matches?(actual); end
572
+
573
+ private
574
+
575
+ def comparable?; end
576
+ def compare; end
514
577
  def not_comparable_clause; end
515
578
  end
516
- class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher
517
- def failure_message; end
518
- def failure_message_when_negated; end
519
- def match(_, actual); end
520
- end
521
- class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher
579
+
580
+ class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
581
+ include ::RSpec::Matchers::BuiltIn::BeHelpers
582
+
583
+ def initialize(operand, operator); end
584
+
585
+ def description; end
586
+ def does_not_match?(actual); end
522
587
  def failure_message; end
523
588
  def failure_message_when_negated; end
524
- def match(_, actual); end
589
+ def matches?(actual); end
590
+
591
+ private
592
+
593
+ def perform_match(actual); end
525
594
  end
526
- class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher
595
+
596
+ class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher
527
597
  def failure_message; end
528
598
  def failure_message_when_negated; end
599
+
600
+ private
601
+
529
602
  def match(_, actual); end
530
603
  end
604
+
531
605
  module RSpec::Matchers::BuiltIn::BeHelpers
606
+ private
607
+
532
608
  def args_to_s; end
533
609
  def args_to_sentence; end
534
610
  def expected_to_sentence; end
535
611
  def inspected_args; end
536
612
  def parenthesize(string); end
537
613
  end
538
- class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher
539
- def <(operand); end
540
- def <=(operand); end
541
- def ==(operand); end
542
- def ===(operand); end
543
- def =~(operand); end
544
- def >(operand); end
545
- def >=(operand); end
614
+
615
+ class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher
546
616
  def failure_message; end
547
617
  def failure_message_when_negated; end
548
- def initialize(*args); end
618
+
619
+ private
620
+
549
621
  def match(_, actual); end
550
- include RSpec::Matchers::BuiltIn::BeHelpers
551
- end
552
- class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher
553
- def description; end
554
- def does_not_match?(actual); end
555
- def failure_message; end
556
- def failure_message_when_negated; end
557
- def initialize(operand, operator); end
558
- def matches?(actual); end
559
- def perform_match(actual); end
560
- include RSpec::Matchers::BuiltIn::BeHelpers
561
622
  end
562
- class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher
563
- def description; end
564
- def does_not_match?(actual, &block); end
565
- def expectation_of(value); end
566
- def failure_message; end
567
- def failure_message_expecting(value); end
568
- def failure_message_when_negated; end
569
- def failure_to_respond_explanation; end
570
- def initialize(method_name, *args, &block); end
571
- def matches?(actual, &block); end
572
- def method_description; end
573
- def predicate_accessible?; end
574
- def predicate_matches?(value = nil); end
575
- def predicate_method_name; end
576
- def predicate_result; end
577
- def private_predicate?; end
578
- def root; end
579
- def validity_message; end
580
- include RSpec::Matchers::BuiltIn::BeHelpers
581
- end
582
- class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate
583
- def predicate; end
584
- end
585
- class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate
623
+
624
+ class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate
625
+ private
626
+
586
627
  def failure_to_respond_explanation; end
587
628
  def predicate; end
588
629
  def predicate_accessible?; end
589
630
  def predicate_method_name; end
590
631
  def present_tense_predicate; end
591
632
  end
592
- class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher
593
- def description; end
633
+
634
+ RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp)
635
+
636
+ class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher
594
637
  def failure_message; end
595
638
  def failure_message_when_negated; end
639
+
640
+ private
641
+
642
+ def match(_, actual); end
643
+ end
644
+
645
+ class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher
596
646
  def initialize(delta); end
647
+
648
+ def description; end
649
+ def failure_message; end
650
+ def failure_message_when_negated; end
597
651
  def matches?(actual); end
652
+ def of(expected); end
653
+ def percent_of(expected); end
654
+
655
+ private
656
+
598
657
  def needs_expected; end
599
658
  def not_numeric_clause; end
600
659
  def numeric?; end
601
- def of(expected); end
602
- def percent_of(expected); end
603
660
  end
604
- class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher
661
+
662
+ module RSpec::Matchers::BuiltIn::CaptureStderr
663
+ class << self
664
+ def capture(block); end
665
+ def name; end
666
+ end
667
+ end
668
+
669
+ module RSpec::Matchers::BuiltIn::CaptureStdout
670
+ class << self
671
+ def capture(block); end
672
+ def name; end
673
+ end
674
+ end
675
+
676
+ class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
677
+ def capture(block); end
678
+ end
679
+
680
+ class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
681
+ def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
682
+
605
683
  def by(expected_delta); end
606
684
  def by_at_least(minimum); end
607
685
  def by_at_most(maximum); end
608
- def change_details; end
609
686
  def description; end
610
687
  def does_not_match?(event_proc); end
611
688
  def failure_message; end
612
689
  def failure_message_when_negated; end
613
690
  def from(value); end
614
- def initialize(receiver = nil, message = nil, &block); end
615
691
  def matches?(event_proc); end
692
+ def supports_block_expectations?; end
693
+ def to(value); end
694
+
695
+ private
696
+
697
+ def change_details; end
616
698
  def negative_failure_reason; end
617
699
  def perform_change(event_proc); end
618
700
  def positive_failure_reason; end
619
701
  def raise_block_syntax_error; end
620
- def supports_block_expectations?; end
702
+ end
703
+
704
+ class RSpec::Matchers::BuiltIn::ChangeDetails
705
+ def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
706
+
707
+ def actual_after; end
708
+ def actual_delta; end
709
+ def changed?; end
710
+ def perform_change(event_proc); end
711
+ def value_representation; end
712
+
713
+ private
714
+
715
+ def evaluate_value_proc; end
716
+ def extract_value_block_snippet; end
717
+ def message_notation(receiver, message); end
718
+ end
719
+
720
+ class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
721
+ def initialize(change_details, expected_before); end
722
+
723
+ def does_not_match?(event_proc); end
724
+ def failure_message_when_negated; end
621
725
  def to(value); end
726
+
727
+ private
728
+
729
+ def change_description; end
622
730
  end
623
- class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher
624
- def description; end
625
- def does_not_match?(_event_proc); end
626
- def failure_message; end
627
- def failure_reason; end
731
+
732
+ class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher
628
733
  def initialize(change_details, expected_delta, relativity, &comparer); end
629
- def matches?(event_proc); end
630
- def supports_block_expectations?; end
631
- end
632
- class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher
633
- def after_value_failure; end
634
- def before_value_failure; end
734
+
635
735
  def description; end
636
- def did_change_failure; end
637
- def did_not_change_failure; end
736
+ def does_not_match?(_event_proc); end
638
737
  def failure_message; end
639
- def initialize(change_details, from, to); end
640
738
  def matches?(event_proc); end
641
- def matches_after?; end
642
- def not_given_a_block_failure; end
643
- def perform_change(event_proc); end
644
739
  def supports_block_expectations?; end
740
+
741
+ private
742
+
743
+ def failure_reason; end
645
744
  end
646
- class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
647
- def change_description; end
648
- def does_not_match?(event_proc); end
649
- def failure_message_when_negated; end
650
- def initialize(change_details, expected_before); end
651
- def to(value); end
652
- end
653
- class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
654
- def change_description; end
745
+
746
+ class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
747
+ def initialize(change_details, expected_after); end
748
+
655
749
  def does_not_match?(_event_proc); end
656
750
  def from(value); end
657
- def initialize(change_details, expected_after); end
658
- end
659
- class RSpec::Matchers::BuiltIn::ChangeDetails
660
- def actual_after; end
661
- def actual_delta; end
662
- def changed?; end
663
- def evaluate_value_proc; end
664
- def extract_value_block_snippet; end
665
- def initialize(matcher_name, receiver = nil, message = nil, &block); end
666
- def message_notation(receiver, message); end
667
- def perform_change(event_proc); end
668
- def value_representation; end
751
+
752
+ private
753
+
754
+ def change_description; end
669
755
  end
670
- class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher
671
- def compound_failure_message; end
756
+
757
+ class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher
758
+ def initialize(matcher_1, matcher_2); end
759
+
672
760
  def description; end
673
761
  def diffable?; end
674
- def diffable_matcher_list; end
675
- def diffable_matcher_list_for(matcher); end
676
762
  def does_not_match?(_actual); end
677
763
  def evaluator; end
678
764
  def expected; end
679
765
  def expects_call_stack_jump?; end
766
+ def matcher_1; end
767
+ def matcher_2; end
768
+ def supports_block_expectations?; end
769
+
770
+ protected
771
+
772
+ def diffable_matcher_list; end
773
+
774
+ private
775
+
776
+ def compound_failure_message; end
777
+ def diffable_matcher_list_for(matcher); end
680
778
  def indent_multiline_message(message); end
681
- def initialize(matcher_1, matcher_2); end
682
779
  def initialize_copy(other); end
683
780
  def match(_expected, actual); end
684
- def matcher_1; end
685
781
  def matcher_1_matches?; end
686
- def matcher_2; end
687
782
  def matcher_2_matches?; end
688
783
  def matcher_is_diffable?(matcher); end
689
784
  def matcher_supports_block_expectations?(matcher); end
690
- def supports_block_expectations?; end
691
785
  end
692
- class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
693
- def initialize(actual, *arg1); end
694
- def matcher_matches?(matcher); end
786
+
787
+ class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound
788
+ def failure_message; end
789
+
790
+ private
791
+
792
+ def conjunction; end
793
+ def match(*_arg0); end
695
794
  end
795
+
696
796
  class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
697
797
  def initialize(actual, matcher_1, matcher_2); end
798
+
799
+ def matcher_matches?(matcher); end
800
+
801
+ private
802
+
698
803
  def inner_matcher_block(outer_args); end
804
+ def order_block_matchers; end
805
+
806
+ class << self
807
+ def matcher_expects_call_stack_jump?(matcher); end
808
+ end
809
+ end
810
+
811
+ class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
812
+ def failure_message; end
813
+
814
+ private
815
+
816
+ def conjunction; end
817
+ def match(*_arg0); end
818
+ end
819
+
820
+ class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
821
+ def initialize(actual, *_arg1); end
822
+
699
823
  def matcher_matches?(matcher); end
700
- def order_block_matchers; end
701
- def self.matcher_expects_call_stack_jump?(matcher); end
702
- end
703
- class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound
704
- def conjunction; end
705
- def failure_message; end
706
- def match(*arg0); end
707
824
  end
708
- class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound
709
- def conjunction; end
825
+
826
+ class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher
827
+ def description; end
710
828
  def failure_message; end
711
- def match(*arg0); end
712
- end
713
- class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher
829
+ def failure_message_when_negated; end
830
+
831
+ private
832
+
714
833
  def actual_collection_line; end
715
834
  def best_solution; end
716
835
  def convert_actual_to_an_array; end
717
- def describe_collection(collection, surface_descriptions = nil); end
718
- def description; end
836
+ def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
719
837
  def expected_collection_line; end
720
838
  def extra_elements_line; end
721
839
  def extra_items; end
722
- def failure_message; end
723
- def failure_message_when_negated; end
724
840
  def generate_failure_message; end
725
841
  def match(_expected, _actual); end
726
842
  def match_when_sorted?; end
727
- def message_line(prefix, collection, surface_descriptions = nil); end
843
+ def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
728
844
  def missing_elements_line; end
729
845
  def missing_items; end
730
846
  def pairings_maximizer; end
731
847
  def safe_sort(array); end
732
848
  def to_a_disallowed?(object); end
733
849
  end
850
+
734
851
  class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
852
+ def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
853
+
735
854
  def actual_to_expected_matched_indexes; end
855
+ def expected_to_actual_matched_indexes; end
856
+ def find_best_solution; end
857
+ def solution; end
858
+
859
+ private
860
+
736
861
  def apply_pairing_to(indeterminates, original_matches, other_list_index); end
737
862
  def best_solution_for_pairing(expected_index, actual_index); end
738
863
  def categorize_indexes(indexes_to_categorize, other_indexes); end
739
- def expected_to_actual_matched_indexes; end
740
- def find_best_solution; end
741
- def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
742
864
  def reciprocal_single_match?(matches, index, other_list); end
743
- def solution; end
744
865
  end
745
- class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct
866
+
867
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
868
+ class << self
869
+ def worse_than?(_other); end
870
+ end
871
+ end
872
+
873
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
746
874
  def +(derived_candidate_solution); end
747
875
  def candidate?; end
748
876
  def ideal?; end
@@ -750,132 +878,198 @@ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < St
750
878
  def indeterminate_actual_indexes=(_); end
751
879
  def indeterminate_expected_indexes; end
752
880
  def indeterminate_expected_indexes=(_); end
753
- def self.[](*arg0); end
754
- def self.inspect; end
755
- def self.members; end
756
- def self.new(*arg0); end
757
881
  def unmatched_actual_indexes; end
758
882
  def unmatched_actual_indexes=(_); end
759
883
  def unmatched_expected_indexes; end
760
884
  def unmatched_expected_indexes=(_); end
761
885
  def unmatched_item_count; end
762
886
  def worse_than?(other); end
887
+
888
+ class << self
889
+ def [](*_arg0); end
890
+ def inspect; end
891
+ def members; end
892
+ def new(*_arg0); end
893
+ end
763
894
  end
764
- class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
765
- def self.worse_than?(_other); end
895
+
896
+ module RSpec::Matchers::BuiltIn::CountExpectation
897
+ def at_least(number); end
898
+ def at_most(number); end
899
+ def exactly(number); end
900
+ def once; end
901
+ def thrice; end
902
+ def times; end
903
+ def twice; end
904
+
905
+ protected
906
+
907
+ def count_expectation_type; end
908
+ def expected_count; end
909
+
910
+ private
911
+
912
+ def count_constraint_to_number(n); end
913
+ def count_expectation_description; end
914
+ def count_failure_reason(action); end
915
+ def cover?(count, number); end
916
+ def expected_count_matches?(actual_count); end
917
+ def has_expected_count?; end
918
+ def human_readable_count(count); end
919
+ def human_readable_expectation_type; end
920
+ def raise_impossible_count_expectation(count); end
921
+ def raise_unsupported_count_expectation; end
922
+ def set_expected_count(relativity, n); end
923
+ def unsupported_count_expectation?(relativity); end
766
924
  end
767
- class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher
768
- def does_not_match?(range); end
925
+
926
+ class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
769
927
  def initialize(*expected); end
928
+
929
+ def does_not_match?(range); end
770
930
  def matches?(range); end
771
931
  end
772
- class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher
932
+
933
+ class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher
934
+ include ::RSpec::Matchers::BuiltIn::BeHelpers
935
+
936
+ def initialize(method_name, *args, &block); end
937
+
773
938
  def description; end
939
+ def does_not_match?(actual, &block); end
774
940
  def failure_message; end
775
- def initialize(*expected); end
776
- def match(_expected, actual); end
777
- def subsets_comparable?; end
778
- end
779
- class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith
780
- def element_matches?; end
781
- def subset_matches?; end
941
+ def failure_message_when_negated; end
942
+ def matches?(actual, &block); end
943
+
944
+ private
945
+
946
+ def expectation_of(value); end
947
+ def failure_message_expecting(value); end
948
+ def failure_to_respond_explanation; end
949
+ def method_description; end
950
+ def predicate_accessible?; end
951
+ def predicate_matches?(value = T.unsafe(nil)); end
952
+ def predicate_method_name; end
953
+ def predicate_result; end
954
+ def private_predicate?; end
955
+ def root; end
956
+ def validity_message; end
782
957
  end
783
- class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith
958
+
959
+ class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
960
+ private
961
+
784
962
  def element_matches?; end
785
963
  def subset_matches?; end
786
964
  end
787
- class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher
965
+
966
+ class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher
788
967
  def description; end
789
968
  def diffable?; end
790
969
  def failure_message; end
791
970
  def failure_message_when_negated; end
971
+
972
+ private
973
+
792
974
  def match(expected, actual); end
793
975
  end
794
- class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher
976
+
977
+ class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher
795
978
  def diffable?; end
796
979
  def failure_message; end
797
980
  def failure_message_when_negated; end
981
+
982
+ private
983
+
798
984
  def match(expected, actual); end
799
985
  end
800
- class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher
801
- def actual_inspected; end
802
- def detailed_failure_message; end
986
+
987
+ class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher
803
988
  def diffable?; end
804
- def expected_is_a_literal_singleton?; end
805
989
  def failure_message; end
806
990
  def failure_message_when_negated; end
991
+
992
+ private
993
+
994
+ def actual_inspected; end
995
+ def detailed_failure_message; end
996
+ def expected_is_a_literal_singleton?; end
807
997
  def inspect_object(o); end
808
998
  def match(expected, actual); end
809
999
  def simple_failure_message; end
810
1000
  end
811
- class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher
1001
+
1002
+ RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array)
1003
+
1004
+ class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher
1005
+ def initialize(*expected); end
1006
+
812
1007
  def does_not_match?(actual); end
813
1008
  def failure_message; end
814
1009
  def failure_message_when_negated; end
815
- def initialize(*expected); end
816
1010
  def matches?(actual); end
817
1011
  end
818
- class Anonymous_Struct_2 < Struct
819
- def actual; end
820
- def actual=(_); end
821
- def expected; end
822
- def expected=(_); end
823
- def self.[](*arg0); end
824
- def self.inspect; end
825
- def self.members; end
826
- def self.new(*arg0); end
827
- end
828
- class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_2
1012
+
1013
+ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct
829
1014
  def actual_exists?; end
1015
+ def valid_test?; end
1016
+ def validity_message; end
1017
+
1018
+ private
1019
+
830
1020
  def deprecated(predicate, actual); end
831
1021
  def existence_values; end
832
1022
  def predicates; end
833
1023
  def uniq_truthy_values; end
834
- def valid_test?; end
835
- def validity_message; end
836
1024
  end
837
- class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher
1025
+
1026
+ class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate
1027
+ private
1028
+
1029
+ def predicate; end
1030
+ end
1031
+
1032
+ RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp)
1033
+
1034
+ class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher
1035
+ def initialize(expected); end
1036
+
838
1037
  def actual; end
839
- def actual_has_attribute?(attribute_key, attribute_value); end
840
- def cache_all_values; end
841
1038
  def description; end
842
1039
  def diffable?; end
843
1040
  def does_not_match?(actual); end
844
1041
  def failure_message; end
845
1042
  def failure_message_when_negated; end
846
- def formatted_values; end
847
- def initialize(expected); end
848
1043
  def matches?(actual); end
1044
+ def respond_to_failed; end
1045
+
1046
+ private
1047
+
1048
+ def actual_has_attribute?(attribute_key, attribute_value); end
1049
+ def cache_all_values; end
1050
+ def formatted_values; end
849
1051
  def perform_match(predicate); end
850
1052
  def respond_to_attributes?; end
851
- def respond_to_failed; end
852
1053
  def respond_to_failure_message_or; end
853
1054
  def respond_to_matcher; end
854
1055
  end
855
- module RSpec::Matchers::BuiltIn::CountExpectation
856
- def at_least(number); end
857
- def at_most(number); end
858
- def count_constraint_to_number(n); end
859
- def count_expectation_description; end
860
- def count_expectation_type; end
861
- def count_failure_reason(action); end
862
- def cover?(count, number); end
863
- def exactly(number); end
864
- def expected_count; end
865
- def expected_count_matches?(actual_count); end
866
- def has_expected_count?; end
867
- def human_readable_count(count); end
868
- def human_readable_expectation_type; end
869
- def once; end
870
- def raise_impossible_count_expectation(count); end
871
- def raise_unsupported_count_expectation; end
872
- def set_expected_count(relativity, n); end
873
- def thrice; end
874
- def times; end
875
- def twice; end
876
- def unsupported_count_expectation?(relativity); end
877
- end
878
- class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
1056
+
1057
+ class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher
1058
+ include ::RSpec::Matchers::BuiltIn::CountExpectation
1059
+
1060
+ def initialize(*expecteds); end
1061
+
1062
+ def description; end
1063
+ def diffable?; end
1064
+ def does_not_match?(actual); end
1065
+ def expected; end
1066
+ def expecteds; end
1067
+ def failure_message; end
1068
+ def failure_message_when_negated; end
1069
+ def matches?(actual); end
1070
+
1071
+ private
1072
+
879
1073
  def actual_collection_includes?(expected_item); end
880
1074
  def actual_hash_has_key?(expected_key); end
881
1075
  def actual_hash_includes?(expected_key, expected_value); end
@@ -886,53 +1080,41 @@ class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
886
1080
  def convert_to_hash?(obj); end
887
1081
  def count_enumerable(expected_item); end
888
1082
  def count_inclusions; end
889
- def description; end
890
1083
  def diff_would_wrongly_highlight_matched_item?; end
891
- def diffable?; end
892
- def does_not_match?(actual); end
893
1084
  def excluded_from_actual; end
894
- def expected; end
895
- def expecteds; end
896
- def failure_message; end
897
- def failure_message_when_negated; end
898
1085
  def format_failure_message(preposition); end
899
- def initialize(*expecteds); end
900
- def matches?(actual); end
901
1086
  def perform_match(&block); end
902
1087
  def readable_list_of(items); end
903
- include RSpec::Matchers::BuiltIn::CountExpectation
904
- end
905
- class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher
906
- def add_new_line_if_needed(message); end
907
- def description; end
908
- def does_not_match?(_actual); end
909
- def failed_objects; end
910
- def failure_message; end
911
- def failure_message_for_item(index, failure_message); end
912
- def indent_multiline_message(message); end
913
- def index_failed_objects; end
914
- def initialize(matcher); end
915
- def initialize_copy(other); end
916
- def iterable?; end
917
- def match(_expected, _actual); end
918
- def matcher; end
919
1088
  end
920
- class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher
921
- def can_safely_call_match?(expected, actual); end
1089
+
1090
+ class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher
1091
+ def initialize(expected); end
1092
+
922
1093
  def description; end
923
1094
  def diffable?; end
924
- def initialize(expected); end
1095
+ def with_captures(*captures); end
1096
+
1097
+ private
1098
+
1099
+ def can_safely_call_match?(expected, actual); end
925
1100
  def match(expected, actual); end
926
1101
  def match_captures(expected, actual); end
927
- def with_captures(*captures); end
928
1102
  end
929
- class RSpec::Matchers::BuiltIn::ReliableMatchData
930
- def captures; end
931
- def initialize(match_data); end
932
- def match_data; end
933
- def names; end
1103
+
1104
+ class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
1105
+ def __delegate_operator(actual, operator, expected); end
934
1106
  end
1107
+
1108
+ module RSpec::Matchers::BuiltIn::NullCapture
1109
+ class << self
1110
+ def capture(_block); end
1111
+ def name; end
1112
+ end
1113
+ end
1114
+
935
1115
  class RSpec::Matchers::BuiltIn::OperatorMatcher
1116
+ def initialize(actual); end
1117
+
936
1118
  def !=(_expected); end
937
1119
  def !~(_expected); end
938
1120
  def <(expected); end
@@ -943,85 +1125,76 @@ class RSpec::Matchers::BuiltIn::OperatorMatcher
943
1125
  def >(expected); end
944
1126
  def >=(expected); end
945
1127
  def description; end
946
- def eval_match(actual, operator, expected); end
947
1128
  def fail_with_message(message); end
1129
+
1130
+ private
1131
+
1132
+ def eval_match(actual, operator, expected); end
948
1133
  def has_non_generic_implementation_of?(op); end
949
- def initialize(actual); end
950
- def self.get(klass, operator); end
951
- def self.register(klass, operator, matcher); end
952
- def self.registry; end
953
- def self.unregister(klass, operator); end
954
- def self.use_custom_matcher_or_delegate(operator); end
955
- end
956
- class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
957
- def __delegate_operator(actual, operator, expected); end
958
- end
959
- class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
960
- def __delegate_operator(actual, operator, expected); end
1134
+
1135
+ class << self
1136
+ def get(klass, operator); end
1137
+ def register(klass, operator, matcher); end
1138
+ def registry; end
1139
+ def unregister(klass, operator); end
1140
+ def use_custom_matcher_or_delegate(operator); end
1141
+ end
961
1142
  end
962
- class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher
963
- def actual_output_description; end
964
- def captured?; end
1143
+
1144
+ class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
1145
+ def initialize(expected); end
1146
+
965
1147
  def description; end
966
1148
  def diffable?; end
967
1149
  def does_not_match?(block); end
968
1150
  def failure_message; end
969
1151
  def failure_message_when_negated; end
970
- def initialize(expected); end
971
1152
  def matches?(block); end
972
- def negative_failure_reason; end
973
- def positive_failure_reason; end
974
1153
  def supports_block_expectations?; end
975
1154
  def to_stderr; end
976
1155
  def to_stderr_from_any_process; end
977
1156
  def to_stdout; end
978
1157
  def to_stdout_from_any_process; end
1158
+
1159
+ private
1160
+
1161
+ def actual_output_description; end
1162
+ def captured?; end
1163
+ def negative_failure_reason; end
1164
+ def positive_failure_reason; end
979
1165
  end
980
- module RSpec::Matchers::BuiltIn::NullCapture
981
- def self.capture(_block); end
982
- def self.name; end
983
- end
984
- module RSpec::Matchers::BuiltIn::CaptureStdout
985
- def self.capture(block); end
986
- def self.name; end
987
- end
988
- module RSpec::Matchers::BuiltIn::CaptureStderr
989
- def self.capture(block); end
990
- def self.name; end
991
- end
992
- class Anonymous_Struct_3 < Struct
993
- def name; end
994
- def name=(_); end
995
- def self.[](*arg0); end
996
- def self.inspect; end
997
- def self.members; end
998
- def self.new(*arg0); end
999
- def stream; end
1000
- def stream=(_); end
1001
- end
1002
- class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_3
1003
- def capture(block); end
1166
+
1167
+ class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
1168
+ def __delegate_operator(actual, operator, expected); end
1004
1169
  end
1170
+
1005
1171
  class RSpec::Matchers::BuiltIn::RaiseError
1006
- def block_matches?; end
1172
+ include ::RSpec::Matchers::Composable
1173
+
1174
+ def initialize(expected_error_or_message, expected_message, &block); end
1175
+
1007
1176
  def description; end
1008
1177
  def does_not_match?(given_proc); end
1178
+ def expects_call_stack_jump?; end
1179
+ def failure_message; end
1180
+ def failure_message_when_negated; end
1181
+ def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
1182
+ def supports_block_expectations?; end
1183
+ def with_message(expected_message); end
1184
+
1185
+ private
1186
+
1187
+ def block_matches?; end
1009
1188
  def error_and_message_match?; end
1010
1189
  def eval_block; end
1011
1190
  def expectation_matched?; end
1012
1191
  def expected_error; end
1013
1192
  def expecting_specific_exception?; end
1014
- def expects_call_stack_jump?; end
1015
- def failure_message; end
1016
- def failure_message_when_negated; end
1017
1193
  def format_backtrace(backtrace); end
1018
1194
  def given_error; end
1019
1195
  def handle_warning(message); end
1020
- def initialize(expected_error_or_message, expected_message, &block); end
1021
- def matches?(given_proc, negative_expectation = nil, &block); end
1022
1196
  def raise_message_already_set; end
1023
1197
  def ready_to_eval_block?; end
1024
- def supports_block_expectations?; end
1025
1198
  def verify_message; end
1026
1199
  def warn_about_bare_error!; end
1027
1200
  def warn_about_bare_error?; end
@@ -1030,10 +1203,24 @@ class RSpec::Matchers::BuiltIn::RaiseError
1030
1203
  def warn_about_nil_error?; end
1031
1204
  def warn_for_negative_false_positives!; end
1032
1205
  def warning; end
1033
- def with_message(expected_message); end
1034
- include RSpec::Matchers::Composable
1035
1206
  end
1036
- class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher
1207
+
1208
+ RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object)
1209
+
1210
+ class RSpec::Matchers::BuiltIn::ReliableMatchData
1211
+ def initialize(match_data); end
1212
+
1213
+ def captures; end
1214
+ def names; end
1215
+
1216
+ protected
1217
+
1218
+ def match_data; end
1219
+ end
1220
+
1221
+ class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
1222
+ def initialize(*names); end
1223
+
1037
1224
  def and_any_keywords; end
1038
1225
  def and_keywords(*keywords); end
1039
1226
  def and_unlimited_arguments; end
@@ -1043,106 +1230,345 @@ class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatche
1043
1230
  def does_not_match?(actual); end
1044
1231
  def failure_message; end
1045
1232
  def failure_message_when_negated; end
1046
- def find_failing_method_names(actual, filter_method); end
1047
1233
  def ignoring_method_signature_failure!; end
1048
- def initialize(*names); end
1049
1234
  def matches?(actual); end
1050
- def matches_arity?(actual, name); end
1051
- def pp_names; end
1052
1235
  def with(n); end
1053
1236
  def with_any_keywords; end
1237
+ def with_keywords(*keywords); end
1238
+ def with_unlimited_arguments; end
1239
+
1240
+ private
1241
+
1242
+ def find_failing_method_names(actual, filter_method); end
1243
+ def matches_arity?(actual, name); end
1244
+ def pp_names; end
1054
1245
  def with_arity; end
1055
1246
  def with_arity_string; end
1056
- def with_keywords(*keywords); end
1057
1247
  def with_keywords_string; end
1058
- def with_unlimited_arguments; end
1059
1248
  end
1249
+
1060
1250
  class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
1061
1251
  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
1252
+
1062
1253
  def matches?(actual, name); end
1063
1254
  def method_signature_for(actual, name); end
1064
1255
  def verifier_for(actual, name); end
1065
1256
  end
1066
- class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher
1067
- def block_representation; end
1257
+
1258
+ class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
1259
+ def initialize(description = T.unsafe(nil), &block); end
1260
+
1068
1261
  def description; end
1069
- def extract_block_snippet; end
1070
1262
  def failure_message; end
1071
1263
  def failure_message_when_negated; end
1072
- def initialize(description = nil, &block); end
1073
1264
  def matches?(actual, &block); end
1265
+
1266
+ private
1267
+
1268
+ def block_representation; end
1269
+ def extract_block_snippet; end
1270
+ end
1271
+
1272
+ class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher
1273
+ def initialize(change_details, from, to); end
1274
+
1275
+ def description; end
1276
+ def failure_message; end
1277
+ def matches?(event_proc); end
1278
+ def supports_block_expectations?; end
1279
+
1280
+ private
1281
+
1282
+ def after_value_failure; end
1283
+ def before_value_failure; end
1284
+ def did_change_failure; end
1285
+ def did_not_change_failure; end
1286
+ def matches_after?; end
1287
+ def not_given_a_block_failure; end
1288
+ def perform_change(event_proc); end
1289
+ end
1290
+
1291
+ RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
1292
+ RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith
1293
+
1294
+ class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher
1295
+ def initialize(*expected); end
1296
+
1297
+ def description; end
1298
+ def failure_message; end
1299
+
1300
+ private
1301
+
1302
+ def match(_expected, actual); end
1303
+ def subsets_comparable?; end
1304
+ end
1305
+
1306
+ class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
1307
+ private
1308
+
1309
+ def element_matches?; end
1310
+ def subset_matches?; end
1074
1311
  end
1312
+
1075
1313
  class RSpec::Matchers::BuiltIn::ThrowSymbol
1076
- def actual_result; end
1077
- def caught; end
1314
+ include ::RSpec::Matchers::Composable
1315
+
1316
+ def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
1317
+
1078
1318
  def description; end
1079
1319
  def does_not_match?(given_proc); end
1080
- def expected(symbol_desc = nil); end
1081
1320
  def expects_call_stack_jump?; end
1082
1321
  def failure_message; end
1083
1322
  def failure_message_when_negated; end
1084
- def initialize(expected_symbol = nil, expected_arg = nil); end
1085
1323
  def matches?(given_proc); end
1086
1324
  def supports_block_expectations?; end
1325
+
1326
+ private
1327
+
1328
+ def actual_result; end
1329
+ def caught; end
1330
+ def expected(symbol_desc = T.unsafe(nil)); end
1087
1331
  def throw_description(symbol, arg); end
1088
- include RSpec::Matchers::Composable
1089
1332
  end
1333
+
1334
+ class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher
1335
+ include ::RSpec::Matchers::BuiltIn::CountExpectation
1336
+
1337
+ def does_not_match?(block); end
1338
+ def failure_message; end
1339
+ def failure_message_when_negated; end
1340
+ def matches?(block); end
1341
+ def supports_block_expectations?; end
1342
+
1343
+ private
1344
+
1345
+ def failure_reason; end
1346
+ end
1347
+
1090
1348
  class RSpec::Matchers::BuiltIn::YieldProbe
1349
+ def initialize(block, &callback); end
1350
+
1091
1351
  def assert_used!; end
1092
1352
  def assert_valid_expect_block!; end
1093
1353
  def has_block?; end
1094
- def initialize(block, &callback); end
1095
1354
  def num_yields; end
1096
- def num_yields=(arg0); end
1355
+ def num_yields=(_arg0); end
1097
1356
  def probe; end
1098
- def self.probe(block, &callback); end
1099
1357
  def single_yield_args; end
1100
1358
  def to_proc; end
1101
1359
  def yielded_args; end
1102
- def yielded_args=(arg0); end
1360
+ def yielded_args=(_arg0); end
1103
1361
  def yielded_once?(matcher_name); end
1362
+
1363
+ class << self
1364
+ def probe(block, &callback); end
1365
+ end
1104
1366
  end
1105
- class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher
1367
+
1368
+ class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
1369
+ def initialize(*args); end
1370
+
1371
+ def description; end
1106
1372
  def does_not_match?(block); end
1107
1373
  def failure_message; end
1108
1374
  def failure_message_when_negated; end
1109
- def failure_reason; end
1110
1375
  def matches?(block); end
1111
1376
  def supports_block_expectations?; end
1112
- include RSpec::Matchers::BuiltIn::CountExpectation
1377
+
1378
+ private
1379
+
1380
+ def expected_arg_description; end
1381
+ def negative_failure_reason; end
1382
+ def positive_failure_reason; end
1113
1383
  end
1114
- class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1384
+
1385
+ class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
1386
+ def initialize(*args); end
1387
+
1388
+ def description; end
1115
1389
  def does_not_match?(block); end
1116
1390
  def failure_message; end
1117
1391
  def failure_message_when_negated; end
1118
1392
  def matches?(block); end
1119
- def negative_failure_reason; end
1120
- def positive_failure_reason; end
1121
1393
  def supports_block_expectations?; end
1122
- end
1123
- class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1394
+
1395
+ private
1396
+
1124
1397
  def all_args_match?; end
1125
1398
  def args_currently_match?; end
1126
- def description; end
1127
- def does_not_match?(block); end
1128
1399
  def expected_arg_description; end
1129
- def failure_message; end
1130
- def failure_message_when_negated; end
1131
- def initialize(*args); end
1132
- def matches?(block); end
1133
1400
  def negative_failure_reason; end
1134
1401
  def positive_failure_reason; end
1135
- def supports_block_expectations?; end
1136
1402
  end
1137
- class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1138
- def description; end
1403
+
1404
+ class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
1139
1405
  def does_not_match?(block); end
1140
- def expected_arg_description; end
1141
1406
  def failure_message; end
1142
1407
  def failure_message_when_negated; end
1143
- def initialize(*args); end
1144
1408
  def matches?(block); end
1409
+ def supports_block_expectations?; end
1410
+
1411
+ private
1412
+
1145
1413
  def negative_failure_reason; end
1146
1414
  def positive_failure_reason; end
1415
+ end
1416
+
1417
+ module RSpec::Matchers::Composable
1418
+ def &(matcher); end
1419
+ def ===(value); end
1420
+ def and(matcher); end
1421
+ def or(matcher); end
1422
+ def |(matcher); end
1423
+
1424
+ private
1425
+
1426
+ def description_of(object); end
1427
+ def should_enumerate?(item); end
1428
+ def surface_descriptions_in(item); end
1429
+ def unreadable_io?(object); end
1430
+ def values_match?(expected, actual); end
1431
+ def with_matchers_cloned(object); end
1432
+
1433
+ class << self
1434
+ def should_enumerate?(item); end
1435
+ def surface_descriptions_in(item); end
1436
+ def unreadable_io?(object); end
1437
+ end
1438
+ end
1439
+
1440
+ class RSpec::Matchers::Composable::DescribableItem < ::Struct
1441
+ def inspect; end
1442
+ def item; end
1443
+ def item=(_); end
1444
+ def pretty_print(pp); end
1445
+
1446
+ class << self
1447
+ def [](*_arg0); end
1448
+ def inspect; end
1449
+ def members; end
1450
+ def new(*_arg0); end
1451
+ end
1452
+ end
1453
+
1454
+ module RSpec::Matchers::DSL
1455
+ def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
1456
+ def define(name, &declarations); end
1457
+ def define_negated_matcher(negated_name, base_name, &description_override); end
1458
+ def matcher(name, &declarations); end
1459
+
1460
+ private
1461
+
1462
+ def warn_about_block_args(name, declarations); end
1463
+ end
1464
+
1465
+ module RSpec::Matchers::DSL::DefaultImplementations
1466
+ include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
1467
+
1468
+ def description; end
1469
+ def diffable?; end
1470
+ def expects_call_stack_jump?; end
1147
1471
  def supports_block_expectations?; end
1472
+
1473
+ private
1474
+
1475
+ def chained_method_clause_sentences; end
1476
+ end
1477
+
1478
+ module RSpec::Matchers::DSL::Macros
1479
+ def chain(method_name, *attr_names, &definition); end
1480
+ def description(&definition); end
1481
+ def diffable; end
1482
+ def failure_message(&definition); end
1483
+ def failure_message_when_negated(&definition); end
1484
+ def match(options = T.unsafe(nil), &match_block); end
1485
+ def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
1486
+ def match_when_negated(options = T.unsafe(nil), &match_block); end
1487
+ def supports_block_expectations; end
1488
+
1489
+ private
1490
+
1491
+ def assign_attributes(attr_names); end
1492
+ def define_user_override(method_name, user_def, &our_def); end
1493
+ end
1494
+
1495
+ module RSpec::Matchers::DSL::Macros::Deprecated
1496
+ def failure_message_for_should(&definition); end
1497
+ def failure_message_for_should_not(&definition); end
1498
+ def match_for_should(&definition); end
1499
+ def match_for_should_not(&definition); end
1500
+ end
1501
+
1502
+ RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc)
1503
+
1504
+ class RSpec::Matchers::DSL::Matcher
1505
+ include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
1506
+ include ::RSpec::Matchers::DSL::DefaultImplementations
1507
+ include ::RSpec::Matchers
1508
+ include ::RSpec::Matchers::Composable
1509
+ extend ::RSpec::Matchers::DSL::Macros
1510
+ extend ::RSpec::Matchers::DSL::Macros::Deprecated
1511
+
1512
+ def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
1513
+
1514
+ def actual; end
1515
+ def block_arg; end
1516
+ def expected; end
1517
+ def expected_as_array; end
1518
+ def inspect; end
1519
+ def name; end
1520
+ def rescued_exception; end
1521
+
1522
+ private
1523
+
1524
+ def actual_arg_for(block); end
1525
+ def method_missing(method, *args, &block); end
1526
+ def respond_to_missing?(method, include_private = T.unsafe(nil)); end
1527
+ end
1528
+
1529
+ RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)
1530
+
1531
+ module RSpec::Matchers::EnglishPhrasing
1532
+ class << self
1533
+ def list(obj); end
1534
+ def split_words(sym); end
1535
+ end
1536
+ end
1537
+
1538
+ class RSpec::Matchers::ExpectedsForMultipleDiffs
1539
+ def initialize(expected_list); end
1540
+
1541
+ def message_with_diff(message, differ, actual); end
1542
+
1543
+ private
1544
+
1545
+ def diffs(differ, actual); end
1546
+
1547
+ class << self
1548
+ def for_many_matchers(matchers); end
1549
+ def from(expected); end
1550
+
1551
+ private
1552
+
1553
+ def diff_label_for(matcher); end
1554
+ def truncated(description); end
1555
+ end
1556
+ end
1557
+
1558
+ RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
1559
+ RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
1560
+ RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp)
1561
+
1562
+ class RSpec::Matchers::MatcherDelegator
1563
+ include ::RSpec::Matchers::Composable
1564
+
1565
+ def initialize(base_matcher); end
1566
+
1567
+ def base_matcher; end
1568
+ def method_missing(*args, &block); end
1569
+
1570
+ private
1571
+
1572
+ def initialize_copy(other); end
1573
+ def respond_to_missing?(name, include_all = T.unsafe(nil)); end
1148
1574
  end