rspec-sorbet 1.8.0 → 1.8.1

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