titleist 0.1.1 → 1.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (109) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/tests.yml +19 -0
  3. data/.gitignore +1 -2
  4. data/.rubocop.yml +26 -1
  5. data/.ruby-version +1 -1
  6. data/Gemfile +13 -2
  7. data/README.md +95 -25
  8. data/Rakefile +17 -6
  9. data/docs/index.md +7 -0
  10. data/lib/generators/titleist/titleist_generator.rb +3 -0
  11. data/lib/titleist.rb +14 -9
  12. data/lib/titleist/controller.rb +36 -0
  13. data/lib/titleist/engine.rb +10 -4
  14. data/lib/titleist/helper.rb +23 -0
  15. data/lib/titleist/title.rb +52 -89
  16. data/lib/titleist/version.rb +5 -1
  17. data/rbi/sord.rbi +117 -0
  18. data/sorbet/config +2 -0
  19. data/sorbet/rbi/gems/actioncable.rbi +318 -0
  20. data/sorbet/rbi/gems/actionmailbox.rbi +56 -0
  21. data/sorbet/rbi/gems/actionmailer.rbi +446 -0
  22. data/sorbet/rbi/gems/actionpack.rbi +3411 -0
  23. data/sorbet/rbi/gems/actiontext.rbi +79 -0
  24. data/sorbet/rbi/gems/actionview.rbi +1185 -0
  25. data/sorbet/rbi/gems/activejob.rbi +362 -0
  26. data/sorbet/rbi/gems/activemodel.rbi +749 -0
  27. data/sorbet/rbi/gems/activerecord.rbi +5713 -0
  28. data/sorbet/rbi/gems/activestorage.rbi +221 -0
  29. data/sorbet/rbi/gems/activesupport.rbi +2437 -0
  30. data/sorbet/rbi/gems/addressable.rbi +146 -0
  31. data/sorbet/rbi/gems/ast.rbi +47 -0
  32. data/sorbet/rbi/gems/capybara.rbi +1787 -0
  33. data/sorbet/rbi/gems/childprocess.rbi +106 -0
  34. data/sorbet/rbi/gems/codeclimate-test-reporter.rbi +125 -0
  35. data/sorbet/rbi/gems/concurrent-ruby.rbi +1587 -0
  36. data/sorbet/rbi/gems/crass.rbi +92 -0
  37. data/sorbet/rbi/gems/docile.rbi +29 -0
  38. data/sorbet/rbi/gems/erubi.rbi +26 -0
  39. data/sorbet/rbi/gems/globalid.rbi +98 -0
  40. data/sorbet/rbi/gems/i18n.rbi +191 -0
  41. data/sorbet/rbi/gems/jaro_winkler.rbi +14 -0
  42. data/sorbet/rbi/gems/loofah.rbi +129 -0
  43. data/sorbet/rbi/gems/mail.rbi +1582 -0
  44. data/sorbet/rbi/gems/marcel.rbi +12 -0
  45. data/sorbet/rbi/gems/method_source.rbi +63 -0
  46. data/sorbet/rbi/gems/mini_mime.rbi +51 -0
  47. data/sorbet/rbi/gems/minitest.rbi +419 -0
  48. data/sorbet/rbi/gems/mocha.rbi +794 -0
  49. data/sorbet/rbi/gems/nio4r.rbi +67 -0
  50. data/sorbet/rbi/gems/nokogiri.rbi +1010 -0
  51. data/sorbet/rbi/gems/parallel.rbi +81 -0
  52. data/sorbet/rbi/gems/parser.rbi +920 -0
  53. data/sorbet/rbi/gems/public_suffix.rbi +103 -0
  54. data/sorbet/rbi/gems/puma.rbi +586 -0
  55. data/sorbet/rbi/gems/rack-test.rbi +161 -0
  56. data/sorbet/rbi/gems/rack.rbi +634 -0
  57. data/sorbet/rbi/gems/rails-dom-testing.rbi +67 -0
  58. data/sorbet/rbi/gems/rails-html-sanitizer.rbi +91 -0
  59. data/sorbet/rbi/gems/railties.rbi +834 -0
  60. data/sorbet/rbi/gems/rainbow.rbi +117 -0
  61. data/sorbet/rbi/gems/rake.rbi +269 -0
  62. data/sorbet/rbi/gems/regexp_parser.rbi +912 -0
  63. data/sorbet/rbi/gems/rubocop.rbi +7232 -0
  64. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  65. data/sorbet/rbi/gems/rubyzip.rbi +546 -0
  66. data/sorbet/rbi/gems/selenium-webdriver.rbi +1450 -0
  67. data/sorbet/rbi/gems/simplecov-html.rbi +30 -0
  68. data/sorbet/rbi/gems/simplecov.rbi +189 -0
  69. data/sorbet/rbi/gems/site_ruby.rbi +265 -0
  70. data/sorbet/rbi/gems/sprockets-rails.rbi +105 -0
  71. data/sorbet/rbi/gems/sprockets.rbi +753 -0
  72. data/sorbet/rbi/gems/sqlite3.rbi +353 -0
  73. data/sorbet/rbi/gems/thor.rbi +579 -0
  74. data/sorbet/rbi/gems/thread_safe.rbi +81 -0
  75. data/sorbet/rbi/gems/tzinfo.rbi +405 -0
  76. data/sorbet/rbi/gems/unicode-display_width.rbi +16 -0
  77. data/sorbet/rbi/gems/webdrivers.rbi +155 -0
  78. data/sorbet/rbi/gems/xpath.rbi +158 -0
  79. data/sorbet/rbi/gems/yard.rbi +1159 -0
  80. data/sorbet/rbi/hidden-definitions/errors.txt +14957 -0
  81. data/sorbet/rbi/hidden-definitions/hidden.rbi +24898 -0
  82. data/sorbet/rbi/sorbet-typed/lib/actionmailer/all/actionmailer.rbi +13 -0
  83. data/sorbet/rbi/sorbet-typed/lib/actionpack/all/actionpack.rbi +938 -0
  84. data/sorbet/rbi/sorbet-typed/lib/actionview/all/actionview.rbi +314 -0
  85. data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi +425 -0
  86. data/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi +17 -0
  87. data/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi +1425 -0
  88. data/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi +475 -0
  89. data/sorbet/rbi/sorbet-typed/lib/activestorage/>=6.0.0/activestorage.rbi +19 -0
  90. data/sorbet/rbi/sorbet-typed/lib/activestorage/all/activestorage.rbi +173 -0
  91. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +23 -0
  92. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +858 -0
  93. data/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi +8684 -0
  94. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +108 -0
  95. data/sorbet/rbi/sorbet-typed/lib/railties/all/railties.rbi +25 -0
  96. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +254 -0
  97. data/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi +4222 -0
  98. data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +111 -0
  99. data/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi +543 -0
  100. data/sorbet/rbi/todo.rbi +20 -0
  101. data/titleist.gemspec +3 -14
  102. metadata +96 -155
  103. data/.travis.yml +0 -45
  104. data/app/controllers/.keep +0 -0
  105. data/app/helpers/.keep +0 -0
  106. data/app/helpers/titleist_helper.rb +0 -47
  107. data/app/mailers/.keep +0 -0
  108. data/app/models/.keep +0 -0
  109. data/app/views/.keep +0 -0
