titleist 0.1.1 → 1.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (109) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/tests.yml +19 -0
  3. data/.gitignore +1 -2
  4. data/.rubocop.yml +26 -1
  5. data/.ruby-version +1 -1
  6. data/Gemfile +13 -2
  7. data/README.md +95 -25
  8. data/Rakefile +17 -6
  9. data/docs/index.md +7 -0
  10. data/lib/generators/titleist/titleist_generator.rb +3 -0
  11. data/lib/titleist.rb +14 -9
  12. data/lib/titleist/controller.rb +36 -0
  13. data/lib/titleist/engine.rb +10 -4
  14. data/lib/titleist/helper.rb +23 -0
  15. data/lib/titleist/title.rb +52 -89
  16. data/lib/titleist/version.rb +5 -1
  17. data/rbi/sord.rbi +117 -0
  18. data/sorbet/config +2 -0
  19. data/sorbet/rbi/gems/actioncable.rbi +318 -0
  20. data/sorbet/rbi/gems/actionmailbox.rbi +56 -0
  21. data/sorbet/rbi/gems/actionmailer.rbi +446 -0
  22. data/sorbet/rbi/gems/actionpack.rbi +3411 -0
  23. data/sorbet/rbi/gems/actiontext.rbi +79 -0
  24. data/sorbet/rbi/gems/actionview.rbi +1185 -0
  25. data/sorbet/rbi/gems/activejob.rbi +362 -0
  26. data/sorbet/rbi/gems/activemodel.rbi +749 -0
  27. data/sorbet/rbi/gems/activerecord.rbi +5713 -0
  28. data/sorbet/rbi/gems/activestorage.rbi +221 -0
  29. data/sorbet/rbi/gems/activesupport.rbi +2437 -0
  30. data/sorbet/rbi/gems/addressable.rbi +146 -0
  31. data/sorbet/rbi/gems/ast.rbi +47 -0
  32. data/sorbet/rbi/gems/capybara.rbi +1787 -0
  33. data/sorbet/rbi/gems/childprocess.rbi +106 -0
  34. data/sorbet/rbi/gems/codeclimate-test-reporter.rbi +125 -0
  35. data/sorbet/rbi/gems/concurrent-ruby.rbi +1587 -0
  36. data/sorbet/rbi/gems/crass.rbi +92 -0
  37. data/sorbet/rbi/gems/docile.rbi +29 -0
  38. data/sorbet/rbi/gems/erubi.rbi +26 -0
  39. data/sorbet/rbi/gems/globalid.rbi +98 -0
  40. data/sorbet/rbi/gems/i18n.rbi +191 -0
  41. data/sorbet/rbi/gems/jaro_winkler.rbi +14 -0
  42. data/sorbet/rbi/gems/loofah.rbi +129 -0
  43. data/sorbet/rbi/gems/mail.rbi +1582 -0
  44. data/sorbet/rbi/gems/marcel.rbi +12 -0
  45. data/sorbet/rbi/gems/method_source.rbi +63 -0
  46. data/sorbet/rbi/gems/mini_mime.rbi +51 -0
  47. data/sorbet/rbi/gems/minitest.rbi +419 -0
  48. data/sorbet/rbi/gems/mocha.rbi +794 -0
  49. data/sorbet/rbi/gems/nio4r.rbi +67 -0
  50. data/sorbet/rbi/gems/nokogiri.rbi +1010 -0
  51. data/sorbet/rbi/gems/parallel.rbi +81 -0
  52. data/sorbet/rbi/gems/parser.rbi +920 -0
  53. data/sorbet/rbi/gems/public_suffix.rbi +103 -0
  54. data/sorbet/rbi/gems/puma.rbi +586 -0
  55. data/sorbet/rbi/gems/rack-test.rbi +161 -0
  56. data/sorbet/rbi/gems/rack.rbi +634 -0
  57. data/sorbet/rbi/gems/rails-dom-testing.rbi +67 -0
  58. data/sorbet/rbi/gems/rails-html-sanitizer.rbi +91 -0
  59. data/sorbet/rbi/gems/railties.rbi +834 -0
  60. data/sorbet/rbi/gems/rainbow.rbi +117 -0
  61. data/sorbet/rbi/gems/rake.rbi +269 -0
  62. data/sorbet/rbi/gems/regexp_parser.rbi +912 -0
  63. data/sorbet/rbi/gems/rubocop.rbi +7232 -0
  64. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  65. data/sorbet/rbi/gems/rubyzip.rbi +546 -0
  66. data/sorbet/rbi/gems/selenium-webdriver.rbi +1450 -0
  67. data/sorbet/rbi/gems/simplecov-html.rbi +30 -0
  68. data/sorbet/rbi/gems/simplecov.rbi +189 -0
  69. data/sorbet/rbi/gems/site_ruby.rbi +265 -0
  70. data/sorbet/rbi/gems/sprockets-rails.rbi +105 -0
  71. data/sorbet/rbi/gems/sprockets.rbi +753 -0
  72. data/sorbet/rbi/gems/sqlite3.rbi +353 -0
  73. data/sorbet/rbi/gems/thor.rbi +579 -0
  74. data/sorbet/rbi/gems/thread_safe.rbi +81 -0
  75. data/sorbet/rbi/gems/tzinfo.rbi +405 -0
  76. data/sorbet/rbi/gems/unicode-display_width.rbi +16 -0
  77. data/sorbet/rbi/gems/webdrivers.rbi +155 -0
  78. data/sorbet/rbi/gems/xpath.rbi +158 -0
  79. data/sorbet/rbi/gems/yard.rbi +1159 -0
  80. data/sorbet/rbi/hidden-definitions/errors.txt +14957 -0
  81. data/sorbet/rbi/hidden-definitions/hidden.rbi +24898 -0
  82. data/sorbet/rbi/sorbet-typed/lib/actionmailer/all/actionmailer.rbi +13 -0
  83. data/sorbet/rbi/sorbet-typed/lib/actionpack/all/actionpack.rbi +938 -0
  84. data/sorbet/rbi/sorbet-typed/lib/actionview/all/actionview.rbi +314 -0
  85. data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi +425 -0
  86. data/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi +17 -0
  87. data/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi +1425 -0
  88. data/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi +475 -0
  89. data/sorbet/rbi/sorbet-typed/lib/activestorage/>=6.0.0/activestorage.rbi +19 -0
  90. data/sorbet/rbi/sorbet-typed/lib/activestorage/all/activestorage.rbi +173 -0
  91. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +23 -0
  92. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +858 -0
  93. data/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi +8684 -0
  94. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +108 -0
  95. data/sorbet/rbi/sorbet-typed/lib/railties/all/railties.rbi +25 -0
  96. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +254 -0
  97. data/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi +4222 -0
  98. data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +111 -0
  99. data/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi +543 -0
  100. data/sorbet/rbi/todo.rbi +20 -0
  101. data/titleist.gemspec +3 -14
  102. metadata +96 -155
  103. data/.travis.yml +0 -45
  104. data/app/controllers/.keep +0 -0
  105. data/app/helpers/.keep +0 -0
  106. data/app/helpers/titleist_helper.rb +0 -47
  107. data/app/mailers/.keep +0 -0
  108. data/app/models/.keep +0 -0
  109. data/app/views/.keep +0 -0
