bhook 0.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (51) hide show
  1. checksums.yaml +7 -0
  2. data/.rspec +3 -0
  3. data/.rubocop.yml +3 -0
  4. data/.ruby-version +1 -0
  5. data/Gemfile +6 -0
  6. data/Gemfile.lock +82 -0
  7. data/LICENSE.txt +21 -0
  8. data/README.md +27 -0
  9. data/Rakefile +13 -0
  10. data/bin/bhook +11 -0
  11. data/lib/bhook/args_parser.rb +55 -0
  12. data/lib/bhook/converter/html.rb +51 -0
  13. data/lib/bhook/directory.rb +62 -0
  14. data/lib/bhook/md_file.rb +50 -0
  15. data/lib/bhook/theme/_after_h1.erb +7 -0
  16. data/lib/bhook/theme/page.erb +71 -0
  17. data/lib/bhook/version.rb +6 -0
  18. data/lib/bhook/workspace.rb +45 -0
  19. data/lib/bhook.rb +22 -0
  20. data/sorbet/config +3 -0
  21. data/sorbet/rbi/gems/ast.rbi +49 -0
  22. data/sorbet/rbi/gems/bhook.rbi +15 -0
  23. data/sorbet/rbi/gems/git.rbi +531 -0
  24. data/sorbet/rbi/gems/kramdown.rbi +255 -0
  25. data/sorbet/rbi/gems/listen.rbi +304 -0
  26. data/sorbet/rbi/gems/parallel.rbi +83 -0
  27. data/sorbet/rbi/gems/parser.rbi +1440 -0
  28. data/sorbet/rbi/gems/rainbow.rbi +122 -0
  29. data/sorbet/rbi/gems/rake.rbi +644 -0
  30. data/sorbet/rbi/gems/rchardet.rbi +181 -0
  31. data/sorbet/rbi/gems/regexp_parser.rbi +929 -0
  32. data/sorbet/rbi/gems/rexml.rbi +599 -0
  33. data/sorbet/rbi/gems/rspec-core.rbi +1898 -0
  34. data/sorbet/rbi/gems/rspec-expectations.rbi +1171 -0
  35. data/sorbet/rbi/gems/rspec-mocks.rbi +1094 -0
  36. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  37. data/sorbet/rbi/gems/rspec.rbi +15 -0
  38. data/sorbet/rbi/gems/rubocop-ast.rbi +1385 -0
  39. data/sorbet/rbi/gems/rubocop-rake.rbi +85 -0
  40. data/sorbet/rbi/gems/rubocop-rspec.rbi +1044 -0
  41. data/sorbet/rbi/gems/rubocop.rbi +8593 -0
  42. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  43. data/sorbet/rbi/gems/unicode-display_width.rbi +20 -0
  44. data/sorbet/rbi/hidden-definitions/errors.txt +4944 -0
  45. data/sorbet/rbi/hidden-definitions/hidden.rbi +10044 -0
  46. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
  47. data/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +645 -0
  48. data/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +24 -0
  49. data/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi +12 -0
  50. data/sorbet/rbi/todo.rbi +7 -0
  51. metadata +235 -0
