clean-architecture 2.0.0 → 3.0.0

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