guard-srb 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 (60) hide show
  1. checksums.yaml +7 -0
  2. data/.rubocop.yml +37 -0
  3. data/.tool-versions +1 -0
  4. data/CHANGELOG.md +5 -0
  5. data/CODE_OF_CONDUCT.md +84 -0
  6. data/Gemfile +14 -0
  7. data/Gemfile.lock +125 -0
  8. data/Guardfile +16 -0
  9. data/LICENSE.txt +21 -0
  10. data/README.md +92 -0
  11. data/Rakefile +18 -0
  12. data/lib/guard/srb/runner.rb +70 -0
  13. data/lib/guard/srb/templates/Guardfile +3 -0
  14. data/lib/guard/srb/version.rb +8 -0
  15. data/lib/guard/srb.rb +105 -0
  16. data/sorbet/config +5 -0
  17. data/sorbet/rbi/annotations/rainbow.rbi +269 -0
  18. data/sorbet/rbi/gems/ast@2.4.2.rbi +584 -0
  19. data/sorbet/rbi/gems/coderay@1.1.3.rbi +3437 -0
  20. data/sorbet/rbi/gems/diff-lcs@1.5.0.rbi +1079 -0
  21. data/sorbet/rbi/gems/ffi@1.15.5.rbi +8 -0
  22. data/sorbet/rbi/gems/formatador@1.1.0.rbi +8 -0
  23. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +103 -0
  24. data/sorbet/rbi/gems/guard-minitest@2.4.6.rbi +299 -0
  25. data/sorbet/rbi/gems/guard@2.16.2.rbi +2286 -0
  26. data/sorbet/rbi/gems/json@2.6.3.rbi +1541 -0
  27. data/sorbet/rbi/gems/listen@3.8.0.rbi +1181 -0
  28. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +1501 -0
  29. data/sorbet/rbi/gems/method_source@1.0.0.rbi +272 -0
  30. data/sorbet/rbi/gems/minitest@5.18.0.rbi +2354 -0
  31. data/sorbet/rbi/gems/mocha@2.0.2.rbi +3934 -0
  32. data/sorbet/rbi/gems/nenv@0.3.0.rbi +146 -0
  33. data/sorbet/rbi/gems/netrc@0.11.0.rbi +161 -0
  34. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +1078 -0
  35. data/sorbet/rbi/gems/parallel@1.23.0.rbi +273 -0
  36. data/sorbet/rbi/gems/parser@3.2.2.1.rbi +9454 -0
  37. data/sorbet/rbi/gems/pry@0.14.2.rbi +10079 -0
  38. data/sorbet/rbi/gems/rainbow@3.1.1.rbi +402 -0
  39. data/sorbet/rbi/gems/rake@13.0.6.rbi +3119 -0
  40. data/sorbet/rbi/gems/rb-fsevent@0.11.2.rbi +8 -0
  41. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +8 -0
  42. data/sorbet/rbi/gems/rbi@0.0.16.rbi +3049 -0
  43. data/sorbet/rbi/gems/regexp_parser@2.8.0.rbi +3765 -0
  44. data/sorbet/rbi/gems/rexml@3.2.5.rbi +4717 -0
  45. data/sorbet/rbi/gems/rubocop-ast@1.28.1.rbi +6967 -0
  46. data/sorbet/rbi/gems/rubocop@1.50.2.rbi +55367 -0
  47. data/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi +1317 -0
  48. data/sorbet/rbi/gems/ruby2_keywords@0.0.5.rbi +8 -0
  49. data/sorbet/rbi/gems/shellany@0.0.1.rbi +101 -0
  50. data/sorbet/rbi/gems/spoom@1.2.1.rbi +2536 -0
  51. data/sorbet/rbi/gems/tapioca@0.11.6.rbi +3246 -0
  52. data/sorbet/rbi/gems/thor@1.2.2.rbi +3965 -0
  53. data/sorbet/rbi/gems/unicode-display_width@2.4.2.rbi +65 -0
  54. data/sorbet/rbi/gems/unparser@0.6.7.rbi +4515 -0
  55. data/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi +426 -0
  56. data/sorbet/rbi/gems/yard@0.9.34.rbi +17907 -0
  57. data/sorbet/rbi/todo.rbi +7 -0
  58. data/sorbet/tapioca/config.yml +13 -0
  59. data/sorbet/tapioca/require.rb +14 -0
  60. metadata +155 -0
