sorbet-progress 0.2.2 → 0.2.3

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: b1b2864945eca327b0b0715aefce371815ee039e5309a58c385e3c065ec3b5e0
4
- data.tar.gz: 899d4f39451f6ac4170817d57740c8be717da092657b02ebfb4e7fef91a6c496
3
+ metadata.gz: f2b752c1402c88bae07c2dae86eda9bcbcff0de8654c7066391b21955120a95b
4
+ data.tar.gz: 969a4bea50f371d608815f3247bf25b372027448ec0c02254061e97e220787ae
5
5
  SHA512:
6
- metadata.gz: 4c0bf9d3fc3ebc153dad7d015a69c6e6963122dbee5de4cb0cd1f64c00c3bb5a02a3dd913e0b1b58dea378b72f6dfe6b76f82f024d402f0c6023dfd6b1bfe09c
7
- data.tar.gz: b10a7fedfca39f5233670f1306e5a35261c7359ddacec44d4bca56d33b2ad96db4b7f8a253fdf49292bd12f05ce20e298e1f07fdacda1106e1752561e4455c03
6
+ metadata.gz: e4a02e2780f150ae44354e74aaf892de8946b19c7fb33cc73d0b548ae66c7d87ecc63907493b76180816296b9d506095a079a652411d41b23f98254884ea1288
7
+ data.tar.gz: d472bdcf06b24cbfc3ed65df404c0c1f527786c7186479489a7d96416dfbbd55a28c5e64663c0c7064fd60fba9f6e3d601a691383c6504e83d9f66b777eff4ef
@@ -12,6 +12,17 @@ recommendations of [keepachangelog.com](http://keepachangelog.com/).
12
12
  - Fixed
13
13
  - None
14
14
 
15
+ ## 0.2.3 (2019-07-08)
16
+
17
+ - Breaking Changes
18
+ - None
19
+ - Added
20
+ - None
21
+ - Fixed
22
+ - Measure the `typed: strict` sigil
23
+ - Dependencies
24
+ - Relax sorbet constraint to `< 0.5`
25
+
15
26
  ## 0.2.2 (2019-07-02)
16
27
 
17
28
  - Breaking Changes
data/README.md CHANGED
@@ -22,13 +22,26 @@ Or install it yourself:
22
22
  ## Usage
23
23
 
24
24
  ```bash
25
- srb tc --metrics-file /tmp/sorbet_metrics.json
26
- sorbet_progress /tmp/sorbet_metrics.json
25
+ bundle exec srb tc --metrics-file /tmp/sorbet_metrics.json
26
+ # No errors! Great job.
27
+ bundle exec sorbet_progress /tmp/sorbet_metrics.json
28
+ # SorbetProgress:
29
+ # total_signatures 1563
30
+ # total_methods 5267
31
+ # total_classes 3795
32
+ # sigil_ignore unknown
33
+ # sigil_false 1
34
+ # sigil_true 12
35
+ # sigil_strong unknown
36
+ # Keep up the good work 👍
27
37
  ```
28
38
 
39
+ Not sure what the best format is. Pull requests welcome. It might be nice to
40
+ have an overall percentage, for example.
41
+
29
42
  ## Contributing
30
43
 
31
- This project does not accept bug reports. Pull requests are welcome.
44
+ This project does not accept bug reports. Pull requests are welcome.
32
45
 
33
46
  This project is intended to be a safe, welcoming space for collaboration, and
34
47
  contributors are expected to adhere to the [code of conduct](/CODE_OF_CONDUCT.md)
@@ -1,4 +1,4 @@
1
- # typed: true
1
+ # typed: strong
2
2
  # frozen_string_literal: true
3
3
 
4
4
  require "sorbet-runtime"
@@ -34,6 +34,7 @@ module SorbetProgress
34
34
  sigil_ignore: "ruby_typer.unknown..types.input.files.sigil.ignore",
35
35
  sigil_false: "ruby_typer.unknown..types.input.files.sigil.false",
36
36
  sigil_true: "ruby_typer.unknown..types.input.files.sigil.true",
37
+ sigil_strict: "ruby_typer.unknown..types.input.files.sigil.strict",
37
38
  sigil_strong: "ruby_typer.unknown..types.input.files.sigil.strong"
38
39
  }.each do |label, name|
39
40
  metric = metrics[name]
@@ -1,4 +1,4 @@
1
- # typed: true
1
+ # typed: strict
2
2
  # frozen_string_literal: true
3
3
 
4
4
  module SorbetProgress
@@ -1,6 +1,6 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- # typed: true
3
+ # typed: strict
4
4
 
5
5
  require "json"
6
6
  require "sorbet_progress/error"
@@ -1,8 +1,9 @@
1
+ # typed: true
1
2
  # frozen_string_literal: true
2
3
 
3
- # typed: true
4
+ # :nodoc:
4
5
  module SorbetProgress
5
6
  def self.gem_version
6
- Gem::Version.new("0.2.2")
7
+ Gem::Version.new("0.2.3")
7
8
  end
8
9
  end
@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
22
22
  spec.required_rubygems_version = ">= 3.0.3"
23
23
 
24
24
  lambda {
25
- requirements = [">= 0.4.4314", "<= 0.4.4366"]
25
+ requirements = [">= 0.4.4314", "< 0.5"]
26
26
  spec.add_runtime_dependency "sorbet", requirements
27
27
  spec.add_runtime_dependency "sorbet-runtime", requirements
28
28
  }.call