@@ -0,0 +1,794 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
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/mocha/all/mocha.rbi
9
+ #
10
+ # mocha-1.11.2
11
+ module Mocha
12
+ def self.activate; end
13
+ def self.configuration; end
14
+ def self.configure; end
15
+ end
16
+ module Mocha::Debug
17
+ def self.puts(message); end
18
+ end
19
+ module Mocha::Detection
20
+ end
21
+ module Mocha::Detection::TestUnit
22
+ def self.testcase; end
23
+ def self.version; end
24
+ end
25
+ module Mocha::Integration
26
+ def self.activate; end
27
+ end
28
+ module Mocha::Integration::TestUnit
29
+ def self.activate; end
30
+ end
31
+ module Mocha::Integration::TestUnit::Nothing
32
+ def self.applicable_to?(_test_unit_version, _ruby_version = nil); end
33
+ def self.description; end
34
+ def self.included(_mod); end
35
+ end
36
+ class Mocha::Integration::AssertionCounter
37
+ def increment; end
38
+ def initialize(test_case); end
39
+ end
40
+ module Mocha::ParameterMatchers
41
+ def Not(matcher); end
42
+ def all_of(*matchers); end
43
+ def any_of(*matchers); end
44
+ def any_parameters; end
45
+ def anything; end
46
+ def equals(value); end
47
+ def equivalent_uri(uri); end
48
+ def has_entries(entries); end
49
+ def has_entry(*options); end
50
+ def has_key(key); end
51
+ def has_value(value); end
52
+ def includes(*items); end
53
+ def instance_of(klass); end
54
+ def is_a(klass); end
55
+ def kind_of(klass); end
56
+ def optionally(*matchers); end
57
+ def regexp_matches(regexp); end
58
+ def responds_with(message, result); end
59
+ def yaml_equivalent(object); end
60
+ end
61
+ class Mocha::ParameterMatchers::Base
62
+ def &(other); end
63
+ def to_matcher; end
64
+ def |(other); end
65
+ end
66
+ class Mocha::ParameterMatchers::Equals < Mocha::ParameterMatchers::Base
67
+ def initialize(value); end
68
+ def matches?(available_parameters); end
69
+ def mocha_inspect; end
70
+ end
71
+ module Mocha::ParameterMatchers::InstanceMethods
72
+ def to_matcher; end
73
+ end
74
+ class Object < BasicObject
75
+ def __is_a__(arg0); end
76
+ include Mocha::Inspect::ObjectMethods
77
+ include Mocha::ObjectMethods
78
+ include Mocha::ObjectMethods
79
+ include Mocha::ParameterMatchers::InstanceMethods
80
+ end
81
+ class Mocha::ParameterMatchers::AllOf < Mocha::ParameterMatchers::Base
82
+ def initialize(*matchers); end
83
+ def matches?(available_parameters); end
84
+ def mocha_inspect; end
85
+ end
86
+ class Mocha::ParameterMatchers::AnyOf < Mocha::ParameterMatchers::Base
87
+ def initialize(*matchers); end
88
+ def matches?(available_parameters); end
89
+ def mocha_inspect; end
90
+ end
91
+ class Mocha::ParameterMatchers::AnyParameters < Mocha::ParameterMatchers::Base
92
+ def matches?(available_parameters); end
93
+ def mocha_inspect; end
94
+ end
95
+ class Mocha::ParameterMatchers::Anything < Mocha::ParameterMatchers::Base
96
+ def matches?(available_parameters); end
97
+ def mocha_inspect; end
98
+ end
99
+ class Mocha::ParameterMatchers::HasEntry < Mocha::ParameterMatchers::Base
100
+ def initialize(key, value); end
101
+ def matches?(available_parameters); end
102
+ def mocha_inspect; end
103
+ end
104
+ class Mocha::ParameterMatchers::HasEntries < Mocha::ParameterMatchers::Base
105
+ def initialize(entries); end
106
+ def matches?(available_parameters); end
107
+ def mocha_inspect; end
108
+ end
109
+ class Mocha::ParameterMatchers::HasKey < Mocha::ParameterMatchers::Base
110
+ def initialize(key); end
111
+ def matches?(available_parameters); end
112
+ def mocha_inspect; end
113
+ end
114
+ class Mocha::ParameterMatchers::HasValue < Mocha::ParameterMatchers::Base
115
+ def initialize(value); end
116
+ def matches?(available_parameters); end
117
+ def mocha_inspect; end
118
+ end
119
+ class Mocha::ParameterMatchers::Includes < Mocha::ParameterMatchers::Base
120
+ def initialize(*items); end
121
+ def matches?(available_parameters); end
122
+ def mocha_inspect; end
123
+ end
124
+ class Mocha::ParameterMatchers::InstanceOf < Mocha::ParameterMatchers::Base
125
+ def initialize(klass); end
126
+ def matches?(available_parameters); end
127
+ def mocha_inspect; end
128
+ end
129
+ class Mocha::ParameterMatchers::IsA < Mocha::ParameterMatchers::Base
130
+ def initialize(klass); end
131
+ def matches?(available_parameters); end
132
+ def mocha_inspect; end
133
+ end
134
+ class Mocha::ParameterMatchers::KindOf < Mocha::ParameterMatchers::Base
135
+ def initialize(klass); end
136
+ def matches?(available_parameters); end
137
+ def mocha_inspect; end
138
+ end
139
+ class Mocha::ParameterMatchers::Not < Mocha::ParameterMatchers::Base
140
+ def initialize(matcher); end
141
+ def matches?(available_parameters); end
142
+ def mocha_inspect; end
143
+ end
144
+ class Mocha::ParameterMatchers::Optionally < Mocha::ParameterMatchers::Base
145
+ def initialize(*parameters); end
146
+ def matches?(available_parameters); end
147
+ def mocha_inspect; end
148
+ end
149
+ class Mocha::ParameterMatchers::RegexpMatches < Mocha::ParameterMatchers::Base
150
+ def initialize(regexp); end
151
+ def matches?(available_parameters); end
152
+ def mocha_inspect; end
153
+ end
154
+ class Mocha::ParameterMatchers::RespondsWith < Mocha::ParameterMatchers::Base
155
+ def initialize(message, result); end
156
+ def matches?(available_parameters); end
157
+ def mocha_inspect; end
158
+ end
159
+ class Mocha::ParameterMatchers::YamlEquivalent < Mocha::ParameterMatchers::Base
160
+ def initialize(object); end
161
+ def matches?(available_parameters); end
162
+ def mocha_inspect; end
163
+ end
164
+ class Mocha::BacktraceFilter
165
+ def filtered(backtrace); end
166
+ def initialize(lib_directory = nil); end
167
+ end
168
+ class Mocha::Deprecation
169
+ def self.messages; end
170
+ def self.messages=(arg0); end
171
+ def self.mode; end
172
+ def self.mode=(arg0); end
173
+ def self.warning(*messages); end
174
+ end
175
+ class Mocha::ParameterMatchers::EquivalentUri < Mocha::ParameterMatchers::Base
176
+ def explode(uri); end
177
+ def initialize(uri); end
178
+ def matches?(available_parameters); end
179
+ def mocha_inspect; end
180
+ end
181
+ class Mocha::Central
182
+ def initialize; end
183
+ def stub(method); end
184
+ def stubba_methods; end
185
+ def stubba_methods=(arg0); end
186
+ def unstub(method); end
187
+ def unstub_all; end
188
+ end
189
+ class Mocha::Central::Null < Mocha::Central
190
+ def initialize(&block); end
191
+ def stub(*arg0); end
192
+ def unstub(*arg0); end
193
+ end
194
+ class Mocha::MethodMatcher
195
+ def expected_method_name; end
196
+ def initialize(expected_method_name); end
197
+ def match?(actual_method_name); end
198
+ def mocha_inspect; end
199
+ end
200
+ module Mocha::Inspect
201
+ end
202
+ module Mocha::Inspect::ObjectMethods
203
+ def mocha_inspect; end
204
+ end
205
+ module Mocha::Inspect::ArrayMethods
206
+ def mocha_inspect; end
207
+ end
208
+ module Mocha::Inspect::HashMethods
209
+ def mocha_inspect; end
210
+ end
211
+ module Mocha::Inspect::TimeMethods
212
+ def mocha_inspect; end
213
+ end
214
+ module Mocha::Inspect::DateMethods
215
+ def mocha_inspect; end
216
+ end
217
+ class Array
218
+ include Mocha::Inspect::ArrayMethods
219
+ end
220
+ class Hash
221
+ include Mocha::Inspect::HashMethods
222
+ end
223
+ class Time
224
+ include Mocha::Inspect::TimeMethods
225
+ end
226
+ class Date
227
+ include Mocha::Inspect::DateMethods
228
+ end
229
+ class Mocha::ParametersMatcher
230
+ def initialize(expected_parameters = nil, &matching_block); end
231
+ def match?(actual_parameters = nil); end
232
+ def matchers; end
233
+ def mocha_inspect; end
234
+ def parameters_match?(actual_parameters); end
235
+ end
236
+ class Mocha::ExpectationError < Exception
237
+ end
238
+ class Mocha::SingleReturnValue
239
+ def evaluate(invocation); end
240
+ def initialize(value); end
241
+ end
242
+ class Mocha::ReturnValues
243
+ def +(other); end
244
+ def initialize(*values); end
245
+ def next(invocation); end
246
+ def self.build(*values); end
247
+ def values; end
248
+ def values=(arg0); end
249
+ end
250
+ class Mocha::ExceptionRaiser
251
+ def evaluate(invocation); end
252
+ def initialize(exception, message); end
253
+ end
254
+ class Mocha::Thrower
255
+ def evaluate(invocation); end
256
+ def initialize(tag, object = nil); end
257
+ end
258
+ class Mocha::YieldParameters
259
+ def add(*parameter_groups); end
260
+ def initialize; end
261
+ def next_invocation; end
262
+ end
263
+ class Mocha::InStateOrderingConstraint
264
+ def allows_invocation_now?; end
265
+ def initialize(state_predicate); end
266
+ def mocha_inspect; end
267
+ end
268
+ class Mocha::ChangeStateSideEffect
269
+ def initialize(state); end
270
+ def mocha_inspect; end
271
+ def perform; end
272
+ end
273
+ class Mocha::Cardinality
274
+ def <<(invocation); end
275
+ def actual_invocations; end
276
+ def allowed_any_number_of_times?; end
277
+ def anticipated_times; end
278
+ def infinite?(number); end
279
+ def initialize(required, maximum); end
280
+ def invocations_allowed?; end
281
+ def invoked_times; end
282
+ def maximum; end
283
+ def needs_verifying?; end
284
+ def required; end
285
+ def satisfied?; end
286
+ def self.at_least(count); end
287
+ def self.at_most(count); end
288
+ def self.exactly(count); end
289
+ def self.times(range_or_count); end
290
+ def times(number); end
291
+ def used?; end
292
+ def verified?; end
293
+ end
294
+ class Mocha::Configuration
295
+ def display_matching_invocations_on_failure=(value); end
296
+ def display_matching_invocations_on_failure?; end
297
+ def initialize(options = nil); end
298
+ def initialize_copy(other); end
299
+ def merge(other); end
300
+ def options; end
301
+ def reinstate_undocumented_behaviour_from_v1_9=(value); end
302
+ def reinstate_undocumented_behaviour_from_v1_9?; end
303
+ def self.allow(action, &block); end
304
+ def self.allow?(action); end
305
+ def self.change_config(action, new_value, &block); end
306
+ def self.configuration; end
307
+ def self.override(temporary_options); end
308
+ def self.prevent(action, &block); end
309
+ def self.prevent?(action); end
310
+ def self.reset_configuration; end
311
+ def self.temporarily_change_config(action, new_value); end
312
+ def self.warn_when(action, &block); end
313
+ def self.warn_when?(action); end
314
+ def stubbing_method_on_nil; end
315
+ def stubbing_method_on_nil=(value); end
316
+ def stubbing_method_on_non_mock_object; end
317
+ def stubbing_method_on_non_mock_object=(value); end
318
+ def stubbing_method_unnecessarily; end
319
+ def stubbing_method_unnecessarily=(value); end
320
+ def stubbing_non_existent_method; end
321
+ def stubbing_non_existent_method=(value); end
322
+ def stubbing_non_public_method; end
323
+ def stubbing_non_public_method=(value); end
324
+ end
325
+ module Mocha::BlockMatchers
326
+ end
327
+ class Mocha::BlockMatchers::OptionalBlock
328
+ def match?(_actual_block); end
329
+ def mocha_inspect; end
330
+ end
331
+ class Mocha::BlockMatchers::BlockGiven
332
+ def match?(actual_block); end
333
+ def mocha_inspect; end
334
+ end
335
+ class Mocha::BlockMatchers::NoBlockGiven
336
+ def match?(actual_block); end
337
+ def mocha_inspect; end
338
+ end
339
+ class Mocha::Expectation
340
+ def add_in_sequence_ordering_constraint(sequence); end
341
+ def add_ordering_constraint(ordering_constraint); end
342
+ def add_side_effect(side_effect); end
343
+ def at_least(minimum_number_of_times); end
344
+ def at_least_once; end
345
+ def at_most(maximum_number_of_times); end
346
+ def at_most_once; end
347
+ def backtrace; end
348
+ def in_correct_order?; end
349
+ def in_sequence(sequence, *sequences); end
350
+ def initialize(mock, expected_method_name, backtrace = nil); end
351
+ def inspect; end
352
+ def invocations_allowed?; end
353
+ def invoke(invocation); end
354
+ def match?(invocation); end
355
+ def matches_method?(method_name); end
356
+ def method_signature; end
357
+ def mocha_inspect; end
358
+ def multiple_yields(*parameter_groups); end
359
+ def never; end
360
+ def once; end
361
+ def perform_side_effects; end
362
+ def raises(exception = nil, message = nil); end
363
+ def returns(*values); end
364
+ def satisfied?; end
365
+ def then(*parameters); end
366
+ def throws(tag, object = nil); end
367
+ def times(range); end
368
+ def twice; end
369
+ def used?; end
370
+ def verified?(assertion_counter = nil); end
371
+ def when(state_predicate); end
372
+ def with(*expected_parameters, &matching_block); end
373
+ def with_block_given; end
374
+ def with_no_block_given; end
375
+ def yields(*parameters); end
376
+ end
377
+ class Mocha::ExpectationList
378
+ def +(other); end
379
+ def add(expectation); end
380
+ def any?; end
381
+ def initialize(expectations = nil); end
382
+ def length; end
383
+ def match(invocation); end
384
+ def match_allowing_invocation(invocation); end
385
+ def matches_method?(method_name); end
386
+ def matching_expectations(invocation); end
387
+ def remove_all_matching_method(method_name); end
388
+ def to_a; end
389
+ def to_set; end
390
+ def verified?(assertion_counter = nil); end
391
+ end
392
+ class Mocha::RaisedException
393
+ def initialize(exception); end
394
+ def mocha_inspect; end
395
+ end
396
+ class Mocha::ThrownObject
397
+ def initialize(tag, value = nil); end
398
+ def mocha_inspect; end
399
+ end
400
+ class Mocha::Invocation
401
+ def arguments; end
402
+ def block; end
403
+ def call(yield_parameters = nil, return_values = nil); end
404
+ def call_description; end
405
+ def full_description; end
406
+ def initialize(mock, method_name, *arguments, &block); end
407
+ def method_name; end
408
+ def raised(exception); end
409
+ def result_description; end
410
+ def returned(value); end
411
+ def short_call_description; end
412
+ def threw(tag, value); end
413
+ end
414
+ class Mocha::ImpersonatingName
415
+ def initialize(object); end
416
+ def mocha_inspect; end
417
+ end
418
+ class Mocha::ImpersonatingAnyInstanceName
419
+ def initialize(klass); end
420
+ def mocha_inspect; end
421
+ end
422
+ class Mocha::Name
423
+ def initialize(name); end
424
+ def mocha_inspect; end
425
+ end
426
+ class Mocha::DefaultName
427
+ def initialize(mock); end
428
+ def mocha_inspect; end
429
+ end
430
+ class Mocha::ObjectReceiver
431
+ def initialize(object); end
432
+ def mocks; end
433
+ end
434
+ class Mocha::AnyInstanceReceiver
435
+ def initialize(klass); end
436
+ def mocks; end
437
+ end
438
+ class Mocha::DefaultReceiver
439
+ def initialize(mock); end
440
+ def mocks; end
441
+ end
442
+ class Mocha::ArgumentIterator
443
+ def each; end
444
+ def initialize(argument); end
445
+ end
446
+ class Mocha::ExpectationErrorFactory
447
+ def self.build(message = nil, backtrace = nil); end
448
+ def self.exception_class; end
449
+ def self.exception_class=(arg0); end
450
+ end
451
+ class Mocha::Mock
452
+ def __expectations__; end
453
+ def __expects__(method_name_or_hash, backtrace = nil); end
454
+ def __expire__; end
455
+ def __singleton_class__; end
456
+ def __stubs__(method_name_or_hash, backtrace = nil); end
457
+ def __verified__?(assertion_counter = nil); end
458
+ def all_expectations; end
459
+ def any_expectations?; end
460
+ def check_expiry; end
461
+ def check_responder_responds_to(symbol); end
462
+ def ensure_method_not_already_defined(method_name); end
463
+ def everything_stubbed; end
464
+ def expects(method_name_or_hash, backtrace = nil); end
465
+ def initialize(mockery, name = nil, receiver = nil); end
466
+ def inspect; end
467
+ def method_missing(symbol, *arguments, &block); end
468
+ def mocha_inspect; end
469
+ def quacks_like(responder); end
470
+ def quacks_like_instance_of(responder_class); end
471
+ def raise_unexpected_invocation_error(invocation, matching_expectation); end
472
+ def respond_to_missing?(symbol, include_private = nil); end
473
+ def responds_like(responder); end
474
+ def responds_like_instance_of(responder_class); end
475
+ def stub_everything; end
476
+ def stubs(method_name_or_hash, backtrace = nil); end
477
+ def unstub(*method_names); end
478
+ end
479
+ class Mocha::StateMachine
480
+ def become(next_state_name); end
481
+ def current_state; end
482
+ def current_state=(arg0); end
483
+ def initialize(name); end
484
+ def is(state_name); end
485
+ def is_not(state_name); end
486
+ def mocha_inspect; end
487
+ def name; end
488
+ def starts_as(initial_state_name); end
489
+ end
490
+ class Mocha::StateMachine::State
491
+ def activate; end
492
+ def active?; end
493
+ def initialize(state_machine, state); end
494
+ def mocha_inspect; end
495
+ end
496
+ class Mocha::StateMachine::StatePredicate
497
+ def active?; end
498
+ def initialize(state_machine, state); end
499
+ def mocha_inspect; end
500
+ end
501
+ class Mocha::Logger
502
+ def initialize(io); end
503
+ def warn(message); end
504
+ end
505
+ class Mocha::ErrorWithFilteredBacktrace < StandardError
506
+ def initialize(message = nil, backtrace = nil); end
507
+ end
508
+ class Mocha::StubbingError < Mocha::ErrorWithFilteredBacktrace
509
+ end
510
+ class Mocha::NotInitializedError < Mocha::ErrorWithFilteredBacktrace
511
+ end
512
+ class Mocha::Mockery
513
+ def add_mock(mock); end
514
+ def add_state_machine(state_machine); end
515
+ def check(action, description, signature_proc, backtrace = nil); end
516
+ def expectations; end
517
+ def logger; end
518
+ def logger=(arg0); end
519
+ def mocha_inspect; end
520
+ def mock_impersonating(object); end
521
+ def mock_impersonating_any_instance_of(klass); end
522
+ def mocks; end
523
+ def named_mock(name); end
524
+ def new_state_machine(name); end
525
+ def on_stubbing(object, method); end
526
+ def on_stubbing_method_unnecessarily(expectation); end
527
+ def reset; end
528
+ def satisfied_expectations; end
529
+ def self.instance; end
530
+ def self.instances; end
531
+ def self.setup; end
532
+ def self.teardown; end
533
+ def self.verify(*args); end
534
+ def state_machines; end
535
+ def stubba; end
536
+ def teardown; end
537
+ def unnamed_mock; end
538
+ def unsatisfied_expectations; end
539
+ def verify(assertion_counter = nil); end
540
+ end
541
+ class Mocha::Mockery::Null < Mocha::Mockery
542
+ def add_mock(*arg0); end
543
+ def add_state_machine(*arg0); end
544
+ def raise_not_initialized_error; end
545
+ def stubba; end
546
+ end
547
+ module Mocha::Hooks
548
+ def mocha_setup; end
549
+ def mocha_teardown; end
550
+ def mocha_verify(assertion_counter = nil); end
551
+ end
552
+ class Mocha::Sequence
553
+ def constrain_as_next_in_sequence(expectation); end
554
+ def initialize(name); end
555
+ def mocha_inspect; end
556
+ def satisfied_to_index?(index); end
557
+ end
558
+ class Mocha::Sequence::InSequenceOrderingConstraint
559
+ def allows_invocation_now?; end
560
+ def initialize(sequence, index); end
561
+ def mocha_inspect; end
562
+ end
563
+ class Mocha::StubbedMethod
564
+ def ==(arg0); end
565
+ def define_new_method; end
566
+ def hide_original_method; end
567
+ def initialize(stubbee, method_name); end
568
+ def matches?(other); end
569
+ def method_name; end
570
+ def mock; end
571
+ def remove_new_method; end
572
+ def remove_original_method_from_stubbee; end
573
+ def reset_mocha; end
574
+ def restore_original_method; end
575
+ def retain_original_visibility(method_owner); end
576
+ def store_original_method; end
577
+ def store_original_method_visibility; end
578
+ def stub; end
579
+ def stub_method_overwrites_original_method?; end
580
+ def stub_method_owner; end
581
+ def stubbee; end
582
+ def to_s; end
583
+ def unstub; end
584
+ def use_prepended_module_for_stub_method; end
585
+ def use_prepended_module_for_stub_method?; end
586
+ end
587
+ class Mocha::StubbedMethod::PrependedModule < Module
588
+ end
589
+ class Mocha::InstanceMethod < Mocha::StubbedMethod
590
+ def method_body(method); end
591
+ def mock_owner; end
592
+ def original_method_owner; end
593
+ def stubbee_method(method_name); end
594
+ end
595
+ module Mocha::ObjectMethods
596
+ def _method(arg0); end
597
+ def expects(expected_methods_vs_return_values); end
598
+ def mocha(instantiate = nil); end
599
+ def reset_mocha; end
600
+ def stubba_class; end
601
+ def stubba_method; end
602
+ def stubba_object; end
603
+ def stubs(stubbed_methods_vs_return_values); end
604
+ def unstub(*method_names); end
605
+ end
606
+ class Mocha::AnyInstanceMethod < Mocha::StubbedMethod
607
+ def method_body(method); end
608
+ def mock_owner; end
609
+ def original_method_owner; end
610
+ def stubbee_method(method_name); end
611
+ end
612
+ module Mocha::ClassMethods
613
+ def __method_exists__?(method, include_public_methods = nil); end
614
+ def __method_visibility__(method, include_public_methods = nil); end
615
+ def any_instance; end
616
+ end
617
+ class Mocha::ClassMethods::AnyInstance
618
+ def initialize(klass); end
619
+ def mocha(instantiate = nil); end
620
+ def respond_to?(method); end
621
+ def stubba_class; end
622
+ def stubba_method; end
623
+ def stubba_object; end
624
+ end
625
+ module Mocha::API
626
+ def mock(*arguments); end
627
+ def self.extended(mod); end
628
+ def self.included(_mod); end
629
+ def sequence(name); end
630
+ def states(name); end
631
+ def stub(*arguments); end
632
+ def stub_everything(*arguments); end
633
+ include Mocha::Hooks
634
+ include Mocha::ParameterMatchers
635
+ end
636
+ module Mocha::Integration::MonkeyPatcher
637
+ def self.apply(mod, run_method_patch); end
638
+ end
639
+ module Mocha::Integration::TestUnit::RubyVersion185AndBelow
640
+ def self.applicable_to?(test_unit_version, ruby_version); end
641
+ def self.description; end
642
+ def self.included(mod); end
643
+ end
644
+ module Mocha::Integration::TestUnit::RubyVersion185AndBelow::RunMethodPatch
645
+ def run(result); end
646
+ end
647
+ module Mocha::Integration::TestUnit::RubyVersion186AndAbove
648
+ def self.applicable_to?(test_unit_version, ruby_version); end
649
+ def self.description; end
650
+ def self.included(mod); end
651
+ end
652
+ module Mocha::Integration::TestUnit::RubyVersion186AndAbove::RunMethodPatch
653
+ def run(result); end
654
+ end
655
+ module Mocha::Integration::TestUnit::GemVersion200
656
+ def self.applicable_to?(test_unit_version, _ruby_version = nil); end
657
+ def self.description; end
658
+ def self.included(mod); end
659
+ end
660
+ module Mocha::Integration::TestUnit::GemVersion200::RunMethodPatch
661
+ def run(result); end
662
+ end
663
+ module Mocha::Integration::TestUnit::GemVersion201To202
664
+ def self.applicable_to?(test_unit_version, _ruby_version = nil); end
665
+ def self.description; end
666
+ def self.included(mod); end
667
+ end
668
+ module Mocha::Integration::TestUnit::GemVersion201To202::RunMethodPatch
669
+ def run(result); end
670
+ end
671
+ module Mocha::Integration::TestUnit::GemVersion203To220
672
+ def self.applicable_to?(test_unit_version, _ruby_version = nil); end
673
+ def self.description; end
674
+ def self.included(mod); end
675
+ end
676
+ module Mocha::Integration::TestUnit::GemVersion203To220::RunMethodPatch
677
+ def run(result); end
678
+ end
679
+ module Mocha::Integration::TestUnit::GemVersion230To250
680
+ def self.applicable_to?(test_unit_version, _ruby_version = nil); end
681
+ def self.description; end
682
+ def self.included(mod); end
683
+ end
684
+ module Mocha::Integration::TestUnit::GemVersion230To250::RunMethodPatch
685
+ def run(result); end
686
+ end
687
+ module Mocha::Integration::TestUnit::Adapter
688
+ def handle_mocha_expectation_error(exception); end
689
+ def self.applicable_to?(test_unit_version, _ruby_version = nil); end
690
+ def self.description; end
691
+ def self.included(mod); end
692
+ include Mocha::API
693
+ end
694
+ class Class < Module
695
+ include Mocha::ClassMethods
696
+ include Mocha::ClassMethods
697
+ end
698
+ module Mocha::Detection::MiniTest
699
+ def self.testcase; end
700
+ def self.version; end
701
+ end
702
+ module Mocha::Integration::MiniTest
703
+ def self.activate; end
704
+ def self.translate(exception); end
705
+ end
706
+ module Mocha::Integration::MiniTest::Nothing
707
+ def self.applicable_to?(_test_unit_version, _ruby_version = nil); end
708
+ def self.description; end
709
+ def self.included(_mod); end
710
+ end
711
+ module Mocha::Integration::MiniTest::Version13
712
+ def self.applicable_to?(mini_test_version); end
713
+ def self.description; end
714
+ def self.included(mod); end
715
+ end
716
+ module Mocha::Integration::MiniTest::Version13::RunMethodPatch
717
+ def run(runner); end
718
+ end
719
+ module Mocha::Integration::MiniTest::Version140
720
+ def self.applicable_to?(mini_test_version); end
721
+ def self.description; end
722
+ def self.included(mod); end
723
+ end
724
+ module Mocha::Integration::MiniTest::Version140::RunMethodPatch
725
+ def run(runner); end
726
+ end
727
+ module Mocha::Integration::MiniTest::Version141
728
+ def self.applicable_to?(mini_test_version); end
729
+ def self.description; end
730
+ def self.included(mod); end
731
+ end
732
+ module Mocha::Integration::MiniTest::Version141::RunMethodPatch
733
+ def run(runner); end
734
+ end
735
+ module Mocha::Integration::MiniTest::Version142To172
736
+ def self.applicable_to?(mini_test_version); end
737
+ def self.description; end
738
+ def self.included(mod); end
739
+ end
740
+ module Mocha::Integration::MiniTest::Version142To172::RunMethodPatch
741
+ def run(runner); end
742
+ end
743
+ module Mocha::Integration::MiniTest::Version200
744
+ def self.applicable_to?(mini_test_version); end
745
+ def self.description; end
746
+ def self.included(mod); end
747
+ end
748
+ module Mocha::Integration::MiniTest::Version200::RunMethodPatch
749
+ def run(runner); end
750
+ end
751
+ module Mocha::Integration::MiniTest::Version201To222
752
+ def self.applicable_to?(mini_test_version); end
753
+ def self.description; end
754
+ def self.included(mod); end
755
+ end
756
+ module Mocha::Integration::MiniTest::Version201To222::RunMethodPatch
757
+ def run(runner); end
758
+ end
759
+ module Mocha::Integration::MiniTest::Version230To2101
760
+ def self.applicable_to?(mini_test_version); end
761
+ def self.description; end
762
+ def self.included(mod); end
763
+ end
764
+ module Mocha::Integration::MiniTest::Version230To2101::RunMethodPatch
765
+ def run(runner); end
766
+ end
767
+ module Mocha::Integration::MiniTest::Version2110To2111
768
+ def self.applicable_to?(mini_test_version); end
769
+ def self.description; end
770
+ def self.included(mod); end
771
+ end
772
+ module Mocha::Integration::MiniTest::Version2110To2111::RunMethodPatch
773
+ def run(runner); end
774
+ end
775
+ module Mocha::Integration::MiniTest::Version2112To320
776
+ def self.applicable_to?(mini_test_version); end
777
+ def self.description; end
778
+ def self.included(mod); end
779
+ end
780
+ module Mocha::Integration::MiniTest::Version2112To320::RunMethodPatch
781
+ def run(runner); end
782
+ end
783
+ module Mocha::Integration::MiniTest::Adapter
784
+ def after_teardown; end
785
+ def before_setup; end
786
+ def before_teardown; end
787
+ def self.applicable_to?(mini_test_version); end
788
+ def self.description; end
789
+ def self.included(_mod); end
790
+ include Mocha::API
791
+ end
792
+ class Minitest::Test < Minitest::Runnable
793
+ include Mocha::Integration::MiniTest::Adapter
794
+ end