@@ -0,0 +1,3765 @@
1
+ # typed: true
2
+
3
+ # DO NOT EDIT MANUALLY
4
+ # This is an autogenerated file for types exported from the `regexp_parser` gem.
5
+ # Please instead update this file by running `bin/tapioca gem regexp_parser`.
6
+
7
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#1
8
+ module Regexp::Expression; end
9
+
10
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#5
11
+ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
12
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
13
+ def alternatives; end
14
+
15
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9
16
+ def human_name; end
17
+
18
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
19
+ def match_length; end
20
+ end
21
+
22
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#6
23
+ Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
24
+
25
+ # A sequence of expressions, used by Alternation as one of its alternatives.
26
+ #
27
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3
28
+ class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
29
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#10
30
+ def human_name; end
31
+ end
32
+
33
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#2
34
+ module Regexp::Expression::Anchor; end
35
+
36
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#18
37
+ Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
38
+
39
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#20
40
+ Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
41
+
42
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3
43
+ class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
44
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
45
+ def match_length; end
46
+ end
47
+
48
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#5
49
+ class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
50
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#11
51
+ def human_name; end
52
+ end
53
+
54
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#8
55
+ class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
56
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#12
57
+ def human_name; end
58
+ end
59
+
60
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#19
61
+ Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
62
+
63
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#21
64
+ Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
65
+
66
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#22
67
+ Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
68
+
69
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#6
70
+ class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
71
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#13
72
+ def human_name; end
73
+ end
74
+
75
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#9
76
+ class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
77
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#14
78
+ def human_name; end
79
+ end
80
+
81
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#11
82
+ class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
83
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#15
84
+ def human_name; end
85
+ end
86
+
87
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#16
88
+ class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
89
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#16
90
+ def human_name; end
91
+ end
92
+
93
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#14
94
+ class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
95
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#17
96
+ def human_name; end
97
+ end
98
+
99
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#13
100
+ class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
101
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#18
102
+ def human_name; end
103
+ end
104
+
105
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#64
106
+ module Regexp::Expression::Assertion; end
107
+
108
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#65
109
+ class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
110
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
111
+ def match_length; end
112
+ end
113
+
114
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#67
115
+ class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
116
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19
117
+ def human_name; end
118
+ end
119
+
120
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#70
121
+ class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
122
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20
123
+ def human_name; end
124
+ end
125
+
126
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#68
127
+ class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
128
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21
129
+ def human_name; end
130
+ end
131
+
132
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#71
133
+ class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
134
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22
135
+ def human_name; end
136
+ end
137
+
138
+ # alias for symmetry between token symbol and Expression class name
139
+ #
140
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#74
141
+ Regexp::Expression::Backref = Regexp::Expression::Backreference
142
+
143
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#2
144
+ module Regexp::Expression::Backreference; end
145
+
146
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3
147
+ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
148
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155
149
+ def match_length; end
150
+
151
+ # Returns the value of attribute referenced_expression.
152
+ #
153
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
154
+ def referenced_expression; end
155
+
156
+ # Sets the attribute referenced_expression
157
+ #
158
+ # @param value the value to set the attribute referenced_expression to.
159
+ #
160
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
161
+ def referenced_expression=(_arg0); end
162
+
163
+ private
164
+
165
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#6
166
+ def initialize_copy(orig); end
167
+
168
+ class << self
169
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#140
170
+ def referential?; end
171
+ end
172
+ end
173
+
174
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
175
+ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
176
+ # @return [Name] a new instance of Name
177
+ #
178
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#38
179
+ def initialize(token, options = T.unsafe(nil)); end
180
+
181
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23
182
+ def human_name; end
183
+
184
+ # Returns the value of attribute name.
185
+ #
186
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35
187
+ def name; end
188
+
189
+ # Returns the value of attribute name.
190
+ #
191
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35
192
+ def reference; end
193
+ end
194
+
195
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
196
+ class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
197
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24
198
+ def human_name; end
199
+ end
200
+
201
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#62
202
+ class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
203
+ # @return [NameRecursionLevel] a new instance of NameRecursionLevel
204
+ #
205
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#65
206
+ def initialize(token, options = T.unsafe(nil)); end
207
+
208
+ # Returns the value of attribute recursion_level.
209
+ #
210
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#63
211
+ def recursion_level; end
212
+ end
213
+
214
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
215
+ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
216
+ # @return [Number] a new instance of Number
217
+ #
218
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#28
219
+ def initialize(token, options = T.unsafe(nil)); end
220
+
221
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25
222
+ def human_name; end
223
+
224
+ # Returns the value of attribute number.
225
+ #
226
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25
227
+ def number; end
228
+
229
+ # Returns the value of attribute number.
230
+ #
231
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25
232
+ def reference; end
233
+ end
234
+
235
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49
236
+ class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
237
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27
238
+ def human_name; end
239
+ end
240
+
241
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#51
242
+ class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
243
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28
244
+ def human_name; end
245
+ end
246
+
247
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#53
248
+ class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
249
+ # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel
250
+ #
251
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56
252
+ def initialize(token, options = T.unsafe(nil)); end
253
+
254
+ # Returns the value of attribute recursion_level.
255
+ #
256
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
257
+ def recursion_level; end
258
+ end
259
+
260
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#44
261
+ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
262
+ # Returns the value of attribute effective_number.
263
+ #
264
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
265
+ def effective_number; end
266
+
267
+ # Sets the attribute effective_number
268
+ #
269
+ # @param value the value to set the attribute effective_number to.
270
+ #
271
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
272
+ def effective_number=(_arg0); end
273
+
274
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26
275
+ def human_name; end
276
+
277
+ # Returns the value of attribute effective_number.
278
+ #
279
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
280
+ def reference; end
281
+ end
282
+
283
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#2
284
+ class Regexp::Expression::Base
285
+ include ::Regexp::Expression::Shared
286
+ extend ::Regexp::Expression::Shared::ClassMethods
287
+
288
+ # @return [Base] a new instance of Base
289
+ #
290
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#5
291
+ def initialize(token, options = T.unsafe(nil)); end
292
+
293
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8
294
+ def =~(string, offset = T.unsafe(nil)); end
295
+
296
+ # @return [Boolean]
297
+ #
298
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25
299
+ def a?; end
300
+
301
+ # @return [Boolean]
302
+ #
303
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25
304
+ def ascii_classes?; end
305
+
306
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#60
307
+ def attributes; end
308
+
309
+ # @return [Boolean]
310
+ #
311
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
312
+ def case_insensitive?; end
313
+
314
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
315
+ def conditional_level; end
316
+
317
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
318
+ def conditional_level=(_arg0); end
319
+
320
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
321
+ def custom_to_s_handling; end
322
+
323
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
324
+ def custom_to_s_handling=(_arg0); end
325
+
326
+ # @return [Boolean]
327
+ #
328
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20
329
+ def d?; end
330
+
331
+ # @return [Boolean]
332
+ #
333
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20
334
+ def default_classes?; end
335
+
336
+ # @return [Boolean]
337
+ #
338
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
339
+ def extended?; end
340
+
341
+ # @return [Boolean]
342
+ #
343
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
344
+ def free_spacing?; end
345
+
346
+ # @return [Boolean]
347
+ #
348
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#47
349
+ def greedy?; end
350
+
351
+ # @return [Boolean]
352
+ #
353
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
354
+ def i?; end
355
+
356
+ # @return [Boolean]
357
+ #
358
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
359
+ def ignore_case?; end
360
+
361
+ # @return [Boolean]
362
+ #
363
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#51
364
+ def lazy?; end
365
+
366
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
367
+ def level; end
368
+
369
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
370
+ def level=(_arg0); end
371
+
372
+ # @return [Boolean]
373
+ #
374
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3
375
+ def m?; end
376
+
377
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8
378
+ def match(string, offset = T.unsafe(nil)); end
379
+
380
+ # @return [Boolean]
381
+ #
382
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3
383
+ def match?(string); end
384
+
385
+ # @return [Boolean]
386
+ #
387
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3
388
+ def matches?(string); end
389
+
390
+ # @return [Boolean]
391
+ #
392
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3
393
+ def multiline?; end
394
+
395
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
396
+ def nesting_level; end
397
+
398
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
399
+ def options; end
400
+
401
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
402
+ def options=(_arg0); end
403
+
404
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
405
+ def parent; end
406
+
407
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
408
+ def parent=(_arg0); end
409
+
410
+ # @return [Boolean]
411
+ #
412
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#56
413
+ def possessive?; end
414
+
415
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
416
+ def pre_quantifier_decorations; end
417
+
418
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
419
+ def pre_quantifier_decorations=(_arg0); end
420
+
421
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
422
+ def quantifier; end
423
+
424
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#17
425
+ def quantify(*args); end
426
+
427
+ # Deprecated. Prefer `#repetitions` which has a more uniform interface.
428
+ #
429
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#26
430
+ def quantity; end
431
+
432
+ # @return [Boolean]
433
+ #
434
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#51
435
+ def reluctant?; end
436
+
437
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#31
438
+ def repetitions; end
439
+
440
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
441
+ def set_level; end
442
+
443
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
444
+ def set_level=(_arg0); end
445
+
446
+ # %l Level (depth) of the expression. Returns 'root' for the root
447
+ # expression, returns zero or higher for all others.
448
+ #
449
+ # %> Indentation at expression's level.
450
+ #
451
+ # %x Index of the expression at its depth. Available when using
452
+ # the sprintf_tree method only.
453
+ #
454
+ # %s Start offset within the whole expression.
455
+ # %e End offset within the whole expression.
456
+ # %S Length of expression.
457
+ #
458
+ # %o Coded offset and length, same as '@%s+%S'
459
+ #
460
+ # %y Type of expression.
461
+ # %k Token of expression.
462
+ # %i ID, same as '%y:%k'
463
+ # %c Class name
464
+ #
465
+ # %q Quantifier info, as {m[,M]}
466
+ # %Q Quantifier text
467
+ #
468
+ # %z Quantifier min
469
+ # %Z Quantifier max
470
+ #
471
+ # %t Base text of the expression (excludes quantifier, if any)
472
+ # %~t Full text if the expression is terminal, otherwise %i
473
+ # %T Full text of the expression (includes quantifier, if any)
474
+ #
475
+ # %b Basic info, same as '%o %i'
476
+ # %m Most info, same as '%b %q'
477
+ # %a All info, same as '%m %t'
478
+ #
479
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37
480
+ def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
481
+
482
+ # %l Level (depth) of the expression. Returns 'root' for the root
483
+ # expression, returns zero or higher for all others.
484
+ #
485
+ # %> Indentation at expression's level.
486
+ #
487
+ # %x Index of the expression at its depth. Available when using
488
+ # the sprintf_tree method only.
489
+ #
490
+ # %s Start offset within the whole expression.
491
+ # %e End offset within the whole expression.
492
+ # %S Length of expression.
493
+ #
494
+ # %o Coded offset and length, same as '@%s+%S'
495
+ #
496
+ # %y Type of expression.
497
+ # %k Token of expression.
498
+ # %i ID, same as '%y:%k'
499
+ # %c Class name
500
+ #
501
+ # %q Quantifier info, as {m[,M]}
502
+ # %Q Quantifier text
503
+ #
504
+ # %z Quantifier min
505
+ # %Z Quantifier max
506
+ #
507
+ # %t Base text of the expression (excludes quantifier, if any)
508
+ # %~t Full text if the expression is terminal, otherwise %i
509
+ # %T Full text of the expression (includes quantifier, if any)
510
+ #
511
+ # %b Basic info, same as '%o %i'
512
+ # %m Most info, same as '%b %q'
513
+ # %a All info, same as '%m %t'
514
+ #
515
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37
516
+ def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
517
+
518
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
519
+ def te; end
520
+
521
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
522
+ def te=(_arg0); end
523
+
524
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
525
+ def text; end
526
+
527
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
528
+ def text=(_arg0); end
529
+
530
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#60
531
+ def to_h; end
532
+
533
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#9
534
+ def to_re(format = T.unsafe(nil)); end
535
+
536
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
537
+ def token; end
538
+
539
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
540
+ def token=(_arg0); end
541
+
542
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
543
+ def ts; end
544
+
545
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
546
+ def ts=(_arg0); end
547
+
548
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
549
+ def type; end
550
+
551
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
552
+ def type=(_arg0); end
553
+
554
+ # @return [Boolean]
555
+ #
556
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30
557
+ def u?; end
558
+
559
+ # @return [Boolean]
560
+ #
561
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30
562
+ def unicode_classes?; end
563
+
564
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#21
565
+ def unquantified_clone; end
566
+
567
+ # @return [Boolean]
568
+ #
569
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
570
+ def x?; end
571
+ end
572
+
573
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2
574
+ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
575
+ # @return [CharacterSet] a new instance of CharacterSet
576
+ #
577
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#9
578
+ def initialize(token, options = T.unsafe(nil)); end
579
+
580
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#19
581
+ def close; end
582
+
583
+ # Returns the value of attribute closed.
584
+ #
585
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
586
+ def closed; end
587
+
588
+ # Sets the attribute closed
589
+ #
590
+ # @param value the value to set the attribute closed to.
591
+ #
592
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
593
+ def closed=(_arg0); end
594
+
595
+ # Returns the value of attribute closed.
596
+ #
597
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
598
+ def closed?; end
599
+
600
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
601
+ def match_length; end
602
+
603
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#15
604
+ def negate; end
605
+
606
+ # Returns the value of attribute negative.
607
+ #
608
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
609
+ def negated?; end
610
+
611
+ # Returns the value of attribute negative.
612
+ #
613
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
614
+ def negative; end
615
+
616
+ # Sets the attribute negative
617
+ #
618
+ # @param value the value to set the attribute negative to.
619
+ #
620
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
621
+ def negative=(_arg0); end
622
+
623
+ # Returns the value of attribute negative.
624
+ #
625
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
626
+ def negative?; end
627
+
628
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#15
629
+ def parts; end
630
+ end
631
+
632
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#3
633
+ class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
634
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29
635
+ def human_name; end
636
+
637
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
638
+ def match_length; end
639
+ end
640
+
641
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#5
642
+ class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
643
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30
644
+ def human_name; end
645
+
646
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
647
+ def match_length; end
648
+ end
649
+
650
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#6
651
+ Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
652
+
653
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3
654
+ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
655
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#8
656
+ def <<(exp); end
657
+
658
+ # @return [Boolean]
659
+ #
660
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#14
661
+ def complete?; end
662
+
663
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31
664
+ def human_name; end
665
+
666
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
667
+ def match_length; end
668
+
669
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#16
670
+ def parts; end
671
+
672
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#4
673
+ def ts; end
674
+ end
675
+
676
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#2
677
+ module Regexp::Expression::CharacterType; end
678
+
679
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#5
680
+ class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
681
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#32
682
+ def human_name; end
683
+ end
684
+
685
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3
686
+ class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
687
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
688
+ def match_length; end
689
+ end
690
+
691
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#6
692
+ class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
693
+
694
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#15
695
+ class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
696
+
697
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#8
698
+ class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
699
+
700
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#14
701
+ class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
702
+
703
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#7
704
+ class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
705
+
706
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#9
707
+ class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
708
+
709
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#13
710
+ class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
711
+
712
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#11
713
+ class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
714
+
715
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#12
716
+ class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
717
+
718
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#10
719
+ class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
720
+
721
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#8
722
+ class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
723
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33
724
+ def human_name; end
725
+
726
+ class << self
727
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#130
728
+ def comment?; end
729
+ end
730
+ end
731
+
732
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2
733
+ module Regexp::Expression::Conditional; end
734
+
735
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25
736
+ class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
737
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34
738
+ def human_name; end
739
+ end
740
+
741
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#9
742
+ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
743
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35
744
+ def human_name; end
745
+
746
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
747
+ def match_length; end
748
+
749
+ # Name or number of the referenced capturing group that determines state.
750
+ # Returns a String if reference is by name, Integer if by number.
751
+ #
752
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#14
753
+ def reference; end
754
+
755
+ # Returns the value of attribute referenced_expression.
756
+ #
757
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
758
+ def referenced_expression; end
759
+
760
+ # Sets the attribute referenced_expression
761
+ #
762
+ # @param value the value to set the attribute referenced_expression to.
763
+ #
764
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
765
+ def referenced_expression=(_arg0); end
766
+
767
+ private
768
+
769
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19
770
+ def initialize_copy(orig); end
771
+
772
+ class << self
773
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#141
774
+ def referential?; end
775
+ end
776
+ end
777
+
778
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#27
779
+ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
780
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30
781
+ def <<(exp); end
782
+
783
+ # @raise [TooManyBranches]
784
+ #
785
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
786
+ def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
787
+
788
+ # @raise [TooManyBranches]
789
+ #
790
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
791
+ def branch(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
792
+
793
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
794
+ def branches; end
795
+
796
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46
797
+ def condition; end
798
+
799
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41
800
+ def condition=(exp); end
801
+
802
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36
803
+ def human_name; end
804
+
805
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
806
+ def match_length; end
807
+
808
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#17
809
+ def parts; end
810
+
811
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
812
+ def reference; end
813
+
814
+ # Returns the value of attribute referenced_expression.
815
+ #
816
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
817
+ def referenced_expression; end
818
+
819
+ # Sets the attribute referenced_expression
820
+ #
821
+ # @param value the value to set the attribute referenced_expression to.
822
+ #
823
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
824
+ def referenced_expression=(_arg0); end
825
+
826
+ private
827
+
828
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
829
+ def initialize_copy(orig); end
830
+
831
+ class << self
832
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#142
833
+ def referential?; end
834
+ end
835
+ end
836
+
837
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3
838
+ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
839
+ # @return [TooManyBranches] a new instance of TooManyBranches
840
+ #
841
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#4
842
+ def initialize; end
843
+ end
844
+
845
+ # alias for symmetry between Token::* and Expression::*
846
+ #
847
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#101
848
+ Regexp::Expression::Escape = Regexp::Expression::EscapeSequence
849
+
850
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#2
851
+ module Regexp::Expression::EscapeSequence; end
852
+
853
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#63
854
+ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
855
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64
856
+ def char; end
857
+
858
+ private
859
+
860
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#70
861
+ def control_sequence_to_s(control_sequence); end
862
+
863
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#75
864
+ def meta_char_to_codepoint(meta_char); end
865
+ end
866
+
867
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#27
868
+ class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
869
+
870
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28
871
+ class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
872
+
873
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3
874
+ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
875
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#9
876
+ def char; end
877
+
878
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4
879
+ def codepoint; end
880
+
881
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
882
+ def match_length; end
883
+ end
884
+
885
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29
886
+ class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
887
+
888
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37
889
+ class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
890
+
891
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#39
892
+ class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
893
+ # @raise [NoMethodError]
894
+ #
895
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40
896
+ def char; end
897
+
898
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#48
899
+ def chars; end
900
+
901
+ # @raise [NoMethodError]
902
+ #
903
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#44
904
+ def codepoint; end
905
+
906
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#52
907
+ def codepoints; end
908
+
909
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164
910
+ def match_length; end
911
+ end
912
+
913
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#81
914
+ class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
915
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82
916
+ def codepoint; end
917
+ end
918
+
919
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30
920
+ class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
921
+
922
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#36
923
+ class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
924
+
925
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#21
926
+ class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
927
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22
928
+ def char; end
929
+ end
930
+
931
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#87
932
+ class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
933
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88
934
+ def codepoint; end
935
+ end
936
+
937
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#93
938
+ class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
939
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94
940
+ def codepoint; end
941
+ end
942
+
943
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31
944
+ class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
945
+
946
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#57
947
+ class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
948
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58
949
+ def char; end
950
+ end
951
+
952
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32
953
+ class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
954
+
955
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33
956
+ class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
957
+
958
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34
959
+ class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
960
+
961
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2
962
+ class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
963
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
964
+ def match_length; end
965
+
966
+ # @raise [Regexp::Parser::Error]
967
+ #
968
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#3
969
+ def quantify(*_args); end
970
+
971
+ class << self
972
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#135
973
+ def decorative?; end
974
+ end
975
+ end
976
+
977
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2
978
+ module Regexp::Expression::Group; end
979
+
980
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#19
981
+ class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
982
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172
983
+ def match_length; end
984
+ end
985
+
986
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#20
987
+ class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
988
+
989
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3
990
+ class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
991
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#18
992
+ def parts; end
993
+ end
994
+
995
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#40
996
+ class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
997
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#37
998
+ def human_name; end
999
+
1000
+ # Returns the value of attribute number.
1001
+ #
1002
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1003
+ def identifier; end
1004
+
1005
+ # Returns the value of attribute number.
1006
+ #
1007
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1008
+ def number; end
1009
+
1010
+ # Sets the attribute number
1011
+ #
1012
+ # @param value the value to set the attribute number to.
1013
+ #
1014
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1015
+ def number=(_arg0); end
1016
+
1017
+ # Returns the value of attribute number_at_level.
1018
+ #
1019
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1020
+ def number_at_level; end
1021
+
1022
+ # Sets the attribute number_at_level
1023
+ #
1024
+ # @param value the value to set the attribute number_at_level to.
1025
+ #
1026
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1027
+ def number_at_level=(_arg0); end
1028
+
1029
+ class << self
1030
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#126
1031
+ def capturing?; end
1032
+ end
1033
+ end
1034
+
1035
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#60
1036
+ class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
1037
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#20
1038
+ def parts; end
1039
+
1040
+ class << self
1041
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#131
1042
+ def comment?; end
1043
+
1044
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#136
1045
+ def decorative?; end
1046
+ end
1047
+ end
1048
+
1049
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#45
1050
+ class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
1051
+ # @return [Named] a new instance of Named
1052
+ #
1053
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#49
1054
+ def initialize(token, options = T.unsafe(nil)); end
1055
+
1056
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#38
1057
+ def human_name; end
1058
+
1059
+ # Returns the value of attribute name.
1060
+ #
1061
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46
1062
+ def identifier; end
1063
+
1064
+ # Returns the value of attribute name.
1065
+ #
1066
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46
1067
+ def name; end
1068
+
1069
+ private
1070
+
1071
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#54
1072
+ def initialize_copy(orig); end
1073
+ end
1074
+
1075
+ # TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no
1076
+ # longer inherit from Group because it is effectively a terminal expression.
1077
+ #
1078
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#23
1079
+ class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
1080
+ # Returns the value of attribute option_changes.
1081
+ #
1082
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24
1083
+ def option_changes; end
1084
+
1085
+ # Sets the attribute option_changes
1086
+ #
1087
+ # @param value the value to set the attribute option_changes to.
1088
+ #
1089
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24
1090
+ def option_changes=(_arg0); end
1091
+
1092
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#31
1093
+ def quantify(*args); end
1094
+
1095
+ private
1096
+
1097
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#26
1098
+ def initialize_copy(orig); end
1099
+ end
1100
+
1101
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#6
1102
+ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
1103
+ # @return [Passive] a new instance of Passive
1104
+ #
1105
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#9
1106
+ def initialize(*_arg0); end
1107
+
1108
+ # Sets the attribute implicit
1109
+ #
1110
+ # @param value the value to set the attribute implicit to.
1111
+ #
1112
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#7
1113
+ def implicit=(_arg0); end
1114
+
1115
+ # @return [Boolean]
1116
+ #
1117
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#14
1118
+ def implicit?; end
1119
+
1120
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#19
1121
+ def parts; end
1122
+ end
1123
+
1124
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#2
1125
+ module Regexp::Expression::Keep; end
1126
+
1127
+ # TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression
1128
+ # that contains all expressions to its left.
1129
+ #
1130
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#5
1131
+ class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
1132
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39
1133
+ def human_name; end
1134
+
1135
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
1136
+ def match_length; end
1137
+ end
1138
+
1139
+ # source://regexp_parser//lib/regexp_parser/expression/classes/literal.rb#2
1140
+ class Regexp::Expression::Literal < ::Regexp::Expression::Base
1141
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40
1142
+ def human_name; end
1143
+
1144
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#105
1145
+ def match_length; end
1146
+ end
1147
+
1148
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85
1149
+ Regexp::Expression::MatchLength = Regexp::MatchLength
1150
+
1151
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#14
1152
+ Regexp::Expression::Nonposixclass = Regexp::Expression::PosixClass
1153
+
1154
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#121
1155
+ Regexp::Expression::Nonproperty = Regexp::Expression::UnicodeProperty
1156
+
1157
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2
1158
+ class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
1159
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1160
+ def match_length; end
1161
+
1162
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#7
1163
+ def name; end
1164
+
1165
+ # @return [Boolean]
1166
+ #
1167
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#3
1168
+ def negative?; end
1169
+ end
1170
+
1171
+ # alias for symmetry between token symbol and Expression class name
1172
+ #
1173
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#13
1174
+ Regexp::Expression::Posixclass = Regexp::Expression::PosixClass
1175
+
1176
+ # alias for symmetry between token symbol and Expression class name
1177
+ #
1178
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#120
1179
+ Regexp::Expression::Property = Regexp::Expression::UnicodeProperty
1180
+
1181
+ # TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and
1182
+ # call super in #initialize, but raise in #quantifier= and #quantify,
1183
+ # or introduce an Expression::Quantifiable intermediate class.
1184
+ # Or actually allow chaining as a more concise but tricky solution than PR#69.
1185
+ #
1186
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#6
1187
+ class Regexp::Expression::Quantifier
1188
+ include ::Regexp::Expression::Shared
1189
+ extend ::Regexp::Expression::Shared::ClassMethods
1190
+
1191
+ # @return [Quantifier] a new instance of Quantifier
1192
+ #
1193
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11
1194
+ def initialize(*args); end
1195
+
1196
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1197
+ def conditional_level; end
1198
+
1199
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1200
+ def conditional_level=(_arg0); end
1201
+
1202
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1203
+ def custom_to_s_handling; end
1204
+
1205
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1206
+ def custom_to_s_handling=(_arg0); end
1207
+
1208
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1209
+ def greedy?; end
1210
+
1211
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1212
+ def lazy?; end
1213
+
1214
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1215
+ def level; end
1216
+
1217
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1218
+ def level=(_arg0); end
1219
+
1220
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#42
1221
+ def max; end
1222
+
1223
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#38
1224
+ def min; end
1225
+
1226
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#46
1227
+ def mode; end
1228
+
1229
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
1230
+ def nesting_level; end
1231
+
1232
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1233
+ def options; end
1234
+
1235
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1236
+ def options=(_arg0); end
1237
+
1238
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1239
+ def parent; end
1240
+
1241
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1242
+ def parent=(_arg0); end
1243
+
1244
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1245
+ def possessive?; end
1246
+
1247
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1248
+ def pre_quantifier_decorations; end
1249
+
1250
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1251
+ def pre_quantifier_decorations=(_arg0); end
1252
+
1253
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
1254
+ def quantifier; end
1255
+
1256
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1257
+ def reluctant?; end
1258
+
1259
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1260
+ def set_level; end
1261
+
1262
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1263
+ def set_level=(_arg0); end
1264
+
1265
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1266
+ def te; end
1267
+
1268
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1269
+ def te=(_arg0); end
1270
+
1271
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1272
+ def text; end
1273
+
1274
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1275
+ def text=(_arg0); end
1276
+
1277
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#19
1278
+ def to_h; end
1279
+
1280
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1281
+ def token; end
1282
+
1283
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1284
+ def token=(_arg0); end
1285
+
1286
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1287
+ def ts; end
1288
+
1289
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1290
+ def ts=(_arg0); end
1291
+
1292
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1293
+ def type; end
1294
+
1295
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1296
+ def type=(_arg0); end
1297
+
1298
+ private
1299
+
1300
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#52
1301
+ def deprecated_old_init(token, text, _min, _max, _mode = T.unsafe(nil)); end
1302
+
1303
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#64
1304
+ def derived_data; end
1305
+ end
1306
+
1307
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9
1308
+ Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
1309
+
1310
+ # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#2
1311
+ class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
1312
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#41
1313
+ def human_name; end
1314
+
1315
+ class << self
1316
+ # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#3
1317
+ def build(options = T.unsafe(nil)); end
1318
+ end
1319
+ end
1320
+
1321
+ # A sequence of expressions. Differs from a Subexpressions by how it handles
1322
+ # quantifiers, as it applies them to its last element instead of itself as
1323
+ # a whole subexpression.
1324
+ #
1325
+ # Used as the base class for the Alternation alternatives, Conditional
1326
+ # branches, and CharacterSet::Intersection intersected sequences.
1327
+ #
1328
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8
1329
+ class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1330
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27
1331
+ def quantify(token, *args); end
1332
+
1333
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1334
+ def ts; end
1335
+
1336
+ class << self
1337
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#10
1338
+ def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
1339
+ end
1340
+ end
1341
+
1342
+ # abstract class
1343
+ #
1344
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3
1345
+ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
1346
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#12
1347
+ def <<(exp); end
1348
+
1349
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#16
1350
+ def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
1351
+
1352
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1353
+ def operands; end
1354
+
1355
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1356
+ def operator; end
1357
+
1358
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#22
1359
+ def parts; end
1360
+
1361
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1362
+ def sequences; end
1363
+
1364
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#8
1365
+ def ts; end
1366
+ end
1367
+
1368
+ # alias for symmetry between token symbol and Expression class name
1369
+ #
1370
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#25
1371
+ Regexp::Expression::Set = Regexp::Expression::CharacterSet
1372
+
1373
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#2
1374
+ module Regexp::Expression::Shared
1375
+ mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
1376
+
1377
+ # Deep-compare two expressions for equality.
1378
+ #
1379
+ # When changing the conditions, please make sure to update
1380
+ # #pretty_print_instance_variables so that it includes all relevant values.
1381
+ #
1382
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
1383
+ def ==(other); end
1384
+
1385
+ # Deep-compare two expressions for equality.
1386
+ #
1387
+ # When changing the conditions, please make sure to update
1388
+ # #pretty_print_instance_variables so that it includes all relevant values.
1389
+ #
1390
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
1391
+ def ===(other); end
1392
+
1393
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#51
1394
+ def base_length; end
1395
+
1396
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#124
1397
+ def capturing?; end
1398
+
1399
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#96
1400
+ def coded_offset; end
1401
+
1402
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#128
1403
+ def comment?; end
1404
+
1405
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#133
1406
+ def decorative?; end
1407
+
1408
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#47
1409
+ def ends_at(include_quantifier = T.unsafe(nil)); end
1410
+
1411
+ # Deep-compare two expressions for equality.
1412
+ #
1413
+ # When changing the conditions, please make sure to update
1414
+ # #pretty_print_instance_variables so that it includes all relevant values.
1415
+ #
1416
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
1417
+ def eql?(other); end
1418
+
1419
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#55
1420
+ def full_length; end
1421
+
1422
+ # default implementation, e.g. "atomic group", "hex escape", "word type", ..
1423
+ #
1424
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#4
1425
+ def human_name; end
1426
+
1427
+ # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#3
1428
+ def inspect; end
1429
+
1430
+ # Test if this expression has the given test_token, and optionally a given
1431
+ # test_type.
1432
+ #
1433
+ # # Any expressions
1434
+ # exp.is? :* # always returns true
1435
+ #
1436
+ # # is it a :capture
1437
+ # exp.is? :capture
1438
+ #
1439
+ # # is it a :character and a :set
1440
+ # exp.is? :character, :set
1441
+ #
1442
+ # # is it a :meta :dot
1443
+ # exp.is? :dot, :meta
1444
+ #
1445
+ # # is it a :meta or :escape :dot
1446
+ # exp.is? :dot, [:meta, :escape]
1447
+ #
1448
+ # @return [Boolean]
1449
+ #
1450
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36
1451
+ def is?(test_token, test_type = T.unsafe(nil)); end
1452
+
1453
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#100
1454
+ def nesting_level=(lvl); end
1455
+
1456
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#92
1457
+ def offset; end
1458
+
1459
+ # Test if this expression matches an entry in the given scope spec.
1460
+ #
1461
+ # A scope spec can be one of:
1462
+ #
1463
+ # . An array: Interpreted as a set of tokens, tested for inclusion
1464
+ # of the expression's token.
1465
+ #
1466
+ # . A hash: Where the key is interpreted as the expression type
1467
+ # and the value is either a symbol or an array. In this
1468
+ # case, when the scope is a hash, one_of? calls itself to
1469
+ # evaluate the key's value.
1470
+ #
1471
+ # . A symbol: matches the expression's token or type, depending on
1472
+ # the level of the call. If one_of? is called directly with
1473
+ # a symbol then it will always be checked against the
1474
+ # type of the expression. If it's being called for a value
1475
+ # from a hash, it will be checked against the token of the
1476
+ # expression.
1477
+ #
1478
+ # # any expression
1479
+ # exp.one_of?(:*) # always true
1480
+ #
1481
+ # # like exp.type?(:group)
1482
+ # exp.one_of?(:group)
1483
+ #
1484
+ # # any expression of type meta
1485
+ # exp.one_of?(:meta => :*)
1486
+ #
1487
+ # # meta dots and alternations
1488
+ # exp.one_of?(:meta => [:dot, :alternation])
1489
+ #
1490
+ # # meta dots and any set tokens
1491
+ # exp.one_of?({meta: [:dot], set: :*})
1492
+ #
1493
+ # @return [Boolean]
1494
+ #
1495
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#75
1496
+ def one_of?(scope, top = T.unsafe(nil)); end
1497
+
1498
+ # @return [Boolean]
1499
+ #
1500
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#111
1501
+ def optional?; end
1502
+
1503
+ # default implementation
1504
+ #
1505
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#4
1506
+ def parts; end
1507
+
1508
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#84
1509
+ def pre_quantifier_decoration(expression_format = T.unsafe(nil)); end
1510
+
1511
+ # Make pretty-print work despite #inspect implementation.
1512
+ #
1513
+ # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#12
1514
+ def pretty_print(q); end
1515
+
1516
+ # Called by pretty_print (ruby/pp) and #inspect.
1517
+ #
1518
+ # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#17
1519
+ def pretty_print_instance_variables; end
1520
+
1521
+ # @return [Boolean]
1522
+ #
1523
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#115
1524
+ def quantified?; end
1525
+
1526
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#106
1527
+ def quantifier=(qtf); end
1528
+
1529
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#88
1530
+ def quantifier_affix(expression_format = T.unsafe(nil)); end
1531
+
1532
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#138
1533
+ def referential?; end
1534
+
1535
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#43
1536
+ def starts_at; end
1537
+
1538
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#120
1539
+ def terminal?; end
1540
+
1541
+ # #to_s reproduces the original source, as an unparser would.
1542
+ #
1543
+ # It takes an optional format argument.
1544
+ #
1545
+ # Example:
1546
+ #
1547
+ # lit = Regexp::Parser.parse(/a +/x)[0]
1548
+ #
1549
+ # lit.to_s # => 'a+' # default; with quantifier
1550
+ # lit.to_s(:full) # => 'a+' # default; with quantifier
1551
+ # lit.to_s(:base) # => 'a' # without quantifier
1552
+ # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
1553
+ #
1554
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72
1555
+ def to_s(format = T.unsafe(nil)); end
1556
+
1557
+ # #to_s reproduces the original source, as an unparser would.
1558
+ #
1559
+ # It takes an optional format argument.
1560
+ #
1561
+ # Example:
1562
+ #
1563
+ # lit = Regexp::Parser.parse(/a +/x)[0]
1564
+ #
1565
+ # lit.to_s # => 'a+' # default; with quantifier
1566
+ # lit.to_s(:full) # => 'a+' # default; with quantifier
1567
+ # lit.to_s(:base) # => 'a' # without quantifier
1568
+ # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
1569
+ #
1570
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72
1571
+ def to_str(format = T.unsafe(nil)); end
1572
+
1573
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#37
1574
+ def token_class; end
1575
+
1576
+ # Test if this expression has the given test_type, which can be either
1577
+ # a symbol or an array of symbols to check against the expression's type.
1578
+ #
1579
+ # # is it a :group expression
1580
+ # exp.type? :group
1581
+ #
1582
+ # # is it a :set, or :meta
1583
+ # exp.type? [:set, :meta]
1584
+ #
1585
+ # @return [Boolean]
1586
+ #
1587
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#13
1588
+ def type?(test_type); end
1589
+
1590
+ private
1591
+
1592
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#18
1593
+ def init_from_token_and_options(token, options = T.unsafe(nil)); end
1594
+
1595
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#32
1596
+ def initialize_copy(orig); end
1597
+
1598
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#10
1599
+ def intersperse(expressions, separator); end
1600
+
1601
+ class << self
1602
+ # @private
1603
+ #
1604
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#5
1605
+ def included(mod); end
1606
+ end
1607
+ end
1608
+
1609
+ # filled in ./methods/*.rb
1610
+ #
1611
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#3
1612
+ module Regexp::Expression::Shared::ClassMethods
1613
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#125
1614
+ def capturing?; end
1615
+
1616
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#129
1617
+ def comment?; end
1618
+
1619
+ # Convenience method to init a valid Expression without a Regexp::Token
1620
+ #
1621
+ # @raise [ArgumentError]
1622
+ #
1623
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#5
1624
+ def construct(params = T.unsafe(nil)); end
1625
+
1626
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#15
1627
+ def construct_defaults; end
1628
+
1629
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#134
1630
+ def decorative?; end
1631
+
1632
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#139
1633
+ def referential?; end
1634
+
1635
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#121
1636
+ def terminal?; end
1637
+
1638
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#25
1639
+ def token_class; end
1640
+ end
1641
+
1642
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#2
1643
+ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1644
+ include ::Enumerable
1645
+
1646
+ # @return [Subexpression] a new instance of Subexpression
1647
+ #
1648
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#7
1649
+ def initialize(token, options = T.unsafe(nil)); end
1650
+
1651
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#20
1652
+ def <<(exp); end
1653
+
1654
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1655
+ def [](*args, &block); end
1656
+
1657
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1658
+ def at(*args, &block); end
1659
+
1660
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#33
1661
+ def dig(*indices); end
1662
+
1663
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1664
+ def each(*args, &block); end
1665
+
1666
+ # Traverses the expression, passing each recursive child to the
1667
+ # given block.
1668
+ # If the block takes two arguments, the indices of the children within
1669
+ # their parents are also passed to it.
1670
+ #
1671
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#8
1672
+ def each_expression(include_self = T.unsafe(nil), &block); end
1673
+
1674
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1675
+ def empty?(*args, &block); end
1676
+
1677
+ # Returns the value of attribute expressions.
1678
+ #
1679
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1680
+ def expressions; end
1681
+
1682
+ # Sets the attribute expressions
1683
+ #
1684
+ # @param value the value to set the attribute expressions to.
1685
+ #
1686
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1687
+ def expressions=(_arg0); end
1688
+
1689
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#50
1690
+ def extract_quantifier_target(quantifier_description); end
1691
+
1692
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1693
+ def fetch(*args, &block); end
1694
+
1695
+ # Returns a new array with the results of calling the given block once
1696
+ # for every expression. If a block is not given, returns an array with
1697
+ # each expression and its level index as an array.
1698
+ #
1699
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#56
1700
+ def flat_map(include_self = T.unsafe(nil), &block); end
1701
+
1702
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1703
+ def index(*args, &block); end
1704
+
1705
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118
1706
+ def inner_match_length; end
1707
+
1708
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1709
+ def join(*args, &block); end
1710
+
1711
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1712
+ def last(*args, &block); end
1713
+
1714
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1715
+ def length(*args, &block); end
1716
+
1717
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111
1718
+ def match_length; end
1719
+
1720
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#21
1721
+ def parts; end
1722
+
1723
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1724
+ def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1725
+
1726
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1727
+ def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1728
+
1729
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#39
1730
+ def te; end
1731
+
1732
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#43
1733
+ def to_h; end
1734
+
1735
+ # Traverses the subexpression (depth-first, pre-order) and calls the given
1736
+ # block for each expression with three arguments; the traversal event,
1737
+ # the expression, and the index of the expression within its parent.
1738
+ #
1739
+ # The event argument is passed as follows:
1740
+ #
1741
+ # - For subexpressions, :enter upon entering the subexpression, and
1742
+ # :exit upon exiting it.
1743
+ #
1744
+ # - For terminal expressions, :visit is called once.
1745
+ #
1746
+ # Returns self.
1747
+ #
1748
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32
1749
+ def traverse(include_self = T.unsafe(nil), &block); end
1750
+
1751
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1752
+ def values_at(*args, &block); end
1753
+
1754
+ # Traverses the subexpression (depth-first, pre-order) and calls the given
1755
+ # block for each expression with three arguments; the traversal event,
1756
+ # the expression, and the index of the expression within its parent.
1757
+ #
1758
+ # The event argument is passed as follows:
1759
+ #
1760
+ # - For subexpressions, :enter upon entering the subexpression, and
1761
+ # :exit upon exiting it.
1762
+ #
1763
+ # - For terminal expressions, :visit is called once.
1764
+ #
1765
+ # Returns self.
1766
+ #
1767
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32
1768
+ def walk(include_self = T.unsafe(nil), &block); end
1769
+
1770
+ protected
1771
+
1772
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#66
1773
+ def each_expression_with_index(&block); end
1774
+
1775
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#73
1776
+ def each_expression_without_index(&block); end
1777
+
1778
+ private
1779
+
1780
+ # Override base method to clone the expressions as well.
1781
+ #
1782
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13
1783
+ def initialize_copy(orig); end
1784
+
1785
+ class << self
1786
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#122
1787
+ def terminal?; end
1788
+ end
1789
+ end
1790
+
1791
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#2
1792
+ module Regexp::Expression::UnicodeProperty; end
1793
+
1794
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#112
1795
+ class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
1796
+
1797
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#17
1798
+ class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
1799
+
1800
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18
1801
+ class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
1802
+
1803
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#35
1804
+ class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
1805
+
1806
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19
1807
+ class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
1808
+
1809
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#36
1810
+ class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
1811
+
1812
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3
1813
+ class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1814
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1815
+ def match_length; end
1816
+
1817
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#8
1818
+ def name; end
1819
+
1820
+ # @return [Boolean]
1821
+ #
1822
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4
1823
+ def negative?; end
1824
+
1825
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#12
1826
+ def shortcut; end
1827
+ end
1828
+
1829
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20
1830
+ class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
1831
+
1832
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#116
1833
+ class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
1834
+
1835
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21
1836
+ class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
1837
+
1838
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#101
1839
+ module Regexp::Expression::UnicodeProperty::Codepoint; end
1840
+
1841
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#104
1842
+ class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1843
+
1844
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102
1845
+ class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1846
+
1847
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105
1848
+ class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1849
+
1850
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#106
1851
+ class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1852
+
1853
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108
1854
+ class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1855
+
1856
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#107
1857
+ class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1858
+
1859
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109
1860
+ class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1861
+
1862
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113
1863
+ class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
1864
+
1865
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22
1866
+ class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
1867
+
1868
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#114
1869
+ class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
1870
+
1871
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23
1872
+ class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
1873
+
1874
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#38
1875
+ module Regexp::Expression::UnicodeProperty::Letter; end
1876
+
1877
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#41
1878
+ class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1879
+
1880
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39
1881
+ class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1882
+
1883
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42
1884
+ class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1885
+
1886
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#44
1887
+ class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1888
+
1889
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46
1890
+ class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1891
+
1892
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47
1893
+ class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1894
+
1895
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#45
1896
+ class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1897
+
1898
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43
1899
+ class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1900
+
1901
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24
1902
+ class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
1903
+
1904
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#50
1905
+ module Regexp::Expression::UnicodeProperty::Mark; end
1906
+
1907
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#53
1908
+ class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1909
+
1910
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51
1911
+ class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1912
+
1913
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#54
1914
+ class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1915
+
1916
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57
1917
+ class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1918
+
1919
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#55
1920
+ class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1921
+
1922
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56
1923
+ class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1924
+
1925
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#33
1926
+ class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
1927
+
1928
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#60
1929
+ module Regexp::Expression::UnicodeProperty::Number; end
1930
+
1931
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#63
1932
+ class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1933
+
1934
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61
1935
+ class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1936
+
1937
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#64
1938
+ class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1939
+
1940
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65
1941
+ class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1942
+
1943
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66
1944
+ class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1945
+
1946
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25
1947
+ class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
1948
+
1949
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26
1950
+ class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
1951
+
1952
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#69
1953
+ module Regexp::Expression::UnicodeProperty::Punctuation; end
1954
+
1955
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#72
1956
+ class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1957
+
1958
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70
1959
+ class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1960
+
1961
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#76
1962
+ class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1963
+
1964
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73
1965
+ class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1966
+
1967
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74
1968
+ class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1969
+
1970
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78
1971
+ class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1972
+
1973
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#77
1974
+ class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1975
+
1976
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75
1977
+ class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1978
+
1979
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79
1980
+ class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1981
+
1982
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#115
1983
+ class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
1984
+
1985
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#82
1986
+ module Regexp::Expression::UnicodeProperty::Separator; end
1987
+
1988
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#85
1989
+ class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1990
+
1991
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83
1992
+ class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1993
+
1994
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87
1995
+ class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1996
+
1997
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88
1998
+ class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1999
+
2000
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#86
2001
+ class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
2002
+
2003
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27
2004
+ class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
2005
+
2006
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#91
2007
+ module Regexp::Expression::UnicodeProperty::Symbol; end
2008
+
2009
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#94
2010
+ class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2011
+
2012
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92
2013
+ class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
2014
+
2015
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#96
2016
+ class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2017
+
2018
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#95
2019
+ class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2020
+
2021
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97
2022
+ class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2023
+
2024
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98
2025
+ class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2026
+
2027
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#28
2028
+ class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
2029
+
2030
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29
2031
+ class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
2032
+
2033
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31
2034
+ class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
2035
+
2036
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#30
2037
+ class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
2038
+
2039
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#11
2040
+ class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
2041
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42
2042
+ def human_name; end
2043
+
2044
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#12
2045
+ def merge(exp); end
2046
+ end
2047
+
2048
+ # A very thin wrapper around the scanner that breaks quantified literal runs,
2049
+ # collects emitted tokens into an array, calculates their nesting depth, and
2050
+ # normalizes tokens for the parser, and checks if they are implemented by the
2051
+ # given syntax flavor.
2052
+ #
2053
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#5
2054
+ class Regexp::Lexer
2055
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#71
2056
+ def emit(token); end
2057
+
2058
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#20
2059
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2060
+
2061
+ private
2062
+
2063
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#91
2064
+ def ascend(type, token); end
2065
+
2066
+ # Returns the value of attribute block.
2067
+ #
2068
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2069
+ def block; end
2070
+
2071
+ # Sets the attribute block
2072
+ #
2073
+ # @param value the value to set the attribute block to.
2074
+ #
2075
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2076
+ def block=(_arg0); end
2077
+
2078
+ # if a codepoint list is followed by a quantifier, that quantifier applies
2079
+ # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc'
2080
+ # c.f. #break_literal.
2081
+ #
2082
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#143
2083
+ def break_codepoint_list(token); end
2084
+
2085
+ # called by scan to break a literal run that is longer than one character
2086
+ # into two separate tokens when it is followed by a quantifier
2087
+ #
2088
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#123
2089
+ def break_literal(token); end
2090
+
2091
+ # Returns the value of attribute collect_tokens.
2092
+ #
2093
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2094
+ def collect_tokens; end
2095
+
2096
+ # Sets the attribute collect_tokens
2097
+ #
2098
+ # @param value the value to set the attribute collect_tokens to.
2099
+ #
2100
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2101
+ def collect_tokens=(_arg0); end
2102
+
2103
+ # Returns the value of attribute conditional_nesting.
2104
+ #
2105
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2106
+ def conditional_nesting; end
2107
+
2108
+ # Sets the attribute conditional_nesting
2109
+ #
2110
+ # @param value the value to set the attribute conditional_nesting to.
2111
+ #
2112
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2113
+ def conditional_nesting=(_arg0); end
2114
+
2115
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#106
2116
+ def descend(type, token); end
2117
+
2118
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#162
2119
+ def merge_condition(current, last); end
2120
+
2121
+ # Returns the value of attribute nesting.
2122
+ #
2123
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2124
+ def nesting; end
2125
+
2126
+ # Sets the attribute nesting
2127
+ #
2128
+ # @param value the value to set the attribute nesting to.
2129
+ #
2130
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2131
+ def nesting=(_arg0); end
2132
+
2133
+ # Returns the value of attribute preprev_token.
2134
+ #
2135
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2136
+ def preprev_token; end
2137
+
2138
+ # Sets the attribute preprev_token
2139
+ #
2140
+ # @param value the value to set the attribute preprev_token to.
2141
+ #
2142
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2143
+ def preprev_token=(_arg0); end
2144
+
2145
+ # Returns the value of attribute prev_token.
2146
+ #
2147
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2148
+ def prev_token; end
2149
+
2150
+ # Sets the attribute prev_token
2151
+ #
2152
+ # @param value the value to set the attribute prev_token to.
2153
+ #
2154
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2155
+ def prev_token=(_arg0); end
2156
+
2157
+ # Returns the value of attribute set_nesting.
2158
+ #
2159
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2160
+ def set_nesting; end
2161
+
2162
+ # Sets the attribute set_nesting
2163
+ #
2164
+ # @param value the value to set the attribute set_nesting to.
2165
+ #
2166
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2167
+ def set_nesting=(_arg0); end
2168
+
2169
+ # Returns the value of attribute shift.
2170
+ #
2171
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2172
+ def shift; end
2173
+
2174
+ # Sets the attribute shift
2175
+ #
2176
+ # @param value the value to set the attribute shift to.
2177
+ #
2178
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2179
+ def shift=(_arg0); end
2180
+
2181
+ # Returns the value of attribute tokens.
2182
+ #
2183
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2184
+ def tokens; end
2185
+
2186
+ # Sets the attribute tokens
2187
+ #
2188
+ # @param value the value to set the attribute tokens to.
2189
+ #
2190
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2191
+ def tokens=(_arg0); end
2192
+
2193
+ class << self
2194
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#16
2195
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2196
+
2197
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#16
2198
+ def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2199
+ end
2200
+ end
2201
+
2202
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#12
2203
+ Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
2204
+
2205
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#14
2206
+ Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
2207
+
2208
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#7
2209
+ Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
2210
+
2211
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#1
2212
+ class Regexp::MatchLength
2213
+ include ::Enumerable
2214
+
2215
+ # @return [MatchLength] a new instance of MatchLength
2216
+ #
2217
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#9
2218
+ def initialize(exp, opts = T.unsafe(nil)); end
2219
+
2220
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#24
2221
+ def each(opts = T.unsafe(nil)); end
2222
+
2223
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#35
2224
+ def endless_each; end
2225
+
2226
+ # @return [Boolean]
2227
+ #
2228
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#44
2229
+ def fixed?; end
2230
+
2231
+ # @return [Boolean]
2232
+ #
2233
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#40
2234
+ def include?(length); end
2235
+
2236
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#60
2237
+ def inspect; end
2238
+
2239
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#52
2240
+ def max; end
2241
+
2242
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#48
2243
+ def min; end
2244
+
2245
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#56
2246
+ def minmax; end
2247
+
2248
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#65
2249
+ def to_re; end
2250
+
2251
+ private
2252
+
2253
+ # Returns the value of attribute base_max.
2254
+ #
2255
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2256
+ def base_max; end
2257
+
2258
+ # Sets the attribute base_max
2259
+ #
2260
+ # @param value the value to set the attribute base_max to.
2261
+ #
2262
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2263
+ def base_max=(_arg0); end
2264
+
2265
+ # Returns the value of attribute base_min.
2266
+ #
2267
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2268
+ def base_min; end
2269
+
2270
+ # Sets the attribute base_min
2271
+ #
2272
+ # @param value the value to set the attribute base_min to.
2273
+ #
2274
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2275
+ def base_min=(_arg0); end
2276
+
2277
+ # Returns the value of attribute exp_class.
2278
+ #
2279
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2280
+ def exp_class; end
2281
+
2282
+ # Sets the attribute exp_class
2283
+ #
2284
+ # @param value the value to set the attribute exp_class to.
2285
+ #
2286
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2287
+ def exp_class=(_arg0); end
2288
+
2289
+ # Returns the value of attribute max_rep.
2290
+ #
2291
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2292
+ def max_rep; end
2293
+
2294
+ # Sets the attribute max_rep
2295
+ #
2296
+ # @param value the value to set the attribute max_rep to.
2297
+ #
2298
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2299
+ def max_rep=(_arg0); end
2300
+
2301
+ # Returns the value of attribute min_rep.
2302
+ #
2303
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2304
+ def min_rep; end
2305
+
2306
+ # Sets the attribute min_rep
2307
+ #
2308
+ # @param value the value to set the attribute min_rep to.
2309
+ #
2310
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2311
+ def min_rep=(_arg0); end
2312
+
2313
+ # Returns the value of attribute reify.
2314
+ #
2315
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2316
+ def reify; end
2317
+
2318
+ # Sets the attribute reify
2319
+ #
2320
+ # @param value the value to set the attribute reify to.
2321
+ #
2322
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2323
+ def reify=(_arg0); end
2324
+
2325
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#74
2326
+ def test_regexp; end
2327
+
2328
+ class << self
2329
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#4
2330
+ def of(obj); end
2331
+ end
2332
+ end
2333
+
2334
+ # source://regexp_parser//lib/regexp_parser/version.rb#2
2335
+ class Regexp::Parser
2336
+ include ::Regexp::Expression
2337
+
2338
+ # source://regexp_parser//lib/regexp_parser/parser.rb#25
2339
+ def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2340
+
2341
+ private
2342
+
2343
+ # source://regexp_parser//lib/regexp_parser/parser.rb#573
2344
+ def active_opts; end
2345
+
2346
+ # source://regexp_parser//lib/regexp_parser/parser.rb#99
2347
+ def anchor(token); end
2348
+
2349
+ # source://regexp_parser//lib/regexp_parser/parser.rb#262
2350
+ def assign_effective_number(exp); end
2351
+
2352
+ # Assigns referenced expressions to refering expressions, e.g. if there is
2353
+ # an instance of Backreference::Number, its #referenced_expression is set to
2354
+ # the instance of Group::Capture that it refers to via its number.
2355
+ #
2356
+ # source://regexp_parser//lib/regexp_parser/parser.rb#580
2357
+ def assign_referenced_expressions; end
2358
+
2359
+ # source://regexp_parser//lib/regexp_parser/parser.rb#227
2360
+ def backref(token); end
2361
+
2362
+ # source://regexp_parser//lib/regexp_parser/parser.rb#202
2363
+ def captured_group_count_at_level; end
2364
+
2365
+ # Returns the value of attribute captured_group_counts.
2366
+ #
2367
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2368
+ def captured_group_counts; end
2369
+
2370
+ # Sets the attribute captured_group_counts
2371
+ #
2372
+ # @param value the value to set the attribute captured_group_counts to.
2373
+ #
2374
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2375
+ def captured_group_counts=(_arg0); end
2376
+
2377
+ # source://regexp_parser//lib/regexp_parser/parser.rb#569
2378
+ def close_completed_character_set_range; end
2379
+
2380
+ # source://regexp_parser//lib/regexp_parser/parser.rb#210
2381
+ def close_group; end
2382
+
2383
+ # source://regexp_parser//lib/regexp_parser/parser.rb#537
2384
+ def close_set; end
2385
+
2386
+ # source://regexp_parser//lib/regexp_parser/parser.rb#269
2387
+ def conditional(token); end
2388
+
2389
+ # Returns the value of attribute conditional_nesting.
2390
+ #
2391
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2392
+ def conditional_nesting; end
2393
+
2394
+ # Sets the attribute conditional_nesting
2395
+ #
2396
+ # @param value the value to set the attribute conditional_nesting to.
2397
+ #
2398
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2399
+ def conditional_nesting=(_arg0); end
2400
+
2401
+ # source://regexp_parser//lib/regexp_parser/parser.rb#206
2402
+ def count_captured_group; end
2403
+
2404
+ # @yield [node]
2405
+ #
2406
+ # source://regexp_parser//lib/regexp_parser/parser.rb#216
2407
+ def decrease_nesting; end
2408
+
2409
+ # source://regexp_parser//lib/regexp_parser/parser.rb#305
2410
+ def escape(token); end
2411
+
2412
+ # source://regexp_parser//lib/regexp_parser/parser.rb#60
2413
+ def extract_options(input, options); end
2414
+
2415
+ # source://regexp_parser//lib/regexp_parser/parser.rb#349
2416
+ def free_space(token); end
2417
+
2418
+ # source://regexp_parser//lib/regexp_parser/parser.rb#114
2419
+ def group(token); end
2420
+
2421
+ # source://regexp_parser//lib/regexp_parser/parser.rb#508
2422
+ def increase_group_level(exp); end
2423
+
2424
+ # source://regexp_parser//lib/regexp_parser/parser.rb#548
2425
+ def intersection(token); end
2426
+
2427
+ # source://regexp_parser//lib/regexp_parser/parser.rb#360
2428
+ def keep(token); end
2429
+
2430
+ # source://regexp_parser//lib/regexp_parser/parser.rb#364
2431
+ def literal(token); end
2432
+
2433
+ # source://regexp_parser//lib/regexp_parser/parser.rb#368
2434
+ def meta(token); end
2435
+
2436
+ # source://regexp_parser//lib/regexp_parser/parser.rb#533
2437
+ def negate_set; end
2438
+
2439
+ # source://regexp_parser//lib/regexp_parser/parser.rb#299
2440
+ def nest(exp); end
2441
+
2442
+ # source://regexp_parser//lib/regexp_parser/parser.rb#294
2443
+ def nest_conditional(exp); end
2444
+
2445
+ # Returns the value of attribute nesting.
2446
+ #
2447
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2448
+ def nesting; end
2449
+
2450
+ # Sets the attribute nesting
2451
+ #
2452
+ # @param value the value to set the attribute nesting to.
2453
+ #
2454
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2455
+ def nesting=(_arg0); end
2456
+
2457
+ # Returns the value of attribute node.
2458
+ #
2459
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2460
+ def node; end
2461
+
2462
+ # Sets the attribute node
2463
+ #
2464
+ # @param value the value to set the attribute node to.
2465
+ #
2466
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2467
+ def node=(_arg0); end
2468
+
2469
+ # source://regexp_parser//lib/regexp_parser/parser.rb#165
2470
+ def open_group(token); end
2471
+
2472
+ # source://regexp_parser//lib/regexp_parser/parser.rb#526
2473
+ def open_set(token); end
2474
+
2475
+ # source://regexp_parser//lib/regexp_parser/parser.rb#130
2476
+ def options_group(token); end
2477
+
2478
+ # Returns the value of attribute options_stack.
2479
+ #
2480
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2481
+ def options_stack; end
2482
+
2483
+ # Sets the attribute options_stack
2484
+ #
2485
+ # @param value the value to set the attribute options_stack to.
2486
+ #
2487
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2488
+ def options_stack=(_arg0); end
2489
+
2490
+ # source://regexp_parser//lib/regexp_parser/parser.rb#76
2491
+ def parse_token(token); end
2492
+
2493
+ # source://regexp_parser//lib/regexp_parser/parser.rb#390
2494
+ def posixclass(token); end
2495
+
2496
+ # source://regexp_parser//lib/regexp_parser/parser.rb#397
2497
+ def property(token); end
2498
+
2499
+ # source://regexp_parser//lib/regexp_parser/parser.rb#478
2500
+ def quantifier(token); end
2501
+
2502
+ # source://regexp_parser//lib/regexp_parser/parser.rb#541
2503
+ def range(token); end
2504
+
2505
+ # Returns the value of attribute root.
2506
+ #
2507
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2508
+ def root; end
2509
+
2510
+ # Sets the attribute root
2511
+ #
2512
+ # @param value the value to set the attribute root to.
2513
+ #
2514
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2515
+ def root=(_arg0); end
2516
+
2517
+ # source://regexp_parser//lib/regexp_parser/parser.rb#379
2518
+ def sequence_operation(klass, token); end
2519
+
2520
+ # source://regexp_parser//lib/regexp_parser/parser.rb#514
2521
+ def set(token); end
2522
+
2523
+ # Returns the value of attribute switching_options.
2524
+ #
2525
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2526
+ def switching_options; end
2527
+
2528
+ # Sets the attribute switching_options
2529
+ #
2530
+ # @param value the value to set the attribute switching_options to.
2531
+ #
2532
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2533
+ def switching_options=(_arg0); end
2534
+
2535
+ # source://regexp_parser//lib/regexp_parser/parser.rb#198
2536
+ def total_captured_group_count; end
2537
+
2538
+ # source://regexp_parser//lib/regexp_parser/parser.rb#552
2539
+ def type(token); end
2540
+
2541
+ class << self
2542
+ # source://regexp_parser//lib/regexp_parser/parser.rb#21
2543
+ def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2544
+ end
2545
+ end
2546
+
2547
+ # source://regexp_parser//lib/regexp_parser/parser.rb#128
2548
+ Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
2549
+
2550
+ # base class for all gem-specific errors
2551
+ #
2552
+ # source://regexp_parser//lib/regexp_parser/error.rb#3
2553
+ class Regexp::Parser::Error < ::StandardError; end
2554
+
2555
+ # source://regexp_parser//lib/regexp_parser/parser.rb#127
2556
+ Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
2557
+
2558
+ # source://regexp_parser//lib/regexp_parser/parser.rb#7
2559
+ class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
2560
+
2561
+ # source://regexp_parser//lib/regexp_parser/parser.rb#394
2562
+ Regexp::Parser::UP = Regexp::Expression::UnicodeProperty
2563
+
2564
+ # source://regexp_parser//lib/regexp_parser/parser.rb#395
2565
+ Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
2566
+
2567
+ # source://regexp_parser//lib/regexp_parser/parser.rb#15
2568
+ class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
2569
+ # @return [UnknownTokenError] a new instance of UnknownTokenError
2570
+ #
2571
+ # source://regexp_parser//lib/regexp_parser/parser.rb#16
2572
+ def initialize(type, token); end
2573
+ end
2574
+
2575
+ # source://regexp_parser//lib/regexp_parser/parser.rb#9
2576
+ class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
2577
+ # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError
2578
+ #
2579
+ # source://regexp_parser//lib/regexp_parser/parser.rb#10
2580
+ def initialize(type, token); end
2581
+ end
2582
+
2583
+ # source://regexp_parser//lib/regexp_parser/version.rb#3
2584
+ Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
2585
+
2586
+ # mapping for simple cases with a 1:1 relation between text and token
2587
+ #
2588
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#3
2589
+ class Regexp::Scanner
2590
+ # Emits an array with the details of the scanned pattern
2591
+ #
2592
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2388
2593
+ def emit(type, token, text); end
2594
+
2595
+ # only public for #||= to work on ruby <= 2.5
2596
+ #
2597
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2413
2598
+ def literal_run; end
2599
+
2600
+ # only public for #||= to work on ruby <= 2.5
2601
+ #
2602
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2413
2603
+ def literal_run=(_arg0); end
2604
+
2605
+ # @raise [PrematureEndError]
2606
+ #
2607
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#24
2608
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2609
+
2610
+ private
2611
+
2612
+ # Appends one or more characters to the literal buffer, to be emitted later
2613
+ # by a call to emit_literal.
2614
+ #
2615
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2450
2616
+ def append_literal(data, ts, te); end
2617
+
2618
+ # Returns the value of attribute block.
2619
+ #
2620
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2621
+ def block; end
2622
+
2623
+ # Sets the attribute block
2624
+ #
2625
+ # @param value the value to set the attribute block to.
2626
+ #
2627
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2628
+ def block=(_arg0); end
2629
+
2630
+ # Returns the value of attribute char_pos.
2631
+ #
2632
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2633
+ def char_pos; end
2634
+
2635
+ # Sets the attribute char_pos
2636
+ #
2637
+ # @param value the value to set the attribute char_pos to.
2638
+ #
2639
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2640
+ def char_pos=(_arg0); end
2641
+
2642
+ # Returns the value of attribute collect_tokens.
2643
+ #
2644
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2645
+ def collect_tokens; end
2646
+
2647
+ # Sets the attribute collect_tokens
2648
+ #
2649
+ # @param value the value to set the attribute collect_tokens to.
2650
+ #
2651
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2652
+ def collect_tokens=(_arg0); end
2653
+
2654
+ # Returns the value of attribute conditional_stack.
2655
+ #
2656
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2657
+ def conditional_stack; end
2658
+
2659
+ # Sets the attribute conditional_stack
2660
+ #
2661
+ # @param value the value to set the attribute conditional_stack to.
2662
+ #
2663
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2664
+ def conditional_stack=(_arg0); end
2665
+
2666
+ # Copy from ts to te from data as text
2667
+ #
2668
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2444
2669
+ def copy(data, ts, te); end
2670
+
2671
+ # Emits the literal run collected by calls to the append_literal method.
2672
+ #
2673
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2455
2674
+ def emit_literal; end
2675
+
2676
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2490
2677
+ def emit_meta_control_sequence(data, ts, te, token); end
2678
+
2679
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2461
2680
+ def emit_options(text); end
2681
+
2682
+ # Returns the value of attribute free_spacing.
2683
+ #
2684
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2685
+ def free_spacing; end
2686
+
2687
+ # Sets the attribute free_spacing
2688
+ #
2689
+ # @param value the value to set the attribute free_spacing to.
2690
+ #
2691
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2692
+ def free_spacing=(_arg0); end
2693
+
2694
+ # @return [Boolean]
2695
+ #
2696
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2423
2697
+ def free_spacing?(input_object, options); end
2698
+
2699
+ # Returns the value of attribute group_depth.
2700
+ #
2701
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2702
+ def group_depth; end
2703
+
2704
+ # Sets the attribute group_depth
2705
+ #
2706
+ # @param value the value to set the attribute group_depth to.
2707
+ #
2708
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2709
+ def group_depth=(_arg0); end
2710
+
2711
+ # @return [Boolean]
2712
+ #
2713
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
2714
+ def in_group?; end
2715
+
2716
+ # @return [Boolean]
2717
+ #
2718
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2439
2719
+ def in_set?; end
2720
+
2721
+ # Returns the value of attribute prev_token.
2722
+ #
2723
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2724
+ def prev_token; end
2725
+
2726
+ # Sets the attribute prev_token
2727
+ #
2728
+ # @param value the value to set the attribute prev_token to.
2729
+ #
2730
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2731
+ def prev_token=(_arg0); end
2732
+
2733
+ # Returns the value of attribute set_depth.
2734
+ #
2735
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2736
+ def set_depth; end
2737
+
2738
+ # Sets the attribute set_depth
2739
+ #
2740
+ # @param value the value to set the attribute set_depth to.
2741
+ #
2742
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2743
+ def set_depth=(_arg0); end
2744
+
2745
+ # Returns the value of attribute spacing_stack.
2746
+ #
2747
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2748
+ def spacing_stack; end
2749
+
2750
+ # Sets the attribute spacing_stack
2751
+ #
2752
+ # @param value the value to set the attribute spacing_stack to.
2753
+ #
2754
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2755
+ def spacing_stack=(_arg0); end
2756
+
2757
+ # Returns the value of attribute tokens.
2758
+ #
2759
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2760
+ def tokens; end
2761
+
2762
+ # Sets the attribute tokens
2763
+ #
2764
+ # @param value the value to set the attribute tokens to.
2765
+ #
2766
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2417
2767
+ def tokens=(_arg0); end
2768
+
2769
+ class << self
2770
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2374
2771
+ def long_prop_map; end
2772
+
2773
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2378
2774
+ def parse_prop_map(name); end
2775
+
2776
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2382
2777
+ def posix_classes; end
2778
+
2779
+ # Scans the given regular expression text, or Regexp object and collects the
2780
+ # emitted token into an array that gets returned at the end. If a block is
2781
+ # given, it gets called for each emitted token.
2782
+ #
2783
+ # This method may raise errors if a syntax error is encountered.
2784
+ # --------------------------------------------------------------------------
2785
+ #
2786
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#20
2787
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2788
+
2789
+ # lazy-load property maps when first needed
2790
+ #
2791
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2370
2792
+ def short_prop_map; end
2793
+ end
2794
+ end
2795
+
2796
+ # Invalid back reference. Used for name a number refs/calls.
2797
+ #
2798
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#44
2799
+ class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
2800
+ # @return [InvalidBackrefError] a new instance of InvalidBackrefError
2801
+ #
2802
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#45
2803
+ def initialize(what, reason); end
2804
+ end
2805
+
2806
+ # Invalid group. Used for named groups.
2807
+ #
2808
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#29
2809
+ class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
2810
+ # @return [InvalidGroupError] a new instance of InvalidGroupError
2811
+ #
2812
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#30
2813
+ def initialize(what, reason); end
2814
+ end
2815
+
2816
+ # Invalid groupOption. Used for inline options.
2817
+ # TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
2818
+ #
2819
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#37
2820
+ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
2821
+ # @return [InvalidGroupOption] a new instance of InvalidGroupOption
2822
+ #
2823
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#38
2824
+ def initialize(option, text); end
2825
+ end
2826
+
2827
+ # Invalid sequence format. Used for escape sequences, mainly.
2828
+ #
2829
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#22
2830
+ class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
2831
+ # @return [InvalidSequenceError] a new instance of InvalidSequenceError
2832
+ #
2833
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#23
2834
+ def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
2835
+ end
2836
+
2837
+ # Unexpected end of pattern
2838
+ #
2839
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#3
2840
+ class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
2841
+ # @return [PrematureEndError] a new instance of PrematureEndError
2842
+ #
2843
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#4
2844
+ def initialize(where = T.unsafe(nil)); end
2845
+ end
2846
+
2847
+ # General scanner error (catch all)
2848
+ #
2849
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#5
2850
+ class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
2851
+
2852
+ # The POSIX class name was not recognized by the scanner.
2853
+ #
2854
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#58
2855
+ class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
2856
+ # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError
2857
+ #
2858
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#59
2859
+ def initialize(text, _); end
2860
+ end
2861
+
2862
+ # The property name was not recognized by the scanner.
2863
+ #
2864
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#51
2865
+ class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
2866
+ # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError
2867
+ #
2868
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#52
2869
+ def initialize(name, _); end
2870
+ end
2871
+
2872
+ # Base for all scanner validation errors
2873
+ #
2874
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#4
2875
+ class Regexp::Scanner::ValidationError < ::Regexp::Scanner::ScannerError
2876
+ class << self
2877
+ # Centralizes and unifies the handling of validation related errors.
2878
+ #
2879
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#5
2880
+ def for(type, problem, reason = T.unsafe(nil)); end
2881
+
2882
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#9
2883
+ def types; end
2884
+ end
2885
+ end
2886
+
2887
+ # After loading all the tokens the map is full. Extract all tokens and types
2888
+ # into the All and Types constants.
2889
+ #
2890
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#3
2891
+ module Regexp::Syntax
2892
+ private
2893
+
2894
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2895
+ def comparable(name); end
2896
+
2897
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2898
+ def const_missing(const_name); end
2899
+
2900
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2901
+ def fallback_version_class(version); end
2902
+
2903
+ # Returns the syntax specification class for the given syntax
2904
+ # version name. The special names 'any' and '*' return Syntax::Any.
2905
+ #
2906
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22
2907
+ def for(name); end
2908
+
2909
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2910
+ def new(name); end
2911
+
2912
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2913
+ def specified_versions; end
2914
+
2915
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
2916
+ def supported?(name); end
2917
+
2918
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2919
+ def version_class(version); end
2920
+
2921
+ class << self
2922
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2923
+ def comparable(name); end
2924
+
2925
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2926
+ def const_missing(const_name); end
2927
+
2928
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2929
+ def fallback_version_class(version); end
2930
+
2931
+ # Returns the syntax specification class for the given syntax
2932
+ # version name. The special names 'any' and '*' return Syntax::Any.
2933
+ #
2934
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22
2935
+ def for(name); end
2936
+
2937
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2938
+ def new(name); end
2939
+
2940
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2941
+ def specified_versions; end
2942
+
2943
+ # @return [Boolean]
2944
+ #
2945
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
2946
+ def supported?(name); end
2947
+
2948
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2949
+ def version_class(version); end
2950
+ end
2951
+ end
2952
+
2953
+ # A syntax that always returns true, passing all tokens as implemented. This
2954
+ # is useful during development, testing, and should be useful for some types
2955
+ # of transformations as well.
2956
+ #
2957
+ # source://regexp_parser//lib/regexp_parser/syntax/any.rb#5
2958
+ class Regexp::Syntax::Any < ::Regexp::Syntax::Base
2959
+ class << self
2960
+ # @return [Boolean]
2961
+ #
2962
+ # source://regexp_parser//lib/regexp_parser/syntax/any.rb#8
2963
+ def implements?(_type, _token); end
2964
+ end
2965
+ end
2966
+
2967
+ # A lookup map of supported types and tokens in a given syntax
2968
+ #
2969
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#9
2970
+ class Regexp::Syntax::Base
2971
+ include ::Regexp::Syntax::Token
2972
+
2973
+ # TODO: drop this backwards compatibility code in v3.0.0, do `private :new`
2974
+ #
2975
+ # @return [Base] a new instance of Base
2976
+ #
2977
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#99
2978
+ def initialize; end
2979
+
2980
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#104
2981
+ def method_missing(name, *args); end
2982
+
2983
+ private
2984
+
2985
+ # @return [Boolean]
2986
+ #
2987
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#115
2988
+ def respond_to_missing?(name, include_private = T.unsafe(nil)); end
2989
+
2990
+ class << self
2991
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#46
2992
+ def added_features; end
2993
+
2994
+ # @raise [NotImplementedError]
2995
+ #
2996
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40
2997
+ def check!(type, token); end
2998
+
2999
+ # @return [Boolean]
3000
+ #
3001
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31
3002
+ def check?(type, token); end
3003
+
3004
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#26
3005
+ def excludes(type, tokens); end
3006
+
3007
+ # Returns the value of attribute features.
3008
+ #
3009
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13
3010
+ def features; end
3011
+
3012
+ # Sets the attribute features
3013
+ #
3014
+ # @param value the value to set the attribute features to.
3015
+ #
3016
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13
3017
+ def features=(_arg0); end
3018
+
3019
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#36
3020
+ def implementations(type); end
3021
+
3022
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#21
3023
+ def implements(type, tokens); end
3024
+
3025
+ # @raise [NotImplementedError]
3026
+ #
3027
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40
3028
+ def implements!(type, token); end
3029
+
3030
+ # @return [Boolean]
3031
+ #
3032
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31
3033
+ def implements?(type, token); end
3034
+
3035
+ # automatically inherit features through the syntax class hierarchy
3036
+ #
3037
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#16
3038
+ def inherited(subclass); end
3039
+
3040
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#54
3041
+ def normalize(type, token); end
3042
+
3043
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#74
3044
+ def normalize_backref(type, token); end
3045
+
3046
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#65
3047
+ def normalize_group(type, token); end
3048
+
3049
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#50
3050
+ def removed_features; end
3051
+ end
3052
+ end
3053
+
3054
+ # source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8
3055
+ Regexp::Syntax::CURRENT = Regexp::Syntax::V2_6_3
3056
+
3057
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6
3058
+ class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
3059
+ # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError
3060
+ #
3061
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#7
3062
+ def initialize(name); end
3063
+ end
3064
+
3065
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#2
3066
+ class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
3067
+ # @return [NotImplementedError] a new instance of NotImplementedError
3068
+ #
3069
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#3
3070
+ def initialize(syntax, type, token); end
3071
+ end
3072
+
3073
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#4
3074
+ class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
3075
+
3076
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#3
3077
+ module Regexp::Syntax::Token; end
3078
+
3079
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#42
3080
+ Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
3081
+
3082
+ # alias for symmetry between Token::* and Expression::*
3083
+ #
3084
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#15
3085
+ module Regexp::Syntax::Token::Alternation; end
3086
+
3087
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#16
3088
+ Regexp::Syntax::Token::Alternation::All = T.let(T.unsafe(nil), Array)
3089
+
3090
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#17
3091
+ Regexp::Syntax::Token::Alternation::Type = T.let(T.unsafe(nil), Symbol)
3092
+
3093
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3
3094
+ module Regexp::Syntax::Token::Anchor; end
3095
+
3096
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#9
3097
+ Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
3098
+
3099
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#4
3100
+ Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
3101
+
3102
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#5
3103
+ Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
3104
+
3105
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#7
3106
+ Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
3107
+
3108
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#6
3109
+ Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
3110
+
3111
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#10
3112
+ Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
3113
+
3114
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#3
3115
+ module Regexp::Syntax::Token::Assertion; end
3116
+
3117
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#7
3118
+ Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
3119
+
3120
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#4
3121
+ Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
3122
+
3123
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#5
3124
+ Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
3125
+
3126
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8
3127
+ Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
3128
+
3129
+ # alias for symmetry between token symbol and Expression class name
3130
+ #
3131
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#31
3132
+ Regexp::Syntax::Token::Backref = Regexp::Syntax::Token::Backreference
3133
+
3134
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3
3135
+ module Regexp::Syntax::Token::Backreference; end
3136
+
3137
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#15
3138
+ Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
3139
+
3140
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#7
3141
+ Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
3142
+
3143
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#6
3144
+ Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
3145
+
3146
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#5
3147
+ Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array)
3148
+
3149
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#4
3150
+ Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array)
3151
+
3152
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#9
3153
+ Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
3154
+
3155
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#16
3156
+ Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
3157
+
3158
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#11
3159
+ Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
3160
+
3161
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#13
3162
+ Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
3163
+
3164
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#3
3165
+ module Regexp::Syntax::Token::CharacterSet; end
3166
+
3167
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#7
3168
+ Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
3169
+
3170
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#4
3171
+ Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
3172
+
3173
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#5
3174
+ Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
3175
+
3176
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#8
3177
+ Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
3178
+
3179
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#3
3180
+ module Regexp::Syntax::Token::CharacterType; end
3181
+
3182
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#10
3183
+ Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
3184
+
3185
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#4
3186
+ Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
3187
+
3188
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#8
3189
+ Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
3190
+
3191
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#5
3192
+ Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
3193
+
3194
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#6
3195
+ Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
3196
+
3197
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#11
3198
+ Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
3199
+
3200
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#3
3201
+ module Regexp::Syntax::Token::Conditional; end
3202
+
3203
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#9
3204
+ Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
3205
+
3206
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#6
3207
+ Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
3208
+
3209
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#4
3210
+ Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
3211
+
3212
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#7
3213
+ Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
3214
+
3215
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#11
3216
+ Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
3217
+
3218
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#3
3219
+ module Regexp::Syntax::Token::Escape; end
3220
+
3221
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#8
3222
+ Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
3223
+
3224
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#24
3225
+ Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
3226
+
3227
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4
3228
+ Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
3229
+
3230
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#6
3231
+ Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
3232
+
3233
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#20
3234
+ Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
3235
+
3236
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#13
3237
+ Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
3238
+
3239
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#22
3240
+ Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
3241
+
3242
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#25
3243
+ Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
3244
+
3245
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#11
3246
+ Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
3247
+
3248
+ # alias for symmetry between Token::* and Expression::*
3249
+ #
3250
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#31
3251
+ Regexp::Syntax::Token::EscapeSequence = Regexp::Syntax::Token::Escape
3252
+
3253
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#11
3254
+ module Regexp::Syntax::Token::FreeSpace; end
3255
+
3256
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#12
3257
+ Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
3258
+
3259
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#13
3260
+ Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
3261
+
3262
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#3
3263
+ module Regexp::Syntax::Token::Group; end
3264
+
3265
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#17
3266
+ Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
3267
+
3268
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#8
3269
+ Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
3270
+
3271
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#4
3272
+ Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
3273
+
3274
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#10
3275
+ Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
3276
+
3277
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#5
3278
+ Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
3279
+
3280
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#7
3281
+ Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
3282
+
3283
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#9
3284
+ Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
3285
+
3286
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#18
3287
+ Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
3288
+
3289
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#12
3290
+ Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
3291
+
3292
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#15
3293
+ Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
3294
+
3295
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#3
3296
+ module Regexp::Syntax::Token::Keep; end
3297
+
3298
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#6
3299
+ Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
3300
+
3301
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#4
3302
+ Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
3303
+
3304
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#7
3305
+ Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
3306
+
3307
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#6
3308
+ module Regexp::Syntax::Token::Literal; end
3309
+
3310
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#7
3311
+ Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
3312
+
3313
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#8
3314
+ Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
3315
+
3316
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#4
3317
+ Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
3318
+
3319
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3
3320
+ module Regexp::Syntax::Token::Meta; end
3321
+
3322
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8
3323
+ Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
3324
+
3325
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#5
3326
+ Regexp::Syntax::Token::Meta::Alternation = T.let(T.unsafe(nil), Array)
3327
+
3328
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#4
3329
+ Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
3330
+
3331
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#6
3332
+ Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
3333
+
3334
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#9
3335
+ Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
3336
+
3337
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3
3338
+ module Regexp::Syntax::Token::PosixClass; end
3339
+
3340
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#9
3341
+ Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
3342
+
3343
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#7
3344
+ Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
3345
+
3346
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#11
3347
+ Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
3348
+
3349
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#4
3350
+ Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
3351
+
3352
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10
3353
+ Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
3354
+
3355
+ # alias for symmetry between token symbol and Token module name
3356
+ #
3357
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#718
3358
+ Regexp::Syntax::Token::Property = Regexp::Syntax::Token::UnicodeProperty
3359
+
3360
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3
3361
+ module Regexp::Syntax::Token::Quantifier; end
3362
+
3363
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#29
3364
+ Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
3365
+
3366
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#4
3367
+ Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
3368
+
3369
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#22
3370
+ Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
3371
+
3372
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#26
3373
+ Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
3374
+
3375
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#24
3376
+ Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
3377
+
3378
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#23
3379
+ Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
3380
+
3381
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#16
3382
+ Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
3383
+
3384
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#10
3385
+ Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
3386
+
3387
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#30
3388
+ Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
3389
+
3390
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#28
3391
+ Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
3392
+
3393
+ # alias for symmetry between token symbol and Token module name
3394
+ #
3395
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#14
3396
+ Regexp::Syntax::Token::Set = Regexp::Syntax::Token::CharacterSet
3397
+
3398
+ # Type is the same as Backreference so keeping it here, for now.
3399
+ #
3400
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20
3401
+ module Regexp::Syntax::Token::SubexpressionCall; end
3402
+
3403
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#24
3404
+ Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
3405
+
3406
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#21
3407
+ Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
3408
+
3409
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#22
3410
+ Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
3411
+
3412
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#43
3413
+ Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
3414
+
3415
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#3
3416
+ module Regexp::Syntax::Token::UnicodeProperty; end
3417
+
3418
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#64
3419
+ Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
3420
+
3421
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#40
3422
+ Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
3423
+
3424
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#44
3425
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
3426
+
3427
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#46
3428
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
3429
+
3430
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#48
3431
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
3432
+
3433
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#50
3434
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
3435
+
3436
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#52
3437
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
3438
+
3439
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#54
3440
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
3441
+
3442
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#56
3443
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
3444
+
3445
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#58
3446
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
3447
+
3448
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#60
3449
+ Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array)
3450
+
3451
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#62
3452
+ Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
3453
+
3454
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#708
3455
+ Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
3456
+
3457
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13
3458
+ module Regexp::Syntax::Token::UnicodeProperty::Category; end
3459
+
3460
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#36
3461
+ Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
3462
+
3463
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#33
3464
+ Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
3465
+
3466
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#14
3467
+ Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
3468
+
3469
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#17
3470
+ Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
3471
+
3472
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#20
3473
+ Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
3474
+
3475
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#23
3476
+ Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
3477
+
3478
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#30
3479
+ Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
3480
+
3481
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#27
3482
+ Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
3483
+
3484
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#6
3485
+ Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
3486
+
3487
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#9
3488
+ Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
3489
+
3490
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#133
3491
+ Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
3492
+
3493
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#66
3494
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
3495
+
3496
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#120
3497
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
3498
+
3499
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#125
3500
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
3501
+
3502
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#129
3503
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
3504
+
3505
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#693
3506
+ Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
3507
+
3508
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#685
3509
+ Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
3510
+
3511
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#711
3512
+ Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
3513
+
3514
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#11
3515
+ Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
3516
+
3517
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#330
3518
+ Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
3519
+
3520
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#135
3521
+ Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
3522
+
3523
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#231
3524
+ Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
3525
+
3526
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#237
3527
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
3528
+
3529
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#247
3530
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
3531
+
3532
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#273
3533
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
3534
+
3535
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#282
3536
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
3537
+
3538
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#291
3539
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
3540
+
3541
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#298
3542
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
3543
+
3544
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#308
3545
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
3546
+
3547
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#315
3548
+ Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array)
3549
+
3550
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#322
3551
+ Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array)
3552
+
3553
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#710
3554
+ Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
3555
+
3556
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#683
3557
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
3558
+
3559
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#332
3560
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
3561
+
3562
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#431
3563
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
3564
+
3565
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#559
3566
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
3567
+
3568
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#594
3569
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
3570
+
3571
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#607
3572
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
3573
+
3574
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#621
3575
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
3576
+
3577
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#631
3578
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
3579
+
3580
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#645
3581
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
3582
+
3583
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#657
3584
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array)
3585
+
3586
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#668
3587
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array)
3588
+
3589
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#695
3590
+ Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
3591
+
3592
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#696
3593
+ Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
3594
+
3595
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#697
3596
+ Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
3597
+
3598
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#698
3599
+ Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
3600
+
3601
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#699
3602
+ Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
3603
+
3604
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#700
3605
+ Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
3606
+
3607
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#701
3608
+ Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
3609
+
3610
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#702
3611
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
3612
+
3613
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#703
3614
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
3615
+
3616
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#704
3617
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
3618
+
3619
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#705
3620
+ Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
3621
+
3622
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706
3623
+ Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
3624
+
3625
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12
3626
+ class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
3627
+ # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError
3628
+ #
3629
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#13
3630
+ def initialize(name); end
3631
+ end
3632
+
3633
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.8.6.rb#1
3634
+ class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
3635
+
3636
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.1.rb#1
3637
+ class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
3638
+
3639
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.3.rb#1
3640
+ class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
3641
+
3642
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.0.0.rb#1
3643
+ class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
3644
+
3645
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.2.0.rb#1
3646
+ class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
3647
+
3648
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.3.0.rb#1
3649
+ class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
3650
+
3651
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.0.rb#1
3652
+ class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
3653
+
3654
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.1.rb#1
3655
+ class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
3656
+
3657
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.5.0.rb#1
3658
+ class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
3659
+
3660
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.0.rb#1
3661
+ class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
3662
+
3663
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.2.rb#1
3664
+ class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
3665
+
3666
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.3.rb#1
3667
+ class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
3668
+
3669
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.1.0.rb#1
3670
+ class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
3671
+
3672
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.2.0.rb#1
3673
+ class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
3674
+
3675
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#4
3676
+ Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
3677
+
3678
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#2
3679
+ Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
3680
+
3681
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#3
3682
+ Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
3683
+
3684
+ # source://regexp_parser//lib/regexp_parser/token.rb#2
3685
+ Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
3686
+
3687
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3688
+ class Regexp::Token < ::Struct
3689
+ def conditional_level; end
3690
+
3691
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3692
+ def conditional_level=(_); end
3693
+
3694
+ # source://regexp_parser//lib/regexp_parser/token.rb#20
3695
+ def length; end
3696
+
3697
+ def level; end
3698
+
3699
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3700
+ def level=(_); end
3701
+
3702
+ # Returns the value of attribute next.
3703
+ #
3704
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3705
+ def next; end
3706
+
3707
+ # Sets the attribute next
3708
+ #
3709
+ # @param value the value to set the attribute next to.
3710
+ #
3711
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3712
+ def next=(_arg0); end
3713
+
3714
+ # source://regexp_parser//lib/regexp_parser/token.rb#16
3715
+ def offset; end
3716
+
3717
+ # Returns the value of attribute previous.
3718
+ #
3719
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3720
+ def previous; end
3721
+
3722
+ # Sets the attribute previous
3723
+ #
3724
+ # @param value the value to set the attribute previous to.
3725
+ #
3726
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3727
+ def previous=(_arg0); end
3728
+
3729
+ def set_level; end
3730
+
3731
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3732
+ def set_level=(_); end
3733
+
3734
+ def te; end
3735
+
3736
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3737
+ def te=(_); end
3738
+
3739
+ def text; end
3740
+
3741
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3742
+ def text=(_); end
3743
+
3744
+ def token; end
3745
+
3746
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3747
+ def token=(_); end
3748
+
3749
+ def ts; end
3750
+
3751
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3752
+ def ts=(_); end
3753
+
3754
+ def type; end
3755
+
3756
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3757
+ def type=(_); end
3758
+
3759
+ class << self
3760
+ def [](*_arg0); end
3761
+ def inspect; end
3762
+ def members; end
3763
+ def new(*_arg0); end
3764
+ end
3765
+ end