muina 0.2.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (155) hide show
  1. checksums.yaml +7 -0
  2. data/.github/workflows/main.yml +16 -0
  3. data/.gitignore +5 -0
  4. data/.mutant.yml +38 -0
  5. data/.rspec +4 -0
  6. data/.rubocop.yml +172 -0
  7. data/.ruby-version +1 -0
  8. data/.simplecov +14 -0
  9. data/CHANGELOG.md +38 -0
  10. data/Gemfile +34 -0
  11. data/Gemfile.lock +265 -0
  12. data/Guardfile +24 -0
  13. data/README.md +36 -0
  14. data/Rakefile +13 -0
  15. data/SECURITY.md +14 -0
  16. data/bin/bundle +114 -0
  17. data/bin/console +15 -0
  18. data/bin/flay +29 -0
  19. data/bin/flog +29 -0
  20. data/bin/guard +29 -0
  21. data/bin/irb +29 -0
  22. data/bin/lefthook +29 -0
  23. data/bin/mutant +29 -0
  24. data/bin/parlour +29 -0
  25. data/bin/rake +29 -0
  26. data/bin/rspec +29 -0
  27. data/bin/rubocop +29 -0
  28. data/bin/setup +8 -0
  29. data/bin/srb +29 -0
  30. data/bin/srb-rbi +29 -0
  31. data/bin/tapioca +29 -0
  32. data/exe/muina +11 -0
  33. data/lefthook.yml +39 -0
  34. data/lib/muina/action/params_factory.rb +17 -0
  35. data/lib/muina/action/step/command.rb +31 -0
  36. data/lib/muina/action/step/failure.rb +18 -0
  37. data/lib/muina/action/step/query.rb +31 -0
  38. data/lib/muina/action/step/result.rb +51 -0
  39. data/lib/muina/action/step.rb +13 -0
  40. data/lib/muina/action.rb +73 -0
  41. data/lib/muina/any.rb +7 -0
  42. data/lib/muina/classes.rb +7 -0
  43. data/lib/muina/module.rb +6 -0
  44. data/lib/muina/parameters.rb +7 -0
  45. data/lib/muina/params.rb +19 -0
  46. data/lib/muina/private_creation.rb +12 -0
  47. data/lib/muina/result/factory.rb +37 -0
  48. data/lib/muina/result/failure.rb +31 -0
  49. data/lib/muina/result/null.rb +25 -0
  50. data/lib/muina/result/success.rb +31 -0
  51. data/lib/muina/result.rb +17 -0
  52. data/lib/muina/service.rb +37 -0
  53. data/lib/muina/symbol_hash.rb +7 -0
  54. data/lib/muina/unit.rb +10 -0
  55. data/lib/muina/untyped_array.rb +7 -0
  56. data/lib/muina/untyped_hash.rb +7 -0
  57. data/lib/muina/value.rb +16 -0
  58. data/lib/muina/version.rb +7 -0
  59. data/lib/muina.rb +42 -0
  60. data/muina.gemspec +35 -0
  61. data/rbi/muina.rbi +268 -0
  62. data/sorbet/config +2 -0
  63. data/sorbet/rbi/gems/actionpack@6.1.4.rbi +5045 -0
  64. data/sorbet/rbi/gems/actionview@6.1.4.rbi +2416 -0
  65. data/sorbet/rbi/gems/activesupport@6.1.4.rbi +3778 -0
  66. data/sorbet/rbi/gems/ast@2.4.2.rbi +54 -0
  67. data/sorbet/rbi/gems/awesome_print@1.9.2.rbi +322 -0
  68. data/sorbet/rbi/gems/builder@3.2.4.rbi +8 -0
  69. data/sorbet/rbi/gems/byebug@11.1.3.rbi +18 -0
  70. data/sorbet/rbi/gems/coderay@1.1.3.rbi +8 -0
  71. data/sorbet/rbi/gems/colorize@0.8.1.rbi +39 -0
  72. data/sorbet/rbi/gems/commander@4.6.0.rbi +8 -0
  73. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +2403 -0
  74. data/sorbet/rbi/gems/crass@1.0.6.rbi +123 -0
  75. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +185 -0
  76. data/sorbet/rbi/gems/docile@1.4.0.rbi +54 -0
  77. data/sorbet/rbi/gems/erubi@1.10.0.rbi +36 -0
  78. data/sorbet/rbi/gems/erubis@2.7.0.rbi +8 -0
  79. data/sorbet/rbi/gems/faker@2.18.0.rbi +2469 -0
  80. data/sorbet/rbi/gems/ffi@1.15.3.rbi +8 -0
  81. data/sorbet/rbi/gems/flay@2.12.1.rbi +178 -0
  82. data/sorbet/rbi/gems/flog@4.6.4.rbi +70 -0
  83. data/sorbet/rbi/gems/formatador@0.3.0.rbi +8 -0
  84. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +49 -0
  85. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +233 -0
  86. data/sorbet/rbi/gems/guard-rubocop@1.4.0.rbi +66 -0
  87. data/sorbet/rbi/gems/guard-shell@0.7.2.rbi +69 -0
  88. data/sorbet/rbi/gems/guard@2.18.0.rbi +617 -0
  89. data/sorbet/rbi/gems/highline@2.0.3.rbi +8 -0
  90. data/sorbet/rbi/gems/i18n@1.8.10.rbi +616 -0
  91. data/sorbet/rbi/gems/io-console@0.5.9.rbi +8 -0
  92. data/sorbet/rbi/gems/irb@1.3.6.rbi +452 -0
  93. data/sorbet/rbi/gems/lefthook@0.7.6.rbi +8 -0
  94. data/sorbet/rbi/gems/listen@3.6.0.rbi +476 -0
  95. data/sorbet/rbi/gems/loofah@2.10.0.rbi +223 -0
  96. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +431 -0
  97. data/sorbet/rbi/gems/method_source@1.0.0.rbi +8 -0
  98. data/sorbet/rbi/gems/minitest@5.14.4.rbi +344 -0
  99. data/sorbet/rbi/gems/mutant-license@0.1.1.1.4043027289354708743625974235631451632228.0.rbi +8 -0
  100. data/sorbet/rbi/gems/mutant-rspec@0.10.32.rbi +8 -0
  101. data/sorbet/rbi/gems/mutant@0.10.32.rbi +4154 -0
  102. data/sorbet/rbi/gems/nenv@0.3.0.rbi +88 -0
  103. data/sorbet/rbi/gems/nokogiri@1.11.7.rbi +1422 -0
  104. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +331 -0
  105. data/sorbet/rbi/gems/parallel@1.20.1.rbi +113 -0
  106. data/sorbet/rbi/gems/parlour@6.0.1.rbi +1726 -0
  107. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +1683 -0
  108. data/sorbet/rbi/gems/path_expander@1.1.0.rbi +24 -0
  109. data/sorbet/rbi/gems/polyfill@1.9.0.rbi +393 -0
  110. data/sorbet/rbi/gems/pry@0.14.1.rbi +8 -0
  111. data/sorbet/rbi/gems/racc@1.5.2.rbi +47 -0
  112. data/sorbet/rbi/gems/rack-test@1.1.0.rbi +272 -0
  113. data/sorbet/rbi/gems/rack@2.2.3.rbi +1618 -0
  114. data/sorbet/rbi/gems/rails-dom-testing@2.0.3.rbi +92 -0
  115. data/sorbet/rbi/gems/rails-html-sanitizer@1.3.0.rbi +183 -0
  116. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +153 -0
  117. data/sorbet/rbi/gems/rake@13.0.6.rbi +808 -0
  118. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +8 -0
  119. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +8 -0
  120. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +1120 -0
  121. data/sorbet/rbi/gems/reline@0.2.6.rbi +662 -0
  122. data/sorbet/rbi/gems/rexml@3.2.5.rbi +672 -0
  123. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +2509 -0
  124. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +1574 -0
  125. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +1462 -0
  126. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +509 -0
  127. data/sorbet/rbi/gems/rspec@3.10.0.rbi +38 -0
  128. data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi +2194 -0
  129. data/sorbet/rbi/gems/rubocop-performance@1.11.4.rbi +899 -0
  130. data/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi +118 -0
  131. data/sorbet/rbi/gems/rubocop-rspec@2.4.0.rbi +1805 -0
  132. data/sorbet/rbi/gems/rubocop-sorbet@0.6.2.rbi +288 -0
  133. data/sorbet/rbi/gems/rubocop@1.18.4.rbi +13197 -0
  134. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +405 -0
  135. data/sorbet/rbi/gems/ruby_parser@3.16.0.rbi +4528 -0
  136. data/sorbet/rbi/gems/safe_type@1.1.1.rbi +157 -0
  137. data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi +359 -0
  138. data/sorbet/rbi/gems/shellany@0.0.1.rbi +28 -0
  139. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +89 -0
  140. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +577 -0
  141. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +8 -0
  142. data/sorbet/rbi/gems/sorbet-coerce@0.5.0.rbi +42 -0
  143. data/sorbet/rbi/gems/sorbet-rails@0.7.4.rbi +8 -0
  144. data/sorbet/rbi/gems/sorbet-struct-comparable@1.1.0.rbi +17 -0
  145. data/sorbet/rbi/gems/spoom@1.1.1.rbi +1193 -0
  146. data/sorbet/rbi/gems/tapioca@0.4.23.rbi +1826 -0
  147. data/sorbet/rbi/gems/thor@1.1.0.rbi +838 -0
  148. data/sorbet/rbi/gems/tzinfo@2.0.4.rbi +856 -0
  149. data/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi +26 -0
  150. data/sorbet/rbi/gems/unparser@0.6.0.rbi +2037 -0
  151. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +173 -0
  152. data/sorbet/rbi/todo.rbi +8 -0
  153. data/sorbet/rbi/typed_params.rbi +7 -0
  154. data/sorbet/tapioca/require.rb +16 -0
  155. metadata +269 -0
