bhook 0.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (51) hide show
  1. checksums.yaml +7 -0
  2. data/.rspec +3 -0
  3. data/.rubocop.yml +3 -0
  4. data/.ruby-version +1 -0
  5. data/Gemfile +6 -0
  6. data/Gemfile.lock +82 -0
  7. data/LICENSE.txt +21 -0
  8. data/README.md +27 -0
  9. data/Rakefile +13 -0
  10. data/bin/bhook +11 -0
  11. data/lib/bhook/args_parser.rb +55 -0
  12. data/lib/bhook/converter/html.rb +51 -0
  13. data/lib/bhook/directory.rb +62 -0
  14. data/lib/bhook/md_file.rb +50 -0
  15. data/lib/bhook/theme/_after_h1.erb +7 -0
  16. data/lib/bhook/theme/page.erb +71 -0
  17. data/lib/bhook/version.rb +6 -0
  18. data/lib/bhook/workspace.rb +45 -0
  19. data/lib/bhook.rb +22 -0
  20. data/sorbet/config +3 -0
  21. data/sorbet/rbi/gems/ast.rbi +49 -0
  22. data/sorbet/rbi/gems/bhook.rbi +15 -0
  23. data/sorbet/rbi/gems/git.rbi +531 -0
  24. data/sorbet/rbi/gems/kramdown.rbi +255 -0
  25. data/sorbet/rbi/gems/listen.rbi +304 -0
  26. data/sorbet/rbi/gems/parallel.rbi +83 -0
  27. data/sorbet/rbi/gems/parser.rbi +1440 -0
  28. data/sorbet/rbi/gems/rainbow.rbi +122 -0
  29. data/sorbet/rbi/gems/rake.rbi +644 -0
  30. data/sorbet/rbi/gems/rchardet.rbi +181 -0
  31. data/sorbet/rbi/gems/regexp_parser.rbi +929 -0
  32. data/sorbet/rbi/gems/rexml.rbi +599 -0
  33. data/sorbet/rbi/gems/rspec-core.rbi +1898 -0
  34. data/sorbet/rbi/gems/rspec-expectations.rbi +1171 -0
  35. data/sorbet/rbi/gems/rspec-mocks.rbi +1094 -0
  36. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  37. data/sorbet/rbi/gems/rspec.rbi +15 -0
  38. data/sorbet/rbi/gems/rubocop-ast.rbi +1385 -0
  39. data/sorbet/rbi/gems/rubocop-rake.rbi +85 -0
  40. data/sorbet/rbi/gems/rubocop-rspec.rbi +1044 -0
  41. data/sorbet/rbi/gems/rubocop.rbi +8593 -0
  42. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  43. data/sorbet/rbi/gems/unicode-display_width.rbi +20 -0
  44. data/sorbet/rbi/hidden-definitions/errors.txt +4944 -0
  45. data/sorbet/rbi/hidden-definitions/hidden.rbi +10044 -0
  46. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
  47. data/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +645 -0
  48. data/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +24 -0
  49. data/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi +12 -0
  50. data/sorbet/rbi/todo.rbi +7 -0
  51. metadata +235 -0
