bhook 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (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