muina 0.2.8 → 0.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (161) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE +25 -0
  3. data/README.md +0 -35
  4. data/lib/muina/maybe/none.rb +57 -0
  5. data/lib/muina/maybe/some.rb +61 -0
  6. data/lib/muina/maybe.rb +13 -0
  7. data/lib/muina/version.rb +1 -2
  8. data/lib/muina.rb +0 -32
  9. metadata +24 -228
  10. data/.github/workflows/main.yml +0 -16
  11. data/.gitignore +0 -5
  12. data/.mutant.yml +0 -38
  13. data/.rspec +0 -4
  14. data/.rubocop.yml +0 -181
  15. data/.ruby-version +0 -1
  16. data/.simplecov +0 -14
  17. data/CHANGELOG.md +0 -38
  18. data/Gemfile +0 -34
  19. data/Gemfile.lock +0 -265
  20. data/Guardfile +0 -24
  21. data/Rakefile +0 -13
  22. data/SECURITY.md +0 -14
  23. data/bin/bundle +0 -114
  24. data/bin/console +0 -15
  25. data/bin/flay +0 -29
  26. data/bin/flog +0 -29
  27. data/bin/guard +0 -29
  28. data/bin/irb +0 -29
  29. data/bin/lefthook +0 -29
  30. data/bin/mutant +0 -29
  31. data/bin/parlour +0 -29
  32. data/bin/rake +0 -29
  33. data/bin/rspec +0 -29
  34. data/bin/rubocop +0 -29
  35. data/bin/setup +0 -8
  36. data/bin/srb +0 -29
  37. data/bin/srb-rbi +0 -29
  38. data/bin/tapioca +0 -29
  39. data/exe/muina +0 -11
  40. data/lefthook.yml +0 -39
  41. data/lib/muina/action/params_factory.rb +0 -17
  42. data/lib/muina/action/step/command.rb +0 -33
  43. data/lib/muina/action/step/failure.rb +0 -18
  44. data/lib/muina/action/step/query.rb +0 -35
  45. data/lib/muina/action/step/result.rb +0 -56
  46. data/lib/muina/action/step.rb +0 -13
  47. data/lib/muina/action.rb +0 -73
  48. data/lib/muina/any.rb +0 -7
  49. data/lib/muina/classes.rb +0 -7
  50. data/lib/muina/deprecator.rb +0 -93
  51. data/lib/muina/entity.rb +0 -20
  52. data/lib/muina/module.rb +0 -6
  53. data/lib/muina/parameters.rb +0 -7
  54. data/lib/muina/params.rb +0 -19
  55. data/lib/muina/private_creation.rb +0 -12
  56. data/lib/muina/result/factory.rb +0 -37
  57. data/lib/muina/result/failure.rb +0 -31
  58. data/lib/muina/result/null.rb +0 -25
  59. data/lib/muina/result/success.rb +0 -31
  60. data/lib/muina/result.rb +0 -17
  61. data/lib/muina/service.rb +0 -25
  62. data/lib/muina/symbol_hash.rb +0 -7
  63. data/lib/muina/unit.rb +0 -10
  64. data/lib/muina/untyped_array.rb +0 -7
  65. data/lib/muina/untyped_hash.rb +0 -7
  66. data/lib/muina/value.rb +0 -24
  67. data/muina.gemspec +0 -35
  68. data/rbi/muina.rbi +0 -311
  69. data/sorbet/config +0 -2
  70. data/sorbet/rbi/gems/actionpack@6.1.4.rbi +0 -5045
  71. data/sorbet/rbi/gems/actionview@6.1.4.rbi +0 -2416
  72. data/sorbet/rbi/gems/activesupport@6.1.4.rbi +0 -3778
  73. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  74. data/sorbet/rbi/gems/awesome_print@1.9.2.rbi +0 -322
  75. data/sorbet/rbi/gems/builder@3.2.4.rbi +0 -8
  76. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -18
  77. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -8
  78. data/sorbet/rbi/gems/colorize@0.8.1.rbi +0 -39
  79. data/sorbet/rbi/gems/commander@4.6.0.rbi +0 -8
  80. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +0 -2403
  81. data/sorbet/rbi/gems/crass@1.0.6.rbi +0 -123
  82. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -185
  83. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  84. data/sorbet/rbi/gems/erubi@1.10.0.rbi +0 -36
  85. data/sorbet/rbi/gems/erubis@2.7.0.rbi +0 -8
  86. data/sorbet/rbi/gems/faker@2.18.0.rbi +0 -2469
  87. data/sorbet/rbi/gems/ffi@1.15.3.rbi +0 -8
  88. data/sorbet/rbi/gems/flay@2.12.1.rbi +0 -178
  89. data/sorbet/rbi/gems/flog@4.6.4.rbi +0 -70
  90. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  91. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -49
  92. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -233
  93. data/sorbet/rbi/gems/guard-rubocop@1.4.0.rbi +0 -66
  94. data/sorbet/rbi/gems/guard-shell@0.7.2.rbi +0 -69
  95. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -617
  96. data/sorbet/rbi/gems/highline@2.0.3.rbi +0 -8
  97. data/sorbet/rbi/gems/i18n@1.8.10.rbi +0 -616
  98. data/sorbet/rbi/gems/io-console@0.5.9.rbi +0 -8
  99. data/sorbet/rbi/gems/irb@1.3.6.rbi +0 -452
  100. data/sorbet/rbi/gems/lefthook@0.7.6.rbi +0 -8
  101. data/sorbet/rbi/gems/listen@3.6.0.rbi +0 -476
  102. data/sorbet/rbi/gems/loofah@2.10.0.rbi +0 -223
  103. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -431
  104. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -8
  105. data/sorbet/rbi/gems/minitest@5.14.4.rbi +0 -344
  106. data/sorbet/rbi/gems/mutant-license@0.1.1.1.4043027289354708743625974235631451632228.0.rbi +0 -8
  107. data/sorbet/rbi/gems/mutant-rspec@0.10.32.rbi +0 -8
  108. data/sorbet/rbi/gems/mutant@0.10.32.rbi +0 -4154
  109. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -88
  110. data/sorbet/rbi/gems/nokogiri@1.11.7.rbi +0 -1422
  111. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -331
  112. data/sorbet/rbi/gems/parallel@1.20.1.rbi +0 -113
  113. data/sorbet/rbi/gems/parlour@6.0.1.rbi +0 -1726
  114. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1683
  115. data/sorbet/rbi/gems/path_expander@1.1.0.rbi +0 -24
  116. data/sorbet/rbi/gems/polyfill@1.9.0.rbi +0 -393
  117. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -8
  118. data/sorbet/rbi/gems/racc@1.5.2.rbi +0 -47
  119. data/sorbet/rbi/gems/rack-test@1.1.0.rbi +0 -272
  120. data/sorbet/rbi/gems/rack@2.2.3.rbi +0 -1618
  121. data/sorbet/rbi/gems/rails-dom-testing@2.0.3.rbi +0 -92
  122. data/sorbet/rbi/gems/rails-html-sanitizer@1.3.0.rbi +0 -183
  123. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  124. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -808
  125. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  126. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  127. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  128. data/sorbet/rbi/gems/reline@0.2.6.rbi +0 -662
  129. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  130. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2509
  131. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  132. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  133. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  134. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  135. data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi +0 -2194
  136. data/sorbet/rbi/gems/rubocop-performance@1.11.4.rbi +0 -899
  137. data/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi +0 -118
  138. data/sorbet/rbi/gems/rubocop-rspec@2.4.0.rbi +0 -1805
  139. data/sorbet/rbi/gems/rubocop-sorbet@0.6.2.rbi +0 -288
  140. data/sorbet/rbi/gems/rubocop@1.18.4.rbi +0 -13197
  141. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  142. data/sorbet/rbi/gems/ruby_parser@3.16.0.rbi +0 -4528
  143. data/sorbet/rbi/gems/safe_type@1.1.1.rbi +0 -157
  144. data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi +0 -359
  145. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -28
  146. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  147. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  148. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  149. data/sorbet/rbi/gems/sorbet-coerce@0.5.0.rbi +0 -42
  150. data/sorbet/rbi/gems/sorbet-rails@0.7.4.rbi +0 -8
  151. data/sorbet/rbi/gems/sorbet-struct-comparable@1.1.0.rbi +0 -17
  152. data/sorbet/rbi/gems/spoom@1.1.1.rbi +0 -1193
  153. data/sorbet/rbi/gems/tapioca@0.4.23.rbi +0 -1826
  154. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -838
  155. data/sorbet/rbi/gems/tzinfo@2.0.4.rbi +0 -856
  156. data/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi +0 -26
  157. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -2037
  158. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +0 -173
  159. data/sorbet/rbi/todo.rbi +0 -8
  160. data/sorbet/rbi/typed_params.rbi +0 -7
  161. data/sorbet/tapioca/require.rb +0 -16
