rspec-sorbet 1.8.0 → 1.8.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (119) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +14 -22
  3. data/.gitignore +2 -1
  4. data/CHANGELOG.md +4 -0
  5. data/Gemfile +1 -5
  6. data/bin/tapioca +29 -0
  7. data/lib/rspec/sorbet/doubles.rb +1 -1
  8. data/lib/rspec/sorbet/version.rb +1 -1
  9. data/nix/sources.json +14 -0
  10. data/nix/sources.nix +174 -0
  11. data/run_ci.sh +7 -0
  12. data/shell.nix +20 -0
  13. data/sorbet/config +2 -0
  14. data/sorbet/rbi/gems/{ast.rbi → ast@2.4.2.rbi} +28 -22
  15. data/sorbet/rbi/gems/byebug@11.1.3.rbi +1568 -0
  16. data/sorbet/rbi/gems/coderay@1.1.3.rbi +1005 -0
  17. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +9 -0
  18. data/sorbet/rbi/gems/docile@1.4.0.rbi +54 -0
  19. data/sorbet/rbi/gems/em-websocket@0.5.2.rbi +8 -0
  20. data/sorbet/rbi/gems/eventmachine@1.2.7.rbi +45 -0
  21. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +3171 -0
  22. data/sorbet/rbi/gems/ffi@1.15.4.rbi +8 -0
  23. data/sorbet/rbi/gems/formatador@0.3.0.rbi +8 -0
  24. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +31 -0
  25. data/sorbet/rbi/gems/guard-livereload@2.5.2.rbi +8 -0
  26. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +211 -0
  27. data/sorbet/rbi/gems/guard@2.18.0.rbi +8 -0
  28. data/sorbet/rbi/gems/http_parser.rb@0.6.0.rbi +8 -0
  29. data/sorbet/rbi/gems/listen@3.7.0.rbi +8 -0
  30. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +8 -0
  31. data/sorbet/rbi/gems/method_source@1.0.0.rbi +72 -0
  32. data/sorbet/rbi/gems/multi_json@1.15.0.rbi +8 -0
  33. data/sorbet/rbi/gems/nenv@0.3.0.rbi +8 -0
  34. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +8 -0
  35. data/sorbet/rbi/gems/parallel@1.21.0.rbi +113 -0
  36. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +1189 -0
  37. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +458 -0
  38. data/sorbet/rbi/gems/{pry.rbi → pry@0.14.1.rbi} +2264 -1727
  39. data/sorbet/rbi/gems/{rainbow.rbi → rainbow@3.0.0.rbi} +90 -55
  40. data/sorbet/rbi/gems/{rake.rbi → rake@13.0.6.rbi} +578 -431
  41. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +8 -0
  42. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +8 -0
  43. data/sorbet/rbi/gems/rbi@0.0.6.rbi +1405 -0
  44. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +1120 -0
  45. data/sorbet/rbi/gems/{rexml.rbi → rexml@3.2.5.rbi} +564 -497
  46. data/sorbet/rbi/gems/{rspec-core.rbi → rspec-core@3.10.1.rbi} +2308 -1766
  47. data/sorbet/rbi/gems/{rspec-expectations.rbi → rspec-expectations@3.10.1.rbi} +1149 -698
  48. data/sorbet/rbi/gems/{rspec-mocks.rbi → rspec-mocks@3.10.2.rbi} +1299 -936
  49. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +509 -0
  50. data/sorbet/rbi/gems/rspec@3.10.0.rbi +38 -0
  51. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +1938 -0
  52. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +1786 -0
  53. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +13252 -0
  54. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +405 -0
  55. data/sorbet/rbi/gems/shellany@0.0.1.rbi +8 -0
  56. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +89 -0
  57. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +577 -0
  58. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +8 -0
  59. data/sorbet/rbi/gems/spoom@1.1.5.rbi +1241 -0
  60. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +98 -0
  61. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +949 -0
  62. data/sorbet/rbi/gems/thor@1.1.0.rbi +839 -0
  63. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +26 -0
  64. data/sorbet/rbi/gems/unparser@0.6.0.rbi +8 -0
  65. data/sorbet/tapioca/require.rb +4 -0
  66. metadata +60 -64
  67. data/.reek.yml +0 -32
  68. data/.ruby-version +0 -1
  69. data/sorbet/rbi/gems/activesupport.rbi +0 -1722
  70. data/sorbet/rbi/gems/byebug.rbi +0 -1041
  71. data/sorbet/rbi/gems/coderay.rbi +0 -285
  72. data/sorbet/rbi/gems/concurrent-ruby.rbi +0 -1586
  73. data/sorbet/rbi/gems/docile.rbi +0 -32
  74. data/sorbet/rbi/gems/em-websocket.rbi +0 -225
  75. data/sorbet/rbi/gems/eventmachine.rbi +0 -489
  76. data/sorbet/rbi/gems/ffaker.rbi +0 -60
  77. data/sorbet/rbi/gems/guard.rbi +0 -397
  78. data/sorbet/rbi/gems/http_parser.rb.rbi +0 -37
  79. data/sorbet/rbi/gems/i18n.rbi +0 -133
  80. data/sorbet/rbi/gems/kwalify.rbi +0 -340
  81. data/sorbet/rbi/gems/listen.rbi +0 -324
  82. data/sorbet/rbi/gems/lumberjack.rbi +0 -300
  83. data/sorbet/rbi/gems/method_source.rbi +0 -64
  84. data/sorbet/rbi/gems/multi_json.rbi +0 -62
  85. data/sorbet/rbi/gems/nenv.rbi +0 -60
  86. data/sorbet/rbi/gems/notiffany.rbi +0 -215
  87. data/sorbet/rbi/gems/parallel.rbi +0 -82
  88. data/sorbet/rbi/gems/parser.rbi +0 -1846
  89. data/sorbet/rbi/gems/pry-byebug.rbi +0 -155
  90. data/sorbet/rbi/gems/rb-fsevent.rbi +0 -31
  91. data/sorbet/rbi/gems/rb-readline.rbi +0 -767
  92. data/sorbet/rbi/gems/reek.rbi +0 -1027
  93. data/sorbet/rbi/gems/regexp_parser.rbi +0 -913
  94. data/sorbet/rbi/gems/rspec-support.rbi +0 -280
  95. data/sorbet/rbi/gems/rspec.rbi +0 -15
  96. data/sorbet/rbi/gems/rubocop-ast.rbi +0 -1053
  97. data/sorbet/rbi/gems/rubocop-rspec.rbi +0 -937
  98. data/sorbet/rbi/gems/rubocop.rbi +0 -6841
  99. data/sorbet/rbi/gems/ruby-progressbar.rbi +0 -305
  100. data/sorbet/rbi/gems/shellany.rbi +0 -29
  101. data/sorbet/rbi/gems/shoulda-matchers.rbi +0 -1848
  102. data/sorbet/rbi/gems/simplecov-html.rbi +0 -35
  103. data/sorbet/rbi/gems/simplecov.rbi +0 -361
  104. data/sorbet/rbi/gems/sqlite3.rbi +0 -354
  105. data/sorbet/rbi/gems/stackprof.rbi +0 -52
  106. data/sorbet/rbi/gems/thor.rbi +0 -32
  107. data/sorbet/rbi/gems/thread_safe.rbi +0 -82
  108. data/sorbet/rbi/gems/timecop.rbi +0 -98
  109. data/sorbet/rbi/gems/tzinfo.rbi +0 -406
  110. data/sorbet/rbi/gems/unicode-display_width.rbi +0 -17
  111. data/sorbet/rbi/hidden-definitions/errors.txt +0 -7275
  112. data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -14595
  113. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +0 -23
  114. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +0 -1431
  115. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +0 -108
  116. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +0 -276
  117. data/sorbet/rbi/sorbet-typed/lib/rubocop/~>0.85/rubocop.rbi +0 -2072
  118. data/sorbet/rbi/sorbet-typed/lib/rubocop-rspec/~>1.39/rubocop-rspec.rbi +0 -398
  119. data/sorbet/rbi/todo.rbi +0 -9