@@ -0,0 +1,1440 @@
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/parser/all/parser.rbi
9
+ #
10
+ # parser-3.1.0.0
11
+
12
+ module Parser
13
+ end
14
+ module Parser::Messages
15
+ def self.compile(reason, arguments); end
16
+ end
17
+ module Parser::Deprecation
18
+ def warn_of_deprecation; end
19
+ def warned_of_deprecation=(arg0); end
20
+ end
21
+ module Parser::AST
22
+ end
23
+ class Parser::AST::Node < AST::Node
24
+ def assign_properties(properties); end
25
+ def loc; end
26
+ def location; end
27
+ end
28
+ class Parser::AST::Processor < AST::Processor
29
+ def on_alias(node); end
30
+ def on_and(node); end
31
+ def on_and_asgn(node); end
32
+ def on_arg(node); end
33
+ def on_arg_expr(node); end
34
+ def on_args(node); end
35
+ def on_argument(node); end
36
+ def on_array(node); end
37
+ def on_array_pattern(node); end
38
+ def on_array_pattern_with_tail(node); end
39
+ def on_back_ref(node); end
40
+ def on_begin(node); end
41
+ def on_block(node); end
42
+ def on_block_pass(node); end
43
+ def on_blockarg(node); end
44
+ def on_blockarg_expr(node); end
45
+ def on_break(node); end
46
+ def on_case(node); end
47
+ def on_case_match(node); end
48
+ def on_casgn(node); end
49
+ def on_class(node); end
50
+ def on_const(node); end
51
+ def on_const_pattern(node); end
52
+ def on_csend(node); end
53
+ def on_cvar(node); end
54
+ def on_cvasgn(node); end
55
+ def on_def(node); end
56
+ def on_defined?(node); end
57
+ def on_defs(node); end
58
+ def on_dstr(node); end
59
+ def on_dsym(node); end
60
+ def on_eflipflop(node); end
61
+ def on_empty_else(node); end
62
+ def on_ensure(node); end
63
+ def on_erange(node); end
64
+ def on_find_pattern(node); end
65
+ def on_for(node); end
66
+ def on_forward_arg(node); end
67
+ def on_gvar(node); end
68
+ def on_gvasgn(node); end
69
+ def on_hash(node); end
70
+ def on_hash_pattern(node); end
71
+ def on_if(node); end
72
+ def on_if_guard(node); end
73
+ def on_iflipflop(node); end
74
+ def on_in_match(node); end
75
+ def on_in_pattern(node); end
76
+ def on_index(node); end
77
+ def on_indexasgn(node); end
78
+ def on_irange(node); end
79
+ def on_ivar(node); end
80
+ def on_ivasgn(node); end
81
+ def on_kwarg(node); end
82
+ def on_kwargs(node); end
83
+ def on_kwbegin(node); end
84
+ def on_kwoptarg(node); end
85
+ def on_kwrestarg(node); end
86
+ def on_kwsplat(node); end
87
+ def on_lambda(node); end
88
+ def on_lvar(node); end
89
+ def on_lvasgn(node); end
90
+ def on_masgn(node); end
91
+ def on_match_alt(node); end
92
+ def on_match_as(node); end
93
+ def on_match_current_line(node); end
94
+ def on_match_pattern(node); end
95
+ def on_match_pattern_p(node); end
96
+ def on_match_rest(node); end
97
+ def on_match_var(node); end
98
+ def on_match_with_lvasgn(node); end
99
+ def on_mlhs(node); end
100
+ def on_module(node); end
101
+ def on_next(node); end
102
+ def on_not(node); end
103
+ def on_nth_ref(node); end
104
+ def on_numblock(node); end
105
+ def on_op_asgn(node); end
106
+ def on_optarg(node); end
107
+ def on_or(node); end
108
+ def on_or_asgn(node); end
109
+ def on_pair(node); end
110
+ def on_pin(node); end
111
+ def on_postexe(node); end
112
+ def on_preexe(node); end
113
+ def on_procarg0(node); end
114
+ def on_redo(node); end
115
+ def on_regexp(node); end
116
+ def on_resbody(node); end
117
+ def on_rescue(node); end
118
+ def on_restarg(node); end
119
+ def on_restarg_expr(node); end
120
+ def on_retry(node); end
121
+ def on_return(node); end
122
+ def on_sclass(node); end
123
+ def on_send(node); end
124
+ def on_shadowarg(node); end
125
+ def on_splat(node); end
126
+ def on_super(node); end
127
+ def on_undef(node); end
128
+ def on_unless_guard(node); end
129
+ def on_until(node); end
130
+ def on_until_post(node); end
131
+ def on_var(node); end
132
+ def on_vasgn(node); end
133
+ def on_when(node); end
134
+ def on_while(node); end
135
+ def on_while_post(node); end
136
+ def on_xstr(node); end
137
+ def on_yield(node); end
138
+ def process_argument_node(node); end
139
+ def process_regular_node(node); end
140
+ def process_var_asgn_node(node); end
141
+ def process_variable_node(node); end
142
+ end
143
+ module Parser::Meta
144
+ end
145
+ module Parser::Source
146
+ end
147
+ class Parser::Source::Buffer
148
+ def bsearch(line_begins, position); end
149
+ def column_for_position(position); end
150
+ def decompose_position(position); end
151
+ def first_line; end
152
+ def freeze; end
153
+ def initialize(name, first_line = nil, source: nil); end
154
+ def inspect; end
155
+ def last_line; end
156
+ def line_begins; end
157
+ def line_for_position(position); end
158
+ def line_index_for_position(position); end
159
+ def line_range(lineno); end
160
+ def name; end
161
+ def raw_source=(input); end
162
+ def read; end
163
+ def self.recognize_encoding(string); end
164
+ def self.reencode_string(input); end
165
+ def slice(range); end
166
+ def source; end
167
+ def source=(input); end
168
+ def source_line(lineno); end
169
+ def source_lines; end
170
+ def source_range; end
171
+ end
172
+ class Parser::Source::Range
173
+ def <=>(other); end
174
+ def adjust(begin_pos: nil, end_pos: nil); end
175
+ def begin; end
176
+ def begin_pos; end
177
+ def column; end
178
+ def column_range; end
179
+ def contained?(other); end
180
+ def contains?(other); end
181
+ def crossing?(other); end
182
+ def disjoint?(other); end
183
+ def empty?; end
184
+ def end; end
185
+ def end_pos; end
186
+ def eql?(arg0); end
187
+ def first_line; end
188
+ def hash; end
189
+ def initialize(source_buffer, begin_pos, end_pos); end
190
+ def inspect; end
191
+ def intersect(other); end
192
+ def is?(*what); end
193
+ def join(other); end
194
+ def last_column; end
195
+ def last_line; end
196
+ def length; end
197
+ def line; end
198
+ def overlaps?(other); end
199
+ def resize(new_size); end
200
+ def size; end
201
+ def source; end
202
+ def source_buffer; end
203
+ def source_line; end
204
+ def to_a; end
205
+ def to_range; end
206
+ def to_s; end
207
+ def with(begin_pos: nil, end_pos: nil); end
208
+ include Comparable
209
+ end
210
+ class Parser::Source::Comment
211
+ def ==(other); end
212
+ def document?; end
213
+ def initialize(range); end
214
+ def inline?; end
215
+ def inspect; end
216
+ def loc; end
217
+ def location; end
218
+ def self.associate(ast, comments); end
219
+ def self.associate_by_identity(ast, comments); end
220
+ def self.associate_locations(ast, comments); end
221
+ def text; end
222
+ def type; end
223
+ end
224
+ class Parser::Source::Comment::Associator
225
+ def advance_comment; end
226
+ def advance_through_directives; end
227
+ def associate; end
228
+ def associate_and_advance_comment(node); end
229
+ def associate_by_identity; end
230
+ def associate_locations; end
231
+ def children_in_source_order(node); end
232
+ def current_comment_before?(node); end
233
+ def current_comment_before_end?(node); end
234
+ def current_comment_decorates?(node); end
235
+ def do_associate; end
236
+ def initialize(ast, comments); end
237
+ def process_leading_comments(node); end
238
+ def process_trailing_comments(node); end
239
+ def skip_directives; end
240
+ def skip_directives=(arg0); end
241
+ def visit(node); end
242
+ end
243
+ class Parser::Source::Rewriter
244
+ def active_clobber; end
245
+ def active_clobber=(value); end
246
+ def active_insertions; end
247
+ def active_insertions=(value); end
248
+ def active_queue; end
249
+ def adjacent?(range1, range2); end
250
+ def adjacent_insertion_mask(range); end
251
+ def adjacent_insertions?(range); end
252
+ def adjacent_position_mask(range); end
253
+ def adjacent_updates?(range); end
254
+ def append(action); end
255
+ def can_merge?(action, existing); end
256
+ def clobbered_insertion?(insertion); end
257
+ def clobbered_position_mask(range); end
258
+ def diagnostics; end
259
+ def in_transaction?; end
260
+ def initialize(source_buffer); end
261
+ def insert_after(range, content); end
262
+ def insert_after_multi(range, content); end
263
+ def insert_before(range, content); end
264
+ def insert_before_multi(range, content); end
265
+ def merge_actions!(action, existing); end
266
+ def merge_actions(action, existing); end
267
+ def merge_replacements(actions); end
268
+ def process; end
269
+ def raise_clobber_error(action, existing); end
270
+ def record_insertion(range); end
271
+ def record_replace(range); end
272
+ def remove(range); end
273
+ def replace(range, content); end
274
+ def replace_actions(old, updated); end
275
+ def replace_compatible_with_insertion?(replace, insertion); end
276
+ def source_buffer; end
277
+ def transaction; end
278
+ def wrap(range, before, after); end
279
+ extend Parser::Deprecation
280
+ end
281
+ class Parser::Source::Rewriter::Action
282
+ def <=>(other); end
283
+ def allow_multiple_insertions; end
284
+ def allow_multiple_insertions?; end
285
+ def initialize(range, replacement = nil, allow_multiple_insertions = nil, order = nil); end
286
+ def order; end
287
+ def range; end
288
+ def replacement; end
289
+ def to_s; end
290
+ include Comparable
291
+ end
292
+ class Parser::Source::TreeRewriter
293
+ def action_root; end
294
+ def action_summary; end
295
+ def as_nested_actions; end
296
+ def as_replacements; end
297
+ def check_policy_validity; end
298
+ def check_range_validity(range); end
299
+ def combine(range, attributes); end
300
+ def diagnostics; end
301
+ def empty?; end
302
+ def enforce_policy(event); end
303
+ def import!(foreign_rewriter, offset: nil); end
304
+ def in_transaction?; end
305
+ def initialize(source_buffer, crossing_deletions: nil, different_replacements: nil, swallowed_insertions: nil); end
306
+ def insert_after(range, content); end
307
+ def insert_after_multi(range, text); end
308
+ def insert_before(range, content); end
309
+ def insert_before_multi(range, text); end
310
+ def inspect; end
311
+ def merge!(with); end
312
+ def merge(with); end
313
+ def process; end
314
+ def remove(range); end
315
+ def replace(range, content); end
316
+ def source_buffer; end
317
+ def transaction; end
318
+ def trigger_policy(event, range: nil, conflict: nil, **arguments); end
319
+ def wrap(range, insert_before, insert_after); end
320
+ extend Parser::Deprecation
321
+ end
322
+ class Parser::Source::TreeRewriter::Action
323
+ def analyse_hierarchy(action); end
324
+ def bsearch_child_index(from = nil); end
325
+ def call_enforcer_for_merge(action); end
326
+ def check_fusible(action, *fusible); end
327
+ def children; end
328
+ def combine(action); end
329
+ def combine_children(more_children); end
330
+ def contract; end
331
+ def do_combine(action); end
332
+ def empty?; end
333
+ def fuse_deletions(action, fusible, other_sibblings); end
334
+ def initialize(range, enforcer, insert_before: nil, replacement: nil, insert_after: nil, children: nil); end
335
+ def insert_after; end
336
+ def insert_before; end
337
+ def insertion?; end
338
+ def merge(action); end
339
+ def moved(source_buffer, offset); end
340
+ def nested_actions; end
341
+ def ordered_replacements; end
342
+ def place_in_hierarchy(action); end
343
+ def range; end
344
+ def replacement; end
345
+ def swallow(children); end
346
+ def with(range: nil, enforcer: nil, children: nil, insert_before: nil, replacement: nil, insert_after: nil); end
347
+ end
348
+ class Parser::Source::Map
349
+ def ==(other); end
350
+ def column; end
351
+ def expression; end
352
+ def first_line; end
353
+ def initialize(expression); end
354
+ def initialize_copy(other); end
355
+ def last_column; end
356
+ def last_line; end
357
+ def line; end
358
+ def node; end
359
+ def node=(node); end
360
+ def to_hash; end
361
+ def update_expression(expression_l); end
362
+ def with(&block); end
363
+ def with_expression(expression_l); end
364
+ end
365
+ class Parser::Source::Map::Operator < Parser::Source::Map
366
+ def initialize(operator, expression); end
367
+ def operator; end
368
+ end
369
+ class Parser::Source::Map::Collection < Parser::Source::Map
370
+ def begin; end
371
+ def end; end
372
+ def initialize(begin_l, end_l, expression_l); end
373
+ end
374
+ class Parser::Source::Map::Constant < Parser::Source::Map
375
+ def double_colon; end
376
+ def initialize(double_colon, name, expression); end
377
+ def name; end
378
+ def operator; end
379
+ def update_operator(operator_l); end
380
+ def with_operator(operator_l); end
381
+ end
382
+ class Parser::Source::Map::Variable < Parser::Source::Map
383
+ def initialize(name_l, expression_l = nil); end
384
+ def name; end
385
+ def operator; end
386
+ def update_operator(operator_l); end
387
+ def with_operator(operator_l); end
388
+ end
389
+ class Parser::Source::Map::Keyword < Parser::Source::Map
390
+ def begin; end
391
+ def end; end
392
+ def initialize(keyword_l, begin_l, end_l, expression_l); end
393
+ def keyword; end
394
+ end
395
+ class Parser::Source::Map::Definition < Parser::Source::Map
396
+ def end; end
397
+ def initialize(keyword_l, operator_l, name_l, end_l); end
398
+ def keyword; end
399
+ def name; end
400
+ def operator; end
401
+ end
402
+ class Parser::Source::Map::MethodDefinition < Parser::Source::Map
403
+ def assignment; end
404
+ def end; end
405
+ def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end
406
+ def keyword; end
407
+ def name; end
408
+ def operator; end
409
+ end
410
+ class Parser::Source::Map::Send < Parser::Source::Map
411
+ def begin; end
412
+ def dot; end
413
+ def end; end
414
+ def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
415
+ def operator; end
416
+ def selector; end
417
+ def update_operator(operator_l); end
418
+ def with_operator(operator_l); end
419
+ end
420
+ class Parser::Source::Map::Index < Parser::Source::Map
421
+ def begin; end
422
+ def end; end
423
+ def initialize(begin_l, end_l, expression_l); end
424
+ def operator; end
425
+ def update_operator(operator_l); end
426
+ def with_operator(operator_l); end
427
+ end
428
+ class Parser::Source::Map::Condition < Parser::Source::Map
429
+ def begin; end
430
+ def else; end
431
+ def end; end
432
+ def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
433
+ def keyword; end
434
+ end
435
+ class Parser::Source::Map::Ternary < Parser::Source::Map
436
+ def colon; end
437
+ def initialize(question_l, colon_l, expression_l); end
438
+ def question; end
439
+ end
440
+ class Parser::Source::Map::For < Parser::Source::Map
441
+ def begin; end
442
+ def end; end
443
+ def in; end
444
+ def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
445
+ def keyword; end
446
+ end
447
+ class Parser::Source::Map::RescueBody < Parser::Source::Map
448
+ def assoc; end
449
+ def begin; end
450
+ def initialize(keyword_l, assoc_l, begin_l, expression_l); end
451
+ def keyword; end
452
+ end
453
+ class Parser::Source::Map::Heredoc < Parser::Source::Map
454
+ def heredoc_body; end
455
+ def heredoc_end; end
456
+ def initialize(begin_l, body_l, end_l); end
457
+ end
458
+ class Parser::Source::Map::ObjcKwarg < Parser::Source::Map
459
+ def argument; end
460
+ def initialize(keyword_l, operator_l, argument_l, expression_l); end
461
+ def keyword; end
462
+ def operator; end
463
+ end
464
+ class Parser::SyntaxError < StandardError
465
+ def diagnostic; end
466
+ def initialize(diagnostic); end
467
+ end
468
+ class Parser::ClobberingError < RuntimeError
469
+ end
470
+ class Parser::Diagnostic
471
+ def arguments; end
472
+ def first_line_only(range); end
473
+ def highlights; end
474
+ def initialize(level, reason, arguments, location, highlights = nil); end
475
+ def last_line_only(range); end
476
+ def level; end
477
+ def location; end
478
+ def message; end
479
+ def reason; end
480
+ def render; end
481
+ def render_line(range, ellipsis = nil, range_end = nil); end
482
+ end
483
+ class Parser::Diagnostic::Engine
484
+ def all_errors_are_fatal; end
485
+ def all_errors_are_fatal=(arg0); end
486
+ def consumer; end
487
+ def consumer=(arg0); end
488
+ def ignore?(diagnostic); end
489
+ def ignore_warnings; end
490
+ def ignore_warnings=(arg0); end
491
+ def initialize(consumer = nil); end
492
+ def process(diagnostic); end
493
+ def raise?(diagnostic); end
494
+ end
495
+ class Parser::StaticEnvironment
496
+ def declare(name); end
497
+ def declare_anonymous_blockarg; end
498
+ def declare_forward_args; end
499
+ def declared?(name); end
500
+ def declared_anonymous_blockarg?; end
501
+ def declared_forward_args?; end
502
+ def empty?; end
503
+ def extend_dynamic; end
504
+ def extend_static; end
505
+ def initialize; end
506
+ def reset; end
507
+ def unextend; end
508
+ end
509
+ class Parser::Lexer
510
+ def advance; end
511
+ def arg_or_cmdarg(cmd_state); end
512
+ def cmdarg; end
513
+ def cmdarg=(arg0); end
514
+ def cmdarg_stack; end
515
+ def command_start; end
516
+ def command_start=(arg0); end
517
+ def comments; end
518
+ def comments=(arg0); end
519
+ def cond; end
520
+ def cond=(arg0); end
521
+ def cond_stack; end
522
+ def context; end
523
+ def context=(arg0); end
524
+ def dedent_level; end
525
+ def diagnostic(type, reason, arguments = nil, location = nil, highlights = nil); end
526
+ def diagnostics; end
527
+ def diagnostics=(arg0); end
528
+ def emit(type, value = nil, s = nil, e = nil); end
529
+ def emit_comment(s = nil, e = nil); end
530
+ def emit_do(do_block = nil); end
531
+ def emit_table(table, s = nil, e = nil); end
532
+ def encode_escape(ord); end
533
+ def encoding; end
534
+ def eof_codepoint?(point); end
535
+ def force_utf32; end
536
+ def force_utf32=(arg0); end
537
+ def initialize(version); end
538
+ def lambda_stack; end
539
+ def literal; end
540
+ def next_state_for_literal(literal); end
541
+ def paren_nest; end
542
+ def pop_cmdarg; end
543
+ def pop_cond; end
544
+ def pop_literal; end
545
+ def push_cmdarg; end
546
+ def push_cond; end
547
+ def push_literal(*args); end
548
+ def range(s = nil, e = nil); end
549
+ def reset(reset_state = nil); end
550
+ def self._lex_eof_trans; end
551
+ def self._lex_eof_trans=(arg0); end
552
+ def self._lex_from_state_actions; end
553
+ def self._lex_from_state_actions=(arg0); end
554
+ def self._lex_index_offsets; end
555
+ def self._lex_index_offsets=(arg0); end
556
+ def self._lex_indicies; end
557
+ def self._lex_indicies=(arg0); end
558
+ def self._lex_key_spans; end
559
+ def self._lex_key_spans=(arg0); end
560
+ def self._lex_to_state_actions; end
561
+ def self._lex_to_state_actions=(arg0); end
562
+ def self._lex_trans_actions; end
563
+ def self._lex_trans_actions=(arg0); end
564
+ def self._lex_trans_keys; end
565
+ def self._lex_trans_keys=(arg0); end
566
+ def self._lex_trans_targs; end
567
+ def self._lex_trans_targs=(arg0); end
568
+ def self.lex_en_expr_arg; end
569
+ def self.lex_en_expr_arg=(arg0); end
570
+ def self.lex_en_expr_beg; end
571
+ def self.lex_en_expr_beg=(arg0); end
572
+ def self.lex_en_expr_cmdarg; end
573
+ def self.lex_en_expr_cmdarg=(arg0); end
574
+ def self.lex_en_expr_dot; end
575
+ def self.lex_en_expr_dot=(arg0); end
576
+ def self.lex_en_expr_end; end
577
+ def self.lex_en_expr_end=(arg0); end
578
+ def self.lex_en_expr_endarg; end
579
+ def self.lex_en_expr_endarg=(arg0); end
580
+ def self.lex_en_expr_endfn; end
581
+ def self.lex_en_expr_endfn=(arg0); end
582
+ def self.lex_en_expr_fname; end
583
+ def self.lex_en_expr_fname=(arg0); end
584
+ def self.lex_en_expr_labelarg; end
585
+ def self.lex_en_expr_labelarg=(arg0); end
586
+ def self.lex_en_expr_mid; end
587
+ def self.lex_en_expr_mid=(arg0); end
588
+ def self.lex_en_expr_value; end
589
+ def self.lex_en_expr_value=(arg0); end
590
+ def self.lex_en_expr_variable; end
591
+ def self.lex_en_expr_variable=(arg0); end
592
+ def self.lex_en_interp_backslash_delimited; end
593
+ def self.lex_en_interp_backslash_delimited=(arg0); end
594
+ def self.lex_en_interp_backslash_delimited_words; end
595
+ def self.lex_en_interp_backslash_delimited_words=(arg0); end
596
+ def self.lex_en_interp_string; end
597
+ def self.lex_en_interp_string=(arg0); end
598
+ def self.lex_en_interp_words; end
599
+ def self.lex_en_interp_words=(arg0); end
600
+ def self.lex_en_leading_dot; end
601
+ def self.lex_en_leading_dot=(arg0); end
602
+ def self.lex_en_line_begin; end
603
+ def self.lex_en_line_begin=(arg0); end
604
+ def self.lex_en_line_comment; end
605
+ def self.lex_en_line_comment=(arg0); end
606
+ def self.lex_en_plain_backslash_delimited; end
607
+ def self.lex_en_plain_backslash_delimited=(arg0); end
608
+ def self.lex_en_plain_backslash_delimited_words; end
609
+ def self.lex_en_plain_backslash_delimited_words=(arg0); end
610
+ def self.lex_en_plain_string; end
611
+ def self.lex_en_plain_string=(arg0); end
612
+ def self.lex_en_plain_words; end
613
+ def self.lex_en_plain_words=(arg0); end
614
+ def self.lex_en_regexp_modifiers; end
615
+ def self.lex_en_regexp_modifiers=(arg0); end
616
+ def self.lex_error; end
617
+ def self.lex_error=(arg0); end
618
+ def self.lex_start; end
619
+ def self.lex_start=(arg0); end
620
+ def source_buffer; end
621
+ def source_buffer=(source_buffer); end
622
+ def stack_pop; end
623
+ def state; end
624
+ def state=(state); end
625
+ def static_env; end
626
+ def static_env=(arg0); end
627
+ def tok(s = nil, e = nil); end
628
+ def tokens; end
629
+ def tokens=(arg0); end
630
+ def version?(*versions); end
631
+ end
632
+ class Parser::Lexer::Literal
633
+ def backslash_delimited?; end
634
+ def clear_buffer; end
635
+ def coerce_encoding(string); end
636
+ def dedent_level; end
637
+ def delimiter?(delimiter); end
638
+ def emit(token, type, s, e); end
639
+ def emit_start_tok; end
640
+ def end_interp_brace_and_try_closing; end
641
+ def extend_content; end
642
+ def extend_space(ts, te); end
643
+ def extend_string(string, ts, te); end
644
+ def flush_string; end
645
+ def heredoc?; end
646
+ def heredoc_e; end
647
+ def infer_indent_level(line); end
648
+ def initialize(lexer, str_type, delimiter, str_s, heredoc_e = nil, indent = nil, dedent_body = nil, label_allowed = nil); end
649
+ def interpolate?; end
650
+ def munge_escape?(character); end
651
+ def nest_and_try_closing(delimiter, ts, te, lookahead = nil); end
652
+ def plain_heredoc?; end
653
+ def regexp?; end
654
+ def saved_herebody_s; end
655
+ def saved_herebody_s=(arg0); end
656
+ def squiggly_heredoc?; end
657
+ def start_interp_brace; end
658
+ def str_s; end
659
+ def supports_line_continuation_via_slash?; end
660
+ def type; end
661
+ def words?; end
662
+ end
663
+ class Parser::Lexer::StackState
664
+ def active?; end
665
+ def clear; end
666
+ def empty?; end
667
+ def initialize(name); end
668
+ def inspect; end
669
+ def lexpop; end
670
+ def pop; end
671
+ def push(bit); end
672
+ def to_s; end
673
+ end
674
+ class Parser::Lexer::Dedenter
675
+ def dedent(string); end
676
+ def initialize(dedent_level); end
677
+ def interrupt; end
678
+ end
679
+ class Parser::Builders::Default
680
+ def __ENCODING__(__ENCODING__t); end
681
+ def __FILE__(__FILE__t); end
682
+ def __LINE__(__LINE__t); end
683
+ def accessible(node); end
684
+ def alias(alias_t, to, from); end
685
+ def arg(name_t); end
686
+ def arg_expr(expr); end
687
+ def arg_name_collides?(this_name, that_name); end
688
+ def arg_prefix_map(op_t, name_t = nil); end
689
+ def args(begin_t, args, end_t, check_args = nil); end
690
+ def array(begin_t, elements, end_t); end
691
+ def array_pattern(lbrack_t, elements, rbrack_t); end
692
+ def assign(lhs, eql_t, rhs); end
693
+ def assignable(node); end
694
+ def associate(begin_t, pairs, end_t); end
695
+ def attr_asgn(receiver, dot_t, selector_t); end
696
+ def back_ref(token); end
697
+ def begin(begin_t, body, end_t); end
698
+ def begin_body(compound_stmt, rescue_bodies = nil, else_t = nil, else_ = nil, ensure_t = nil, ensure_ = nil); end
699
+ def begin_keyword(begin_t, body, end_t); end
700
+ def binary_op(receiver, operator_t, arg); end
701
+ def binary_op_map(left_e, op_t, right_e); end
702
+ def block(method_call, begin_t, args, body, end_t); end
703
+ def block_map(receiver_l, begin_t, end_t); end
704
+ def block_pass(amper_t, arg); end
705
+ def blockarg(amper_t, name_t); end
706
+ def blockarg_expr(amper_t, expr); end
707
+ def call_lambda(lambda_t); end
708
+ def call_method(receiver, dot_t, selector_t, lparen_t = nil, args = nil, rparen_t = nil); end
709
+ def call_type_for_dot(dot_t); end
710
+ def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
711
+ def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
712
+ def character(char_t); end
713
+ def check_assignment_to_numparam(name, loc); end
714
+ def check_condition(cond); end
715
+ def check_duplicate_arg(this_arg, map = nil); end
716
+ def check_duplicate_args(args, map = nil); end
717
+ def check_duplicate_pattern_key(name, loc); end
718
+ def check_duplicate_pattern_variable(name, loc); end
719
+ def check_lvar_name(name, loc); end
720
+ def check_reserved_for_numparam(name, loc); end
721
+ def collapse_string_parts?(parts); end
722
+ def collection_map(begin_t, parts, end_t); end
723
+ def complex(complex_t); end
724
+ def compstmt(statements); end
725
+ def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
726
+ def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
727
+ def condition_mod(if_true, if_false, cond_t, cond); end
728
+ def const(name_t); end
729
+ def const_fetch(scope, t_colon2, name_t); end
730
+ def const_global(t_colon3, name_t); end
731
+ def const_op_assignable(node); end
732
+ def const_pattern(const, ldelim_t, pattern, rdelim_t); end
733
+ def constant_map(scope, colon2_t, name_t); end
734
+ def cvar(token); end
735
+ def dedent_string(node, dedent_level); end
736
+ def def_class(class_t, name, lt_t, superclass, body, end_t); end
737
+ def def_endless_method(def_t, name_t, args, assignment_t, body); end
738
+ def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
739
+ def def_method(def_t, name_t, args, body, end_t); end
740
+ def def_module(module_t, name, body, end_t); end
741
+ def def_sclass(class_t, lshft_t, expr, body, end_t); end
742
+ def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
743
+ def definition_map(keyword_t, operator_t, name_t, end_t); end
744
+ def delimited_string_map(string_t); end
745
+ def diagnostic(type, reason, arguments, location, highlights = nil); end
746
+ def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
747
+ def emit_file_line_as_literals; end
748
+ def emit_file_line_as_literals=(arg0); end
749
+ def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
750
+ def expr_map(loc); end
751
+ def false(false_t); end
752
+ def find_pattern(lbrack_t, elements, rbrack_t); end
753
+ def float(float_t); end
754
+ def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
755
+ def for_map(keyword_t, in_t, begin_t, end_t); end
756
+ def forward_arg(dots_t); end
757
+ def forward_only_args(begin_t, dots_t, end_t); end
758
+ def forwarded_args(dots_t); end
759
+ def guard_map(keyword_t, guard_body_e); end
760
+ def gvar(token); end
761
+ def hash_pattern(lbrace_t, kwargs, rbrace_t); end
762
+ def ident(token); end
763
+ def if_guard(if_t, if_body); end
764
+ def in_match(lhs, in_t, rhs); end
765
+ def in_pattern(in_t, pattern, guard, then_t, body); end
766
+ def index(receiver, lbrack_t, indexes, rbrack_t); end
767
+ def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
768
+ def index_map(receiver_e, lbrack_t, rbrack_t); end
769
+ def initialize; end
770
+ def integer(integer_t); end
771
+ def ivar(token); end
772
+ def join_exprs(left_expr, right_expr); end
773
+ def keyword_cmd(type, keyword_t, lparen_t = nil, args = nil, rparen_t = nil); end
774
+ def keyword_map(keyword_t, begin_t, args, end_t); end
775
+ def keyword_mod_map(pre_e, keyword_t, post_e); end
776
+ def kwarg(name_t); end
777
+ def kwarg_map(name_t, value_e = nil); end
778
+ def kwargs?(node); end
779
+ def kwnilarg(dstar_t, nil_t); end
780
+ def kwoptarg(name_t, value); end
781
+ def kwrestarg(dstar_t, name_t = nil); end
782
+ def kwsplat(dstar_t, arg); end
783
+ def loc(token); end
784
+ def logical_op(type, lhs, op_t, rhs); end
785
+ def loop(type, keyword_t, cond, do_t, body, end_t); end
786
+ def loop_mod(type, body, keyword_t, cond); end
787
+ def match_alt(left, pipe_t, right); end
788
+ def match_as(value, assoc_t, as); end
789
+ def match_hash_var(name_t); end
790
+ def match_hash_var_from_str(begin_t, strings, end_t); end
791
+ def match_label(label_type, label); end
792
+ def match_nil_pattern(dstar_t, nil_t); end
793
+ def match_op(receiver, match_t, arg); end
794
+ def match_pair(label_type, label, value); end
795
+ def match_pattern(lhs, match_t, rhs); end
796
+ def match_pattern_p(lhs, match_t, rhs); end
797
+ def match_rest(star_t, name_t = nil); end
798
+ def match_var(name_t); end
799
+ def match_with_trailing_comma(match, comma_t); end
800
+ def module_definition_map(keyword_t, name_e, operator_t, end_t); end
801
+ def multi_assign(lhs, eql_t, rhs); end
802
+ def multi_lhs(begin_t, items, end_t); end
803
+ def n(type, children, source_map); end
804
+ def n0(type, source_map); end
805
+ def nil(nil_t); end
806
+ def not_op(not_t, begin_t = nil, receiver = nil, end_t = nil); end
807
+ def nth_ref(token); end
808
+ def numargs(max_numparam); end
809
+ def numeric(kind, token); end
810
+ def objc_kwarg(kwname_t, assoc_t, name_t); end
811
+ def objc_restarg(star_t, name = nil); end
812
+ def objc_varargs(pair, rest_of_varargs); end
813
+ def op_assign(lhs, op_t, rhs); end
814
+ def optarg(name_t, eql_t, value); end
815
+ def pair(key, assoc_t, value); end
816
+ def pair_keyword(key_t, value); end
817
+ def pair_keyword_map(key_t, value_e); end
818
+ def pair_label(key_t); end
819
+ def pair_list_18(list); end
820
+ def pair_quoted(begin_t, parts, end_t, value); end
821
+ def pair_quoted_map(begin_t, end_t, value_e); end
822
+ def parser; end
823
+ def parser=(arg0); end
824
+ def pin(pin_t, var); end
825
+ def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
826
+ def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
827
+ def prefix_string_map(symbol); end
828
+ def procarg0(arg); end
829
+ def range_exclusive(lhs, dot3_t, rhs); end
830
+ def range_inclusive(lhs, dot2_t, rhs); end
831
+ def range_map(start_e, op_t, end_e); end
832
+ def rational(rational_t); end
833
+ def regexp_compose(begin_t, parts, end_t, options); end
834
+ def regexp_map(begin_t, end_t, options_e); end
835
+ def regexp_options(regopt_t); end
836
+ def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
837
+ def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
838
+ def restarg(star_t, name_t = nil); end
839
+ def restarg_expr(star_t, expr = nil); end
840
+ def rewrite_hash_args_to_kwargs(args); end
841
+ def self(token); end
842
+ def self.emit_arg_inside_procarg0; end
843
+ def self.emit_arg_inside_procarg0=(arg0); end
844
+ def self.emit_encoding; end
845
+ def self.emit_encoding=(arg0); end
846
+ def self.emit_forward_arg; end
847
+ def self.emit_forward_arg=(arg0); end
848
+ def self.emit_index; end
849
+ def self.emit_index=(arg0); end
850
+ def self.emit_kwargs; end
851
+ def self.emit_kwargs=(arg0); end
852
+ def self.emit_lambda; end
853
+ def self.emit_lambda=(arg0); end
854
+ def self.emit_match_pattern; end
855
+ def self.emit_match_pattern=(arg0); end
856
+ def self.emit_procarg0; end
857
+ def self.emit_procarg0=(arg0); end
858
+ def self.modernize; end
859
+ def send_binary_op_map(lhs_e, selector_t, rhs_e); end
860
+ def send_index_map(receiver_e, lbrack_t, rbrack_t); end
861
+ def send_map(receiver_e, dot_t, selector_t, begin_t = nil, args = nil, end_t = nil); end
862
+ def send_unary_op_map(selector_t, arg_e); end
863
+ def shadowarg(name_t); end
864
+ def splat(star_t, arg = nil); end
865
+ def static_regexp(parts, options); end
866
+ def static_regexp_node(node); end
867
+ def static_string(nodes); end
868
+ def string(string_t); end
869
+ def string_compose(begin_t, parts, end_t); end
870
+ def string_internal(string_t); end
871
+ def string_map(begin_t, parts, end_t); end
872
+ def string_value(token); end
873
+ def symbol(symbol_t); end
874
+ def symbol_compose(begin_t, parts, end_t); end
875
+ def symbol_internal(symbol_t); end
876
+ def symbols_compose(begin_t, parts, end_t); end
877
+ def ternary(cond, question_t, if_true, colon_t, if_false); end
878
+ def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
879
+ def token_map(token); end
880
+ def true(true_t); end
881
+ def unary_num(unary_t, numeric); end
882
+ def unary_op(op_t, receiver); end
883
+ def unary_op_map(op_t, arg_e = nil); end
884
+ def undef_method(undef_t, names); end
885
+ def unless_guard(unless_t, unless_body); end
886
+ def unquoted_map(token); end
887
+ def validate_definee(definee); end
888
+ def validate_no_forward_arg_after_restarg(args); end
889
+ def value(token); end
890
+ def var_send_map(variable_e); end
891
+ def variable_map(name_t); end
892
+ def when(when_t, patterns, then_t, body); end
893
+ def word(parts); end
894
+ def words_compose(begin_t, parts, end_t); end
895
+ def xstring_compose(begin_t, parts, end_t); end
896
+ end
897
+ class Parser::Context
898
+ def in_argdef; end
899
+ def in_argdef=(arg0); end
900
+ def in_block; end
901
+ def in_block=(arg0); end
902
+ def in_class; end
903
+ def in_class=(arg0); end
904
+ def in_def; end
905
+ def in_def=(arg0); end
906
+ def in_defined; end
907
+ def in_defined=(arg0); end
908
+ def in_dynamic_block?; end
909
+ def in_kwarg; end
910
+ def in_kwarg=(arg0); end
911
+ def in_lambda; end
912
+ def in_lambda=(arg0); end
913
+ def initialize; end
914
+ def reset; end
915
+ end
916
+ class Parser::MaxNumparamStack
917
+ def empty?; end
918
+ def has_numparams?; end
919
+ def has_ordinary_params!; end
920
+ def has_ordinary_params?; end
921
+ def initialize; end
922
+ def pop; end
923
+ def push(static:); end
924
+ def register(numparam); end
925
+ def set(value); end
926
+ def stack; end
927
+ def top; end
928
+ end
929
+ class Parser::CurrentArgStack
930
+ def empty?; end
931
+ def initialize; end
932
+ def pop; end
933
+ def push(value); end
934
+ def reset; end
935
+ def set(value); end
936
+ def stack; end
937
+ def top; end
938
+ end
939
+ class Parser::VariablesStack
940
+ def declare(name); end
941
+ def declared?(name); end
942
+ def empty?; end
943
+ def initialize; end
944
+ def pop; end
945
+ def push; end
946
+ def reset; end
947
+ end
948
+ class Parser::Base < Racc::Parser
949
+ def builder; end
950
+ def check_kwarg_name(name_t); end
951
+ def context; end
952
+ def current_arg_stack; end
953
+ def diagnostic(level, reason, arguments, location_t, highlights_ts = nil); end
954
+ def diagnostics; end
955
+ def initialize(builder = nil); end
956
+ def lexer; end
957
+ def max_numparam_stack; end
958
+ def next_token; end
959
+ def on_error(error_token_id, error_value, value_stack); end
960
+ def parse(source_buffer); end
961
+ def parse_with_comments(source_buffer); end
962
+ def pattern_hash_keys; end
963
+ def pattern_variables; end
964
+ def reset; end
965
+ def self.default_parser; end
966
+ def self.parse(string, file = nil, line = nil); end
967
+ def self.parse_file(filename); end
968
+ def self.parse_file_with_comments(filename); end
969
+ def self.parse_with_comments(string, file = nil, line = nil); end
970
+ def self.setup_source_buffer(file, line, string, encoding); end
971
+ def source_buffer; end
972
+ def static_env; end
973
+ def tokenize(source_buffer, recover = nil); end
974
+ end
975
+ class Parser::Rewriter < Parser::AST::Processor
976
+ def assignment?(node); end
977
+ def initialize(*arg0); end
978
+ def insert_after(range, content); end
979
+ def insert_before(range, content); end
980
+ def remove(range); end
981
+ def replace(range, content); end
982
+ def rewrite(source_buffer, ast); end
983
+ def wrap(range, before, after); end
984
+ extend Parser::Deprecation
985
+ end
986
+ class Parser::TreeRewriter < Parser::AST::Processor
987
+ def assignment?(node); end
988
+ def insert_after(range, content); end
989
+ def insert_before(range, content); end
990
+ def remove(range); end
991
+ def replace(range, content); end
992
+ def rewrite(source_buffer, ast, **policy); end
993
+ def wrap(range, before, after); end
994
+ end
995
+ module Parser::Builders
996
+ end
997
+ class Parser::Ruby24 < Parser::Base
998
+ def _reduce_10(val, _values, result); end
999
+ def _reduce_100(val, _values, result); end
1000
+ def _reduce_101(val, _values, result); end
1001
+ def _reduce_102(val, _values, result); end
1002
+ def _reduce_103(val, _values, result); end
1003
+ def _reduce_104(val, _values, result); end
1004
+ def _reduce_105(val, _values, result); end
1005
+ def _reduce_106(val, _values, result); end
1006
+ def _reduce_107(val, _values, result); end
1007
+ def _reduce_108(val, _values, result); end
1008
+ def _reduce_11(val, _values, result); end
1009
+ def _reduce_110(val, _values, result); end
1010
+ def _reduce_111(val, _values, result); end
1011
+ def _reduce_112(val, _values, result); end
1012
+ def _reduce_118(val, _values, result); end
1013
+ def _reduce_12(val, _values, result); end
1014
+ def _reduce_122(val, _values, result); end
1015
+ def _reduce_123(val, _values, result); end
1016
+ def _reduce_124(val, _values, result); end
1017
+ def _reduce_13(val, _values, result); end
1018
+ def _reduce_14(val, _values, result); end
1019
+ def _reduce_16(val, _values, result); end
1020
+ def _reduce_17(val, _values, result); end
1021
+ def _reduce_18(val, _values, result); end
1022
+ def _reduce_19(val, _values, result); end
1023
+ def _reduce_196(val, _values, result); end
1024
+ def _reduce_197(val, _values, result); end
1025
+ def _reduce_198(val, _values, result); end
1026
+ def _reduce_199(val, _values, result); end
1027
+ def _reduce_2(val, _values, result); end
1028
+ def _reduce_20(val, _values, result); end
1029
+ def _reduce_200(val, _values, result); end
1030
+ def _reduce_201(val, _values, result); end
1031
+ def _reduce_202(val, _values, result); end
1032
+ def _reduce_203(val, _values, result); end
1033
+ def _reduce_204(val, _values, result); end
1034
+ def _reduce_205(val, _values, result); end
1035
+ def _reduce_206(val, _values, result); end
1036
+ def _reduce_207(val, _values, result); end
1037
+ def _reduce_208(val, _values, result); end
1038
+ def _reduce_209(val, _values, result); end
1039
+ def _reduce_21(val, _values, result); end
1040
+ def _reduce_210(val, _values, result); end
1041
+ def _reduce_211(val, _values, result); end
1042
+ def _reduce_212(val, _values, result); end
1043
+ def _reduce_213(val, _values, result); end
1044
+ def _reduce_214(val, _values, result); end
1045
+ def _reduce_215(val, _values, result); end
1046
+ def _reduce_216(val, _values, result); end
1047
+ def _reduce_217(val, _values, result); end
1048
+ def _reduce_218(val, _values, result); end
1049
+ def _reduce_219(val, _values, result); end
1050
+ def _reduce_22(val, _values, result); end
1051
+ def _reduce_220(val, _values, result); end
1052
+ def _reduce_221(val, _values, result); end
1053
+ def _reduce_222(val, _values, result); end
1054
+ def _reduce_223(val, _values, result); end
1055
+ def _reduce_224(val, _values, result); end
1056
+ def _reduce_225(val, _values, result); end
1057
+ def _reduce_226(val, _values, result); end
1058
+ def _reduce_227(val, _values, result); end
1059
+ def _reduce_228(val, _values, result); end
1060
+ def _reduce_229(val, _values, result); end
1061
+ def _reduce_23(val, _values, result); end
1062
+ def _reduce_230(val, _values, result); end
1063
+ def _reduce_231(val, _values, result); end
1064
+ def _reduce_232(val, _values, result); end
1065
+ def _reduce_233(val, _values, result); end
1066
+ def _reduce_234(val, _values, result); end
1067
+ def _reduce_235(val, _values, result); end
1068
+ def _reduce_236(val, _values, result); end
1069
+ def _reduce_24(val, _values, result); end
1070
+ def _reduce_241(val, _values, result); end
1071
+ def _reduce_242(val, _values, result); end
1072
+ def _reduce_244(val, _values, result); end
1073
+ def _reduce_245(val, _values, result); end
1074
+ def _reduce_246(val, _values, result); end
1075
+ def _reduce_248(val, _values, result); end
1076
+ def _reduce_25(val, _values, result); end
1077
+ def _reduce_251(val, _values, result); end
1078
+ def _reduce_252(val, _values, result); end
1079
+ def _reduce_253(val, _values, result); end
1080
+ def _reduce_254(val, _values, result); end
1081
+ def _reduce_255(val, _values, result); end
1082
+ def _reduce_256(val, _values, result); end
1083
+ def _reduce_257(val, _values, result); end
1084
+ def _reduce_258(val, _values, result); end
1085
+ def _reduce_259(val, _values, result); end
1086
+ def _reduce_26(val, _values, result); end
1087
+ def _reduce_260(val, _values, result); end
1088
+ def _reduce_261(val, _values, result); end
1089
+ def _reduce_262(val, _values, result); end
1090
+ def _reduce_263(val, _values, result); end
1091
+ def _reduce_264(val, _values, result); end
1092
+ def _reduce_265(val, _values, result); end
1093
+ def _reduce_266(val, _values, result); end
1094
+ def _reduce_267(val, _values, result); end
1095
+ def _reduce_269(val, _values, result); end
1096
+ def _reduce_27(val, _values, result); end
1097
+ def _reduce_270(val, _values, result); end
1098
+ def _reduce_271(val, _values, result); end
1099
+ def _reduce_28(val, _values, result); end
1100
+ def _reduce_282(val, _values, result); end
1101
+ def _reduce_283(val, _values, result); end
1102
+ def _reduce_284(val, _values, result); end
1103
+ def _reduce_285(val, _values, result); end
1104
+ def _reduce_286(val, _values, result); end
1105
+ def _reduce_287(val, _values, result); end
1106
+ def _reduce_288(val, _values, result); end
1107
+ def _reduce_289(val, _values, result); end
1108
+ def _reduce_290(val, _values, result); end
1109
+ def _reduce_291(val, _values, result); end
1110
+ def _reduce_292(val, _values, result); end
1111
+ def _reduce_293(val, _values, result); end
1112
+ def _reduce_294(val, _values, result); end
1113
+ def _reduce_295(val, _values, result); end
1114
+ def _reduce_296(val, _values, result); end
1115
+ def _reduce_297(val, _values, result); end
1116
+ def _reduce_298(val, _values, result); end
1117
+ def _reduce_299(val, _values, result); end
1118
+ def _reduce_3(val, _values, result); end
1119
+ def _reduce_30(val, _values, result); end
1120
+ def _reduce_300(val, _values, result); end
1121
+ def _reduce_301(val, _values, result); end
1122
+ def _reduce_303(val, _values, result); end
1123
+ def _reduce_304(val, _values, result); end
1124
+ def _reduce_305(val, _values, result); end
1125
+ def _reduce_306(val, _values, result); end
1126
+ def _reduce_307(val, _values, result); end
1127
+ def _reduce_308(val, _values, result); end
1128
+ def _reduce_309(val, _values, result); end
1129
+ def _reduce_31(val, _values, result); end
1130
+ def _reduce_310(val, _values, result); end
1131
+ def _reduce_311(val, _values, result); end
1132
+ def _reduce_312(val, _values, result); end
1133
+ def _reduce_313(val, _values, result); end
1134
+ def _reduce_314(val, _values, result); end
1135
+ def _reduce_315(val, _values, result); end
1136
+ def _reduce_316(val, _values, result); end
1137
+ def _reduce_317(val, _values, result); end
1138
+ def _reduce_318(val, _values, result); end
1139
+ def _reduce_319(val, _values, result); end
1140
+ def _reduce_32(val, _values, result); end
1141
+ def _reduce_320(val, _values, result); end
1142
+ def _reduce_321(val, _values, result); end
1143
+ def _reduce_322(val, _values, result); end
1144
+ def _reduce_323(val, _values, result); end
1145
+ def _reduce_324(val, _values, result); end
1146
+ def _reduce_325(val, _values, result); end
1147
+ def _reduce_326(val, _values, result); end
1148
+ def _reduce_327(val, _values, result); end
1149
+ def _reduce_328(val, _values, result); end
1150
+ def _reduce_329(val, _values, result); end
1151
+ def _reduce_330(val, _values, result); end
1152
+ def _reduce_331(val, _values, result); end
1153
+ def _reduce_332(val, _values, result); end
1154
+ def _reduce_333(val, _values, result); end
1155
+ def _reduce_335(val, _values, result); end
1156
+ def _reduce_336(val, _values, result); end
1157
+ def _reduce_339(val, _values, result); end
1158
+ def _reduce_34(val, _values, result); end
1159
+ def _reduce_343(val, _values, result); end
1160
+ def _reduce_345(val, _values, result); end
1161
+ def _reduce_348(val, _values, result); end
1162
+ def _reduce_349(val, _values, result); end
1163
+ def _reduce_35(val, _values, result); end
1164
+ def _reduce_350(val, _values, result); end
1165
+ def _reduce_351(val, _values, result); end
1166
+ def _reduce_353(val, _values, result); end
1167
+ def _reduce_354(val, _values, result); end
1168
+ def _reduce_355(val, _values, result); end
1169
+ def _reduce_356(val, _values, result); end
1170
+ def _reduce_357(val, _values, result); end
1171
+ def _reduce_358(val, _values, result); end
1172
+ def _reduce_359(val, _values, result); end
1173
+ def _reduce_36(val, _values, result); end
1174
+ def _reduce_360(val, _values, result); end
1175
+ def _reduce_361(val, _values, result); end
1176
+ def _reduce_362(val, _values, result); end
1177
+ def _reduce_363(val, _values, result); end
1178
+ def _reduce_364(val, _values, result); end
1179
+ def _reduce_365(val, _values, result); end
1180
+ def _reduce_366(val, _values, result); end
1181
+ def _reduce_367(val, _values, result); end
1182
+ def _reduce_368(val, _values, result); end
1183
+ def _reduce_369(val, _values, result); end
1184
+ def _reduce_37(val, _values, result); end
1185
+ def _reduce_370(val, _values, result); end
1186
+ def _reduce_371(val, _values, result); end
1187
+ def _reduce_373(val, _values, result); end
1188
+ def _reduce_374(val, _values, result); end
1189
+ def _reduce_375(val, _values, result); end
1190
+ def _reduce_376(val, _values, result); end
1191
+ def _reduce_377(val, _values, result); end
1192
+ def _reduce_378(val, _values, result); end
1193
+ def _reduce_379(val, _values, result); end
1194
+ def _reduce_38(val, _values, result); end
1195
+ def _reduce_380(val, _values, result); end
1196
+ def _reduce_382(val, _values, result); end
1197
+ def _reduce_383(val, _values, result); end
1198
+ def _reduce_384(val, _values, result); end
1199
+ def _reduce_385(val, _values, result); end
1200
+ def _reduce_386(val, _values, result); end
1201
+ def _reduce_387(val, _values, result); end
1202
+ def _reduce_388(val, _values, result); end
1203
+ def _reduce_389(val, _values, result); end
1204
+ def _reduce_39(val, _values, result); end
1205
+ def _reduce_390(val, _values, result); end
1206
+ def _reduce_391(val, _values, result); end
1207
+ def _reduce_393(val, _values, result); end
1208
+ def _reduce_394(val, _values, result); end
1209
+ def _reduce_395(val, _values, result); end
1210
+ def _reduce_396(val, _values, result); end
1211
+ def _reduce_397(val, _values, result); end
1212
+ def _reduce_398(val, _values, result); end
1213
+ def _reduce_399(val, _values, result); end
1214
+ def _reduce_4(val, _values, result); end
1215
+ def _reduce_40(val, _values, result); end
1216
+ def _reduce_400(val, _values, result); end
1217
+ def _reduce_401(val, _values, result); end
1218
+ def _reduce_402(val, _values, result); end
1219
+ def _reduce_403(val, _values, result); end
1220
+ def _reduce_404(val, _values, result); end
1221
+ def _reduce_405(val, _values, result); end
1222
+ def _reduce_406(val, _values, result); end
1223
+ def _reduce_407(val, _values, result); end
1224
+ def _reduce_408(val, _values, result); end
1225
+ def _reduce_409(val, _values, result); end
1226
+ def _reduce_41(val, _values, result); end
1227
+ def _reduce_410(val, _values, result); end
1228
+ def _reduce_411(val, _values, result); end
1229
+ def _reduce_412(val, _values, result); end
1230
+ def _reduce_413(val, _values, result); end
1231
+ def _reduce_414(val, _values, result); end
1232
+ def _reduce_415(val, _values, result); end
1233
+ def _reduce_416(val, _values, result); end
1234
+ def _reduce_417(val, _values, result); end
1235
+ def _reduce_418(val, _values, result); end
1236
+ def _reduce_419(val, _values, result); end
1237
+ def _reduce_420(val, _values, result); end
1238
+ def _reduce_421(val, _values, result); end
1239
+ def _reduce_422(val, _values, result); end
1240
+ def _reduce_423(val, _values, result); end
1241
+ def _reduce_424(val, _values, result); end
1242
+ def _reduce_425(val, _values, result); end
1243
+ def _reduce_426(val, _values, result); end
1244
+ def _reduce_427(val, _values, result); end
1245
+ def _reduce_429(val, _values, result); end
1246
+ def _reduce_43(val, _values, result); end
1247
+ def _reduce_430(val, _values, result); end
1248
+ def _reduce_431(val, _values, result); end
1249
+ def _reduce_434(val, _values, result); end
1250
+ def _reduce_436(val, _values, result); end
1251
+ def _reduce_441(val, _values, result); end
1252
+ def _reduce_442(val, _values, result); end
1253
+ def _reduce_443(val, _values, result); end
1254
+ def _reduce_444(val, _values, result); end
1255
+ def _reduce_445(val, _values, result); end
1256
+ def _reduce_446(val, _values, result); end
1257
+ def _reduce_447(val, _values, result); end
1258
+ def _reduce_448(val, _values, result); end
1259
+ def _reduce_449(val, _values, result); end
1260
+ def _reduce_450(val, _values, result); end
1261
+ def _reduce_451(val, _values, result); end
1262
+ def _reduce_452(val, _values, result); end
1263
+ def _reduce_453(val, _values, result); end
1264
+ def _reduce_454(val, _values, result); end
1265
+ def _reduce_455(val, _values, result); end
1266
+ def _reduce_456(val, _values, result); end
1267
+ def _reduce_457(val, _values, result); end
1268
+ def _reduce_458(val, _values, result); end
1269
+ def _reduce_459(val, _values, result); end
1270
+ def _reduce_46(val, _values, result); end
1271
+ def _reduce_460(val, _values, result); end
1272
+ def _reduce_461(val, _values, result); end
1273
+ def _reduce_462(val, _values, result); end
1274
+ def _reduce_463(val, _values, result); end
1275
+ def _reduce_464(val, _values, result); end
1276
+ def _reduce_465(val, _values, result); end
1277
+ def _reduce_466(val, _values, result); end
1278
+ def _reduce_467(val, _values, result); end
1279
+ def _reduce_468(val, _values, result); end
1280
+ def _reduce_469(val, _values, result); end
1281
+ def _reduce_47(val, _values, result); end
1282
+ def _reduce_470(val, _values, result); end
1283
+ def _reduce_471(val, _values, result); end
1284
+ def _reduce_472(val, _values, result); end
1285
+ def _reduce_473(val, _values, result); end
1286
+ def _reduce_474(val, _values, result); end
1287
+ def _reduce_475(val, _values, result); end
1288
+ def _reduce_477(val, _values, result); end
1289
+ def _reduce_478(val, _values, result); end
1290
+ def _reduce_479(val, _values, result); end
1291
+ def _reduce_48(val, _values, result); end
1292
+ def _reduce_480(val, _values, result); end
1293
+ def _reduce_481(val, _values, result); end
1294
+ def _reduce_482(val, _values, result); end
1295
+ def _reduce_483(val, _values, result); end
1296
+ def _reduce_484(val, _values, result); end
1297
+ def _reduce_485(val, _values, result); end
1298
+ def _reduce_486(val, _values, result); end
1299
+ def _reduce_487(val, _values, result); end
1300
+ def _reduce_488(val, _values, result); end
1301
+ def _reduce_489(val, _values, result); end
1302
+ def _reduce_49(val, _values, result); end
1303
+ def _reduce_490(val, _values, result); end
1304
+ def _reduce_491(val, _values, result); end
1305
+ def _reduce_492(val, _values, result); end
1306
+ def _reduce_493(val, _values, result); end
1307
+ def _reduce_494(val, _values, result); end
1308
+ def _reduce_495(val, _values, result); end
1309
+ def _reduce_496(val, _values, result); end
1310
+ def _reduce_497(val, _values, result); end
1311
+ def _reduce_498(val, _values, result); end
1312
+ def _reduce_499(val, _values, result); end
1313
+ def _reduce_5(val, _values, result); end
1314
+ def _reduce_500(val, _values, result); end
1315
+ def _reduce_501(val, _values, result); end
1316
+ def _reduce_502(val, _values, result); end
1317
+ def _reduce_503(val, _values, result); end
1318
+ def _reduce_504(val, _values, result); end
1319
+ def _reduce_505(val, _values, result); end
1320
+ def _reduce_506(val, _values, result); end
1321
+ def _reduce_507(val, _values, result); end
1322
+ def _reduce_508(val, _values, result); end
1323
+ def _reduce_509(val, _values, result); end
1324
+ def _reduce_510(val, _values, result); end
1325
+ def _reduce_511(val, _values, result); end
1326
+ def _reduce_512(val, _values, result); end
1327
+ def _reduce_513(val, _values, result); end
1328
+ def _reduce_514(val, _values, result); end
1329
+ def _reduce_515(val, _values, result); end
1330
+ def _reduce_516(val, _values, result); end
1331
+ def _reduce_517(val, _values, result); end
1332
+ def _reduce_518(val, _values, result); end
1333
+ def _reduce_519(val, _values, result); end
1334
+ def _reduce_520(val, _values, result); end
1335
+ def _reduce_521(val, _values, result); end
1336
+ def _reduce_522(val, _values, result); end
1337
+ def _reduce_523(val, _values, result); end
1338
+ def _reduce_524(val, _values, result); end
1339
+ def _reduce_525(val, _values, result); end
1340
+ def _reduce_526(val, _values, result); end
1341
+ def _reduce_527(val, _values, result); end
1342
+ def _reduce_528(val, _values, result); end
1343
+ def _reduce_529(val, _values, result); end
1344
+ def _reduce_530(val, _values, result); end
1345
+ def _reduce_531(val, _values, result); end
1346
+ def _reduce_532(val, _values, result); end
1347
+ def _reduce_533(val, _values, result); end
1348
+ def _reduce_535(val, _values, result); end
1349
+ def _reduce_536(val, _values, result); end
1350
+ def _reduce_537(val, _values, result); end
1351
+ def _reduce_538(val, _values, result); end
1352
+ def _reduce_539(val, _values, result); end
1353
+ def _reduce_540(val, _values, result); end
1354
+ def _reduce_541(val, _values, result); end
1355
+ def _reduce_542(val, _values, result); end
1356
+ def _reduce_543(val, _values, result); end
1357
+ def _reduce_544(val, _values, result); end
1358
+ def _reduce_545(val, _values, result); end
1359
+ def _reduce_546(val, _values, result); end
1360
+ def _reduce_547(val, _values, result); end
1361
+ def _reduce_548(val, _values, result); end
1362
+ def _reduce_549(val, _values, result); end
1363
+ def _reduce_55(val, _values, result); end
1364
+ def _reduce_552(val, _values, result); end
1365
+ def _reduce_553(val, _values, result); end
1366
+ def _reduce_554(val, _values, result); end
1367
+ def _reduce_555(val, _values, result); end
1368
+ def _reduce_556(val, _values, result); end
1369
+ def _reduce_557(val, _values, result); end
1370
+ def _reduce_558(val, _values, result); end
1371
+ def _reduce_559(val, _values, result); end
1372
+ def _reduce_56(val, _values, result); end
1373
+ def _reduce_562(val, _values, result); end
1374
+ def _reduce_563(val, _values, result); end
1375
+ def _reduce_566(val, _values, result); end
1376
+ def _reduce_567(val, _values, result); end
1377
+ def _reduce_568(val, _values, result); end
1378
+ def _reduce_57(val, _values, result); end
1379
+ def _reduce_570(val, _values, result); end
1380
+ def _reduce_571(val, _values, result); end
1381
+ def _reduce_573(val, _values, result); end
1382
+ def _reduce_574(val, _values, result); end
1383
+ def _reduce_575(val, _values, result); end
1384
+ def _reduce_576(val, _values, result); end
1385
+ def _reduce_577(val, _values, result); end
1386
+ def _reduce_578(val, _values, result); end
1387
+ def _reduce_59(val, _values, result); end
1388
+ def _reduce_591(val, _values, result); end
1389
+ def _reduce_592(val, _values, result); end
1390
+ def _reduce_597(val, _values, result); end
1391
+ def _reduce_598(val, _values, result); end
1392
+ def _reduce_6(val, _values, result); end
1393
+ def _reduce_60(val, _values, result); end
1394
+ def _reduce_602(val, _values, result); end
1395
+ def _reduce_606(val, _values, result); end
1396
+ def _reduce_61(val, _values, result); end
1397
+ def _reduce_62(val, _values, result); end
1398
+ def _reduce_63(val, _values, result); end
1399
+ def _reduce_64(val, _values, result); end
1400
+ def _reduce_65(val, _values, result); end
1401
+ def _reduce_66(val, _values, result); end
1402
+ def _reduce_67(val, _values, result); end
1403
+ def _reduce_68(val, _values, result); end
1404
+ def _reduce_69(val, _values, result); end
1405
+ def _reduce_70(val, _values, result); end
1406
+ def _reduce_71(val, _values, result); end
1407
+ def _reduce_72(val, _values, result); end
1408
+ def _reduce_73(val, _values, result); end
1409
+ def _reduce_75(val, _values, result); end
1410
+ def _reduce_76(val, _values, result); end
1411
+ def _reduce_77(val, _values, result); end
1412
+ def _reduce_78(val, _values, result); end
1413
+ def _reduce_79(val, _values, result); end
1414
+ def _reduce_8(val, _values, result); end
1415
+ def _reduce_80(val, _values, result); end
1416
+ def _reduce_81(val, _values, result); end
1417
+ def _reduce_82(val, _values, result); end
1418
+ def _reduce_83(val, _values, result); end
1419
+ def _reduce_85(val, _values, result); end
1420
+ def _reduce_86(val, _values, result); end
1421
+ def _reduce_87(val, _values, result); end
1422
+ def _reduce_88(val, _values, result); end
1423
+ def _reduce_89(val, _values, result); end
1424
+ def _reduce_9(val, _values, result); end
1425
+ def _reduce_90(val, _values, result); end
1426
+ def _reduce_91(val, _values, result); end
1427
+ def _reduce_92(val, _values, result); end
1428
+ def _reduce_93(val, _values, result); end
1429
+ def _reduce_94(val, _values, result); end
1430
+ def _reduce_95(val, _values, result); end
1431
+ def _reduce_96(val, _values, result); end
1432
+ def _reduce_97(val, _values, result); end
1433
+ def _reduce_98(val, _values, result); end
1434
+ def _reduce_99(val, _values, result); end
1435
+ def _reduce_none(val, _values, result); end
1436
+ def default_encoding; end
1437
+ def local_pop; end
1438
+ def local_push; end
1439
+ def version; end
1440
+ end