@@ -0,0 +1,1171 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-expectations/all/rspec-expectations.rbi
9
+ #
10
+ # rspec-expectations-3.11.0
11
+
12
+ module RSpec
13
+ end
14
+ module RSpec::Matchers
15
+ def a_block_changing(*args, &block); end
16
+ def a_block_outputting(*args, &block); end
17
+ def a_block_raising(*args, &block); end
18
+ def a_block_throwing(*args, &block); end
19
+ def a_block_yielding_control(*args, &block); end
20
+ def a_block_yielding_successive_args(*args, &block); end
21
+ def a_block_yielding_with_args(*args, &block); end
22
+ def a_block_yielding_with_no_args(*args, &block); end
23
+ def a_collection_containing_exactly(*args, &block); end
24
+ def a_collection_ending_with(*args, &block); end
25
+ def a_collection_including(*args, &block); end
26
+ def a_collection_starting_with(*args, &block); end
27
+ def a_falsey_value(*args, &block); end
28
+ def a_falsy_value(*args, &block); end
29
+ def a_hash_including(*args, &block); end
30
+ def a_kind_of(*args, &block); end
31
+ def a_nil_value(*args, &block); end
32
+ def a_range_covering(*args, &block); end
33
+ def a_string_ending_with(*args, &block); end
34
+ def a_string_including(*args, &block); end
35
+ def a_string_matching(*args, &block); end
36
+ def a_string_starting_with(*args, &block); end
37
+ def a_truthy_value(*args, &block); end
38
+ def a_value(*args, &block); end
39
+ def a_value_between(*args, &block); end
40
+ def a_value_within(*args, &block); end
41
+ def aggregate_failures(label = nil, metadata = nil, &block); end
42
+ def all(expected); end
43
+ def an_instance_of(*args, &block); end
44
+ def an_object_eq_to(*args, &block); end
45
+ def an_object_eql_to(*args, &block); end
46
+ def an_object_equal_to(*args, &block); end
47
+ def an_object_existing(*args, &block); end
48
+ def an_object_having_attributes(*args, &block); end
49
+ def an_object_matching(*args, &block); end
50
+ def an_object_responding_to(*args, &block); end
51
+ def an_object_satisfying(*args, &block); end
52
+ def be(*args); end
53
+ def be_a(klass); end
54
+ def be_a_kind_of(expected); end
55
+ def be_an(klass); end
56
+ def be_an_instance_of(expected); end
57
+ def be_between(min, max); end
58
+ def be_falsey; end
59
+ def be_falsy(*args, &block); end
60
+ def be_instance_of(expected); end
61
+ def be_kind_of(expected); end
62
+ def be_nil; end
63
+ def be_truthy; end
64
+ def be_within(delta); end
65
+ def change(receiver = nil, message = nil, &block); end
66
+ def changing(*args, &block); end
67
+ def contain_exactly(*items); end
68
+ def containing_exactly(*args, &block); end
69
+ def cover(*values); end
70
+ def covering(*args, &block); end
71
+ def end_with(*expected); end
72
+ def ending_with(*args, &block); end
73
+ def eq(expected); end
74
+ def eq_to(*args, &block); end
75
+ def eql(expected); end
76
+ def eql_to(*args, &block); end
77
+ def equal(expected); end
78
+ def equal_to(*args, &block); end
79
+ def exist(*args); end
80
+ def existing(*args, &block); end
81
+ def expect(value = nil, &block); end
82
+ def have_attributes(expected); end
83
+ def having_attributes(*args, &block); end
84
+ def include(*expected); end
85
+ def including(*args, &block); end
86
+ def match(expected); end
87
+ def match_array(items); end
88
+ def match_regex(*args, &block); end
89
+ def matching(*args, &block); end
90
+ def method_missing(method, *args, &block); end
91
+ def output(expected = nil); end
92
+ def raise_error(error = nil, message = nil, &block); end
93
+ def raise_exception(error = nil, message = nil, &block); end
94
+ def raising(*args, &block); end
95
+ def respond_to(*names); end
96
+ def respond_to_missing?(method, *arg1); end
97
+ def responding_to(*args, &block); end
98
+ def satisfy(description = nil, &block); end
99
+ def satisfying(*args, &block); end
100
+ def self.alias_matcher(*args, &block); end
101
+ def self.clear_generated_description; end
102
+ def self.configuration; end
103
+ def self.generated_description; end
104
+ def self.is_a_describable_matcher?(obj); end
105
+ def self.is_a_matcher?(obj); end
106
+ def self.last_description; end
107
+ def self.last_expectation_handler; end
108
+ def self.last_expectation_handler=(arg0); end
109
+ def self.last_matcher; end
110
+ def self.last_matcher=(arg0); end
111
+ def start_with(*expected); end
112
+ def starting_with(*args, &block); end
113
+ def throw_symbol(expected_symbol = nil, expected_arg = nil); end
114
+ def throwing(*args, &block); end
115
+ def within(*args, &block); end
116
+ def yield_control; end
117
+ def yield_successive_args(*args); end
118
+ def yield_with_args(*args); end
119
+ def yield_with_no_args; end
120
+ def yielding_control(*args, &block); end
121
+ def yielding_successive_args(*args, &block); end
122
+ def yielding_with_args(*args, &block); end
123
+ def yielding_with_no_args(*args, &block); end
124
+ extend RSpec::Matchers::DSL
125
+ end
126
+ module RSpec::Matchers::EnglishPhrasing
127
+ def self.list(obj); end
128
+ def self.split_words(sym); end
129
+ end
130
+ module RSpec::Matchers::Composable
131
+ def &(matcher); end
132
+ def ===(value); end
133
+ def and(matcher); end
134
+ def description_of(object); end
135
+ def or(matcher); end
136
+ def self.should_enumerate?(item); end
137
+ def self.surface_descriptions_in(item); end
138
+ def self.unreadable_io?(object); end
139
+ def should_enumerate?(item); end
140
+ def surface_descriptions_in(item); end
141
+ def unreadable_io?(object); end
142
+ def values_match?(expected, actual); end
143
+ def with_matchers_cloned(object); end
144
+ def |(matcher); end
145
+ end
146
+ class RSpec::Matchers::Composable::DescribableItem < Struct
147
+ def inspect; end
148
+ def item; end
149
+ def item=(_); end
150
+ def pretty_print(pp); end
151
+ def self.[](*arg0); end
152
+ def self.inspect; end
153
+ def self.members; end
154
+ def self.new(*arg0); end
155
+ end
156
+ module RSpec::Matchers::BuiltIn
157
+ end
158
+ class RSpec::Matchers::BuiltIn::BaseMatcher
159
+ def actual; end
160
+ def actual_formatted; end
161
+ def assert_ivars(*expected_ivars); end
162
+ def description; end
163
+ def diffable?; end
164
+ def expected; end
165
+ def expected_formatted; end
166
+ def expects_call_stack_jump?; end
167
+ def initialize(expected = nil); end
168
+ def match_unless_raises(*exceptions); end
169
+ def matcher_name; end
170
+ def matcher_name=(arg0); end
171
+ def matches?(actual); end
172
+ def present_ivars; end
173
+ def rescued_exception; end
174
+ def self.matcher_name; end
175
+ def self.underscore(camel_cased_word); end
176
+ def supports_block_expectations?; end
177
+ def supports_value_expectations?; end
178
+ include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
179
+ include RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
180
+ include RSpec::Matchers::Composable
181
+ end
182
+ module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
183
+ def improve_hash_formatting(inspect_string); end
184
+ def self.improve_hash_formatting(inspect_string); end
185
+ end
186
+ module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
187
+ def failure_message; end
188
+ def failure_message_when_negated; end
189
+ def self.has_default_failure_messages?(matcher); end
190
+ end
191
+ module RSpec::Matchers::DSL
192
+ def alias_matcher(new_name, old_name, options = nil, &description_override); end
193
+ def define(name, &declarations); end
194
+ def define_negated_matcher(negated_name, base_name, &description_override); end
195
+ def matcher(name, &declarations); end
196
+ def warn_about_block_args(name, declarations); end
197
+ end
198
+ module RSpec::Matchers::DSL::Macros
199
+ def assign_attributes(attr_names); end
200
+ def chain(method_name, *attr_names, &definition); end
201
+ def define_user_override(method_name, user_def, &our_def); end
202
+ def description(&definition); end
203
+ def diffable; end
204
+ def failure_message(&definition); end
205
+ def failure_message_when_negated(&definition); end
206
+ def match(options = nil, &match_block); end
207
+ def match_unless_raises(expected_exception = nil, &match_block); end
208
+ def match_when_negated(options = nil, &match_block); end
209
+ def supports_block_expectations; end
210
+ end
211
+ module RSpec::Matchers::DSL::Macros::Deprecated
212
+ def failure_message_for_should(&definition); end
213
+ def failure_message_for_should_not(&definition); end
214
+ def match_for_should(&definition); end
215
+ def match_for_should_not(&definition); end
216
+ end
217
+ module RSpec::Matchers::DSL::DefaultImplementations
218
+ def chained_method_clause_sentences; end
219
+ def description; end
220
+ def diffable?; end
221
+ def expects_call_stack_jump?; end
222
+ def supports_block_expectations?; end
223
+ def supports_value_expectations?; end
224
+ include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
225
+ end
226
+ class RSpec::Matchers::DSL::Matcher
227
+ def actual; end
228
+ def actual_arg_for(block); end
229
+ def block_arg; end
230
+ def expected; end
231
+ def expected_as_array; end
232
+ def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
233
+ def inspect; end
234
+ def method_missing(method, *args, &block); end
235
+ def name; end
236
+ def rescued_exception; end
237
+ def respond_to_missing?(method, include_private = nil); end
238
+ extend RSpec::Matchers::DSL::Macros
239
+ extend RSpec::Matchers::DSL::Macros::Deprecated
240
+ include RSpec::Matchers
241
+ include RSpec::Matchers::Composable
242
+ include RSpec::Matchers::DSL::DefaultImplementations
243
+ end
244
+ class RSpec::Matchers::MatcherDelegator
245
+ def base_matcher; end
246
+ def initialize(base_matcher); end
247
+ def initialize_copy(other); end
248
+ def method_missing(*args, &block); end
249
+ def respond_to_missing?(name, include_all = nil); end
250
+ include RSpec::Matchers::Composable
251
+ end
252
+ class RSpec::Matchers::AliasedMatcher < RSpec::Matchers::MatcherDelegator
253
+ def description; end
254
+ def failure_message; end
255
+ def failure_message_when_negated; end
256
+ def initialize(base_matcher, description_block); end
257
+ def method_missing(*arg0); end
258
+ end
259
+ class RSpec::Matchers::AliasedMatcherWithOperatorSupport < RSpec::Matchers::AliasedMatcher
260
+ end
261
+ class RSpec::Matchers::AliasedNegatedMatcher < RSpec::Matchers::AliasedMatcher
262
+ def does_not_match?(*args, &block); end
263
+ def failure_message; end
264
+ def failure_message_when_negated; end
265
+ def matches?(*args, &block); end
266
+ def optimal_failure_message(same, inverted); end
267
+ end
268
+ class RSpec::Matchers::ExpectedsForMultipleDiffs
269
+ def diffs(differ, actual); end
270
+ def initialize(expected_list); end
271
+ def message_with_diff(message, differ, actual); end
272
+ def self.diff_label_for(matcher); end
273
+ def self.for_many_matchers(matchers); end
274
+ def self.from(expected); end
275
+ def self.truncated(description); end
276
+ end
277
+ module RSpec::Support
278
+ def self.require_rspec_expectations(f); end
279
+ def self.require_rspec_matchers(f); end
280
+ end
281
+ module RSpec::Expectations
282
+ def self.configuration; end
283
+ def self.differ; end
284
+ def self.fail_with(message, expected = nil, actual = nil); end
285
+ end
286
+ class RSpec::Expectations::ExpectationTarget
287
+ def initialize(value); end
288
+ def self.for(value, block); end
289
+ def target; end
290
+ include RSpec::Expectations::ExpectationTarget::InstanceMethods
291
+ end
292
+ module RSpec::Expectations::ExpectationTarget::UndefinedValue
293
+ end
294
+ module RSpec::Expectations::ExpectationTarget::InstanceMethods
295
+ def not_to(matcher = nil, message = nil, &block); end
296
+ def prevent_operator_matchers(verb); end
297
+ def to(matcher = nil, message = nil, &block); end
298
+ def to_not(matcher = nil, message = nil, &block); end
299
+ end
300
+ class RSpec::Expectations::ValueExpectationTarget < RSpec::Expectations::ExpectationTarget
301
+ def enforce_value_expectation(matcher); end
302
+ def not_to(matcher = nil, message = nil, &block); end
303
+ def supports_value_expectations?(matcher); end
304
+ def to(matcher = nil, message = nil, &block); end
305
+ end
306
+ class RSpec::Expectations::BlockExpectationTarget < RSpec::Expectations::ExpectationTarget
307
+ def enforce_block_expectation(matcher); end
308
+ def not_to(matcher, message = nil, &block); end
309
+ def supports_block_expectations?(matcher); end
310
+ def to(matcher, message = nil, &block); end
311
+ def to_not(matcher, message = nil, &block); end
312
+ end
313
+ module RSpec::Expectations::Syntax
314
+ def default_should_host; end
315
+ def disable_expect(syntax_host = nil); end
316
+ def disable_should(syntax_host = nil); end
317
+ def enable_expect(syntax_host = nil); end
318
+ def enable_should(syntax_host = nil); end
319
+ def expect_enabled?(syntax_host = nil); end
320
+ def self.default_should_host; end
321
+ def self.disable_expect(syntax_host = nil); end
322
+ def self.disable_should(syntax_host = nil); end
323
+ def self.enable_expect(syntax_host = nil); end
324
+ def self.enable_should(syntax_host = nil); end
325
+ def self.expect_enabled?(syntax_host = nil); end
326
+ def self.should_enabled?(syntax_host = nil); end
327
+ def self.warn_about_should!; end
328
+ def self.warn_about_should_unless_configured(method_name); end
329
+ def should_enabled?(syntax_host = nil); end
330
+ def warn_about_should!; end
331
+ def warn_about_should_unless_configured(method_name); end
332
+ end
333
+ class BasicObject
334
+ end
335
+ class RSpec::Expectations::Configuration
336
+ def add_should_and_should_not_to(*modules); end
337
+ def backtrace_formatter; end
338
+ def backtrace_formatter=(arg0); end
339
+ def color?; end
340
+ def false_positives_handler; end
341
+ def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end
342
+ def include_chain_clauses_in_custom_matcher_descriptions?; end
343
+ def initialize; end
344
+ def max_formatted_output_length=(length); end
345
+ def on_potential_false_positives; end
346
+ def on_potential_false_positives=(behavior); end
347
+ def reset_syntaxes_to_default; end
348
+ def strict_predicate_matchers; end
349
+ def strict_predicate_matchers=(flag); end
350
+ def strict_predicate_matchers?; end
351
+ def syntax; end
352
+ def syntax=(values); end
353
+ def warn_about_potential_false_positives=(boolean); end
354
+ def warn_about_potential_false_positives?; end
355
+ end
356
+ module RSpec::Expectations::Configuration::NullBacktraceFormatter
357
+ def self.format_backtrace(backtrace); end
358
+ end
359
+ class InvalidName___Class_0x00___Differ_1
360
+ end
361
+ module RSpec::Expectations::ExpectationHelper
362
+ def self.check_message(msg); end
363
+ def self.handle_failure(matcher, message, failure_message_method); end
364
+ def self.modern_matcher_from(matcher); end
365
+ def self.with_matcher(handler, matcher, message); end
366
+ end
367
+ class RSpec::Expectations::PositiveExpectationHandler
368
+ def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
369
+ def self.opposite_should_method; end
370
+ def self.should_method; end
371
+ def self.verb; end
372
+ end
373
+ class RSpec::Expectations::NegativeExpectationHandler
374
+ def self.does_not_match?(matcher, actual, &block); end
375
+ def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
376
+ def self.opposite_should_method; end
377
+ def self.should_method; end
378
+ def self.verb; end
379
+ end
380
+ class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator
381
+ def initialize(matcher); end
382
+ def self.wrap(matcher); end
383
+ end
384
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter
385
+ def failure_message; end
386
+ def failure_message_when_negated; end
387
+ def self.interface_matches?(matcher); end
388
+ end
389
+ class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter
390
+ def failure_message; end
391
+ def failure_message_when_negated; end
392
+ def self.interface_matches?(matcher); end
393
+ end
394
+ module RSpec::Expectations::Version
395
+ end
396
+ class RSpec::Expectations::ExpectationNotMetError < Exception
397
+ end
398
+ class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError
399
+ def aggregation_block_label; end
400
+ def aggregation_metadata; end
401
+ def all_exceptions; end
402
+ def backtrace_line(line); end
403
+ def block_description; end
404
+ def enumerated(exceptions, index_offset); end
405
+ def enumerated_errors; end
406
+ def enumerated_failures; end
407
+ def exception_count_description; end
408
+ def exclusion_patterns; end
409
+ def failures; end
410
+ def format_backtrace(backtrace); end
411
+ def indentation; end
412
+ def indented(failure_message, index); end
413
+ def index_label(index); end
414
+ def initialize(failure_aggregator); end
415
+ def longest_index_label_width; end
416
+ def message; end
417
+ def other_errors; end
418
+ def pluralize(noun, count); end
419
+ def summary; end
420
+ def width_of_label(index); end
421
+ end
422
+ class RSpec::Expectations::BlockSnippetExtractor
423
+ def beginning_line_number; end
424
+ def block_token_extractor; end
425
+ def body_content_lines; end
426
+ def file_path; end
427
+ def initialize(proc, method_name); end
428
+ def method_name; end
429
+ def proc; end
430
+ def raw_body_lines; end
431
+ def raw_body_snippet; end
432
+ def self.try_extracting_single_line_body_of(proc, method_name); end
433
+ def source; end
434
+ def source_location; end
435
+ end
436
+ class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError
437
+ end
438
+ class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error
439
+ end
440
+ class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error
441
+ end
442
+ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct
443
+ def after_beginning_of_args_state(token); end
444
+ def after_beginning_of_body_state(token); end
445
+ def after_method_call_state(token); end
446
+ def after_opener_state(token); end
447
+ def beginning_line_number; end
448
+ def beginning_line_number=(_); end
449
+ def block_locator; end
450
+ def body_tokens; end
451
+ def correct_block?(body_tokens); end
452
+ def finalize_pending_tokens!; end
453
+ def finish!; end
454
+ def finish_or_find_next_block_if_incorrect!; end
455
+ def handle_closer_token(token); end
456
+ def handle_opener_token(token); end
457
+ def initial_state(token); end
458
+ def initialize(*arg0); end
459
+ def invoke_state_handler(token); end
460
+ def method_name; end
461
+ def method_name=(_); end
462
+ def opener_token?(token); end
463
+ def opener_token_stack; end
464
+ def parse!; end
465
+ def pending_tokens; end
466
+ def pipe_token?(token); end
467
+ def self.[](*arg0); end
468
+ def self.inspect; end
469
+ def self.members; end
470
+ def self.new(*arg0); end
471
+ def source; end
472
+ def source=(_); end
473
+ def state; end
474
+ end
475
+ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct
476
+ def beginning_line_number; end
477
+ def beginning_line_number=(_); end
478
+ def block_body_node; end
479
+ def block_wrapper_node; end
480
+ def body_content_locations; end
481
+ def candidate_block_wrapper_nodes; end
482
+ def candidate_method_ident_nodes; end
483
+ def method_call_location; end
484
+ def method_ident_node; end
485
+ def method_ident_node?(node); end
486
+ def method_name; end
487
+ def method_name=(_); end
488
+ def self.[](*arg0); end
489
+ def self.inspect; end
490
+ def self.members; end
491
+ def self.new(*arg0); end
492
+ def source; end
493
+ def source=(_); end
494
+ end
495
+ class RSpec::Expectations::FailureAggregator
496
+ def aggregate; end
497
+ def assign_backtrace(failure); end
498
+ def block_label; end
499
+ def call(failure, options); end
500
+ def failures; end
501
+ def initialize(block_label, metadata); end
502
+ def metadata; end
503
+ def notify_aggregated_failures; end
504
+ def other_errors; end
505
+ end
506
+ class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher
507
+ def match(expected, actual); end
508
+ end
509
+ class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher
510
+ def description; end
511
+ def match(expected, actual); end
512
+ end
513
+ class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher
514
+ def comparable?; end
515
+ def compare; end
516
+ def description; end
517
+ def exclusive; end
518
+ def failure_message; end
519
+ def inclusive; end
520
+ def initialize(min, max); end
521
+ def matches?(actual); end
522
+ def not_comparable_clause; end
523
+ end
524
+ class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher
525
+ def failure_message; end
526
+ def failure_message_when_negated; end
527
+ def match(_, actual); end
528
+ end
529
+ class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher
530
+ def failure_message; end
531
+ def failure_message_when_negated; end
532
+ def match(_, actual); end
533
+ end
534
+ class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher
535
+ def failure_message; end
536
+ def failure_message_when_negated; end
537
+ def match(_, actual); end
538
+ end
539
+ module RSpec::Matchers::BuiltIn::BeHelpers
540
+ def args_to_s; end
541
+ def args_to_sentence; end
542
+ def expected_to_sentence; end
543
+ def inspected_args; end
544
+ def parenthesize(string); end
545
+ end
546
+ class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher
547
+ def <(operand); end
548
+ def <=(operand); end
549
+ def ==(operand); end
550
+ def ===(operand); end
551
+ def =~(operand); end
552
+ def >(operand); end
553
+ def >=(operand); end
554
+ def failure_message; end
555
+ def failure_message_when_negated; end
556
+ def initialize(*args); end
557
+ def match(_, actual); end
558
+ include RSpec::Matchers::BuiltIn::BeHelpers
559
+ end
560
+ class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher
561
+ def description; end
562
+ def does_not_match?(actual); end
563
+ def failure_message; end
564
+ def failure_message_when_negated; end
565
+ def initialize(operand, operator); end
566
+ def matches?(actual); end
567
+ def perform_match(actual); end
568
+ include RSpec::Matchers::BuiltIn::BeHelpers
569
+ end
570
+ class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher
571
+ def description; end
572
+ def does_not_match?(actual, &block); end
573
+ def expectation_of(value); end
574
+ def failure_message; end
575
+ def failure_message_expecting(value); end
576
+ def failure_message_when_negated; end
577
+ def failure_to_respond_explanation; end
578
+ def initialize(method_name, *args, &block); end
579
+ def matches?(actual, &block); end
580
+ def method_description; end
581
+ def predicate_accessible?; end
582
+ def predicate_matches?(value = nil); end
583
+ def predicate_method_name; end
584
+ def predicate_result; end
585
+ def private_predicate?; end
586
+ def root; end
587
+ def validity_message; end
588
+ include RSpec::Matchers::BuiltIn::BeHelpers
589
+ end
590
+ class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate
591
+ def predicate; end
592
+ end
593
+ class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate
594
+ def failure_to_respond_explanation; end
595
+ def predicate; end
596
+ def predicate_accessible?; end
597
+ def predicate_method_name; end
598
+ def present_tense_predicate; end
599
+ end
600
+ class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher
601
+ def description; end
602
+ def failure_message; end
603
+ def failure_message_when_negated; end
604
+ def initialize(delta); end
605
+ def matches?(actual); end
606
+ def needs_expected; end
607
+ def not_numeric_clause; end
608
+ def numeric?; end
609
+ def of(expected); end
610
+ def percent_of(expected); end
611
+ end
612
+ class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher
613
+ def by(expected_delta); end
614
+ def by_at_least(minimum); end
615
+ def by_at_most(maximum); end
616
+ def change_details; end
617
+ def description; end
618
+ def does_not_match?(event_proc); end
619
+ def failure_message; end
620
+ def failure_message_when_negated; end
621
+ def from(value); end
622
+ def initialize(receiver = nil, message = nil, &block); end
623
+ def matches?(event_proc); end
624
+ def negative_failure_reason; end
625
+ def perform_change(event_proc); end
626
+ def positive_failure_reason; end
627
+ def raise_block_syntax_error; end
628
+ def supports_block_expectations?; end
629
+ def supports_value_expectations?; end
630
+ def to(value); end
631
+ end
632
+ class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher
633
+ def description; end
634
+ def does_not_match?(_event_proc); end
635
+ def failure_message; end
636
+ def failure_reason; end
637
+ def initialize(change_details, expected_delta, relativity, &comparer); end
638
+ def matches?(event_proc); end
639
+ def supports_block_expectations?; end
640
+ def supports_value_expectations?; end
641
+ end
642
+ class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher
643
+ def after_value_failure; end
644
+ def before_value_failure; end
645
+ def description; end
646
+ def did_change_failure; end
647
+ def did_not_change_failure; end
648
+ def failure_message; end
649
+ def initialize(change_details, from, to); end
650
+ def matches?(event_proc); end
651
+ def matches_after?; end
652
+ def not_given_a_block_failure; end
653
+ def perform_change(event_proc); end
654
+ def supports_block_expectations?; end
655
+ def supports_value_expectations?; end
656
+ end
657
+ class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
658
+ def change_description; end
659
+ def does_not_match?(event_proc); end
660
+ def failure_message_when_negated; end
661
+ def initialize(change_details, expected_before); end
662
+ def to(value); end
663
+ end
664
+ class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
665
+ def change_description; end
666
+ def does_not_match?(_event_proc); end
667
+ def from(value); end
668
+ def initialize(change_details, expected_after); end
669
+ end
670
+ class RSpec::Matchers::BuiltIn::ChangeDetails
671
+ def actual_after; end
672
+ def actual_delta; end
673
+ def changed?; end
674
+ def evaluate_value_proc; end
675
+ def extract_value_block_snippet; end
676
+ def initialize(matcher_name, receiver = nil, message = nil, &block); end
677
+ def message_notation(receiver, message); end
678
+ def perform_change(event_proc); end
679
+ def value_representation; end
680
+ end
681
+ module RSpec::Matchers::BuiltIn::ChangeDetails::UNDEFINED
682
+ end
683
+ class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher
684
+ def compound_failure_message; end
685
+ def description; end
686
+ def diffable?; end
687
+ def diffable_matcher_list; end
688
+ def diffable_matcher_list_for(matcher); end
689
+ def does_not_match?(_actual); end
690
+ def evaluator; end
691
+ def expected; end
692
+ def expects_call_stack_jump?; end
693
+ def indent_multiline_message(message); end
694
+ def initialize(matcher_1, matcher_2); end
695
+ def initialize_copy(other); end
696
+ def match(_expected, actual); end
697
+ def matcher_1; end
698
+ def matcher_1_matches?; end
699
+ def matcher_2; end
700
+ def matcher_2_matches?; end
701
+ def matcher_is_diffable?(matcher); end
702
+ def matcher_supports_block_expectations?(matcher); end
703
+ def matcher_supports_value_expectations?(matcher); end
704
+ def supports_block_expectations?; end
705
+ def supports_value_expectations?; end
706
+ end
707
+ class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
708
+ def initialize(actual, *arg1); end
709
+ def matcher_matches?(matcher); end
710
+ end
711
+ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
712
+ def initialize(actual, matcher_1, matcher_2); end
713
+ def inner_matcher_block(outer_args); end
714
+ def matcher_matches?(matcher); end
715
+ def order_block_matchers; end
716
+ def self.matcher_expects_call_stack_jump?(matcher); end
717
+ end
718
+ class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound
719
+ def conjunction; end
720
+ def failure_message; end
721
+ def match(*arg0); end
722
+ end
723
+ class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound
724
+ def conjunction; end
725
+ def failure_message; end
726
+ def match(*arg0); end
727
+ end
728
+ class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher
729
+ def actual_collection_line; end
730
+ def best_solution; end
731
+ def convert_actual_to_an_array; end
732
+ def describe_collection(collection, surface_descriptions = nil); end
733
+ def description; end
734
+ def expected_collection_line; end
735
+ def extra_elements_line; end
736
+ def extra_items; end
737
+ def failure_message; end
738
+ def failure_message_when_negated; end
739
+ def generate_failure_message; end
740
+ def match(_expected, _actual); end
741
+ def match_when_sorted?; end
742
+ def message_line(prefix, collection, surface_descriptions = nil); end
743
+ def missing_elements_line; end
744
+ def missing_items; end
745
+ def pairings_maximizer; end
746
+ def safe_sort(array); end
747
+ def to_a_disallowed?(object); end
748
+ end
749
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
750
+ def actual_to_expected_matched_indexes; end
751
+ def apply_pairing_to(indeterminates, original_matches, other_list_index); end
752
+ def best_solution_for_pairing(expected_index, actual_index); end
753
+ def categorize_indexes(indexes_to_categorize, other_indexes); end
754
+ def expected_to_actual_matched_indexes; end
755
+ def find_best_solution; end
756
+ def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
757
+ def reciprocal_single_match?(matches, index, other_list); end
758
+ def solution; end
759
+ end
760
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct
761
+ def +(derived_candidate_solution); end
762
+ def candidate?; end
763
+ def ideal?; end
764
+ def indeterminate_actual_indexes; end
765
+ def indeterminate_actual_indexes=(_); end
766
+ def indeterminate_expected_indexes; end
767
+ def indeterminate_expected_indexes=(_); end
768
+ def self.[](*arg0); end
769
+ def self.inspect; end
770
+ def self.members; end
771
+ def self.new(*arg0); end
772
+ def unmatched_actual_indexes; end
773
+ def unmatched_actual_indexes=(_); end
774
+ def unmatched_expected_indexes; end
775
+ def unmatched_expected_indexes=(_); end
776
+ def unmatched_item_count; end
777
+ def worse_than?(other); end
778
+ end
779
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
780
+ def self.worse_than?(_other); end
781
+ end
782
+ class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher
783
+ def does_not_match?(range); end
784
+ def initialize(*expected); end
785
+ def matches?(range); end
786
+ end
787
+ class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher
788
+ def description; end
789
+ def failure_message; end
790
+ def initialize(*expected); end
791
+ def match(_expected, actual); end
792
+ def subsets_comparable?; end
793
+ end
794
+ class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith
795
+ def element_matches?; end
796
+ def subset_matches?; end
797
+ end
798
+ class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith
799
+ def element_matches?; end
800
+ def subset_matches?; end
801
+ end
802
+ class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher
803
+ def description; end
804
+ def diffable?; end
805
+ def failure_message; end
806
+ def failure_message_when_negated; end
807
+ def match(expected, actual); end
808
+ end
809
+ class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher
810
+ def diffable?; end
811
+ def failure_message; end
812
+ def failure_message_when_negated; end
813
+ def match(expected, actual); end
814
+ end
815
+ class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher
816
+ def actual_inspected; end
817
+ def detailed_failure_message; end
818
+ def diffable?; end
819
+ def expected_is_a_literal_singleton?; end
820
+ def failure_message; end
821
+ def failure_message_when_negated; end
822
+ def inspect_object(o); end
823
+ def match(expected, actual); end
824
+ def simple_failure_message; end
825
+ end
826
+ class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher
827
+ def does_not_match?(actual); end
828
+ def failure_message; end
829
+ def failure_message_when_negated; end
830
+ def initialize(*expected); end
831
+ def matches?(actual); end
832
+ end
833
+ class Anonymous_Struct_2 < Struct
834
+ def actual; end
835
+ def actual=(_); end
836
+ def expected; end
837
+ def expected=(_); end
838
+ def self.[](*arg0); end
839
+ def self.inspect; end
840
+ def self.members; end
841
+ def self.new(*arg0); end
842
+ end
843
+ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_2
844
+ def actual_exists?; end
845
+ def deprecated(predicate, actual); end
846
+ def existence_values; end
847
+ def predicates; end
848
+ def uniq_truthy_values; end
849
+ def valid_test?; end
850
+ def validity_message; end
851
+ end
852
+ class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher
853
+ def actual; end
854
+ def actual_has_attribute?(attribute_key, attribute_value); end
855
+ def cache_all_values; end
856
+ def description; end
857
+ def diffable?; end
858
+ def does_not_match?(actual); end
859
+ def failure_message; end
860
+ def failure_message_when_negated; end
861
+ def formatted_values; end
862
+ def initialize(expected); end
863
+ def matches?(actual); end
864
+ def perform_match(predicate); end
865
+ def respond_to_attributes?; end
866
+ def respond_to_failed; end
867
+ def respond_to_failure_message_or; end
868
+ def respond_to_matcher; end
869
+ end
870
+ module RSpec::Matchers::BuiltIn::CountExpectation
871
+ def at_least(number); end
872
+ def at_most(number); end
873
+ def count_constraint_to_number(n); end
874
+ def count_expectation_description; end
875
+ def count_expectation_type; end
876
+ def count_failure_reason(action); end
877
+ def cover?(count, number); end
878
+ def exactly(number); end
879
+ def expected_count; end
880
+ def expected_count_matches?(actual_count); end
881
+ def has_expected_count?; end
882
+ def human_readable_count(count); end
883
+ def human_readable_expectation_type; end
884
+ def once; end
885
+ def raise_impossible_count_expectation(count); end
886
+ def raise_unsupported_count_expectation; end
887
+ def set_expected_count(relativity, n); end
888
+ def thrice; end
889
+ def times; end
890
+ def twice; end
891
+ def unsupported_count_expectation?(relativity); end
892
+ end
893
+ class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
894
+ def actual_collection_includes?(expected_item); end
895
+ def actual_hash_has_key?(expected_key); end
896
+ def actual_hash_includes?(expected_key, expected_value); end
897
+ def check_actual?(actual); end
898
+ def check_expected_count?; end
899
+ def comparing_hash_keys?(expected_item); end
900
+ def comparing_hash_to_a_subset?(expected_item); end
901
+ def convert_to_hash?(obj); end
902
+ def count_enumerable(expected_item); end
903
+ def count_inclusions; end
904
+ def description; end
905
+ def diff_would_wrongly_highlight_matched_item?; end
906
+ def diffable?; end
907
+ def does_not_match?(actual); end
908
+ def excluded_from_actual; end
909
+ def expected; end
910
+ def expecteds; end
911
+ def failure_message; end
912
+ def failure_message_when_negated; end
913
+ def format_failure_message(preposition); end
914
+ def initialize(*expecteds); end
915
+ def matches?(actual); end
916
+ def perform_match(&block); end
917
+ def readable_list_of(items); end
918
+ include RSpec::Matchers::BuiltIn::CountExpectation
919
+ end
920
+ class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher
921
+ def add_new_line_if_needed(message); end
922
+ def description; end
923
+ def does_not_match?(_actual); end
924
+ def failed_objects; end
925
+ def failure_message; end
926
+ def failure_message_for_item(index, failure_message); end
927
+ def indent_multiline_message(message); end
928
+ def index_failed_objects; end
929
+ def initialize(matcher); end
930
+ def initialize_copy(other); end
931
+ def iterable?; end
932
+ def match(_expected, _actual); end
933
+ def matcher; end
934
+ end
935
+ class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher
936
+ def can_safely_call_match?(expected, actual); end
937
+ def description; end
938
+ def diffable?; end
939
+ def initialize(expected); end
940
+ def match(expected, actual); end
941
+ def match_captures(expected, actual); end
942
+ def with_captures(*captures); end
943
+ end
944
+ class RSpec::Matchers::BuiltIn::ReliableMatchData
945
+ def captures; end
946
+ def initialize(match_data); end
947
+ def match_data; end
948
+ def names; end
949
+ end
950
+ class RSpec::Matchers::BuiltIn::OperatorMatcher
951
+ def !=(_expected); end
952
+ def !~(_expected); end
953
+ def <(expected); end
954
+ def <=(expected); end
955
+ def ==(expected); end
956
+ def ===(expected); end
957
+ def =~(expected); end
958
+ def >(expected); end
959
+ def >=(expected); end
960
+ def description; end
961
+ def eval_match(actual, operator, expected); end
962
+ def fail_with_message(message); end
963
+ def has_non_generic_implementation_of?(op); end
964
+ def initialize(actual); end
965
+ def self.get(klass, operator); end
966
+ def self.register(klass, operator, matcher); end
967
+ def self.registry; end
968
+ def self.unregister(klass, operator); end
969
+ def self.use_custom_matcher_or_delegate(operator); end
970
+ end
971
+ class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
972
+ def __delegate_operator(actual, operator, expected); end
973
+ end
974
+ class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
975
+ def __delegate_operator(actual, operator, expected); end
976
+ end
977
+ class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher
978
+ def actual_output_description; end
979
+ def captured?; end
980
+ def description; end
981
+ def diffable?; end
982
+ def does_not_match?(block); end
983
+ def failure_message; end
984
+ def failure_message_when_negated; end
985
+ def initialize(expected); end
986
+ def matches?(block); end
987
+ def negative_failure_reason; end
988
+ def positive_failure_reason; end
989
+ def supports_block_expectations?; end
990
+ def supports_value_expectations?; end
991
+ def to_stderr; end
992
+ def to_stderr_from_any_process; end
993
+ def to_stdout; end
994
+ def to_stdout_from_any_process; end
995
+ end
996
+ module RSpec::Matchers::BuiltIn::NullCapture
997
+ def self.capture(_block); end
998
+ def self.name; end
999
+ end
1000
+ module RSpec::Matchers::BuiltIn::CaptureStdout
1001
+ def self.capture(block); end
1002
+ def self.name; end
1003
+ end
1004
+ module RSpec::Matchers::BuiltIn::CaptureStderr
1005
+ def self.capture(block); end
1006
+ def self.name; end
1007
+ end
1008
+ class Anonymous_Struct_3 < Struct
1009
+ def name; end
1010
+ def name=(_); end
1011
+ def self.[](*arg0); end
1012
+ def self.inspect; end
1013
+ def self.members; end
1014
+ def self.new(*arg0); end
1015
+ def stream; end
1016
+ def stream=(_); end
1017
+ end
1018
+ class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_3
1019
+ def capture(block); end
1020
+ end
1021
+ class RSpec::Matchers::BuiltIn::RaiseError
1022
+ def actual_error_message; end
1023
+ def block_matches?; end
1024
+ def description; end
1025
+ def does_not_match?(given_proc); end
1026
+ def error_and_message_match?; end
1027
+ def eval_block; end
1028
+ def expectation_matched?; end
1029
+ def expected_error; end
1030
+ def expecting_specific_exception?; end
1031
+ def expects_call_stack_jump?; end
1032
+ def failure_message; end
1033
+ def failure_message_when_negated; end
1034
+ def format_backtrace(backtrace); end
1035
+ def given_error; end
1036
+ def handle_warning(message); end
1037
+ def initialize(expected_error_or_message, expected_message, &block); end
1038
+ def matches?(given_proc, negative_expectation = nil, &block); end
1039
+ def raise_message_already_set; end
1040
+ def ready_to_eval_block?; end
1041
+ def supports_block_expectations?; end
1042
+ def supports_value_expectations?; end
1043
+ def verify_message; end
1044
+ def warn_about_bare_error!; end
1045
+ def warn_about_bare_error?; end
1046
+ def warn_about_negative_false_positive!(expression); end
1047
+ def warn_about_nil_error!; end
1048
+ def warn_about_nil_error?; end
1049
+ def warn_for_negative_false_positives!; end
1050
+ def warning; end
1051
+ def with_message(expected_message); end
1052
+ include RSpec::Matchers::Composable
1053
+ end
1054
+ class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher
1055
+ def and_any_keywords; end
1056
+ def and_keywords(*keywords); end
1057
+ def and_unlimited_arguments; end
1058
+ def argument; end
1059
+ def arguments; end
1060
+ def description; end
1061
+ def does_not_match?(actual); end
1062
+ def failure_message; end
1063
+ def failure_message_when_negated; end
1064
+ def find_failing_method_names(actual, filter_method); end
1065
+ def ignoring_method_signature_failure!; end
1066
+ def initialize(*names); end
1067
+ def matches?(actual); end
1068
+ def matches_arity?(actual, name); end
1069
+ def pp_names; end
1070
+ def with(n); end
1071
+ def with_any_keywords; end
1072
+ def with_arity; end
1073
+ def with_arity_string; end
1074
+ def with_keywords(*keywords); end
1075
+ def with_keywords_string; end
1076
+ def with_unlimited_arguments; end
1077
+ end
1078
+ class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
1079
+ def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
1080
+ def matches?(actual, name); end
1081
+ def method_signature_for(actual, name); end
1082
+ def verifier_for(actual, name); end
1083
+ end
1084
+ class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher
1085
+ def block_representation; end
1086
+ def description; end
1087
+ def extract_block_snippet; end
1088
+ def failure_message; end
1089
+ def failure_message_when_negated; end
1090
+ def initialize(description = nil, &block); end
1091
+ def matches?(actual, &block); end
1092
+ end
1093
+ class RSpec::Matchers::BuiltIn::ThrowSymbol
1094
+ def actual_result; end
1095
+ def caught; end
1096
+ def description; end
1097
+ def does_not_match?(given_proc); end
1098
+ def expected(symbol_desc = nil); end
1099
+ def expects_call_stack_jump?; end
1100
+ def failure_message; end
1101
+ def failure_message_when_negated; end
1102
+ def initialize(expected_symbol = nil, expected_arg = nil); end
1103
+ def matches?(given_proc); end
1104
+ def supports_block_expectations?; end
1105
+ def supports_value_expectations?; end
1106
+ def throw_description(symbol, arg); end
1107
+ include RSpec::Matchers::Composable
1108
+ end
1109
+ class RSpec::Matchers::BuiltIn::YieldProbe
1110
+ def assert_used!; end
1111
+ def assert_valid_expect_block!; end
1112
+ def has_block?; end
1113
+ def initialize(block, &callback); end
1114
+ def num_yields; end
1115
+ def num_yields=(arg0); end
1116
+ def probe; end
1117
+ def self.probe(block, &callback); end
1118
+ def single_yield_args; end
1119
+ def to_proc; end
1120
+ def yielded_args; end
1121
+ def yielded_args=(arg0); end
1122
+ def yielded_once?(matcher_name); end
1123
+ end
1124
+ class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher
1125
+ def does_not_match?(block); end
1126
+ def failure_message; end
1127
+ def failure_message_when_negated; end
1128
+ def failure_reason; end
1129
+ def matches?(block); end
1130
+ def supports_block_expectations?; end
1131
+ def supports_value_expectations?; end
1132
+ include RSpec::Matchers::BuiltIn::CountExpectation
1133
+ end
1134
+ class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1135
+ def does_not_match?(block); end
1136
+ def failure_message; end
1137
+ def failure_message_when_negated; end
1138
+ def matches?(block); end
1139
+ def negative_failure_reason; end
1140
+ def positive_failure_reason; end
1141
+ def supports_block_expectations?; end
1142
+ def supports_value_expectations?; end
1143
+ end
1144
+ class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1145
+ def all_args_match?; end
1146
+ def args_currently_match?; end
1147
+ def description; end
1148
+ def does_not_match?(block); end
1149
+ def expected_arg_description; end
1150
+ def failure_message; end
1151
+ def failure_message_when_negated; end
1152
+ def initialize(*args); end
1153
+ def matches?(block); end
1154
+ def negative_failure_reason; end
1155
+ def positive_failure_reason; end
1156
+ def supports_block_expectations?; end
1157
+ def supports_value_expectations?; end
1158
+ end
1159
+ class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher
1160
+ def description; end
1161
+ def does_not_match?(block); end
1162
+ def expected_arg_description; end
1163
+ def failure_message; end
1164
+ def failure_message_when_negated; end
1165
+ def initialize(*args); end
1166
+ def matches?(block); end
1167
+ def negative_failure_reason; end
1168
+ def positive_failure_reason; end
1169
+ def supports_block_expectations?; end
1170
+ def supports_value_expectations?; end
1171
+ end