@@ -1,1574 +0,0 @@
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 sync`.
4
-
5
- # typed: true
6
-
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
303
- end
304
-
305
- module RSpec::Expectations::Version; end
306
- RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String)
307
-
308
- module RSpec::Matchers
309
- extend ::RSpec::Matchers::DSL
310
-
311
- def a_block_changing(*args, &block); end
312
- def a_block_outputting(*args, &block); end
313
- def a_block_raising(*args, &block); end
314
- def a_block_throwing(*args, &block); end
315
- def a_block_yielding_control(*args, &block); end
316
- def a_block_yielding_successive_args(*args, &block); end
317
- def a_block_yielding_with_args(*args, &block); end
318
- def a_block_yielding_with_no_args(*args, &block); end
319
- def a_collection_containing_exactly(*args, &block); end
320
- def a_collection_ending_with(*args, &block); end
321
- def a_collection_including(*args, &block); end
322
- def a_collection_starting_with(*args, &block); end
323
- def a_falsey_value(*args, &block); end
324
- def a_falsy_value(*args, &block); end
325
- def a_hash_including(*args, &block); end
326
- def a_kind_of(*args, &block); end
327
- def a_nil_value(*args, &block); end
328
- def a_range_covering(*args, &block); end
329
- def a_string_ending_with(*args, &block); end
330
- def a_string_including(*args, &block); end
331
- def a_string_matching(*args, &block); end
332
- def a_string_starting_with(*args, &block); end
333
- def a_truthy_value(*args, &block); end
334
- def a_value(*args, &block); end
335
- def a_value_between(*args, &block); end
336
- def a_value_within(*args, &block); end
337
- def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
338
- def all(expected); end
339
- def an_instance_of(*args, &block); end
340
- def an_object_eq_to(*args, &block); end
341
- def an_object_eql_to(*args, &block); end
342
- def an_object_equal_to(*args, &block); end
343
- def an_object_existing(*args, &block); end
344
- def an_object_having_attributes(*args, &block); end
345
- def an_object_matching(*args, &block); end
346
- def an_object_responding_to(*args, &block); end
347
- def an_object_satisfying(*args, &block); end
348
- def be(*args); end
349
- def be_a(klass); end
350
- def be_a_kind_of(expected); end
351
- def be_an(klass); end
352
- def be_an_instance_of(expected); end
353
- def be_between(min, max); end
354
- def be_falsey; end
355
- def be_falsy(*args, &block); end
356
- def be_instance_of(expected); end
357
- def be_kind_of(expected); end
358
- def be_nil; end
359
- def be_truthy; end
360
- def be_within(delta); end
361
- def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
362
- def changing(*args, &block); end
363
- def contain_exactly(*items); end
364
- def containing_exactly(*args, &block); end
365
- def cover(*values); end
366
- def covering(*args, &block); end
367
- def end_with(*expected); end
368
- def ending_with(*args, &block); end
369
- def eq(expected); end
370
- def eq_to(*args, &block); end
371
- def eql(expected); end
372
- def eql_to(*args, &block); end
373
- def equal(expected); end
374
- def equal_to(*args, &block); end
375
- def exist(*args); end
376
- def existing(*args, &block); end
377
- def expect(value = T.unsafe(nil), &block); end
378
- def have_attributes(expected); end
379
- def having_attributes(*args, &block); end
380
- def include(*expected); end
381
- def including(*args, &block); end
382
- def match(expected); end
383
- def match_array(items); end
384
- def match_regex(*args, &block); end
385
- def matching(*args, &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
389
- def raising(*args, &block); end
390
- def respond_to(*names); end
391
- def responding_to(*args, &block); end
392
- def satisfy(description = T.unsafe(nil), &block); end
393
- def satisfying(*args, &block); end
394
- def start_with(*expected); end
395
- def starting_with(*args, &block); end
396
- def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
397
- def throwing(*args, &block); end
398
- def within(*args, &block); end
399
- def yield_control; end
400
- def yield_successive_args(*args); end
401
- def yield_with_args(*args); end
402
- def yield_with_no_args; end
403
- def yielding_control(*args, &block); end
404
- def yielding_successive_args(*args, &block); end
405
- def yielding_with_args(*args, &block); end
406
- def yielding_with_no_args(*args, &block); 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
426
- 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
435
- 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
448
- end
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
472
- end
473
-
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
-
481
- def actual; end
482
- def actual_formatted; end
483
- def description; end
484
- def diffable?; end
485
- def expected; end
486
- def expected_formatted; end
487
- def expects_call_stack_jump?; end
488
- def match_unless_raises(*exceptions); end
489
- def matcher_name; end
490
- def matcher_name=(_arg0); end
491
- def matches?(actual); end
492
- def present_ivars; end
493
- def rescued_exception; end
494
- def supports_block_expectations?; 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
507
- end
508
-
509
- module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
510
- def failure_message; end
511
- def failure_message_when_negated; end
512
-
513
- class << self
514
- def has_default_failure_messages?(matcher); end
515
- end
516
- 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
526
- end
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
542
- def failure_message; end
543
- def failure_message_when_negated; end
544
-
545
- private
546
-
547
- def match(_, actual); end
548
- end
549
-
550
- class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
551
- private
552
-
553
- def match(expected, actual); end
554
- end
555
-
556
- class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
557
- def description; end
558
-
559
- private
560
-
561
- def match(expected, actual); end
562
- end
563
-
564
- class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher
565
- def initialize(min, max); end
566
-
567
- def description; end
568
- def exclusive; end
569
- def failure_message; end
570
- def inclusive; end
571
- def matches?(actual); end
572
-
573
- private
574
-
575
- def comparable?; end
576
- def compare; end
577
- def not_comparable_clause; end
578
- end
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
587
- def failure_message; end
588
- def failure_message_when_negated; end
589
- def matches?(actual); end
590
-
591
- private
592
-
593
- def perform_match(actual); end
594
- end
595
-
596
- class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher
597
- def failure_message; end
598
- def failure_message_when_negated; end
599
-
600
- private
601
-
602
- def match(_, actual); end
603
- end
604
-
605
- module RSpec::Matchers::BuiltIn::BeHelpers
606
- private
607
-
608
- def args_to_s; end
609
- def args_to_sentence; end
610
- def expected_to_sentence; end
611
- def inspected_args; end
612
- def parenthesize(string); end
613
- end
614
-
615
- class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher
616
- def failure_message; end
617
- def failure_message_when_negated; end
618
-
619
- private
620
-
621
- def match(_, actual); end
622
- end
623
-
624
- class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate
625
- private
626
-
627
- def failure_to_respond_explanation; end
628
- def predicate; end
629
- def predicate_accessible?; end
630
- def predicate_method_name; end
631
- def present_tense_predicate; end
632
- 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
637
- def failure_message; end
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
646
- def initialize(delta); end
647
-
648
- def description; end
649
- def failure_message; end
650
- def failure_message_when_negated; end
651
- def matches?(actual); end
652
- def of(expected); end
653
- def percent_of(expected); end
654
-
655
- private
656
-
657
- def needs_expected; end
658
- def not_numeric_clause; end
659
- def numeric?; end
660
- end
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
-
683
- def by(expected_delta); end
684
- def by_at_least(minimum); end
685
- def by_at_most(maximum); end
686
- def description; end
687
- def does_not_match?(event_proc); end
688
- def failure_message; end
689
- def failure_message_when_negated; end
690
- def from(value); end
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
698
- def negative_failure_reason; end
699
- def perform_change(event_proc); end
700
- def positive_failure_reason; end
701
- def raise_block_syntax_error; 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
725
- def to(value); end
726
-
727
- private
728
-
729
- def change_description; end
730
- end
731
-
732
- class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher
733
- def initialize(change_details, expected_delta, relativity, &comparer); end
734
-
735
- def description; end
736
- def does_not_match?(_event_proc); end
737
- def failure_message; end
738
- def matches?(event_proc); end
739
- def supports_block_expectations?; end
740
-
741
- private
742
-
743
- def failure_reason; end
744
- end
745
-
746
- class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
747
- def initialize(change_details, expected_after); end
748
-
749
- def does_not_match?(_event_proc); end
750
- def from(value); end
751
-
752
- private
753
-
754
- def change_description; end
755
- end
756
-
757
- class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher
758
- def initialize(matcher_1, matcher_2); end
759
-
760
- def description; end
761
- def diffable?; end
762
- def does_not_match?(_actual); end
763
- def evaluator; end
764
- def expected; end
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
778
- def indent_multiline_message(message); end
779
- def initialize_copy(other); end
780
- def match(_expected, actual); end
781
- def matcher_1_matches?; end
782
- def matcher_2_matches?; end
783
- def matcher_is_diffable?(matcher); end
784
- def matcher_supports_block_expectations?(matcher); end
785
- 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
794
- end
795
-
796
- class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
797
- def initialize(actual, matcher_1, matcher_2); end
798
-
799
- def matcher_matches?(matcher); end
800
-
801
- private
802
-
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
-
823
- def matcher_matches?(matcher); end
824
- end
825
-
826
- class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher
827
- def description; end
828
- def failure_message; end
829
- def failure_message_when_negated; end
830
-
831
- private
832
-
833
- def actual_collection_line; end
834
- def best_solution; end
835
- def convert_actual_to_an_array; end
836
- def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
837
- def expected_collection_line; end
838
- def extra_elements_line; end
839
- def extra_items; end
840
- def generate_failure_message; end
841
- def match(_expected, _actual); end
842
- def match_when_sorted?; end
843
- def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
844
- def missing_elements_line; end
845
- def missing_items; end
846
- def pairings_maximizer; end
847
- def safe_sort(array); end
848
- def to_a_disallowed?(object); end
849
- end
850
-
851
- class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
852
- def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
853
-
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
-
861
- def apply_pairing_to(indeterminates, original_matches, other_list_index); end
862
- def best_solution_for_pairing(expected_index, actual_index); end
863
- def categorize_indexes(indexes_to_categorize, other_indexes); end
864
- def reciprocal_single_match?(matches, index, other_list); end
865
- end
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
874
- def +(derived_candidate_solution); end
875
- def candidate?; end
876
- def ideal?; end
877
- def indeterminate_actual_indexes; end
878
- def indeterminate_actual_indexes=(_); end
879
- def indeterminate_expected_indexes; end
880
- def indeterminate_expected_indexes=(_); end
881
- def unmatched_actual_indexes; end
882
- def unmatched_actual_indexes=(_); end
883
- def unmatched_expected_indexes; end
884
- def unmatched_expected_indexes=(_); end
885
- def unmatched_item_count; end
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
894
- 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
924
- end
925
-
926
- class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
927
- def initialize(*expected); end
928
-
929
- def does_not_match?(range); end
930
- def matches?(range); end
931
- end
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
-
938
- def description; end
939
- def does_not_match?(actual, &block); end
940
- def failure_message; 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
957
- end
958
-
959
- class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
960
- private
961
-
962
- def element_matches?; end
963
- def subset_matches?; end
964
- end
965
-
966
- class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher
967
- def description; end
968
- def diffable?; end
969
- def failure_message; end
970
- def failure_message_when_negated; end
971
-
972
- private
973
-
974
- def match(expected, actual); end
975
- end
976
-
977
- class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher
978
- def diffable?; end
979
- def failure_message; end
980
- def failure_message_when_negated; end
981
-
982
- private
983
-
984
- def match(expected, actual); end
985
- end
986
-
987
- class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher
988
- def diffable?; end
989
- def failure_message; end
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
997
- def inspect_object(o); end
998
- def match(expected, actual); end
999
- def simple_failure_message; end
1000
- end
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
-
1007
- def does_not_match?(actual); end
1008
- def failure_message; end
1009
- def failure_message_when_negated; end
1010
- def matches?(actual); end
1011
- end
1012
-
1013
- class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct
1014
- def actual_exists?; end
1015
- def valid_test?; end
1016
- def validity_message; end
1017
-
1018
- private
1019
-
1020
- def deprecated(predicate, actual); end
1021
- def existence_values; end
1022
- def predicates; end
1023
- def uniq_truthy_values; end
1024
- end
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
-
1037
- def actual; end
1038
- def description; end
1039
- def diffable?; end
1040
- def does_not_match?(actual); end
1041
- def failure_message; end
1042
- def failure_message_when_negated; end
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
1051
- def perform_match(predicate); end
1052
- def respond_to_attributes?; end
1053
- def respond_to_failure_message_or; end
1054
- def respond_to_matcher; end
1055
- end
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
-
1073
- def actual_collection_includes?(expected_item); end
1074
- def actual_hash_has_key?(expected_key); end
1075
- def actual_hash_includes?(expected_key, expected_value); end
1076
- def check_actual?(actual); end
1077
- def check_expected_count?; end
1078
- def comparing_hash_keys?(expected_item); end
1079
- def comparing_hash_to_a_subset?(expected_item); end
1080
- def convert_to_hash?(obj); end
1081
- def count_enumerable(expected_item); end
1082
- def count_inclusions; end
1083
- def diff_would_wrongly_highlight_matched_item?; end
1084
- def excluded_from_actual; end
1085
- def format_failure_message(preposition); end
1086
- def perform_match(&block); end
1087
- def readable_list_of(items); end
1088
- end
1089
-
1090
- class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher
1091
- def initialize(expected); end
1092
-
1093
- def description; end
1094
- def diffable?; end
1095
- def with_captures(*captures); end
1096
-
1097
- private
1098
-
1099
- def can_safely_call_match?(expected, actual); end
1100
- def match(expected, actual); end
1101
- def match_captures(expected, actual); end
1102
- end
1103
-
1104
- class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
1105
- def __delegate_operator(actual, operator, expected); end
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
-
1115
- class RSpec::Matchers::BuiltIn::OperatorMatcher
1116
- def initialize(actual); end
1117
-
1118
- def !=(_expected); end
1119
- def !~(_expected); end
1120
- def <(expected); end
1121
- def <=(expected); end
1122
- def ==(expected); end
1123
- def ===(expected); end
1124
- def =~(expected); end
1125
- def >(expected); end
1126
- def >=(expected); end
1127
- def description; end
1128
- def fail_with_message(message); end
1129
-
1130
- private
1131
-
1132
- def eval_match(actual, operator, expected); end
1133
- def has_non_generic_implementation_of?(op); 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
1142
- end
1143
-
1144
- class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
1145
- def initialize(expected); end
1146
-
1147
- def description; end
1148
- def diffable?; end
1149
- def does_not_match?(block); end
1150
- def failure_message; end
1151
- def failure_message_when_negated; end
1152
- def matches?(block); end
1153
- def supports_block_expectations?; end
1154
- def to_stderr; end
1155
- def to_stderr_from_any_process; end
1156
- def to_stdout; end
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
1165
- end
1166
-
1167
- class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
1168
- def __delegate_operator(actual, operator, expected); end
1169
- end
1170
-
1171
- class RSpec::Matchers::BuiltIn::RaiseError
1172
- include ::RSpec::Matchers::Composable
1173
-
1174
- def initialize(expected_error_or_message, expected_message, &block); end
1175
-
1176
- def description; end
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
1188
- def error_and_message_match?; end
1189
- def eval_block; end
1190
- def expectation_matched?; end
1191
- def expected_error; end
1192
- def expecting_specific_exception?; end
1193
- def format_backtrace(backtrace); end
1194
- def given_error; end
1195
- def handle_warning(message); end
1196
- def raise_message_already_set; end
1197
- def ready_to_eval_block?; end
1198
- def verify_message; end
1199
- def warn_about_bare_error!; end
1200
- def warn_about_bare_error?; end
1201
- def warn_about_negative_false_positive!(expression); end
1202
- def warn_about_nil_error!; end
1203
- def warn_about_nil_error?; end
1204
- def warn_for_negative_false_positives!; end
1205
- def warning; end
1206
- end
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
-
1224
- def and_any_keywords; end
1225
- def and_keywords(*keywords); end
1226
- def and_unlimited_arguments; end
1227
- def argument; end
1228
- def arguments; end
1229
- def description; end
1230
- def does_not_match?(actual); end
1231
- def failure_message; end
1232
- def failure_message_when_negated; end
1233
- def ignoring_method_signature_failure!; end
1234
- def matches?(actual); end
1235
- def with(n); end
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
1245
- def with_arity; end
1246
- def with_arity_string; end
1247
- def with_keywords_string; end
1248
- end
1249
-
1250
- class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
1251
- def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
1252
-
1253
- def matches?(actual, name); end
1254
- def method_signature_for(actual, name); end
1255
- def verifier_for(actual, name); end
1256
- end
1257
-
1258
- class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
1259
- def initialize(description = T.unsafe(nil), &block); end
1260
-
1261
- def description; end
1262
- def failure_message; end
1263
- def failure_message_when_negated; end
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
1311
- end
1312
-
1313
- class RSpec::Matchers::BuiltIn::ThrowSymbol
1314
- include ::RSpec::Matchers::Composable
1315
-
1316
- def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
1317
-
1318
- def description; end
1319
- def does_not_match?(given_proc); end
1320
- def expects_call_stack_jump?; end
1321
- def failure_message; end
1322
- def failure_message_when_negated; end
1323
- def matches?(given_proc); end
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
1331
- def throw_description(symbol, arg); end
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
-
1348
- class RSpec::Matchers::BuiltIn::YieldProbe
1349
- def initialize(block, &callback); end
1350
-
1351
- def assert_used!; end
1352
- def assert_valid_expect_block!; end
1353
- def has_block?; end
1354
- def num_yields; end
1355
- def num_yields=(_arg0); end
1356
- def probe; end
1357
- def single_yield_args; end
1358
- def to_proc; end
1359
- def yielded_args; end
1360
- def yielded_args=(_arg0); end
1361
- def yielded_once?(matcher_name); end
1362
-
1363
- class << self
1364
- def probe(block, &callback); end
1365
- end
1366
- end
1367
-
1368
- class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
1369
- def initialize(*args); end
1370
-
1371
- def description; end
1372
- def does_not_match?(block); end
1373
- def failure_message; end
1374
- def failure_message_when_negated; end
1375
- def matches?(block); end
1376
- def supports_block_expectations?; end
1377
-
1378
- private
1379
-
1380
- def expected_arg_description; end
1381
- def negative_failure_reason; end
1382
- def positive_failure_reason; end
1383
- end
1384
-
1385
- class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
1386
- def initialize(*args); end
1387
-
1388
- def description; end
1389
- def does_not_match?(block); end
1390
- def failure_message; end
1391
- def failure_message_when_negated; end
1392
- def matches?(block); end
1393
- def supports_block_expectations?; end
1394
-
1395
- private
1396
-
1397
- def all_args_match?; end
1398
- def args_currently_match?; end
1399
- def expected_arg_description; end
1400
- def negative_failure_reason; end
1401
- def positive_failure_reason; end
1402
- end
1403
-
1404
- class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
1405
- def does_not_match?(block); end
1406
- def failure_message; end
1407
- def failure_message_when_negated; end
1408
- def matches?(block); end
1409
- def supports_block_expectations?; end
1410
-
1411
- private
1412
-
1413
- def negative_failure_reason; end
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
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
1574
- end