@@ -0,0 +1,1120 @@
1
+ # DO NOT EDIT MANUALLY
2
+ # This is an autogenerated file for types exported from the `regexp_parser` gem.
3
+ # Please instead update this file by running `bin/tapioca gem regexp_parser`.
4
+
5
+ # typed: true
6
+
7
+ module Regexp::Expression; end
8
+
9
+ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
10
+ def alternatives; end
11
+ def match_length; end
12
+ end
13
+
14
+ Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
15
+ class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence; end
16
+ module Regexp::Expression::Anchor; end
17
+ Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
18
+ Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
19
+
20
+ class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
21
+ def match_length; end
22
+ end
23
+
24
+ class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base; end
25
+ class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base; end
26
+ Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
27
+ Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
28
+ Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
29
+ class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base; end
30
+ class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base; end
31
+ class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base; end
32
+ class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base; end
33
+ class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base; end
34
+ class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base; end
35
+ module Regexp::Expression::Assertion; end
36
+
37
+ class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
38
+ def match_length; end
39
+ end
40
+
41
+ class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base; end
42
+ class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base; end
43
+ class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base; end
44
+ class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base; end
45
+ module Regexp::Expression::Backreference; end
46
+
47
+ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
48
+ def match_length; end
49
+ def referenced_expression; end
50
+ def referenced_expression=(_arg0); end
51
+
52
+ private
53
+
54
+ def initialize_copy(orig); end
55
+ end
56
+
57
+ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
58
+ def initialize(token, options = T.unsafe(nil)); end
59
+
60
+ def name; end
61
+ def reference; end
62
+ end
63
+
64
+ class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name; end
65
+
66
+ class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
67
+ def initialize(token, options = T.unsafe(nil)); end
68
+
69
+ def recursion_level; end
70
+ end
71
+
72
+ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
73
+ def initialize(token, options = T.unsafe(nil)); end
74
+
75
+ def number; end
76
+ def reference; end
77
+ end
78
+
79
+ class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number; end
80
+ class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative; end
81
+
82
+ class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number
83
+ def initialize(token, options = T.unsafe(nil)); end
84
+
85
+ def recursion_level; end
86
+ end
87
+
88
+ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
89
+ def effective_number; end
90
+ def effective_number=(_arg0); end
91
+ def reference; end
92
+ end
93
+
94
+ class Regexp::Expression::Base
95
+ include ::RuboCop::Ext::RegexpParser::Expression::Base
96
+
97
+ def initialize(token, options = T.unsafe(nil)); end
98
+
99
+ def =~(string, offset = T.unsafe(nil)); end
100
+ def a?; end
101
+ def ascii_classes?; end
102
+ def attributes; end
103
+ def base_length; end
104
+ def case_insensitive?; end
105
+ def coded_offset; end
106
+ def conditional_level; end
107
+ def conditional_level=(_arg0); end
108
+ def d?; end
109
+ def default_classes?; end
110
+ def extended?; end
111
+ def free_spacing?; end
112
+ def full_length; end
113
+ def greedy?; end
114
+ def i?; end
115
+ def ignore_case?; end
116
+ def is?(test_token, test_type = T.unsafe(nil)); end
117
+ def lazy?; end
118
+ def level; end
119
+ def level=(_arg0); end
120
+ def m?; end
121
+ def match(string, offset = T.unsafe(nil)); end
122
+ def match?(string); end
123
+ def matches?(string); end
124
+ def multiline?; end
125
+ def nesting_level; end
126
+ def nesting_level=(_arg0); end
127
+ def offset; end
128
+ def one_of?(scope, top = T.unsafe(nil)); end
129
+ def options; end
130
+ def options=(_arg0); end
131
+ def possessive?; end
132
+ def quantified?; end
133
+ def quantifier; end
134
+ def quantifier=(_arg0); end
135
+ def quantifier_affix(expression_format); end
136
+ def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
137
+ def quantity; end
138
+ def reluctant?; end
139
+ def repetitions; end
140
+ def set_level; end
141
+ def set_level=(_arg0); end
142
+ def starts_at; end
143
+ def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
144
+ def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
145
+ def terminal?; end
146
+ def text; end
147
+ def text=(_arg0); end
148
+ def to_h; end
149
+ def to_re(format = T.unsafe(nil)); end
150
+ def to_s(format = T.unsafe(nil)); end
151
+ def token; end
152
+ def token=(_arg0); end
153
+ def ts; end
154
+ def ts=(_arg0); end
155
+ def type; end
156
+ def type=(_arg0); end
157
+ def type?(test_type); end
158
+ def u?; end
159
+ def unicode_classes?; end
160
+ def unquantified_clone; end
161
+ def x?; end
162
+
163
+ private
164
+
165
+ def initialize_copy(orig); end
166
+ end
167
+
168
+ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
169
+ include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet
170
+
171
+ def initialize(token, options = T.unsafe(nil)); end
172
+
173
+ def close; end
174
+ def closed; end
175
+ def closed=(_arg0); end
176
+ def closed?; end
177
+ def match_length; end
178
+ def negate; end
179
+ def negated?; end
180
+ def negative; end
181
+ def negative=(_arg0); end
182
+ def negative?; end
183
+ def to_s(format = T.unsafe(nil)); end
184
+ end
185
+
186
+ class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
187
+ def match_length; end
188
+ end
189
+
190
+ class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
191
+ def match_length; end
192
+ end
193
+
194
+ Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
195
+
196
+ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
197
+ def <<(exp); end
198
+ def complete?; end
199
+ def match_length; end
200
+ def starts_at; end
201
+ def to_s(_format = T.unsafe(nil)); end
202
+ def ts; end
203
+ end
204
+
205
+ module Regexp::Expression::CharacterType; end
206
+ class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base; end
207
+
208
+ class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
209
+ def match_length; end
210
+ end
211
+
212
+ class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
213
+ class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
214
+ class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
215
+ class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
216
+ class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
217
+ class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
218
+ class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
219
+ class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
220
+ class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
221
+ class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
222
+ class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace; end
223
+ module Regexp::Expression::Conditional; end
224
+ class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence; end
225
+
226
+ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
227
+ def match_length; end
228
+ def reference; end
229
+ def referenced_expression; end
230
+ def referenced_expression=(_arg0); end
231
+
232
+ private
233
+
234
+ def initialize_copy(orig); end
235
+ end
236
+
237
+ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
238
+ def <<(exp); end
239
+ def add_sequence(active_opts = T.unsafe(nil)); end
240
+ def branch(active_opts = T.unsafe(nil)); end
241
+ def branches; end
242
+ def condition; end
243
+ def condition=(exp); end
244
+ def match_length; end
245
+ def reference; end
246
+ def referenced_expression; end
247
+ def referenced_expression=(_arg0); end
248
+ def to_s(format = T.unsafe(nil)); end
249
+
250
+ private
251
+
252
+ def initialize_copy(orig); end
253
+ end
254
+
255
+ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
256
+ def initialize; end
257
+ end
258
+
259
+ module Regexp::Expression::EscapeSequence; end
260
+
261
+ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
262
+ def char; end
263
+
264
+ private
265
+
266
+ def control_sequence_to_s(control_sequence); end
267
+ def meta_char_to_codepoint(meta_char); end
268
+ end
269
+
270
+ class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
271
+ class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
272
+
273
+ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
274
+ def char; end
275
+ def codepoint; end
276
+ def match_length; end
277
+ end
278
+
279
+ class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
280
+ class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
281
+
282
+ class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
283
+ def char; end
284
+ def chars; end
285
+ def codepoint; end
286
+ def codepoints; end
287
+ def match_length; end
288
+ end
289
+
290
+ class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
291
+ def codepoint; end
292
+ end
293
+
294
+ class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
295
+ class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
296
+
297
+ class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
298
+ def char; end
299
+ end
300
+
301
+ class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
302
+ def codepoint; end
303
+ end
304
+
305
+ class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
306
+ def codepoint; end
307
+ end
308
+
309
+ class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
310
+
311
+ class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
312
+ def char; end
313
+ end
314
+
315
+ class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
316
+ class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
317
+ class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
318
+
319
+ class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
320
+ def match_length; end
321
+ def quantify(_token, _text, _min = T.unsafe(nil), _max = T.unsafe(nil), _mode = T.unsafe(nil)); end
322
+ end
323
+
324
+ module Regexp::Expression::Group; end
325
+
326
+ class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
327
+ def match_length; end
328
+ end
329
+
330
+ class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
331
+
332
+ class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
333
+ def capturing?; end
334
+ def comment?; end
335
+ def to_s(format = T.unsafe(nil)); end
336
+ end
337
+
338
+ class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
339
+ def capturing?; end
340
+ def identifier; end
341
+ def number; end
342
+ def number=(_arg0); end
343
+ def number_at_level; end
344
+ def number_at_level=(_arg0); end
345
+ end
346
+
347
+ class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
348
+ def comment?; end
349
+ def to_s(_format = T.unsafe(nil)); end
350
+ end
351
+
352
+ class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
353
+ def initialize(token, options = T.unsafe(nil)); end
354
+
355
+ def identifier; end
356
+ def name; end
357
+
358
+ private
359
+
360
+ def initialize_copy(orig); end
361
+ end
362
+
363
+ class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
364
+ def option_changes; end
365
+ def option_changes=(_arg0); end
366
+
367
+ private
368
+
369
+ def initialize_copy(orig); end
370
+ end
371
+
372
+ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
373
+ def initialize(*_arg0); end
374
+
375
+ def implicit=(_arg0); end
376
+ def implicit?; end
377
+ def to_s(format = T.unsafe(nil)); end
378
+ end
379
+
380
+ module Regexp::Expression::Keep; end
381
+
382
+ class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
383
+ def match_length; end
384
+ end
385
+
386
+ class Regexp::Expression::Literal < ::Regexp::Expression::Base
387
+ def match_length; end
388
+ end
389
+
390
+ Regexp::Expression::MatchLength = Regexp::MatchLength
391
+
392
+ class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
393
+ def match_length; end
394
+ def name; end
395
+ def negative?; end
396
+ end
397
+
398
+ class Regexp::Expression::Quantifier
399
+ def initialize(token, text, min, max, mode); end
400
+
401
+ def ==(other); end
402
+ def eq(other); end
403
+ def greedy?; end
404
+ def lazy?; end
405
+ def max; end
406
+ def min; end
407
+ def mode; end
408
+ def possessive?; end
409
+ def reluctant?; end
410
+ def text; end
411
+ def to_h; end
412
+ def to_s; end
413
+ def to_str; end
414
+ def token; end
415
+
416
+ private
417
+
418
+ def initialize_copy(orig); end
419
+ end
420
+
421
+ Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
422
+
423
+ class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
424
+ class << self
425
+ def build(options = T.unsafe(nil)); end
426
+ def build_token; end
427
+ end
428
+ end
429
+
430
+ class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
431
+ def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
432
+ def starts_at; end
433
+ def ts; end
434
+
435
+ class << self
436
+ def add_to(subexpression, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
437
+ def at_levels(level, set_level, conditional_level); end
438
+ end
439
+ end
440
+
441
+ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
442
+ def <<(exp); end
443
+ def add_sequence(active_opts = T.unsafe(nil)); end
444
+ def operands; end
445
+ def operator; end
446
+ def sequences; end
447
+ def starts_at; end
448
+ def to_s(format = T.unsafe(nil)); end
449
+ def ts; end
450
+ end
451
+
452
+ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
453
+ include ::Enumerable
454
+
455
+ def initialize(token, options = T.unsafe(nil)); end
456
+
457
+ def <<(exp); end
458
+ def [](*args, &block); end
459
+ def at(*args, &block); end
460
+ def dig(*indices); end
461
+ def each(*args, &block); end
462
+ def each_expression(include_self = T.unsafe(nil)); end
463
+ def empty?(*args, &block); end
464
+ def expressions; end
465
+ def expressions=(_arg0); end
466
+ def fetch(*args, &block); end
467
+ def flat_map(include_self = T.unsafe(nil)); end
468
+ def index(*args, &block); end
469
+ def inner_match_length; end
470
+ def join(*args, &block); end
471
+ def last(*args, &block); end
472
+ def length(*args, &block); end
473
+ def match_length; end
474
+ def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
475
+ def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
476
+ def te; end
477
+ def to_h; end
478
+ def to_s(format = T.unsafe(nil)); end
479
+ def traverse(include_self = T.unsafe(nil), &block); end
480
+ def values_at(*args, &block); end
481
+ def walk(include_self = T.unsafe(nil), &block); end
482
+
483
+ private
484
+
485
+ def initialize_copy(orig); end
486
+ end
487
+
488
+ module Regexp::Expression::UnicodeProperty; end
489
+ class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
490
+ class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
491
+ class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
492
+ class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
493
+ class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
494
+ class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
495
+
496
+ class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
497
+ def match_length; end
498
+ def name; end
499
+ def negative?; end
500
+ def shortcut; end
501
+ end
502
+
503
+ class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
504
+ class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
505
+ class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
506
+ module Regexp::Expression::UnicodeProperty::Codepoint; end
507
+ class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
508
+ class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
509
+ class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
510
+ class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
511
+ class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
512
+ class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
513
+ class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
514
+ class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
515
+ class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
516
+ class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
517
+ class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
518
+ module Regexp::Expression::UnicodeProperty::Letter; end
519
+ class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
520
+ class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
521
+ class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
522
+ class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
523
+ class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
524
+ class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
525
+ class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
526
+ class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
527
+ class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
528
+ module Regexp::Expression::UnicodeProperty::Mark; end
529
+ class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
530
+ class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
531
+ class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
532
+ class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
533
+ class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
534
+ class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
535
+ class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
536
+ module Regexp::Expression::UnicodeProperty::Number; end
537
+ class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
538
+ class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
539
+ class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
540
+ class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
541
+ class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
542
+ class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
543
+ class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
544
+ module Regexp::Expression::UnicodeProperty::Punctuation; end
545
+ class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
546
+ class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
547
+ class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
548
+ class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
549
+ class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
550
+ class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
551
+ class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
552
+ class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
553
+ class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
554
+ class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
555
+ module Regexp::Expression::UnicodeProperty::Separator; end
556
+ class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
557
+ class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
558
+ class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
559
+ class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
560
+ class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
561
+ class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
562
+ module Regexp::Expression::UnicodeProperty::Symbol; end
563
+ class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
564
+ class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
565
+ class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
566
+ class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
567
+ class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
568
+ class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
569
+ class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
570
+ class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
571
+ class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
572
+ class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
573
+
574
+ class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
575
+ def merge(exp); end
576
+ end
577
+
578
+ class Regexp::Lexer
579
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
580
+
581
+ private
582
+
583
+ def ascend(type, token); end
584
+ def break_codepoint_list(token); end
585
+ def break_literal(token); end
586
+ def conditional_nesting; end
587
+ def conditional_nesting=(_arg0); end
588
+ def descend(type, token); end
589
+ def merge_condition(current); end
590
+ def nesting; end
591
+ def nesting=(_arg0); end
592
+ def set_nesting; end
593
+ def set_nesting=(_arg0); end
594
+ def shift; end
595
+ def shift=(_arg0); end
596
+ def tokens; end
597
+ def tokens=(_arg0); end
598
+
599
+ class << self
600
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
601
+ def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
602
+ end
603
+ end
604
+
605
+ Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
606
+ Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
607
+
608
+ class Regexp::MatchLength
609
+ include ::Enumerable
610
+
611
+ def initialize(exp, opts = T.unsafe(nil)); end
612
+
613
+ def each(opts = T.unsafe(nil)); end
614
+ def endless_each; end
615
+ def fixed?; end
616
+ def include?(length); end
617
+ def inspect; end
618
+ def max; end
619
+ def min; end
620
+ def minmax; end
621
+ def to_re; end
622
+
623
+ private
624
+
625
+ def base_max; end
626
+ def base_max=(_arg0); end
627
+ def base_min; end
628
+ def base_min=(_arg0); end
629
+ def exp_class; end
630
+ def exp_class=(_arg0); end
631
+ def max_rep; end
632
+ def max_rep=(_arg0); end
633
+ def min_rep; end
634
+ def min_rep=(_arg0); end
635
+ def reify; end
636
+ def reify=(_arg0); end
637
+ def test_regexp; end
638
+
639
+ class << self
640
+ def of(obj); end
641
+ end
642
+ end
643
+
644
+ class Regexp::Parser
645
+ include ::Regexp::Expression
646
+ include ::Regexp::Expression::UnicodeProperty
647
+
648
+ def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
649
+
650
+ private
651
+
652
+ def active_opts; end
653
+ def anchor(token); end
654
+ def assign_effective_number(exp); end
655
+ def assign_referenced_expressions; end
656
+ def backref(token); end
657
+ def captured_group_count_at_level; end
658
+ def captured_group_counts; end
659
+ def captured_group_counts=(_arg0); end
660
+ def close_completed_character_set_range; end
661
+ def close_group; end
662
+ def close_set; end
663
+ def conditional(token); end
664
+ def conditional_nesting; end
665
+ def conditional_nesting=(_arg0); end
666
+ def count_captured_group; end
667
+ def decrease_nesting; end
668
+ def escape(token); end
669
+ def extract_options(input, options); end
670
+ def free_space(token); end
671
+ def group(token); end
672
+ def increase_level(exp); end
673
+ def intersection(token); end
674
+ def interval(target_node, token); end
675
+ def keep(token); end
676
+ def literal(token); end
677
+ def meta(token); end
678
+ def negate_set; end
679
+ def nest(exp); end
680
+ def nest_conditional(exp); end
681
+ def nesting; end
682
+ def nesting=(_arg0); end
683
+ def node; end
684
+ def node=(_arg0); end
685
+ def open_group(token); end
686
+ def open_set(token); end
687
+ def options_group(token); end
688
+ def options_stack; end
689
+ def options_stack=(_arg0); end
690
+ def parse_token(token); end
691
+ def posixclass(token); end
692
+ def property(token); end
693
+ def quantifier(token); end
694
+ def range(token); end
695
+ def root; end
696
+ def root=(_arg0); end
697
+ def sequence_operation(klass, token); end
698
+ def set(token); end
699
+ def switching_options; end
700
+ def switching_options=(_arg0); end
701
+ def total_captured_group_count; end
702
+ def type(token); end
703
+ def update_transplanted_subtree(exp, new_parent); end
704
+
705
+ class << self
706
+ def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
707
+ end
708
+ end
709
+
710
+ Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
711
+ class Regexp::Parser::Error < ::StandardError; end
712
+ Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
713
+ class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
714
+ Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
715
+
716
+ class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
717
+ def initialize(type, token); end
718
+ end
719
+
720
+ class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
721
+ def initialize(type, token); end
722
+ end
723
+
724
+ Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
725
+
726
+ class Regexp::Scanner
727
+ def emit(type, token, text); end
728
+ def scan(input_object, options: T.unsafe(nil), &block); end
729
+
730
+ private
731
+
732
+ def append_literal(data, ts, te); end
733
+ def block; end
734
+ def block=(_arg0); end
735
+ def char_pos; end
736
+ def char_pos=(_arg0); end
737
+ def conditional_stack; end
738
+ def conditional_stack=(_arg0); end
739
+ def copy(data, ts, te); end
740
+ def emit_literal; end
741
+ def emit_meta_control_sequence(data, ts, te, token); end
742
+ def emit_options(text); end
743
+ def free_spacing; end
744
+ def free_spacing=(_arg0); end
745
+ def free_spacing?(input_object, options); end
746
+ def group_depth; end
747
+ def group_depth=(_arg0); end
748
+ def in_group?; end
749
+ def in_set?; end
750
+ def literal; end
751
+ def literal=(_arg0); end
752
+ def set_depth; end
753
+ def set_depth=(_arg0); end
754
+ def spacing_stack; end
755
+ def spacing_stack=(_arg0); end
756
+ def tokens; end
757
+ def tokens=(_arg0); end
758
+ def validation_error(type, what, reason); end
759
+
760
+ class << self
761
+ def long_prop_map; end
762
+ def scan(input_object, options: T.unsafe(nil), &block); end
763
+ def short_prop_map; end
764
+ end
765
+ end
766
+
767
+ class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
768
+ def initialize(what, reason); end
769
+ end
770
+
771
+ class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
772
+ def initialize(what, reason); end
773
+ end
774
+
775
+ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
776
+ def initialize(option, text); end
777
+ end
778
+
779
+ class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
780
+ def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
781
+ end
782
+
783
+ class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
784
+ def initialize(where = T.unsafe(nil)); end
785
+ end
786
+
787
+ class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
788
+
789
+ class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
790
+ def initialize(name); end
791
+ end
792
+
793
+ class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error
794
+ def initialize(reason); end
795
+ end
796
+
797
+ module Regexp::Syntax
798
+ private
799
+
800
+ def comparable_version(name); end
801
+ def const_missing(const_name); end
802
+ def fallback_version_class(version); end
803
+ def inherit_from_version(parent_version, new_version); end
804
+ def new(name); end
805
+ def specified_versions; end
806
+ def supported?(name); end
807
+ def version_class(version); end
808
+ def version_const_name(version_string); end
809
+ def warn_if_future_version(const_name); end
810
+
811
+ class << self
812
+ def comparable_version(name); end
813
+ def const_missing(const_name); end
814
+ def fallback_version_class(version); end
815
+ def inherit_from_version(parent_version, new_version); end
816
+ def new(name); end
817
+ def specified_versions; end
818
+ def supported?(name); end
819
+ def version_class(version); end
820
+ def version_const_name(version_string); end
821
+ def warn_if_future_version(const_name); end
822
+ end
823
+ end
824
+
825
+ class Regexp::Syntax::Any < ::Regexp::Syntax::Base
826
+ def initialize; end
827
+
828
+ def implements!(_type, _token); end
829
+ def implements?(_type, _token); end
830
+ end
831
+
832
+ class Regexp::Syntax::Base
833
+ include ::Regexp::Syntax::Token
834
+
835
+ def initialize; end
836
+
837
+ def check!(type, token); end
838
+ def check?(type, token); end
839
+ def excludes(type, tokens); end
840
+ def features; end
841
+ def implementations(type); end
842
+ def implements(type, tokens); end
843
+ def implements!(type, token); end
844
+ def implements?(type, token); end
845
+ def normalize(type, token); end
846
+ def normalize_backref(type, token); end
847
+ def normalize_group(type, token); end
848
+
849
+ class << self
850
+ def inspect; end
851
+ end
852
+ end
853
+
854
+ class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
855
+ def initialize(name); end
856
+ end
857
+
858
+ class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
859
+ def initialize(syntax, type, token); end
860
+ end
861
+
862
+ class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
863
+ module Regexp::Syntax::Token; end
864
+ Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
865
+ module Regexp::Syntax::Token::Anchor; end
866
+ Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
867
+ Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
868
+ Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
869
+ Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
870
+ Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
871
+ Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
872
+ module Regexp::Syntax::Token::Assertion; end
873
+ Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
874
+ Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
875
+ Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
876
+ Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
877
+ module Regexp::Syntax::Token::Backreference; end
878
+ Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
879
+ Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
880
+ Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
881
+ Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
882
+ Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
883
+ module Regexp::Syntax::Token::CharacterSet; end
884
+ Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
885
+ Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
886
+ Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
887
+ Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
888
+ module Regexp::Syntax::Token::CharacterType; end
889
+ Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
890
+ Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
891
+ Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
892
+ Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
893
+ Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
894
+ Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
895
+ module Regexp::Syntax::Token::Conditional; end
896
+ Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
897
+ Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
898
+ Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
899
+ Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
900
+ Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
901
+ module Regexp::Syntax::Token::Escape; end
902
+ Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
903
+ Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
904
+ Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
905
+ Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
906
+ Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
907
+ Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
908
+ Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
909
+ Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
910
+ Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
911
+ module Regexp::Syntax::Token::FreeSpace; end
912
+ Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
913
+ Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
914
+ module Regexp::Syntax::Token::Group; end
915
+ Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
916
+ Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
917
+ Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
918
+ Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
919
+ Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
920
+ Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
921
+ Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
922
+ Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
923
+ Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
924
+ Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
925
+ module Regexp::Syntax::Token::Keep; end
926
+ Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
927
+ Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
928
+ Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
929
+ module Regexp::Syntax::Token::Literal; end
930
+ Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
931
+ Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
932
+ Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
933
+ module Regexp::Syntax::Token::Meta; end
934
+ Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
935
+ Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
936
+ Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
937
+ Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
938
+ module Regexp::Syntax::Token::PosixClass; end
939
+ Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
940
+ Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
941
+ Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
942
+ Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
943
+ Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
944
+ module Regexp::Syntax::Token::Quantifier; end
945
+ Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
946
+ Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
947
+ Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
948
+ Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
949
+ Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
950
+ Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
951
+ Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
952
+ Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
953
+ Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
954
+ module Regexp::Syntax::Token::SubexpressionCall; end
955
+ Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
956
+ Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
957
+ Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
958
+ Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
959
+ module Regexp::Syntax::Token::UnicodeProperty; end
960
+ Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
961
+ Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
962
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
963
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
964
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
965
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
966
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
967
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
968
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
969
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
970
+ Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
971
+ module Regexp::Syntax::Token::UnicodeProperty::Category; end
972
+ Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
973
+ Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
974
+ Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
975
+ Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
976
+ Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
977
+ Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
978
+ Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
979
+ Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
980
+ Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
981
+ Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
982
+ Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
983
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
984
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
985
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
986
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
987
+ Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
988
+ Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
989
+ Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
990
+ Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
991
+ Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
992
+ Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
993
+ Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
994
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
995
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
996
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
997
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
998
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
999
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
1000
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
1001
+ Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
1002
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
1003
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
1004
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
1005
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
1006
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
1007
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
1008
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
1009
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
1010
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
1011
+ Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
1012
+ Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
1013
+ Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
1014
+ Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
1015
+ Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
1016
+ Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
1017
+ Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
1018
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
1019
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
1020
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
1021
+
1022
+ class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
1023
+ def initialize(name); end
1024
+ end
1025
+
1026
+ class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base
1027
+ def initialize; end
1028
+ end
1029
+
1030
+ class Regexp::Syntax::V1_9 < ::Regexp::Syntax::V1_9_3; end
1031
+
1032
+ class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6
1033
+ def initialize; end
1034
+ end
1035
+
1036
+ class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1
1037
+ def initialize; end
1038
+ end
1039
+
1040
+ class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9
1041
+ def initialize; end
1042
+ end
1043
+
1044
+ class Regexp::Syntax::V2_1 < ::Regexp::Syntax::V2_0_0; end
1045
+ class Regexp::Syntax::V2_2 < ::Regexp::Syntax::V2_2_0; end
1046
+
1047
+ class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_1
1048
+ def initialize; end
1049
+ end
1050
+
1051
+ class Regexp::Syntax::V2_3 < ::Regexp::Syntax::V2_3_0; end
1052
+
1053
+ class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2
1054
+ def initialize; end
1055
+ end
1056
+
1057
+ class Regexp::Syntax::V2_4 < ::Regexp::Syntax::V2_4_1; end
1058
+
1059
+ class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3
1060
+ def initialize; end
1061
+ end
1062
+
1063
+ class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0
1064
+ def initialize; end
1065
+ end
1066
+
1067
+ class Regexp::Syntax::V2_5 < ::Regexp::Syntax::V2_5_0; end
1068
+
1069
+ class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4
1070
+ def initialize; end
1071
+ end
1072
+
1073
+ class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5
1074
+ def initialize; end
1075
+ end
1076
+
1077
+ class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0
1078
+ def initialize; end
1079
+ end
1080
+
1081
+ class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2
1082
+ def initialize; end
1083
+ end
1084
+
1085
+ Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
1086
+ Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
1087
+ Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
1088
+ Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
1089
+
1090
+ class Regexp::Token < ::Struct
1091
+ def conditional_level; end
1092
+ def conditional_level=(_); end
1093
+ def length; end
1094
+ def level; end
1095
+ def level=(_); end
1096
+ def next; end
1097
+ def next=(_arg0); end
1098
+ def offset; end
1099
+ def previous; end
1100
+ def previous=(_arg0); end
1101
+ def set_level; end
1102
+ def set_level=(_); end
1103
+ def te; end
1104
+ def te=(_); end
1105
+ def text; end
1106
+ def text=(_); end
1107
+ def token; end
1108
+ def token=(_); end
1109
+ def ts; end
1110
+ def ts=(_); end
1111
+ def type; end
1112
+ def type=(_); end
1113
+
1114
+ class << self
1115
+ def [](*_arg0); end
1116
+ def inspect; end
1117
+ def members; end
1118
+ def new(*_arg0); end
1119
+ end
1120
+ end