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,1462 +0,0 @@
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)