etwin 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (77) hide show
  1. checksums.yaml +7 -0
  2. data/.gitignore +11 -0
  3. data/.rspec +3 -0
  4. data/.rubocop.yml +11 -0
  5. data/.travis.yml +6 -0
  6. data/Gemfile +9 -0
  7. data/Gemfile.lock +82 -0
  8. data/README.md +30 -0
  9. data/Rakefile +8 -0
  10. data/bin/console +15 -0
  11. data/bin/setup +8 -0
  12. data/etwin.gemspec +37 -0
  13. data/lib/etwin.rb +27 -0
  14. data/lib/etwin/_auth.rb +4 -0
  15. data/lib/etwin/auth.rb +14 -0
  16. data/lib/etwin/auth/_auth_context.rb +30 -0
  17. data/lib/etwin/auth/auth_context.rb +9 -0
  18. data/lib/etwin/auth/auth_scope.rb +25 -0
  19. data/lib/etwin/auth/auth_type.rb +26 -0
  20. data/lib/etwin/auth/guest_auth_context.rb +71 -0
  21. data/lib/etwin/auth/user_auth_context.rb +83 -0
  22. data/lib/etwin/client.rb +11 -0
  23. data/lib/etwin/client/auth.rb +66 -0
  24. data/lib/etwin/client/etwin_client.rb +17 -0
  25. data/lib/etwin/client/http_etwin_client.rb +36 -0
  26. data/lib/etwin/core.rb +10 -0
  27. data/lib/etwin/core/object_type.rb +35 -0
  28. data/lib/etwin/hammerfest.rb +13 -0
  29. data/lib/etwin/hammerfest/hammerfest_server.rb +27 -0
  30. data/lib/etwin/hammerfest/hammerfest_user_id.rb +57 -0
  31. data/lib/etwin/hammerfest/hammerfest_username.rb +57 -0
  32. data/lib/etwin/hammerfest/short_hammerfest_user.rb +103 -0
  33. data/lib/etwin/link.rb +15 -0
  34. data/lib/etwin/link/hammerfest_link.rb +106 -0
  35. data/lib/etwin/link/link_action.rb +93 -0
  36. data/lib/etwin/link/twinoid_link.rb +106 -0
  37. data/lib/etwin/link/versioned_hammerfest_link.rb +93 -0
  38. data/lib/etwin/link/versioned_links.rb +123 -0
  39. data/lib/etwin/link/versioned_twinoid_link.rb +93 -0
  40. data/lib/etwin/twinoid.rb +12 -0
  41. data/lib/etwin/twinoid/short_twinoid_user.rb +93 -0
  42. data/lib/etwin/twinoid/twinoid_user_display_name.rb +57 -0
  43. data/lib/etwin/twinoid/twinoid_user_id.rb +57 -0
  44. data/lib/etwin/user.rb +15 -0
  45. data/lib/etwin/user/short_user.rb +93 -0
  46. data/lib/etwin/user/user.rb +123 -0
  47. data/lib/etwin/user/user_display_name.rb +57 -0
  48. data/lib/etwin/user/user_display_name_version.rb +83 -0
  49. data/lib/etwin/user/user_display_name_versions.rb +83 -0
  50. data/lib/etwin/user/user_id.rb +57 -0
  51. data/lib/etwin/version.rb +6 -0
  52. data/sorbet/config +2 -0
  53. data/sorbet/rbi/gems/ast.rbi +48 -0
  54. data/sorbet/rbi/gems/debase.rbi +67 -0
  55. data/sorbet/rbi/gems/irb.rbi +352 -0
  56. data/sorbet/rbi/gems/parallel.rbi +83 -0
  57. data/sorbet/rbi/gems/parser.rbi +1405 -0
  58. data/sorbet/rbi/gems/rainbow.rbi +118 -0
  59. data/sorbet/rbi/gems/rake.rbi +644 -0
  60. data/sorbet/rbi/gems/regexp_parser.rbi +914 -0
  61. data/sorbet/rbi/gems/reline.rbi +556 -0
  62. data/sorbet/rbi/gems/rexml.rbi +605 -0
  63. data/sorbet/rbi/gems/rspec-core.rbi +1920 -0
  64. data/sorbet/rbi/gems/rspec-expectations.rbi +1148 -0
  65. data/sorbet/rbi/gems/rspec-mocks.rbi +1090 -0
  66. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  67. data/sorbet/rbi/gems/rspec.rbi +15 -0
  68. data/sorbet/rbi/gems/rubocop-ast.rbi +1338 -0
  69. data/sorbet/rbi/gems/rubocop.rbi +7491 -0
  70. data/sorbet/rbi/gems/ruby-debug-ide.rbi +608 -0
  71. data/sorbet/rbi/gems/ruby-progressbar.rbi +305 -0
  72. data/sorbet/rbi/gems/unicode-display_width.rbi +17 -0
  73. data/sorbet/rbi/hidden-definitions/errors.txt +4905 -0
  74. data/sorbet/rbi/hidden-definitions/hidden.rbi +9193 -0
  75. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
  76. data/sorbet/rbi/todo.rbi +7 -0
  77. metadata +220 -0
