rspec-sorbet 1.8.1 → 1.8.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (58) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/lib/rspec/sorbet/version.rb +1 -1
  4. data/rspec-sorbet.gemspec +1 -1
  5. metadata +1 -54
  6. data/sorbet/config +0 -4
  7. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  8. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -1568
  9. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -1005
  10. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -9
  11. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  12. data/sorbet/rbi/gems/em-websocket@0.5.2.rbi +0 -8
  13. data/sorbet/rbi/gems/eventmachine@1.2.7.rbi +0 -45
  14. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +0 -3171
  15. data/sorbet/rbi/gems/ffi@1.15.4.rbi +0 -8
  16. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  17. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -31
  18. data/sorbet/rbi/gems/guard-livereload@2.5.2.rbi +0 -8
  19. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -211
  20. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -8
  21. data/sorbet/rbi/gems/http_parser.rb@0.6.0.rbi +0 -8
  22. data/sorbet/rbi/gems/listen@3.7.0.rbi +0 -8
  23. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -8
  24. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -72
  25. data/sorbet/rbi/gems/multi_json@1.15.0.rbi +0 -8
  26. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -8
  27. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -8
  28. data/sorbet/rbi/gems/parallel@1.21.0.rbi +0 -113
  29. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1189
  30. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +0 -458
  31. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -2486
  32. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  33. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -795
  34. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  35. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  36. data/sorbet/rbi/gems/rbi@0.0.6.rbi +0 -1405
  37. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  38. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  39. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2455
  40. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  41. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  42. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  43. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  44. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +0 -1938
  45. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +0 -1786
  46. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +0 -13252
  47. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  48. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -8
  49. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  50. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  51. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  52. data/sorbet/rbi/gems/spoom@1.1.5.rbi +0 -1241
  53. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +0 -98
  54. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +0 -949
  55. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -839
  56. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +0 -26
  57. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -8
  58. data/sorbet/tapioca/require.rb +0 -4