@@ -0,0 +1,1462 @@
1
+ # DO NOT EDIT MANUALLY
2
+ # This is an autogenerated file for types exported from the `rspec-mocks` gem.
3
+ # Please instead update this file by running `bin/tapioca sync`.
4
+
5
+ # typed: true
6
+
7
+ module RSpec::Mocks
8
+ class << self
9
+ def allow_message(subject, message, opts = T.unsafe(nil), &block); end
10
+ def configuration; end
11
+ def error_generator; end
12
+ def expect_message(subject, message, opts = T.unsafe(nil), &block); end
13
+ def setup; end
14
+ def space; end
15
+ def teardown; end
16
+ def verify; end
17
+ def with_temporary_scope; end
18
+ end
19
+ end
20
+
21
+ class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase
22
+ def expression; end
23
+ def not_to(matcher, *_args); end
24
+ def to(matcher, &block); end
25
+ def to_not(matcher, *_args); end
26
+ end
27
+
28
+ class RSpec::Mocks::AndReturnImplementation
29
+ def initialize(values_to_return); end
30
+
31
+ def call(*_args_to_ignore, &_block); end
32
+ end
33
+
34
+ class RSpec::Mocks::AndWrapOriginalImplementation
35
+ def initialize(method, block); end
36
+
37
+ def call(*args, &block); end
38
+ def initial_action=(_value); end
39
+ def inner_action; end
40
+ def inner_action=(_value); end
41
+ def present?; end
42
+ def terminal_action=(_value); end
43
+
44
+ private
45
+
46
+ def cannot_modify_further_error; end
47
+ end
48
+
49
+ class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < ::StandardError; end
50
+
51
+ class RSpec::Mocks::AndYieldImplementation
52
+ def initialize(args_to_yield, eval_context, error_generator); end
53
+
54
+ def call(*_args_to_ignore, &block); end
55
+ end
56
+
57
+ module RSpec::Mocks::AnyInstance
58
+ class << self
59
+ def error_generator; end
60
+ end
61
+ end
62
+
63
+ class RSpec::Mocks::AnyInstance::Chain
64
+ include ::RSpec::Mocks::AnyInstance::Chain::Customizations
65
+
66
+ def initialize(recorder, *args, &block); end
67
+
68
+ def constrained_to_any_of?(*constraints); end
69
+ def expectation_fulfilled!; end
70
+ def matches_args?(*args); end
71
+ def never; end
72
+ def playback!(instance); end
73
+ def with(*args, &block); end
74
+
75
+ private
76
+
77
+ def last_message; end
78
+ def messages; end
79
+ def negated?; end
80
+ def record(rspec_method_name, *args, &block); end
81
+ end
82
+
83
+ module RSpec::Mocks::AnyInstance::Chain::Customizations
84
+ def and_call_original(*args, &block); end
85
+ def and_raise(*args, &block); end
86
+ def and_return(*args, &block); end
87
+ def and_throw(*args, &block); end
88
+ def and_wrap_original(*args, &block); end
89
+ def and_yield(*args, &block); end
90
+ def at_least(*args, &block); end
91
+ def at_most(*args, &block); end
92
+ def exactly(*args, &block); end
93
+ def never(*args, &block); end
94
+ def once(*args, &block); end
95
+ def thrice(*args, &block); end
96
+ def time(*args, &block); end
97
+ def times(*args, &block); end
98
+ def twice(*args, &block); end
99
+ def with(*args, &block); end
100
+
101
+ class << self
102
+ def record(method_name); end
103
+ end
104
+ end
105
+
106
+ class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
107
+ def raise_does_not_implement_error(klass, method_name); end
108
+ def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
109
+ def raise_not_supported_with_prepend_error(method_name, problem_mod); end
110
+ def raise_second_instance_received_message_error(unfulfilled_expectations); end
111
+ end
112
+
113
+ class RSpec::Mocks::AnyInstance::ExpectChainChain < ::RSpec::Mocks::AnyInstance::StubChain
114
+ def initialize(*args); end
115
+
116
+ def expectation_fulfilled?; end
117
+ def playback!(instance); end
118
+
119
+ private
120
+
121
+ def create_message_expectation_on(instance); end
122
+ def invocation_order; end
123
+ end
124
+
125
+ class RSpec::Mocks::AnyInstance::ExpectationChain < ::RSpec::Mocks::AnyInstance::Chain
126
+ def initialize(*args, &block); end
127
+
128
+ def expectation_fulfilled?; end
129
+
130
+ private
131
+
132
+ def verify_invocation_order(_rspec_method_name, *_args, &_block); end
133
+ end
134
+
135
+ class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
136
+ def initialize(targets); end
137
+
138
+ def method_missing(*args, &block); end
139
+
140
+ private
141
+
142
+ def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
143
+ end
144
+
145
+ class RSpec::Mocks::AnyInstance::MessageChains
146
+ def initialize; end
147
+
148
+ def [](method_name); end
149
+ def add(method_name, chain); end
150
+ def all_expectations_fulfilled?; end
151
+ def each_unfulfilled_expectation_matching(method_name, *args); end
152
+ def has_expectation?(method_name); end
153
+ def playback!(instance, method_name); end
154
+ def received_expected_message!(method_name); end
155
+ def remove_stub_chains_for!(method_name); end
156
+ def unfulfilled_expectations; end
157
+
158
+ private
159
+
160
+ def raise_if_second_instance_to_receive_message(instance); end
161
+ end
162
+
163
+ class RSpec::Mocks::AnyInstance::PositiveExpectationChain < ::RSpec::Mocks::AnyInstance::ExpectationChain
164
+ private
165
+
166
+ def create_message_expectation_on(instance); end
167
+ def invocation_order; end
168
+ end
169
+
170
+ RSpec::Mocks::AnyInstance::PositiveExpectationChain::ExpectationInvocationOrder = T.let(T.unsafe(nil), Hash)
171
+
172
+ class RSpec::Mocks::AnyInstance::Proxy
173
+ def initialize(recorder, target_proxies); end
174
+
175
+ def expect_chain(*chain, &block); end
176
+ def klass; end
177
+ def should_not_receive(method_name, &block); end
178
+ def should_receive(method_name, &block); end
179
+ def stub(method_name_or_method_map, &block); end
180
+ def stub_chain(*chain, &block); end
181
+ def unstub(method_name); end
182
+
183
+ private
184
+
185
+ def perform_proxying(method_name, args, block, &target_proxy_block); end
186
+ end
187
+
188
+ class RSpec::Mocks::AnyInstance::Recorder
189
+ def initialize(klass); end
190
+
191
+ def already_observing?(method_name); end
192
+ def build_alias_method_name(method_name); end
193
+ def expect_chain(*method_names_and_optional_return_values, &block); end
194
+ def instance_that_received(method_name); end
195
+ def klass; end
196
+ def message_chains; end
197
+ def notify_received_message(_object, message, args, _blk); end
198
+ def playback!(instance, method_name); end
199
+ def should_not_receive(method_name, &block); end
200
+ def should_receive(method_name, &block); end
201
+ def stop_all_observation!; end
202
+ def stub(method_name, &block); end
203
+ def stub_chain(*method_names_and_optional_return_values, &block); end
204
+ def stubs; end
205
+ def unstub(method_name); end
206
+ def verify; end
207
+
208
+ protected
209
+
210
+ def stop_observing!(method_name); end
211
+
212
+ private
213
+
214
+ def allow_no_prepended_module_definition_of(method_name); end
215
+ def ancestor_is_an_observer?(method_name); end
216
+ def backup_method!(method_name); end
217
+ def mark_invoked!(method_name); end
218
+ def normalize_chain(*args); end
219
+ def observe!(method_name); end
220
+ def public_protected_or_private_method_defined?(method_name); end
221
+ def received_expected_message!(method_name); end
222
+ def remove_dummy_method!(method_name); end
223
+ def restore_method!(method_name); end
224
+ def restore_original_method!(method_name); end
225
+ def super_class_observers_for(method_name); end
226
+ def super_class_observing?(method_name); end
227
+ end
228
+
229
+ class RSpec::Mocks::AnyInstance::StubChain < ::RSpec::Mocks::AnyInstance::Chain
230
+ def expectation_fulfilled?; end
231
+
232
+ private
233
+
234
+ def create_message_expectation_on(instance); end
235
+ def invocation_order; end
236
+ def verify_invocation_order(rspec_method_name, *_args, &_block); end
237
+ end
238
+
239
+ RSpec::Mocks::AnyInstance::StubChain::EmptyInvocationOrder = T.let(T.unsafe(nil), Hash)
240
+ RSpec::Mocks::AnyInstance::StubChain::InvocationOrder = T.let(T.unsafe(nil), Hash)
241
+
242
+ class RSpec::Mocks::AnyInstance::StubChainChain < ::RSpec::Mocks::AnyInstance::StubChain
243
+ def initialize(*args); end
244
+
245
+ private
246
+
247
+ def create_message_expectation_on(instance); end
248
+ def invocation_order; end
249
+ end
250
+
251
+ class RSpec::Mocks::AnyInstanceAllowanceTarget < ::RSpec::Mocks::TargetBase
252
+ def expression; end
253
+ def not_to(matcher, *_args); end
254
+ def to(matcher, &block); end
255
+ def to_not(matcher, *_args); end
256
+ end
257
+
258
+ class RSpec::Mocks::AnyInstanceExpectationTarget < ::RSpec::Mocks::TargetBase
259
+ def expression; end
260
+ def not_to(matcher, &block); end
261
+ def to(matcher, &block); end
262
+ def to_not(matcher, &block); end
263
+ end
264
+
265
+ class RSpec::Mocks::ArgumentListMatcher
266
+ def initialize(*expected_args); end
267
+
268
+ def args_match?(*args); end
269
+ def expected_args; end
270
+ def resolve_expected_args_based_on(actual_args); end
271
+
272
+ private
273
+
274
+ def ensure_expected_args_valid!; end
275
+ def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end
276
+ end
277
+
278
+ RSpec::Mocks::ArgumentListMatcher::MATCH_ALL = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentListMatcher)
279
+
280
+ module RSpec::Mocks::ArgumentMatchers
281
+ def a_kind_of(klass); end
282
+ def an_instance_of(klass); end
283
+ def any_args; end
284
+ def anything; end
285
+ def array_including(*args); end
286
+ def boolean; end
287
+ def duck_type(*args); end
288
+ def hash_excluding(*args); end
289
+ def hash_including(*args); end
290
+ def hash_not_including(*args); end
291
+ def instance_of(klass); end
292
+ def kind_of(klass); end
293
+ def no_args; end
294
+
295
+ class << self
296
+ def anythingize_lonely_keys(*args); end
297
+ end
298
+ end
299
+
300
+ class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
301
+ def ===(_other); end
302
+ def description; end
303
+ end
304
+
305
+ RSpec::Mocks::ArgumentMatchers::AnyArgMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgMatcher)
306
+
307
+ class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
308
+ def description; end
309
+ end
310
+
311
+ RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher)
312
+
313
+ class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher
314
+ def initialize(expected); end
315
+
316
+ def ===(actual); end
317
+ def description; end
318
+
319
+ private
320
+
321
+ def formatted_expected_values; end
322
+ end
323
+
324
+ class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
325
+ def initialize(expected); end
326
+
327
+ def ===(predicate, actual); end
328
+ def description(name); end
329
+
330
+ private
331
+
332
+ def formatted_expected_hash; end
333
+ end
334
+
335
+ class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
336
+ def ===(value); end
337
+ def description; end
338
+ end
339
+
340
+ RSpec::Mocks::ArgumentMatchers::BooleanMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::BooleanMatcher)
341
+
342
+ class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher
343
+ def initialize(*methods_to_respond_to); end
344
+
345
+ def ===(value); end
346
+ def description; end
347
+ end
348
+
349
+ class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
350
+ def ===(actual); end
351
+ def description; end
352
+ end
353
+
354
+ class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
355
+ def ===(actual); end
356
+ def description; end
357
+ end
358
+
359
+ class RSpec::Mocks::ArgumentMatchers::InstanceOf
360
+ def initialize(klass); end
361
+
362
+ def ===(actual); end
363
+ def description; end
364
+ end
365
+
366
+ class RSpec::Mocks::ArgumentMatchers::KindOf
367
+ def initialize(klass); end
368
+
369
+ def ===(actual); end
370
+ def description; end
371
+ end
372
+
373
+ class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
374
+ def description; end
375
+ end
376
+
377
+ RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
378
+
379
+ class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
380
+ class << self
381
+ def inherited(subklass); end
382
+ end
383
+ end
384
+
385
+ class RSpec::Mocks::CallbackInvocationStrategy
386
+ def call(doubled_module); end
387
+ end
388
+
389
+ class RSpec::Mocks::CannotSupportArgMutationsError < ::StandardError; end
390
+
391
+ class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference
392
+ def with_signature; end
393
+
394
+ class << self
395
+ def applies_to?(method_name); end
396
+ end
397
+ end
398
+
399
+ class RSpec::Mocks::ClassVerifyingDouble < ::Module
400
+ include ::RSpec::Mocks::TestDouble
401
+ include ::RSpec::Mocks::VerifyingDouble
402
+ include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
403
+ end
404
+
405
+ class RSpec::Mocks::Configuration
406
+ def initialize; end
407
+
408
+ def add_stub_and_should_receive_to(*modules); end
409
+ def allow_message_expectations_on_nil; end
410
+ def allow_message_expectations_on_nil=(_arg0); end
411
+ def before_verifying_doubles(&block); end
412
+ def color?; end
413
+ def patch_marshal_to_support_partial_doubles=(val); end
414
+ def reset_syntaxes_to_default; end
415
+ def syntax; end
416
+ def syntax=(*values); end
417
+ def temporarily_suppress_partial_double_verification; end
418
+ def temporarily_suppress_partial_double_verification=(_arg0); end
419
+ def transfer_nested_constants=(_arg0); end
420
+ def transfer_nested_constants?; end
421
+ def verify_doubled_constant_names=(_arg0); end
422
+ def verify_doubled_constant_names?; end
423
+ def verify_partial_doubles=(val); end
424
+ def verify_partial_doubles?; end
425
+ def verifying_double_callbacks; end
426
+ def when_declaring_verifying_double(&block); end
427
+ def yield_receiver_to_any_instance_implementation_blocks=(_arg0); end
428
+ def yield_receiver_to_any_instance_implementation_blocks?; end
429
+ end
430
+
431
+ class RSpec::Mocks::Constant
432
+ extend ::RSpec::Support::RecursiveConstMethods
433
+
434
+ def initialize(name); end
435
+
436
+ def hidden=(_arg0); end
437
+ def hidden?; end
438
+ def inspect; end
439
+ def mutated?; end
440
+ def name; end
441
+ def original_value; end
442
+ def original_value=(_arg0); end
443
+ def previously_defined=(_arg0); end
444
+ def previously_defined?; end
445
+ def stubbed=(_arg0); end
446
+ def stubbed?; end
447
+ def to_s; end
448
+ def valid_name=(_arg0); end
449
+ def valid_name?; end
450
+
451
+ class << self
452
+ def original(name); end
453
+ def unmutated(name); end
454
+ end
455
+ end
456
+
457
+ class RSpec::Mocks::ConstantMutator
458
+ extend ::RSpec::Support::RecursiveConstMethods
459
+
460
+ class << self
461
+ def hide(constant_name); end
462
+ def mutate(mutator); end
463
+ def raise_on_invalid_const; end
464
+ def stub(constant_name, value, options = T.unsafe(nil)); end
465
+ end
466
+ end
467
+
468
+ class RSpec::Mocks::ConstantMutator::BaseMutator
469
+ include ::RSpec::Support::RecursiveConstMethods
470
+
471
+ def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
472
+
473
+ def full_constant_name; end
474
+ def idempotently_reset; end
475
+ def original_value; end
476
+ def to_constant; end
477
+ end
478
+
479
+ class RSpec::Mocks::ConstantMutator::ConstantHider < ::RSpec::Mocks::ConstantMutator::BaseMutator
480
+ def mutate; end
481
+ def reset; end
482
+ def to_constant; end
483
+ end
484
+
485
+ class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < ::RSpec::Mocks::ConstantMutator::BaseMutator
486
+ def initialize(*args); end
487
+
488
+ def mutate; end
489
+ def reset; end
490
+ def should_transfer_nested_constants?; end
491
+ def to_constant; end
492
+ def transfer_nested_constants; end
493
+ def verify_constants_to_transfer!; end
494
+ end
495
+
496
+ class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < ::RSpec::Mocks::ConstantMutator::BaseMutator
497
+ def mutate; end
498
+ def reset; end
499
+ def to_constant; end
500
+
501
+ private
502
+
503
+ def name_for(parent, name); end
504
+ end
505
+
506
+ RSpec::Mocks::DEFAULT_CALLBACK_INVOCATION_STRATEGY = T.let(T.unsafe(nil), RSpec::Mocks::CallbackInvocationStrategy)
507
+
508
+ class RSpec::Mocks::DirectObjectReference
509
+ def initialize(object); end
510
+
511
+ def const_to_replace; end
512
+ def defined?; end
513
+ def description; end
514
+ def target; end
515
+ def when_loaded; end
516
+ end
517
+
518
+ class RSpec::Mocks::Double
519
+ include ::RSpec::Mocks::TestDouble
520
+ end
521
+
522
+ class RSpec::Mocks::ErrorGenerator
523
+ def initialize(target = T.unsafe(nil)); end
524
+
525
+ def default_error_message(expectation, expected_args, actual_args); end
526
+ def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
527
+ def expectation_on_nil_message(method_name); end
528
+ def intro(unwrapped = T.unsafe(nil)); end
529
+ def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end
530
+ def opts; end
531
+ def opts=(_arg0); end
532
+ def raise_already_invoked_error(message, calling_customization); end
533
+ def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
534
+ def raise_double_negation_error(wrapped_expression); end
535
+ def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
536
+ def raise_expectation_on_mocked_method(method); end
537
+ def raise_expectation_on_nil_error(method_name); end
538
+ def raise_expectation_on_unstubbed_method(method); end
539
+ def raise_expired_test_double_error; end
540
+ def raise_have_received_disallowed(type, reason); end
541
+ def raise_invalid_arguments_error(verifier); end
542
+ def raise_method_not_stubbed_error(method_name); end
543
+ def raise_missing_block_error(args_to_yield); end
544
+ def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
545
+ def raise_non_public_error(method_name, visibility); end
546
+ def raise_only_valid_on_a_partial_double(method); end
547
+ def raise_out_of_order_error(message); end
548
+ def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end
549
+ def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end
550
+ def raise_unexpected_message_error(message, args); end
551
+ def raise_unimplemented_error(doubled_module, method_name, object); end
552
+ def raise_verifying_double_not_defined_error(ref); end
553
+ def raise_wrong_arity_error(args_to_yield, signature); end
554
+
555
+ private
556
+
557
+ def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
558
+ def arg_list(args); end
559
+ def count_message(count, expectation_count_type = T.unsafe(nil)); end
560
+ def diff_message(expected_args, actual_args); end
561
+ def differ; end
562
+ def error_message(expectation, args_for_multiple_calls); end
563
+ def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end
564
+ def format_args(args); end
565
+ def format_received_args(args_for_multiple_calls); end
566
+ def group_count(index, args); end
567
+ def grouped_args(args); end
568
+ def list_of_exactly_one_string?(args); end
569
+ def notify(*args); end
570
+ def prepend_to_backtrace(exception, line); end
571
+ def received_part_of_expectation_error(actual_received_count, args); end
572
+ def times(count); end
573
+ def unexpected_arguments_message(expected_args_string, actual_args_string); end
574
+ def unpack_string_args(formatted_expected_args, actual_args); end
575
+ end
576
+
577
+ module RSpec::Mocks::ExampleMethods
578
+ include ::RSpec::Mocks::ArgumentMatchers
579
+ include ::RSpec::Mocks::ExampleMethods::ExpectHost
580
+
581
+ def allow(target); end
582
+ def allow_any_instance_of(klass); end
583
+ def allow_message_expectations_on_nil; end
584
+ def class_double(doubled_class, *args); end
585
+ def class_spy(*args); end
586
+ def double(*args); end
587
+ def expect_any_instance_of(klass); end
588
+ def have_received(method_name, &block); end
589
+ def hide_const(constant_name); end
590
+ def instance_double(doubled_class, *args); end
591
+ def instance_spy(*args); end
592
+ def object_double(object_or_name, *args); end
593
+ def object_spy(*args); end
594
+ def receive(method_name, &block); end
595
+ def receive_message_chain(*messages, &block); end
596
+ def receive_messages(message_return_value_hash); end
597
+ def spy(*args); end
598
+ def stub_const(constant_name, value, options = T.unsafe(nil)); end
599
+ def without_partial_double_verification; end
600
+
601
+ class << self
602
+ def declare_double(type, *args); end
603
+ def declare_verifying_double(type, ref, *args); end
604
+ def extended(object); end
605
+ def included(klass); end
606
+ end
607
+ end
608
+
609
+ module RSpec::Mocks::ExampleMethods::ExpectHost
610
+ def expect(target); end
611
+ end
612
+
613
+ class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain
614
+ private
615
+
616
+ def expectation(object, message, &return_block); end
617
+
618
+ class << self
619
+ def expect_chain_on(object, *chain, &blk); end
620
+ end
621
+ end
622
+
623
+ class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase
624
+ include ::RSpec::Mocks::ExpectationTargetMethods
625
+ end
626
+
627
+ module RSpec::Mocks::ExpectationTargetMethods
628
+ include ::RSpec::Mocks::TargetDelegationInstanceMethods
629
+ extend ::RSpec::Mocks::TargetDelegationClassMethods
630
+
631
+ def expression; end
632
+ def not_to(matcher, &block); end
633
+ def to(matcher, &block); end
634
+ def to_not(matcher, &block); end
635
+ end
636
+
637
+ class RSpec::Mocks::ExpiredTestDoubleError < ::RSpec::Mocks::MockExpectationError; end
638
+ RSpec::Mocks::IGNORED_BACKTRACE_LINE = T.let(T.unsafe(nil), String)
639
+
640
+ class RSpec::Mocks::Implementation
641
+ def call(*args, &block); end
642
+ def initial_action; end
643
+ def initial_action=(_arg0); end
644
+ def inner_action; end
645
+ def inner_action=(_arg0); end
646
+ def present?; end
647
+ def terminal_action; end
648
+ def terminal_action=(_arg0); end
649
+
650
+ private
651
+
652
+ def actions; end
653
+ end
654
+
655
+ class RSpec::Mocks::InstanceMethodReference < ::RSpec::Mocks::MethodReference
656
+ private
657
+
658
+ def find_method(mod); end
659
+ def method_defined?(mod); end
660
+ def method_implemented?(mod); end
661
+ def visibility_from(mod); end
662
+ end
663
+
664
+ class RSpec::Mocks::InstanceMethodStasher
665
+ def initialize(object, method); end
666
+
667
+ def handle_restoration_failures; end
668
+ def method_is_stashed?; end
669
+ def original_method; end
670
+ def restore; end
671
+ def stash; end
672
+
673
+ private
674
+
675
+ def method_defined_directly_on_klass?; end
676
+ def method_defined_on_klass?(klass = T.unsafe(nil)); end
677
+ def method_owned_by_klass?; end
678
+ end
679
+
680
+ class RSpec::Mocks::InstanceVerifyingDouble
681
+ include ::RSpec::Mocks::TestDouble
682
+ include ::RSpec::Mocks::VerifyingDouble
683
+
684
+ def __build_mock_proxy(order_group); end
685
+ end
686
+
687
+ class RSpec::Mocks::MarshalExtension
688
+ class << self
689
+ def patch!; end
690
+ def unpatch!; end
691
+ end
692
+ end
693
+
694
+ module RSpec::Mocks::Matchers; end
695
+
696
+ class RSpec::Mocks::Matchers::ExpectationCustomization
697
+ def initialize(method_name, args, block); end
698
+
699
+ def block; end
700
+ def block=(_arg0); end
701
+ def playback_onto(expectation); end
702
+ end
703
+
704
+ class RSpec::Mocks::Matchers::HaveReceived
705
+ include ::RSpec::Mocks::Matchers::Matcher
706
+
707
+ def initialize(method_name, &block); end
708
+
709
+ def at_least(*args); end
710
+ def at_most(*args); end
711
+ def description; end
712
+ def does_not_match?(subject); end
713
+ def exactly(*args); end
714
+ def failure_message; end
715
+ def failure_message_when_negated; end
716
+ def matches?(subject, &block); end
717
+ def name; end
718
+ def once(*args); end
719
+ def ordered(*args); end
720
+ def setup_allowance(_subject, &_block); end
721
+ def setup_any_instance_allowance(_subject, &_block); end
722
+ def setup_any_instance_expectation(_subject, &_block); end
723
+ def setup_any_instance_negative_expectation(_subject, &_block); end
724
+ def setup_expectation(subject, &block); end
725
+ def setup_negative_expectation(subject, &block); end
726
+ def thrice(*args); end
727
+ def time(*args); end
728
+ def times(*args); end
729
+ def twice(*args); end
730
+ def with(*args); end
731
+
732
+ private
733
+
734
+ def apply_constraints_to(expectation); end
735
+ def capture_failure_message; end
736
+ def count_constraint; end
737
+ def disallow(type, reason = T.unsafe(nil)); end
738
+ def ensure_count_unconstrained; end
739
+ def expect; end
740
+ def expected_messages_received_in_order?; end
741
+ def mock_proxy; end
742
+ def notify_failure_message; end
743
+ end
744
+
745
+ RSpec::Mocks::Matchers::HaveReceived::ARGS_CONSTRAINTS = T.let(T.unsafe(nil), Array)
746
+ RSpec::Mocks::Matchers::HaveReceived::CONSTRAINTS = T.let(T.unsafe(nil), Array)
747
+ RSpec::Mocks::Matchers::HaveReceived::COUNT_CONSTRAINTS = T.let(T.unsafe(nil), Array)
748
+ module RSpec::Mocks::Matchers::Matcher; end
749
+
750
+ class RSpec::Mocks::Matchers::Receive
751
+ include ::RSpec::Mocks::Matchers::Matcher
752
+
753
+ def initialize(message, block); end
754
+
755
+ def and_call_original(*args, &block); end
756
+ def and_raise(*args, &block); end
757
+ def and_return(*args, &block); end
758
+ def and_throw(*args, &block); end
759
+ def and_wrap_original(*args, &block); end
760
+ def and_yield(*args, &block); end
761
+ def at_least(*args, &block); end
762
+ def at_most(*args, &block); end
763
+ def description; end
764
+ def does_not_match?(subject, &block); end
765
+ def exactly(*args, &block); end
766
+ def matches?(subject, &block); end
767
+ def name; end
768
+ def never(*args, &block); end
769
+ def once(*args, &block); end
770
+ def ordered(*args, &block); end
771
+ def setup_allowance(subject, &block); end
772
+ def setup_any_instance_allowance(subject, &block); end
773
+ def setup_any_instance_expectation(subject, &block); end
774
+ def setup_any_instance_negative_expectation(subject, &block); end
775
+ def setup_expectation(subject, &block); end
776
+ def setup_negative_expectation(subject, &block); end
777
+ def thrice(*args, &block); end
778
+ def time(*args, &block); end
779
+ def times(*args, &block); end
780
+ def twice(*args, &block); end
781
+ def with(*args, &block); end
782
+
783
+ private
784
+
785
+ def describable; end
786
+ def move_block_to_last_customization(block); end
787
+ def setup_any_instance_method_substitute(subject, method, block); end
788
+ def setup_method_substitute(host, method, block, *args); end
789
+ def setup_mock_proxy_method_substitute(subject, method, block); end
790
+ def warn_if_any_instance(expression, subject); end
791
+ end
792
+
793
+ class RSpec::Mocks::Matchers::Receive::DefaultDescribable
794
+ def initialize(message); end
795
+
796
+ def description_for(verb); end
797
+ end
798
+
799
+ class RSpec::Mocks::Matchers::ReceiveMessageChain
800
+ include ::RSpec::Mocks::Matchers::Matcher
801
+
802
+ def initialize(chain, &block); end
803
+
804
+ def and_call_original(*args, &block); end
805
+ def and_raise(*args, &block); end
806
+ def and_return(*args, &block); end
807
+ def and_throw(*args, &block); end
808
+ def and_yield(*args, &block); end
809
+ def description; end
810
+ def does_not_match?(*_args); end
811
+ def matches?(subject, &block); end
812
+ def name; end
813
+ def setup_allowance(subject, &block); end
814
+ def setup_any_instance_allowance(subject, &block); end
815
+ def setup_any_instance_expectation(subject, &block); end
816
+ def setup_expectation(subject, &block); end
817
+ def setup_negative_expectation(*_args); end
818
+ def with(*args, &block); end
819
+
820
+ private
821
+
822
+ def formatted_chain; end
823
+ def replay_customizations(chain); end
824
+ end
825
+
826
+ class RSpec::Mocks::Matchers::ReceiveMessages
827
+ include ::RSpec::Mocks::Matchers::Matcher
828
+
829
+ def initialize(message_return_value_hash); end
830
+
831
+ def description; end
832
+ def does_not_match?(_subject); end
833
+ def matches?(subject); end
834
+ def name; end
835
+ def setup_allowance(subject); end
836
+ def setup_any_instance_allowance(subject); end
837
+ def setup_any_instance_expectation(subject); end
838
+ def setup_expectation(subject); end
839
+ def setup_negative_expectation(_subject); end
840
+ def warn_about_block; end
841
+
842
+ private
843
+
844
+ def any_instance_of(subject); end
845
+ def each_message_on(host); end
846
+ def proxy_on(subject); end
847
+ end
848
+
849
+ class RSpec::Mocks::MessageChain
850
+ def initialize(object, *chain, &blk); end
851
+
852
+ def block; end
853
+ def chain; end
854
+ def object; end
855
+ def setup_chain; end
856
+
857
+ private
858
+
859
+ def chain_on(object, *chain, &block); end
860
+ def find_matching_expectation; end
861
+ def find_matching_stub; end
862
+ def format_chain(*chain, &blk); end
863
+ end
864
+
865
+ class RSpec::Mocks::MessageExpectation
866
+ include ::RSpec::Mocks::MessageExpectation::ImplementationDetails
867
+
868
+ def and_call_original; end
869
+ def and_raise(*args); end
870
+ def and_return(first_value, *values); end
871
+ def and_throw(*args); end
872
+ def and_wrap_original(&block); end
873
+ def and_yield(*args, &block); end
874
+ def at_least(n, &block); end
875
+ def at_most(n, &block); end
876
+ def exactly(n, &block); end
877
+ def inspect; end
878
+ def never; end
879
+ def once(&block); end
880
+ def ordered(&block); end
881
+ def thrice(&block); end
882
+ def time(&block); end
883
+ def times(&block); end
884
+ def to_s; end
885
+ def twice(&block); end
886
+ def with(*args, &block); end
887
+ end
888
+
889
+ module RSpec::Mocks::MessageExpectation::ImplementationDetails
890
+ def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end
891
+
892
+ def actual_received_count_matters?; end
893
+ def additional_expected_calls; end
894
+ def advise(*args); end
895
+ def and_yield_receiver_to_implementation; end
896
+ def argument_list_matcher=(_arg0); end
897
+ def called_max_times?; end
898
+ def description_for(verb); end
899
+ def ensure_expected_ordering_received!; end
900
+ def error_generator; end
901
+ def expectation_count_type; end
902
+ def expected_args; end
903
+ def expected_messages_received?; end
904
+ def generate_error; end
905
+ def ignoring_args?; end
906
+ def implementation; end
907
+ def increase_actual_received_count!; end
908
+ def invoke(parent_stub, *args, &block); end
909
+ def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
910
+ def matches?(message, *args); end
911
+ def matches_at_least_count?; end
912
+ def matches_at_most_count?; end
913
+ def matches_exact_count?; end
914
+ def matches_name_but_not_args(message, *args); end
915
+ def message; end
916
+ def negative?; end
917
+ def negative_expectation_for?(message); end
918
+ def ordered?; end
919
+ def orig_object; end
920
+ def raise_out_of_order_error; end
921
+ def raise_unexpected_message_args_error(args_for_multiple_calls); end
922
+ def safe_invoke(parent_stub, *args, &block); end
923
+ def similar_messages; end
924
+ def type; end
925
+ def unadvise(args); end
926
+ def verify_messages_received; end
927
+ def yield_receiver_to_implementation_block?; end
928
+
929
+ protected
930
+
931
+ def error_generator=(_arg0); end
932
+ def expected_from=(_arg0); end
933
+ def expected_received_count=(_arg0); end
934
+ def implementation=(_arg0); end
935
+
936
+ private
937
+
938
+ def exception_source_id; end
939
+ def has_been_invoked?; end
940
+ def initial_implementation_action=(action); end
941
+ def inner_implementation_action=(action); end
942
+ def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end
943
+ def raise_already_invoked_error_if_necessary(calling_customization); end
944
+ def set_expected_received_count(relativity, n); end
945
+ def terminal_implementation_action=(action); end
946
+ def warn_about_stub_override; end
947
+ def wrap_original(method_name, &block); end
948
+ end
949
+
950
+ class RSpec::Mocks::MethodDouble
951
+ def initialize(object, method_name, proxy); end
952
+
953
+ def add_default_stub(*args, &implementation); end
954
+ def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
955
+ def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
956
+ def add_simple_stub(method_name, response); end
957
+ def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end
958
+ def build_expectation(error_generator, expectation_ordering); end
959
+ def clear; end
960
+ def configure_method; end
961
+ def define_proxy_method; end
962
+ def expectations; end
963
+ def message_expectation_class; end
964
+ def method_name; end
965
+ def method_stasher; end
966
+ def object; end
967
+ def object_singleton_class; end
968
+ def original_implementation_callable; end
969
+ def original_method; end
970
+ def proxy_method_invoked(_obj, *args, &block); end
971
+ def raise_method_not_stubbed_error; end
972
+ def remove_stub; end
973
+ def remove_stub_if_present; end
974
+ def reset; end
975
+ def restore_original_method; end
976
+ def restore_original_visibility; end
977
+ def save_original_implementation_callable!; end
978
+ def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end
979
+ def show_frozen_warning; end
980
+ def stubs; end
981
+ def verify; end
982
+ def visibility; end
983
+
984
+ private
985
+
986
+ def definition_target; end
987
+ def new_rspec_prepended_module; end
988
+ def remove_method_from_definition_target; end
989
+ def usable_rspec_prepended_module; end
990
+ end
991
+
992
+ class RSpec::Mocks::MethodDouble::RSpecPrependedModule < ::Module; end
993
+
994
+ class RSpec::Mocks::MethodReference
995
+ def initialize(object_reference, method_name); end
996
+
997
+ def defined?; end
998
+ def implemented?; end
999
+ def unimplemented?; end
1000
+ def visibility; end
1001
+ def with_signature; end
1002
+
1003
+ private
1004
+
1005
+ def original_method; end
1006
+
1007
+ class << self
1008
+ def for(object_reference, method_name); end
1009
+ def instance_method_visibility_for(klass, method_name); end
1010
+ def method_defined_at_any_visibility?(klass, method_name); end
1011
+ def method_visibility_for(object, method_name); end
1012
+ end
1013
+ end
1014
+
1015
+ class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception; end
1016
+ class RSpec::Mocks::MockExpectationError < ::Exception; end
1017
+
1018
+ class RSpec::Mocks::NamedObjectReference
1019
+ def initialize(const_name); end
1020
+
1021
+ def const_to_replace; end
1022
+ def defined?; end
1023
+ def description; end
1024
+ def target; end
1025
+ def when_loaded; end
1026
+
1027
+ private
1028
+
1029
+ def object; end
1030
+ end
1031
+
1032
+ class RSpec::Mocks::NegationUnsupportedError < ::StandardError; end
1033
+
1034
+ class RSpec::Mocks::NestedSpace < ::RSpec::Mocks::Space
1035
+ def initialize(parent); end
1036
+
1037
+ def constant_mutator_for(name); end
1038
+ def proxies_of(klass); end
1039
+ def registered?(object); end
1040
+
1041
+ private
1042
+
1043
+ def any_instance_recorder_not_found_for(id, klass); end
1044
+ def proxy_not_found_for(id, object); end
1045
+ end
1046
+
1047
+ class RSpec::Mocks::NoCallbackInvocationStrategy
1048
+ def call(_doubled_module); end
1049
+ end
1050
+
1051
+ class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference
1052
+ private
1053
+
1054
+ def find_method(object); end
1055
+ def method_defined?(object); end
1056
+ def method_implemented?(object); end
1057
+ def visibility_from(object); end
1058
+
1059
+ class << self
1060
+ def for(object_reference, method_name); end
1061
+ end
1062
+ end
1063
+
1064
+ class RSpec::Mocks::ObjectReference
1065
+ class << self
1066
+ def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end
1067
+
1068
+ private
1069
+
1070
+ def anonymous_module?(mod); end
1071
+ def name_of(mod); end
1072
+ end
1073
+ end
1074
+
1075
+ RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
1076
+
1077
+ class RSpec::Mocks::ObjectVerifyingDouble
1078
+ include ::RSpec::Mocks::TestDouble
1079
+ include ::RSpec::Mocks::VerifyingDouble
1080
+ include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
1081
+ end
1082
+
1083
+ module RSpec::Mocks::ObjectVerifyingDoubleMethods
1084
+ include ::RSpec::Mocks::TestDouble
1085
+ include ::RSpec::Mocks::VerifyingDouble
1086
+
1087
+ def as_stubbed_const(options = T.unsafe(nil)); end
1088
+
1089
+ private
1090
+
1091
+ def __build_mock_proxy(order_group); end
1092
+ end
1093
+
1094
+ class RSpec::Mocks::OrderGroup
1095
+ def initialize; end
1096
+
1097
+ def clear; end
1098
+ def consume; end
1099
+ def empty?; end
1100
+ def handle_order_constraint(expectation); end
1101
+ def invoked(message); end
1102
+ def ready_for?(expectation); end
1103
+ def register(expectation); end
1104
+ def verify_invocation_order(expectation); end
1105
+
1106
+ private
1107
+
1108
+ def expectation_for(message); end
1109
+ def expectations_invoked_in_order?; end
1110
+ def expected_invocations; end
1111
+ def invoked_expectations; end
1112
+ def remaining_expectations; end
1113
+ end
1114
+
1115
+ class RSpec::Mocks::OutsideOfExampleError < ::StandardError; end
1116
+
1117
+ class RSpec::Mocks::PartialClassDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
1118
+ include ::RSpec::Mocks::PartialClassDoubleProxyMethods
1119
+ end
1120
+
1121
+ module RSpec::Mocks::PartialClassDoubleProxyMethods
1122
+ def initialize(source_space, *args); end
1123
+
1124
+ def original_method_handle_for(message); end
1125
+
1126
+ protected
1127
+
1128
+ def method_double_from_ancestor_for(message); end
1129
+ def original_unbound_method_handle_from_ancestor_for(message); end
1130
+ def superclass_proxy; end
1131
+ end
1132
+
1133
+ class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy
1134
+ def add_simple_expectation(method_name, response, location); end
1135
+ def add_simple_stub(method_name, response); end
1136
+ def message_received(message, *args, &block); end
1137
+ def original_method_handle_for(message); end
1138
+ def reset; end
1139
+ def visibility_for(method_name); end
1140
+
1141
+ private
1142
+
1143
+ def any_instance_class_recorder_observing_method?(klass, method_name); end
1144
+ end
1145
+
1146
+ class RSpec::Mocks::Proxy
1147
+ def initialize(object, order_group, options = T.unsafe(nil)); end
1148
+
1149
+ def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
1150
+ def add_simple_expectation(method_name, response, location); end
1151
+ def add_simple_stub(method_name, response); end
1152
+ def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
1153
+ def as_null_object; end
1154
+ def build_expectation(method_name); end
1155
+ def check_for_unexpected_arguments(expectation); end
1156
+ def ensure_can_be_proxied!(object); end
1157
+ def ensure_implemented(*_args); end
1158
+ def has_negative_expectation?(message); end
1159
+ def message_received(message, *args, &block); end
1160
+ def messages_arg_list; end
1161
+ def method_double_if_exists_for_message(message); end
1162
+ def null_object?; end
1163
+ def object; end
1164
+ def original_method_handle_for(_message); end
1165
+ def prepended_modules_of_singleton_class; end
1166
+ def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
1167
+ def raise_unexpected_message_error(method_name, args); end
1168
+ def received_message?(method_name, *args, &block); end
1169
+ def record_message_received(message, *args, &block); end
1170
+ def remove_stub(method_name); end
1171
+ def remove_stub_if_present(method_name); end
1172
+ def replay_received_message_on(expectation, &block); end
1173
+ def reset; end
1174
+ def verify; end
1175
+ def visibility_for(_method_name); end
1176
+
1177
+ private
1178
+
1179
+ def find_almost_matching_expectation(method_name, *args); end
1180
+ def find_almost_matching_stub(method_name, *args); end
1181
+ def find_best_matching_expectation_for(method_name); end
1182
+ def find_matching_expectation(method_name, *args); end
1183
+ def find_matching_method_stub(method_name, *args); end
1184
+ def method_double_for(message); end
1185
+
1186
+ class << self
1187
+ def prepended_modules_of(klass); end
1188
+ end
1189
+ end
1190
+
1191
+ RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash)
1192
+
1193
+ class RSpec::Mocks::Proxy::SpecificMessage < ::Struct
1194
+ def ==(expectation); end
1195
+ def args; end
1196
+ def args=(_); end
1197
+ def message; end
1198
+ def message=(_); end
1199
+ def object; end
1200
+ def object=(_); end
1201
+
1202
+ class << self
1203
+ def [](*_arg0); end
1204
+ def inspect; end
1205
+ def members; end
1206
+ def new(*_arg0); end
1207
+ end
1208
+ end
1209
+
1210
+ class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy
1211
+ def initialize(order_group); end
1212
+
1213
+ def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
1214
+ def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
1215
+ def disallow_expectations; end
1216
+ def disallow_expectations=(_arg0); end
1217
+ def warn_about_expectations; end
1218
+ def warn_about_expectations=(_arg0); end
1219
+
1220
+ private
1221
+
1222
+ def raise_error(method_name); end
1223
+ def set_expectation_behavior; end
1224
+ def warn(method_name); end
1225
+ def warn_or_raise!(method_name); end
1226
+ end
1227
+
1228
+ class RSpec::Mocks::RootSpace
1229
+ def any_instance_proxy_for(*_args); end
1230
+ def any_instance_recorder_for(*_args); end
1231
+ def any_instance_recorders_from_ancestry_of(_object); end
1232
+ def new_scope; end
1233
+ def proxy_for(*_args); end
1234
+ def register_constant_mutator(_mutator); end
1235
+ def registered?(_object); end
1236
+ def reset_all; end
1237
+ def superclass_proxy_for(*_args); end
1238
+ def verify_all; end
1239
+
1240
+ private
1241
+
1242
+ def raise_lifecycle_message; end
1243
+ end
1244
+
1245
+ class RSpec::Mocks::SimpleMessageExpectation
1246
+ def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end
1247
+
1248
+ def called_max_times?; end
1249
+ def invoke(*_); end
1250
+ def matches?(message, *_); end
1251
+ def unadvise(_); end
1252
+ def verify_messages_received; end
1253
+ end
1254
+
1255
+ class RSpec::Mocks::Space
1256
+ def initialize; end
1257
+
1258
+ def any_instance_mutex; end
1259
+ def any_instance_proxy_for(klass); end
1260
+ def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end
1261
+ def any_instance_recorders; end
1262
+ def any_instance_recorders_from_ancestry_of(object); end
1263
+ def constant_mutator_for(name); end
1264
+ def ensure_registered(object); end
1265
+ def new_scope; end
1266
+ def proxies; end
1267
+ def proxies_of(klass); end
1268
+ def proxy_for(object); end
1269
+ def proxy_mutex; end
1270
+ def register_constant_mutator(mutator); end
1271
+ def registered?(object); end
1272
+ def reset_all; end
1273
+ def superclass_proxy_for(klass); end
1274
+ def verify_all; end
1275
+
1276
+ private
1277
+
1278
+ def any_instance_recorder_not_found_for(id, klass); end
1279
+ def class_proxy_with_callback_verification_strategy(object, strategy); end
1280
+ def id_for(object); end
1281
+ def new_mutex; end
1282
+ def proxy_not_found_for(id, object); end
1283
+ def superclass_proxy_not_found_for(id, object); end
1284
+ end
1285
+
1286
+ class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain
1287
+ private
1288
+
1289
+ def expectation(object, message, &return_block); end
1290
+
1291
+ class << self
1292
+ def stub_chain_on(object, *chain, &blk); end
1293
+ end
1294
+ end
1295
+
1296
+ module RSpec::Mocks::Syntax
1297
+ class << self
1298
+ def default_should_syntax_host; end
1299
+ def disable_expect(syntax_host = T.unsafe(nil)); end
1300
+ def disable_should(syntax_host = T.unsafe(nil)); end
1301
+ def enable_expect(syntax_host = T.unsafe(nil)); end
1302
+ def enable_should(syntax_host = T.unsafe(nil)); end
1303
+ def expect_enabled?(syntax_host = T.unsafe(nil)); end
1304
+ def should_enabled?(syntax_host = T.unsafe(nil)); end
1305
+ def warn_about_should!; end
1306
+ def warn_unless_should_configured(method_name, replacement = T.unsafe(nil)); end
1307
+ end
1308
+ end
1309
+
1310
+ class RSpec::Mocks::TargetBase
1311
+ include ::RSpec::Mocks::TargetDelegationInstanceMethods
1312
+ extend ::RSpec::Mocks::TargetDelegationClassMethods
1313
+
1314
+ def initialize(target); end
1315
+ end
1316
+
1317
+ module RSpec::Mocks::TargetDelegationClassMethods
1318
+ def delegate_not_to(matcher_method, options = T.unsafe(nil)); end
1319
+ def delegate_to(matcher_method); end
1320
+ def disallow_negation(method_name); end
1321
+ end
1322
+
1323
+ module RSpec::Mocks::TargetDelegationInstanceMethods
1324
+ def target; end
1325
+
1326
+ private
1327
+
1328
+ def define_matcher(matcher, name, &block); end
1329
+ def matcher_allowed?(matcher); end
1330
+ def raise_negation_unsupported(method_name, matcher); end
1331
+ def raise_unsupported_matcher(method_name, matcher); end
1332
+ end
1333
+
1334
+ module RSpec::Mocks::TestDouble
1335
+ def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end
1336
+
1337
+ def ==(other); end
1338
+ def __build_mock_proxy_unless_expired(order_group); end
1339
+ def __disallow_further_usage!; end
1340
+ def as_null_object; end
1341
+ def freeze; end
1342
+ def inspect; end
1343
+ def null_object?; end
1344
+ def respond_to?(message, incl_private = T.unsafe(nil)); end
1345
+ def to_s; end
1346
+
1347
+ private
1348
+
1349
+ def __build_mock_proxy(order_group); end
1350
+ def __mock_proxy; end
1351
+ def __raise_expired_error; end
1352
+ def assign_stubs(stubs); end
1353
+ def initialize_copy(other); end
1354
+ def method_missing(message, *args, &block); end
1355
+ end
1356
+
1357
+ module RSpec::Mocks::TestDoubleFormatter
1358
+ class << self
1359
+ def format(dbl, unwrap = T.unsafe(nil)); end
1360
+
1361
+ private
1362
+
1363
+ def name_desc(dbl); end
1364
+ def type_desc(dbl); end
1365
+ def verified_module_desc(dbl); end
1366
+ end
1367
+ end
1368
+
1369
+ class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy
1370
+ def reset; end
1371
+ end
1372
+
1373
+ class RSpec::Mocks::UnsupportedMatcherError < ::StandardError; end
1374
+
1375
+ module RSpec::Mocks::VerifyingDouble
1376
+ def initialize(doubled_module, *args); end
1377
+
1378
+ def __send__(name, *args, &block); end
1379
+ def method_missing(message, *args, &block); end
1380
+ def respond_to?(message, include_private = T.unsafe(nil)); end
1381
+ def send(name, *args, &block); end
1382
+ end
1383
+
1384
+ module RSpec::Mocks::VerifyingDouble::SilentIO
1385
+ class << self
1386
+ def method_missing(*_arg0); end
1387
+ def respond_to?(*_arg0); end
1388
+ end
1389
+ end
1390
+
1391
+ class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError; end
1392
+
1393
+ class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < ::RSpec::Mocks::VerifyingExistingMethodDouble
1394
+ def with_signature; end
1395
+ end
1396
+
1397
+ class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMethodDouble
1398
+ def initialize(object, method_name, proxy); end
1399
+
1400
+ def unimplemented?; end
1401
+ def with_signature; end
1402
+
1403
+ class << self
1404
+ def for(object, method_name, proxy); end
1405
+ end
1406
+ end
1407
+
1408
+ class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation
1409
+ def initialize(*args); end
1410
+
1411
+ def method_reference; end
1412
+ def method_reference=(_arg0); end
1413
+ def with(*args, &block); end
1414
+
1415
+ private
1416
+
1417
+ def validate_expected_arguments!; end
1418
+ end
1419
+
1420
+ class RSpec::Mocks::VerifyingMethodDouble < ::RSpec::Mocks::MethodDouble
1421
+ def initialize(object, method_name, proxy, method_reference); end
1422
+
1423
+ def add_expectation(*args, &block); end
1424
+ def add_stub(*args, &block); end
1425
+ def message_expectation_class; end
1426
+ def proxy_method_invoked(obj, *args, &block); end
1427
+ def validate_arguments!(actual_args); end
1428
+ end
1429
+
1430
+ class RSpec::Mocks::VerifyingPartialClassDoubleProxy < ::RSpec::Mocks::VerifyingPartialDoubleProxy
1431
+ include ::RSpec::Mocks::PartialClassDoubleProxyMethods
1432
+ end
1433
+
1434
+ class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
1435
+ include ::RSpec::Mocks::VerifyingProxyMethods
1436
+
1437
+ def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end
1438
+
1439
+ def ensure_implemented(_method_name); end
1440
+ def method_reference; end
1441
+ end
1442
+
1443
+ class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy
1444
+ include ::RSpec::Mocks::VerifyingProxyMethods
1445
+
1446
+ def initialize(object, order_group, doubled_module, method_reference_class); end
1447
+
1448
+ def method_reference; end
1449
+ def validate_arguments!(method_name, args); end
1450
+ def visibility_for(method_name); end
1451
+ end
1452
+
1453
+ module RSpec::Mocks::VerifyingProxyMethods
1454
+ def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
1455
+ def add_simple_stub(method_name, *args); end
1456
+ def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
1457
+ def ensure_implemented(method_name); end
1458
+ def ensure_publicly_implemented(method_name, _object); end
1459
+ end
1460
+
1461
+ module RSpec::Mocks::Version; end
1462
+ RSpec::Mocks::Version::STRING = T.let(T.unsafe(nil), String)