@@ -0,0 +1,280 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-support/all/rspec-support.rbi
9
+ #
10
+ # rspec-support-3.10.0
11
+
12
+ module RSpec
13
+ extend RSpec::Support::Warnings
14
+ end
15
+ module RSpec::Support
16
+ def self.class_of(object); end
17
+ def self.define_optimized_require_for_rspec(lib, &require_relative); end
18
+ def self.deregister_matcher_definition(&block); end
19
+ def self.failure_notifier; end
20
+ def self.failure_notifier=(callable); end
21
+ def self.is_a_matcher?(object); end
22
+ def self.matcher_definitions; end
23
+ def self.method_handle_for(object, method_name); end
24
+ def self.notify_failure(failure, options = nil); end
25
+ def self.register_matcher_definition(&block); end
26
+ def self.require_rspec_support(f); end
27
+ def self.rspec_description_for_object(object); end
28
+ def self.thread_local_data; end
29
+ def self.warning_notifier; end
30
+ def self.warning_notifier=(arg0); end
31
+ def self.with_failure_notifier(callable); end
32
+ end
33
+ module RSpec::Support::Version
34
+ end
35
+ class RSpec::Support::ComparableVersion
36
+ def <=>(other); end
37
+ def initialize(string); end
38
+ def segments; end
39
+ def string; end
40
+ include Comparable
41
+ end
42
+ module RSpec::Support::OS
43
+ def self.windows?; end
44
+ def self.windows_file_path?; end
45
+ def windows?; end
46
+ def windows_file_path?; end
47
+ end
48
+ module RSpec::Support::Ruby
49
+ def jruby?; end
50
+ def jruby_9000?; end
51
+ def jruby_version; end
52
+ def mri?; end
53
+ def non_mri?; end
54
+ def rbx?; end
55
+ def self.jruby?; end
56
+ def self.jruby_9000?; end
57
+ def self.jruby_version; end
58
+ def self.mri?; end
59
+ def self.non_mri?; end
60
+ def self.rbx?; end
61
+ def self.truffleruby?; end
62
+ def truffleruby?; end
63
+ end
64
+ module RSpec::Support::RubyFeatures
65
+ def caller_locations_supported?; end
66
+ def fork_supported?; end
67
+ def kw_args_supported?; end
68
+ def module_prepends_supported?; end
69
+ def module_refinement_supported?; end
70
+ def optional_and_splat_args_supported?; end
71
+ def required_kw_args_supported?; end
72
+ def ripper_supported?; end
73
+ def self.caller_locations_supported?; end
74
+ def self.fork_supported?; end
75
+ def self.kw_args_supported?; end
76
+ def self.module_prepends_supported?; end
77
+ def self.module_refinement_supported?; end
78
+ def self.optional_and_splat_args_supported?; end
79
+ def self.required_kw_args_supported?; end
80
+ def self.ripper_supported?; end
81
+ def self.supports_exception_cause?; end
82
+ def self.supports_rebinding_module_methods?; end
83
+ def self.supports_taint?; end
84
+ def supports_exception_cause?; end
85
+ def supports_rebinding_module_methods?; end
86
+ def supports_taint?; end
87
+ end
88
+ module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
89
+ def self.===(exception); end
90
+ end
91
+ class RSpec::CallerFilter
92
+ def self.first_non_rspec_line(skip_frames = nil, increment = nil); end
93
+ end
94
+ module RSpec::Support::Warnings
95
+ def deprecate(deprecated, options = nil); end
96
+ def warn_deprecation(message, options = nil); end
97
+ def warn_with(message, options = nil); end
98
+ def warning(text, options = nil); end
99
+ end
100
+ class RSpec::Support::EncodedString
101
+ def <<(string); end
102
+ def ==(*args, &block); end
103
+ def detect_source_encoding(string); end
104
+ def empty?(*args, &block); end
105
+ def encoding(*args, &block); end
106
+ def eql?(*args, &block); end
107
+ def initialize(string, encoding = nil); end
108
+ def lines(*args, &block); end
109
+ def matching_encoding(string); end
110
+ def remove_invalid_bytes(string); end
111
+ def self.pick_encoding(source_a, source_b); end
112
+ def source_encoding; end
113
+ def split(regex_or_string); end
114
+ def to_s; end
115
+ def to_str; end
116
+ end
117
+ class RSpec::Support::ReentrantMutex
118
+ def enter; end
119
+ def exit; end
120
+ def initialize; end
121
+ def synchronize; end
122
+ end
123
+ class RSpec::Support::Mutex < Thread::Mutex
124
+ def self.new; end
125
+ end
126
+ class RSpec::Support::DirectoryMaker
127
+ def self.directory_exists?(dirname); end
128
+ def self.generate_path(stack, part); end
129
+ def self.generate_stack(path); end
130
+ def self.mkdir_p(path); end
131
+ end
132
+ class RSpec::Support::MethodSignature
133
+ def arbitrary_kw_args?; end
134
+ def classify_arity(arity = nil); end
135
+ def classify_parameters; end
136
+ def could_contain_kw_args?(args); end
137
+ def description; end
138
+ def has_kw_args_in?(args); end
139
+ def initialize(method); end
140
+ def invalid_kw_args_from(given_kw_args); end
141
+ def max_non_kw_args; end
142
+ def min_non_kw_args; end
143
+ def missing_kw_args_from(given_kw_args); end
144
+ def non_kw_args_arity_description; end
145
+ def optional_kw_args; end
146
+ def required_kw_args; end
147
+ def unlimited_args?; end
148
+ def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = nil); end
149
+ end
150
+ class RSpec::Support::MethodSignatureExpectation
151
+ def empty?; end
152
+ def expect_arbitrary_keywords; end
153
+ def expect_arbitrary_keywords=(arg0); end
154
+ def expect_unlimited_arguments; end
155
+ def expect_unlimited_arguments=(arg0); end
156
+ def initialize; end
157
+ def keywords; end
158
+ def keywords=(values); end
159
+ def max_count; end
160
+ def max_count=(number); end
161
+ def min_count; end
162
+ def min_count=(number); end
163
+ end
164
+ class RSpec::Support::BlockSignature < RSpec::Support::MethodSignature
165
+ def classify_parameters; end
166
+ end
167
+ class RSpec::Support::MethodSignatureVerifier
168
+ def arbitrary_kw_args?; end
169
+ def error_message; end
170
+ def initialize(signature, args = nil); end
171
+ def invalid_kw_args; end
172
+ def kw_args; end
173
+ def max_non_kw_args; end
174
+ def min_non_kw_args; end
175
+ def missing_kw_args; end
176
+ def non_kw_args; end
177
+ def split_args(*args); end
178
+ def unlimited_args?; end
179
+ def valid?; end
180
+ def valid_non_kw_args?; end
181
+ def with_expectation(expectation); end
182
+ end
183
+ class RSpec::Support::LooseSignatureVerifier < RSpec::Support::MethodSignatureVerifier
184
+ def split_args(*args); end
185
+ end
186
+ class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
187
+ def has_kw_args_in?(args); end
188
+ def initialize(signature); end
189
+ def invalid_kw_args_from(_kw_args); end
190
+ def missing_kw_args_from(_kw_args); end
191
+ def non_kw_args_arity_description; end
192
+ def valid_non_kw_args?(*args); end
193
+ end
194
+ module RSpec::Support::WithKeywordsWhenNeeded
195
+ def class_exec(klass, *args, &block); end
196
+ def self.class_exec(klass, *args, &block); end
197
+ end
198
+ module RSpec::Support::RecursiveConstMethods
199
+ def const_defined_on?(mod, const_name); end
200
+ def constants_defined_on(mod); end
201
+ def get_const_defined_on(mod, const_name); end
202
+ def normalize_const_name(const_name); end
203
+ def recursive_const_defined?(const_name); end
204
+ def recursive_const_get(const_name); end
205
+ end
206
+ class RSpec::Support::ObjectFormatter
207
+ def format(object); end
208
+ def initialize(max_formatted_output_length = nil); end
209
+ def max_formatted_output_length; end
210
+ def max_formatted_output_length=(arg0); end
211
+ def prepare_array(array); end
212
+ def prepare_element(element); end
213
+ def prepare_for_inspection(object); end
214
+ def prepare_hash(input_hash); end
215
+ def recursive_structure?(object); end
216
+ def self.default_instance; end
217
+ def self.format(object); end
218
+ def self.prepare_for_inspection(object); end
219
+ def sort_hash_keys(input_hash); end
220
+ def truncate_string(str, start_index, end_index); end
221
+ def with_entering_structure(structure); end
222
+ end
223
+ class RSpec::Support::ObjectFormatter::InspectableItem < Struct
224
+ def inspect; end
225
+ def pretty_print(pp); end
226
+ def self.[](*arg0); end
227
+ def self.inspect; end
228
+ def self.members; end
229
+ def self.new(*arg0); end
230
+ def text; end
231
+ def text=(_); end
232
+ end
233
+ class RSpec::Support::ObjectFormatter::BaseInspector < Struct
234
+ def formatter; end
235
+ def formatter=(_); end
236
+ def inspect; end
237
+ def object; end
238
+ def object=(_); end
239
+ def pretty_print(pp); end
240
+ def self.[](*arg0); end
241
+ def self.can_inspect?(_object); end
242
+ def self.inspect; end
243
+ def self.members; end
244
+ def self.new(*arg0); end
245
+ end
246
+ class RSpec::Support::ObjectFormatter::TimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
247
+ def inspect; end
248
+ def self.can_inspect?(object); end
249
+ end
250
+ class RSpec::Support::ObjectFormatter::DateTimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
251
+ def inspect; end
252
+ def self.can_inspect?(object); end
253
+ end
254
+ class RSpec::Support::ObjectFormatter::BigDecimalInspector < RSpec::Support::ObjectFormatter::BaseInspector
255
+ def inspect; end
256
+ def self.can_inspect?(object); end
257
+ end
258
+ class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < RSpec::Support::ObjectFormatter::BaseInspector
259
+ def inspect; end
260
+ def self.can_inspect?(object); end
261
+ end
262
+ class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
263
+ def inspect; end
264
+ def klass; end
265
+ def native_object_id; end
266
+ def self.can_inspect?(object); end
267
+ end
268
+ class RSpec::Support::ObjectFormatter::DelegatorInspector < RSpec::Support::ObjectFormatter::BaseInspector
269
+ def inspect; end
270
+ def self.can_inspect?(object); end
271
+ end
272
+ class RSpec::Support::ObjectFormatter::InspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
273
+ def inspect; end
274
+ def self.can_inspect?(object); end
275
+ end
276
+ module RSpec::Support::FuzzyMatcher
277
+ def self.arrays_match?(expected_list, actual_list); end
278
+ def self.hashes_match?(expected_hash, actual_hash); end
279
+ def self.values_match?(expected, actual); end
280
+ end
@@ -0,0 +1,15 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strict
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi
9
+ #
10
+ # rspec-3.10.0
11
+
12
+ module RSpec
13
+ end
14
+ module RSpec::Version
15
+ end
@@ -0,0 +1,1338 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strict
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/rubocop-ast/all/rubocop-ast.rbi
9
+ #
10
+ # rubocop-ast-1.1.1
11
+
12
+ module RuboCop
13
+ end
14
+ module RuboCop::AST
15
+ extend RuboCop::AST::RuboCopCompatibility
16
+ end
17
+ module RuboCop::AST::Ext
18
+ end
19
+ module RuboCop::AST::Ext::Range
20
+ def line_span(exclude_end: nil); end
21
+ end
22
+ class Parser::Source::Range
23
+ include RuboCop::AST::Ext::Range
24
+ end
25
+ class RuboCop::AST::NodePattern
26
+ def ==(other); end
27
+ def as_json(_options = nil); end
28
+ def ast; end
29
+ def captures(*args, &block); end
30
+ def encode_with(coder); end
31
+ def eql?(other); end
32
+ def freeze; end
33
+ def init_with(coder); end
34
+ def initialize(str, compiler: nil); end
35
+ def marshal_dump; end
36
+ def marshal_load(pattern); end
37
+ def match(*args, **rest, &block); end
38
+ def match_code; end
39
+ def named_parameters(*args, &block); end
40
+ def pattern; end
41
+ def positional_parameters(*args, &block); end
42
+ def self.descend(element, &block); end
43
+ def to_s; end
44
+ extend Forwardable
45
+ include RuboCop::AST::NodePattern::MethodDefiner
46
+ end
47
+ module RuboCop::AST::NodePattern::MethodDefiner
48
+ def as_lambda; end
49
+ def compile_as_lambda; end
50
+ def compile_init; end
51
+ def def_helper(base, method_name, **defaults); end
52
+ def def_node_matcher(base, method_name, **defaults); end
53
+ def def_node_search(base, method_name, **defaults); end
54
+ def emit_keyword_list(forwarding: nil); end
55
+ def emit_lambda_code; end
56
+ def emit_method_code; end
57
+ def emit_node_search(method_name); end
58
+ def emit_node_search_body(method_name, prelude:, on_match:); end
59
+ def emit_param_list; end
60
+ def emit_params(*first, forwarding: nil); end
61
+ def emit_retval; end
62
+ def emit_yield_capture(when_no_capture = nil, yield_with: nil); end
63
+ def wrapping_block(method_name, **defaults); end
64
+ end
65
+ module RuboCop::AST::NodePattern::Macros
66
+ def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
67
+ def def_node_search(method_name, pattern_str, **keyword_defaults); end
68
+ end
69
+ class RuboCop::AST::NodePattern::Invalid < StandardError
70
+ end
71
+ module RuboCop::AST::Descendence
72
+ def child_nodes; end
73
+ def descendants; end
74
+ def each_child_node(*types); end
75
+ def each_descendant(*types, &block); end
76
+ def each_node(*types, &block); end
77
+ def visit_descendants(types, &block); end
78
+ end
79
+ class RuboCop::AST::NodePattern::Builder
80
+ def emit_atom(type, value); end
81
+ def emit_call(type, selector, args = nil); end
82
+ def emit_capture(capture_token, node); end
83
+ def emit_list(type, _begin, children, _end); end
84
+ def emit_subsequence(node_list); end
85
+ def emit_unary_op(type, _operator = nil, *children); end
86
+ def emit_union(begin_t, pattern_lists, end_t); end
87
+ def n(type, *args); end
88
+ def optimizable_as_set?(children); end
89
+ def union_children(pattern_lists); end
90
+ end
91
+ class RuboCop::AST::NodePattern::Comment
92
+ def ==(other); end
93
+ def initialize(range); end
94
+ def inspect; end
95
+ def loc; end
96
+ def location; end
97
+ def text; end
98
+ end
99
+ class RuboCop::AST::NodePattern::Compiler
100
+ def bind(*args, &block); end
101
+ def binding; end
102
+ def captures; end
103
+ def compile_as_atom(node); end
104
+ def compile_as_node_pattern(node, **options); end
105
+ def compile_sequence(sequence, var:); end
106
+ def each_union(enum, &block); end
107
+ def enforce_same_captures(enum); end
108
+ def freeze; end
109
+ def initialize; end
110
+ def named_parameter(name); end
111
+ def named_parameters; end
112
+ def new_capture; end
113
+ def next_capture; end
114
+ def parser; end
115
+ def positional_parameter(number); end
116
+ def positional_parameters; end
117
+ def with_temp_variables(*names, &block); end
118
+ extend Forwardable
119
+ end
120
+ class RuboCop::AST::NodePattern::Compiler::Subcompiler
121
+ def compile(node); end
122
+ def compiler; end
123
+ def do_compile; end
124
+ def initialize(compiler); end
125
+ def node; end
126
+ def self.inherited(base); end
127
+ def self.method_added(method); end
128
+ def self.registry; end
129
+ end
130
+ class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler
131
+ def visit_const; end
132
+ def visit_named_parameter; end
133
+ def visit_number; end
134
+ def visit_other_type; end
135
+ def visit_positional_parameter; end
136
+ def visit_regexp; end
137
+ def visit_set; end
138
+ def visit_string; end
139
+ def visit_symbol; end
140
+ def visit_unify; end
141
+ end
142
+ class RuboCop::AST::NodePattern::Compiler::Binding
143
+ def bind(name); end
144
+ def forbid(names); end
145
+ def initialize; end
146
+ def union_bind(enum); end
147
+ end
148
+ class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler
149
+ def access; end
150
+ def access_element; end
151
+ def access_node; end
152
+ def compile_args(arg_list, first: nil); end
153
+ def compile_guard_clause; end
154
+ def compile_value_match(value); end
155
+ def initialize(compiler, var: nil, access: nil, seq_head: nil); end
156
+ def multiple_access(kind); end
157
+ def seq_head; end
158
+ def visit_ascend; end
159
+ def visit_capture; end
160
+ def visit_descend; end
161
+ def visit_function_call; end
162
+ def visit_intersection; end
163
+ def visit_negation; end
164
+ def visit_node_type; end
165
+ def visit_other_type; end
166
+ def visit_predicate; end
167
+ def visit_sequence; end
168
+ def visit_unify; end
169
+ def visit_union; end
170
+ def visit_wildcard; end
171
+ end
172
+ class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler
173
+ def compile(node); end
174
+ def compile_and_advance(term); end
175
+ def compile_any_order_branches(matched_var); end
176
+ def compile_any_order_else; end
177
+ def compile_captured_repetition(child_code, child_captures); end
178
+ def compile_case(when_branches, else_code); end
179
+ def compile_child_nb_guard(arity_range); end
180
+ def compile_cur_index; end
181
+ def compile_index(cur = nil); end
182
+ def compile_loop(term); end
183
+ def compile_loop_advance(to = nil); end
184
+ def compile_matched(kind); end
185
+ def compile_max_matched; end
186
+ def compile_min_check; end
187
+ def compile_remaining; end
188
+ def compile_sequence; end
189
+ def compile_terms(children = nil, last_arity = nil); end
190
+ def compile_union_forks; end
191
+ def cur_index; end
192
+ def empty_loop; end
193
+ def handle_prev; end
194
+ def in_sync; end
195
+ def initialize(compiler, sequence:, var:); end
196
+ def merge_forks!(forks); end
197
+ def preserve_union_start(forks); end
198
+ def remaining_arities(children, last_arity); end
199
+ def sync; end
200
+ def use_index_from_end; end
201
+ def visit_any_order; end
202
+ def visit_capture; end
203
+ def visit_other_type; end
204
+ def visit_repetition; end
205
+ def visit_rest; end
206
+ def visit_union; end
207
+ def within_loop; end
208
+ end
209
+ class RuboCop::AST::NodePattern::LexerRex
210
+ def action; end
211
+ def filename; end
212
+ def filename=(arg0); end
213
+ def location; end
214
+ def match; end
215
+ def matches; end
216
+ def next_token; end
217
+ def parse(str); end
218
+ def parse_file(path); end
219
+ def scanner_class; end
220
+ def ss; end
221
+ def ss=(arg0); end
222
+ def state; end
223
+ def state=(arg0); end
224
+ end
225
+ class RuboCop::AST::NodePattern::LexerRex::LexerError < StandardError
226
+ end
227
+ class RuboCop::AST::NodePattern::LexerRex::ScanError < RuboCop::AST::NodePattern::LexerRex::LexerError
228
+ end
229
+ class RuboCop::AST::NodePattern::Lexer < RuboCop::AST::NodePattern::LexerRex
230
+ def comments; end
231
+ def do_parse; end
232
+ def emit(type); end
233
+ def emit_comment; end
234
+ def emit_regexp; end
235
+ def initialize(source); end
236
+ def source_buffer; end
237
+ def token(type, value); end
238
+ def tokens; end
239
+ end
240
+ class RuboCop::AST::NodePattern::Node < Parser::AST::Node
241
+ def arity; end
242
+ def arity_range; end
243
+ def capture?; end
244
+ def child; end
245
+ def children_nodes; end
246
+ def in_sequence_head; end
247
+ def matches_within_set?; end
248
+ def nb_captures; end
249
+ def rest?; end
250
+ def variadic?; end
251
+ def with(type: nil, children: nil, location: nil); end
252
+ extend Forwardable
253
+ include RuboCop::AST::Descendence
254
+ end
255
+ module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
256
+ def in_sequence_head; end
257
+ end
258
+ class RuboCop::AST::NodePattern::Node::Capture < RuboCop::AST::NodePattern::Node
259
+ def arity(*args, &block); end
260
+ def capture?; end
261
+ def in_sequence_head; end
262
+ def nb_captures; end
263
+ def rest?(*args, &block); end
264
+ end
265
+ class RuboCop::AST::NodePattern::Node::Sequence < RuboCop::AST::NodePattern::Node
266
+ def initialize(type, children = nil, properties = nil); end
267
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
268
+ end
269
+ class RuboCop::AST::NodePattern::Node::Predicate < RuboCop::AST::NodePattern::Node
270
+ def arg_list; end
271
+ def method_name; end
272
+ end
273
+ class RuboCop::AST::NodePattern::Node::Repetition < RuboCop::AST::NodePattern::Node
274
+ def arity; end
275
+ def operator; end
276
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
277
+ end
278
+ class RuboCop::AST::NodePattern::Node::Rest < RuboCop::AST::NodePattern::Node
279
+ def arity; end
280
+ def in_sequence_head; end
281
+ def rest?; end
282
+ end
283
+ class RuboCop::AST::NodePattern::Node::AnyOrder < RuboCop::AST::NodePattern::Node
284
+ def arity; end
285
+ def ends_with_rest?; end
286
+ def rest_node; end
287
+ def term_nodes; end
288
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
289
+ end
290
+ module RuboCop::AST::NodePattern::Node::MapMinMax
291
+ def map_min_max(enum); end
292
+ end
293
+ class RuboCop::AST::NodePattern::Node::Subsequence < RuboCop::AST::NodePattern::Node
294
+ def arity; end
295
+ def in_sequence_head; end
296
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
297
+ include RuboCop::AST::NodePattern::Node::MapMinMax
298
+ end
299
+ class RuboCop::AST::NodePattern::Node::Union < RuboCop::AST::NodePattern::Node
300
+ def arity; end
301
+ def in_sequence_head; end
302
+ include RuboCop::AST::NodePattern::Node::MapMinMax
303
+ end
304
+ class RuboCop::AST::NodePattern::Parser < Racc::Parser
305
+ def _reduce_10(val, _values); end
306
+ def _reduce_11(val, _values); end
307
+ def _reduce_13(val, _values); end
308
+ def _reduce_14(val, _values); end
309
+ def _reduce_15(val, _values); end
310
+ def _reduce_16(val, _values); end
311
+ def _reduce_17(val, _values); end
312
+ def _reduce_18(val, _values); end
313
+ def _reduce_19(val, _values); end
314
+ def _reduce_2(val, _values); end
315
+ def _reduce_20(val, _values); end
316
+ def _reduce_21(val, _values); end
317
+ def _reduce_22(val, _values); end
318
+ def _reduce_25(val, _values); end
319
+ def _reduce_26(val, _values); end
320
+ def _reduce_3(val, _values); end
321
+ def _reduce_33(val, _values); end
322
+ def _reduce_37(val, _values); end
323
+ def _reduce_38(val, _values); end
324
+ def _reduce_39(val, _values); end
325
+ def _reduce_4(val, _values); end
326
+ def _reduce_40(val, _values); end
327
+ def _reduce_41(val, _values); end
328
+ def _reduce_42(val, _values); end
329
+ def _reduce_43(val, _values); end
330
+ def _reduce_44(val, _values); end
331
+ def _reduce_45(val, _values); end
332
+ def _reduce_46(val, _values); end
333
+ def _reduce_5(val, _values); end
334
+ def _reduce_6(val, _values); end
335
+ def _reduce_7(val, _values); end
336
+ def _reduce_8(val, _values); end
337
+ def _reduce_9(val, _values); end
338
+ def _reduce_none(val, _values); end
339
+ def emit_atom(*args, &block); end
340
+ def emit_call(*args, &block); end
341
+ def emit_capture(*args, &block); end
342
+ def emit_list(*args, &block); end
343
+ def emit_unary_op(*args, &block); end
344
+ def emit_union(*args, &block); end
345
+ def enforce_unary(node); end
346
+ def initialize(builder = nil); end
347
+ def inspect; end
348
+ def next_token(*args, &block); end
349
+ def on_error(token, val, _vstack); end
350
+ def parse(source); end
351
+ extend Forwardable
352
+ end
353
+ module RuboCop::AST::NodePattern::Sets
354
+ def self.[](set); end
355
+ def self.name(set); end
356
+ def self.uniq(name); end
357
+ end
358
+ module RuboCop::AST::Sexp
359
+ def s(type, *children); end
360
+ end
361
+ class RuboCop::AST::Node < Parser::AST::Node
362
+ def __ENCODING___type?; end
363
+ def __FILE___type?; end
364
+ def __LINE___type?; end
365
+ def alias_type?; end
366
+ def ancestors; end
367
+ def and_asgn_type?; end
368
+ def and_type?; end
369
+ def arg_expr_type?; end
370
+ def arg_type?; end
371
+ def args_type?; end
372
+ def argument?; end
373
+ def argument_type?; end
374
+ def array_pattern_type?; end
375
+ def array_pattern_with_tail_type?; end
376
+ def array_type?; end
377
+ def assignment?; end
378
+ def assignment_or_similar?(param0 = nil); end
379
+ def back_ref_type?; end
380
+ def basic_conditional?; end
381
+ def basic_literal?; end
382
+ def begin_type?; end
383
+ def begin_value_used?; end
384
+ def block_pass_type?; end
385
+ def block_type?; end
386
+ def blockarg_expr_type?; end
387
+ def blockarg_type?; end
388
+ def boolean_type?; end
389
+ def break_type?; end
390
+ def call_type?; end
391
+ def case_if_value_used?; end
392
+ def case_match_type?; end
393
+ def case_type?; end
394
+ def casgn_type?; end
395
+ def cbase_type?; end
396
+ def chained?; end
397
+ def class_constructor?(param0 = nil); end
398
+ def class_definition?(param0 = nil); end
399
+ def class_type?; end
400
+ def complete!; end
401
+ def complete?; end
402
+ def complex_type?; end
403
+ def conditional?; end
404
+ def const_name; end
405
+ def const_pattern_type?; end
406
+ def const_type?; end
407
+ def csend_type?; end
408
+ def cvar_type?; end
409
+ def cvasgn_type?; end
410
+ def def_type?; end
411
+ def defined_module0(param0 = nil); end
412
+ def defined_module; end
413
+ def defined_module_name; end
414
+ def defined_type?; end
415
+ def defs_type?; end
416
+ def dstr_type?; end
417
+ def dsym_type?; end
418
+ def each_ancestor(*types, &block); end
419
+ def eflipflop_type?; end
420
+ def empty_else_type?; end
421
+ def empty_source?; end
422
+ def ensure_type?; end
423
+ def equals_asgn?; end
424
+ def erange_type?; end
425
+ def false_type?; end
426
+ def falsey_literal?; end
427
+ def find_pattern_type?; end
428
+ def first_line; end
429
+ def float_type?; end
430
+ def for_type?; end
431
+ def for_value_used?; end
432
+ def forward_arg_type?; end
433
+ def forward_args_type?; end
434
+ def forwarded_args_type?; end
435
+ def global_const?(param0 = nil, param1); end
436
+ def guard_clause?; end
437
+ def gvar_type?; end
438
+ def gvasgn_type?; end
439
+ def hash_pattern_type?; end
440
+ def hash_type?; end
441
+ def ident_type?; end
442
+ def if_guard_type?; end
443
+ def if_type?; end
444
+ def iflipflop_type?; end
445
+ def immutable_literal?; end
446
+ def in_match_type?; end
447
+ def in_pattern_type?; end
448
+ def index_type?; end
449
+ def indexasgn_type?; end
450
+ def initialize(type, children = nil, properties = nil); end
451
+ def int_type?; end
452
+ def irange_type?; end
453
+ def ivar_type?; end
454
+ def ivasgn_type?; end
455
+ def keyword?; end
456
+ def kwarg_type?; end
457
+ def kwbegin_type?; end
458
+ def kwnilarg_type?; end
459
+ def kwoptarg_type?; end
460
+ def kwrestarg_type?; end
461
+ def kwsplat_type?; end
462
+ def lambda?(param0 = nil); end
463
+ def lambda_or_proc?(param0 = nil); end
464
+ def lambda_type?; end
465
+ def last_line; end
466
+ def left_sibling; end
467
+ def left_siblings; end
468
+ def line_count; end
469
+ def literal?; end
470
+ def loop_keyword?; end
471
+ def lvar_type?; end
472
+ def lvasgn_type?; end
473
+ def masgn_type?; end
474
+ def match_alt_type?; end
475
+ def match_as_type?; end
476
+ def match_current_line_type?; end
477
+ def match_guard_clause?(param0 = nil); end
478
+ def match_nil_pattern_type?; end
479
+ def match_rest_type?; end
480
+ def match_var_type?; end
481
+ def match_with_lvasgn_type?; end
482
+ def match_with_trailing_comma_type?; end
483
+ def mlhs_type?; end
484
+ def module_definition?(param0 = nil); end
485
+ def module_type?; end
486
+ def multiline?; end
487
+ def mutable_literal?; end
488
+ def new_class_or_module_block?(param0 = nil); end
489
+ def next_type?; end
490
+ def nil_type?; end
491
+ def node_parts; end
492
+ def nonempty_line_count; end
493
+ def not_type?; end
494
+ def nth_ref_type?; end
495
+ def numargs_type?; end
496
+ def numblock_type?; end
497
+ def numeric_type?; end
498
+ def objc_kwarg_type?; end
499
+ def objc_restarg_type?; end
500
+ def objc_varargs_type?; end
501
+ def op_asgn_type?; end
502
+ def operator_keyword?; end
503
+ def optarg_type?; end
504
+ def or_asgn_type?; end
505
+ def or_type?; end
506
+ def pair_type?; end
507
+ def parent; end
508
+ def parent=(node); end
509
+ def parent?; end
510
+ def parent_module_name; end
511
+ def parent_module_name_for_block(ancestor); end
512
+ def parent_module_name_for_sclass(sclass_node); end
513
+ def parent_module_name_part(node); end
514
+ def parenthesized_call?; end
515
+ def pin_type?; end
516
+ def post_condition_loop?; end
517
+ def postexe_type?; end
518
+ def preexe_type?; end
519
+ def proc?(param0 = nil); end
520
+ def procarg0_type?; end
521
+ def pure?; end
522
+ def range_type?; end
523
+ def rational_type?; end
524
+ def receiver(param0 = nil); end
525
+ def recursive_basic_literal?; end
526
+ def recursive_literal?; end
527
+ def redo_type?; end
528
+ def reference?; end
529
+ def regexp_type?; end
530
+ def regopt_type?; end
531
+ def resbody_type?; end
532
+ def rescue_type?; end
533
+ def restarg_expr_type?; end
534
+ def restarg_type?; end
535
+ def retry_type?; end
536
+ def return_type?; end
537
+ def right_sibling; end
538
+ def right_siblings; end
539
+ def root?; end
540
+ def sclass_type?; end
541
+ def self_type?; end
542
+ def send_type?; end
543
+ def shadowarg_type?; end
544
+ def shorthand_asgn?; end
545
+ def sibling_index; end
546
+ def single_line?; end
547
+ def source; end
548
+ def source_length; end
549
+ def source_range; end
550
+ def special_keyword?; end
551
+ def splat_type?; end
552
+ def str_content(param0 = nil); end
553
+ def str_type?; end
554
+ def struct_constructor?(param0 = nil); end
555
+ def super_type?; end
556
+ def sym_type?; end
557
+ def true_type?; end
558
+ def truthy_literal?; end
559
+ def undef_type?; end
560
+ def unless_guard_type?; end
561
+ def until_post_type?; end
562
+ def until_type?; end
563
+ def updated(type = nil, children = nil, properties = nil); end
564
+ def value_used?; end
565
+ def variable?; end
566
+ def visit_ancestors(types); end
567
+ def when_type?; end
568
+ def while_post_type?; end
569
+ def while_type?; end
570
+ def while_until_value_used?; end
571
+ def xstr_type?; end
572
+ def yield_type?; end
573
+ def zsuper_type?; end
574
+ extend RuboCop::AST::NodePattern::Macros
575
+ include RuboCop::AST::Descendence
576
+ include RuboCop::AST::Sexp
577
+ end
578
+ module RuboCop::AST::MethodIdentifierPredicates
579
+ def assignment_method?; end
580
+ def bang_method?; end
581
+ def camel_case_method?; end
582
+ def comparison_method?; end
583
+ def const_receiver?; end
584
+ def enumerable_method?; end
585
+ def enumerator_method?; end
586
+ def method?(name); end
587
+ def negation_method?; end
588
+ def nonmutating_array_method?; end
589
+ def nonmutating_binary_operator_method?; end
590
+ def nonmutating_hash_method?; end
591
+ def nonmutating_operator_method?; end
592
+ def nonmutating_string_method?; end
593
+ def nonmutating_unary_operator_method?; end
594
+ def operator_method?; end
595
+ def predicate_method?; end
596
+ def prefix_bang?; end
597
+ def prefix_not?; end
598
+ def self_receiver?; end
599
+ end
600
+ module RuboCop::AST::BinaryOperatorNode
601
+ def conditions; end
602
+ def lhs; end
603
+ def rhs; end
604
+ end
605
+ module RuboCop::AST::CollectionNode
606
+ def &(*args, &block); end
607
+ def *(*args, &block); end
608
+ def +(*args, &block); end
609
+ def -(*args, &block); end
610
+ def <<(*args, &block); end
611
+ def [](*args, &block); end
612
+ def []=(*args, &block); end
613
+ def all?(*args, &block); end
614
+ def any?(*args, &block); end
615
+ def append(*args, &block); end
616
+ def assoc(*args, &block); end
617
+ def at(*args, &block); end
618
+ def bsearch(*args, &block); end
619
+ def bsearch_index(*args, &block); end
620
+ def chain(*args, &block); end
621
+ def chunk(*args, &block); end
622
+ def chunk_while(*args, &block); end
623
+ def clear(*args, &block); end
624
+ def collect!(*args, &block); end
625
+ def collect(*args, &block); end
626
+ def collect_concat(*args, &block); end
627
+ def combination(*args, &block); end
628
+ def compact!(*args, &block); end
629
+ def compact(*args, &block); end
630
+ def concat(*args, &block); end
631
+ def count(*args, &block); end
632
+ def cycle(*args, &block); end
633
+ def deconstruct(*args, &block); end
634
+ def delete(*args, &block); end
635
+ def delete_at(*args, &block); end
636
+ def delete_if(*args, &block); end
637
+ def detect(*args, &block); end
638
+ def difference(*args, &block); end
639
+ def dig(*args, &block); end
640
+ def drop(*args, &block); end
641
+ def drop_while(*args, &block); end
642
+ def each(*args, &block); end
643
+ def each_cons(*args, &block); end
644
+ def each_entry(*args, &block); end
645
+ def each_index(*args, &block); end
646
+ def each_slice(*args, &block); end
647
+ def each_with_index(*args, &block); end
648
+ def each_with_object(*args, &block); end
649
+ def empty?(*args, &block); end
650
+ def entries(*args, &block); end
651
+ def fetch(*args, &block); end
652
+ def fill(*args, &block); end
653
+ def filter!(*args, &block); end
654
+ def filter(*args, &block); end
655
+ def filter_map(*args, &block); end
656
+ def find(*args, &block); end
657
+ def find_all(*args, &block); end
658
+ def find_index(*args, &block); end
659
+ def first(*args, &block); end
660
+ def flat_map(*args, &block); end
661
+ def flatten!(*args, &block); end
662
+ def flatten(*args, &block); end
663
+ def grep(*args, &block); end
664
+ def grep_v(*args, &block); end
665
+ def group_by(*args, &block); end
666
+ def include?(*args, &block); end
667
+ def index(*args, &block); end
668
+ def inject(*args, &block); end
669
+ def insert(*args, &block); end
670
+ def intersection(*args, &block); end
671
+ def join(*args, &block); end
672
+ def keep_if(*args, &block); end
673
+ def last(*args, &block); end
674
+ def lazy(*args, &block); end
675
+ def length(*args, &block); end
676
+ def map!(*args, &block); end
677
+ def map(*args, &block); end
678
+ def max(*args, &block); end
679
+ def max_by(*args, &block); end
680
+ def member?(*args, &block); end
681
+ def min(*args, &block); end
682
+ def min_by(*args, &block); end
683
+ def minmax(*args, &block); end
684
+ def minmax_by(*args, &block); end
685
+ def none?(*args, &block); end
686
+ def one?(*args, &block); end
687
+ def pack(*args, &block); end
688
+ def partition(*args, &block); end
689
+ def permutation(*args, &block); end
690
+ def pop(*args, &block); end
691
+ def prepend(*args, &block); end
692
+ def product(*args, &block); end
693
+ def push(*args, &block); end
694
+ def rassoc(*args, &block); end
695
+ def reduce(*args, &block); end
696
+ def reject!(*args, &block); end
697
+ def reject(*args, &block); end
698
+ def repeated_combination(*args, &block); end
699
+ def repeated_permutation(*args, &block); end
700
+ def replace(*args, &block); end
701
+ def reverse!(*args, &block); end
702
+ def reverse(*args, &block); end
703
+ def reverse_each(*args, &block); end
704
+ def rindex(*args, &block); end
705
+ def rotate!(*args, &block); end
706
+ def rotate(*args, &block); end
707
+ def sample(*args, &block); end
708
+ def select!(*args, &block); end
709
+ def select(*args, &block); end
710
+ def shelljoin(*args, &block); end
711
+ def shift(*args, &block); end
712
+ def shuffle!(*args, &block); end
713
+ def shuffle(*args, &block); end
714
+ def size(*args, &block); end
715
+ def slice!(*args, &block); end
716
+ def slice(*args, &block); end
717
+ def slice_after(*args, &block); end
718
+ def slice_before(*args, &block); end
719
+ def slice_when(*args, &block); end
720
+ def sort!(*args, &block); end
721
+ def sort(*args, &block); end
722
+ def sort_by!(*args, &block); end
723
+ def sort_by(*args, &block); end
724
+ def sum(*args, &block); end
725
+ def take(*args, &block); end
726
+ def take_while(*args, &block); end
727
+ def tally(*args, &block); end
728
+ def to_ary(*args, &block); end
729
+ def to_h(*args, &block); end
730
+ def to_set(*args, &block); end
731
+ def transpose(*args, &block); end
732
+ def union(*args, &block); end
733
+ def uniq!(*args, &block); end
734
+ def uniq(*args, &block); end
735
+ def unshift(*args, &block); end
736
+ def values_at(*args, &block); end
737
+ def zip(*args, &block); end
738
+ def |(*args, &block); end
739
+ extend Forwardable
740
+ end
741
+ module RuboCop::AST::ConditionalNode
742
+ def body; end
743
+ def condition; end
744
+ def multiline_condition?; end
745
+ def single_line_condition?; end
746
+ end
747
+ module RuboCop::AST::HashElementNode
748
+ def delimiter_delta(other); end
749
+ def key; end
750
+ def key_delta(other, alignment = nil); end
751
+ def same_line?(other); end
752
+ def value; end
753
+ def value_delta(other); end
754
+ end
755
+ class RuboCop::AST::HashElementNode::HashElementDelta
756
+ def delimiter_delta; end
757
+ def delta(first, second, alignment = nil); end
758
+ def first; end
759
+ def initialize(first, second); end
760
+ def key_delta(alignment = nil); end
761
+ def keyword_splat?; end
762
+ def second; end
763
+ def valid_argument_types?; end
764
+ def value_delta; end
765
+ end
766
+ module RuboCop::AST::MethodDispatchNode
767
+ def access_modifier?; end
768
+ def adjacent_def_modifier?(param0 = nil); end
769
+ def arithmetic_operation?; end
770
+ def assignment?; end
771
+ def bare_access_modifier?; end
772
+ def bare_access_modifier_declaration?(param0 = nil); end
773
+ def binary_operation?; end
774
+ def block_literal?; end
775
+ def block_node; end
776
+ def command?(name); end
777
+ def const_receiver?; end
778
+ def def_modifier?; end
779
+ def dot?; end
780
+ def double_colon?; end
781
+ def implicit_call?; end
782
+ def in_macro_scope?(param0 = nil); end
783
+ def lambda?; end
784
+ def lambda_literal?; end
785
+ def macro?; end
786
+ def method_name; end
787
+ def non_bare_access_modifier?; end
788
+ def non_bare_access_modifier_declaration?(param0 = nil); end
789
+ def receiver; end
790
+ def safe_navigation?; end
791
+ def self_receiver?; end
792
+ def setter_method?; end
793
+ def special_modifier?; end
794
+ def unary_operation?; end
795
+ extend RuboCop::AST::NodePattern::Macros
796
+ include RuboCop::AST::MethodIdentifierPredicates
797
+ end
798
+ module RuboCop::AST::ModifierNode
799
+ def modifier_form?; end
800
+ end
801
+ module RuboCop::AST::NumericNode
802
+ def sign?; end
803
+ end
804
+ module RuboCop::AST::ParameterizedNode
805
+ def arguments?; end
806
+ def block_argument?; end
807
+ def first_argument; end
808
+ def last_argument; end
809
+ def parenthesized?; end
810
+ def rest_argument?; end
811
+ def splat_argument?; end
812
+ end
813
+ module RuboCop::AST::ParameterizedNode::WrappedArguments
814
+ def arguments; end
815
+ include RuboCop::AST::ParameterizedNode
816
+ end
817
+ module RuboCop::AST::ParameterizedNode::RestArguments
818
+ def arguments; end
819
+ def arguments?; end
820
+ def first_argument; end
821
+ def last_argument; end
822
+ include RuboCop::AST::ParameterizedNode
823
+ end
824
+ module RuboCop::AST::PredicateOperatorNode
825
+ def logical_operator?; end
826
+ def operator; end
827
+ def semantic_operator?; end
828
+ end
829
+ module RuboCop::AST::BasicLiteralNode
830
+ def value; end
831
+ end
832
+ class RuboCop::AST::AliasNode < RuboCop::AST::Node
833
+ def new_identifier; end
834
+ def old_identifier; end
835
+ end
836
+ class RuboCop::AST::AndNode < RuboCop::AST::Node
837
+ def alternate_operator; end
838
+ def inverse_operator; end
839
+ include RuboCop::AST::BinaryOperatorNode
840
+ include RuboCop::AST::PredicateOperatorNode
841
+ end
842
+ class RuboCop::AST::ArgsNode < RuboCop::AST::Node
843
+ def empty_and_without_delimiters?; end
844
+ include RuboCop::AST::CollectionNode
845
+ end
846
+ class RuboCop::AST::ArrayNode < RuboCop::AST::Node
847
+ def bracketed?; end
848
+ def each_value(&block); end
849
+ def percent_literal?(type = nil); end
850
+ def square_brackets?; end
851
+ def values; end
852
+ end
853
+ class RuboCop::AST::BlockNode < RuboCop::AST::Node
854
+ def arguments; end
855
+ def arguments?; end
856
+ def body; end
857
+ def braces?; end
858
+ def closing_delimiter; end
859
+ def delimiters; end
860
+ def keywords?; end
861
+ def lambda?; end
862
+ def method_name; end
863
+ def multiline?; end
864
+ def opening_delimiter; end
865
+ def send_node; end
866
+ def single_line?; end
867
+ def void_context?; end
868
+ include RuboCop::AST::MethodIdentifierPredicates
869
+ end
870
+ class RuboCop::AST::BreakNode < RuboCop::AST::Node
871
+ include RuboCop::AST::ParameterizedNode::WrappedArguments
872
+ end
873
+ class RuboCop::AST::CaseMatchNode < RuboCop::AST::Node
874
+ def each_in_pattern(&block); end
875
+ def else?; end
876
+ def else_branch; end
877
+ def in_pattern_branches; end
878
+ def keyword; end
879
+ include RuboCop::AST::ConditionalNode
880
+ end
881
+ class RuboCop::AST::CaseNode < RuboCop::AST::Node
882
+ def branches; end
883
+ def each_when(&block); end
884
+ def else?; end
885
+ def else_branch; end
886
+ def keyword; end
887
+ def when_branches; end
888
+ include RuboCop::AST::ConditionalNode
889
+ end
890
+ class RuboCop::AST::ClassNode < RuboCop::AST::Node
891
+ def body; end
892
+ def identifier; end
893
+ def parent_class; end
894
+ end
895
+ class RuboCop::AST::ConstNode < RuboCop::AST::Node
896
+ def absolute?; end
897
+ def class_name?; end
898
+ def each_path(&block); end
899
+ def module_name?; end
900
+ def namespace; end
901
+ def relative?; end
902
+ def short_name; end
903
+ end
904
+ class RuboCop::AST::DefNode < RuboCop::AST::Node
905
+ def argument_forwarding?; end
906
+ def arguments; end
907
+ def body; end
908
+ def endless?; end
909
+ def method_name; end
910
+ def receiver; end
911
+ def void_context?; end
912
+ include RuboCop::AST::MethodIdentifierPredicates
913
+ include RuboCop::AST::ParameterizedNode
914
+ end
915
+ class RuboCop::AST::DefinedNode < RuboCop::AST::Node
916
+ def arguments; end
917
+ def node_parts; end
918
+ include RuboCop::AST::MethodDispatchNode
919
+ include RuboCop::AST::ParameterizedNode
920
+ end
921
+ class RuboCop::AST::EnsureNode < RuboCop::AST::Node
922
+ def body; end
923
+ end
924
+ class RuboCop::AST::ForNode < RuboCop::AST::Node
925
+ def body; end
926
+ def collection; end
927
+ def do?; end
928
+ def keyword; end
929
+ def variable; end
930
+ def void_context?; end
931
+ end
932
+ class RuboCop::AST::ForwardArgsNode < RuboCop::AST::Node
933
+ def to_a; end
934
+ include RuboCop::AST::CollectionNode
935
+ end
936
+ class RuboCop::AST::FloatNode < RuboCop::AST::Node
937
+ include RuboCop::AST::BasicLiteralNode
938
+ include RuboCop::AST::NumericNode
939
+ end
940
+ class RuboCop::AST::HashNode < RuboCop::AST::Node
941
+ def braces?; end
942
+ def each_key(&block); end
943
+ def each_pair; end
944
+ def each_value(&block); end
945
+ def empty?; end
946
+ def keys; end
947
+ def mixed_delimiters?; end
948
+ def pairs; end
949
+ def pairs_on_same_line?; end
950
+ def values; end
951
+ end
952
+ class RuboCop::AST::IfNode < RuboCop::AST::Node
953
+ def branches; end
954
+ def each_branch(&block); end
955
+ def else?; end
956
+ def else_branch; end
957
+ def elsif?; end
958
+ def elsif_conditional?; end
959
+ def if?; end
960
+ def if_branch; end
961
+ def inverse_keyword; end
962
+ def keyword; end
963
+ def modifier_form?; end
964
+ def nested_conditional?; end
965
+ def node_parts; end
966
+ def ternary?; end
967
+ def unless?; end
968
+ include RuboCop::AST::ConditionalNode
969
+ include RuboCop::AST::ModifierNode
970
+ end
971
+ class RuboCop::AST::IndexNode < RuboCop::AST::Node
972
+ def assignment_method?; end
973
+ def attribute_accessor?; end
974
+ def first_argument_index; end
975
+ def method_name; end
976
+ include RuboCop::AST::MethodDispatchNode
977
+ include RuboCop::AST::ParameterizedNode::RestArguments
978
+ end
979
+ class RuboCop::AST::IndexasgnNode < RuboCop::AST::Node
980
+ def assignment_method?; end
981
+ def attribute_accessor?; end
982
+ def first_argument_index; end
983
+ def method_name; end
984
+ include RuboCop::AST::MethodDispatchNode
985
+ include RuboCop::AST::ParameterizedNode::RestArguments
986
+ end
987
+ class RuboCop::AST::IntNode < RuboCop::AST::Node
988
+ include RuboCop::AST::BasicLiteralNode
989
+ include RuboCop::AST::NumericNode
990
+ end
991
+ class RuboCop::AST::KeywordSplatNode < RuboCop::AST::Node
992
+ def colon?; end
993
+ def hash_rocket?; end
994
+ def node_parts; end
995
+ def operator; end
996
+ include RuboCop::AST::HashElementNode
997
+ end
998
+ class RuboCop::AST::LambdaNode < RuboCop::AST::Node
999
+ def assignment_method?; end
1000
+ def attribute_accessor?; end
1001
+ def first_argument_index; end
1002
+ def lambda?; end
1003
+ def lambda_literal?; end
1004
+ def method_name; end
1005
+ def receiver; end
1006
+ include RuboCop::AST::MethodDispatchNode
1007
+ include RuboCop::AST::ParameterizedNode::RestArguments
1008
+ end
1009
+ class RuboCop::AST::ModuleNode < RuboCop::AST::Node
1010
+ def body; end
1011
+ def identifier; end
1012
+ end
1013
+ class RuboCop::AST::NextNode < RuboCop::AST::Node
1014
+ include RuboCop::AST::ParameterizedNode::WrappedArguments
1015
+ end
1016
+ class RuboCop::AST::OrNode < RuboCop::AST::Node
1017
+ def alternate_operator; end
1018
+ def inverse_operator; end
1019
+ include RuboCop::AST::BinaryOperatorNode
1020
+ include RuboCop::AST::PredicateOperatorNode
1021
+ end
1022
+ class RuboCop::AST::PairNode < RuboCop::AST::Node
1023
+ def colon?; end
1024
+ def delimiter(*deprecated, with_spacing: nil); end
1025
+ def hash_rocket?; end
1026
+ def inverse_delimiter(*deprecated, with_spacing: nil); end
1027
+ def value_on_new_line?; end
1028
+ include RuboCop::AST::HashElementNode
1029
+ end
1030
+ class RuboCop::AST::RangeNode < RuboCop::AST::Node
1031
+ def begin; end
1032
+ def end; end
1033
+ end
1034
+ class RuboCop::AST::RegexpNode < RuboCop::AST::Node
1035
+ def content; end
1036
+ def delimiter?(char); end
1037
+ def delimiters; end
1038
+ def extended?; end
1039
+ def ignore_case?; end
1040
+ def interpolation?; end
1041
+ def multiline_mode?; end
1042
+ def no_encoding?; end
1043
+ def options; end
1044
+ def percent_r_literal?; end
1045
+ def regopt; end
1046
+ def regopt_include?(option); end
1047
+ def single_interpolation?; end
1048
+ def slash_literal?; end
1049
+ def to_regexp; end
1050
+ end
1051
+ class RuboCop::AST::RescueNode < RuboCop::AST::Node
1052
+ def body; end
1053
+ def branches; end
1054
+ def else?; end
1055
+ def else_branch; end
1056
+ def resbody_branches; end
1057
+ end
1058
+ class RuboCop::AST::ResbodyNode < RuboCop::AST::Node
1059
+ def body; end
1060
+ def branch_index; end
1061
+ def exception_variable; end
1062
+ def exceptions; end
1063
+ end
1064
+ class RuboCop::AST::ReturnNode < RuboCop::AST::Node
1065
+ include RuboCop::AST::ParameterizedNode::WrappedArguments
1066
+ end
1067
+ class RuboCop::AST::SelfClassNode < RuboCop::AST::Node
1068
+ def body; end
1069
+ def identifier; end
1070
+ end
1071
+ class RuboCop::AST::SendNode < RuboCop::AST::Node
1072
+ def attribute_accessor?(param0 = nil); end
1073
+ def first_argument_index; end
1074
+ include RuboCop::AST::MethodDispatchNode
1075
+ include RuboCop::AST::ParameterizedNode::RestArguments
1076
+ end
1077
+ class RuboCop::AST::StrNode < RuboCop::AST::Node
1078
+ def heredoc?; end
1079
+ include RuboCop::AST::BasicLiteralNode
1080
+ end
1081
+ class RuboCop::AST::SuperNode < RuboCop::AST::Node
1082
+ def arguments; end
1083
+ def node_parts; end
1084
+ include RuboCop::AST::MethodDispatchNode
1085
+ include RuboCop::AST::ParameterizedNode
1086
+ end
1087
+ class RuboCop::AST::SymbolNode < RuboCop::AST::Node
1088
+ include RuboCop::AST::BasicLiteralNode
1089
+ end
1090
+ class RuboCop::AST::UntilNode < RuboCop::AST::Node
1091
+ def do?; end
1092
+ def inverse_keyword; end
1093
+ def keyword; end
1094
+ include RuboCop::AST::ConditionalNode
1095
+ include RuboCop::AST::ModifierNode
1096
+ end
1097
+ class RuboCop::AST::WhenNode < RuboCop::AST::Node
1098
+ def body; end
1099
+ def branch_index; end
1100
+ def conditions; end
1101
+ def each_condition(&block); end
1102
+ def then?; end
1103
+ end
1104
+ class RuboCop::AST::WhileNode < RuboCop::AST::Node
1105
+ def do?; end
1106
+ def inverse_keyword; end
1107
+ def keyword; end
1108
+ include RuboCop::AST::ConditionalNode
1109
+ include RuboCop::AST::ModifierNode
1110
+ end
1111
+ class RuboCop::AST::YieldNode < RuboCop::AST::Node
1112
+ def arguments; end
1113
+ def node_parts; end
1114
+ include RuboCop::AST::MethodDispatchNode
1115
+ include RuboCop::AST::ParameterizedNode
1116
+ end
1117
+ class RuboCop::AST::Builder < Parser::Builders::Default
1118
+ def n(type, children, source_map); end
1119
+ def node_klass(type); end
1120
+ def string_value(token); end
1121
+ end
1122
+ class RuboCop::AST::ProcessedSource
1123
+ def [](*args); end
1124
+ def ast; end
1125
+ def ast_with_comments; end
1126
+ def blank?; end
1127
+ def buffer; end
1128
+ def checksum; end
1129
+ def comment_at_line(line); end
1130
+ def comment_index; end
1131
+ def commented?(source_range); end
1132
+ def comments; end
1133
+ def comments_before_line(line); end
1134
+ def contains_comment?(source_range); end
1135
+ def create_parser(ruby_version); end
1136
+ def current_line(token); end
1137
+ def diagnostics; end
1138
+ def each_comment(&block); end
1139
+ def each_comment_in_lines(line_range); end
1140
+ def each_token(&block); end
1141
+ def file_path; end
1142
+ def find_comment(&block); end
1143
+ def find_token(&block); end
1144
+ def first_token_index(range_or_node); end
1145
+ def first_token_of(range_or_node); end
1146
+ def following_line(token); end
1147
+ def initialize(source, ruby_version, path = nil); end
1148
+ def last_token_index(range_or_node); end
1149
+ def last_token_of(range_or_node); end
1150
+ def line_indentation(line_number); end
1151
+ def line_with_comment?(line); end
1152
+ def lines; end
1153
+ def parse(source, ruby_version); end
1154
+ def parser_class(ruby_version); end
1155
+ def parser_error; end
1156
+ def path; end
1157
+ def preceding_line(token); end
1158
+ def raw_source; end
1159
+ def ruby_version; end
1160
+ def self.from_file(path, ruby_version); end
1161
+ def sorted_tokens; end
1162
+ def source_range(range_or_node); end
1163
+ def start_with?(string); end
1164
+ def tokenize(parser); end
1165
+ def tokens; end
1166
+ def tokens_within(range_or_node); end
1167
+ def valid_syntax?; end
1168
+ end
1169
+ module RuboCop::AST::RuboCopCompatibility
1170
+ def rubocop_loaded; end
1171
+ end
1172
+ class RuboCop::AST::Token
1173
+ def begin_pos; end
1174
+ def column; end
1175
+ def comma?; end
1176
+ def comment?; end
1177
+ def end?; end
1178
+ def end_pos; end
1179
+ def equal_sign?; end
1180
+ def initialize(pos, type, text); end
1181
+ def left_array_bracket?; end
1182
+ def left_brace?; end
1183
+ def left_bracket?; end
1184
+ def left_curly_brace?; end
1185
+ def left_parens?; end
1186
+ def left_ref_bracket?; end
1187
+ def line; end
1188
+ def pos; end
1189
+ def rescue_modifier?; end
1190
+ def right_bracket?; end
1191
+ def right_curly_brace?; end
1192
+ def right_parens?; end
1193
+ def self.from_parser_token(parser_token); end
1194
+ def semicolon?; end
1195
+ def space_after?; end
1196
+ def space_before?; end
1197
+ def text; end
1198
+ def to_s; end
1199
+ def type; end
1200
+ end
1201
+ module RuboCop::AST::Traversal
1202
+ def on_(node); end
1203
+ def on___ENCODING__(node); end
1204
+ def on___FILE__(node); end
1205
+ def on___LINE__(node); end
1206
+ def on_alias(node); end
1207
+ def on_and(node); end
1208
+ def on_and_asgn(node); end
1209
+ def on_arg(node); end
1210
+ def on_arg_expr(node); end
1211
+ def on_args(node); end
1212
+ def on_array(node); end
1213
+ def on_array_pattern(node); end
1214
+ def on_array_pattern_with_tail(node); end
1215
+ def on_back_ref(node); end
1216
+ def on_begin(node); end
1217
+ def on_block(node); end
1218
+ def on_block_pass(node); end
1219
+ def on_blockarg(node); end
1220
+ def on_break(node); end
1221
+ def on_case(node); end
1222
+ def on_case_match(node); end
1223
+ def on_casgn(node); end
1224
+ def on_cbase(node); end
1225
+ def on_class(node); end
1226
+ def on_complex(node); end
1227
+ def on_const(node); end
1228
+ def on_const_pattern(node); end
1229
+ def on_csend(node); end
1230
+ def on_cvar(node); end
1231
+ def on_cvasgn(node); end
1232
+ def on_def(node); end
1233
+ def on_defined?(node); end
1234
+ def on_defs(node); end
1235
+ def on_dstr(node); end
1236
+ def on_dsym(node); end
1237
+ def on_eflipflop(node); end
1238
+ def on_empty_else(node); end
1239
+ def on_ensure(node); end
1240
+ def on_erange(node); end
1241
+ def on_false(node); end
1242
+ def on_find_pattern(node); end
1243
+ def on_float(node); end
1244
+ def on_for(node); end
1245
+ def on_forward_arg(node); end
1246
+ def on_forward_args(node); end
1247
+ def on_forwarded_args(node); end
1248
+ def on_gvar(node); end
1249
+ def on_gvasgn(node); end
1250
+ def on_hash(node); end
1251
+ def on_hash_pattern(node); end
1252
+ def on_if(node); end
1253
+ def on_if_guard(node); end
1254
+ def on_iflipflop(node); end
1255
+ def on_in_match(node); end
1256
+ def on_in_pattern(node); end
1257
+ def on_index(node); end
1258
+ def on_indexasgn(node); end
1259
+ def on_int(node); end
1260
+ def on_irange(node); end
1261
+ def on_ivar(node); end
1262
+ def on_ivasgn(node); end
1263
+ def on_kwarg(node); end
1264
+ def on_kwbegin(node); end
1265
+ def on_kwnilarg(node); end
1266
+ def on_kwoptarg(node); end
1267
+ def on_kwrestarg(node); end
1268
+ def on_kwsplat(node); end
1269
+ def on_lambda(node); end
1270
+ def on_lvar(node); end
1271
+ def on_lvasgn(node); end
1272
+ def on_masgn(node); end
1273
+ def on_match_alt(node); end
1274
+ def on_match_as(node); end
1275
+ def on_match_current_line(node); end
1276
+ def on_match_nil_pattern(node); end
1277
+ def on_match_rest(node); end
1278
+ def on_match_var(node); end
1279
+ def on_match_with_lvasgn(node); end
1280
+ def on_match_with_trailing_comma(node); end
1281
+ def on_mlhs(node); end
1282
+ def on_module(node); end
1283
+ def on_mrasgn(node); end
1284
+ def on_next(node); end
1285
+ def on_nil(node); end
1286
+ def on_not(node); end
1287
+ def on_nth_ref(node); end
1288
+ def on_numblock(node); end
1289
+ def on_op_asgn(node); end
1290
+ def on_optarg(node); end
1291
+ def on_or(node); end
1292
+ def on_or_asgn(node); end
1293
+ def on_pair(node); end
1294
+ def on_pin(node); end
1295
+ def on_postexe(node); end
1296
+ def on_preexe(node); end
1297
+ def on_procarg0(node); end
1298
+ def on_rasgn(node); end
1299
+ def on_rational(node); end
1300
+ def on_redo(node); end
1301
+ def on_regexp(node); end
1302
+ def on_regopt(node); end
1303
+ def on_resbody(node); end
1304
+ def on_rescue(node); end
1305
+ def on_restarg(node); end
1306
+ def on_retry(node); end
1307
+ def on_return(node); end
1308
+ def on_sclass(node); end
1309
+ def on_self(node); end
1310
+ def on_send(node); end
1311
+ def on_shadowarg(node); end
1312
+ def on_splat(node); end
1313
+ def on_str(node); end
1314
+ def on_super(node); end
1315
+ def on_sym(node); end
1316
+ def on_true(node); end
1317
+ def on_undef(node); end
1318
+ def on_unless_guard(node); end
1319
+ def on_until(node); end
1320
+ def on_until_post(node); end
1321
+ def on_when(node); end
1322
+ def on_while(node); end
1323
+ def on_while_post(node); end
1324
+ def on_xstr(node); end
1325
+ def on_yield(node); end
1326
+ def on_zsuper(node); end
1327
+ def walk(node); end
1328
+ extend RuboCop::AST::Traversal::CallbackCompiler
1329
+ end
1330
+ class RuboCop::AST::Traversal::DebugError < RuntimeError
1331
+ end
1332
+ module RuboCop::AST::Traversal::CallbackCompiler
1333
+ def arity_check(range); end
1334
+ def body(signature, prelude); end
1335
+ def def_callback(type, *signature, arity: nil, arity_check: nil, body: nil); end
1336
+ end
1337
+ module RuboCop::AST::Version
1338
+ end