@@ -0,0 +1,117 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rainbow/all/rainbow.rbi
9
+ #
10
+ # rainbow-3.0.0
11
+ module Rainbow
12
+ def self.enabled; end
13
+ def self.enabled=(value); end
14
+ def self.global; end
15
+ def self.new; end
16
+ def self.uncolor(string); end
17
+ end
18
+ class Rainbow::StringUtils
19
+ def self.uncolor(string); end
20
+ def self.wrap_with_sgr(string, codes); end
21
+ end
22
+ module Rainbow::X11ColorNames
23
+ end
24
+ class Rainbow::Color
25
+ def ground; end
26
+ def self.build(ground, values); end
27
+ def self.parse_hex_color(hex); end
28
+ end
29
+ class Rainbow::Color::Indexed < Rainbow::Color
30
+ def codes; end
31
+ def initialize(ground, num); end
32
+ def num; end
33
+ end
34
+ class Rainbow::Color::Named < Rainbow::Color::Indexed
35
+ def initialize(ground, name); end
36
+ def self.color_names; end
37
+ def self.valid_names; end
38
+ end
39
+ class Rainbow::Color::RGB < Rainbow::Color::Indexed
40
+ def b; end
41
+ def code_from_rgb; end
42
+ def codes; end
43
+ def g; end
44
+ def initialize(ground, *values); end
45
+ def r; end
46
+ def self.to_ansi_domain(value); end
47
+ end
48
+ class Rainbow::Color::X11Named < Rainbow::Color::RGB
49
+ def initialize(ground, name); end
50
+ def self.color_names; end
51
+ def self.valid_names; end
52
+ include Rainbow::X11ColorNames
53
+ end
54
+ class Rainbow::Presenter < String
55
+ def background(*values); end
56
+ def bg(*values); end
57
+ def black; end
58
+ def blink; end
59
+ def blue; end
60
+ def bold; end
61
+ def bright; end
62
+ def color(*values); end
63
+ def cyan; end
64
+ def dark; end
65
+ def faint; end
66
+ def fg(*values); end
67
+ def foreground(*values); end
68
+ def green; end
69
+ def hide; end
70
+ def inverse; end
71
+ def italic; end
72
+ def magenta; end
73
+ def method_missing(method_name, *args); end
74
+ def red; end
75
+ def reset; end
76
+ def respond_to_missing?(method_name, *args); end
77
+ def underline; end
78
+ def white; end
79
+ def wrap_with_sgr(codes); end
80
+ def yellow; end
81
+ end
82
+ class Rainbow::NullPresenter < String
83
+ def background(*_values); end
84
+ def bg(*_values); end
85
+ def black; end
86
+ def blink; end
87
+ def blue; end
88
+ def bold; end
89
+ def bright; end
90
+ def color(*_values); end
91
+ def cyan; end
92
+ def dark; end
93
+ def faint; end
94
+ def fg(*_values); end
95
+ def foreground(*_values); end
96
+ def green; end
97
+ def hide; end
98
+ def inverse; end
99
+ def italic; end
100
+ def magenta; end
101
+ def method_missing(method_name, *args); end
102
+ def red; end
103
+ def reset; end
104
+ def respond_to_missing?(method_name, *args); end
105
+ def underline; end
106
+ def white; end
107
+ def yellow; end
108
+ end
109
+ class Rainbow::Wrapper
110
+ def enabled; end
111
+ def enabled=(arg0); end
112
+ def initialize(enabled = nil); end
113
+ def wrap(string); end
114
+ end
115
+ class Object < BasicObject
116
+ def Rainbow(string); end
117
+ end
@@ -0,0 +1,269 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi
9
+ #
10
+ # rake-13.0.1
11
+ module Rake
12
+ def self.each_dir_parent(dir); end
13
+ def self.from_pathname(path); end
14
+ end
15
+ module Rake::Cloneable
16
+ def initialize_copy(source); end
17
+ end
18
+ module FileUtils
19
+ def create_shell_runner(cmd); end
20
+ def ruby(*args, **options, &block); end
21
+ def safe_ln(*args, **options); end
22
+ def set_verbose_option(options); end
23
+ def sh(*cmd, &block); end
24
+ def sh_show_command(cmd); end
25
+ def split_all(path); end
26
+ end
27
+ module Rake::FileUtilsExt
28
+ def cd(*args, **options, &block); end
29
+ def chdir(*args, **options, &block); end
30
+ def chmod(*args, **options, &block); end
31
+ def chmod_R(*args, **options, &block); end
32
+ def chown(*args, **options, &block); end
33
+ def chown_R(*args, **options, &block); end
34
+ def copy(*args, **options, &block); end
35
+ def cp(*args, **options, &block); end
36
+ def cp_lr(*args, **options, &block); end
37
+ def cp_r(*args, **options, &block); end
38
+ def install(*args, **options, &block); end
39
+ def link(*args, **options, &block); end
40
+ def ln(*args, **options, &block); end
41
+ def ln_s(*args, **options, &block); end
42
+ def ln_sf(*args, **options, &block); end
43
+ def makedirs(*args, **options, &block); end
44
+ def mkdir(*args, **options, &block); end
45
+ def mkdir_p(*args, **options, &block); end
46
+ def mkpath(*args, **options, &block); end
47
+ def move(*args, **options, &block); end
48
+ def mv(*args, **options, &block); end
49
+ def nowrite(value = nil); end
50
+ def rake_check_options(options, *optdecl); end
51
+ def rake_output_message(message); end
52
+ def remove(*args, **options, &block); end
53
+ def rm(*args, **options, &block); end
54
+ def rm_f(*args, **options, &block); end
55
+ def rm_r(*args, **options, &block); end
56
+ def rm_rf(*args, **options, &block); end
57
+ def rmdir(*args, **options, &block); end
58
+ def rmtree(*args, **options, &block); end
59
+ def safe_unlink(*args, **options, &block); end
60
+ def self.nowrite_flag; end
61
+ def self.nowrite_flag=(arg0); end
62
+ def self.verbose_flag; end
63
+ def self.verbose_flag=(arg0); end
64
+ def symlink(*args, **options, &block); end
65
+ def touch(*args, **options, &block); end
66
+ def verbose(value = nil); end
67
+ def when_writing(msg = nil); end
68
+ extend Rake::FileUtilsExt
69
+ include FileUtils
70
+ end
71
+ class Module
72
+ def rake_extension(method); end
73
+ end
74
+ class String
75
+ def ext(newext = nil); end
76
+ def pathmap(spec = nil, &block); end
77
+ def pathmap_explode; end
78
+ def pathmap_partial(n); end
79
+ def pathmap_replace(patterns, &block); end
80
+ end
81
+ class Rake::FileList
82
+ def &(*args, &block); end
83
+ def *(other); end
84
+ def +(*args, &block); end
85
+ def -(*args, &block); end
86
+ def <<(obj); end
87
+ def <=>(*args, &block); end
88
+ def ==(array); end
89
+ def [](*args, &block); end
90
+ def []=(*args, &block); end
91
+ def add(*filenames); end
92
+ def add_matching(pattern); end
93
+ def all?(*args, &block); end
94
+ def any?(*args, &block); end
95
+ def append(*args, &block); end
96
+ def assoc(*args, &block); end
97
+ def at(*args, &block); end
98
+ def bsearch(*args, &block); end
99
+ def bsearch_index(*args, &block); end
100
+ def chain(*args, &block); end
101
+ def chunk(*args, &block); end
102
+ def chunk_while(*args, &block); end
103
+ def clear(*args, &block); end
104
+ def clear_exclude; end
105
+ def collect!(*args, &block); end
106
+ def collect(*args, &block); end
107
+ def collect_concat(*args, &block); end
108
+ def combination(*args, &block); end
109
+ def compact!(*args, &block); end
110
+ def compact(*args, &block); end
111
+ def concat(*args, &block); end
112
+ def count(*args, &block); end
113
+ def cycle(*args, &block); end
114
+ def delete(*args, &block); end
115
+ def delete_at(*args, &block); end
116
+ def delete_if(*args, &block); end
117
+ def detect(*args, &block); end
118
+ def difference(*args, &block); end
119
+ def dig(*args, &block); end
120
+ def drop(*args, &block); end
121
+ def drop_while(*args, &block); end
122
+ def each(*args, &block); end
123
+ def each_cons(*args, &block); end
124
+ def each_entry(*args, &block); end
125
+ def each_index(*args, &block); end
126
+ def each_slice(*args, &block); end
127
+ def each_with_index(*args, &block); end
128
+ def each_with_object(*args, &block); end
129
+ def egrep(pattern, *options); end
130
+ def empty?(*args, &block); end
131
+ def entries(*args, &block); end
132
+ def exclude(*patterns, &block); end
133
+ def exclude?(*args, &block); end
134
+ def excluded_from_list?(fn); end
135
+ def excluding(*args, &block); end
136
+ def existing!; end
137
+ def existing; end
138
+ def ext(newext = nil); end
139
+ def extract!(*args, &block); end
140
+ def extract_options!(*args, &block); end
141
+ def fetch(*args, &block); end
142
+ def fifth(*args, &block); end
143
+ def fill(*args, &block); end
144
+ def filter!(*args, &block); end
145
+ def filter(*args, &block); end
146
+ def find(*args, &block); end
147
+ def find_all(*args, &block); end
148
+ def find_index(*args, &block); end
149
+ def first(*args, &block); end
150
+ def flat_map(*args, &block); end
151
+ def flatten!(*args, &block); end
152
+ def flatten(*args, &block); end
153
+ def forty_two(*args, &block); end
154
+ def fourth(*args, &block); end
155
+ def from(*args, &block); end
156
+ def grep(*args, &block); end
157
+ def grep_v(*args, &block); end
158
+ def group_by(*args, &block); end
159
+ def gsub!(pat, rep); end
160
+ def gsub(pat, rep); end
161
+ def import(array); end
162
+ def in_groups(*args, &block); end
163
+ def in_groups_of(*args, &block); end
164
+ def include(*filenames); end
165
+ def include?(*args, &block); end
166
+ def including(*args, &block); end
167
+ def index(*args, &block); end
168
+ def index_by(*args, &block); end
169
+ def index_with(*args, &block); end
170
+ def initialize(*patterns); end
171
+ def inject(*args, &block); end
172
+ def inquiry(*args, &block); end
173
+ def insert(*args, &block); end
174
+ def inspect(*args, &block); end
175
+ def is_a?(klass); end
176
+ def join(*args, &block); end
177
+ def keep_if(*args, &block); end
178
+ def kind_of?(klass); end
179
+ def last(*args, &block); end
180
+ def lazy(*args, &block); end
181
+ def length(*args, &block); end
182
+ def many?(*args, &block); end
183
+ def map!(*args, &block); end
184
+ def map(*args, &block); end
185
+ def max(*args, &block); end
186
+ def max_by(*args, &block); end
187
+ def member?(*args, &block); end
188
+ def min(*args, &block); end
189
+ def min_by(*args, &block); end
190
+ def minmax(*args, &block); end
191
+ def minmax_by(*args, &block); end
192
+ def none?(*args, &block); end
193
+ def one?(*args, &block); end
194
+ def pack(*args, &block); end
195
+ def partition(&block); end
196
+ def pathmap(spec = nil, &block); end
197
+ def permutation(*args, &block); end
198
+ def place(*args, &block); end
199
+ def pluck(*args, &block); end
200
+ def pop(*args, &block); end
201
+ def prepend(*args, &block); end
202
+ def product(*args, &block); end
203
+ def push(*args, &block); end
204
+ def rassoc(*args, &block); end
205
+ def reduce(*args, &block); end
206
+ def reject!(*args, &block); end
207
+ def reject(*args, &block); end
208
+ def repeated_combination(*args, &block); end
209
+ def repeated_permutation(*args, &block); end
210
+ def replace(*args, &block); end
211
+ def resolve; end
212
+ def resolve_add(fn); end
213
+ def resolve_exclude; end
214
+ def reverse!(*args, &block); end
215
+ def reverse(*args, &block); end
216
+ def reverse_each(*args, &block); end
217
+ def rindex(*args, &block); end
218
+ def rotate!(*args, &block); end
219
+ def rotate(*args, &block); end
220
+ def sample(*args, &block); end
221
+ def second(*args, &block); end
222
+ def second_to_last(*args, &block); end
223
+ def select!(*args, &block); end
224
+ def select(*args, &block); end
225
+ def self.[](*args); end
226
+ def self.glob(pattern, *args); end
227
+ def shelljoin(*args, &block); end
228
+ def shift(*args, &block); end
229
+ def shuffle!(*args, &block); end
230
+ def shuffle(*args, &block); end
231
+ def size(*args, &block); end
232
+ def slice!(*args, &block); end
233
+ def slice(*args, &block); end
234
+ def slice_after(*args, &block); end
235
+ def slice_before(*args, &block); end
236
+ def slice_when(*args, &block); end
237
+ def sort!(*args, &block); end
238
+ def sort(*args, &block); end
239
+ def sort_by!(*args, &block); end
240
+ def sort_by(*args, &block); end
241
+ def split(*args, &block); end
242
+ def sub!(pat, rep); end
243
+ def sub(pat, rep); end
244
+ def sum(*args, &block); end
245
+ def take(*args, &block); end
246
+ def take_while(*args, &block); end
247
+ def third(*args, &block); end
248
+ def third_to_last(*args, &block); end
249
+ def to(*args, &block); end
250
+ def to_a; end
251
+ def to_ary; end
252
+ def to_default_s(*args, &block); end
253
+ def to_formatted_s(*args, &block); end
254
+ def to_h(*args, &block); end
255
+ def to_s; end
256
+ def to_sentence(*args, &block); end
257
+ def to_set(*args, &block); end
258
+ def to_xml(*args, &block); end
259
+ def transpose(*args, &block); end
260
+ def union(*args, &block); end
261
+ def uniq!(*args, &block); end
262
+ def uniq(*args, &block); end
263
+ def unshift(*args, &block); end
264
+ def values_at(*args, &block); end
265
+ def without(*args, &block); end
266
+ def zip(*args, &block); end
267
+ def |(*args, &block); end
268
+ include Rake::Cloneable
269
+ end
@@ -0,0 +1,912 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/regexp_parser/all/regexp_parser.rbi
9
+ #
10
+ # regexp_parser-1.6.0
11
+ class Regexp
12
+ end
13
+ class Regexp::Parser
14
+ def active_opts; end
15
+ def anchor(token); end
16
+ def assign_effective_number(exp); end
17
+ def assign_referenced_expressions; end
18
+ def backref(token); end
19
+ def captured_group_count_at_level; end
20
+ def captured_group_counts; end
21
+ def captured_group_counts=(arg0); end
22
+ def close_completed_character_set_range; end
23
+ def close_group; end
24
+ def close_set; end
25
+ def conditional(token); end
26
+ def conditional_nesting; end
27
+ def conditional_nesting=(arg0); end
28
+ def count_captured_group; end
29
+ def decrease_nesting; end
30
+ def escape(token); end
31
+ def free_space(token); end
32
+ def group(token); end
33
+ def intersection(token); end
34
+ def interval(target_node, token); end
35
+ def keep(token); end
36
+ def meta(token); end
37
+ def negate_set; end
38
+ def nest(exp); end
39
+ def nest_conditional(exp); end
40
+ def nesting; end
41
+ def nesting=(arg0); end
42
+ def node; end
43
+ def node=(arg0); end
44
+ def open_group(token); end
45
+ def open_set(token); end
46
+ def options_from_input(input); end
47
+ def options_group(token); end
48
+ def options_stack; end
49
+ def options_stack=(arg0); end
50
+ def parse(input, syntax = nil, &block); end
51
+ def parse_token(token); end
52
+ def posixclass(token); end
53
+ def property(token); end
54
+ def quantifier(token); end
55
+ def range(token); end
56
+ def root; end
57
+ def root=(arg0); end
58
+ def self.parse(input, syntax = nil, &block); end
59
+ def sequence_operation(klass, token); end
60
+ def set(token); end
61
+ def switching_options; end
62
+ def switching_options=(arg0); end
63
+ def total_captured_group_count; end
64
+ def type(token); end
65
+ def update_transplanted_subtree(exp, new_parent); end
66
+ include Regexp::Expression
67
+ include Regexp::Expression::UnicodeProperty
68
+ include Regexp::Syntax
69
+ end
70
+ class Regexp::Token < Struct
71
+ def conditional_level; end
72
+ def conditional_level=(_); end
73
+ def length; end
74
+ def level; end
75
+ def level=(_); end
76
+ def next; end
77
+ def next=(arg0); end
78
+ def offset; end
79
+ def previous; end
80
+ def previous=(arg0); end
81
+ def self.[](*arg0); end
82
+ def self.inspect; end
83
+ def self.members; end
84
+ def self.new(*arg0); end
85
+ def set_level; end
86
+ def set_level=(_); end
87
+ def te; end
88
+ def te=(_); end
89
+ def text; end
90
+ def text=(_); end
91
+ def token; end
92
+ def token=(_); end
93
+ def ts; end
94
+ def ts=(_); end
95
+ def type; end
96
+ def type=(_); end
97
+ end
98
+ class Regexp::Scanner
99
+ def append_literal(data, ts, te); end
100
+ def block; end
101
+ def block=(arg0); end
102
+ def conditional_stack; end
103
+ def conditional_stack=(arg0); end
104
+ def copy(data, range); end
105
+ def emit(type, token, text, ts, te); end
106
+ def emit_literal; end
107
+ def emit_meta_control_sequence(data, ts, te, token); end
108
+ def emit_options(text, ts, te); end
109
+ def free_spacing; end
110
+ def free_spacing=(arg0); end
111
+ def group_depth; end
112
+ def group_depth=(arg0); end
113
+ def in_group?; end
114
+ def in_set?; end
115
+ def literal; end
116
+ def literal=(arg0); end
117
+ def scan(input_object, &block); end
118
+ def self.long_prop_map; end
119
+ def self.scan(input_object, &block); end
120
+ def self.short_prop_map; end
121
+ def set_depth; end
122
+ def set_depth=(arg0); end
123
+ def spacing_stack; end
124
+ def spacing_stack=(arg0); end
125
+ def text(data, ts, te, soff = nil); end
126
+ def tokens; end
127
+ def tokens=(arg0); end
128
+ def validation_error(type, what, reason); end
129
+ end
130
+ class Regexp::Scanner::ScannerError < StandardError
131
+ end
132
+ class Regexp::Scanner::ValidationError < StandardError
133
+ def initialize(reason); end
134
+ end
135
+ class Regexp::Scanner::PrematureEndError < Regexp::Scanner::ScannerError
136
+ def initialize(where = nil); end
137
+ end
138
+ class Regexp::Scanner::InvalidSequenceError < Regexp::Scanner::ValidationError
139
+ def initialize(what = nil, where = nil); end
140
+ end
141
+ class Regexp::Scanner::InvalidGroupError < Regexp::Scanner::ValidationError
142
+ def initialize(what, reason); end
143
+ end
144
+ class Regexp::Scanner::InvalidGroupOption < Regexp::Scanner::ValidationError
145
+ def initialize(option, text); end
146
+ end
147
+ class Regexp::Scanner::InvalidBackrefError < Regexp::Scanner::ValidationError
148
+ def initialize(what, reason); end
149
+ end
150
+ class Regexp::Scanner::UnknownUnicodePropertyError < Regexp::Scanner::ValidationError
151
+ def initialize(name); end
152
+ end
153
+ module Regexp::Syntax
154
+ def comparable_version(name); end
155
+ def const_missing(const_name); end
156
+ def fallback_version_class(version); end
157
+ def inherit_from_version(parent_version, new_version); end
158
+ def new(name); end
159
+ def self.comparable_version(name); end
160
+ def self.const_missing(const_name); end
161
+ def self.fallback_version_class(version); end
162
+ def self.inherit_from_version(parent_version, new_version); end
163
+ def self.new(name); end
164
+ def self.specified_versions; end
165
+ def self.supported?(name); end
166
+ def self.version_class(version); end
167
+ def self.version_const_name(version_string); end
168
+ def self.warn_if_future_version(const_name); end
169
+ def specified_versions; end
170
+ def supported?(name); end
171
+ def version_class(version); end
172
+ def version_const_name(version_string); end
173
+ def warn_if_future_version(const_name); end
174
+ end
175
+ module Regexp::Syntax::Token
176
+ end
177
+ module Regexp::Syntax::Token::Anchor
178
+ end
179
+ module Regexp::Syntax::Token::Assertion
180
+ end
181
+ module Regexp::Syntax::Token::Backreference
182
+ end
183
+ module Regexp::Syntax::Token::SubexpressionCall
184
+ end
185
+ module Regexp::Syntax::Token::PosixClass
186
+ end
187
+ module Regexp::Syntax::Token::CharacterSet
188
+ end
189
+ module Regexp::Syntax::Token::CharacterType
190
+ end
191
+ module Regexp::Syntax::Token::Conditional
192
+ end
193
+ module Regexp::Syntax::Token::Escape
194
+ end
195
+ module Regexp::Syntax::Token::Group
196
+ end
197
+ module Regexp::Syntax::Token::Keep
198
+ end
199
+ module Regexp::Syntax::Token::Meta
200
+ end
201
+ module Regexp::Syntax::Token::Quantifier
202
+ end
203
+ module Regexp::Syntax::Token::UnicodeProperty
204
+ end
205
+ module Regexp::Syntax::Token::UnicodeProperty::Category
206
+ end
207
+ module Regexp::Syntax::Token::Literal
208
+ end
209
+ module Regexp::Syntax::Token::FreeSpace
210
+ end
211
+ class Regexp::Syntax::NotImplementedError < SyntaxError
212
+ def initialize(syntax, type, token); end
213
+ end
214
+ class Regexp::Syntax::Base
215
+ def check!(type, token); end
216
+ def check?(type, token); end
217
+ def excludes(type, tokens); end
218
+ def features; end
219
+ def implementations(type); end
220
+ def implements!(type, token); end
221
+ def implements(type, tokens); end
222
+ def implements?(type, token); end
223
+ def initialize; end
224
+ def normalize(type, token); end
225
+ def normalize_backref(type, token); end
226
+ def normalize_group(type, token); end
227
+ def self.inspect; end
228
+ include Regexp::Syntax::Token
229
+ end
230
+ class Regexp::Syntax::Any < Regexp::Syntax::Base
231
+ def implements!(type, token); end
232
+ def implements?(type, token); end
233
+ def initialize; end
234
+ end
235
+ class Regexp::Syntax::InvalidVersionNameError < SyntaxError
236
+ def initialize(name); end
237
+ end
238
+ class Regexp::Syntax::UnknownSyntaxNameError < SyntaxError
239
+ def initialize(name); end
240
+ end
241
+ class Regexp::Syntax::V1_8_6 < Regexp::Syntax::Base
242
+ def initialize; end
243
+ end
244
+ class Regexp::Syntax::V1_9_1 < Regexp::Syntax::V1_8_6
245
+ def initialize; end
246
+ end
247
+ class Regexp::Syntax::V1_9_3 < Regexp::Syntax::V1_9_1
248
+ def initialize; end
249
+ end
250
+ class Regexp::Syntax::V1_9 < Regexp::Syntax::V1_9_3
251
+ end
252
+ class Regexp::Syntax::V2_0_0 < Regexp::Syntax::V1_9
253
+ def initialize; end
254
+ end
255
+ class Regexp::Syntax::V2_1 < Regexp::Syntax::V2_0_0
256
+ end
257
+ class Regexp::Syntax::V2_2_0 < Regexp::Syntax::V2_1
258
+ def initialize; end
259
+ end
260
+ class Regexp::Syntax::V2_2 < Regexp::Syntax::V2_2_0
261
+ end
262
+ class Regexp::Syntax::V2_3_0 < Regexp::Syntax::V2_2
263
+ def initialize; end
264
+ end
265
+ class Regexp::Syntax::V2_3 < Regexp::Syntax::V2_3_0
266
+ end
267
+ class Regexp::Syntax::V2_4_0 < Regexp::Syntax::V2_3
268
+ def initialize; end
269
+ end
270
+ class Regexp::Syntax::V2_4_1 < Regexp::Syntax::V2_4_0
271
+ def initialize; end
272
+ end
273
+ class Regexp::Syntax::V2_4 < Regexp::Syntax::V2_4_1
274
+ end
275
+ class Regexp::Syntax::V2_5_0 < Regexp::Syntax::V2_4
276
+ def initialize; end
277
+ end
278
+ class Regexp::Syntax::V2_5 < Regexp::Syntax::V2_5_0
279
+ end
280
+ class Regexp::Syntax::V2_6_0 < Regexp::Syntax::V2_5
281
+ def initialize; end
282
+ end
283
+ class Regexp::Syntax::V2_6_2 < Regexp::Syntax::V2_6_0
284
+ def initialize; end
285
+ end
286
+ class Regexp::Syntax::V2_6_3 < Regexp::Syntax::V2_6_2
287
+ def initialize; end
288
+ end
289
+ class Regexp::Syntax::SyntaxError < StandardError
290
+ end
291
+ class Regexp::Lexer
292
+ def ascend(type, token); end
293
+ def break_codepoint_list(token); end
294
+ def break_literal(token); end
295
+ def conditional_nesting; end
296
+ def conditional_nesting=(arg0); end
297
+ def descend(type, token); end
298
+ def lex(input, syntax = nil, &block); end
299
+ def merge_condition(current); end
300
+ def nesting; end
301
+ def nesting=(arg0); end
302
+ def self.lex(input, syntax = nil, &block); end
303
+ def self.scan(input, syntax = nil, &block); end
304
+ def set_nesting; end
305
+ def set_nesting=(arg0); end
306
+ def shift; end
307
+ def shift=(arg0); end
308
+ def tokens; end
309
+ def tokens=(arg0); end
310
+ end
311
+ module Regexp::Expression
312
+ def self.parsed(exp); end
313
+ end
314
+ class Regexp::Expression::Quantifier
315
+ def greedy?; end
316
+ def initialize(token, text, min, max, mode); end
317
+ def initialize_clone(orig); end
318
+ def lazy?; end
319
+ def max; end
320
+ def min; end
321
+ def mode; end
322
+ def possessive?; end
323
+ def reluctant?; end
324
+ def text; end
325
+ def to_h; end
326
+ def to_s; end
327
+ def to_str; end
328
+ def token; end
329
+ end
330
+ class Regexp::Expression::Subexpression < Regexp::Expression::Base
331
+ def <<(exp); end
332
+ def [](*args, &block); end
333
+ def at(*args, &block); end
334
+ def dig(*indices); end
335
+ def each(*args, &block); end
336
+ def each_expression(include_self = nil, &block); end
337
+ def empty?(*args, &block); end
338
+ def expressions; end
339
+ def expressions=(arg0); end
340
+ def fetch(*args, &block); end
341
+ def flat_map(include_self = nil, &block); end
342
+ def index(*args, &block); end
343
+ def initialize(token, options = nil); end
344
+ def initialize_clone(orig); end
345
+ def inner_match_length; end
346
+ def join(*args, &block); end
347
+ def last(*args, &block); end
348
+ def length(*args, &block); end
349
+ def match_length; end
350
+ def strfre_tree(format = nil, include_self = nil, separator = nil); end
351
+ def strfregexp_tree(format = nil, include_self = nil, separator = nil); end
352
+ def te; end
353
+ def to_h; end
354
+ def to_s(format = nil); end
355
+ def traverse(include_self = nil, &block); end
356
+ def values_at(*args, &block); end
357
+ def walk(include_self = nil, &block); end
358
+ include Enumerable
359
+ end
360
+ class Regexp::Expression::Sequence < Regexp::Expression::Subexpression
361
+ def initialize(*args); end
362
+ def quantify(token, text, min = nil, max = nil, mode = nil); end
363
+ def self.add_to(subexpression, params = nil, active_opts = nil); end
364
+ def self.at_levels(level, set_level, conditional_level); end
365
+ def starts_at; end
366
+ def ts; end
367
+ end
368
+ class Regexp::Expression::SequenceOperation < Regexp::Expression::Subexpression
369
+ def <<(exp); end
370
+ def add_sequence(active_opts = nil); end
371
+ def operands; end
372
+ def operator; end
373
+ def sequences; end
374
+ def starts_at; end
375
+ def to_s(format = nil); end
376
+ def ts; end
377
+ end
378
+ class Regexp::Expression::Alternative < Regexp::Expression::Sequence
379
+ end
380
+ class Regexp::Expression::Alternation < Regexp::Expression::SequenceOperation
381
+ def alternatives; end
382
+ def match_length; end
383
+ end
384
+ module Regexp::Expression::Anchor
385
+ end
386
+ class Regexp::Expression::Anchor::Base < Regexp::Expression::Base
387
+ def match_length; end
388
+ end
389
+ class Regexp::Expression::Anchor::BeginningOfLine < Regexp::Expression::Anchor::Base
390
+ end
391
+ class Regexp::Expression::Anchor::EndOfLine < Regexp::Expression::Anchor::Base
392
+ end
393
+ class Regexp::Expression::Anchor::BeginningOfString < Regexp::Expression::Anchor::Base
394
+ end
395
+ class Regexp::Expression::Anchor::EndOfString < Regexp::Expression::Anchor::Base
396
+ end
397
+ class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < Regexp::Expression::Anchor::Base
398
+ end
399
+ class Regexp::Expression::Anchor::WordBoundary < Regexp::Expression::Anchor::Base
400
+ end
401
+ class Regexp::Expression::Anchor::NonWordBoundary < Regexp::Expression::Anchor::Base
402
+ end
403
+ class Regexp::Expression::Anchor::MatchStart < Regexp::Expression::Anchor::Base
404
+ end
405
+ module Regexp::Expression::Backreference
406
+ end
407
+ class Regexp::Expression::Backreference::Base < Regexp::Expression::Base
408
+ def match_length; end
409
+ def referenced_expression; end
410
+ def referenced_expression=(arg0); end
411
+ end
412
+ class Regexp::Expression::Backreference::Number < Regexp::Expression::Backreference::Base
413
+ def initialize(token, options = nil); end
414
+ def number; end
415
+ def reference; end
416
+ end
417
+ class Regexp::Expression::Backreference::Name < Regexp::Expression::Backreference::Base
418
+ def initialize(token, options = nil); end
419
+ def name; end
420
+ def reference; end
421
+ end
422
+ class Regexp::Expression::Backreference::NumberRelative < Regexp::Expression::Backreference::Number
423
+ def effective_number; end
424
+ def effective_number=(arg0); end
425
+ def reference; end
426
+ end
427
+ class Regexp::Expression::Backreference::NumberCall < Regexp::Expression::Backreference::Number
428
+ end
429
+ class Regexp::Expression::Backreference::NameCall < Regexp::Expression::Backreference::Name
430
+ end
431
+ class Regexp::Expression::Backreference::NumberCallRelative < Regexp::Expression::Backreference::NumberRelative
432
+ end
433
+ class Regexp::Expression::Backreference::NumberRecursionLevel < Regexp::Expression::Backreference::Number
434
+ def initialize(token, options = nil); end
435
+ def recursion_level; end
436
+ end
437
+ class Regexp::Expression::Backreference::NameRecursionLevel < Regexp::Expression::Backreference::Name
438
+ def initialize(token, options = nil); end
439
+ def recursion_level; end
440
+ end
441
+ module Regexp::Expression::Conditional
442
+ end
443
+ class Regexp::Expression::Conditional::TooManyBranches < StandardError
444
+ def initialize; end
445
+ end
446
+ class Regexp::Expression::Conditional::Condition < Regexp::Expression::Base
447
+ def match_length; end
448
+ def reference; end
449
+ def referenced_expression; end
450
+ def referenced_expression=(arg0); end
451
+ end
452
+ class Regexp::Expression::Conditional::Branch < Regexp::Expression::Sequence
453
+ end
454
+ class Regexp::Expression::Conditional::Expression < Regexp::Expression::Subexpression
455
+ def <<(exp); end
456
+ def add_sequence(active_opts = nil); end
457
+ def branch(active_opts = nil); end
458
+ def branches; end
459
+ def condition; end
460
+ def condition=(exp); end
461
+ def match_length; end
462
+ def reference; end
463
+ def referenced_expression; end
464
+ def referenced_expression=(arg0); end
465
+ def to_s(format = nil); end
466
+ end
467
+ module Regexp::Expression::EscapeSequence
468
+ end
469
+ class Regexp::Expression::EscapeSequence::Base < Regexp::Expression::Base
470
+ def char; end
471
+ def codepoint; end
472
+ def match_length; end
473
+ end
474
+ class Regexp::Expression::EscapeSequence::Literal < Regexp::Expression::EscapeSequence::Base
475
+ def char; end
476
+ end
477
+ class Regexp::Expression::EscapeSequence::AsciiEscape < Regexp::Expression::EscapeSequence::Base
478
+ end
479
+ class Regexp::Expression::EscapeSequence::Backspace < Regexp::Expression::EscapeSequence::Base
480
+ end
481
+ class Regexp::Expression::EscapeSequence::Bell < Regexp::Expression::EscapeSequence::Base
482
+ end
483
+ class Regexp::Expression::EscapeSequence::FormFeed < Regexp::Expression::EscapeSequence::Base
484
+ end
485
+ class Regexp::Expression::EscapeSequence::Newline < Regexp::Expression::EscapeSequence::Base
486
+ end
487
+ class Regexp::Expression::EscapeSequence::Return < Regexp::Expression::EscapeSequence::Base
488
+ end
489
+ class Regexp::Expression::EscapeSequence::Tab < Regexp::Expression::EscapeSequence::Base
490
+ end
491
+ class Regexp::Expression::EscapeSequence::VerticalTab < Regexp::Expression::EscapeSequence::Base
492
+ end
493
+ class Regexp::Expression::EscapeSequence::Hex < Regexp::Expression::EscapeSequence::Base
494
+ end
495
+ class Regexp::Expression::EscapeSequence::Codepoint < Regexp::Expression::EscapeSequence::Base
496
+ end
497
+ class Regexp::Expression::EscapeSequence::CodepointList < Regexp::Expression::EscapeSequence::Base
498
+ def char; end
499
+ def chars; end
500
+ def codepoint; end
501
+ def codepoints; end
502
+ def match_length; end
503
+ end
504
+ class Regexp::Expression::EscapeSequence::Octal < Regexp::Expression::EscapeSequence::Base
505
+ def char; end
506
+ end
507
+ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < Regexp::Expression::EscapeSequence::Base
508
+ def char; end
509
+ def control_sequence_to_s(control_sequence); end
510
+ def meta_char_to_codepoint(meta_char); end
511
+ end
512
+ class Regexp::Expression::EscapeSequence::Control < Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
513
+ def codepoint; end
514
+ end
515
+ class Regexp::Expression::EscapeSequence::Meta < Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
516
+ def codepoint; end
517
+ end
518
+ class Regexp::Expression::EscapeSequence::MetaControl < Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
519
+ def codepoint; end
520
+ end
521
+ class Regexp::Expression::FreeSpace < Regexp::Expression::Base
522
+ def match_length; end
523
+ def quantify(token, text, min = nil, max = nil, mode = nil); end
524
+ end
525
+ class Regexp::Expression::Comment < Regexp::Expression::FreeSpace
526
+ end
527
+ class Regexp::Expression::WhiteSpace < Regexp::Expression::FreeSpace
528
+ def merge(exp); end
529
+ end
530
+ module Regexp::Expression::Group
531
+ end
532
+ class Regexp::Expression::Group::Base < Regexp::Expression::Subexpression
533
+ def capturing?; end
534
+ def comment?; end
535
+ def to_s(format = nil); end
536
+ end
537
+ class Regexp::Expression::Group::Atomic < Regexp::Expression::Group::Base
538
+ end
539
+ class Regexp::Expression::Group::Passive < Regexp::Expression::Group::Base
540
+ end
541
+ class Regexp::Expression::Group::Absence < Regexp::Expression::Group::Base
542
+ def match_length; end
543
+ end
544
+ class Regexp::Expression::Group::Options < Regexp::Expression::Group::Base
545
+ def option_changes; end
546
+ def option_changes=(arg0); end
547
+ end
548
+ class Regexp::Expression::Group::Capture < Regexp::Expression::Group::Base
549
+ def capturing?; end
550
+ def identifier; end
551
+ def number; end
552
+ def number=(arg0); end
553
+ def number_at_level; end
554
+ def number_at_level=(arg0); end
555
+ end
556
+ class Regexp::Expression::Group::Named < Regexp::Expression::Group::Capture
557
+ def identifier; end
558
+ def initialize(token, options = nil); end
559
+ def initialize_clone(orig); end
560
+ def name; end
561
+ end
562
+ class Regexp::Expression::Group::Comment < Regexp::Expression::Group::Base
563
+ def comment?; end
564
+ def to_s(_format = nil); end
565
+ end
566
+ module Regexp::Expression::Assertion
567
+ end
568
+ class Regexp::Expression::Assertion::Base < Regexp::Expression::Group::Base
569
+ def match_length; end
570
+ end
571
+ class Regexp::Expression::Assertion::Lookahead < Regexp::Expression::Assertion::Base
572
+ end
573
+ class Regexp::Expression::Assertion::NegativeLookahead < Regexp::Expression::Assertion::Base
574
+ end
575
+ class Regexp::Expression::Assertion::Lookbehind < Regexp::Expression::Assertion::Base
576
+ end
577
+ class Regexp::Expression::Assertion::NegativeLookbehind < Regexp::Expression::Assertion::Base
578
+ end
579
+ module Regexp::Expression::Keep
580
+ end
581
+ class Regexp::Expression::Keep::Mark < Regexp::Expression::Base
582
+ def match_length; end
583
+ end
584
+ class Regexp::Expression::Literal < Regexp::Expression::Base
585
+ def match_length; end
586
+ end
587
+ class Regexp::Expression::PosixClass < Regexp::Expression::Base
588
+ def match_length; end
589
+ def name; end
590
+ def negative?; end
591
+ end
592
+ module Regexp::Expression::UnicodeProperty
593
+ end
594
+ class Regexp::Expression::UnicodeProperty::Base < Regexp::Expression::Base
595
+ def match_length; end
596
+ def name; end
597
+ def negative?; end
598
+ def shortcut; end
599
+ end
600
+ class Regexp::Expression::UnicodeProperty::Alnum < Regexp::Expression::UnicodeProperty::Base
601
+ end
602
+ class Regexp::Expression::UnicodeProperty::Alpha < Regexp::Expression::UnicodeProperty::Base
603
+ end
604
+ class Regexp::Expression::UnicodeProperty::Ascii < Regexp::Expression::UnicodeProperty::Base
605
+ end
606
+ class Regexp::Expression::UnicodeProperty::Blank < Regexp::Expression::UnicodeProperty::Base
607
+ end
608
+ class Regexp::Expression::UnicodeProperty::Cntrl < Regexp::Expression::UnicodeProperty::Base
609
+ end
610
+ class Regexp::Expression::UnicodeProperty::Digit < Regexp::Expression::UnicodeProperty::Base
611
+ end
612
+ class Regexp::Expression::UnicodeProperty::Graph < Regexp::Expression::UnicodeProperty::Base
613
+ end
614
+ class Regexp::Expression::UnicodeProperty::Lower < Regexp::Expression::UnicodeProperty::Base
615
+ end
616
+ class Regexp::Expression::UnicodeProperty::Print < Regexp::Expression::UnicodeProperty::Base
617
+ end
618
+ class Regexp::Expression::UnicodeProperty::Punct < Regexp::Expression::UnicodeProperty::Base
619
+ end
620
+ class Regexp::Expression::UnicodeProperty::Space < Regexp::Expression::UnicodeProperty::Base
621
+ end
622
+ class Regexp::Expression::UnicodeProperty::Upper < Regexp::Expression::UnicodeProperty::Base
623
+ end
624
+ class Regexp::Expression::UnicodeProperty::Word < Regexp::Expression::UnicodeProperty::Base
625
+ end
626
+ class Regexp::Expression::UnicodeProperty::Xdigit < Regexp::Expression::UnicodeProperty::Base
627
+ end
628
+ class Regexp::Expression::UnicodeProperty::XPosixPunct < Regexp::Expression::UnicodeProperty::Base
629
+ end
630
+ class Regexp::Expression::UnicodeProperty::Newline < Regexp::Expression::UnicodeProperty::Base
631
+ end
632
+ class Regexp::Expression::UnicodeProperty::Any < Regexp::Expression::UnicodeProperty::Base
633
+ end
634
+ class Regexp::Expression::UnicodeProperty::Assigned < Regexp::Expression::UnicodeProperty::Base
635
+ end
636
+ module Regexp::Expression::UnicodeProperty::Letter
637
+ end
638
+ class Regexp::Expression::UnicodeProperty::Letter::Base < Regexp::Expression::UnicodeProperty::Base
639
+ end
640
+ class Regexp::Expression::UnicodeProperty::Letter::Any < Regexp::Expression::UnicodeProperty::Letter::Base
641
+ end
642
+ class Regexp::Expression::UnicodeProperty::Letter::Cased < Regexp::Expression::UnicodeProperty::Letter::Base
643
+ end
644
+ class Regexp::Expression::UnicodeProperty::Letter::Uppercase < Regexp::Expression::UnicodeProperty::Letter::Base
645
+ end
646
+ class Regexp::Expression::UnicodeProperty::Letter::Lowercase < Regexp::Expression::UnicodeProperty::Letter::Base
647
+ end
648
+ class Regexp::Expression::UnicodeProperty::Letter::Titlecase < Regexp::Expression::UnicodeProperty::Letter::Base
649
+ end
650
+ class Regexp::Expression::UnicodeProperty::Letter::Modifier < Regexp::Expression::UnicodeProperty::Letter::Base
651
+ end
652
+ class Regexp::Expression::UnicodeProperty::Letter::Other < Regexp::Expression::UnicodeProperty::Letter::Base
653
+ end
654
+ module Regexp::Expression::UnicodeProperty::Mark
655
+ end
656
+ class Regexp::Expression::UnicodeProperty::Mark::Base < Regexp::Expression::UnicodeProperty::Base
657
+ end
658
+ class Regexp::Expression::UnicodeProperty::Mark::Any < Regexp::Expression::UnicodeProperty::Mark::Base
659
+ end
660
+ class Regexp::Expression::UnicodeProperty::Mark::Combining < Regexp::Expression::UnicodeProperty::Mark::Base
661
+ end
662
+ class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < Regexp::Expression::UnicodeProperty::Mark::Base
663
+ end
664
+ class Regexp::Expression::UnicodeProperty::Mark::Spacing < Regexp::Expression::UnicodeProperty::Mark::Base
665
+ end
666
+ class Regexp::Expression::UnicodeProperty::Mark::Enclosing < Regexp::Expression::UnicodeProperty::Mark::Base
667
+ end
668
+ module Regexp::Expression::UnicodeProperty::Number
669
+ end
670
+ class Regexp::Expression::UnicodeProperty::Number::Base < Regexp::Expression::UnicodeProperty::Base
671
+ end
672
+ class Regexp::Expression::UnicodeProperty::Number::Any < Regexp::Expression::UnicodeProperty::Number::Base
673
+ end
674
+ class Regexp::Expression::UnicodeProperty::Number::Decimal < Regexp::Expression::UnicodeProperty::Number::Base
675
+ end
676
+ class Regexp::Expression::UnicodeProperty::Number::Letter < Regexp::Expression::UnicodeProperty::Number::Base
677
+ end
678
+ class Regexp::Expression::UnicodeProperty::Number::Other < Regexp::Expression::UnicodeProperty::Number::Base
679
+ end
680
+ module Regexp::Expression::UnicodeProperty::Punctuation
681
+ end
682
+ class Regexp::Expression::UnicodeProperty::Punctuation::Base < Regexp::Expression::UnicodeProperty::Base
683
+ end
684
+ class Regexp::Expression::UnicodeProperty::Punctuation::Any < Regexp::Expression::UnicodeProperty::Punctuation::Base
685
+ end
686
+ class Regexp::Expression::UnicodeProperty::Punctuation::Connector < Regexp::Expression::UnicodeProperty::Punctuation::Base
687
+ end
688
+ class Regexp::Expression::UnicodeProperty::Punctuation::Dash < Regexp::Expression::UnicodeProperty::Punctuation::Base
689
+ end
690
+ class Regexp::Expression::UnicodeProperty::Punctuation::Open < Regexp::Expression::UnicodeProperty::Punctuation::Base
691
+ end
692
+ class Regexp::Expression::UnicodeProperty::Punctuation::Close < Regexp::Expression::UnicodeProperty::Punctuation::Base
693
+ end
694
+ class Regexp::Expression::UnicodeProperty::Punctuation::Initial < Regexp::Expression::UnicodeProperty::Punctuation::Base
695
+ end
696
+ class Regexp::Expression::UnicodeProperty::Punctuation::Final < Regexp::Expression::UnicodeProperty::Punctuation::Base
697
+ end
698
+ class Regexp::Expression::UnicodeProperty::Punctuation::Other < Regexp::Expression::UnicodeProperty::Punctuation::Base
699
+ end
700
+ module Regexp::Expression::UnicodeProperty::Separator
701
+ end
702
+ class Regexp::Expression::UnicodeProperty::Separator::Base < Regexp::Expression::UnicodeProperty::Base
703
+ end
704
+ class Regexp::Expression::UnicodeProperty::Separator::Any < Regexp::Expression::UnicodeProperty::Separator::Base
705
+ end
706
+ class Regexp::Expression::UnicodeProperty::Separator::Space < Regexp::Expression::UnicodeProperty::Separator::Base
707
+ end
708
+ class Regexp::Expression::UnicodeProperty::Separator::Line < Regexp::Expression::UnicodeProperty::Separator::Base
709
+ end
710
+ class Regexp::Expression::UnicodeProperty::Separator::Paragraph < Regexp::Expression::UnicodeProperty::Separator::Base
711
+ end
712
+ module Regexp::Expression::UnicodeProperty::Symbol
713
+ end
714
+ class Regexp::Expression::UnicodeProperty::Symbol::Base < Regexp::Expression::UnicodeProperty::Base
715
+ end
716
+ class Regexp::Expression::UnicodeProperty::Symbol::Any < Regexp::Expression::UnicodeProperty::Symbol::Base
717
+ end
718
+ class Regexp::Expression::UnicodeProperty::Symbol::Math < Regexp::Expression::UnicodeProperty::Symbol::Base
719
+ end
720
+ class Regexp::Expression::UnicodeProperty::Symbol::Currency < Regexp::Expression::UnicodeProperty::Symbol::Base
721
+ end
722
+ class Regexp::Expression::UnicodeProperty::Symbol::Modifier < Regexp::Expression::UnicodeProperty::Symbol::Base
723
+ end
724
+ class Regexp::Expression::UnicodeProperty::Symbol::Other < Regexp::Expression::UnicodeProperty::Symbol::Base
725
+ end
726
+ module Regexp::Expression::UnicodeProperty::Codepoint
727
+ end
728
+ class Regexp::Expression::UnicodeProperty::Codepoint::Base < Regexp::Expression::UnicodeProperty::Base
729
+ end
730
+ class Regexp::Expression::UnicodeProperty::Codepoint::Any < Regexp::Expression::UnicodeProperty::Codepoint::Base
731
+ end
732
+ class Regexp::Expression::UnicodeProperty::Codepoint::Control < Regexp::Expression::UnicodeProperty::Codepoint::Base
733
+ end
734
+ class Regexp::Expression::UnicodeProperty::Codepoint::Format < Regexp::Expression::UnicodeProperty::Codepoint::Base
735
+ end
736
+ class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < Regexp::Expression::UnicodeProperty::Codepoint::Base
737
+ end
738
+ class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < Regexp::Expression::UnicodeProperty::Codepoint::Base
739
+ end
740
+ class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < Regexp::Expression::UnicodeProperty::Codepoint::Base
741
+ end
742
+ class Regexp::Expression::UnicodeProperty::Age < Regexp::Expression::UnicodeProperty::Base
743
+ end
744
+ class Regexp::Expression::UnicodeProperty::Derived < Regexp::Expression::UnicodeProperty::Base
745
+ end
746
+ class Regexp::Expression::UnicodeProperty::Emoji < Regexp::Expression::UnicodeProperty::Base
747
+ end
748
+ class Regexp::Expression::UnicodeProperty::Script < Regexp::Expression::UnicodeProperty::Base
749
+ end
750
+ class Regexp::Expression::UnicodeProperty::Block < Regexp::Expression::UnicodeProperty::Base
751
+ end
752
+ class Regexp::Expression::Root < Regexp::Expression::Subexpression
753
+ def initialize(*args); end
754
+ def self.build(options = nil); end
755
+ def self.build_token; end
756
+ end
757
+ class Regexp::Expression::CharacterSet < Regexp::Expression::Subexpression
758
+ def close; end
759
+ def closed; end
760
+ def closed=(arg0); end
761
+ def closed?; end
762
+ def initialize(token, options = nil); end
763
+ def match_length; end
764
+ def negate; end
765
+ def negated?; end
766
+ def negative; end
767
+ def negative=(arg0); end
768
+ def negative?; end
769
+ def to_s(format = nil); end
770
+ end
771
+ class Regexp::Expression::CharacterSet::IntersectedSequence < Regexp::Expression::Sequence
772
+ def match_length; end
773
+ end
774
+ class Regexp::Expression::CharacterSet::Intersection < Regexp::Expression::SequenceOperation
775
+ def match_length; end
776
+ end
777
+ class Regexp::Expression::CharacterSet::Range < Regexp::Expression::Subexpression
778
+ def <<(exp); end
779
+ def complete?; end
780
+ def match_length; end
781
+ def starts_at; end
782
+ def to_s(_format = nil); end
783
+ def ts; end
784
+ end
785
+ module Regexp::Expression::CharacterType
786
+ end
787
+ class Regexp::Expression::CharacterType::Base < Regexp::Expression::Base
788
+ def match_length; end
789
+ end
790
+ class Regexp::Expression::CharacterType::Any < Regexp::Expression::CharacterType::Base
791
+ end
792
+ class Regexp::Expression::CharacterType::Digit < Regexp::Expression::CharacterType::Base
793
+ end
794
+ class Regexp::Expression::CharacterType::NonDigit < Regexp::Expression::CharacterType::Base
795
+ end
796
+ class Regexp::Expression::CharacterType::Hex < Regexp::Expression::CharacterType::Base
797
+ end
798
+ class Regexp::Expression::CharacterType::NonHex < Regexp::Expression::CharacterType::Base
799
+ end
800
+ class Regexp::Expression::CharacterType::Word < Regexp::Expression::CharacterType::Base
801
+ end
802
+ class Regexp::Expression::CharacterType::NonWord < Regexp::Expression::CharacterType::Base
803
+ end
804
+ class Regexp::Expression::CharacterType::Space < Regexp::Expression::CharacterType::Base
805
+ end
806
+ class Regexp::Expression::CharacterType::NonSpace < Regexp::Expression::CharacterType::Base
807
+ end
808
+ class Regexp::Expression::CharacterType::Linebreak < Regexp::Expression::CharacterType::Base
809
+ end
810
+ class Regexp::Expression::CharacterType::ExtendedGrapheme < Regexp::Expression::CharacterType::Base
811
+ end
812
+ class Regexp::Expression::Base
813
+ def =~(string, offset = nil); end
814
+ def a?; end
815
+ def ascii_classes?; end
816
+ def attributes; end
817
+ def case_insensitive?; end
818
+ def coded_offset; end
819
+ def conditional_level; end
820
+ def conditional_level=(arg0); end
821
+ def d?; end
822
+ def default_classes?; end
823
+ def extended?; end
824
+ def free_spacing?; end
825
+ def full_length; end
826
+ def greedy?; end
827
+ def i?; end
828
+ def ignore_case?; end
829
+ def initialize(token, options = nil); end
830
+ def initialize_clone(orig); end
831
+ def is?(test_token, test_type = nil); end
832
+ def lazy?; end
833
+ def level; end
834
+ def level=(arg0); end
835
+ def m?; end
836
+ def match(string, offset = nil); end
837
+ def match?(string); end
838
+ def matches?(string); end
839
+ def multiline?; end
840
+ def nesting_level; end
841
+ def nesting_level=(arg0); end
842
+ def offset; end
843
+ def one_of?(scope, top = nil); end
844
+ def options; end
845
+ def options=(arg0); end
846
+ def possessive?; end
847
+ def quantified?; end
848
+ def quantifier; end
849
+ def quantifier=(arg0); end
850
+ def quantifier_affix(expression_format); end
851
+ def quantify(token, text, min = nil, max = nil, mode = nil); end
852
+ def quantity; end
853
+ def reluctant?; end
854
+ def repetitions; end
855
+ def set_level; end
856
+ def set_level=(arg0); end
857
+ def starts_at; end
858
+ def strfre(format = nil, indent_offset = nil, index = nil); end
859
+ def strfregexp(format = nil, indent_offset = nil, index = nil); end
860
+ def terminal?; end
861
+ def text; end
862
+ def text=(arg0); end
863
+ def to_h; end
864
+ def to_re(format = nil); end
865
+ def to_s(format = nil); end
866
+ def token; end
867
+ def token=(arg0); end
868
+ def ts; end
869
+ def ts=(arg0); end
870
+ def type; end
871
+ def type=(arg0); end
872
+ def type?(test_type); end
873
+ def u?; end
874
+ def unicode_classes?; end
875
+ def unquantified_clone; end
876
+ def x?; end
877
+ end
878
+ class Regexp::MatchLength
879
+ def base_max; end
880
+ def base_max=(arg0); end
881
+ def base_min; end
882
+ def base_min=(arg0); end
883
+ def each(opts = nil); end
884
+ def endless_each(&block); end
885
+ def exp_class; end
886
+ def exp_class=(arg0); end
887
+ def fixed?; end
888
+ def include?(length); end
889
+ def initialize(exp, opts = nil); end
890
+ def inspect; end
891
+ def max; end
892
+ def max_rep; end
893
+ def max_rep=(arg0); end
894
+ def min; end
895
+ def min_rep; end
896
+ def min_rep=(arg0); end
897
+ def minmax; end
898
+ def reify; end
899
+ def reify=(arg0); end
900
+ def self.of(obj); end
901
+ def test_regexp; end
902
+ def to_re; end
903
+ include Enumerable
904
+ end
905
+ class Regexp::Parser::ParserError < StandardError
906
+ end
907
+ class Regexp::Parser::UnknownTokenTypeError < Regexp::Parser::ParserError
908
+ def initialize(type, token); end
909
+ end
910
+ class Regexp::Parser::UnknownTokenError < Regexp::Parser::ParserError
911
+ def initialize(type, token); end
912
+ end