@@ -0,0 +1,47 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ast/all/ast.rbi
9
+ #
10
+ # ast-2.4.0
11
+ module AST
12
+ end
13
+ class AST::Node
14
+ def +(array); end
15
+ def <<(element); end
16
+ def ==(other); end
17
+ def append(element); end
18
+ def assign_properties(properties); end
19
+ def children; end
20
+ def clone; end
21
+ def concat(array); end
22
+ def dup; end
23
+ def eql?(other); end
24
+ def fancy_type; end
25
+ def hash; end
26
+ def initialize(type, children = nil, properties = nil); end
27
+ def inspect(indent = nil); end
28
+ def original_dup; end
29
+ def to_a; end
30
+ def to_ast; end
31
+ def to_s(indent = nil); end
32
+ def to_sexp(indent = nil); end
33
+ def to_sexp_array; end
34
+ def type; end
35
+ def updated(type = nil, children = nil, properties = nil); end
36
+ end
37
+ class AST::Processor
38
+ include AST::Processor::Mixin
39
+ end
40
+ module AST::Processor::Mixin
41
+ def handler_missing(node); end
42
+ def process(node); end
43
+ def process_all(nodes); end
44
+ end
45
+ module AST::Sexp
46
+ def s(type, *children); end
47
+ end
@@ -0,0 +1,14 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/jaro_winkler/all/jaro_winkler.rbi
9
+ #
10
+ # jaro_winkler-1.5.3
11
+ module JaroWinkler
12
+ def self.distance(*arg0); end
13
+ def self.jaro_distance(*arg0); end
14
+ end
@@ -0,0 +1,81 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parallel/all/parallel.rbi
9
+ #
10
+ # parallel-1.17.0
11
+ module Parallel
12
+ def self.add_progress_bar!(job_factory, options); end
13
+ def self.all?(*args, &block); end
14
+ def self.any?(*args, &block); end
15
+ def self.call_with_index(item, index, options, &block); end
16
+ def self.create_workers(job_factory, options, &block); end
17
+ def self.each(array, options = nil, &block); end
18
+ def self.each_with_index(array, options = nil, &block); end
19
+ def self.extract_count_from_options(options); end
20
+ def self.flat_map(*args, &block); end
21
+ def self.handle_exception(exception, results); end
22
+ def self.in_processes(options = nil, &block); end
23
+ def self.in_threads(options = nil); end
24
+ def self.map(source, options = nil, &block); end
25
+ def self.map_with_index(array, options = nil, &block); end
26
+ def self.process_incoming_jobs(read, write, job_factory, options, &block); end
27
+ def self.replace_worker(job_factory, workers, i, options, blk); end
28
+ def self.with_instrumentation(item, index, options); end
29
+ def self.work_direct(job_factory, options, &block); end
30
+ def self.work_in_processes(job_factory, options, &blk); end
31
+ def self.work_in_threads(job_factory, options, &block); end
32
+ def self.worker(job_factory, options, &block); end
33
+ def self.worker_number; end
34
+ def self.worker_number=(worker_num); end
35
+ extend Parallel::ProcessorCount
36
+ end
37
+ module Parallel::ProcessorCount
38
+ def physical_processor_count; end
39
+ def processor_count; end
40
+ end
41
+ class Parallel::DeadWorker < StandardError
42
+ end
43
+ class Parallel::Break < StandardError
44
+ end
45
+ class Parallel::Kill < StandardError
46
+ end
47
+ class Parallel::UndumpableException < StandardError
48
+ def backtrace; end
49
+ def initialize(original); end
50
+ end
51
+ class Parallel::ExceptionWrapper
52
+ def exception; end
53
+ def initialize(exception); end
54
+ end
55
+ class Parallel::Worker
56
+ def close_pipes; end
57
+ def initialize(read, write, pid); end
58
+ def pid; end
59
+ def read; end
60
+ def stop; end
61
+ def thread; end
62
+ def thread=(arg0); end
63
+ def wait; end
64
+ def work(data); end
65
+ def write; end
66
+ end
67
+ class Parallel::JobFactory
68
+ def initialize(source, mutex); end
69
+ def next; end
70
+ def pack(item, index); end
71
+ def producer?; end
72
+ def queue_wrapper(array); end
73
+ def size; end
74
+ def unpack(data); end
75
+ end
76
+ class Parallel::UserInterruptHandler
77
+ def self.kill(thing); end
78
+ def self.kill_on_ctrl_c(pids, options); end
79
+ def self.restore_interrupt(old, signal); end
80
+ def self.trap_interrupt(signal); end
81
+ end
@@ -0,0 +1,835 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parser/all/parser.rbi
9
+ #
10
+ # parser-2.6.3.0
11
+ module Parser
12
+ end
13
+ module Parser::Deprecation
14
+ def warn_of_deprecation; end
15
+ def warned_of_deprecation=(arg0); end
16
+ end
17
+ module Parser::AST
18
+ end
19
+ class Parser::AST::Node < AST::Node
20
+ def assign_properties(properties); end
21
+ def loc; end
22
+ def location; end
23
+ end
24
+ class Parser::AST::Processor < AST::Processor
25
+ def on_alias(node); end
26
+ def on_and(node); end
27
+ def on_and_asgn(node); end
28
+ def on_arg(node); end
29
+ def on_arg_expr(node); end
30
+ def on_args(node); end
31
+ def on_argument(node); end
32
+ def on_array(node); end
33
+ def on_back_ref(node); end
34
+ def on_begin(node); end
35
+ def on_block(node); end
36
+ def on_block_pass(node); end
37
+ def on_blockarg(node); end
38
+ def on_blockarg_expr(node); end
39
+ def on_break(node); end
40
+ def on_case(node); end
41
+ def on_casgn(node); end
42
+ def on_class(node); end
43
+ def on_const(node); end
44
+ def on_csend(node); end
45
+ def on_cvar(node); end
46
+ def on_cvasgn(node); end
47
+ def on_def(node); end
48
+ def on_defined?(node); end
49
+ def on_defs(node); end
50
+ def on_dstr(node); end
51
+ def on_dsym(node); end
52
+ def on_eflipflop(node); end
53
+ def on_ensure(node); end
54
+ def on_erange(node); end
55
+ def on_for(node); end
56
+ def on_gvar(node); end
57
+ def on_gvasgn(node); end
58
+ def on_hash(node); end
59
+ def on_if(node); end
60
+ def on_iflipflop(node); end
61
+ def on_index(node); end
62
+ def on_indexasgn(node); end
63
+ def on_irange(node); end
64
+ def on_ivar(node); end
65
+ def on_ivasgn(node); end
66
+ def on_kwarg(node); end
67
+ def on_kwbegin(node); end
68
+ def on_kwoptarg(node); end
69
+ def on_kwrestarg(node); end
70
+ def on_kwsplat(node); end
71
+ def on_lambda(node); end
72
+ def on_lvar(node); end
73
+ def on_lvasgn(node); end
74
+ def on_masgn(node); end
75
+ def on_match_current_line(node); end
76
+ def on_match_with_lvasgn(node); end
77
+ def on_mlhs(node); end
78
+ def on_module(node); end
79
+ def on_next(node); end
80
+ def on_not(node); end
81
+ def on_nth_ref(node); end
82
+ def on_op_asgn(node); end
83
+ def on_optarg(node); end
84
+ def on_or(node); end
85
+ def on_or_asgn(node); end
86
+ def on_pair(node); end
87
+ def on_postexe(node); end
88
+ def on_preexe(node); end
89
+ def on_procarg0(node); end
90
+ def on_redo(node); end
91
+ def on_regexp(node); end
92
+ def on_resbody(node); end
93
+ def on_rescue(node); end
94
+ def on_restarg(node); end
95
+ def on_restarg_expr(node); end
96
+ def on_retry(node); end
97
+ def on_return(node); end
98
+ def on_sclass(node); end
99
+ def on_send(node); end
100
+ def on_shadowarg(node); end
101
+ def on_splat(node); end
102
+ def on_super(node); end
103
+ def on_undef(node); end
104
+ def on_until(node); end
105
+ def on_until_post(node); end
106
+ def on_var(node); end
107
+ def on_vasgn(node); end
108
+ def on_when(node); end
109
+ def on_while(node); end
110
+ def on_while_post(node); end
111
+ def on_xstr(node); end
112
+ def on_yield(node); end
113
+ def process_argument_node(node); end
114
+ def process_regular_node(node); end
115
+ def process_var_asgn_node(node); end
116
+ def process_variable_node(node); end
117
+ end
118
+ module Parser::Meta
119
+ end
120
+ module Parser::Source
121
+ end
122
+ class Parser::Source::Buffer
123
+ def column_for_position(position); end
124
+ def decompose_position(position); end
125
+ def first_line; end
126
+ def initialize(name, first_line = nil); end
127
+ def last_line; end
128
+ def line_begins; end
129
+ def line_for(position); end
130
+ def line_for_position(position); end
131
+ def line_range(lineno); end
132
+ def name; end
133
+ def raw_source=(input); end
134
+ def read; end
135
+ def self.recognize_encoding(string); end
136
+ def self.reencode_string(input); end
137
+ def slice(range); end
138
+ def source; end
139
+ def source=(input); end
140
+ def source_line(lineno); end
141
+ def source_lines; end
142
+ def source_range; end
143
+ end
144
+ class Parser::Source::Range
145
+ def <=>(other); end
146
+ def adjust(begin_pos: nil, end_pos: nil); end
147
+ def begin; end
148
+ def begin_pos; end
149
+ def column; end
150
+ def column_range; end
151
+ def contained?(other); end
152
+ def contains?(other); end
153
+ def crossing?(other); end
154
+ def disjoint?(other); end
155
+ def empty?; end
156
+ def end; end
157
+ def end_pos; end
158
+ def first_line; end
159
+ def initialize(source_buffer, begin_pos, end_pos); end
160
+ def inspect; end
161
+ def intersect(other); end
162
+ def is?(*what); end
163
+ def join(other); end
164
+ def last_column; end
165
+ def last_line; end
166
+ def length; end
167
+ def line; end
168
+ def overlaps?(other); end
169
+ def resize(new_size); end
170
+ def size; end
171
+ def source; end
172
+ def source_buffer; end
173
+ def source_line; end
174
+ def to_a; end
175
+ def to_s; end
176
+ def with(begin_pos: nil, end_pos: nil); end
177
+ include Comparable
178
+ end
179
+ class Parser::Source::Comment
180
+ def ==(other); end
181
+ def document?; end
182
+ def initialize(range); end
183
+ def inline?; end
184
+ def inspect; end
185
+ def loc; end
186
+ def location; end
187
+ def self.associate(ast, comments); end
188
+ def self.associate_locations(ast, comments); end
189
+ def text; end
190
+ def type; end
191
+ end
192
+ class Parser::Source::Comment::Associator
193
+ def advance_comment; end
194
+ def advance_through_directives; end
195
+ def associate; end
196
+ def associate_and_advance_comment(node); end
197
+ def associate_locations; end
198
+ def current_comment_before?(node); end
199
+ def current_comment_before_end?(node); end
200
+ def current_comment_decorates?(node); end
201
+ def do_associate; end
202
+ def initialize(ast, comments); end
203
+ def process_leading_comments(node); end
204
+ def process_trailing_comments(node); end
205
+ def skip_directives; end
206
+ def skip_directives=(arg0); end
207
+ def visit(node); end
208
+ end
209
+ class Parser::Source::Rewriter
210
+ def active_clobber; end
211
+ def active_clobber=(value); end
212
+ def active_insertions; end
213
+ def active_insertions=(value); end
214
+ def active_queue; end
215
+ def adjacent?(range1, range2); end
216
+ def adjacent_insertion_mask(range); end
217
+ def adjacent_insertions?(range); end
218
+ def adjacent_position_mask(range); end
219
+ def adjacent_updates?(range); end
220
+ def append(action); end
221
+ def can_merge?(action, existing); end
222
+ def clobbered_insertion?(insertion); end
223
+ def clobbered_position_mask(range); end
224
+ def diagnostics; end
225
+ def in_transaction?; end
226
+ def initialize(source_buffer); end
227
+ def insert_after(range, content); end
228
+ def insert_after_multi(range, content); end
229
+ def insert_before(range, content); end
230
+ def insert_before_multi(range, content); end
231
+ def merge_actions!(action, existing); end
232
+ def merge_actions(action, existing); end
233
+ def merge_replacements(actions); end
234
+ def process; end
235
+ def raise_clobber_error(action, existing); end
236
+ def record_insertion(range); end
237
+ def record_replace(range); end
238
+ def remove(range); end
239
+ def replace(range, content); end
240
+ def replace_actions(old, updated); end
241
+ def replace_compatible_with_insertion?(replace, insertion); end
242
+ def source_buffer; end
243
+ def transaction; end
244
+ def wrap(range, before, after); end
245
+ extend Parser::Deprecation
246
+ end
247
+ class Parser::Source::Rewriter::Action
248
+ def <=>(other); end
249
+ def allow_multiple_insertions; end
250
+ def allow_multiple_insertions?; end
251
+ def initialize(range, replacement = nil, allow_multiple_insertions = nil, order = nil); end
252
+ def order; end
253
+ def range; end
254
+ def replacement; end
255
+ def to_s; end
256
+ include Comparable
257
+ end
258
+ class Parser::Source::TreeRewriter
259
+ def check_policy_validity; end
260
+ def check_range_validity(range); end
261
+ def combine(range, attributes); end
262
+ def diagnostics; end
263
+ def enforce_policy(event); end
264
+ def in_transaction?; end
265
+ def initialize(source_buffer, crossing_deletions: nil, different_replacements: nil, swallowed_insertions: nil); end
266
+ def insert_after(range, content); end
267
+ def insert_after_multi(range, text); end
268
+ def insert_before(range, content); end
269
+ def insert_before_multi(range, text); end
270
+ def process; end
271
+ def remove(range); end
272
+ def replace(range, content); end
273
+ def source_buffer; end
274
+ def transaction; end
275
+ def trigger_policy(event, range: nil, conflict: nil, **arguments); end
276
+ def wrap(range, insert_before, insert_after); end
277
+ extend Parser::Deprecation
278
+ end
279
+ class Parser::Source::TreeRewriter::Action
280
+ def call_enforcer_for_merge(action); end
281
+ def combine(action); end
282
+ def do_combine(action); end
283
+ def fuse_deletions(action, fusible, other_sibblings); end
284
+ def initialize(range, enforcer, insert_before: nil, replacement: nil, insert_after: nil, children: nil); end
285
+ def insert_after; end
286
+ def insert_before; end
287
+ def insertion?; end
288
+ def merge(action); end
289
+ def ordered_replacements; end
290
+ def place_in_hierachy(action); end
291
+ def range; end
292
+ def relationship_with(action); end
293
+ def replacement; end
294
+ def swallow(children); end
295
+ def with(range: nil, children: nil, insert_before: nil, replacement: nil, insert_after: nil); end
296
+ end
297
+ class Parser::Source::Map
298
+ def ==(other); end
299
+ def column; end
300
+ def expression; end
301
+ def first_line; end
302
+ def initialize(expression); end
303
+ def initialize_copy(other); end
304
+ def last_column; end
305
+ def last_line; end
306
+ def line; end
307
+ def node; end
308
+ def node=(node); end
309
+ def to_hash; end
310
+ def update_expression(expression_l); end
311
+ def with(&block); end
312
+ def with_expression(expression_l); end
313
+ end
314
+ class Parser::Source::Map::Operator < Parser::Source::Map
315
+ def initialize(operator, expression); end
316
+ def operator; end
317
+ end
318
+ class Parser::Source::Map::Collection < Parser::Source::Map
319
+ def begin; end
320
+ def end; end
321
+ def initialize(begin_l, end_l, expression_l); end
322
+ end
323
+ class Parser::Source::Map::Constant < Parser::Source::Map
324
+ def double_colon; end
325
+ def initialize(double_colon, name, expression); end
326
+ def name; end
327
+ def operator; end
328
+ def update_operator(operator_l); end
329
+ def with_operator(operator_l); end
330
+ end
331
+ class Parser::Source::Map::Variable < Parser::Source::Map
332
+ def initialize(name_l, expression_l = nil); end
333
+ def name; end
334
+ def operator; end
335
+ def update_operator(operator_l); end
336
+ def with_operator(operator_l); end
337
+ end
338
+ class Parser::Source::Map::Keyword < Parser::Source::Map
339
+ def begin; end
340
+ def end; end
341
+ def initialize(keyword_l, begin_l, end_l, expression_l); end
342
+ def keyword; end
343
+ end
344
+ class Parser::Source::Map::Definition < Parser::Source::Map
345
+ def end; end
346
+ def initialize(keyword_l, operator_l, name_l, end_l); end
347
+ def keyword; end
348
+ def name; end
349
+ def operator; end
350
+ end
351
+ class Parser::Source::Map::Send < Parser::Source::Map
352
+ def begin; end
353
+ def dot; end
354
+ def end; end
355
+ def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
356
+ def operator; end
357
+ def selector; end
358
+ def update_operator(operator_l); end
359
+ def with_operator(operator_l); end
360
+ end
361
+ class Parser::Source::Map::Index < Parser::Source::Map
362
+ def begin; end
363
+ def end; end
364
+ def initialize(begin_l, end_l, expression_l); end
365
+ def operator; end
366
+ def update_operator(operator_l); end
367
+ def with_operator(operator_l); end
368
+ end
369
+ class Parser::Source::Map::Condition < Parser::Source::Map
370
+ def begin; end
371
+ def else; end
372
+ def end; end
373
+ def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
374
+ def keyword; end
375
+ end
376
+ class Parser::Source::Map::Ternary < Parser::Source::Map
377
+ def colon; end
378
+ def initialize(question_l, colon_l, expression_l); end
379
+ def question; end
380
+ end
381
+ class Parser::Source::Map::For < Parser::Source::Map
382
+ def begin; end
383
+ def end; end
384
+ def in; end
385
+ def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
386
+ def keyword; end
387
+ end
388
+ class Parser::Source::Map::RescueBody < Parser::Source::Map
389
+ def assoc; end
390
+ def begin; end
391
+ def initialize(keyword_l, assoc_l, begin_l, expression_l); end
392
+ def keyword; end
393
+ end
394
+ class Parser::Source::Map::Heredoc < Parser::Source::Map
395
+ def heredoc_body; end
396
+ def heredoc_end; end
397
+ def initialize(begin_l, body_l, end_l); end
398
+ end
399
+ class Parser::Source::Map::ObjcKwarg < Parser::Source::Map
400
+ def argument; end
401
+ def initialize(keyword_l, operator_l, argument_l, expression_l); end
402
+ def keyword; end
403
+ def operator; end
404
+ end
405
+ class Parser::SyntaxError < StandardError
406
+ def diagnostic; end
407
+ def initialize(diagnostic); end
408
+ end
409
+ class Parser::ClobberingError < RuntimeError
410
+ end
411
+ class Parser::Diagnostic
412
+ def arguments; end
413
+ def first_line_only(range); end
414
+ def highlights; end
415
+ def initialize(level, reason, arguments, location, highlights = nil); end
416
+ def last_line_only(range); end
417
+ def level; end
418
+ def location; end
419
+ def message; end
420
+ def reason; end
421
+ def render; end
422
+ def render_line(range, ellipsis = nil, range_end = nil); end
423
+ end
424
+ class Parser::Diagnostic::Engine
425
+ def all_errors_are_fatal; end
426
+ def all_errors_are_fatal=(arg0); end
427
+ def consumer; end
428
+ def consumer=(arg0); end
429
+ def ignore?(diagnostic); end
430
+ def ignore_warnings; end
431
+ def ignore_warnings=(arg0); end
432
+ def initialize(consumer = nil); end
433
+ def process(diagnostic); end
434
+ def raise?(diagnostic); end
435
+ end
436
+ class Parser::StaticEnvironment
437
+ def declare(name); end
438
+ def declared?(name); end
439
+ def extend_dynamic; end
440
+ def extend_static; end
441
+ def initialize; end
442
+ def reset; end
443
+ def unextend; end
444
+ end
445
+ class Parser::Lexer
446
+ def advance; end
447
+ def arg_or_cmdarg; end
448
+ def cmdarg; end
449
+ def cmdarg=(arg0); end
450
+ def comments; end
451
+ def comments=(arg0); end
452
+ def cond; end
453
+ def cond=(arg0); end
454
+ def context; end
455
+ def context=(arg0); end
456
+ def dedent_level; end
457
+ def diagnostic(type, reason, arguments = nil, location = nil, highlights = nil); end
458
+ def diagnostics; end
459
+ def diagnostics=(arg0); end
460
+ def emit(type, value = nil, s = nil, e = nil); end
461
+ def emit_comment(s = nil, e = nil); end
462
+ def emit_do(do_block = nil); end
463
+ def emit_table(table, s = nil, e = nil); end
464
+ def encode_escape(ord); end
465
+ def encoding; end
466
+ def eof_codepoint?(point); end
467
+ def force_utf32; end
468
+ def force_utf32=(arg0); end
469
+ def in_kwarg; end
470
+ def in_kwarg=(arg0); end
471
+ def initialize(version); end
472
+ def literal; end
473
+ def next_state_for_literal(literal); end
474
+ def pop_cmdarg; end
475
+ def pop_cond; end
476
+ def pop_literal; end
477
+ def push_cmdarg; end
478
+ def push_cond; end
479
+ def push_literal(*args); end
480
+ def range(s = nil, e = nil); end
481
+ def reset(reset_state = nil); end
482
+ def self._lex_eof_trans; end
483
+ def self._lex_eof_trans=(arg0); end
484
+ def self._lex_from_state_actions; end
485
+ def self._lex_from_state_actions=(arg0); end
486
+ def self._lex_index_offsets; end
487
+ def self._lex_index_offsets=(arg0); end
488
+ def self._lex_indicies; end
489
+ def self._lex_indicies=(arg0); end
490
+ def self._lex_key_spans; end
491
+ def self._lex_key_spans=(arg0); end
492
+ def self._lex_to_state_actions; end
493
+ def self._lex_to_state_actions=(arg0); end
494
+ def self._lex_trans_actions; end
495
+ def self._lex_trans_actions=(arg0); end
496
+ def self._lex_trans_keys; end
497
+ def self._lex_trans_keys=(arg0); end
498
+ def self._lex_trans_targs; end
499
+ def self._lex_trans_targs=(arg0); end
500
+ def self.lex_en_expr_arg; end
501
+ def self.lex_en_expr_arg=(arg0); end
502
+ def self.lex_en_expr_beg; end
503
+ def self.lex_en_expr_beg=(arg0); end
504
+ def self.lex_en_expr_cmdarg; end
505
+ def self.lex_en_expr_cmdarg=(arg0); end
506
+ def self.lex_en_expr_dot; end
507
+ def self.lex_en_expr_dot=(arg0); end
508
+ def self.lex_en_expr_end; end
509
+ def self.lex_en_expr_end=(arg0); end
510
+ def self.lex_en_expr_endarg; end
511
+ def self.lex_en_expr_endarg=(arg0); end
512
+ def self.lex_en_expr_endfn; end
513
+ def self.lex_en_expr_endfn=(arg0); end
514
+ def self.lex_en_expr_fname; end
515
+ def self.lex_en_expr_fname=(arg0); end
516
+ def self.lex_en_expr_labelarg; end
517
+ def self.lex_en_expr_labelarg=(arg0); end
518
+ def self.lex_en_expr_mid; end
519
+ def self.lex_en_expr_mid=(arg0); end
520
+ def self.lex_en_expr_value; end
521
+ def self.lex_en_expr_value=(arg0); end
522
+ def self.lex_en_expr_variable; end
523
+ def self.lex_en_expr_variable=(arg0); end
524
+ def self.lex_en_interp_backslash_delimited; end
525
+ def self.lex_en_interp_backslash_delimited=(arg0); end
526
+ def self.lex_en_interp_backslash_delimited_words; end
527
+ def self.lex_en_interp_backslash_delimited_words=(arg0); end
528
+ def self.lex_en_interp_string; end
529
+ def self.lex_en_interp_string=(arg0); end
530
+ def self.lex_en_interp_words; end
531
+ def self.lex_en_interp_words=(arg0); end
532
+ def self.lex_en_leading_dot; end
533
+ def self.lex_en_leading_dot=(arg0); end
534
+ def self.lex_en_line_begin; end
535
+ def self.lex_en_line_begin=(arg0); end
536
+ def self.lex_en_line_comment; end
537
+ def self.lex_en_line_comment=(arg0); end
538
+ def self.lex_en_plain_backslash_delimited; end
539
+ def self.lex_en_plain_backslash_delimited=(arg0); end
540
+ def self.lex_en_plain_backslash_delimited_words; end
541
+ def self.lex_en_plain_backslash_delimited_words=(arg0); end
542
+ def self.lex_en_plain_string; end
543
+ def self.lex_en_plain_string=(arg0); end
544
+ def self.lex_en_plain_words; end
545
+ def self.lex_en_plain_words=(arg0); end
546
+ def self.lex_en_regexp_modifiers; end
547
+ def self.lex_en_regexp_modifiers=(arg0); end
548
+ def self.lex_error; end
549
+ def self.lex_error=(arg0); end
550
+ def self.lex_start; end
551
+ def self.lex_start=(arg0); end
552
+ def source_buffer; end
553
+ def source_buffer=(source_buffer); end
554
+ def stack_pop; end
555
+ def state; end
556
+ def state=(state); end
557
+ def static_env; end
558
+ def static_env=(arg0); end
559
+ def tok(s = nil, e = nil); end
560
+ def tokens; end
561
+ def tokens=(arg0); end
562
+ def version?(*versions); end
563
+ end
564
+ class Parser::Lexer::Literal
565
+ def backslash_delimited?; end
566
+ def clear_buffer; end
567
+ def coerce_encoding(string); end
568
+ def dedent_level; end
569
+ def delimiter?(delimiter); end
570
+ def emit(token, type, s, e); end
571
+ def emit_start_tok; end
572
+ def end_interp_brace_and_try_closing; end
573
+ def extend_content; end
574
+ def extend_space(ts, te); end
575
+ def extend_string(string, ts, te); end
576
+ def flush_string; end
577
+ def heredoc?; end
578
+ def heredoc_e; end
579
+ def infer_indent_level(line); end
580
+ def initialize(lexer, str_type, delimiter, str_s, heredoc_e = nil, indent = nil, dedent_body = nil, label_allowed = nil); end
581
+ def interpolate?; end
582
+ def munge_escape?(character); end
583
+ def nest_and_try_closing(delimiter, ts, te, lookahead = nil); end
584
+ def plain_heredoc?; end
585
+ def regexp?; end
586
+ def saved_herebody_s; end
587
+ def saved_herebody_s=(arg0); end
588
+ def squiggly_heredoc?; end
589
+ def start_interp_brace; end
590
+ def str_s; end
591
+ def supports_line_continuation_via_slash?; end
592
+ def type; end
593
+ def words?; end
594
+ end
595
+ class Parser::Lexer::StackState
596
+ def active?; end
597
+ def clear; end
598
+ def empty?; end
599
+ def initialize(name); end
600
+ def inspect; end
601
+ def lexpop; end
602
+ def pop; end
603
+ def push(bit); end
604
+ def to_s; end
605
+ end
606
+ class Parser::Lexer::Dedenter
607
+ def dedent(string); end
608
+ def initialize(dedent_level); end
609
+ def interrupt; end
610
+ end
611
+ class Parser::Builders::Default
612
+ def __ENCODING__(__ENCODING__t); end
613
+ def __FILE__(__FILE__t); end
614
+ def __LINE__(__LINE__t); end
615
+ def accessible(node); end
616
+ def alias(alias_t, to, from); end
617
+ def arg(name_t); end
618
+ def arg_expr(expr); end
619
+ def arg_name_collides?(this_name, that_name); end
620
+ def arg_prefix_map(op_t, name_t = nil); end
621
+ def args(begin_t, args, end_t, check_args = nil); end
622
+ def array(begin_t, elements, end_t); end
623
+ def assign(lhs, eql_t, rhs); end
624
+ def assignable(node); end
625
+ def associate(begin_t, pairs, end_t); end
626
+ def attr_asgn(receiver, dot_t, selector_t); end
627
+ def back_ref(token); end
628
+ def begin(begin_t, body, end_t); end
629
+ def begin_body(compound_stmt, rescue_bodies = nil, else_t = nil, else_ = nil, ensure_t = nil, ensure_ = nil); end
630
+ def begin_keyword(begin_t, body, end_t); end
631
+ def binary_op(receiver, operator_t, arg); end
632
+ def binary_op_map(left_e, op_t, right_e); end
633
+ def block(method_call, begin_t, args, body, end_t); end
634
+ def block_map(receiver_l, begin_t, end_t); end
635
+ def block_pass(amper_t, arg); end
636
+ def blockarg(amper_t, name_t); end
637
+ def blockarg_expr(amper_t, expr); end
638
+ def call_lambda(lambda_t); end
639
+ def call_method(receiver, dot_t, selector_t, lparen_t = nil, args = nil, rparen_t = nil); end
640
+ def call_type_for_dot(dot_t); end
641
+ def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
642
+ def character(char_t); end
643
+ def check_condition(cond); end
644
+ def check_duplicate_args(args, map = nil); end
645
+ def collapse_string_parts?(parts); end
646
+ def collection_map(begin_t, parts, end_t); end
647
+ def complex(complex_t); end
648
+ def compstmt(statements); end
649
+ def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
650
+ def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
651
+ def condition_mod(if_true, if_false, cond_t, cond); end
652
+ def const(name_t); end
653
+ def const_fetch(scope, t_colon2, name_t); end
654
+ def const_global(t_colon3, name_t); end
655
+ def const_op_assignable(node); end
656
+ def constant_map(scope, colon2_t, name_t); end
657
+ def cvar(token); end
658
+ def dedent_string(node, dedent_level); end
659
+ def def_class(class_t, name, lt_t, superclass, body, end_t); end
660
+ def def_method(def_t, name_t, args, body, end_t); end
661
+ def def_module(module_t, name, body, end_t); end
662
+ def def_sclass(class_t, lshft_t, expr, body, end_t); end
663
+ def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
664
+ def definition_map(keyword_t, operator_t, name_t, end_t); end
665
+ def delimited_string_map(string_t); end
666
+ def diagnostic(type, reason, arguments, location, highlights = nil); end
667
+ def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
668
+ def emit_file_line_as_literals; end
669
+ def emit_file_line_as_literals=(arg0); end
670
+ def expr_map(loc); end
671
+ def false(false_t); end
672
+ def float(float_t); end
673
+ def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
674
+ def for_map(keyword_t, in_t, begin_t, end_t); end
675
+ def gvar(token); end
676
+ def ident(token); end
677
+ def index(receiver, lbrack_t, indexes, rbrack_t); end
678
+ def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
679
+ def index_map(receiver_e, lbrack_t, rbrack_t); end
680
+ def initialize; end
681
+ def integer(integer_t); end
682
+ def ivar(token); end
683
+ def join_exprs(left_expr, right_expr); end
684
+ def keyword_cmd(type, keyword_t, lparen_t = nil, args = nil, rparen_t = nil); end
685
+ def keyword_map(keyword_t, begin_t, args, end_t); end
686
+ def keyword_mod_map(pre_e, keyword_t, post_e); end
687
+ def kwarg(name_t); end
688
+ def kwarg_map(name_t, value_e = nil); end
689
+ def kwoptarg(name_t, value); end
690
+ def kwrestarg(dstar_t, name_t = nil); end
691
+ def kwsplat(dstar_t, arg); end
692
+ def loc(token); end
693
+ def logical_op(type, lhs, op_t, rhs); end
694
+ def loop(type, keyword_t, cond, do_t, body, end_t); end
695
+ def loop_mod(type, body, keyword_t, cond); end
696
+ def match_op(receiver, match_t, arg); end
697
+ def method_ref(receiver, dot_t, selector_t); end
698
+ def module_definition_map(keyword_t, name_e, operator_t, end_t); end
699
+ def multi_assign(lhs, eql_t, rhs); end
700
+ def multi_lhs(begin_t, items, end_t); end
701
+ def n(type, children, source_map); end
702
+ def n0(type, source_map); end
703
+ def nil(nil_t); end
704
+ def not_op(not_t, begin_t = nil, receiver = nil, end_t = nil); end
705
+ def nth_ref(token); end
706
+ def numeric(kind, token); end
707
+ def objc_kwarg(kwname_t, assoc_t, name_t); end
708
+ def objc_restarg(star_t, name = nil); end
709
+ def objc_varargs(pair, rest_of_varargs); end
710
+ def op_assign(lhs, op_t, rhs); end
711
+ def optarg(name_t, eql_t, value); end
712
+ def pair(key, assoc_t, value); end
713
+ def pair_keyword(key_t, value); end
714
+ def pair_keyword_map(key_t, value_e); end
715
+ def pair_list_18(list); end
716
+ def pair_quoted(begin_t, parts, end_t, value); end
717
+ def pair_quoted_map(begin_t, end_t, value_e); end
718
+ def parser; end
719
+ def parser=(arg0); end
720
+ def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
721
+ def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
722
+ def prefix_string_map(symbol); end
723
+ def procarg0(arg); end
724
+ def range_exclusive(lhs, dot3_t, rhs); end
725
+ def range_inclusive(lhs, dot2_t, rhs); end
726
+ def range_map(start_e, op_t, end_e); end
727
+ def rational(rational_t); end
728
+ def regexp_compose(begin_t, parts, end_t, options); end
729
+ def regexp_map(begin_t, end_t, options_e); end
730
+ def regexp_options(regopt_t); end
731
+ def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
732
+ def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
733
+ def restarg(star_t, name_t = nil); end
734
+ def restarg_expr(star_t, expr = nil); end
735
+ def self(token); end
736
+ def self.emit_encoding; end
737
+ def self.emit_encoding=(arg0); end
738
+ def self.emit_index; end
739
+ def self.emit_index=(arg0); end
740
+ def self.emit_lambda; end
741
+ def self.emit_lambda=(arg0); end
742
+ def self.emit_procarg0; end
743
+ def self.emit_procarg0=(arg0); end
744
+ def self.modernize; end
745
+ def send_binary_op_map(lhs_e, selector_t, rhs_e); end
746
+ def send_index_map(receiver_e, lbrack_t, rbrack_t); end
747
+ def send_map(receiver_e, dot_t, selector_t, begin_t = nil, args = nil, end_t = nil); end
748
+ def send_unary_op_map(selector_t, arg_e); end
749
+ def shadowarg(name_t); end
750
+ def splat(star_t, arg = nil); end
751
+ def static_regexp(parts, options); end
752
+ def static_regexp_node(node); end
753
+ def static_string(nodes); end
754
+ def string(string_t); end
755
+ def string_compose(begin_t, parts, end_t); end
756
+ def string_internal(string_t); end
757
+ def string_map(begin_t, parts, end_t); end
758
+ def string_value(token); end
759
+ def symbol(symbol_t); end
760
+ def symbol_compose(begin_t, parts, end_t); end
761
+ def symbol_internal(symbol_t); end
762
+ def symbols_compose(begin_t, parts, end_t); end
763
+ def ternary(cond, question_t, if_true, colon_t, if_false); end
764
+ def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
765
+ def token_map(token); end
766
+ def true(true_t); end
767
+ def unary_num(unary_t, numeric); end
768
+ def unary_op(op_t, receiver); end
769
+ def unary_op_map(op_t, arg_e = nil); end
770
+ def undef_method(undef_t, names); end
771
+ def unquoted_map(token); end
772
+ def value(token); end
773
+ def var_send_map(variable_e); end
774
+ def variable_map(name_t); end
775
+ def when(when_t, patterns, then_t, body); end
776
+ def word(parts); end
777
+ def words_compose(begin_t, parts, end_t); end
778
+ def xstring_compose(begin_t, parts, end_t); end
779
+ end
780
+ class Parser::Context
781
+ def class_definition_allowed?; end
782
+ def dynamic_const_definition_allowed?; end
783
+ def in_class?; end
784
+ def indirectly_in_def?; end
785
+ def initialize; end
786
+ def module_definition_allowed?; end
787
+ def pop; end
788
+ def push(state); end
789
+ def reset; end
790
+ def stack; end
791
+ end
792
+ class Parser::Base < Racc::Parser
793
+ def builder; end
794
+ def check_kwarg_name(name_t); end
795
+ def context; end
796
+ def diagnostic(level, reason, arguments, location_t, highlights_ts = nil); end
797
+ def diagnostics; end
798
+ def initialize(builder = nil); end
799
+ def next_token; end
800
+ def on_error(error_token_id, error_value, value_stack); end
801
+ def parse(source_buffer); end
802
+ def parse_with_comments(source_buffer); end
803
+ def reset; end
804
+ def self.default_parser; end
805
+ def self.parse(string, file = nil, line = nil); end
806
+ def self.parse_file(filename); end
807
+ def self.parse_file_with_comments(filename); end
808
+ def self.parse_with_comments(string, file = nil, line = nil); end
809
+ def self.setup_source_buffer(file, line, string, encoding); end
810
+ def source_buffer; end
811
+ def static_env; end
812
+ def tokenize(source_buffer, recover = nil); end
813
+ end
814
+ class Parser::Rewriter < Parser::AST::Processor
815
+ def assignment?(node); end
816
+ def initialize(*arg0); end
817
+ def insert_after(range, content); end
818
+ def insert_before(range, content); end
819
+ def remove(range); end
820
+ def replace(range, content); end
821
+ def rewrite(source_buffer, ast); end
822
+ def wrap(range, before, after); end
823
+ extend Parser::Deprecation
824
+ end
825
+ class Parser::TreeRewriter < Parser::AST::Processor
826
+ def assignment?(node); end
827
+ def insert_after(range, content); end
828
+ def insert_before(range, content); end
829
+ def remove(range); end
830
+ def replace(range, content); end
831
+ def rewrite(source_buffer, ast, **policy); end
832
+ def wrap(range, before, after); end
833
+ end
834
+ module Parser::Builders
835
+ end