bhook 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (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