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