@@ -1,2486 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `pry` gem.
3
- # Please instead update this file by running `bin/tapioca gem pry`.
4
-
5
- # typed: true
6
-
7
- class BasicObject
8
- def __binding__; end
9
- end
10
-
11
- class Object < ::BasicObject
12
- include ::Kernel
13
- include ::JSON::Ext::Generator::GeneratorMethods::Object
14
- include ::PP::ObjectMixin
15
-
16
- def __binding__; end
17
- def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end
18
- end
19
-
20
- class Pry
21
- extend ::Forwardable
22
- extend ::Pry::Forwardable
23
-
24
- def initialize(options = T.unsafe(nil)); end
25
-
26
- def add_sticky_local(name, &block); end
27
- def backtrace; end
28
- def backtrace=(_arg0); end
29
- def binding_stack; end
30
- def binding_stack=(_arg0); end
31
- def color(*args, &block); end
32
- def color=(*args, &block); end
33
- def commands(*args, &block); end
34
- def commands=(*args, &block); end
35
- def complete(str); end
36
- def config; end
37
- def current_binding; end
38
- def current_context; end
39
- def custom_completions; end
40
- def custom_completions=(_arg0); end
41
- def editor(*args, &block); end
42
- def editor=(*args, &block); end
43
- def eval(line, options = T.unsafe(nil)); end
44
- def eval_string; end
45
- def eval_string=(_arg0); end
46
- def evaluate_ruby(code); end
47
- def exception_handler(*args, &block); end
48
- def exception_handler=(*args, &block); end
49
- def exec_hook(name, *args, &block); end
50
- def exit_value; end
51
- def extra_sticky_locals(*args, &block); end
52
- def extra_sticky_locals=(*args, &block); end
53
- def hooks(*args, &block); end
54
- def hooks=(*args, &block); end
55
- def inject_local(name, value, binding); end
56
- def inject_sticky_locals!; end
57
- def input(*args, &block); end
58
- def input=(*args, &block); end
59
- def input_ring; end
60
- def last_dir; end
61
- def last_dir=(_arg0); end
62
- def last_exception; end
63
- def last_exception=(exception); end
64
- def last_file; end
65
- def last_file=(_arg0); end
66
- def last_result; end
67
- def last_result=(_arg0); end
68
- def last_result_is_exception?; end
69
- def memory_size; end
70
- def memory_size=(size); end
71
- def output; end
72
- def output=(*args, &block); end
73
- def output_ring; end
74
- def pager; end
75
- def pager=(*args, &block); end
76
- def pop_prompt; end
77
- def print(*args, &block); end
78
- def print=(*args, &block); end
79
- def process_command(val); end
80
- def process_command_safely(val); end
81
- def prompt; end
82
- def prompt=(new_prompt); end
83
- def push_binding(object); end
84
- def push_initial_binding(target = T.unsafe(nil)); end
85
- def push_prompt(new_prompt); end
86
- def quiet?; end
87
- def raise_up(*args); end
88
- def raise_up!(*args); end
89
- def raise_up_common(force, *args); end
90
- def repl(target = T.unsafe(nil)); end
91
- def reset_eval_string; end
92
- def run_command(val); end
93
- def select_prompt; end
94
- def set_last_result(result, code = T.unsafe(nil)); end
95
- def should_print?; end
96
- def show_result(result); end
97
- def sticky_locals; end
98
- def suppress_output; end
99
- def suppress_output=(_arg0); end
100
- def update_input_history(code); end
101
-
102
- private
103
-
104
- def ensure_correct_encoding!(val); end
105
- def generate_prompt(prompt_proc, conf); end
106
- def handle_line(line, options); end
107
- def prompt_stack; end
108
-
109
- class << self
110
- def Code(obj); end
111
- def Method(obj); end
112
- def WrappedModule(obj); end
113
- def auto_resize!; end
114
- def binding_for(target); end
115
- def cli; end
116
- def cli=(_arg0); end
117
- def color(*args, &block); end
118
- def color=(*args, &block); end
119
- def commands(*args, &block); end
120
- def commands=(*args, &block); end
121
- def config; end
122
- def config=(_arg0); end
123
- def configure; end
124
- def critical_section; end
125
- def current; end
126
- def current_line; end
127
- def current_line=(_arg0); end
128
- def custom_completions; end
129
- def custom_completions=(_arg0); end
130
- def editor(*args, &block); end
131
- def editor=(*args, &block); end
132
- def eval_path; end
133
- def eval_path=(_arg0); end
134
- def exception_handler(*args, &block); end
135
- def exception_handler=(*args, &block); end
136
- def extra_sticky_locals(*args, &block); end
137
- def extra_sticky_locals=(*args, &block); end
138
- def final_session_setup; end
139
- def history(*args, &block); end
140
- def history=(*args, &block); end
141
- def hooks(*args, &block); end
142
- def hooks=(*args, &block); end
143
- def in_critical_section?; end
144
- def init; end
145
- def initial_session?; end
146
- def initial_session_setup; end
147
- def input(*args, &block); end
148
- def input=(*args, &block); end
149
- def last_internal_error; end
150
- def last_internal_error=(_arg0); end
151
- def line_buffer; end
152
- def line_buffer=(_arg0); end
153
- def load_file_at_toplevel(file); end
154
- def load_file_through_repl(file_name); end
155
- def load_history; end
156
- def load_rc_files; end
157
- def load_requires; end
158
- def load_traps; end
159
- def load_win32console; end
160
- def main; end
161
- def memory_size(*args, &block); end
162
- def memory_size=(*args, &block); end
163
- def output(*args, &block); end
164
- def output=(*args, &block); end
165
- def pager(*args, &block); end
166
- def pager=(*args, &block); end
167
- def print(*args, &block); end
168
- def print=(*args, &block); end
169
- def prompt(*args, &block); end
170
- def prompt=(*args, &block); end
171
- def quiet; end
172
- def quiet=(_arg0); end
173
- def rc_files_to_load; end
174
- def real_path_to(file); end
175
- def reset_defaults; end
176
- def run_command(command_string, options = T.unsafe(nil)); end
177
- def start(target = T.unsafe(nil), options = T.unsafe(nil)); end
178
- def start_with_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end
179
- def start_without_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end
180
- def toplevel_binding; end
181
- def toplevel_binding=(_arg0); end
182
- def view_clip(obj, options = T.unsafe(nil)); end
183
- end
184
- end
185
-
186
- Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array)
187
-
188
- class Pry::BasicObject < ::BasicObject
189
- include ::Kernel
190
- end
191
-
192
- Pry::BasicObject::Dir = Dir
193
- Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object)
194
- Pry::BasicObject::File = File
195
- Pry::BasicObject::Kernel = Kernel
196
- Pry::BasicObject::LoadError = LoadError
197
- Pry::BasicObject::Pry = Pry
198
-
199
- class Pry::BlockCommand < ::Pry::Command
200
- def call(*args); end
201
- def help; end
202
- end
203
-
204
- class Pry::CLI
205
- class << self
206
- def add_option_processor(&block); end
207
- def add_options(&block); end
208
- def input_args; end
209
- def input_args=(_arg0); end
210
- def option_processors; end
211
- def option_processors=(_arg0); end
212
- def options; end
213
- def options=(_arg0); end
214
- def parse_options(args = T.unsafe(nil)); end
215
- def reset; end
216
- def start(opts); end
217
- end
218
- end
219
-
220
- class Pry::CLI::NoOptionsError < ::StandardError; end
221
-
222
- class Pry::ClassCommand < ::Pry::Command
223
- def args; end
224
- def args=(_arg0); end
225
- def call(*args); end
226
- def complete(search); end
227
- def help; end
228
- def options(opt); end
229
- def opts; end
230
- def opts=(_arg0); end
231
- def process; end
232
- def setup; end
233
- def slop; end
234
- def subcommands(cmd); end
235
-
236
- class << self
237
- def doc; end
238
- def file; end
239
- def inherited(klass); end
240
- def line; end
241
- def source; end
242
- def source_file; end
243
- def source_line; end
244
- def source_location; end
245
-
246
- private
247
-
248
- def source_object; end
249
- end
250
- end
251
-
252
- class Pry::Code
253
- extend ::MethodSource::CodeHelpers
254
-
255
- def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end
256
-
257
- def <<(line); end
258
- def ==(other); end
259
- def after(lineno, lines = T.unsafe(nil)); end
260
- def around(lineno, lines = T.unsafe(nil)); end
261
- def before(lineno, lines = T.unsafe(nil)); end
262
- def between(start_line, end_line = T.unsafe(nil)); end
263
- def code_type; end
264
- def code_type=(_arg0); end
265
- def comment_describing(line_number); end
266
- def expression_at(line_number, consume = T.unsafe(nil)); end
267
- def grep(pattern); end
268
- def highlighted; end
269
- def length; end
270
- def max_lineno_width; end
271
- def method_missing(method_name, *args, &block); end
272
- def nesting_at(line_number); end
273
- def print_to_output(output, color = T.unsafe(nil)); end
274
- def push(line); end
275
- def raw; end
276
- def reject(&block); end
277
- def select(&block); end
278
- def take_lines(start_line, num_lines); end
279
- def to_s; end
280
- def with_indentation(spaces = T.unsafe(nil)); end
281
- def with_line_numbers(y_n = T.unsafe(nil)); end
282
- def with_marker(lineno = T.unsafe(nil)); end
283
-
284
- protected
285
-
286
- def alter(&block); end
287
-
288
- private
289
-
290
- def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
291
-
292
- class << self
293
- def from_file(filename, code_type = T.unsafe(nil)); end
294
- def from_method(meth, start_line = T.unsafe(nil)); end
295
- def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end
296
- end
297
- end
298
-
299
- class Pry::Code::CodeRange
300
- def initialize(start_line, end_line = T.unsafe(nil)); end
301
-
302
- def indices_range(lines); end
303
-
304
- private
305
-
306
- def end_line; end
307
- def find_end_index(lines); end
308
- def find_start_index(lines); end
309
- def force_set_end_line; end
310
- def indices(lines); end
311
- def set_end_line_from_range; end
312
- def start_line; end
313
- end
314
-
315
- class Pry::Code::LOC
316
- def initialize(line, lineno); end
317
-
318
- def ==(other); end
319
- def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end
320
- def add_marker(marker_lineno); end
321
- def colorize(code_type); end
322
- def dup; end
323
- def handle_multiline_entries_from_edit_command(line, max_width); end
324
- def indent(distance); end
325
- def line; end
326
- def lineno; end
327
- def tuple; end
328
- end
329
-
330
- class Pry::CodeFile
331
- def initialize(filename, code_type = T.unsafe(nil)); end
332
-
333
- def code; end
334
- def code_type; end
335
-
336
- private
337
-
338
- def abs_path; end
339
- def code_path; end
340
- def from_load_path; end
341
- def from_pry_init_pwd; end
342
- def from_pwd; end
343
- def readable?(path); end
344
- def type_from_filename(filename, default = T.unsafe(nil)); end
345
- end
346
-
347
- Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String)
348
- Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash)
349
- Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash)
350
- Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String)
351
-
352
- class Pry::CodeObject
353
- include ::Pry::Helpers::OptionsHelpers
354
- include ::Pry::Helpers::CommandHelpers
355
-
356
- def initialize(str, pry_instance, options = T.unsafe(nil)); end
357
-
358
- def command_lookup; end
359
- def default_lookup; end
360
- def empty_lookup; end
361
- def method_or_class_lookup; end
362
- def pry_instance; end
363
- def pry_instance=(_arg0); end
364
- def str; end
365
- def str=(_arg0); end
366
- def super_level; end
367
- def super_level=(_arg0); end
368
- def target; end
369
- def target=(_arg0); end
370
-
371
- private
372
-
373
- def looks_like_an_instance_method?(str); end
374
- def lookup_super(obj, super_level); end
375
- def safe_to_evaluate?(str); end
376
- def sourcable_object?(obj); end
377
- def target_self; end
378
-
379
- class << self
380
- def lookup(str, pry_instance, options = T.unsafe(nil)); end
381
- end
382
- end
383
-
384
- module Pry::CodeObject::Helpers
385
- def c_method?; end
386
- def c_module?; end
387
- def command?; end
388
- def module_with_yard_docs?; end
389
- def real_method_object?; end
390
- end
391
-
392
- class Pry::ColorPrinter < ::PP
393
- def pp(object); end
394
- def text(str, max_width = T.unsafe(nil)); end
395
-
396
- private
397
-
398
- def highlight_object_literal(object_literal); end
399
- def inspect_object(object); end
400
-
401
- class << self
402
- def default(_output, value, pry_instance); end
403
- def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end
404
- end
405
- end
406
-
407
- class Pry::Command
408
- include ::Pry::Helpers::BaseHelpers
409
- include ::Pry::Helpers::OptionsHelpers
410
- include ::Pry::Helpers::CommandHelpers
411
- include ::Pry::Helpers::Text
412
- extend ::Pry::Helpers::DocumentationHelpers
413
- extend ::Pry::CodeObject::Helpers
414
-
415
- def initialize(context = T.unsafe(nil)); end
416
-
417
- def _pry_; end
418
- def _pry_=(_arg0); end
419
- def arg_string; end
420
- def arg_string=(_arg0); end
421
- def block; end
422
- def captures; end
423
- def captures=(_arg0); end
424
- def check_for_command_collision(command_match, arg_string); end
425
- def command_block; end
426
- def command_block=(_arg0); end
427
- def command_name; end
428
- def command_options; end
429
- def command_set; end
430
- def command_set=(_arg0); end
431
- def commands; end
432
- def complete(_search); end
433
- def context; end
434
- def context=(_arg0); end
435
- def description; end
436
- def eval_string; end
437
- def eval_string=(_arg0); end
438
- def hooks; end
439
- def hooks=(_arg0); end
440
- def interpolate_string(str); end
441
- def match; end
442
- def name; end
443
- def output; end
444
- def output=(_arg0); end
445
- def process_line(line); end
446
- def pry_instance; end
447
- def pry_instance=(_arg0); end
448
- def run(command_string, *args); end
449
- def source; end
450
- def state; end
451
- def target; end
452
- def target=(_arg0); end
453
- def target_self; end
454
- def tokenize(val); end
455
- def void; end
456
-
457
- private
458
-
459
- def after_hooks; end
460
- def before_hooks; end
461
- def call_safely(*args); end
462
- def call_with_hooks(*args); end
463
- def find_hooks(event); end
464
- def normalize_method_args(method, args); end
465
- def pass_block(arg_string); end
466
- def use_unpatched_symbol; end
467
-
468
- class << self
469
- def banner(arg = T.unsafe(nil)); end
470
- def block; end
471
- def block=(_arg0); end
472
- def command_name; end
473
- def command_options(arg = T.unsafe(nil)); end
474
- def command_options=(_arg0); end
475
- def command_regex; end
476
- def convert_to_regex(obj); end
477
- def default_options(match); end
478
- def description(arg = T.unsafe(nil)); end
479
- def description=(_arg0); end
480
- def doc; end
481
- def file; end
482
- def group(name = T.unsafe(nil)); end
483
- def inspect; end
484
- def line; end
485
- def match(arg = T.unsafe(nil)); end
486
- def match=(_arg0); end
487
- def match_score(val); end
488
- def matches?(val); end
489
- def name; end
490
- def options(arg = T.unsafe(nil)); end
491
- def options=(_arg0); end
492
- def source; end
493
- def source_file; end
494
- def source_line; end
495
- def state; end
496
- def subclass(match, description, options, helpers, &block); end
497
- end
498
- end
499
-
500
- class Pry::Command::AmendLine < ::Pry::ClassCommand
501
- def process; end
502
-
503
- private
504
-
505
- def amend_input; end
506
- def delete_from_array(array, range); end
507
- def insert_into_array(array, range); end
508
- def line_count; end
509
- def line_range; end
510
- def replace_in_array(array, range); end
511
- def start_and_end_line_number; end
512
- def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end
513
- end
514
-
515
- class Pry::Command::Bang < ::Pry::ClassCommand
516
- def process; end
517
- end
518
-
519
- class Pry::Command::BangPry < ::Pry::ClassCommand
520
- def process; end
521
- end
522
-
523
- class Pry::Command::Cat < ::Pry::ClassCommand
524
- def complete(search); end
525
- def load_path_completions; end
526
- def options(opt); end
527
- def process; end
528
- end
529
-
530
- class Pry::Command::Cat::AbstractFormatter
531
- include ::Pry::Helpers::OptionsHelpers
532
- include ::Pry::Helpers::CommandHelpers
533
- include ::Pry::Helpers::BaseHelpers
534
-
535
- private
536
-
537
- def between_lines; end
538
- def code_type; end
539
- def decorate(content); end
540
- def use_line_numbers?; end
541
- end
542
-
543
- class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter
544
- include ::Pry::Helpers::Text
545
-
546
- def initialize(exception, pry_instance, opts); end
547
-
548
- def ex; end
549
- def format; end
550
- def opts; end
551
- def pry_instance; end
552
-
553
- private
554
-
555
- def backtrace_file; end
556
- def backtrace_level; end
557
- def backtrace_line; end
558
- def check_for_errors; end
559
- def code_window_size; end
560
- def header; end
561
- def increment_backtrace_level; end
562
- def start_and_end_line_for_code_window; end
563
- end
564
-
565
- class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter
566
- def initialize(file_with_embedded_line, pry_instance, opts); end
567
-
568
- def file_and_line; end
569
- def file_with_embedded_line; end
570
- def format; end
571
- def opts; end
572
- def pry_instance; end
573
-
574
- private
575
-
576
- def code_type; end
577
- def code_window_size; end
578
- def decorate(content); end
579
- def detect_code_type_from_file(file_name); end
580
- def file_name; end
581
- def line_number; end
582
- end
583
-
584
- class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter
585
- def initialize(input_expressions, opts); end
586
-
587
- def format; end
588
- def input_expressions; end
589
- def input_expressions=(_arg0); end
590
- def opts; end
591
- def opts=(_arg0); end
592
-
593
- private
594
-
595
- def normalized_expression_range; end
596
- def numbered_input_items; end
597
- def selected_input_items; end
598
- end
599
-
600
- class Pry::Command::Cd < ::Pry::ClassCommand
601
- def process; end
602
- end
603
-
604
- class Pry::Command::ChangeInspector < ::Pry::ClassCommand
605
- def process(inspector); end
606
-
607
- private
608
-
609
- def inspector_map; end
610
- end
611
-
612
- class Pry::Command::ChangePrompt < ::Pry::ClassCommand
613
- def options(opt); end
614
- def process(prompt); end
615
-
616
- private
617
-
618
- def change_prompt(prompt); end
619
- def list_prompts; end
620
- end
621
-
622
- class Pry::Command::ClearScreen < ::Pry::ClassCommand
623
- def process; end
624
- end
625
-
626
- class Pry::Command::CodeCollector
627
- include ::Pry::Helpers::OptionsHelpers
628
- include ::Pry::Helpers::CommandHelpers
629
-
630
- def initialize(args, opts, pry_instance); end
631
-
632
- def args; end
633
- def code_object; end
634
- def content; end
635
- def file; end
636
- def file=(_arg0); end
637
- def line_range; end
638
- def obj_name; end
639
- def opts; end
640
- def pry_input_content; end
641
- def pry_instance; end
642
- def pry_output_content; end
643
- def restrict_to_lines(content, range); end
644
-
645
- private
646
-
647
- def bad_option_combination?; end
648
- def code_object_doc; end
649
- def code_object_source_or_file; end
650
- def convert_to_range(range); end
651
- def could_not_locate(name); end
652
- def file_content; end
653
- def pry_array_content_as_string(array, ranges); end
654
-
655
- class << self
656
- def inject_options(opt); end
657
- def input_expression_ranges; end
658
- def input_expression_ranges=(_arg0); end
659
- def output_result_ranges; end
660
- def output_result_ranges=(_arg0); end
661
- end
662
- end
663
-
664
- class Pry::Command::DisablePry < ::Pry::ClassCommand
665
- def process; end
666
- end
667
-
668
- class Pry::Command::Edit < ::Pry::ClassCommand
669
- def apply_runtime_patch; end
670
- def bad_option_combination?; end
671
- def code_object; end
672
- def ensure_file_name_is_valid(file_name); end
673
- def file_and_line; end
674
- def file_and_line_for_current_exception; end
675
- def file_based_exception?; end
676
- def file_edit; end
677
- def filename_argument; end
678
- def initial_temp_file_content; end
679
- def input_expression; end
680
- def never_reload?; end
681
- def options(opt); end
682
- def patch_exception?; end
683
- def previously_patched?(code_object); end
684
- def probably_a_file?(str); end
685
- def process; end
686
- def pry_method?(code_object); end
687
- def reload?(file_name = T.unsafe(nil)); end
688
- def reloadable?; end
689
- def repl_edit; end
690
- def repl_edit?; end
691
- def runtime_patch?; end
692
- end
693
-
694
- class Pry::Command::Edit::ExceptionPatcher
695
- def initialize(pry_instance, state, exception_file_and_line); end
696
-
697
- def file_and_line; end
698
- def file_and_line=(_arg0); end
699
- def perform_patch; end
700
- def pry_instance; end
701
- def pry_instance=(_arg0); end
702
- def state; end
703
- def state=(_arg0); end
704
- end
705
-
706
- module Pry::Command::Edit::FileAndLineLocator
707
- class << self
708
- def from_binding(target); end
709
- def from_code_object(code_object, filename_argument); end
710
- def from_exception(exception, backtrace_level); end
711
- def from_filename_argument(filename_argument); end
712
- end
713
- end
714
-
715
- class Pry::Command::Exit < ::Pry::ClassCommand
716
- def process; end
717
- def process_pop_and_return; end
718
- end
719
-
720
- class Pry::Command::ExitAll < ::Pry::ClassCommand
721
- def process; end
722
- end
723
-
724
- class Pry::Command::ExitProgram < ::Pry::ClassCommand
725
- def process; end
726
- end
727
-
728
- class Pry::Command::FindMethod < ::Pry::ClassCommand
729
- extend ::Pry::Helpers::BaseHelpers
730
-
731
- def options(opt); end
732
- def process; end
733
-
734
- private
735
-
736
- def additional_info(header, method); end
737
- def content_search(namespace); end
738
- def matched_method_lines(header, method); end
739
- def name_search(namespace); end
740
- def pattern; end
741
- def print_matches(matches); end
742
- def print_matches_for_class(klass, grouped); end
743
- def recurse_namespace(klass, done = T.unsafe(nil), &block); end
744
- def search_all_methods(namespace); end
745
- def search_class; end
746
- def show_search_results(matches); end
747
- end
748
-
749
- class Pry::Command::FixIndent < ::Pry::ClassCommand
750
- def process; end
751
- end
752
-
753
- class Pry::Command::Help < ::Pry::ClassCommand
754
- def command_groups; end
755
- def display_command(command); end
756
- def display_filtered_commands(search); end
757
- def display_filtered_search_results(search); end
758
- def display_index(groups); end
759
- def display_search(search); end
760
- def group_sort_key(group_name); end
761
- def help_text_for_commands(name, commands); end
762
- def normalize(key); end
763
- def process; end
764
- def search_hash(search, hash); end
765
- def sorted_commands(commands); end
766
- def sorted_group_names(groups); end
767
- def visible_commands; end
768
- end
769
-
770
- class Pry::Command::Hist < ::Pry::ClassCommand
771
- def options(opt); end
772
- def process; end
773
-
774
- private
775
-
776
- def check_for_juxtaposed_replay(replay_sequence); end
777
- def find_history; end
778
- def process_clear; end
779
- def process_display; end
780
- def process_replay; end
781
- def process_save; end
782
- end
783
-
784
- class Pry::Command::ImportSet < ::Pry::ClassCommand
785
- def process(_command_set_name); end
786
- end
787
-
788
- class Pry::Command::JumpTo < ::Pry::ClassCommand
789
- def process(break_level); end
790
- end
791
-
792
- class Pry::Command::ListInspectors < ::Pry::ClassCommand
793
- def process; end
794
-
795
- private
796
-
797
- def inspector_map; end
798
- def selected_inspector?(inspector); end
799
- def selected_text; end
800
- end
801
-
802
- class Pry::Command::Ls < ::Pry::ClassCommand
803
- def no_user_opts?; end
804
- def options(opt); end
805
- def process; end
806
-
807
- private
808
-
809
- def error_list; end
810
- def raise_errors_if_arguments_are_weird; end
811
- end
812
-
813
- class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter
814
- include ::Pry::Command::Ls::Interrogatable
815
-
816
- def initialize(interrogatee, no_user_opts, opts, pry_instance); end
817
-
818
- def correct_opts?; end
819
- def output_self; end
820
-
821
- private
822
-
823
- def format(mod, constants); end
824
- def show_deprecated_constants?; end
825
- end
826
-
827
- Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
828
- Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
829
-
830
- class Pry::Command::Ls::Formatter
831
- def initialize(pry_instance); end
832
-
833
- def grep=(_arg0); end
834
- def pry_instance; end
835
- def write_out; end
836
-
837
- private
838
-
839
- def color(type, str); end
840
- def correct_opts?; end
841
- def format_value(value); end
842
- def grep; end
843
- def output_section(heading, body); end
844
- def output_self; end
845
- end
846
-
847
- class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter
848
- def initialize(opts, pry_instance); end
849
-
850
- def output_self; end
851
-
852
- private
853
-
854
- def format(globals); end
855
- end
856
-
857
- Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array)
858
- Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array)
859
-
860
- class Pry::Command::Ls::Grep
861
- def initialize(grep_regexp); end
862
-
863
- def regexp; end
864
- end
865
-
866
- class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter
867
- include ::Pry::Command::Ls::Interrogatable
868
-
869
- def initialize(interrogatee, no_user_opts, opts, pry_instance); end
870
-
871
- def correct_opts?; end
872
- def output_self; end
873
-
874
- private
875
-
876
- def format(type, vars); end
877
- end
878
-
879
- module Pry::Command::Ls::Interrogatable
880
- private
881
-
882
- def interrogatee_mod; end
883
- def interrogating_a_module?; end
884
- end
885
-
886
- module Pry::Command::Ls::JRubyHacks
887
- private
888
-
889
- def rubbishness(name); end
890
- def trim_jruby_aliases(methods); end
891
- end
892
-
893
- class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter
894
- def initialize(no_user_opts, args, pry_instance); end
895
-
896
- def correct_opts?; end
897
- def output_self; end
898
-
899
- private
900
-
901
- def format(locals); end
902
- end
903
-
904
- class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter
905
- def initialize(opts, pry_instance); end
906
-
907
- def output_self; end
908
-
909
- private
910
-
911
- def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end
912
- def format(name_value_pairs); end
913
- end
914
-
915
- class Pry::Command::Ls::LsEntity
916
- def initialize(opts); end
917
-
918
- def entities_table; end
919
- def pry_instance; end
920
-
921
- private
922
-
923
- def constants; end
924
- def entities; end
925
- def globals; end
926
- def grep(entity); end
927
- def instance_vars; end
928
- def local_names; end
929
- def local_vars; end
930
- def methods; end
931
- def self_methods; end
932
- end
933
-
934
- class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter
935
- include ::Pry::Command::Ls::Interrogatable
936
- include ::Pry::Command::Ls::JRubyHacks
937
- include ::Pry::Command::Ls::MethodsHelper
938
-
939
- def initialize(interrogatee, no_user_opts, opts, pry_instance); end
940
-
941
- def output_self; end
942
-
943
- private
944
-
945
- def below_ceiling; end
946
- def correct_opts?; end
947
- end
948
-
949
- module Pry::Command::Ls::MethodsHelper
950
- include ::Pry::Command::Ls::JRubyHacks
951
-
952
- private
953
-
954
- def all_methods(instance_methods = T.unsafe(nil)); end
955
- def format(methods); end
956
- def resolution_order; end
957
- end
958
-
959
- class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter
960
- include ::Pry::Command::Ls::Interrogatable
961
- include ::Pry::Command::Ls::JRubyHacks
962
- include ::Pry::Command::Ls::MethodsHelper
963
-
964
- def initialize(interrogatee, no_user_opts, opts, pry_instance); end
965
-
966
- def output_self; end
967
-
968
- private
969
-
970
- def correct_opts?; end
971
- end
972
-
973
- class Pry::Command::Nesting < ::Pry::ClassCommand
974
- def process; end
975
- end
976
-
977
- class Pry::Command::Play < ::Pry::ClassCommand
978
- def code_object; end
979
- def content; end
980
- def content_after_options; end
981
- def content_at_expression; end
982
- def default_file; end
983
- def file_content; end
984
- def options(opt); end
985
- def perform_play; end
986
- def process; end
987
- def should_use_default_file?; end
988
- def show_input; end
989
- end
990
-
991
- class Pry::Command::PryBacktrace < ::Pry::ClassCommand
992
- def process; end
993
- end
994
-
995
- class Pry::Command::RaiseUp < ::Pry::ClassCommand
996
- def process; end
997
- end
998
-
999
- class Pry::Command::ReloadCode < ::Pry::ClassCommand
1000
- def process; end
1001
-
1002
- private
1003
-
1004
- def check_for_reloadability(code_object, identifier); end
1005
- def current_file; end
1006
- def reload_current_file; end
1007
- def reload_object(identifier); end
1008
- end
1009
-
1010
- class Pry::Command::Reset < ::Pry::ClassCommand
1011
- def process; end
1012
- end
1013
-
1014
- class Pry::Command::Ri < ::Pry::ClassCommand
1015
- def process(spec); end
1016
- end
1017
-
1018
- class Pry::Command::SaveFile < ::Pry::ClassCommand
1019
- def display_content; end
1020
- def file_name; end
1021
- def mode; end
1022
- def options(opt); end
1023
- def process; end
1024
- def save_file; end
1025
- end
1026
-
1027
- class Pry::Command::ShellCommand < ::Pry::ClassCommand
1028
- def process(cmd); end
1029
-
1030
- private
1031
-
1032
- def cd_path_env; end
1033
- def cd_path_exists?; end
1034
- def parse_destination(dest); end
1035
- def path_from_cd_path(dest); end
1036
- def process_cd(dest); end
1037
- def special_case_path?(dest); end
1038
- end
1039
-
1040
- class Pry::Command::ShellMode < ::Pry::ClassCommand
1041
- def process; end
1042
- end
1043
-
1044
- class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo
1045
- include ::Pry::Helpers::DocumentationHelpers
1046
-
1047
- def content_for(code_object); end
1048
- def docs_for(code_object); end
1049
- def header_options; end
1050
- def process; end
1051
- def render_doc_markup_for(code_object); end
1052
- def start_line_for(code_object); end
1053
- end
1054
-
1055
- class Pry::Command::ShowInfo < ::Pry::ClassCommand
1056
- extend ::Pry::Helpers::BaseHelpers
1057
-
1058
- def initialize(*_arg0); end
1059
-
1060
- def code_object_header(code_object, line_num); end
1061
- def code_object_with_accessible_source(code_object); end
1062
- def complete(input); end
1063
- def content_and_header_for_code_object(code_object); end
1064
- def content_and_headers_for_all_module_candidates(mod); end
1065
- def file_and_line_for(code_object); end
1066
- def header(code_object); end
1067
- def header_options; end
1068
- def method_header(code_object, line_num); end
1069
- def method_sections(code_object); end
1070
- def module_header(code_object, line_num); end
1071
- def no_definition_message; end
1072
- def obj_name; end
1073
- def options(opt); end
1074
- def process; end
1075
- def show_all_modules?(code_object); end
1076
- def start_line_for(code_object); end
1077
- def use_line_numbers?; end
1078
- def valid_superclass?(code_object); end
1079
- end
1080
-
1081
- class Pry::Command::ShowInput < ::Pry::ClassCommand
1082
- def process; end
1083
- end
1084
-
1085
- class Pry::Command::ShowSource < ::Pry::Command::ShowInfo
1086
- include ::Pry::Helpers::DocumentationHelpers
1087
-
1088
- def content_for(code_object); end
1089
- def docs_for(code_object); end
1090
- def header_options; end
1091
- def options(opt); end
1092
- def process; end
1093
- def render_doc_markup_for(code_object); end
1094
- def start_line_for(code_object); end
1095
- end
1096
-
1097
- class Pry::Command::Stat < ::Pry::ClassCommand
1098
- def options(opt); end
1099
- def process; end
1100
- end
1101
-
1102
- class Pry::Command::SwitchTo < ::Pry::ClassCommand
1103
- def process(selection); end
1104
- end
1105
-
1106
- class Pry::Command::ToggleColor < ::Pry::ClassCommand
1107
- def color_toggle; end
1108
- def process; end
1109
- end
1110
-
1111
- Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object)
1112
-
1113
- class Pry::Command::Version < ::Pry::ClassCommand
1114
- def process; end
1115
- end
1116
-
1117
- class Pry::Command::WatchExpression < ::Pry::ClassCommand
1118
- def options(opt); end
1119
- def process; end
1120
-
1121
- private
1122
-
1123
- def add_expression(_arguments); end
1124
- def add_hook; end
1125
- def delete(index); end
1126
- def eval_and_print_changed(output); end
1127
- def expressions; end
1128
- def list; end
1129
- end
1130
-
1131
- class Pry::Command::WatchExpression::Expression
1132
- def initialize(pry_instance, target, source); end
1133
-
1134
- def changed?; end
1135
- def eval!; end
1136
- def previous_value; end
1137
- def pry_instance; end
1138
- def source; end
1139
- def target; end
1140
- def to_s; end
1141
- def value; end
1142
-
1143
- private
1144
-
1145
- def target_eval(target, source); end
1146
- end
1147
-
1148
- class Pry::Command::Whereami < ::Pry::ClassCommand
1149
- def initialize(*_arg0); end
1150
-
1151
- def bad_option_combination?; end
1152
- def code; end
1153
- def code?; end
1154
- def location; end
1155
- def options(opt); end
1156
- def process; end
1157
- def setup; end
1158
-
1159
- private
1160
-
1161
- def class_code; end
1162
- def code_window; end
1163
- def default_code; end
1164
- def expand_path(filename); end
1165
- def handle_internal_binding; end
1166
- def marker; end
1167
- def method_code; end
1168
- def nothing_to_do?; end
1169
- def small_method?; end
1170
- def target_class; end
1171
- def top_level?; end
1172
- def use_line_numbers?; end
1173
- def valid_method?; end
1174
- def window_size; end
1175
-
1176
- class << self
1177
- def method_size_cutoff; end
1178
- def method_size_cutoff=(_arg0); end
1179
- end
1180
- end
1181
-
1182
- class Pry::Command::Wtf < ::Pry::ClassCommand
1183
- def options(opt); end
1184
- def process; end
1185
-
1186
- private
1187
-
1188
- def format_backtrace(backtrace); end
1189
- def format_header(title, exception); end
1190
- def read_line(file, line); end
1191
- def trim_backtrace(backtrace); end
1192
- def unwind_exceptions; end
1193
- end
1194
-
1195
- Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp)
1196
- class Pry::CommandError < ::StandardError; end
1197
-
1198
- class Pry::CommandSet
1199
- include ::Enumerable
1200
- include ::Pry::Helpers::BaseHelpers
1201
-
1202
- def initialize(*imported_sets, &block); end
1203
-
1204
- def [](pattern); end
1205
- def []=(pattern, command); end
1206
- def add_command(command); end
1207
- def alias_command(match, action, options = T.unsafe(nil)); end
1208
- def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
1209
- def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
1210
- def complete(search, context = T.unsafe(nil)); end
1211
- def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
1212
- def delete(*searches); end
1213
- def desc(search, description = T.unsafe(nil)); end
1214
- def each(&block); end
1215
- def find_command(pattern); end
1216
- def find_command_by_match_or_listing(match_or_listing); end
1217
- def find_command_for_help(search); end
1218
- def helper_module; end
1219
- def import(*sets); end
1220
- def import_from(set, *matches); end
1221
- def keys; end
1222
- def list_commands; end
1223
- def process_line(val, context = T.unsafe(nil)); end
1224
- def rename_command(new_match, search, options = T.unsafe(nil)); end
1225
- def to_h; end
1226
- def to_hash; end
1227
- def valid_command?(val); end
1228
-
1229
- private
1230
-
1231
- def helpers(&block); end
1232
- end
1233
-
1234
- class Pry::CommandState
1235
- def initialize; end
1236
-
1237
- def reset(command_name); end
1238
- def state_for(command_name); end
1239
-
1240
- class << self
1241
- def default; end
1242
- end
1243
- end
1244
-
1245
- Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet)
1246
-
1247
- class Pry::Config
1248
- extend ::Pry::Config::Attributable
1249
-
1250
- def initialize; end
1251
-
1252
- def [](attr); end
1253
- def []=(attr, value); end
1254
- def auto_indent; end
1255
- def auto_indent=(_arg0); end
1256
- def collision_warning; end
1257
- def collision_warning=(_arg0); end
1258
- def color; end
1259
- def color=(_arg0); end
1260
- def command_completions; end
1261
- def command_completions=(_arg0); end
1262
- def command_prefix; end
1263
- def command_prefix=(_arg0); end
1264
- def commands; end
1265
- def commands=(_arg0); end
1266
- def completer; end
1267
- def completer=(_arg0); end
1268
- def control_d_handler; end
1269
- def control_d_handler=(value); end
1270
- def correct_indent; end
1271
- def correct_indent=(_arg0); end
1272
- def default_window_size; end
1273
- def default_window_size=(_arg0); end
1274
- def disable_auto_reload; end
1275
- def disable_auto_reload=(_arg0); end
1276
- def editor; end
1277
- def editor=(_arg0); end
1278
- def exception_handler; end
1279
- def exception_handler=(_arg0); end
1280
- def exception_whitelist; end
1281
- def exception_whitelist=(_arg0); end
1282
- def exec_string; end
1283
- def exec_string=(_arg0); end
1284
- def extra_sticky_locals; end
1285
- def extra_sticky_locals=(_arg0); end
1286
- def file_completions; end
1287
- def file_completions=(_arg0); end
1288
- def history; end
1289
- def history=(_arg0); end
1290
- def history_file; end
1291
- def history_file=(_arg0); end
1292
- def history_ignorelist; end
1293
- def history_ignorelist=(_arg0); end
1294
- def history_load; end
1295
- def history_load=(_arg0); end
1296
- def history_save; end
1297
- def history_save=(_arg0); end
1298
- def hooks; end
1299
- def hooks=(_arg0); end
1300
- def input; end
1301
- def input=(_arg0); end
1302
- def ls; end
1303
- def ls=(_arg0); end
1304
- def memory_size; end
1305
- def memory_size=(_arg0); end
1306
- def merge(config_hash); end
1307
- def merge!(config_hash); end
1308
- def method_missing(method_name, *args, &_block); end
1309
- def output; end
1310
- def output=(_arg0); end
1311
- def output_prefix; end
1312
- def output_prefix=(_arg0); end
1313
- def pager; end
1314
- def pager=(_arg0); end
1315
- def print; end
1316
- def print=(_arg0); end
1317
- def prompt; end
1318
- def prompt=(_arg0); end
1319
- def prompt_name; end
1320
- def prompt_name=(_arg0); end
1321
- def prompt_safe_contexts; end
1322
- def prompt_safe_contexts=(_arg0); end
1323
- def quiet; end
1324
- def quiet=(_arg0); end
1325
- def rc_file; end
1326
- def rc_file=(_arg0); end
1327
- def requires; end
1328
- def requires=(_arg0); end
1329
- def should_load_local_rc; end
1330
- def should_load_local_rc=(_arg0); end
1331
- def should_load_rc; end
1332
- def should_load_rc=(_arg0); end
1333
- def should_load_requires; end
1334
- def should_load_requires=(_arg0); end
1335
- def should_trap_interrupts; end
1336
- def should_trap_interrupts=(_arg0); end
1337
- def system; end
1338
- def system=(_arg0); end
1339
- def unrescued_exceptions; end
1340
- def unrescued_exceptions=(_arg0); end
1341
- def windows_console_warning; end
1342
- def windows_console_warning=(_arg0); end
1343
-
1344
- private
1345
-
1346
- def default_rc_file; end
1347
- def initialize_dup(other); end
1348
- def lazy_readline; end
1349
- def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
1350
- end
1351
-
1352
- module Pry::Config::Attributable
1353
- def attribute(attr_name); end
1354
- end
1355
-
1356
- class Pry::Config::LazyValue
1357
- def initialize(&block); end
1358
-
1359
- def call; end
1360
- end
1361
-
1362
- class Pry::Config::MemoizedValue
1363
- def initialize(&block); end
1364
-
1365
- def call; end
1366
- end
1367
-
1368
- class Pry::Config::Value
1369
- def initialize(value); end
1370
-
1371
- def call; end
1372
- end
1373
-
1374
- module Pry::ControlDHandler
1375
- class << self
1376
- def default(pry_instance); end
1377
- end
1378
- end
1379
-
1380
- Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array)
1381
-
1382
- class Pry::Editor
1383
- include ::Pry::Helpers::OptionsHelpers
1384
- include ::Pry::Helpers::CommandHelpers
1385
-
1386
- def initialize(pry_instance); end
1387
-
1388
- def build_editor_invocation_string(file, line, blocking); end
1389
- def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end
1390
- def invoke_editor(file, line, blocking = T.unsafe(nil)); end
1391
- def pry_instance; end
1392
-
1393
- private
1394
-
1395
- def blocking_flag_for_editor(blocking); end
1396
- def editor_name; end
1397
- def open_editor(editor_invocation); end
1398
- def open_editor_on_jruby(editor_invocation); end
1399
- def start_line_syntax_for_editor(file_name, line_number); end
1400
-
1401
- class << self
1402
- def default; end
1403
- end
1404
- end
1405
-
1406
- module Pry::Env
1407
- class << self
1408
- def [](key); end
1409
- end
1410
- end
1411
-
1412
- module Pry::ExceptionHandler
1413
- class << self
1414
- def handle_exception(output, exception, _pry_instance); end
1415
-
1416
- private
1417
-
1418
- def cause_text(cause); end
1419
- def exception_text(exception); end
1420
- def standard_error_text_for(exception); end
1421
- end
1422
- end
1423
-
1424
- module Pry::Forwardable
1425
- include ::Forwardable
1426
-
1427
- def def_private_delegators(target, *private_delegates); end
1428
- end
1429
-
1430
- module Pry::FrozenObjectException
1431
- class << self
1432
- def ===(exception); end
1433
- end
1434
- end
1435
-
1436
- module Pry::Helpers
1437
- class << self
1438
- def tablify(things, line_length, pry_instance = T.unsafe(nil)); end
1439
- def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end
1440
- def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end
1441
- end
1442
- end
1443
-
1444
- module Pry::Helpers::BaseHelpers
1445
- extend ::Pry::Helpers::BaseHelpers
1446
-
1447
- def colorize_code(code); end
1448
- def find_command(name, set = T.unsafe(nil)); end
1449
- def heading(text); end
1450
- def highlight(string, regexp, highlight_color = T.unsafe(nil)); end
1451
- def not_a_real_file?(file); end
1452
- def safe_send(obj, method, *args, &block); end
1453
- def silence_warnings; end
1454
- def stagger_output(text, _out = T.unsafe(nil)); end
1455
- def use_ansi_codes?; end
1456
- end
1457
-
1458
- module Pry::Helpers::CommandHelpers
1459
- include ::Pry::Helpers::OptionsHelpers
1460
- extend ::Pry::Helpers::OptionsHelpers
1461
- extend ::Pry::Helpers::CommandHelpers
1462
-
1463
- def absolute_index_number(line_number, array_length); end
1464
- def absolute_index_range(range_or_number, array_length); end
1465
- def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end
1466
- def internal_binding?(context); end
1467
- def one_index_number(line_number); end
1468
- def one_index_range(range); end
1469
- def one_index_range_or_number(range_or_number); end
1470
- def restrict_to_lines(content, lines); end
1471
- def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end
1472
- def temp_file(ext = T.unsafe(nil)); end
1473
- def unindent(dirty_text, left_padding = T.unsafe(nil)); end
1474
- end
1475
-
1476
- module Pry::Helpers::DocumentationHelpers
1477
- private
1478
-
1479
- def get_comment_content(comment); end
1480
- def process_comment_markup(comment); end
1481
- def process_rdoc(comment); end
1482
- def process_yardoc(comment); end
1483
- def process_yardoc_tag(comment, tag); end
1484
- def strip_comments_from_c_code(code); end
1485
- def strip_leading_whitespace(text); end
1486
-
1487
- class << self
1488
- def get_comment_content(comment); end
1489
- def process_comment_markup(comment); end
1490
- def process_rdoc(comment); end
1491
- def process_yardoc(comment); end
1492
- def process_yardoc_tag(comment, tag); end
1493
- def strip_comments_from_c_code(code); end
1494
- def strip_leading_whitespace(text); end
1495
- end
1496
- end
1497
-
1498
- Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array)
1499
-
1500
- module Pry::Helpers::OptionsHelpers
1501
- private
1502
-
1503
- def method_object; end
1504
- def method_options(opt); end
1505
-
1506
- class << self
1507
- def method_object; end
1508
- def method_options(opt); end
1509
- end
1510
- end
1511
-
1512
- module Pry::Helpers::Platform
1513
- class << self
1514
- def jruby?; end
1515
- def jruby_19?; end
1516
- def linux?; end
1517
- def mac_osx?; end
1518
- def mri?; end
1519
- def mri_19?; end
1520
- def mri_2?; end
1521
- def windows?; end
1522
- def windows_ansi?; end
1523
- end
1524
- end
1525
-
1526
- class Pry::Helpers::Table
1527
- def initialize(items, args, pry_instance = T.unsafe(nil)); end
1528
-
1529
- def ==(other); end
1530
- def column_count; end
1531
- def column_count=(count); end
1532
- def columns; end
1533
- def fits_on_line?(line_length); end
1534
- def items; end
1535
- def items=(items); end
1536
- def rows_to_s(style = T.unsafe(nil)); end
1537
- def to_a; end
1538
- def to_s; end
1539
-
1540
- private
1541
-
1542
- def _max_width(things); end
1543
- def _rebuild_colorless_cache; end
1544
- def _recall_color_for(thing); end
1545
- def _recolumn; end
1546
- end
1547
-
1548
- module Pry::Helpers::Text
1549
- extend ::Pry::Helpers::Text
1550
-
1551
- def black(text); end
1552
- def black_on_black(text); end
1553
- def black_on_blue(text); end
1554
- def black_on_cyan(text); end
1555
- def black_on_green(text); end
1556
- def black_on_magenta(text); end
1557
- def black_on_purple(text); end
1558
- def black_on_red(text); end
1559
- def black_on_white(text); end
1560
- def black_on_yellow(text); end
1561
- def blue(text); end
1562
- def blue_on_black(text); end
1563
- def blue_on_blue(text); end
1564
- def blue_on_cyan(text); end
1565
- def blue_on_green(text); end
1566
- def blue_on_magenta(text); end
1567
- def blue_on_purple(text); end
1568
- def blue_on_red(text); end
1569
- def blue_on_white(text); end
1570
- def blue_on_yellow(text); end
1571
- def bold(text); end
1572
- def bright_black(text); end
1573
- def bright_black_on_black(text); end
1574
- def bright_black_on_blue(text); end
1575
- def bright_black_on_cyan(text); end
1576
- def bright_black_on_green(text); end
1577
- def bright_black_on_magenta(text); end
1578
- def bright_black_on_purple(text); end
1579
- def bright_black_on_red(text); end
1580
- def bright_black_on_white(text); end
1581
- def bright_black_on_yellow(text); end
1582
- def bright_blue(text); end
1583
- def bright_blue_on_black(text); end
1584
- def bright_blue_on_blue(text); end
1585
- def bright_blue_on_cyan(text); end
1586
- def bright_blue_on_green(text); end
1587
- def bright_blue_on_magenta(text); end
1588
- def bright_blue_on_purple(text); end
1589
- def bright_blue_on_red(text); end
1590
- def bright_blue_on_white(text); end
1591
- def bright_blue_on_yellow(text); end
1592
- def bright_cyan(text); end
1593
- def bright_cyan_on_black(text); end
1594
- def bright_cyan_on_blue(text); end
1595
- def bright_cyan_on_cyan(text); end
1596
- def bright_cyan_on_green(text); end
1597
- def bright_cyan_on_magenta(text); end
1598
- def bright_cyan_on_purple(text); end
1599
- def bright_cyan_on_red(text); end
1600
- def bright_cyan_on_white(text); end
1601
- def bright_cyan_on_yellow(text); end
1602
- def bright_green(text); end
1603
- def bright_green_on_black(text); end
1604
- def bright_green_on_blue(text); end
1605
- def bright_green_on_cyan(text); end
1606
- def bright_green_on_green(text); end
1607
- def bright_green_on_magenta(text); end
1608
- def bright_green_on_purple(text); end
1609
- def bright_green_on_red(text); end
1610
- def bright_green_on_white(text); end
1611
- def bright_green_on_yellow(text); end
1612
- def bright_magenta(text); end
1613
- def bright_magenta_on_black(text); end
1614
- def bright_magenta_on_blue(text); end
1615
- def bright_magenta_on_cyan(text); end
1616
- def bright_magenta_on_green(text); end
1617
- def bright_magenta_on_magenta(text); end
1618
- def bright_magenta_on_purple(text); end
1619
- def bright_magenta_on_red(text); end
1620
- def bright_magenta_on_white(text); end
1621
- def bright_magenta_on_yellow(text); end
1622
- def bright_purple(text); end
1623
- def bright_purple_on_black(text); end
1624
- def bright_purple_on_blue(text); end
1625
- def bright_purple_on_cyan(text); end
1626
- def bright_purple_on_green(text); end
1627
- def bright_purple_on_magenta(text); end
1628
- def bright_purple_on_purple(text); end
1629
- def bright_purple_on_red(text); end
1630
- def bright_purple_on_white(text); end
1631
- def bright_purple_on_yellow(text); end
1632
- def bright_red(text); end
1633
- def bright_red_on_black(text); end
1634
- def bright_red_on_blue(text); end
1635
- def bright_red_on_cyan(text); end
1636
- def bright_red_on_green(text); end
1637
- def bright_red_on_magenta(text); end
1638
- def bright_red_on_purple(text); end
1639
- def bright_red_on_red(text); end
1640
- def bright_red_on_white(text); end
1641
- def bright_red_on_yellow(text); end
1642
- def bright_white(text); end
1643
- def bright_white_on_black(text); end
1644
- def bright_white_on_blue(text); end
1645
- def bright_white_on_cyan(text); end
1646
- def bright_white_on_green(text); end
1647
- def bright_white_on_magenta(text); end
1648
- def bright_white_on_purple(text); end
1649
- def bright_white_on_red(text); end
1650
- def bright_white_on_white(text); end
1651
- def bright_white_on_yellow(text); end
1652
- def bright_yellow(text); end
1653
- def bright_yellow_on_black(text); end
1654
- def bright_yellow_on_blue(text); end
1655
- def bright_yellow_on_cyan(text); end
1656
- def bright_yellow_on_green(text); end
1657
- def bright_yellow_on_magenta(text); end
1658
- def bright_yellow_on_purple(text); end
1659
- def bright_yellow_on_red(text); end
1660
- def bright_yellow_on_white(text); end
1661
- def bright_yellow_on_yellow(text); end
1662
- def cyan(text); end
1663
- def cyan_on_black(text); end
1664
- def cyan_on_blue(text); end
1665
- def cyan_on_cyan(text); end
1666
- def cyan_on_green(text); end
1667
- def cyan_on_magenta(text); end
1668
- def cyan_on_purple(text); end
1669
- def cyan_on_red(text); end
1670
- def cyan_on_white(text); end
1671
- def cyan_on_yellow(text); end
1672
- def default(text); end
1673
- def green(text); end
1674
- def green_on_black(text); end
1675
- def green_on_blue(text); end
1676
- def green_on_cyan(text); end
1677
- def green_on_green(text); end
1678
- def green_on_magenta(text); end
1679
- def green_on_purple(text); end
1680
- def green_on_red(text); end
1681
- def green_on_white(text); end
1682
- def green_on_yellow(text); end
1683
- def indent(text, chars); end
1684
- def magenta(text); end
1685
- def magenta_on_black(text); end
1686
- def magenta_on_blue(text); end
1687
- def magenta_on_cyan(text); end
1688
- def magenta_on_green(text); end
1689
- def magenta_on_magenta(text); end
1690
- def magenta_on_purple(text); end
1691
- def magenta_on_red(text); end
1692
- def magenta_on_white(text); end
1693
- def magenta_on_yellow(text); end
1694
- def no_color; end
1695
- def no_pager; end
1696
- def purple(text); end
1697
- def purple_on_black(text); end
1698
- def purple_on_blue(text); end
1699
- def purple_on_cyan(text); end
1700
- def purple_on_green(text); end
1701
- def purple_on_magenta(text); end
1702
- def purple_on_purple(text); end
1703
- def purple_on_red(text); end
1704
- def purple_on_white(text); end
1705
- def purple_on_yellow(text); end
1706
- def red(text); end
1707
- def red_on_black(text); end
1708
- def red_on_blue(text); end
1709
- def red_on_cyan(text); end
1710
- def red_on_green(text); end
1711
- def red_on_magenta(text); end
1712
- def red_on_purple(text); end
1713
- def red_on_red(text); end
1714
- def red_on_white(text); end
1715
- def red_on_yellow(text); end
1716
- def strip_color(text); end
1717
- def white(text); end
1718
- def white_on_black(text); end
1719
- def white_on_blue(text); end
1720
- def white_on_cyan(text); end
1721
- def white_on_green(text); end
1722
- def white_on_magenta(text); end
1723
- def white_on_purple(text); end
1724
- def white_on_red(text); end
1725
- def white_on_white(text); end
1726
- def white_on_yellow(text); end
1727
- def with_line_numbers(text, offset, color = T.unsafe(nil)); end
1728
- def yellow(text); end
1729
- def yellow_on_black(text); end
1730
- def yellow_on_blue(text); end
1731
- def yellow_on_cyan(text); end
1732
- def yellow_on_green(text); end
1733
- def yellow_on_magenta(text); end
1734
- def yellow_on_purple(text); end
1735
- def yellow_on_red(text); end
1736
- def yellow_on_white(text); end
1737
- def yellow_on_yellow(text); end
1738
- end
1739
-
1740
- Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash)
1741
-
1742
- class Pry::History
1743
- def initialize(options = T.unsafe(nil)); end
1744
-
1745
- def <<(line); end
1746
- def clear; end
1747
- def filter(history); end
1748
- def history_line_count; end
1749
- def load; end
1750
- def loader; end
1751
- def loader=(_arg0); end
1752
- def original_lines; end
1753
- def push(line); end
1754
- def saver; end
1755
- def saver=(_arg0); end
1756
- def session_line_count; end
1757
- def to_a; end
1758
-
1759
- private
1760
-
1761
- def history_file; end
1762
- def history_file_path; end
1763
- def invalid_readline_line?(line); end
1764
- def read_from_file; end
1765
- def save_to_file(line); end
1766
- def should_ignore?(line); end
1767
-
1768
- class << self
1769
- def default_file; end
1770
- end
1771
- end
1772
-
1773
- class Pry::Hooks
1774
- def initialize; end
1775
-
1776
- def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end
1777
- def clear_event_hooks(event_name); end
1778
- def delete_hook(event_name, hook_name); end
1779
- def errors; end
1780
- def exec_hook(event_name, *args, &block); end
1781
- def get_hook(event_name, hook_name); end
1782
- def get_hooks(event_name); end
1783
- def hook_count(event_name); end
1784
- def hook_exists?(event_name, hook_name); end
1785
- def merge(other); end
1786
- def merge!(other); end
1787
-
1788
- protected
1789
-
1790
- def hooks; end
1791
-
1792
- private
1793
-
1794
- def initialize_copy(_orig); end
1795
-
1796
- class << self
1797
- def default; end
1798
- end
1799
- end
1800
-
1801
- class Pry::Indent
1802
- include ::Pry::Helpers::BaseHelpers
1803
-
1804
- def initialize(pry_instance = T.unsafe(nil)); end
1805
-
1806
- def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end
1807
- def current_prefix; end
1808
- def end_of_statement?(last_token, last_kind); end
1809
- def in_string?; end
1810
- def indent(input); end
1811
- def indent_level; end
1812
- def indentation_delta(tokens); end
1813
- def module_nesting; end
1814
- def open_delimiters; end
1815
- def open_delimiters_line; end
1816
- def reset; end
1817
- def stack; end
1818
- def tokenize(string); end
1819
- def track_delimiter(token); end
1820
- def track_module_nesting(token, kind); end
1821
- def track_module_nesting_end(token, kind = T.unsafe(nil)); end
1822
-
1823
- class << self
1824
- def indent(str); end
1825
- def nesting_at(str, line_number); end
1826
- end
1827
- end
1828
-
1829
- Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array)
1830
- Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array)
1831
- Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash)
1832
- Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array)
1833
- Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array)
1834
- Pry::Indent::SPACES = T.let(T.unsafe(nil), String)
1835
- Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array)
1836
- class Pry::Indent::UnparseableNestingError < ::StandardError; end
1837
-
1838
- class Pry::InputCompleter
1839
- def initialize(input, pry = T.unsafe(nil)); end
1840
-
1841
- def build_path(input); end
1842
- def call(str, options = T.unsafe(nil)); end
1843
- def ignored_modules; end
1844
- def select_message(path, receiver, message, candidates); end
1845
- end
1846
-
1847
- Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp)
1848
- Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp)
1849
- Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp)
1850
- Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
1851
- Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp)
1852
- Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp)
1853
- Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp)
1854
- Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp)
1855
- Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
1856
- Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp)
1857
- Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp)
1858
- Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp)
1859
- Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
1860
- Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String)
1861
-
1862
- class Pry::InputLock
1863
- def initialize; end
1864
-
1865
- def __with_ownership; end
1866
- def enter_interruptible_region; end
1867
- def interruptible_region; end
1868
- def leave_interruptible_region; end
1869
- def with_ownership(&block); end
1870
-
1871
- class << self
1872
- def for(input); end
1873
- def global_lock; end
1874
- def global_lock=(_arg0); end
1875
- def input_locks; end
1876
- def input_locks=(_arg0); end
1877
- end
1878
- end
1879
-
1880
- class Pry::InputLock::Interrupt < ::Exception; end
1881
- class Pry::Inspector; end
1882
- Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash)
1883
- Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String)
1884
-
1885
- class Pry::LastException < ::BasicObject
1886
- def initialize(exception); end
1887
-
1888
- def bt_index; end
1889
- def bt_index=(_arg0); end
1890
- def bt_source_location_for(index); end
1891
- def file; end
1892
- def inc_bt_index; end
1893
- def line; end
1894
- def method_missing(name, *args, &block); end
1895
- def wrapped_exception; end
1896
-
1897
- private
1898
-
1899
- def respond_to_missing?(name, include_all = T.unsafe(nil)); end
1900
- end
1901
-
1902
- class Pry::Method
1903
- include ::Pry::Helpers::BaseHelpers
1904
- include ::Pry::Helpers::DocumentationHelpers
1905
- include ::Pry::CodeObject::Helpers
1906
- extend ::Pry::Helpers::BaseHelpers
1907
- extend ::Forwardable
1908
- extend ::Pry::Forwardable
1909
-
1910
- def initialize(method, known_info = T.unsafe(nil)); end
1911
-
1912
- def ==(other); end
1913
- def alias?; end
1914
- def aliases; end
1915
- def bound_method?; end
1916
- def comment; end
1917
- def doc; end
1918
- def dynamically_defined?; end
1919
- def is_a?(klass); end
1920
- def kind_of?(klass); end
1921
- def method_missing(method_name, *args, &block); end
1922
- def name; end
1923
- def name_with_owner; end
1924
- def original_name; end
1925
- def owner(*args, &block); end
1926
- def parameters(*args, &block); end
1927
- def pry_method?; end
1928
- def receiver(*args, &block); end
1929
- def redefine(source); end
1930
- def respond_to?(method_name, include_all = T.unsafe(nil)); end
1931
- def signature; end
1932
- def singleton_method?; end
1933
- def source; end
1934
- def source?; end
1935
- def source_file; end
1936
- def source_line; end
1937
- def source_range; end
1938
- def source_type; end
1939
- def super(times = T.unsafe(nil)); end
1940
- def unbound_method?; end
1941
- def undefined?; end
1942
- def visibility; end
1943
- def wrapped; end
1944
- def wrapped_owner; end
1945
-
1946
- private
1947
-
1948
- def c_source; end
1949
- def method_name_from_first_line(first_ln); end
1950
- def pry_doc_info; end
1951
- def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
1952
- def ruby_source; end
1953
- def super_using_ancestors(ancestors, times = T.unsafe(nil)); end
1954
-
1955
- class << self
1956
- def all_from_class(klass, include_super = T.unsafe(nil)); end
1957
- def all_from_obj(obj, include_super = T.unsafe(nil)); end
1958
- def from_binding(binding); end
1959
- def from_class(klass, name, target = T.unsafe(nil)); end
1960
- def from_module(klass, name, target = T.unsafe(nil)); end
1961
- def from_obj(obj, name, target = T.unsafe(nil)); end
1962
- def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end
1963
- def instance_method_definition?(name, definition_line); end
1964
- def instance_resolution_order(klass); end
1965
- def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end
1966
- def method_definition?(name, definition_line); end
1967
- def resolution_order(obj); end
1968
- def singleton_class_of(obj); end
1969
- def singleton_class_resolution_order(klass); end
1970
- def singleton_method_definition?(name, definition_line); end
1971
- end
1972
- end
1973
-
1974
- class Pry::Method::Disowned < ::Pry::Method
1975
- def initialize(receiver, method_name); end
1976
-
1977
- def method_missing(method_name, *args, &block); end
1978
- def name; end
1979
- def owner; end
1980
- def receiver; end
1981
- def source?; end
1982
- def undefined?; end
1983
-
1984
- private
1985
-
1986
- def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
1987
- end
1988
-
1989
- class Pry::Method::Patcher
1990
- def initialize(method); end
1991
-
1992
- def method; end
1993
- def method=(_arg0); end
1994
- def patch_in_ram(source); end
1995
-
1996
- private
1997
-
1998
- def cache_key; end
1999
- def definition_for_owner(line); end
2000
- def redefine(source); end
2001
- def with_method_transaction; end
2002
- def wrap(source); end
2003
- def wrap_for_nesting(source); end
2004
- def wrap_for_owner(source); end
2005
-
2006
- class << self
2007
- def code_for(filename); end
2008
- end
2009
- end
2010
-
2011
- class Pry::Method::WeirdMethodLocator
2012
- def initialize(method, target); end
2013
-
2014
- def find_method; end
2015
- def lost_method?; end
2016
- def method; end
2017
- def method=(_arg0); end
2018
- def target; end
2019
- def target=(_arg0); end
2020
-
2021
- private
2022
-
2023
- def all_methods_for(obj); end
2024
- def expanded_source_location(source_location); end
2025
- def find_method_in_superclass; end
2026
- def find_renamed_method; end
2027
- def index_to_line_number(index); end
2028
- def lines_for_file(file); end
2029
- def normal_method?(method); end
2030
- def pry_file?; end
2031
- def renamed_method_source_location; end
2032
- def skip_superclass_search?; end
2033
- def target_file; end
2034
- def target_line; end
2035
- def target_self; end
2036
- def valid_file?(file); end
2037
-
2038
- class << self
2039
- def normal_method?(method, binding); end
2040
- def weird_method?(method, binding); end
2041
- end
2042
- end
2043
-
2044
- class Pry::MethodNotFound < ::Pry::CommandError; end
2045
-
2046
- class Pry::NoCommandError < ::StandardError
2047
- def initialize(match, owner); end
2048
- end
2049
-
2050
- class Pry::ObjectPath
2051
- def initialize(path_string, current_stack); end
2052
-
2053
- def resolve; end
2054
-
2055
- private
2056
-
2057
- def complete?(segment); end
2058
- def handle_failure(context, err); end
2059
- end
2060
-
2061
- Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array)
2062
- class Pry::ObsoleteError < ::StandardError; end
2063
-
2064
- class Pry::Output
2065
- def initialize(pry_instance); end
2066
-
2067
- def <<(*objs); end
2068
- def decolorize_maybe(str); end
2069
- def height; end
2070
- def method_missing(method_name, *args, &block); end
2071
- def print(*objs); end
2072
- def pry_instance; end
2073
- def puts(*objs); end
2074
- def size; end
2075
- def tty?; end
2076
- def width; end
2077
- def write(*objs); end
2078
-
2079
- private
2080
-
2081
- def actual_screen_size; end
2082
- def ansicon_env_size; end
2083
- def env_size; end
2084
- def io_console_size; end
2085
- def nonzero_column?(size); end
2086
- def readline_size; end
2087
- def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
2088
- end
2089
-
2090
- Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array)
2091
-
2092
- class Pry::Pager
2093
- def initialize(pry_instance); end
2094
-
2095
- def open; end
2096
- def page(text); end
2097
- def pry_instance; end
2098
-
2099
- private
2100
-
2101
- def best_available; end
2102
- def enabled?; end
2103
- def output; end
2104
- end
2105
-
2106
- class Pry::Pager::NullPager
2107
- def initialize(out); end
2108
-
2109
- def <<(str); end
2110
- def close; end
2111
- def print(str); end
2112
- def puts(str); end
2113
- def write(str); end
2114
-
2115
- private
2116
-
2117
- def height; end
2118
- def width; end
2119
- end
2120
-
2121
- class Pry::Pager::PageTracker
2122
- def initialize(rows, cols); end
2123
-
2124
- def page?; end
2125
- def record(str); end
2126
- def reset; end
2127
-
2128
- private
2129
-
2130
- def line_length(line); end
2131
- end
2132
-
2133
- class Pry::Pager::SimplePager < ::Pry::Pager::NullPager
2134
- def initialize(*_arg0); end
2135
-
2136
- def write(str); end
2137
- end
2138
-
2139
- class Pry::Pager::StopPaging < ::StandardError; end
2140
-
2141
- class Pry::Pager::SystemPager < ::Pry::Pager::NullPager
2142
- def initialize(*_arg0); end
2143
-
2144
- def close; end
2145
- def write(str); end
2146
-
2147
- private
2148
-
2149
- def invoked_pager?; end
2150
- def pager; end
2151
- def write_to_pager(text); end
2152
-
2153
- class << self
2154
- def available?; end
2155
- def default_pager; end
2156
- end
2157
- end
2158
-
2159
- class Pry::Prompt
2160
- def initialize(name, description, prompt_procs); end
2161
-
2162
- def [](key); end
2163
- def description; end
2164
- def incomplete_proc; end
2165
- def name; end
2166
- def prompt_procs; end
2167
- def wait_proc; end
2168
-
2169
- class << self
2170
- def [](name); end
2171
- def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end
2172
- def all; end
2173
- end
2174
- end
2175
-
2176
- class Pry::REPL
2177
- extend ::Forwardable
2178
- extend ::Pry::Forwardable
2179
-
2180
- def initialize(pry, options = T.unsafe(nil)); end
2181
-
2182
- def input(*args, &block); end
2183
- def output(*args, &block); end
2184
- def pry; end
2185
- def pry=(_arg0); end
2186
- def start; end
2187
-
2188
- private
2189
-
2190
- def calculate_overhang(current_prompt, original_val, indented_val); end
2191
- def coolline_available?; end
2192
- def epilogue; end
2193
- def handle_read_errors; end
2194
- def input_readline(*args); end
2195
- def piping?; end
2196
- def prologue; end
2197
- def read; end
2198
- def read_line(current_prompt); end
2199
- def readline_available?; end
2200
- def repl; end
2201
- def set_readline_output; end
2202
-
2203
- class << self
2204
- def start(options); end
2205
- end
2206
- end
2207
-
2208
- class Pry::REPLFileLoader
2209
- def initialize(file_name); end
2210
-
2211
- def define_additional_commands; end
2212
- def interactive_mode(pry_instance); end
2213
- def load; end
2214
- def non_interactive_mode(pry_instance, content); end
2215
- end
2216
-
2217
- module Pry::RescuableException
2218
- class << self
2219
- def ===(exception); end
2220
- end
2221
- end
2222
-
2223
- class Pry::Result
2224
- def initialize(is_command, retval = T.unsafe(nil)); end
2225
-
2226
- def command?; end
2227
- def retval; end
2228
- def void_command?; end
2229
- end
2230
-
2231
- class Pry::Ring
2232
- def initialize(max_size); end
2233
-
2234
- def <<(value); end
2235
- def [](index); end
2236
- def clear; end
2237
- def count; end
2238
- def max_size; end
2239
- def size; end
2240
- def to_a; end
2241
-
2242
- private
2243
-
2244
- def transpose_buffer_tail; end
2245
- end
2246
-
2247
- class Pry::Slop
2248
- include ::Enumerable
2249
-
2250
- def initialize(config = T.unsafe(nil), &block); end
2251
-
2252
- def [](key); end
2253
- def add_callback(label, &block); end
2254
- def banner(banner = T.unsafe(nil)); end
2255
- def banner=(banner); end
2256
- def command(command, options = T.unsafe(nil), &block); end
2257
- def config; end
2258
- def description(desc = T.unsafe(nil)); end
2259
- def description=(desc); end
2260
- def each(&block); end
2261
- def fetch_command(command); end
2262
- def fetch_option(key); end
2263
- def get(key); end
2264
- def help; end
2265
- def missing; end
2266
- def on(*objects, &block); end
2267
- def opt(*objects, &block); end
2268
- def option(*objects, &block); end
2269
- def options; end
2270
- def parse(items = T.unsafe(nil), &block); end
2271
- def parse!(items = T.unsafe(nil), &block); end
2272
- def present?(*keys); end
2273
- def run(callable = T.unsafe(nil), &block); end
2274
- def separator(text); end
2275
- def strict?; end
2276
- def to_h(include_commands = T.unsafe(nil)); end
2277
- def to_hash(include_commands = T.unsafe(nil)); end
2278
- def to_s; end
2279
-
2280
- private
2281
-
2282
- def autocreate(items, index); end
2283
- def build_option(objects, &block); end
2284
- def clean(object); end
2285
- def commands_to_help; end
2286
- def execute_multiple_switches(option, argument, index); end
2287
- def execute_option(option, argument, index, item = T.unsafe(nil)); end
2288
- def extract_long_flag(objects, config); end
2289
- def extract_option(flag); end
2290
- def extract_short_flag(objects, config); end
2291
- def method_missing(method, *args, &block); end
2292
- def process_item(items, index, &block); end
2293
- def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
2294
-
2295
- class << self
2296
- def optspec(string, config = T.unsafe(nil)); end
2297
- def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
2298
- def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
2299
- end
2300
- end
2301
-
2302
- class Pry::Slop::Commands
2303
- include ::Enumerable
2304
-
2305
- def initialize(config = T.unsafe(nil), &block); end
2306
-
2307
- def [](key); end
2308
- def arguments; end
2309
- def banner(banner = T.unsafe(nil)); end
2310
- def banner=(_arg0); end
2311
- def commands; end
2312
- def config; end
2313
- def default(config = T.unsafe(nil), &block); end
2314
- def each(&block); end
2315
- def get(key); end
2316
- def global(config = T.unsafe(nil), &block); end
2317
- def help; end
2318
- def inspect; end
2319
- def on(command, config = T.unsafe(nil), &block); end
2320
- def parse(items = T.unsafe(nil)); end
2321
- def parse!(items = T.unsafe(nil)); end
2322
- def present?(key); end
2323
- def to_hash; end
2324
- def to_s; end
2325
-
2326
- private
2327
-
2328
- def execute_arguments!(items); end
2329
- def execute_global_opts!(items); end
2330
- end
2331
-
2332
- Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
2333
- class Pry::Slop::Error < ::StandardError; end
2334
- class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end
2335
- class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end
2336
- class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end
2337
- class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end
2338
- class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end
2339
-
2340
- class Pry::Slop::Option
2341
- def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end
2342
-
2343
- def accepts_optional_argument?; end
2344
- def argument_in_value; end
2345
- def argument_in_value=(_arg0); end
2346
- def call(*objects); end
2347
- def config; end
2348
- def count; end
2349
- def count=(_arg0); end
2350
- def description; end
2351
- def expects_argument?; end
2352
- def help; end
2353
- def inspect; end
2354
- def key; end
2355
- def long; end
2356
- def short; end
2357
- def to_s; end
2358
- def types; end
2359
- def value; end
2360
- def value=(new_value); end
2361
-
2362
- private
2363
-
2364
- def value_to_float(value); end
2365
- def value_to_integer(value); end
2366
- def value_to_range(value); end
2367
- end
2368
-
2369
- Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
2370
- Pry::Slop::VERSION = T.let(T.unsafe(nil), String)
2371
-
2372
- class Pry::SyntaxHighlighter
2373
- class << self
2374
- def highlight(code, language = T.unsafe(nil)); end
2375
- def keyword_token_color; end
2376
- def overwrite_coderay_comment_token!; end
2377
- def tokenize(code, language = T.unsafe(nil)); end
2378
- end
2379
- end
2380
-
2381
- module Pry::SystemCommandHandler
2382
- class << self
2383
- def default(output, command, _pry_instance); end
2384
- end
2385
- end
2386
-
2387
- module Pry::TooSafeException
2388
- class << self
2389
- def ===(exception); end
2390
- end
2391
- end
2392
-
2393
- module Pry::UserError; end
2394
- Pry::VERSION = T.let(T.unsafe(nil), String)
2395
-
2396
- module Pry::Warning
2397
- class << self
2398
- def warn(message); end
2399
- end
2400
- end
2401
-
2402
- class Pry::WrappedModule
2403
- include ::Pry::Helpers::BaseHelpers
2404
- include ::Pry::CodeObject::Helpers
2405
-
2406
- def initialize(mod); end
2407
-
2408
- def candidate(rank); end
2409
- def candidates; end
2410
- def class?; end
2411
- def constants(inherit = T.unsafe(nil)); end
2412
- def doc; end
2413
- def file; end
2414
- def line; end
2415
- def method_missing(method_name, *args, &block); end
2416
- def method_prefix; end
2417
- def module?; end
2418
- def nonblank_name; end
2419
- def number_of_candidates; end
2420
- def singleton_class?; end
2421
- def singleton_instance; end
2422
- def source; end
2423
- def source_file; end
2424
- def source_line; end
2425
- def source_location; end
2426
- def super(times = T.unsafe(nil)); end
2427
- def wrapped; end
2428
- def yard_doc; end
2429
- def yard_docs?; end
2430
- def yard_file; end
2431
- def yard_line; end
2432
-
2433
- private
2434
-
2435
- def all_methods_for(mod); end
2436
- def all_relevant_methods_for(mod); end
2437
- def all_source_locations_by_popularity; end
2438
- def lines_for_file(file); end
2439
- def method_candidates; end
2440
- def method_defined_by_forwardable_module?(method); end
2441
- def nested_module?(parent, name); end
2442
- def primary_candidate; end
2443
- def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
2444
-
2445
- class << self
2446
- def from_str(mod_name, target = T.unsafe(nil)); end
2447
-
2448
- private
2449
-
2450
- def safe_to_evaluate?(str, target); end
2451
- end
2452
- end
2453
-
2454
- class Pry::WrappedModule::Candidate
2455
- include ::Pry::Helpers::DocumentationHelpers
2456
- include ::Pry::CodeObject::Helpers
2457
- extend ::Forwardable
2458
- extend ::Pry::Forwardable
2459
-
2460
- def initialize(wrapper, rank); end
2461
-
2462
- def class?(*args, &block); end
2463
- def doc; end
2464
- def file; end
2465
- def line; end
2466
- def module?(*args, &block); end
2467
- def nonblank_name(*args, &block); end
2468
- def number_of_candidates(*args, &block); end
2469
- def source; end
2470
- def source_file; end
2471
- def source_line; end
2472
- def source_location; end
2473
- def wrapped(*args, &block); end
2474
-
2475
- private
2476
-
2477
- def class_regexes; end
2478
- def first_line_of_module_definition(file, line); end
2479
- def first_method_source_location; end
2480
- def last_method_source_location; end
2481
- def lines_for_file(*a, &b); end
2482
- def method_candidates(*a, &b); end
2483
- def name(*a, &b); end
2484
- def number_of_lines_in_first_chunk; end
2485
- def yard_docs?(*a, &b); end
2486
- end