muina 0.2.8 → 0.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (161) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE +25 -0
  3. data/README.md +0 -35
  4. data/lib/muina/maybe/none.rb +57 -0
  5. data/lib/muina/maybe/some.rb +61 -0
  6. data/lib/muina/maybe.rb +13 -0
  7. data/lib/muina/version.rb +1 -2
  8. data/lib/muina.rb +0 -32
  9. metadata +24 -228
  10. data/.github/workflows/main.yml +0 -16
  11. data/.gitignore +0 -5
  12. data/.mutant.yml +0 -38
  13. data/.rspec +0 -4
  14. data/.rubocop.yml +0 -181
  15. data/.ruby-version +0 -1
  16. data/.simplecov +0 -14
  17. data/CHANGELOG.md +0 -38
  18. data/Gemfile +0 -34
  19. data/Gemfile.lock +0 -265
  20. data/Guardfile +0 -24
  21. data/Rakefile +0 -13
  22. data/SECURITY.md +0 -14
  23. data/bin/bundle +0 -114
  24. data/bin/console +0 -15
  25. data/bin/flay +0 -29
  26. data/bin/flog +0 -29
  27. data/bin/guard +0 -29
  28. data/bin/irb +0 -29
  29. data/bin/lefthook +0 -29
  30. data/bin/mutant +0 -29
  31. data/bin/parlour +0 -29
  32. data/bin/rake +0 -29
  33. data/bin/rspec +0 -29
  34. data/bin/rubocop +0 -29
  35. data/bin/setup +0 -8
  36. data/bin/srb +0 -29
  37. data/bin/srb-rbi +0 -29
  38. data/bin/tapioca +0 -29
  39. data/exe/muina +0 -11
  40. data/lefthook.yml +0 -39
  41. data/lib/muina/action/params_factory.rb +0 -17
  42. data/lib/muina/action/step/command.rb +0 -33
  43. data/lib/muina/action/step/failure.rb +0 -18
  44. data/lib/muina/action/step/query.rb +0 -35
  45. data/lib/muina/action/step/result.rb +0 -56
  46. data/lib/muina/action/step.rb +0 -13
  47. data/lib/muina/action.rb +0 -73
  48. data/lib/muina/any.rb +0 -7
  49. data/lib/muina/classes.rb +0 -7
  50. data/lib/muina/deprecator.rb +0 -93
  51. data/lib/muina/entity.rb +0 -20
  52. data/lib/muina/module.rb +0 -6
  53. data/lib/muina/parameters.rb +0 -7
  54. data/lib/muina/params.rb +0 -19
  55. data/lib/muina/private_creation.rb +0 -12
  56. data/lib/muina/result/factory.rb +0 -37
  57. data/lib/muina/result/failure.rb +0 -31
  58. data/lib/muina/result/null.rb +0 -25
  59. data/lib/muina/result/success.rb +0 -31
  60. data/lib/muina/result.rb +0 -17
  61. data/lib/muina/service.rb +0 -25
  62. data/lib/muina/symbol_hash.rb +0 -7
  63. data/lib/muina/unit.rb +0 -10
  64. data/lib/muina/untyped_array.rb +0 -7
  65. data/lib/muina/untyped_hash.rb +0 -7
  66. data/lib/muina/value.rb +0 -24
  67. data/muina.gemspec +0 -35
  68. data/rbi/muina.rbi +0 -311
  69. data/sorbet/config +0 -2
  70. data/sorbet/rbi/gems/actionpack@6.1.4.rbi +0 -5045
  71. data/sorbet/rbi/gems/actionview@6.1.4.rbi +0 -2416
  72. data/sorbet/rbi/gems/activesupport@6.1.4.rbi +0 -3778
  73. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  74. data/sorbet/rbi/gems/awesome_print@1.9.2.rbi +0 -322
  75. data/sorbet/rbi/gems/builder@3.2.4.rbi +0 -8
  76. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -18
  77. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -8
  78. data/sorbet/rbi/gems/colorize@0.8.1.rbi +0 -39
  79. data/sorbet/rbi/gems/commander@4.6.0.rbi +0 -8
  80. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +0 -2403
  81. data/sorbet/rbi/gems/crass@1.0.6.rbi +0 -123
  82. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -185
  83. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  84. data/sorbet/rbi/gems/erubi@1.10.0.rbi +0 -36
  85. data/sorbet/rbi/gems/erubis@2.7.0.rbi +0 -8
  86. data/sorbet/rbi/gems/faker@2.18.0.rbi +0 -2469
  87. data/sorbet/rbi/gems/ffi@1.15.3.rbi +0 -8
  88. data/sorbet/rbi/gems/flay@2.12.1.rbi +0 -178
  89. data/sorbet/rbi/gems/flog@4.6.4.rbi +0 -70
  90. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  91. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -49
  92. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -233
  93. data/sorbet/rbi/gems/guard-rubocop@1.4.0.rbi +0 -66
  94. data/sorbet/rbi/gems/guard-shell@0.7.2.rbi +0 -69
  95. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -617
  96. data/sorbet/rbi/gems/highline@2.0.3.rbi +0 -8
  97. data/sorbet/rbi/gems/i18n@1.8.10.rbi +0 -616
  98. data/sorbet/rbi/gems/io-console@0.5.9.rbi +0 -8
  99. data/sorbet/rbi/gems/irb@1.3.6.rbi +0 -452
  100. data/sorbet/rbi/gems/lefthook@0.7.6.rbi +0 -8
  101. data/sorbet/rbi/gems/listen@3.6.0.rbi +0 -476
  102. data/sorbet/rbi/gems/loofah@2.10.0.rbi +0 -223
  103. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -431
  104. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -8
  105. data/sorbet/rbi/gems/minitest@5.14.4.rbi +0 -344
  106. data/sorbet/rbi/gems/mutant-license@0.1.1.1.4043027289354708743625974235631451632228.0.rbi +0 -8
  107. data/sorbet/rbi/gems/mutant-rspec@0.10.32.rbi +0 -8
  108. data/sorbet/rbi/gems/mutant@0.10.32.rbi +0 -4154
  109. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -88
  110. data/sorbet/rbi/gems/nokogiri@1.11.7.rbi +0 -1422
  111. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -331
  112. data/sorbet/rbi/gems/parallel@1.20.1.rbi +0 -113
  113. data/sorbet/rbi/gems/parlour@6.0.1.rbi +0 -1726
  114. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1683
  115. data/sorbet/rbi/gems/path_expander@1.1.0.rbi +0 -24
  116. data/sorbet/rbi/gems/polyfill@1.9.0.rbi +0 -393
  117. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -8
  118. data/sorbet/rbi/gems/racc@1.5.2.rbi +0 -47
  119. data/sorbet/rbi/gems/rack-test@1.1.0.rbi +0 -272
  120. data/sorbet/rbi/gems/rack@2.2.3.rbi +0 -1618
  121. data/sorbet/rbi/gems/rails-dom-testing@2.0.3.rbi +0 -92
  122. data/sorbet/rbi/gems/rails-html-sanitizer@1.3.0.rbi +0 -183
  123. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  124. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -808
  125. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  126. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  127. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  128. data/sorbet/rbi/gems/reline@0.2.6.rbi +0 -662
  129. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  130. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2509
  131. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  132. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  133. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  134. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  135. data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi +0 -2194
  136. data/sorbet/rbi/gems/rubocop-performance@1.11.4.rbi +0 -899
  137. data/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi +0 -118
  138. data/sorbet/rbi/gems/rubocop-rspec@2.4.0.rbi +0 -1805
  139. data/sorbet/rbi/gems/rubocop-sorbet@0.6.2.rbi +0 -288
  140. data/sorbet/rbi/gems/rubocop@1.18.4.rbi +0 -13197
  141. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  142. data/sorbet/rbi/gems/ruby_parser@3.16.0.rbi +0 -4528
  143. data/sorbet/rbi/gems/safe_type@1.1.1.rbi +0 -157
  144. data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi +0 -359
  145. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -28
  146. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  147. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  148. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  149. data/sorbet/rbi/gems/sorbet-coerce@0.5.0.rbi +0 -42
  150. data/sorbet/rbi/gems/sorbet-rails@0.7.4.rbi +0 -8
  151. data/sorbet/rbi/gems/sorbet-struct-comparable@1.1.0.rbi +0 -17
  152. data/sorbet/rbi/gems/spoom@1.1.1.rbi +0 -1193
  153. data/sorbet/rbi/gems/tapioca@0.4.23.rbi +0 -1826
  154. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -838
  155. data/sorbet/rbi/gems/tzinfo@2.0.4.rbi +0 -856
  156. data/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi +0 -26
  157. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -2037
  158. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +0 -173
  159. data/sorbet/rbi/todo.rbi +0 -8
  160. data/sorbet/rbi/typed_params.rbi +0 -7
  161. data/sorbet/tapioca/require.rb +0 -16
@@ -1,3778 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `activesupport` gem.
3
- # Please instead update this file by running `bin/tapioca sync`.
4
-
5
- # typed: false
6
-
7
- module ActiveSupport
8
- extend ::ActiveSupport::LazyLoadHooks
9
- extend ::ActiveSupport::Autoload
10
-
11
- def parse_json_times; end
12
- def parse_json_times=(val); end
13
- def test_order; end
14
- def test_order=(val); end
15
-
16
- class << self
17
- def eager_load!; end
18
- def escape_html_entities_in_json(*args, &block); end
19
- def escape_html_entities_in_json=(arg); end
20
- def gem_version; end
21
- def json_encoder(*args, &block); end
22
- def json_encoder=(arg); end
23
- def parse_json_times; end
24
- def parse_json_times=(val); end
25
- def test_order; end
26
- def test_order=(val); end
27
- def time_precision(*args, &block); end
28
- def time_precision=(arg); end
29
- def to_time_preserves_timezone; end
30
- def to_time_preserves_timezone=(value); end
31
- def use_standard_json_time_format(*args, &block); end
32
- def use_standard_json_time_format=(arg); end
33
- def utc_to_local_returns_utc_offset_times; end
34
- def utc_to_local_returns_utc_offset_times=(value); end
35
- def version; end
36
- end
37
- end
38
-
39
- module ActiveSupport::ActionableError
40
- extend ::ActiveSupport::Concern
41
-
42
- mixes_in_class_methods ::ActiveSupport::ActionableError::ClassMethods
43
-
44
- class << self
45
- def actions(error); end
46
- def dispatch(error, name); end
47
- end
48
- end
49
-
50
- module ActiveSupport::ActionableError::ClassMethods
51
- def action(name, &block); end
52
- end
53
-
54
- class ActiveSupport::ActionableError::NonActionable < ::StandardError; end
55
-
56
- class ActiveSupport::ArrayInquirer < ::Array
57
- def any?(*candidates); end
58
-
59
- private
60
-
61
- def method_missing(name, *args); end
62
- def respond_to_missing?(name, include_private = T.unsafe(nil)); end
63
- end
64
-
65
- module ActiveSupport::Autoload
66
- def autoload(const_name, path = T.unsafe(nil)); end
67
- def autoload_at(path); end
68
- def autoload_under(path); end
69
- def autoloads; end
70
- def eager_autoload; end
71
- def eager_load!; end
72
-
73
- class << self
74
- def extended(base); end
75
- end
76
- end
77
-
78
- class ActiveSupport::BacktraceCleaner
79
- def initialize; end
80
-
81
- def add_filter(&block); end
82
- def add_silencer(&block); end
83
- def clean(backtrace, kind = T.unsafe(nil)); end
84
- def filter(backtrace, kind = T.unsafe(nil)); end
85
- def remove_filters!; end
86
- def remove_silencers!; end
87
-
88
- private
89
-
90
- def add_gem_filter; end
91
- def add_gem_silencer; end
92
- def add_stdlib_silencer; end
93
- def filter_backtrace(backtrace); end
94
- def noise(backtrace); end
95
- def silence(backtrace); end
96
- end
97
-
98
- ActiveSupport::BacktraceCleaner::FORMATTED_GEMS_PATTERN = T.let(T.unsafe(nil), Regexp)
99
-
100
- module ActiveSupport::Benchmarkable
101
- def benchmark(message = T.unsafe(nil), options = T.unsafe(nil)); end
102
- end
103
-
104
- module ActiveSupport::BigDecimalWithDefaultFormat
105
- def to_s(format = T.unsafe(nil)); end
106
- end
107
-
108
- module ActiveSupport::Cache
109
- class << self
110
- def expand_cache_key(key, namespace = T.unsafe(nil)); end
111
- def lookup_store(store = T.unsafe(nil), *parameters); end
112
-
113
- private
114
-
115
- def retrieve_cache_key(key); end
116
- def retrieve_store_class(store); end
117
- end
118
- end
119
-
120
- class ActiveSupport::Cache::Entry
121
- def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_arg5); end
122
-
123
- def bytesize; end
124
- def dup_value!; end
125
- def expired?; end
126
- def expires_at; end
127
- def expires_at=(value); end
128
- def mismatched?(version); end
129
- def value; end
130
- def version; end
131
-
132
- private
133
-
134
- def compress!(compress_threshold); end
135
- def compressed?; end
136
- def uncompress(value); end
137
- end
138
-
139
- ActiveSupport::Cache::Entry::DEFAULT_COMPRESS_LIMIT = T.let(T.unsafe(nil), Integer)
140
-
141
- class ActiveSupport::Cache::FileStore < ::ActiveSupport::Cache::Store
142
- include ::ActiveSupport::Cache::Strategy::LocalCache
143
-
144
- def initialize(cache_path, **options); end
145
-
146
- def cache_path; end
147
-
148
- private
149
-
150
- def delete_empty_directories(dir); end
151
- def ensure_cache_path(path); end
152
- def file_path_key(path); end
153
- def lock_file(file_name, &block); end
154
- def modify_value(name, amount, options); end
155
- def normalize_key(key, options); end
156
- def search_dir(dir, &callback); end
157
-
158
- class << self
159
- def supports_cache_versioning?; end
160
- end
161
- end
162
-
163
- ActiveSupport::Cache::FileStore::DIR_FORMATTER = T.let(T.unsafe(nil), String)
164
- ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE = T.let(T.unsafe(nil), Integer)
165
- ActiveSupport::Cache::FileStore::FILEPATH_MAX_SIZE = T.let(T.unsafe(nil), Integer)
166
- ActiveSupport::Cache::FileStore::GITKEEP_FILES = T.let(T.unsafe(nil), Array)
167
-
168
- class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
169
- def initialize(options = T.unsafe(nil)); end
170
-
171
- def cleanup(options = T.unsafe(nil)); end
172
- def clear(options = T.unsafe(nil)); end
173
- def decrement(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
174
- def delete_matched(matcher, options = T.unsafe(nil)); end
175
- def increment(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
176
- def inspect; end
177
- def prune(target_size, max_time = T.unsafe(nil)); end
178
- def pruning?; end
179
- def synchronize(&block); end
180
-
181
- private
182
-
183
- def cached_size(key, payload); end
184
- def delete_entry(key, **options); end
185
- def modify_value(name, amount, options); end
186
- def read_entry(key, **options); end
187
- def write_entry(key, entry, **options); end
188
-
189
- class << self
190
- def supports_cache_versioning?; end
191
- end
192
- end
193
-
194
- ActiveSupport::Cache::MemoryStore::DEFAULT_CODER = ActiveSupport::Cache::MemoryStore::DupCoder
195
-
196
- module ActiveSupport::Cache::MemoryStore::DupCoder
197
- class << self
198
- def dump(entry); end
199
- def load(entry); end
200
- end
201
- end
202
-
203
- ActiveSupport::Cache::MemoryStore::PER_ENTRY_OVERHEAD = T.let(T.unsafe(nil), Integer)
204
-
205
- module ActiveSupport::Cache::NullCoder
206
- class << self
207
- def dump(entry); end
208
- def load(payload); end
209
- end
210
- end
211
-
212
- class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
213
- include ::ActiveSupport::Cache::Strategy::LocalCache
214
-
215
- class << self
216
- def supports_cache_versioning?; end
217
- end
218
- end
219
-
220
- class ActiveSupport::Cache::Store
221
- def initialize(options = T.unsafe(nil)); end
222
-
223
- def cleanup(options = T.unsafe(nil)); end
224
- def clear(options = T.unsafe(nil)); end
225
- def decrement(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
226
- def delete(name, options = T.unsafe(nil)); end
227
- def delete_matched(matcher, options = T.unsafe(nil)); end
228
- def delete_multi(names, options = T.unsafe(nil)); end
229
- def exist?(name, options = T.unsafe(nil)); end
230
- def fetch(name, options = T.unsafe(nil), &block); end
231
- def fetch_multi(*names); end
232
- def increment(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
233
- def logger; end
234
- def logger=(val); end
235
- def mute; end
236
- def options; end
237
- def read(name, options = T.unsafe(nil)); end
238
- def read_multi(*names); end
239
- def silence; end
240
- def silence!; end
241
- def silence?; end
242
- def write(name, value, options = T.unsafe(nil)); end
243
- def write_multi(hash, options = T.unsafe(nil)); end
244
-
245
- private
246
-
247
- def delete_entry(key, **options); end
248
- def delete_multi_entries(entries, **options); end
249
- def deserialize_entry(payload); end
250
- def expanded_key(key); end
251
- def expanded_version(key); end
252
- def get_entry_value(entry, name, options); end
253
- def handle_expired_entry(entry, key, options); end
254
- def instrument(operation, key, options = T.unsafe(nil)); end
255
- def key_matcher(pattern, options); end
256
- def merged_options(call_options); end
257
- def namespace_key(key, options = T.unsafe(nil)); end
258
- def normalize_key(key, options = T.unsafe(nil)); end
259
- def normalize_version(key, options = T.unsafe(nil)); end
260
- def read_entry(key, **options); end
261
- def read_multi_entries(names, **options); end
262
- def save_block_result_to_cache(name, options); end
263
- def serialize_entry(entry); end
264
- def write_entry(key, entry, **options); end
265
- def write_multi_entries(hash, **options); end
266
-
267
- class << self
268
- def logger; end
269
- def logger=(val); end
270
-
271
- private
272
-
273
- def ensure_connection_pool_added!; end
274
- def retrieve_pool_options(options); end
275
- end
276
- end
277
-
278
- ActiveSupport::Cache::Store::DEFAULT_CODER = Marshal
279
- module ActiveSupport::Cache::Strategy; end
280
-
281
- module ActiveSupport::Cache::Strategy::LocalCache
282
- def cleanup(**options); end
283
- def clear(**options); end
284
- def decrement(name, amount = T.unsafe(nil), **options); end
285
- def delete_matched(matcher, options = T.unsafe(nil)); end
286
- def increment(name, amount = T.unsafe(nil), **options); end
287
- def middleware; end
288
- def with_local_cache; end
289
-
290
- private
291
-
292
- def bypass_local_cache; end
293
- def delete_entry(key, **options); end
294
- def local_cache; end
295
- def local_cache_key; end
296
- def read_entry(key, **options); end
297
- def read_multi_entries(keys, **options); end
298
- def use_temporary_local_cache(temporary_cache); end
299
- def write_cache_value(name, value, **options); end
300
- def write_entry(key, entry, **options); end
301
- end
302
-
303
- class ActiveSupport::Cache::Strategy::LocalCache::LocalCacheRegistry
304
- extend ::ActiveSupport::PerThreadRegistry
305
-
306
- def initialize; end
307
-
308
- def cache_for(local_cache_key); end
309
- def set_cache_for(local_cache_key, value); end
310
-
311
- class << self
312
- def cache_for(l); end
313
- def set_cache_for(l, v); end
314
- end
315
- end
316
-
317
- class ActiveSupport::Cache::Strategy::LocalCache::LocalStore < ::ActiveSupport::Cache::Store
318
- def initialize; end
319
-
320
- def clear(options = T.unsafe(nil)); end
321
- def delete_entry(key, **options); end
322
- def fetch_entry(key, options = T.unsafe(nil)); end
323
- def read_entry(key, **options); end
324
- def read_multi_entries(keys, **options); end
325
- def synchronize; end
326
- def write_entry(key, entry, **options); end
327
- end
328
-
329
- class ActiveSupport::Cache::Strategy::LocalCache::Middleware
330
- def initialize(name, local_cache_key); end
331
-
332
- def call(env); end
333
- def local_cache_key; end
334
- def name; end
335
- def new(app); end
336
- end
337
-
338
- ActiveSupport::Cache::UNIVERSAL_OPTIONS = T.let(T.unsafe(nil), Array)
339
-
340
- class ActiveSupport::CachingKeyGenerator
341
- def initialize(key_generator); end
342
-
343
- def generate_key(*args); end
344
- end
345
-
346
- module ActiveSupport::Callbacks
347
- extend ::ActiveSupport::Concern
348
-
349
- mixes_in_class_methods ::ActiveSupport::Callbacks::ClassMethods
350
-
351
- def run_callbacks(kind); end
352
-
353
- private
354
-
355
- def halted_callback_hook(filter, name); end
356
- end
357
-
358
- ActiveSupport::Callbacks::CALLBACK_FILTER_TYPES = T.let(T.unsafe(nil), Array)
359
-
360
- class ActiveSupport::Callbacks::CallTemplate
361
- def initialize(target, method, arguments, block); end
362
-
363
- def expand(target, value, block); end
364
- def inverted_lambda; end
365
- def make_lambda; end
366
-
367
- class << self
368
- def build(filter, callback); end
369
- end
370
- end
371
-
372
- class ActiveSupport::Callbacks::Callback
373
- def initialize(name, filter, kind, options, chain_config); end
374
-
375
- def apply(callback_sequence); end
376
- def chain_config; end
377
- def current_scopes; end
378
- def duplicates?(other); end
379
- def filter; end
380
- def kind; end
381
- def kind=(_arg0); end
382
- def matches?(_kind, _filter); end
383
- def merge_conditional_options(chain, if_option:, unless_option:); end
384
- def name; end
385
- def name=(_arg0); end
386
- def raw_filter; end
387
-
388
- private
389
-
390
- def check_conditionals(conditionals); end
391
- def compute_identifier(filter); end
392
- def conditions_lambdas; end
393
-
394
- class << self
395
- def build(chain, filter, kind, options); end
396
- end
397
- end
398
-
399
- ActiveSupport::Callbacks::Callback::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
400
-
401
- class ActiveSupport::Callbacks::CallbackChain
402
- include ::Enumerable
403
-
404
- def initialize(name, config); end
405
-
406
- def append(*callbacks); end
407
- def clear; end
408
- def compile; end
409
- def config; end
410
- def delete(o); end
411
- def each(&block); end
412
- def empty?; end
413
- def index(o); end
414
- def insert(index, o); end
415
- def name; end
416
- def prepend(*callbacks); end
417
-
418
- protected
419
-
420
- def chain; end
421
-
422
- private
423
-
424
- def append_one(callback); end
425
- def default_terminator; end
426
- def initialize_copy(other); end
427
- def prepend_one(callback); end
428
- def remove_duplicates(callback); end
429
- end
430
-
431
- class ActiveSupport::Callbacks::CallbackSequence
432
- def initialize(nested = T.unsafe(nil), call_template = T.unsafe(nil), user_conditions = T.unsafe(nil)); end
433
-
434
- def after(&after); end
435
- def around(call_template, user_conditions); end
436
- def before(&before); end
437
- def expand_call_template(arg, block); end
438
- def final?; end
439
- def invoke_after(arg); end
440
- def invoke_before(arg); end
441
- def nested; end
442
- def skip?(arg); end
443
- end
444
-
445
- module ActiveSupport::Callbacks::ClassMethods
446
- def __update_callbacks(name); end
447
- def define_callbacks(*names); end
448
- def normalize_callback_params(filters, block); end
449
- def reset_callbacks(name); end
450
- def set_callback(name, *filter_list, &block); end
451
- def skip_callback(name, *filter_list, &block); end
452
-
453
- protected
454
-
455
- def get_callbacks(name); end
456
- def set_callbacks(name, callbacks); end
457
- end
458
-
459
- module ActiveSupport::Callbacks::Conditionals; end
460
-
461
- class ActiveSupport::Callbacks::Conditionals::Value
462
- def initialize(&block); end
463
-
464
- def call(target, value); end
465
- end
466
-
467
- module ActiveSupport::Callbacks::Filters; end
468
-
469
- class ActiveSupport::Callbacks::Filters::After
470
- class << self
471
- def build(callback_sequence, user_callback, user_conditions, chain_config); end
472
-
473
- private
474
-
475
- def conditional(callback_sequence, user_callback, user_conditions); end
476
- def halting(callback_sequence, user_callback); end
477
- def halting_and_conditional(callback_sequence, user_callback, user_conditions); end
478
- def simple(callback_sequence, user_callback); end
479
- end
480
- end
481
-
482
- class ActiveSupport::Callbacks::Filters::Before
483
- class << self
484
- def build(callback_sequence, user_callback, user_conditions, chain_config, filter, name); end
485
-
486
- private
487
-
488
- def halting(callback_sequence, user_callback, halted_lambda, filter, name); end
489
- def halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name); end
490
- end
491
- end
492
-
493
- class ActiveSupport::Callbacks::Filters::Environment < ::Struct
494
- def halted; end
495
- def halted=(_); end
496
- def target; end
497
- def target=(_); end
498
- def value; end
499
- def value=(_); end
500
-
501
- class << self
502
- def [](*_arg0); end
503
- def inspect; end
504
- def members; end
505
- def new(*_arg0); end
506
- end
507
- end
508
-
509
- module ActiveSupport::Concern
510
- def append_features(base); end
511
- def class_methods(&class_methods_module_definition); end
512
- def included(base = T.unsafe(nil), &block); end
513
- def prepend_features(base); end
514
- def prepended(base = T.unsafe(nil), &block); end
515
-
516
- class << self
517
- def extended(base); end
518
- end
519
- end
520
-
521
- class ActiveSupport::Concern::MultipleIncludedBlocks < ::StandardError
522
- def initialize; end
523
- end
524
-
525
- class ActiveSupport::Concern::MultiplePrependBlocks < ::StandardError
526
- def initialize; end
527
- end
528
-
529
- module ActiveSupport::Concurrency; end
530
-
531
- class ActiveSupport::Concurrency::ShareLock
532
- include ::MonitorMixin
533
-
534
- def initialize; end
535
-
536
- def exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), after_compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
537
- def raw_state; end
538
- def sharing; end
539
- def start_exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
540
- def start_sharing; end
541
- def stop_exclusive(compatible: T.unsafe(nil)); end
542
- def stop_sharing; end
543
- def yield_shares(purpose: T.unsafe(nil), compatible: T.unsafe(nil), block_share: T.unsafe(nil)); end
544
-
545
- private
546
-
547
- def busy_for_exclusive?(purpose); end
548
- def busy_for_sharing?(purpose); end
549
- def eligible_waiters?(compatible); end
550
- def wait_for(method); end
551
- end
552
-
553
- module ActiveSupport::Configurable
554
- extend ::ActiveSupport::Concern
555
-
556
- mixes_in_class_methods ::ActiveSupport::Configurable::ClassMethods
557
-
558
- def config; end
559
- end
560
-
561
- module ActiveSupport::Configurable::ClassMethods
562
- def config; end
563
- def configure; end
564
-
565
- private
566
-
567
- def config_accessor(*names, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil)); end
568
- end
569
-
570
- class ActiveSupport::Configurable::Configuration < ::ActiveSupport::InheritableOptions
571
- def compile_methods!; end
572
-
573
- class << self
574
- def compile_methods!(keys); end
575
- end
576
- end
577
-
578
- class ActiveSupport::ConfigurationFile
579
- def initialize(content_path); end
580
-
581
- def parse(context: T.unsafe(nil), **options); end
582
-
583
- private
584
-
585
- def read(content_path); end
586
- def render(context); end
587
-
588
- class << self
589
- def parse(content_path, **options); end
590
- end
591
- end
592
-
593
- class ActiveSupport::ConfigurationFile::FormatError < ::StandardError; end
594
-
595
- class ActiveSupport::CurrentAttributes
596
- include ::ActiveSupport::Callbacks
597
- extend ::ActiveSupport::Callbacks::ClassMethods
598
- extend ::ActiveSupport::DescendantsTracker
599
-
600
- def initialize; end
601
-
602
- def __callbacks; end
603
- def __callbacks?; end
604
- def _reset_callbacks; end
605
- def _run_reset_callbacks(&block); end
606
- def attributes; end
607
- def attributes=(_arg0); end
608
- def reset; end
609
- def set(set_attributes); end
610
-
611
- private
612
-
613
- def assign_attributes(new_attributes); end
614
- def compute_attributes(keys); end
615
-
616
- class << self
617
- def __callbacks; end
618
- def __callbacks=(value); end
619
- def __callbacks?; end
620
- def _reset_callbacks; end
621
- def _reset_callbacks=(value); end
622
- def after_reset(&block); end
623
- def attribute(*names); end
624
- def before_reset(&block); end
625
- def clear_all; end
626
- def instance; end
627
- def reset(*args, &block); end
628
- def reset_all; end
629
- def resets(&block); end
630
- def set(*args, &block); end
631
-
632
- private
633
-
634
- def current_instances; end
635
- def current_instances_key; end
636
- def generated_attribute_methods; end
637
- def method_missing(name, *args, &block); end
638
- end
639
- end
640
-
641
- module ActiveSupport::Dependencies
642
- extend ::ActiveSupport::Dependencies
643
-
644
- def _eager_load_paths; end
645
- def _eager_load_paths=(val); end
646
- def autoload_module!(into, const_name, qualified_name, path_suffix); end
647
- def autoload_once_paths; end
648
- def autoload_once_paths=(val); end
649
- def autoload_paths; end
650
- def autoload_paths=(val); end
651
- def autoloadable_module?(path_suffix); end
652
- def autoloaded?(desc); end
653
- def autoloaded_constants; end
654
- def autoloaded_constants=(val); end
655
- def clear; end
656
- def constant_watch_stack; end
657
- def constant_watch_stack=(val); end
658
- def constantize(name); end
659
- def depend_on(file_name, message = T.unsafe(nil)); end
660
- def explicitly_unloadable_constants; end
661
- def explicitly_unloadable_constants=(val); end
662
- def history; end
663
- def history=(val); end
664
- def hook!; end
665
- def interlock; end
666
- def interlock=(val); end
667
- def load?; end
668
- def load_file(path, const_paths = T.unsafe(nil)); end
669
- def load_missing_constant(from_mod, const_name); end
670
- def load_once_path?(path); end
671
- def loadable_constants_for_path(path, bases = T.unsafe(nil)); end
672
- def loaded; end
673
- def loaded=(val); end
674
- def loading; end
675
- def loading=(val); end
676
- def log(message); end
677
- def logger; end
678
- def logger=(val); end
679
- def mark_for_unload(const_desc); end
680
- def mechanism; end
681
- def mechanism=(val); end
682
- def new_constants_in(*descs); end
683
- def qualified_const_defined?(path); end
684
- def qualified_name_for(mod, name); end
685
- def reference(klass); end
686
- def remove_constant(const); end
687
- def remove_unloadable_constants!; end
688
- def require_or_load(file_name, const_path = T.unsafe(nil)); end
689
- def safe_constantize(name); end
690
- def search_for_file(path_suffix); end
691
- def to_constant_name(desc); end
692
- def unhook!; end
693
- def verbose; end
694
- def verbose=(val); end
695
- def warnings_on_first_load; end
696
- def warnings_on_first_load=(val); end
697
- def will_unload?(const_desc); end
698
-
699
- private
700
-
701
- def real_mod_name(mod); end
702
- def uninitialized_constant(qualified_name, const_name, receiver:); end
703
-
704
- class << self
705
- def _eager_load_paths; end
706
- def _eager_load_paths=(val); end
707
- def autoload_once_paths; end
708
- def autoload_once_paths=(val); end
709
- def autoload_paths; end
710
- def autoload_paths=(val); end
711
- def autoloaded_constants; end
712
- def autoloaded_constants=(val); end
713
- def constant_watch_stack; end
714
- def constant_watch_stack=(val); end
715
- def explicitly_unloadable_constants; end
716
- def explicitly_unloadable_constants=(val); end
717
- def history; end
718
- def history=(val); end
719
- def interlock; end
720
- def interlock=(val); end
721
- def load_interlock; end
722
- def loaded; end
723
- def loaded=(val); end
724
- def loading; end
725
- def loading=(val); end
726
- def logger; end
727
- def logger=(val); end
728
- def mechanism; end
729
- def mechanism=(val); end
730
- def run_interlock; end
731
- def unload_interlock; end
732
- def verbose; end
733
- def verbose=(val); end
734
- def warnings_on_first_load; end
735
- def warnings_on_first_load=(val); end
736
- end
737
- end
738
-
739
- module ActiveSupport::Dependencies::Blamable
740
- def blame_file!(file); end
741
- def blamed_files; end
742
- def copy_blame!(exc); end
743
- def describe_blame; end
744
- end
745
-
746
- class ActiveSupport::Dependencies::ClassCache
747
- def initialize; end
748
-
749
- def [](key); end
750
- def clear!; end
751
- def empty?; end
752
- def get(key); end
753
- def key?(key); end
754
- def safe_get(key); end
755
- def store(klass); end
756
- end
757
-
758
- class ActiveSupport::Dependencies::Interlock
759
- def initialize; end
760
-
761
- def done_running; end
762
- def done_unloading; end
763
- def loading; end
764
- def permit_concurrent_loads; end
765
- def raw_state(&block); end
766
- def running; end
767
- def start_running; end
768
- def start_unloading; end
769
- def unloading; end
770
- end
771
-
772
- module ActiveSupport::Dependencies::Loadable
773
- def load_dependency(file); end
774
- def require_dependency(file_name, message = T.unsafe(nil)); end
775
- def require_or_load(file_name); end
776
- def unloadable(const_desc); end
777
-
778
- private
779
-
780
- def load(file, wrap = T.unsafe(nil)); end
781
- def require(file); end
782
-
783
- class << self
784
- def exclude_from(base); end
785
- def include_into(base); end
786
- end
787
- end
788
-
789
- module ActiveSupport::Dependencies::ModuleConstMissing
790
- def const_missing(const_name); end
791
- def guess_for_anonymous(const_name); end
792
- def unloadable(const_desc = T.unsafe(nil)); end
793
-
794
- class << self
795
- def append_features(base); end
796
- def exclude_from(base); end
797
- def include_into(base); end
798
- end
799
- end
800
-
801
- ActiveSupport::Dependencies::Reference = T.let(T.unsafe(nil), ActiveSupport::Dependencies::ClassCache)
802
- ActiveSupport::Dependencies::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
803
-
804
- class ActiveSupport::Dependencies::WatchStack
805
- include ::Enumerable
806
-
807
- def initialize; end
808
-
809
- def each(&block); end
810
- def new_constants; end
811
- def watch_namespaces(namespaces); end
812
- def watching; end
813
- def watching?; end
814
-
815
- private
816
-
817
- def pop_modules(modules); end
818
- end
819
-
820
- class ActiveSupport::Deprecation
821
- extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
822
- include ::ActiveSupport::Deprecation::InstanceDelegator
823
- include ::ActiveSupport::Deprecation::Behavior
824
- include ::ActiveSupport::Deprecation::Reporting
825
- include ::ActiveSupport::Deprecation::Disallowed
826
- include ::ActiveSupport::Deprecation::MethodWrapper
827
- extend ::Singleton::SingletonClassMethods
828
- extend ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
829
- include ::Singleton
830
-
831
- def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end
832
-
833
- def deprecation_horizon; end
834
- def deprecation_horizon=(_arg0); end
835
-
836
- class << self
837
- def allow(*args, &block); end
838
- def behavior(*args, &block); end
839
- def behavior=(arg); end
840
- def debug(*args, &block); end
841
- def debug=(arg); end
842
- def deprecate_methods(*args, &block); end
843
- def deprecation_horizon(*args, &block); end
844
- def deprecation_horizon=(arg); end
845
- def disallowed_behavior(*args, &block); end
846
- def disallowed_behavior=(arg); end
847
- def disallowed_warnings(*args, &block); end
848
- def disallowed_warnings=(arg); end
849
- def gem_name(*args, &block); end
850
- def gem_name=(arg); end
851
- def instance; end
852
- def silence(*args, &block); end
853
- def silenced(*args, &block); end
854
- def silenced=(arg); end
855
- end
856
- end
857
-
858
- module ActiveSupport::Deprecation::Behavior
859
- def behavior; end
860
- def behavior=(behavior); end
861
- def debug; end
862
- def debug=(_arg0); end
863
- def disallowed_behavior; end
864
- def disallowed_behavior=(behavior); end
865
-
866
- private
867
-
868
- def arity_coerce(behavior); end
869
- end
870
-
871
- ActiveSupport::Deprecation::DEFAULT_BEHAVIORS = T.let(T.unsafe(nil), Hash)
872
-
873
- module ActiveSupport::Deprecation::DeprecatedConstantAccessor
874
- class << self
875
- def included(base); end
876
- end
877
- end
878
-
879
- class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
880
- def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end
881
-
882
- def class; end
883
- def hash(*args, &block); end
884
- def inspect; end
885
- def instance_methods(*args, &block); end
886
- def name(*args, &block); end
887
- def respond_to?(*args, &block); end
888
-
889
- private
890
-
891
- def const_missing(name); end
892
- def method_missing(called, *args, &block); end
893
- def target; end
894
-
895
- class << self
896
- def new(*args, **options, &block); end
897
- end
898
- end
899
-
900
- class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupport::Deprecation::DeprecationProxy
901
- def initialize(instance, method, var = T.unsafe(nil), deprecator = T.unsafe(nil)); end
902
-
903
- private
904
-
905
- def target; end
906
- def warn(callstack, called, args); end
907
- end
908
-
909
- class ActiveSupport::Deprecation::DeprecatedObjectProxy < ::ActiveSupport::Deprecation::DeprecationProxy
910
- def initialize(object, message, deprecator = T.unsafe(nil)); end
911
-
912
- private
913
-
914
- def target; end
915
- def warn(callstack, called, args); end
916
- end
917
-
918
- class ActiveSupport::Deprecation::DeprecationProxy
919
- def inspect; end
920
-
921
- private
922
-
923
- def method_missing(called, *args, &block); end
924
-
925
- class << self
926
- def new(*args, &block); end
927
- end
928
- end
929
-
930
- module ActiveSupport::Deprecation::Disallowed
931
- def disallowed_warnings; end
932
- def disallowed_warnings=(_arg0); end
933
-
934
- private
935
-
936
- def deprecation_disallowed?(message); end
937
- def explicitly_allowed?(message); end
938
- end
939
-
940
- module ActiveSupport::Deprecation::InstanceDelegator
941
- mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
942
-
943
- class << self
944
- def included(base); end
945
- end
946
- end
947
-
948
- module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
949
- def include(included_module); end
950
- def method_added(method_name); end
951
- end
952
-
953
- module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
954
- def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
955
- def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
956
- end
957
-
958
- module ActiveSupport::Deprecation::MethodWrapper
959
- def deprecate_methods(target_module, *method_names); end
960
- end
961
-
962
- module ActiveSupport::Deprecation::Reporting
963
- def allow(allowed_warnings = T.unsafe(nil), if: T.unsafe(nil), &block); end
964
- def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
965
- def gem_name; end
966
- def gem_name=(_arg0); end
967
- def silence(&block); end
968
- def silenced; end
969
- def silenced=(_arg0); end
970
- def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
971
-
972
- private
973
-
974
- def _extract_callstack(callstack); end
975
- def deprecated_method_warning(method_name, message = T.unsafe(nil)); end
976
- def deprecation_caller_message(callstack); end
977
- def deprecation_message(callstack, message = T.unsafe(nil)); end
978
- def extract_callstack(callstack); end
979
- def ignored_callstack(path); end
980
- end
981
-
982
- ActiveSupport::Deprecation::Reporting::RAILS_GEM_ROOT = T.let(T.unsafe(nil), String)
983
- class ActiveSupport::DeprecationException < ::StandardError; end
984
-
985
- module ActiveSupport::DescendantsTracker
986
- def descendants; end
987
- def direct_descendants; end
988
- def inherited(base); end
989
- def subclasses; end
990
-
991
- class << self
992
- def clear; end
993
- def descendants(klass); end
994
- def direct_descendants(klass); end
995
- def store_inherited(klass, descendant); end
996
- def subclasses(klass); end
997
-
998
- private
999
-
1000
- def accumulate_descendants(klass, acc); end
1001
- end
1002
- end
1003
-
1004
- class ActiveSupport::DescendantsTracker::DescendantsArray
1005
- include ::Enumerable
1006
-
1007
- def initialize; end
1008
-
1009
- def <<(klass); end
1010
- def cleanup!; end
1011
- def each; end
1012
- def refs_size; end
1013
- def reject!; end
1014
-
1015
- private
1016
-
1017
- def initialize_copy(orig); end
1018
- end
1019
-
1020
- class ActiveSupport::Digest
1021
- class << self
1022
- def hash_digest_class; end
1023
- def hash_digest_class=(klass); end
1024
- def hexdigest(arg); end
1025
- end
1026
- end
1027
-
1028
- class ActiveSupport::Duration
1029
- def initialize(value, parts); end
1030
-
1031
- def %(other); end
1032
- def *(other); end
1033
- def +(other); end
1034
- def +@; end
1035
- def -(other); end
1036
- def -@; end
1037
- def /(other); end
1038
- def <=>(other); end
1039
- def ==(other); end
1040
- def after(time = T.unsafe(nil)); end
1041
- def ago(time = T.unsafe(nil)); end
1042
- def as_json(options = T.unsafe(nil)); end
1043
- def before(time = T.unsafe(nil)); end
1044
- def coerce(other); end
1045
- def encode_with(coder); end
1046
- def eql?(other); end
1047
- def from_now(time = T.unsafe(nil)); end
1048
- def hash; end
1049
- def in_days; end
1050
- def in_hours; end
1051
- def in_minutes; end
1052
- def in_months; end
1053
- def in_seconds; end
1054
- def in_weeks; end
1055
- def in_years; end
1056
- def init_with(coder); end
1057
- def inspect; end
1058
- def instance_of?(klass); end
1059
- def is_a?(klass); end
1060
- def iso8601(precision: T.unsafe(nil)); end
1061
- def kind_of?(klass); end
1062
- def parts; end
1063
- def parts=(_arg0); end
1064
- def since(time = T.unsafe(nil)); end
1065
- def to_i; end
1066
- def to_s; end
1067
- def until(time = T.unsafe(nil)); end
1068
- def value; end
1069
- def value=(_arg0); end
1070
-
1071
- private
1072
-
1073
- def method_missing(method, *args, &block); end
1074
- def raise_type_error(other); end
1075
- def respond_to_missing?(method, _); end
1076
- def sum(sign, time = T.unsafe(nil)); end
1077
-
1078
- class << self
1079
- def ===(other); end
1080
- def build(value); end
1081
- def days(value); end
1082
- def hours(value); end
1083
- def minutes(value); end
1084
- def months(value); end
1085
- def parse(iso8601duration); end
1086
- def seconds(value); end
1087
- def weeks(value); end
1088
- def years(value); end
1089
-
1090
- private
1091
-
1092
- def calculate_total_seconds(parts); end
1093
- end
1094
- end
1095
-
1096
- class ActiveSupport::Duration::ISO8601Parser
1097
- def initialize(string); end
1098
-
1099
- def mode; end
1100
- def mode=(_arg0); end
1101
- def parse!; end
1102
- def parts; end
1103
- def scanner; end
1104
- def sign; end
1105
- def sign=(_arg0); end
1106
-
1107
- private
1108
-
1109
- def finished?; end
1110
- def number; end
1111
- def raise_parsing_error(reason = T.unsafe(nil)); end
1112
- def scan(pattern); end
1113
- def validate!; end
1114
- end
1115
-
1116
- ActiveSupport::Duration::ISO8601Parser::COMMA = T.let(T.unsafe(nil), String)
1117
- ActiveSupport::Duration::ISO8601Parser::DATE_COMPONENT = T.let(T.unsafe(nil), Regexp)
1118
- ActiveSupport::Duration::ISO8601Parser::DATE_COMPONENTS = T.let(T.unsafe(nil), Array)
1119
- ActiveSupport::Duration::ISO8601Parser::DATE_MARKER = T.let(T.unsafe(nil), Regexp)
1120
- ActiveSupport::Duration::ISO8601Parser::DATE_TO_PART = T.let(T.unsafe(nil), Hash)
1121
- ActiveSupport::Duration::ISO8601Parser::PERIOD = T.let(T.unsafe(nil), String)
1122
- ActiveSupport::Duration::ISO8601Parser::PERIOD_OR_COMMA = T.let(T.unsafe(nil), Regexp)
1123
- class ActiveSupport::Duration::ISO8601Parser::ParsingError < ::ArgumentError; end
1124
- ActiveSupport::Duration::ISO8601Parser::SIGN_MARKER = T.let(T.unsafe(nil), Regexp)
1125
- ActiveSupport::Duration::ISO8601Parser::TIME_COMPONENT = T.let(T.unsafe(nil), Regexp)
1126
- ActiveSupport::Duration::ISO8601Parser::TIME_COMPONENTS = T.let(T.unsafe(nil), Array)
1127
- ActiveSupport::Duration::ISO8601Parser::TIME_MARKER = T.let(T.unsafe(nil), Regexp)
1128
- ActiveSupport::Duration::ISO8601Parser::TIME_TO_PART = T.let(T.unsafe(nil), Hash)
1129
-
1130
- class ActiveSupport::Duration::ISO8601Serializer
1131
- def initialize(duration, precision: T.unsafe(nil)); end
1132
-
1133
- def serialize; end
1134
-
1135
- private
1136
-
1137
- def normalize; end
1138
- def week_mixed_with_date?(parts); end
1139
- end
1140
-
1141
- ActiveSupport::Duration::ISO8601Serializer::DATE_COMPONENTS = T.let(T.unsafe(nil), Array)
1142
- ActiveSupport::Duration::PARTS = T.let(T.unsafe(nil), Array)
1143
- ActiveSupport::Duration::PARTS_IN_SECONDS = T.let(T.unsafe(nil), Hash)
1144
- ActiveSupport::Duration::SECONDS_PER_DAY = T.let(T.unsafe(nil), Integer)
1145
- ActiveSupport::Duration::SECONDS_PER_HOUR = T.let(T.unsafe(nil), Integer)
1146
- ActiveSupport::Duration::SECONDS_PER_MINUTE = T.let(T.unsafe(nil), Integer)
1147
- ActiveSupport::Duration::SECONDS_PER_MONTH = T.let(T.unsafe(nil), Integer)
1148
- ActiveSupport::Duration::SECONDS_PER_WEEK = T.let(T.unsafe(nil), Integer)
1149
- ActiveSupport::Duration::SECONDS_PER_YEAR = T.let(T.unsafe(nil), Integer)
1150
-
1151
- class ActiveSupport::Duration::Scalar < ::Numeric
1152
- def initialize(value); end
1153
-
1154
- def %(other); end
1155
- def *(other); end
1156
- def +(other); end
1157
- def -(other); end
1158
- def -@; end
1159
- def /(other); end
1160
- def <=>(other); end
1161
- def coerce(other); end
1162
- def to_f(*args, &block); end
1163
- def to_i(*args, &block); end
1164
- def to_s(*args, &block); end
1165
- def value; end
1166
-
1167
- private
1168
-
1169
- def calculate(op, other); end
1170
- def raise_type_error(other); end
1171
- end
1172
-
1173
- class ActiveSupport::EnvironmentInquirer < ::ActiveSupport::StringInquirer
1174
- def initialize(env); end
1175
-
1176
- def development?; end
1177
- def production?; end
1178
- def test?; end
1179
- end
1180
-
1181
- ActiveSupport::EnvironmentInquirer::DEFAULT_ENVIRONMENTS = T.let(T.unsafe(nil), Array)
1182
-
1183
- class ActiveSupport::EventedFileUpdateChecker
1184
- def initialize(files, dirs = T.unsafe(nil), &block); end
1185
-
1186
- def execute; end
1187
- def execute_if_updated; end
1188
- def updated?; end
1189
- end
1190
-
1191
- class ActiveSupport::EventedFileUpdateChecker::Core
1192
- def initialize(files, dirs); end
1193
-
1194
- def changed(modified, added, removed); end
1195
- def common_path(paths); end
1196
- def directories_to_watch; end
1197
- def finalizer; end
1198
- def normalize_dirs!; end
1199
- def restart; end
1200
- def restart?; end
1201
- def start; end
1202
- def stop; end
1203
- def thread_safely; end
1204
- def updated; end
1205
- def watching?(file); end
1206
- end
1207
-
1208
- class ActiveSupport::ExecutionWrapper
1209
- include ::ActiveSupport::Callbacks
1210
- extend ::ActiveSupport::Callbacks::ClassMethods
1211
- extend ::ActiveSupport::DescendantsTracker
1212
-
1213
- def __callbacks; end
1214
- def __callbacks?; end
1215
- def _complete_callbacks; end
1216
- def _run_callbacks; end
1217
- def _run_complete_callbacks(&block); end
1218
- def _run_run_callbacks(&block); end
1219
- def complete!; end
1220
- def run!; end
1221
-
1222
- private
1223
-
1224
- def hook_state; end
1225
-
1226
- class << self
1227
- def __callbacks; end
1228
- def __callbacks=(value); end
1229
- def __callbacks?; end
1230
- def _complete_callbacks; end
1231
- def _complete_callbacks=(value); end
1232
- def _run_callbacks; end
1233
- def _run_callbacks=(value); end
1234
- def active; end
1235
- def active=(_arg0); end
1236
- def active?; end
1237
- def inherited(other); end
1238
- def register_hook(hook, outer: T.unsafe(nil)); end
1239
- def run!; end
1240
- def to_complete(*args, &block); end
1241
- def to_run(*args, &block); end
1242
- def wrap; end
1243
- end
1244
- end
1245
-
1246
- class ActiveSupport::ExecutionWrapper::CompleteHook < ::Struct
1247
- def after(target); end
1248
- def before(target); end
1249
- def hook; end
1250
- def hook=(_); end
1251
-
1252
- class << self
1253
- def [](*_arg0); end
1254
- def inspect; end
1255
- def members; end
1256
- def new(*_arg0); end
1257
- end
1258
- end
1259
-
1260
- ActiveSupport::ExecutionWrapper::Null = T.let(T.unsafe(nil), Object)
1261
-
1262
- class ActiveSupport::ExecutionWrapper::RunHook < ::Struct
1263
- def before(target); end
1264
- def hook; end
1265
- def hook=(_); end
1266
-
1267
- class << self
1268
- def [](*_arg0); end
1269
- def inspect; end
1270
- def members; end
1271
- def new(*_arg0); end
1272
- end
1273
- end
1274
-
1275
- class ActiveSupport::Executor < ::ActiveSupport::ExecutionWrapper; end
1276
-
1277
- class ActiveSupport::FileUpdateChecker
1278
- def initialize(files, dirs = T.unsafe(nil), &block); end
1279
-
1280
- def execute; end
1281
- def execute_if_updated; end
1282
- def updated?; end
1283
-
1284
- private
1285
-
1286
- def compile_ext(array); end
1287
- def compile_glob(hash); end
1288
- def escape(key); end
1289
- def max_mtime(paths); end
1290
- def updated_at(paths); end
1291
- def watched; end
1292
- end
1293
-
1294
- module ActiveSupport::ForkTracker
1295
- class << self
1296
- def after_fork(&block); end
1297
- def check!; end
1298
- def hook!; end
1299
- def unregister(callback); end
1300
- end
1301
- end
1302
-
1303
- module ActiveSupport::ForkTracker::CoreExt
1304
- def fork(*_arg0); end
1305
- end
1306
-
1307
- module ActiveSupport::ForkTracker::CoreExtPrivate
1308
- private
1309
-
1310
- def fork(*_arg0); end
1311
- end
1312
-
1313
- module ActiveSupport::Gzip
1314
- class << self
1315
- def compress(source, level = T.unsafe(nil), strategy = T.unsafe(nil)); end
1316
- def decompress(source); end
1317
- end
1318
- end
1319
-
1320
- class ActiveSupport::Gzip::Stream < ::StringIO
1321
- def initialize(*_arg0); end
1322
-
1323
- def close; end
1324
- end
1325
-
1326
- class ActiveSupport::HashWithIndifferentAccess < ::Hash
1327
- def initialize(constructor = T.unsafe(nil)); end
1328
-
1329
- def [](key); end
1330
- def []=(key, value); end
1331
- def assoc(key); end
1332
- def compact; end
1333
- def deep_stringify_keys; end
1334
- def deep_stringify_keys!; end
1335
- def deep_symbolize_keys; end
1336
- def default(*args); end
1337
- def delete(key); end
1338
- def dig(*args); end
1339
- def dup; end
1340
- def except(*keys); end
1341
- def extractable_options?; end
1342
- def fetch(key, *extras); end
1343
- def fetch_values(*indices, &block); end
1344
- def has_key?(key); end
1345
- def include?(key); end
1346
- def key?(key); end
1347
- def member?(key); end
1348
- def merge(*hashes, &block); end
1349
- def merge!(*other_hashes, &block); end
1350
- def nested_under_indifferent_access; end
1351
- def regular_update(*_arg0); end
1352
- def regular_writer(_arg0, _arg1); end
1353
- def reject(*args, &block); end
1354
- def replace(other_hash); end
1355
- def reverse_merge(other_hash); end
1356
- def reverse_merge!(other_hash); end
1357
- def select(*args, &block); end
1358
- def slice(*keys); end
1359
- def slice!(*keys); end
1360
- def store(key, value); end
1361
- def stringify_keys; end
1362
- def stringify_keys!; end
1363
- def symbolize_keys; end
1364
- def to_hash; end
1365
- def to_options; end
1366
- def to_options!; end
1367
- def transform_keys(*args, &block); end
1368
- def transform_keys!; end
1369
- def transform_values(*args, &block); end
1370
- def update(*other_hashes, &block); end
1371
- def values_at(*keys); end
1372
- def with_defaults(other_hash); end
1373
- def with_defaults!(other_hash); end
1374
- def with_indifferent_access; end
1375
- def without(*keys); end
1376
-
1377
- private
1378
-
1379
- def convert_key(key); end
1380
- def convert_value(value, conversion: T.unsafe(nil)); end
1381
- def set_defaults(target); end
1382
- def update_with_single_argument(other_hash, block); end
1383
-
1384
- class << self
1385
- def [](*args); end
1386
- end
1387
- end
1388
-
1389
- module ActiveSupport::Inflector
1390
- extend ::ActiveSupport::Inflector
1391
-
1392
- def camelize(term, uppercase_first_letter = T.unsafe(nil)); end
1393
- def classify(table_name); end
1394
- def constantize(camel_cased_word); end
1395
- def dasherize(underscored_word); end
1396
- def deconstantize(path); end
1397
- def demodulize(path); end
1398
- def foreign_key(class_name, separate_class_name_and_id_with_underscore = T.unsafe(nil)); end
1399
- def humanize(lower_case_and_underscored_word, capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
1400
- def inflections(locale = T.unsafe(nil)); end
1401
- def ordinal(number); end
1402
- def ordinalize(number); end
1403
- def parameterize(string, separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end
1404
- def pluralize(word, locale = T.unsafe(nil)); end
1405
- def safe_constantize(camel_cased_word); end
1406
- def singularize(word, locale = T.unsafe(nil)); end
1407
- def tableize(class_name); end
1408
- def titleize(word, keep_id_suffix: T.unsafe(nil)); end
1409
- def transliterate(string, replacement = T.unsafe(nil), locale: T.unsafe(nil)); end
1410
- def underscore(camel_cased_word); end
1411
- def upcase_first(string); end
1412
-
1413
- private
1414
-
1415
- def apply_inflections(word, rules, locale = T.unsafe(nil)); end
1416
- def const_regexp(camel_cased_word); end
1417
- end
1418
-
1419
- ActiveSupport::Inflector::ALLOWED_ENCODINGS_FOR_TRANSLITERATE = T.let(T.unsafe(nil), Array)
1420
-
1421
- class ActiveSupport::Inflector::Inflections
1422
- def initialize; end
1423
-
1424
- def acronym(word); end
1425
- def acronyms; end
1426
- def acronyms_camelize_regex; end
1427
- def acronyms_underscore_regex; end
1428
- def clear(scope = T.unsafe(nil)); end
1429
- def human(rule, replacement); end
1430
- def humans; end
1431
- def irregular(singular, plural); end
1432
- def plural(rule, replacement); end
1433
- def plurals; end
1434
- def singular(rule, replacement); end
1435
- def singulars; end
1436
- def uncountable(*words); end
1437
- def uncountables; end
1438
-
1439
- private
1440
-
1441
- def define_acronym_regex_patterns; end
1442
- def initialize_dup(orig); end
1443
-
1444
- class << self
1445
- def instance(locale = T.unsafe(nil)); end
1446
- end
1447
- end
1448
-
1449
- class ActiveSupport::Inflector::Inflections::Uncountables < ::Array
1450
- def initialize; end
1451
-
1452
- def <<(*word); end
1453
- def add(words); end
1454
- def delete(entry); end
1455
- def uncountable?(str); end
1456
-
1457
- private
1458
-
1459
- def to_regex(string); end
1460
- end
1461
-
1462
- class ActiveSupport::InheritableOptions < ::ActiveSupport::OrderedOptions
1463
- def initialize(parent = T.unsafe(nil)); end
1464
-
1465
- def inheritable_copy; end
1466
- end
1467
-
1468
- module ActiveSupport::JSON
1469
- class << self
1470
- def decode(json); end
1471
- def encode(value, options = T.unsafe(nil)); end
1472
- def parse_error; end
1473
-
1474
- private
1475
-
1476
- def convert_dates_from(data); end
1477
- end
1478
- end
1479
-
1480
- ActiveSupport::JSON::DATETIME_REGEX = T.let(T.unsafe(nil), Regexp)
1481
- ActiveSupport::JSON::DATE_REGEX = T.let(T.unsafe(nil), Regexp)
1482
-
1483
- module ActiveSupport::JSON::Encoding
1484
- class << self
1485
- def escape_html_entities_in_json; end
1486
- def escape_html_entities_in_json=(_arg0); end
1487
- def json_encoder; end
1488
- def json_encoder=(_arg0); end
1489
- def time_precision; end
1490
- def time_precision=(_arg0); end
1491
- def use_standard_json_time_format; end
1492
- def use_standard_json_time_format=(_arg0); end
1493
- end
1494
- end
1495
-
1496
- class ActiveSupport::JSON::Encoding::JSONGemEncoder
1497
- def initialize(options = T.unsafe(nil)); end
1498
-
1499
- def encode(value); end
1500
- def options; end
1501
-
1502
- private
1503
-
1504
- def jsonify(value); end
1505
- def stringify(jsonified); end
1506
- end
1507
-
1508
- ActiveSupport::JSON::Encoding::JSONGemEncoder::ESCAPED_CHARS = T.let(T.unsafe(nil), Hash)
1509
- ActiveSupport::JSON::Encoding::JSONGemEncoder::ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = T.let(T.unsafe(nil), Regexp)
1510
- ActiveSupport::JSON::Encoding::JSONGemEncoder::ESCAPE_REGEX_WITH_HTML_ENTITIES = T.let(T.unsafe(nil), Regexp)
1511
-
1512
- class ActiveSupport::JSON::Encoding::JSONGemEncoder::EscapedString < ::String
1513
- def to_json(*_arg0); end
1514
- def to_s; end
1515
- end
1516
-
1517
- class ActiveSupport::KeyGenerator
1518
- def initialize(secret, options = T.unsafe(nil)); end
1519
-
1520
- def generate_key(salt, key_size = T.unsafe(nil)); end
1521
- end
1522
-
1523
- module ActiveSupport::LazyLoadHooks
1524
- def on_load(name, options = T.unsafe(nil), &block); end
1525
- def run_load_hooks(name, base = T.unsafe(nil)); end
1526
-
1527
- private
1528
-
1529
- def execute_hook(name, base, options, block); end
1530
- def with_execution_control(name, block, once); end
1531
-
1532
- class << self
1533
- def extended(base); end
1534
- end
1535
- end
1536
-
1537
- class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
1538
- def colorize_logging; end
1539
- def colorize_logging=(val); end
1540
- def debug(progname = T.unsafe(nil), &block); end
1541
- def error(progname = T.unsafe(nil), &block); end
1542
- def fatal(progname = T.unsafe(nil), &block); end
1543
- def finish(name, id, payload); end
1544
- def info(progname = T.unsafe(nil), &block); end
1545
- def logger; end
1546
- def start(name, id, payload); end
1547
- def unknown(progname = T.unsafe(nil), &block); end
1548
- def warn(progname = T.unsafe(nil), &block); end
1549
-
1550
- private
1551
-
1552
- def color(text, color, bold = T.unsafe(nil)); end
1553
-
1554
- class << self
1555
- def colorize_logging; end
1556
- def colorize_logging=(val); end
1557
- def flush_all!; end
1558
- def log_subscribers; end
1559
- def logger; end
1560
- def logger=(_arg0); end
1561
-
1562
- private
1563
-
1564
- def fetch_public_methods(subscriber, inherit_all); end
1565
- end
1566
- end
1567
-
1568
- ActiveSupport::LogSubscriber::BLACK = T.let(T.unsafe(nil), String)
1569
- ActiveSupport::LogSubscriber::BLUE = T.let(T.unsafe(nil), String)
1570
- ActiveSupport::LogSubscriber::BOLD = T.let(T.unsafe(nil), String)
1571
- ActiveSupport::LogSubscriber::CLEAR = T.let(T.unsafe(nil), String)
1572
- ActiveSupport::LogSubscriber::CYAN = T.let(T.unsafe(nil), String)
1573
- ActiveSupport::LogSubscriber::GREEN = T.let(T.unsafe(nil), String)
1574
- ActiveSupport::LogSubscriber::MAGENTA = T.let(T.unsafe(nil), String)
1575
- ActiveSupport::LogSubscriber::RED = T.let(T.unsafe(nil), String)
1576
- ActiveSupport::LogSubscriber::WHITE = T.let(T.unsafe(nil), String)
1577
- ActiveSupport::LogSubscriber::YELLOW = T.let(T.unsafe(nil), String)
1578
-
1579
- class ActiveSupport::Logger < ::Logger
1580
- include ::ActiveSupport::LoggerSilence
1581
- include ::ActiveSupport::LoggerThreadSafeLevel
1582
-
1583
- def initialize(*args, **kwargs); end
1584
-
1585
- def silencer; end
1586
- def silencer=(val); end
1587
-
1588
- class << self
1589
- def broadcast(logger); end
1590
- def local_levels; end
1591
- def local_levels=(val); end
1592
- def logger_outputs_to?(logger, *sources); end
1593
- def silencer; end
1594
- def silencer=(val); end
1595
- end
1596
- end
1597
-
1598
- class ActiveSupport::Logger::SimpleFormatter < ::Logger::Formatter
1599
- def call(severity, timestamp, progname, msg); end
1600
- end
1601
-
1602
- module ActiveSupport::LoggerSilence
1603
- extend ::ActiveSupport::Concern
1604
- include ::ActiveSupport::LoggerThreadSafeLevel
1605
-
1606
- def silence(severity = T.unsafe(nil)); end
1607
- end
1608
-
1609
- module ActiveSupport::LoggerThreadSafeLevel
1610
- extend ::ActiveSupport::Concern
1611
-
1612
- def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
1613
- def debug?; end
1614
- def error?; end
1615
- def fatal?; end
1616
- def info?; end
1617
- def level; end
1618
- def local_level; end
1619
- def local_level=(level); end
1620
- def local_log_id; end
1621
- def log_at(level); end
1622
- def unknown?; end
1623
- def warn?; end
1624
- end
1625
-
1626
- module ActiveSupport::MarshalWithAutoloading
1627
- def load(source, proc = T.unsafe(nil)); end
1628
- end
1629
-
1630
- class ActiveSupport::MessageEncryptor
1631
- include ::ActiveSupport::Messages::Rotator
1632
- include ::ActiveSupport::Messages::Rotator::Encryptor
1633
-
1634
- def encrypt_and_sign(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
1635
-
1636
- private
1637
-
1638
- def _decrypt(encrypted_message, purpose); end
1639
- def _encrypt(value, **metadata_options); end
1640
- def aead_mode?; end
1641
- def new_cipher; end
1642
- def resolve_verifier; end
1643
- def verifier; end
1644
-
1645
- class << self
1646
- def default_cipher; end
1647
- def key_len(cipher = T.unsafe(nil)); end
1648
- def use_authenticated_message_encryption; end
1649
- def use_authenticated_message_encryption=(val); end
1650
- end
1651
- end
1652
-
1653
- class ActiveSupport::MessageEncryptor::InvalidMessage < ::StandardError; end
1654
-
1655
- module ActiveSupport::MessageEncryptor::NullSerializer
1656
- class << self
1657
- def dump(value); end
1658
- def load(value); end
1659
- end
1660
- end
1661
-
1662
- module ActiveSupport::MessageEncryptor::NullVerifier
1663
- class << self
1664
- def generate(value); end
1665
- def verify(value); end
1666
- end
1667
- end
1668
-
1669
- ActiveSupport::MessageEncryptor::OpenSSLCipherError = OpenSSL::Cipher::CipherError
1670
-
1671
- class ActiveSupport::MessageVerifier
1672
- include ::ActiveSupport::Messages::Rotator
1673
- include ::ActiveSupport::Messages::Rotator::Verifier
1674
-
1675
- def generate(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
1676
- def valid_message?(signed_message); end
1677
- def verify(*args, **options); end
1678
-
1679
- private
1680
-
1681
- def decode(data); end
1682
- def encode(data); end
1683
- def generate_digest(data); end
1684
- end
1685
-
1686
- class ActiveSupport::MessageVerifier::InvalidSignature < ::StandardError; end
1687
- module ActiveSupport::Messages; end
1688
-
1689
- class ActiveSupport::Messages::Metadata
1690
- def initialize(message, expires_at = T.unsafe(nil), purpose = T.unsafe(nil)); end
1691
-
1692
- def as_json(options = T.unsafe(nil)); end
1693
- def verify(purpose); end
1694
-
1695
- private
1696
-
1697
- def fresh?; end
1698
- def match?(purpose); end
1699
- def parse_expires_at(expires_at); end
1700
-
1701
- class << self
1702
- def verify(message, purpose); end
1703
- def wrap(message, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
1704
-
1705
- private
1706
-
1707
- def decode(message); end
1708
- def encode(message); end
1709
- def extract_metadata(message); end
1710
- def pick_expiry(expires_at, expires_in); end
1711
- end
1712
- end
1713
-
1714
- module ActiveSupport::Messages::Rotator
1715
- def initialize(*secrets, on_rotation: T.unsafe(nil), **options); end
1716
-
1717
- def rotate(*secrets, **options); end
1718
-
1719
- private
1720
-
1721
- def run_rotations(on_rotation); end
1722
- end
1723
-
1724
- module ActiveSupport::Messages::Rotator::Encryptor
1725
- include ::ActiveSupport::Messages::Rotator
1726
-
1727
- def decrypt_and_verify(*args, on_rotation: T.unsafe(nil), **options); end
1728
-
1729
- private
1730
-
1731
- def build_rotation(secret = T.unsafe(nil), sign_secret = T.unsafe(nil), options); end
1732
- end
1733
-
1734
- module ActiveSupport::Messages::Rotator::Verifier
1735
- include ::ActiveSupport::Messages::Rotator
1736
-
1737
- def verified(*args, on_rotation: T.unsafe(nil), **options); end
1738
-
1739
- private
1740
-
1741
- def build_rotation(secret = T.unsafe(nil), options); end
1742
- end
1743
-
1744
- module ActiveSupport::Multibyte
1745
- class << self
1746
- def proxy_class; end
1747
- def proxy_class=(klass); end
1748
- end
1749
- end
1750
-
1751
- class ActiveSupport::Multibyte::Chars
1752
- include ::Comparable
1753
-
1754
- def initialize(string); end
1755
-
1756
- def <=>(*args, &block); end
1757
- def =~(*args, &block); end
1758
- def acts_like_string?(*args, &block); end
1759
- def as_json(options = T.unsafe(nil)); end
1760
- def compose; end
1761
- def decompose; end
1762
- def grapheme_length; end
1763
- def limit(limit); end
1764
- def match?(*args, &block); end
1765
- def method_missing(method, *args, &block); end
1766
- def reverse; end
1767
- def reverse!(*args); end
1768
- def slice!(*args); end
1769
- def split(*args); end
1770
- def tidy_bytes(force = T.unsafe(nil)); end
1771
- def tidy_bytes!(*args); end
1772
- def titlecase; end
1773
- def titleize; end
1774
- def to_s; end
1775
- def to_str; end
1776
- def wrapped_string; end
1777
-
1778
- private
1779
-
1780
- def chars(string); end
1781
- def respond_to_missing?(method, include_private); end
1782
- end
1783
-
1784
- module ActiveSupport::Multibyte::Unicode
1785
- extend ::ActiveSupport::Multibyte::Unicode
1786
-
1787
- def compose(codepoints); end
1788
- def decompose(type, codepoints); end
1789
- def default_normalization_form; end
1790
- def default_normalization_form=(_); end
1791
- def tidy_bytes(string, force = T.unsafe(nil)); end
1792
-
1793
- private
1794
-
1795
- def recode_windows1252_chars(string); end
1796
- end
1797
-
1798
- ActiveSupport::Multibyte::Unicode::UNICODE_VERSION = T.let(T.unsafe(nil), String)
1799
-
1800
- module ActiveSupport::Notifications
1801
- class << self
1802
- def instrument(name, payload = T.unsafe(nil)); end
1803
- def instrumenter; end
1804
- def monotonic_subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
1805
- def notifier; end
1806
- def notifier=(_arg0); end
1807
- def publish(name, *args); end
1808
- def subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
1809
- def subscribed(callback, pattern = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
1810
- def unsubscribe(subscriber_or_name); end
1811
- end
1812
- end
1813
-
1814
- class ActiveSupport::Notifications::Event
1815
- def initialize(name, start, ending, transaction_id, payload); end
1816
-
1817
- def <<(event); end
1818
- def allocations; end
1819
- def children; end
1820
- def cpu_time; end
1821
- def duration; end
1822
- def end; end
1823
- def finish!; end
1824
- def idle_time; end
1825
- def name; end
1826
- def parent_of?(event); end
1827
- def payload; end
1828
- def payload=(_arg0); end
1829
- def start!; end
1830
- def time; end
1831
- def transaction_id; end
1832
-
1833
- private
1834
-
1835
- def now; end
1836
- def now_allocations; end
1837
- def now_cpu; end
1838
- end
1839
-
1840
- class ActiveSupport::Notifications::Fanout
1841
- include ::Mutex_m
1842
-
1843
- def initialize; end
1844
-
1845
- def finish(name, id, payload, listeners = T.unsafe(nil)); end
1846
- def listeners_for(name); end
1847
- def listening?(name); end
1848
- def lock; end
1849
- def locked?; end
1850
- def publish(name, *args); end
1851
- def start(name, id, payload); end
1852
- def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
1853
- def synchronize(&block); end
1854
- def try_lock; end
1855
- def unlock; end
1856
- def unsubscribe(subscriber_or_name); end
1857
- def wait; end
1858
- end
1859
-
1860
- module ActiveSupport::Notifications::Fanout::Subscribers
1861
- class << self
1862
- def new(pattern, listener, monotonic); end
1863
- def wrap_all(pattern, subscriber); end
1864
- end
1865
- end
1866
-
1867
- class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
1868
- def initialize(delegate); end
1869
-
1870
- def finish(name, id, payload); end
1871
- def matches?(_arg0); end
1872
- def publish(name, *args); end
1873
- def start(name, id, payload); end
1874
- def subscribed_to?(name); end
1875
- def unsubscribe!(*_arg0); end
1876
- end
1877
-
1878
- class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
1879
- def finish(name, id, payload); end
1880
- def start(name, id, payload); end
1881
-
1882
- private
1883
-
1884
- def build_event(name, id, payload); end
1885
- end
1886
-
1887
- class ActiveSupport::Notifications::Fanout::Subscribers::Evented
1888
- def initialize(pattern, delegate); end
1889
-
1890
- def finish(name, id, payload); end
1891
- def matches?(name); end
1892
- def pattern; end
1893
- def publish(name, *args); end
1894
- def start(name, id, payload); end
1895
- def subscribed_to?(name); end
1896
- def unsubscribe!(name); end
1897
- end
1898
-
1899
- class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
1900
- def initialize(pattern); end
1901
-
1902
- def ===(name); end
1903
- def exclusions; end
1904
- def pattern; end
1905
- def unsubscribe!(name); end
1906
-
1907
- class << self
1908
- def wrap(pattern); end
1909
- end
1910
- end
1911
-
1912
- class ActiveSupport::Notifications::Fanout::Subscribers::MonotonicTimed < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
1913
- def finish(name, id, payload); end
1914
- def publish(name, *args); end
1915
- def start(name, id, payload); end
1916
- end
1917
-
1918
- class ActiveSupport::Notifications::Fanout::Subscribers::Timed < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
1919
- def finish(name, id, payload); end
1920
- def publish(name, *args); end
1921
- def start(name, id, payload); end
1922
- end
1923
-
1924
- class ActiveSupport::Notifications::InstrumentationRegistry
1925
- extend ::ActiveSupport::PerThreadRegistry
1926
-
1927
- def initialize; end
1928
-
1929
- def instrumenter_for(notifier); end
1930
- end
1931
-
1932
- class ActiveSupport::Notifications::Instrumenter
1933
- def initialize(notifier); end
1934
-
1935
- def finish(name, payload); end
1936
- def finish_with_state(listeners_state, name, payload); end
1937
- def id; end
1938
- def instrument(name, payload = T.unsafe(nil)); end
1939
- def start(name, payload); end
1940
-
1941
- private
1942
-
1943
- def unique_id; end
1944
- end
1945
-
1946
- module ActiveSupport::NumberHelper
1947
- extend ::ActiveSupport::Autoload
1948
- extend ::ActiveSupport::NumberHelper
1949
-
1950
- def number_to_currency(number, options = T.unsafe(nil)); end
1951
- def number_to_delimited(number, options = T.unsafe(nil)); end
1952
- def number_to_human(number, options = T.unsafe(nil)); end
1953
- def number_to_human_size(number, options = T.unsafe(nil)); end
1954
- def number_to_percentage(number, options = T.unsafe(nil)); end
1955
- def number_to_phone(number, options = T.unsafe(nil)); end
1956
- def number_to_rounded(number, options = T.unsafe(nil)); end
1957
- end
1958
-
1959
- class ActiveSupport::NumberHelper::NumberConverter
1960
- def initialize(number, options); end
1961
-
1962
- def execute; end
1963
- def namespace; end
1964
- def namespace=(_arg0); end
1965
- def namespace?; end
1966
- def number; end
1967
- def opts; end
1968
- def validate_float; end
1969
- def validate_float=(_arg0); end
1970
- def validate_float?; end
1971
-
1972
- private
1973
-
1974
- def default_format_options; end
1975
- def default_value(key); end
1976
- def format_options; end
1977
- def i18n_format_options; end
1978
- def options; end
1979
- def translate_in_locale(key, **i18n_options); end
1980
- def translate_number_value_with_default(key, **i18n_options); end
1981
- def valid_float?; end
1982
-
1983
- class << self
1984
- def convert(number, options); end
1985
- def namespace; end
1986
- def namespace=(value); end
1987
- def namespace?; end
1988
- def validate_float; end
1989
- def validate_float=(value); end
1990
- def validate_float?; end
1991
- end
1992
- end
1993
-
1994
- ActiveSupport::NumberHelper::NumberConverter::DEFAULTS = T.let(T.unsafe(nil), Hash)
1995
-
1996
- class ActiveSupport::NumberHelper::NumberToCurrencyConverter < ::ActiveSupport::NumberHelper::NumberConverter
1997
- def convert; end
1998
-
1999
- private
2000
-
2001
- def i18n_opts; end
2002
- def options; end
2003
-
2004
- class << self
2005
- def namespace; end
2006
- end
2007
- end
2008
-
2009
- class ActiveSupport::NumberHelper::NumberToDelimitedConverter < ::ActiveSupport::NumberHelper::NumberConverter
2010
- def convert; end
2011
-
2012
- private
2013
-
2014
- def delimiter_pattern; end
2015
- def parts; end
2016
-
2017
- class << self
2018
- def validate_float; end
2019
- end
2020
- end
2021
-
2022
- ActiveSupport::NumberHelper::NumberToDelimitedConverter::DEFAULT_DELIMITER_REGEX = T.let(T.unsafe(nil), Regexp)
2023
-
2024
- class ActiveSupport::NumberHelper::NumberToHumanConverter < ::ActiveSupport::NumberHelper::NumberConverter
2025
- def convert; end
2026
-
2027
- private
2028
-
2029
- def calculate_exponent(units); end
2030
- def determine_unit(units, exponent); end
2031
- def format; end
2032
- def unit_exponents(units); end
2033
-
2034
- class << self
2035
- def namespace; end
2036
- def validate_float; end
2037
- end
2038
- end
2039
-
2040
- ActiveSupport::NumberHelper::NumberToHumanConverter::DECIMAL_UNITS = T.let(T.unsafe(nil), Hash)
2041
- ActiveSupport::NumberHelper::NumberToHumanConverter::INVERTED_DECIMAL_UNITS = T.let(T.unsafe(nil), Hash)
2042
-
2043
- class ActiveSupport::NumberHelper::NumberToHumanSizeConverter < ::ActiveSupport::NumberHelper::NumberConverter
2044
- def convert; end
2045
-
2046
- private
2047
-
2048
- def base; end
2049
- def conversion_format; end
2050
- def exponent; end
2051
- def smaller_than_base?; end
2052
- def storage_unit_key; end
2053
- def unit; end
2054
-
2055
- class << self
2056
- def namespace; end
2057
- def validate_float; end
2058
- end
2059
- end
2060
-
2061
- ActiveSupport::NumberHelper::NumberToHumanSizeConverter::STORAGE_UNITS = T.let(T.unsafe(nil), Array)
2062
-
2063
- class ActiveSupport::NumberHelper::NumberToPercentageConverter < ::ActiveSupport::NumberHelper::NumberConverter
2064
- def convert; end
2065
-
2066
- class << self
2067
- def namespace; end
2068
- end
2069
- end
2070
-
2071
- class ActiveSupport::NumberHelper::NumberToPhoneConverter < ::ActiveSupport::NumberHelper::NumberConverter
2072
- def convert; end
2073
-
2074
- private
2075
-
2076
- def convert_to_phone_number(number); end
2077
- def convert_with_area_code(number); end
2078
- def convert_without_area_code(number); end
2079
- def country_code(code); end
2080
- def delimiter; end
2081
- def phone_ext(ext); end
2082
- def regexp_pattern(default_pattern); end
2083
- def start_with_delimiter?(number); end
2084
- end
2085
-
2086
- class ActiveSupport::NumberHelper::NumberToRoundedConverter < ::ActiveSupport::NumberHelper::NumberConverter
2087
- def convert; end
2088
-
2089
- private
2090
-
2091
- def format_number(number); end
2092
- def strip_insignificant_zeros; end
2093
-
2094
- class << self
2095
- def namespace; end
2096
- def validate_float; end
2097
- end
2098
- end
2099
-
2100
- class ActiveSupport::NumberHelper::RoundingHelper
2101
- def initialize(options); end
2102
-
2103
- def digit_count(number); end
2104
- def options; end
2105
- def round(number); end
2106
-
2107
- private
2108
-
2109
- def absolute_precision(number); end
2110
- def convert_to_decimal(number); end
2111
- def significant; end
2112
- end
2113
-
2114
- class ActiveSupport::OptionMerger
2115
- def initialize(context, options); end
2116
-
2117
- private
2118
-
2119
- def invoke_method(method, arguments, options, &block); end
2120
- def method_missing(method, *arguments, &block); end
2121
- end
2122
-
2123
- class ActiveSupport::OrderedHash < ::Hash
2124
- def encode_with(coder); end
2125
- def extractable_options?; end
2126
- def nested_under_indifferent_access; end
2127
- def reject(*args, &block); end
2128
- def select(*args, &block); end
2129
- def to_yaml_type; end
2130
- end
2131
-
2132
- class ActiveSupport::OrderedOptions < ::Hash
2133
- def [](key); end
2134
- def []=(key, value); end
2135
- def extractable_options?; end
2136
- def inspect; end
2137
- def method_missing(name, *args); end
2138
-
2139
- protected
2140
-
2141
- def _get(_arg0); end
2142
-
2143
- private
2144
-
2145
- def respond_to_missing?(name, include_private); end
2146
- end
2147
-
2148
- class ActiveSupport::ParameterFilter
2149
- def initialize(filters = T.unsafe(nil), mask: T.unsafe(nil)); end
2150
-
2151
- def filter(params); end
2152
- def filter_param(key, value); end
2153
-
2154
- private
2155
-
2156
- def compiled_filter; end
2157
- end
2158
-
2159
- class ActiveSupport::ParameterFilter::CompiledFilter
2160
- def initialize(regexps, deep_regexps, blocks, mask:); end
2161
-
2162
- def blocks; end
2163
- def call(params, parents = T.unsafe(nil), original_params = T.unsafe(nil)); end
2164
- def deep_regexps; end
2165
- def regexps; end
2166
- def value_for_key(key, value, parents = T.unsafe(nil), original_params = T.unsafe(nil)); end
2167
-
2168
- class << self
2169
- def compile(filters, mask:); end
2170
- end
2171
- end
2172
-
2173
- ActiveSupport::ParameterFilter::FILTERED = T.let(T.unsafe(nil), String)
2174
-
2175
- module ActiveSupport::PerThreadRegistry
2176
- def instance; end
2177
-
2178
- private
2179
-
2180
- def method_missing(name, *args, &block); end
2181
-
2182
- class << self
2183
- def extended(object); end
2184
- end
2185
- end
2186
-
2187
- class ActiveSupport::ProxyObject < ::BasicObject
2188
- def raise(*args); end
2189
- end
2190
-
2191
- class ActiveSupport::Reloader < ::ActiveSupport::ExecutionWrapper
2192
- def initialize; end
2193
-
2194
- def _class_unload_callbacks; end
2195
- def _prepare_callbacks; end
2196
- def _run_class_unload_callbacks(&block); end
2197
- def _run_prepare_callbacks(&block); end
2198
- def check; end
2199
- def check=(_arg0); end
2200
- def check?; end
2201
- def class_unload!(&block); end
2202
- def complete!; end
2203
- def executor; end
2204
- def executor=(_arg0); end
2205
- def executor?; end
2206
- def release_unload_lock!; end
2207
- def require_unload_lock!; end
2208
- def run!; end
2209
-
2210
- class << self
2211
- def __callbacks; end
2212
- def _class_unload_callbacks; end
2213
- def _class_unload_callbacks=(value); end
2214
- def _prepare_callbacks; end
2215
- def _prepare_callbacks=(value); end
2216
- def after_class_unload(*args, &block); end
2217
- def before_class_unload(*args, &block); end
2218
- def check; end
2219
- def check!; end
2220
- def check=(value); end
2221
- def check?; end
2222
- def executor; end
2223
- def executor=(value); end
2224
- def executor?; end
2225
- def prepare!; end
2226
- def reload!; end
2227
- def reloaded!; end
2228
- def run!; end
2229
- def to_prepare(*args, &block); end
2230
- def wrap; end
2231
- end
2232
- end
2233
-
2234
- module ActiveSupport::Rescuable
2235
- extend ::ActiveSupport::Concern
2236
-
2237
- mixes_in_class_methods ::ActiveSupport::Rescuable::ClassMethods
2238
-
2239
- def handler_for_rescue(exception); end
2240
- def rescue_with_handler(exception); end
2241
- end
2242
-
2243
- module ActiveSupport::Rescuable::ClassMethods
2244
- def handler_for_rescue(exception, object: T.unsafe(nil)); end
2245
- def rescue_from(*klasses, with: T.unsafe(nil), &block); end
2246
- def rescue_with_handler(exception, object: T.unsafe(nil), visited_exceptions: T.unsafe(nil)); end
2247
-
2248
- private
2249
-
2250
- def constantize_rescue_handler_class(class_or_name); end
2251
- def find_rescue_handler(exception); end
2252
- end
2253
-
2254
- class ActiveSupport::SafeBuffer < ::String
2255
- def initialize(str = T.unsafe(nil)); end
2256
-
2257
- def %(args); end
2258
- def *(*_arg0); end
2259
- def +(other); end
2260
- def <<(value); end
2261
- def [](*args); end
2262
- def []=(*args); end
2263
- def capitalize(*args, &block); end
2264
- def capitalize!(*args); end
2265
- def chomp(*args, &block); end
2266
- def chomp!(*args); end
2267
- def chop(*args, &block); end
2268
- def chop!(*args); end
2269
- def clone_empty; end
2270
- def concat(value); end
2271
- def delete(*args, &block); end
2272
- def delete!(*args); end
2273
- def delete_prefix(*args, &block); end
2274
- def delete_prefix!(*args); end
2275
- def delete_suffix(*args, &block); end
2276
- def delete_suffix!(*args); end
2277
- def downcase(*args, &block); end
2278
- def downcase!(*args); end
2279
- def encode_with(coder); end
2280
- def gsub(*args, &block); end
2281
- def gsub!(*args, &block); end
2282
- def html_safe?; end
2283
- def insert(index, value); end
2284
- def lstrip(*args, &block); end
2285
- def lstrip!(*args); end
2286
- def next(*args, &block); end
2287
- def next!(*args); end
2288
- def prepend(value); end
2289
- def replace(value); end
2290
- def reverse(*args, &block); end
2291
- def reverse!(*args); end
2292
- def rstrip(*args, &block); end
2293
- def rstrip!(*args); end
2294
- def safe_concat(value); end
2295
- def scrub(*args, &block); end
2296
- def scrub!(*args); end
2297
- def slice(*args, &block); end
2298
- def slice!(*args); end
2299
- def squeeze(*args, &block); end
2300
- def squeeze!(*args); end
2301
- def strip(*args, &block); end
2302
- def strip!(*args); end
2303
- def sub(*args, &block); end
2304
- def sub!(*args, &block); end
2305
- def succ(*args, &block); end
2306
- def succ!(*args); end
2307
- def swapcase(*args, &block); end
2308
- def swapcase!(*args); end
2309
- def to_param; end
2310
- def to_s; end
2311
- def tr(*args, &block); end
2312
- def tr!(*args); end
2313
- def tr_s(*args, &block); end
2314
- def tr_s!(*args); end
2315
- def unicode_normalize(*args, &block); end
2316
- def unicode_normalize!(*args); end
2317
- def upcase(*args, &block); end
2318
- def upcase!(*args); end
2319
-
2320
- private
2321
-
2322
- def html_escape_interpolated_argument(arg); end
2323
- def initialize_copy(other); end
2324
- def original_concat(*_arg0); end
2325
- def set_block_back_references(block, match_data); end
2326
- end
2327
-
2328
- class ActiveSupport::SafeBuffer::SafeConcatError < ::StandardError
2329
- def initialize; end
2330
- end
2331
-
2332
- ActiveSupport::SafeBuffer::UNSAFE_STRING_METHODS = T.let(T.unsafe(nil), Array)
2333
- ActiveSupport::SafeBuffer::UNSAFE_STRING_METHODS_WITH_BACKREF = T.let(T.unsafe(nil), Array)
2334
-
2335
- class ActiveSupport::SecureCompareRotator
2336
- include ::ActiveSupport::Messages::Rotator
2337
- include ::ActiveSupport::SecurityUtils
2338
-
2339
- def secure_compare!(other_value, on_rotation: T.unsafe(nil)); end
2340
-
2341
- private
2342
-
2343
- def build_rotation(previous_value, _options); end
2344
- end
2345
-
2346
- class ActiveSupport::SecureCompareRotator::InvalidMatch < ::StandardError; end
2347
-
2348
- module ActiveSupport::SecurityUtils
2349
- private
2350
-
2351
- def fixed_length_secure_compare(a, b); end
2352
- def secure_compare(a, b); end
2353
-
2354
- class << self
2355
- def fixed_length_secure_compare(a, b); end
2356
- def secure_compare(a, b); end
2357
- end
2358
- end
2359
-
2360
- class ActiveSupport::StringInquirer < ::String
2361
- private
2362
-
2363
- def method_missing(method_name, *arguments); end
2364
- def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
2365
- end
2366
-
2367
- class ActiveSupport::Subscriber
2368
- def initialize; end
2369
-
2370
- def finish(name, id, payload); end
2371
- def patterns; end
2372
- def start(name, id, payload); end
2373
-
2374
- private
2375
-
2376
- def event_stack; end
2377
-
2378
- class << self
2379
- def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil), inherit_all: T.unsafe(nil)); end
2380
- def detach_from(namespace, notifier = T.unsafe(nil)); end
2381
- def method_added(event); end
2382
- def subscribers; end
2383
-
2384
- private
2385
-
2386
- def add_event_subscriber(event); end
2387
- def fetch_public_methods(subscriber, inherit_all); end
2388
- def find_attached_subscriber; end
2389
- def invalid_event?(event); end
2390
- def namespace; end
2391
- def notifier; end
2392
- def pattern_subscribed?(pattern); end
2393
- def prepare_pattern(event); end
2394
- def remove_event_subscriber(event); end
2395
- def subscriber; end
2396
- end
2397
- end
2398
-
2399
- class ActiveSupport::SubscriberQueueRegistry
2400
- extend ::ActiveSupport::PerThreadRegistry
2401
-
2402
- def initialize; end
2403
-
2404
- def get_queue(queue_key); end
2405
- end
2406
-
2407
- module ActiveSupport::TaggedLogging
2408
- include ::Lumberjack::TaggedLogging
2409
- extend ::Lumberjack::TaggedLogging::ClassMethods
2410
-
2411
- def clear_tags!(*args, &block); end
2412
- def flush; end
2413
- def pop_tags(*args, &block); end
2414
- def push_tags(*args, &block); end
2415
- def tagged(*tags); end
2416
- end
2417
-
2418
- module ActiveSupport::TaggedLogging::Formatter
2419
- def call(severity, timestamp, progname, msg); end
2420
- def clear_tags!; end
2421
- def current_tags; end
2422
- def pop_tags(size = T.unsafe(nil)); end
2423
- def push_tags(*tags); end
2424
- def tagged(*tags); end
2425
- def tags_text; end
2426
- end
2427
-
2428
- module ActiveSupport::TaggedLogging::LocalTagStorage
2429
- def current_tags; end
2430
- def current_tags=(_arg0); end
2431
-
2432
- class << self
2433
- def extended(base); end
2434
- end
2435
- end
2436
-
2437
- class ActiveSupport::TestCase < ::Minitest::Test
2438
- extend ::ActiveSupport::Testing::Declarative
2439
- include ::ActiveSupport::Testing::TaggedLogging
2440
- include ::ActiveSupport::Callbacks
2441
- include ::ActiveSupport::Testing::Assertions
2442
- include ::ActiveSupport::Testing::Deprecation
2443
- include ::ActiveSupport::Testing::TimeHelpers
2444
- include ::ActiveSupport::Testing::FileFixtures
2445
- extend ::ActiveSupport::Callbacks::ClassMethods
2446
- extend ::ActiveSupport::DescendantsTracker
2447
- extend ::ActiveSupport::Testing::SetupAndTeardown::ClassMethods
2448
- include ::ActiveSupport::Testing::SetupAndTeardown
2449
-
2450
- def __callbacks; end
2451
- def __callbacks?; end
2452
- def _run_setup_callbacks(&block); end
2453
- def _run_teardown_callbacks(&block); end
2454
- def _setup_callbacks; end
2455
- def _teardown_callbacks; end
2456
- def assert_no_match(matcher, obj, msg = T.unsafe(nil)); end
2457
- def assert_not_empty(obj, msg = T.unsafe(nil)); end
2458
- def assert_not_equal(exp, act, msg = T.unsafe(nil)); end
2459
- def assert_not_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
2460
- def assert_not_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
2461
- def assert_not_includes(collection, obj, msg = T.unsafe(nil)); end
2462
- def assert_not_instance_of(cls, obj, msg = T.unsafe(nil)); end
2463
- def assert_not_kind_of(cls, obj, msg = T.unsafe(nil)); end
2464
- def assert_not_nil(obj, msg = T.unsafe(nil)); end
2465
- def assert_not_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
2466
- def assert_not_predicate(o1, op, msg = T.unsafe(nil)); end
2467
- def assert_not_respond_to(obj, meth, msg = T.unsafe(nil)); end
2468
- def assert_not_same(exp, act, msg = T.unsafe(nil)); end
2469
- def assert_raise(*exp); end
2470
- def file_fixture_path; end
2471
- def file_fixture_path?; end
2472
- def method_name; end
2473
-
2474
- class << self
2475
- def __callbacks; end
2476
- def __callbacks=(value); end
2477
- def __callbacks?; end
2478
- def _setup_callbacks; end
2479
- def _setup_callbacks=(value); end
2480
- def _teardown_callbacks; end
2481
- def _teardown_callbacks=(value); end
2482
- def file_fixture_path; end
2483
- def file_fixture_path=(value); end
2484
- def file_fixture_path?; end
2485
- def parallelize(workers: T.unsafe(nil), with: T.unsafe(nil)); end
2486
- def parallelize_setup(&block); end
2487
- def parallelize_teardown(&block); end
2488
- def test_order; end
2489
- def test_order=(new_order); end
2490
- end
2491
- end
2492
-
2493
- ActiveSupport::TestCase::Assertion = Minitest::Assertion
2494
- module ActiveSupport::Testing; end
2495
-
2496
- module ActiveSupport::Testing::Assertions
2497
- def assert_changes(expression, message = T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), &block); end
2498
- def assert_difference(expression, *args, &block); end
2499
- def assert_no_changes(expression, message = T.unsafe(nil), &block); end
2500
- def assert_no_difference(expression, message = T.unsafe(nil), &block); end
2501
- def assert_not(object, message = T.unsafe(nil)); end
2502
- def assert_nothing_raised; end
2503
- end
2504
-
2505
- ActiveSupport::Testing::Assertions::UNTRACKED = T.let(T.unsafe(nil), Object)
2506
-
2507
- module ActiveSupport::Testing::ConstantLookup
2508
- extend ::ActiveSupport::Concern
2509
-
2510
- mixes_in_class_methods ::ActiveSupport::Testing::ConstantLookup::ClassMethods
2511
- end
2512
-
2513
- module ActiveSupport::Testing::ConstantLookup::ClassMethods
2514
- def determine_constant_from_test_name(test_name); end
2515
- end
2516
-
2517
- module ActiveSupport::Testing::Declarative
2518
- def test(name, &block); end
2519
- end
2520
-
2521
- module ActiveSupport::Testing::Deprecation
2522
- def assert_deprecated(match = T.unsafe(nil), deprecator = T.unsafe(nil), &block); end
2523
- def assert_not_deprecated(deprecator = T.unsafe(nil), &block); end
2524
- def collect_deprecations(deprecator = T.unsafe(nil)); end
2525
- end
2526
-
2527
- module ActiveSupport::Testing::FileFixtures
2528
- extend ::ActiveSupport::Concern
2529
-
2530
- def file_fixture(fixture_name); end
2531
- end
2532
-
2533
- module ActiveSupport::Testing::Isolation
2534
- include ::ActiveSupport::Testing::Isolation::Forking
2535
-
2536
- def run; end
2537
-
2538
- class << self
2539
- def forking_env?; end
2540
- def included(klass); end
2541
- end
2542
- end
2543
-
2544
- module ActiveSupport::Testing::Isolation::Forking
2545
- def run_in_isolation(&blk); end
2546
- end
2547
-
2548
- module ActiveSupport::Testing::Isolation::Subprocess
2549
- def run_in_isolation(&blk); end
2550
- end
2551
-
2552
- ActiveSupport::Testing::Isolation::Subprocess::ORIG_ARGV = T.let(T.unsafe(nil), Array)
2553
-
2554
- class ActiveSupport::Testing::Parallelization
2555
- def initialize(worker_count); end
2556
-
2557
- def <<(work); end
2558
- def after_fork_hooks; end
2559
- def run_cleanup_hooks; end
2560
- def shutdown; end
2561
- def start; end
2562
-
2563
- class << self
2564
- def after_fork_hook(&blk); end
2565
- def after_fork_hooks; end
2566
- def run_cleanup_hook(&blk); end
2567
- def run_cleanup_hooks; end
2568
- end
2569
- end
2570
-
2571
- class ActiveSupport::Testing::Parallelization::Server
2572
- include ::DRb::DRbUndumped
2573
-
2574
- def initialize; end
2575
-
2576
- def <<(o); end
2577
- def active_workers?; end
2578
- def pop; end
2579
- def record(reporter, result); end
2580
- def shutdown; end
2581
- def start_worker(worker_id); end
2582
- def stop_worker(worker_id); end
2583
- end
2584
-
2585
- class ActiveSupport::Testing::Parallelization::Worker
2586
- def initialize(number, url); end
2587
-
2588
- def after_fork; end
2589
- def perform_job(job); end
2590
- def run_cleanup; end
2591
- def safe_record(reporter, result); end
2592
- def start; end
2593
- def work_from_queue; end
2594
-
2595
- private
2596
-
2597
- def add_setup_exception(result); end
2598
- def set_process_title(status); end
2599
- end
2600
-
2601
- module ActiveSupport::Testing::SetupAndTeardown
2602
- def after_teardown; end
2603
- def before_setup; end
2604
-
2605
- class << self
2606
- def prepended(klass); end
2607
- end
2608
- end
2609
-
2610
- module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
2611
- def setup(*args, &block); end
2612
- def teardown(*args, &block); end
2613
- end
2614
-
2615
- class ActiveSupport::Testing::SimpleStubs
2616
- def initialize; end
2617
-
2618
- def stub_object(object, method_name, &block); end
2619
- def stubbed?; end
2620
- def stubbing(object, method_name); end
2621
- def unstub_all!; end
2622
-
2623
- private
2624
-
2625
- def unstub_object(stub); end
2626
- end
2627
-
2628
- class ActiveSupport::Testing::SimpleStubs::Stub < ::Struct
2629
- def method_name; end
2630
- def method_name=(_); end
2631
- def object; end
2632
- def object=(_); end
2633
- def original_method; end
2634
- def original_method=(_); end
2635
-
2636
- class << self
2637
- def [](*_arg0); end
2638
- def inspect; end
2639
- def members; end
2640
- def new(*_arg0); end
2641
- end
2642
- end
2643
-
2644
- module ActiveSupport::Testing::TaggedLogging
2645
- def before_setup; end
2646
- def tagged_logger=(_arg0); end
2647
-
2648
- private
2649
-
2650
- def tagged_logger; end
2651
- end
2652
-
2653
- module ActiveSupport::Testing::TimeHelpers
2654
- def after_teardown; end
2655
- def freeze_time(&block); end
2656
- def travel(duration, &block); end
2657
- def travel_back; end
2658
- def travel_to(date_or_time); end
2659
- def unfreeze_time; end
2660
-
2661
- private
2662
-
2663
- def simple_stubs; end
2664
- end
2665
-
2666
- class ActiveSupport::TimeWithZone
2667
- include ::DateAndTime::Compatibility
2668
- include ::Comparable
2669
-
2670
- def initialize(utc_time, time_zone, local_time = T.unsafe(nil), period = T.unsafe(nil)); end
2671
-
2672
- def +(other); end
2673
- def -(other); end
2674
- def <=>(other); end
2675
- def acts_like_time?; end
2676
- def advance(options); end
2677
- def after?(_arg0); end
2678
- def ago(other); end
2679
- def as_json(options = T.unsafe(nil)); end
2680
- def before?(_arg0); end
2681
- def between?(min, max); end
2682
- def blank?; end
2683
- def change(options); end
2684
- def comparable_time; end
2685
- def day; end
2686
- def dst?; end
2687
- def encode_with(coder); end
2688
- def eql?(other); end
2689
- def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
2690
- def freeze; end
2691
- def future?; end
2692
- def getgm; end
2693
- def getlocal(utc_offset = T.unsafe(nil)); end
2694
- def getutc; end
2695
- def gmt?; end
2696
- def gmt_offset; end
2697
- def gmtime; end
2698
- def gmtoff; end
2699
- def hash; end
2700
- def hour; end
2701
- def httpdate; end
2702
- def in(other); end
2703
- def in_time_zone(new_zone = T.unsafe(nil)); end
2704
- def init_with(coder); end
2705
- def inspect; end
2706
- def is_a?(klass); end
2707
- def isdst; end
2708
- def iso8601(fraction_digits = T.unsafe(nil)); end
2709
- def kind_of?(klass); end
2710
- def localtime(utc_offset = T.unsafe(nil)); end
2711
- def marshal_dump; end
2712
- def marshal_load(variables); end
2713
- def mday; end
2714
- def method_missing(sym, *args, &block); end
2715
- def min; end
2716
- def mon; end
2717
- def month; end
2718
- def next_day?; end
2719
- def nsec; end
2720
- def past?; end
2721
- def period; end
2722
- def prev_day?; end
2723
- def respond_to?(sym, include_priv = T.unsafe(nil)); end
2724
- def rfc2822; end
2725
- def rfc3339(fraction_digits = T.unsafe(nil)); end
2726
- def rfc822; end
2727
- def sec; end
2728
- def since(other); end
2729
- def strftime(format); end
2730
- def time; end
2731
- def time_zone; end
2732
- def to_a; end
2733
- def to_date; end
2734
- def to_datetime; end
2735
- def to_f; end
2736
- def to_formatted_s(format = T.unsafe(nil)); end
2737
- def to_i; end
2738
- def to_r; end
2739
- def to_s(format = T.unsafe(nil)); end
2740
- def to_time; end
2741
- def today?; end
2742
- def tomorrow?; end
2743
- def tv_sec; end
2744
- def usec; end
2745
- def utc; end
2746
- def utc?; end
2747
- def utc_offset; end
2748
- def wday; end
2749
- def xmlschema(fraction_digits = T.unsafe(nil)); end
2750
- def yday; end
2751
- def year; end
2752
- def yesterday?; end
2753
- def zone; end
2754
-
2755
- private
2756
-
2757
- def duration_of_variable_length?(obj); end
2758
- def get_period_and_ensure_valid_local_time(period); end
2759
- def incorporate_utc_offset(time, offset); end
2760
- def respond_to_missing?(sym, include_priv); end
2761
- def transfer_time_values_to_utc_constructor(time); end
2762
- def wrap_with_time_zone(time); end
2763
-
2764
- class << self
2765
- def name; end
2766
- end
2767
- end
2768
-
2769
- ActiveSupport::TimeWithZone::PRECISIONS = T.let(T.unsafe(nil), Hash)
2770
- ActiveSupport::TimeWithZone::SECONDS_PER_DAY = T.let(T.unsafe(nil), Integer)
2771
-
2772
- class ActiveSupport::TimeZone
2773
- include ::Comparable
2774
-
2775
- def initialize(name, utc_offset = T.unsafe(nil), tzinfo = T.unsafe(nil)); end
2776
-
2777
- def <=>(zone); end
2778
- def =~(re); end
2779
- def at(*args); end
2780
- def encode_with(coder); end
2781
- def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
2782
- def init_with(coder); end
2783
- def iso8601(str); end
2784
- def local(*args); end
2785
- def local_to_utc(time, dst = T.unsafe(nil)); end
2786
- def match?(re); end
2787
- def name; end
2788
- def now; end
2789
- def parse(str, now = T.unsafe(nil)); end
2790
- def period_for_local(time, dst = T.unsafe(nil)); end
2791
- def period_for_utc(time); end
2792
- def periods_for_local(time); end
2793
- def rfc3339(str); end
2794
- def strptime(str, format, now = T.unsafe(nil)); end
2795
- def to_s; end
2796
- def today; end
2797
- def tomorrow; end
2798
- def tzinfo; end
2799
- def utc_offset; end
2800
- def utc_to_local(time); end
2801
- def yesterday; end
2802
-
2803
- private
2804
-
2805
- def parts_to_time(parts, now); end
2806
- def time_now; end
2807
-
2808
- class << self
2809
- def [](arg); end
2810
- def all; end
2811
- def clear; end
2812
- def country_zones(country_code); end
2813
- def create(*_arg0); end
2814
- def find_tzinfo(name); end
2815
- def new(name); end
2816
- def seconds_to_utc_offset(seconds, colon = T.unsafe(nil)); end
2817
- def us_zones; end
2818
-
2819
- private
2820
-
2821
- def load_country_zones(code); end
2822
- def zones_map; end
2823
- end
2824
- end
2825
-
2826
- ActiveSupport::TimeZone::MAPPING = T.let(T.unsafe(nil), Hash)
2827
- ActiveSupport::TimeZone::UTC_OFFSET_WITHOUT_COLON = T.let(T.unsafe(nil), String)
2828
- ActiveSupport::TimeZone::UTC_OFFSET_WITH_COLON = T.let(T.unsafe(nil), String)
2829
-
2830
- module ActiveSupport::ToJsonWithActiveSupportEncoder
2831
- def to_json(options = T.unsafe(nil)); end
2832
- end
2833
-
2834
- module ActiveSupport::Tryable
2835
- def try(method_name = T.unsafe(nil), *args, &b); end
2836
- def try!(method_name = T.unsafe(nil), *args, &b); end
2837
- end
2838
-
2839
- module ActiveSupport::VERSION; end
2840
- ActiveSupport::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
2841
- ActiveSupport::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
2842
- ActiveSupport::VERSION::STRING = T.let(T.unsafe(nil), String)
2843
- ActiveSupport::VERSION::TINY = T.let(T.unsafe(nil), Integer)
2844
-
2845
- class ActiveSupport::XMLConverter
2846
- def initialize(xml, disallowed_types = T.unsafe(nil)); end
2847
-
2848
- def to_h; end
2849
-
2850
- private
2851
-
2852
- def become_array?(value); end
2853
- def become_content?(value); end
2854
- def become_empty_string?(value); end
2855
- def become_hash?(value); end
2856
- def deep_to_h(value); end
2857
- def garbage?(value); end
2858
- def normalize_keys(params); end
2859
- def nothing?(value); end
2860
- def process_array(value); end
2861
- def process_content(value); end
2862
- def process_hash(value); end
2863
- end
2864
-
2865
- ActiveSupport::XMLConverter::DISALLOWED_TYPES = T.let(T.unsafe(nil), Array)
2866
-
2867
- class ActiveSupport::XMLConverter::DisallowedType < ::StandardError
2868
- def initialize(type); end
2869
- end
2870
-
2871
- module ActiveSupport::XmlMini
2872
- extend ::ActiveSupport::XmlMini
2873
-
2874
- def backend; end
2875
- def backend=(name); end
2876
- def depth; end
2877
- def depth=(_arg0); end
2878
- def parse(*args, &block); end
2879
- def rename_key(key, options = T.unsafe(nil)); end
2880
- def to_tag(key, value, options); end
2881
- def with_backend(name); end
2882
-
2883
- private
2884
-
2885
- def _dasherize(key); end
2886
- def _parse_binary(bin, entity); end
2887
- def _parse_file(file, entity); end
2888
- def cast_backend_name_to_module(name); end
2889
- def current_thread_backend; end
2890
- def current_thread_backend=(name); end
2891
- end
2892
-
2893
- ActiveSupport::XmlMini::DEFAULT_ENCODINGS = T.let(T.unsafe(nil), Hash)
2894
- ActiveSupport::XmlMini::FORMATTING = T.let(T.unsafe(nil), Hash)
2895
-
2896
- module ActiveSupport::XmlMini::FileLike
2897
- def content_type; end
2898
- def content_type=(_arg0); end
2899
- def original_filename; end
2900
- def original_filename=(_arg0); end
2901
- end
2902
-
2903
- ActiveSupport::XmlMini::PARSING = T.let(T.unsafe(nil), Hash)
2904
- ActiveSupport::XmlMini::TYPE_NAMES = T.let(T.unsafe(nil), Hash)
2905
-
2906
- module ActiveSupport::XmlMini_REXML
2907
- extend ::ActiveSupport::XmlMini_REXML
2908
-
2909
- def parse(data); end
2910
-
2911
- private
2912
-
2913
- def collapse(element, depth); end
2914
- def empty_content?(element); end
2915
- def get_attributes(element); end
2916
- def merge!(hash, key, value); end
2917
- def merge_element!(hash, element, depth); end
2918
- def merge_texts!(hash, element); end
2919
- def require_rexml; end
2920
- end
2921
-
2922
- ActiveSupport::XmlMini_REXML::CONTENT_KEY = T.let(T.unsafe(nil), String)
2923
-
2924
- class Array
2925
- include ::Enumerable
2926
- include ::JSON::Ext::Generator::GeneratorMethods::Array
2927
-
2928
- def as_json(options = T.unsafe(nil)); end
2929
- def compact_blank!; end
2930
- def deep_dup; end
2931
- def excluding(*elements); end
2932
- def extract_options!; end
2933
- def fifth; end
2934
- def forty_two; end
2935
- def fourth; end
2936
- def from(position); end
2937
- def including(*elements); end
2938
- def second; end
2939
- def second_to_last; end
2940
- def sum(init = T.unsafe(nil), &block); end
2941
- def third; end
2942
- def third_to_last; end
2943
- def to(position); end
2944
- def to_formatted_s(format = T.unsafe(nil)); end
2945
- def to_param; end
2946
- def to_query(key); end
2947
- def to_s(format = T.unsafe(nil)); end
2948
- def to_sentence(options = T.unsafe(nil)); end
2949
- def to_xml(options = T.unsafe(nil)); end
2950
- def without(*elements); end
2951
-
2952
- class << self
2953
- def wrap(object); end
2954
- end
2955
- end
2956
-
2957
- class BigDecimal < ::Numeric
2958
- include ::ActiveSupport::BigDecimalWithDefaultFormat
2959
-
2960
- def as_json(options = T.unsafe(nil)); end
2961
- end
2962
-
2963
- BigDecimal::EXCEPTION_NaN = T.let(T.unsafe(nil), Integer)
2964
- BigDecimal::VERSION = T.let(T.unsafe(nil), String)
2965
-
2966
- class Class < ::Module
2967
- def class_attribute(*attrs, instance_accessor: T.unsafe(nil), instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_predicate: T.unsafe(nil), default: T.unsafe(nil)); end
2968
- def descendants; end
2969
- def subclasses; end
2970
- end
2971
-
2972
- class Date
2973
- include ::Comparable
2974
- include ::DateAndTime::Zones
2975
- include ::DateAndTime::Calculations
2976
-
2977
- def +(other); end
2978
- def -(other); end
2979
- def <=>(other); end
2980
- def acts_like_date?; end
2981
- def advance(options); end
2982
- def ago(seconds); end
2983
- def as_json(options = T.unsafe(nil)); end
2984
- def at_beginning_of_day; end
2985
- def at_end_of_day; end
2986
- def at_midday; end
2987
- def at_middle_of_day; end
2988
- def at_midnight; end
2989
- def at_noon; end
2990
- def beginning_of_day; end
2991
- def change(options); end
2992
- def compare_with_coercion(other); end
2993
- def end_of_day; end
2994
- def in(seconds); end
2995
- def inspect; end
2996
- def midday; end
2997
- def middle_of_day; end
2998
- def midnight; end
2999
- def minus_with_duration(other); end
3000
- def noon; end
3001
- def plus_with_duration(other); end
3002
- def readable_inspect; end
3003
- def since(seconds); end
3004
- def to_formatted_s(format = T.unsafe(nil)); end
3005
- def to_s(format = T.unsafe(nil)); end
3006
- def to_time(form = T.unsafe(nil)); end
3007
- def xmlschema; end
3008
-
3009
- class << self
3010
- def beginning_of_week; end
3011
- def beginning_of_week=(week_start); end
3012
- def beginning_of_week_default; end
3013
- def beginning_of_week_default=(_arg0); end
3014
- def current; end
3015
- def find_beginning_of_week!(week_start); end
3016
- def tomorrow; end
3017
- def yesterday; end
3018
- end
3019
- end
3020
-
3021
- Date::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
3022
- module DateAndTime; end
3023
-
3024
- module DateAndTime::Calculations
3025
- def after?(date_or_time); end
3026
- def all_day; end
3027
- def all_month; end
3028
- def all_quarter; end
3029
- def all_week(start_day = T.unsafe(nil)); end
3030
- def all_year; end
3031
- def at_beginning_of_month; end
3032
- def at_beginning_of_quarter; end
3033
- def at_beginning_of_week(start_day = T.unsafe(nil)); end
3034
- def at_beginning_of_year; end
3035
- def at_end_of_month; end
3036
- def at_end_of_quarter; end
3037
- def at_end_of_week(start_day = T.unsafe(nil)); end
3038
- def at_end_of_year; end
3039
- def before?(date_or_time); end
3040
- def beginning_of_month; end
3041
- def beginning_of_quarter; end
3042
- def beginning_of_week(start_day = T.unsafe(nil)); end
3043
- def beginning_of_year; end
3044
- def days_ago(days); end
3045
- def days_since(days); end
3046
- def days_to_week_start(start_day = T.unsafe(nil)); end
3047
- def end_of_month; end
3048
- def end_of_quarter; end
3049
- def end_of_week(start_day = T.unsafe(nil)); end
3050
- def end_of_year; end
3051
- def future?; end
3052
- def last_month; end
3053
- def last_quarter; end
3054
- def last_week(start_day = T.unsafe(nil), same_time: T.unsafe(nil)); end
3055
- def last_weekday; end
3056
- def last_year; end
3057
- def monday; end
3058
- def months_ago(months); end
3059
- def months_since(months); end
3060
- def next_day?; end
3061
- def next_occurring(day_of_week); end
3062
- def next_quarter; end
3063
- def next_week(given_day_in_next_week = T.unsafe(nil), same_time: T.unsafe(nil)); end
3064
- def next_weekday; end
3065
- def on_weekday?; end
3066
- def on_weekend?; end
3067
- def past?; end
3068
- def prev_day?; end
3069
- def prev_occurring(day_of_week); end
3070
- def prev_quarter; end
3071
- def prev_week(start_day = T.unsafe(nil), same_time: T.unsafe(nil)); end
3072
- def prev_weekday; end
3073
- def sunday; end
3074
- def today?; end
3075
- def tomorrow; end
3076
- def tomorrow?; end
3077
- def weeks_ago(weeks); end
3078
- def weeks_since(weeks); end
3079
- def years_ago(years); end
3080
- def years_since(years); end
3081
- def yesterday; end
3082
- def yesterday?; end
3083
-
3084
- private
3085
-
3086
- def copy_time_to(other); end
3087
- def days_span(day); end
3088
- def first_hour(date_or_time); end
3089
- def last_hour(date_or_time); end
3090
- end
3091
-
3092
- DateAndTime::Calculations::DAYS_INTO_WEEK = T.let(T.unsafe(nil), Hash)
3093
- DateAndTime::Calculations::WEEKEND_DAYS = T.let(T.unsafe(nil), Array)
3094
-
3095
- module DateAndTime::Compatibility
3096
- def preserve_timezone; end
3097
- def utc_to_local_returns_utc_offset_times; end
3098
-
3099
- class << self
3100
- def preserve_timezone; end
3101
- def preserve_timezone=(val); end
3102
- def utc_to_local_returns_utc_offset_times; end
3103
- def utc_to_local_returns_utc_offset_times=(val); end
3104
- end
3105
- end
3106
-
3107
- module DateAndTime::Zones
3108
- def in_time_zone(zone = T.unsafe(nil)); end
3109
-
3110
- private
3111
-
3112
- def time_with_zone(time, zone); end
3113
- end
3114
-
3115
- class DateTime < ::Date
3116
- def <=>(other); end
3117
- def advance(options); end
3118
- def ago(seconds); end
3119
- def as_json(options = T.unsafe(nil)); end
3120
- def at_beginning_of_day; end
3121
- def at_beginning_of_hour; end
3122
- def at_beginning_of_minute; end
3123
- def at_end_of_day; end
3124
- def at_end_of_hour; end
3125
- def at_end_of_minute; end
3126
- def at_midday; end
3127
- def at_middle_of_day; end
3128
- def at_midnight; end
3129
- def at_noon; end
3130
- def beginning_of_day; end
3131
- def beginning_of_hour; end
3132
- def beginning_of_minute; end
3133
- def change(options); end
3134
- def end_of_day; end
3135
- def end_of_hour; end
3136
- def end_of_minute; end
3137
- def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
3138
- def getgm; end
3139
- def getlocal(utc_offset = T.unsafe(nil)); end
3140
- def getutc; end
3141
- def gmtime; end
3142
- def in(seconds); end
3143
- def inspect; end
3144
- def localtime(utc_offset = T.unsafe(nil)); end
3145
- def midday; end
3146
- def middle_of_day; end
3147
- def midnight; end
3148
- def noon; end
3149
- def nsec; end
3150
- def readable_inspect; end
3151
- def seconds_since_midnight; end
3152
- def seconds_until_end_of_day; end
3153
- def since(seconds); end
3154
- def subsec; end
3155
- def to_f; end
3156
- def to_formatted_s(format = T.unsafe(nil)); end
3157
- def to_i; end
3158
- def to_s(format = T.unsafe(nil)); end
3159
- def usec; end
3160
- def utc; end
3161
- def utc?; end
3162
- def utc_offset; end
3163
-
3164
- private
3165
-
3166
- def offset_in_seconds; end
3167
- def seconds_since_unix_epoch; end
3168
-
3169
- class << self
3170
- def civil_from_format(utc_or_local, year, month = T.unsafe(nil), day = T.unsafe(nil), hour = T.unsafe(nil), min = T.unsafe(nil), sec = T.unsafe(nil)); end
3171
- def current; end
3172
- end
3173
- end
3174
-
3175
- module ERB::Util
3176
- private
3177
-
3178
- def h(s); end
3179
- def html_escape(s); end
3180
- def html_escape_once(s); end
3181
- def json_escape(s); end
3182
- def unwrapped_html_escape(s); end
3183
-
3184
- class << self
3185
- def h(s); end
3186
- def html_escape(s); end
3187
- def html_escape_once(s); end
3188
- def json_escape(s); end
3189
- def unwrapped_html_escape(s); end
3190
- end
3191
- end
3192
-
3193
- ERB::Util::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
3194
- ERB::Util::HTML_ESCAPE_ONCE_REGEXP = T.let(T.unsafe(nil), Regexp)
3195
- ERB::Util::JSON_ESCAPE = T.let(T.unsafe(nil), Hash)
3196
- ERB::Util::JSON_ESCAPE_REGEXP = T.let(T.unsafe(nil), Regexp)
3197
-
3198
- module Enumerable
3199
- def as_json(options = T.unsafe(nil)); end
3200
- def compact_blank; end
3201
- def exclude?(object); end
3202
- def excluding(*elements); end
3203
- def including(*elements); end
3204
- def index_by; end
3205
- def index_with(default = T.unsafe(nil)); end
3206
- def many?; end
3207
- def pick(*keys); end
3208
- def pluck(*keys); end
3209
- def sum(identity = T.unsafe(nil), &block); end
3210
- def without(*elements); end
3211
- end
3212
-
3213
- Enumerable::INDEX_WITH_DEFAULT = T.let(T.unsafe(nil), Object)
3214
-
3215
- class Exception
3216
- include ::ActiveSupport::Dependencies::Blamable
3217
-
3218
- def as_json(options = T.unsafe(nil)); end
3219
- end
3220
-
3221
- class FalseClass
3222
- include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
3223
- include ::SafeType::BooleanMixin
3224
-
3225
- def as_json(options = T.unsafe(nil)); end
3226
- def blank?; end
3227
- def to_param; end
3228
- end
3229
-
3230
- class Float < ::Numeric
3231
- include ::JSON::Ext::Generator::GeneratorMethods::Float
3232
-
3233
- def as_json(options = T.unsafe(nil)); end
3234
- end
3235
-
3236
- class Hash
3237
- include ::Enumerable
3238
- include ::JSON::Ext::Generator::GeneratorMethods::Hash
3239
-
3240
- def as_json(options = T.unsafe(nil)); end
3241
- def assert_valid_keys(*valid_keys); end
3242
- def compact_blank; end
3243
- def compact_blank!; end
3244
- def deep_dup; end
3245
- def deep_merge(other_hash, &block); end
3246
- def deep_merge!(other_hash, &block); end
3247
- def deep_stringify_keys; end
3248
- def deep_stringify_keys!; end
3249
- def deep_symbolize_keys; end
3250
- def deep_symbolize_keys!; end
3251
- def deep_transform_keys(&block); end
3252
- def deep_transform_keys!(&block); end
3253
- def except(*keys); end
3254
- def except!(*keys); end
3255
- def extract!(*keys); end
3256
- def extractable_options?; end
3257
- def nested_under_indifferent_access; end
3258
- def reverse_merge(other_hash); end
3259
- def reverse_merge!(other_hash); end
3260
- def reverse_update(other_hash); end
3261
- def slice!(*keys); end
3262
- def stringify_keys; end
3263
- def stringify_keys!; end
3264
- def symbolize_keys; end
3265
- def symbolize_keys!; end
3266
- def to_options; end
3267
- def to_options!; end
3268
- def to_param(namespace = T.unsafe(nil)); end
3269
- def to_query(namespace = T.unsafe(nil)); end
3270
- def to_xml(options = T.unsafe(nil)); end
3271
- def with_defaults(other_hash); end
3272
- def with_defaults!(other_hash); end
3273
- def with_indifferent_access; end
3274
-
3275
- private
3276
-
3277
- def _deep_transform_keys_in_object(object, &block); end
3278
- def _deep_transform_keys_in_object!(object, &block); end
3279
-
3280
- class << self
3281
- def from_trusted_xml(xml); end
3282
- def from_xml(xml, disallowed_types = T.unsafe(nil)); end
3283
- end
3284
- end
3285
-
3286
- HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
3287
-
3288
- class IO
3289
- include ::Enumerable
3290
- include ::File::Constants
3291
-
3292
- def as_json(options = T.unsafe(nil)); end
3293
- end
3294
-
3295
- class IO::ConsoleMode
3296
- def echo=(_arg0); end
3297
- def raw(*_arg0); end
3298
- def raw!(*_arg0); end
3299
-
3300
- private
3301
-
3302
- def initialize_copy(_arg0); end
3303
- end
3304
-
3305
- class IO::EAGAINWaitReadable < ::Errno::EAGAIN
3306
- include ::IO::WaitReadable
3307
- end
3308
-
3309
- class IO::EAGAINWaitWritable < ::Errno::EAGAIN
3310
- include ::IO::WaitWritable
3311
- end
3312
-
3313
- class IO::EINPROGRESSWaitReadable < ::Errno::EINPROGRESS
3314
- include ::IO::WaitReadable
3315
- end
3316
-
3317
- class IO::EINPROGRESSWaitWritable < ::Errno::EINPROGRESS
3318
- include ::IO::WaitWritable
3319
- end
3320
-
3321
- IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
3322
- IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
3323
-
3324
- class IPAddr
3325
- include ::Comparable
3326
-
3327
- def as_json(options = T.unsafe(nil)); end
3328
- end
3329
-
3330
- class Integer < ::Numeric
3331
- include ::JSON::Ext::Generator::GeneratorMethods::Integer
3332
-
3333
- def month; end
3334
- def months; end
3335
- def year; end
3336
- def years; end
3337
- end
3338
-
3339
- module Kernel
3340
- private
3341
-
3342
- def enable_warnings; end
3343
- def silence_warnings; end
3344
- def suppress(*exception_classes); end
3345
- def with_warnings(flag); end
3346
-
3347
- class << self
3348
- def enable_warnings; end
3349
- def silence_warnings; end
3350
- def suppress(*exception_classes); end
3351
- def with_warnings(flag); end
3352
- end
3353
- end
3354
-
3355
- class LoadError < ::ScriptError
3356
- def is_missing?(location); end
3357
- end
3358
-
3359
- class Method
3360
- def duplicable?; end
3361
- end
3362
-
3363
- class Module
3364
- include ::ActiveSupport::Dependencies::ModuleConstMissing
3365
- include ::Module::Concerning
3366
-
3367
- def alias_attribute(new_name, old_name); end
3368
- def anonymous?; end
3369
- def attr_internal(*attrs); end
3370
- def attr_internal_accessor(*attrs); end
3371
- def attr_internal_reader(*attrs); end
3372
- def attr_internal_writer(*attrs); end
3373
- def cattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
3374
- def cattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
3375
- def cattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
3376
- def delegate(*methods, to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), private: T.unsafe(nil)); end
3377
- def delegate_missing_to(target, allow_nil: T.unsafe(nil)); end
3378
- def deprecate(*method_names); end
3379
- def mattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
3380
- def mattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
3381
- def mattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
3382
- def method_visibility(method); end
3383
- def module_parent; end
3384
- def module_parent_name; end
3385
- def module_parents; end
3386
- def redefine_method(method, &block); end
3387
- def redefine_singleton_method(method, &block); end
3388
- def remove_possible_method(method); end
3389
- def remove_possible_singleton_method(method); end
3390
- def silence_redefinition_of_method(method); end
3391
- def thread_cattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil)); end
3392
- def thread_cattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil)); end
3393
- def thread_cattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil)); end
3394
- def thread_mattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil)); end
3395
- def thread_mattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil)); end
3396
- def thread_mattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil)); end
3397
-
3398
- private
3399
-
3400
- def attr_internal_define(attr_name, type); end
3401
- def attr_internal_ivar_name(attr); end
3402
-
3403
- class << self
3404
- def attr_internal_naming_format; end
3405
- def attr_internal_naming_format=(_arg0); end
3406
- end
3407
- end
3408
-
3409
- module Module::Concerning
3410
- def concern(topic, &module_definition); end
3411
- def concerning(topic, prepend: T.unsafe(nil), &block); end
3412
- end
3413
-
3414
- Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
3415
- Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
3416
- class Module::DelegationError < ::NoMethodError; end
3417
- Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
3418
-
3419
- class NameError < ::StandardError
3420
- include ::DidYouMean::Correctable
3421
-
3422
- def missing_name; end
3423
- def missing_name?(name); end
3424
-
3425
- private
3426
-
3427
- def real_mod_name(mod); end
3428
- end
3429
-
3430
- NameError::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
3431
-
3432
- class NilClass
3433
- include ::JSON::Ext::Generator::GeneratorMethods::NilClass
3434
-
3435
- def as_json(options = T.unsafe(nil)); end
3436
- def blank?; end
3437
- def to_param; end
3438
- def try(_method_name = T.unsafe(nil), *_arg1); end
3439
- def try!(_method_name = T.unsafe(nil), *_arg1); end
3440
- end
3441
-
3442
- class Numeric
3443
- include ::Comparable
3444
-
3445
- def as_json(options = T.unsafe(nil)); end
3446
- def blank?; end
3447
- def byte; end
3448
- def bytes; end
3449
- def day; end
3450
- def days; end
3451
- def exabyte; end
3452
- def exabytes; end
3453
- def fortnight; end
3454
- def fortnights; end
3455
- def gigabyte; end
3456
- def gigabytes; end
3457
- def hour; end
3458
- def hours; end
3459
- def html_safe?; end
3460
- def in_milliseconds; end
3461
- def kilobyte; end
3462
- def kilobytes; end
3463
- def megabyte; end
3464
- def megabytes; end
3465
- def minute; end
3466
- def minutes; end
3467
- def petabyte; end
3468
- def petabytes; end
3469
- def second; end
3470
- def seconds; end
3471
- def terabyte; end
3472
- def terabytes; end
3473
- def week; end
3474
- def weeks; end
3475
- end
3476
-
3477
- Numeric::EXABYTE = T.let(T.unsafe(nil), Integer)
3478
- Numeric::GIGABYTE = T.let(T.unsafe(nil), Integer)
3479
- Numeric::KILOBYTE = T.let(T.unsafe(nil), Integer)
3480
- Numeric::MEGABYTE = T.let(T.unsafe(nil), Integer)
3481
- Numeric::PETABYTE = T.let(T.unsafe(nil), Integer)
3482
- Numeric::TERABYTE = T.let(T.unsafe(nil), Integer)
3483
-
3484
- class Object < ::BasicObject
3485
- include ::ActiveSupport::Dependencies::Loadable
3486
- include ::ActiveSupport::ForkTracker::CoreExt
3487
- include ::ActiveSupport::ForkTracker::CoreExtPrivate
3488
- include ::Kernel
3489
- include ::JSON::Ext::Generator::GeneratorMethods::Object
3490
- include ::ActiveSupport::Tryable
3491
- include ::PP::ObjectMixin
3492
- include ::ActiveSupport::ToJsonWithActiveSupportEncoder
3493
-
3494
- def acts_like?(duck); end
3495
- def as_json(options = T.unsafe(nil)); end
3496
- def blank?; end
3497
- def deep_dup; end
3498
- def duplicable?; end
3499
- def html_safe?; end
3500
- def in?(another_object); end
3501
- def instance_values; end
3502
- def instance_variable_names; end
3503
- def presence; end
3504
- def presence_in(another_object); end
3505
- def present?; end
3506
- def to_param; end
3507
- def to_query(key); end
3508
- def with_options(options, &block); end
3509
- end
3510
-
3511
- class Pathname
3512
- def as_json(options = T.unsafe(nil)); end
3513
- end
3514
-
3515
- class Process::Status
3516
- def as_json(options = T.unsafe(nil)); end
3517
- end
3518
-
3519
- class Range
3520
- include ::Enumerable
3521
-
3522
- def as_json(options = T.unsafe(nil)); end
3523
- def sum(identity = T.unsafe(nil)); end
3524
- end
3525
-
3526
- class Regexp
3527
- def as_json(options = T.unsafe(nil)); end
3528
- def multiline?; end
3529
- end
3530
-
3531
- Regexp::ENC_EUC = T.let(T.unsafe(nil), Integer)
3532
- Regexp::ENC_NONE = T.let(T.unsafe(nil), Integer)
3533
- Regexp::ENC_SJIS = T.let(T.unsafe(nil), Integer)
3534
- Regexp::ENC_UTF8 = T.let(T.unsafe(nil), Integer)
3535
- Regexp::ONCE = T.let(T.unsafe(nil), Integer)
3536
- Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
3537
-
3538
- class Regexp::Token < ::Struct
3539
- def conditional_level; end
3540
- def conditional_level=(_); end
3541
- def length; end
3542
- def level; end
3543
- def level=(_); end
3544
- def next; end
3545
- def next=(_arg0); end
3546
- def offset; end
3547
- def previous; end
3548
- def previous=(_arg0); end
3549
- def set_level; end
3550
- def set_level=(_); end
3551
- def te; end
3552
- def te=(_); end
3553
- def text; end
3554
- def text=(_); end
3555
- def token; end
3556
- def token=(_); end
3557
- def ts; end
3558
- def ts=(_); end
3559
- def type; end
3560
- def type=(_); end
3561
-
3562
- class << self
3563
- def [](*_arg0); end
3564
- def inspect; end
3565
- def members; end
3566
- def new(*_arg0); end
3567
- end
3568
- end
3569
-
3570
- class String
3571
- include ::Comparable
3572
- include ::JSON::Ext::Generator::GeneratorMethods::String
3573
- include ::Colorize::InstanceMethods
3574
- extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
3575
- extend ::Colorize::ClassMethods
3576
-
3577
- def acts_like_string?; end
3578
- def as_json(options = T.unsafe(nil)); end
3579
- def at(position); end
3580
- def blank?; end
3581
- def camelcase(first_letter = T.unsafe(nil)); end
3582
- def camelize(first_letter = T.unsafe(nil)); end
3583
- def classify; end
3584
- def constantize; end
3585
- def dasherize; end
3586
- def deconstantize; end
3587
- def demodulize; end
3588
- def first(limit = T.unsafe(nil)); end
3589
- def foreign_key(separate_class_name_and_id_with_underscore = T.unsafe(nil)); end
3590
- def from(position); end
3591
- def html_safe; end
3592
- def humanize(capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
3593
- def is_utf8?; end
3594
- def last(limit = T.unsafe(nil)); end
3595
- def mb_chars; end
3596
- def parameterize(separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end
3597
- def pluralize(count = T.unsafe(nil), locale = T.unsafe(nil)); end
3598
- def remove(*patterns); end
3599
- def remove!(*patterns); end
3600
- def safe_constantize; end
3601
- def singularize(locale = T.unsafe(nil)); end
3602
- def squish; end
3603
- def squish!; end
3604
- def tableize; end
3605
- def titlecase(keep_id_suffix: T.unsafe(nil)); end
3606
- def titleize(keep_id_suffix: T.unsafe(nil)); end
3607
- def to(position); end
3608
- def to_date; end
3609
- def to_datetime; end
3610
- def to_time(form = T.unsafe(nil)); end
3611
- def truncate(truncate_at, options = T.unsafe(nil)); end
3612
- def truncate_bytes(truncate_at, omission: T.unsafe(nil)); end
3613
- def truncate_words(words_count, options = T.unsafe(nil)); end
3614
-
3615
- sig { returns(String) }
3616
- def underscore; end
3617
-
3618
- def upcase_first; end
3619
- end
3620
-
3621
- String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
3622
- String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
3623
-
3624
- class Struct
3625
- include ::Enumerable
3626
-
3627
- def as_json(options = T.unsafe(nil)); end
3628
- end
3629
-
3630
- Struct::CompletionJourneyData = Struct
3631
- Struct::Group = Etc::Group
3632
- Struct::HTMLElementDescription = Struct
3633
- Struct::Key = Struct
3634
- Struct::MenuInfo = Struct
3635
- Struct::Passwd = Etc::Passwd
3636
- Struct::Tms = Process::Tms
3637
-
3638
- class Symbol
3639
- include ::Comparable
3640
-
3641
- def as_json(options = T.unsafe(nil)); end
3642
- def end_with?(*suffixes); end
3643
- def ends_with?(*suffixes); end
3644
- def start_with?(*prefixes); end
3645
- def starts_with?(*prefixes); end
3646
- end
3647
-
3648
- class Time
3649
- include ::Comparable
3650
- include ::DateAndTime::Zones
3651
- include ::DateAndTime::Calculations
3652
-
3653
- def +(other); end
3654
- def -(other); end
3655
- def <=>(other); end
3656
- def acts_like_time?; end
3657
- def advance(options); end
3658
- def ago(seconds); end
3659
- def as_json(options = T.unsafe(nil)); end
3660
- def at_beginning_of_day; end
3661
- def at_beginning_of_hour; end
3662
- def at_beginning_of_minute; end
3663
- def at_end_of_day; end
3664
- def at_end_of_hour; end
3665
- def at_end_of_minute; end
3666
- def at_midday; end
3667
- def at_middle_of_day; end
3668
- def at_midnight; end
3669
- def at_noon; end
3670
- def beginning_of_day; end
3671
- def beginning_of_hour; end
3672
- def beginning_of_minute; end
3673
- def blank?; end
3674
- def ceil(precision = T.unsafe(nil)); end
3675
- def change(options); end
3676
- def compare_with_coercion(other); end
3677
- def end_of_day; end
3678
- def end_of_hour; end
3679
- def end_of_minute; end
3680
- def eql?(other); end
3681
- def eql_with_coercion(other); end
3682
- def floor(precision = T.unsafe(nil)); end
3683
- def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
3684
- def in(seconds); end
3685
- def midday; end
3686
- def middle_of_day; end
3687
- def midnight; end
3688
- def minus_with_coercion(other); end
3689
- def minus_with_duration(other); end
3690
- def minus_without_coercion(other); end
3691
- def next_day(days = T.unsafe(nil)); end
3692
- def next_month(months = T.unsafe(nil)); end
3693
- def next_year(years = T.unsafe(nil)); end
3694
- def noon; end
3695
- def plus_with_duration(other); end
3696
- def prev_day(days = T.unsafe(nil)); end
3697
- def prev_month(months = T.unsafe(nil)); end
3698
- def prev_year(years = T.unsafe(nil)); end
3699
- def sec_fraction; end
3700
- def seconds_since_midnight; end
3701
- def seconds_until_end_of_day; end
3702
- def since(seconds); end
3703
- def to_formatted_s(format = T.unsafe(nil)); end
3704
- def to_s(format = T.unsafe(nil)); end
3705
-
3706
- class << self
3707
- def ===(other); end
3708
- def at(*args); end
3709
- def at_with_coercion(*args); end
3710
- def current; end
3711
- def days_in_month(month, year = T.unsafe(nil)); end
3712
- def days_in_year(year = T.unsafe(nil)); end
3713
- def find_zone(time_zone); end
3714
- def find_zone!(time_zone); end
3715
- def rfc3339(str); end
3716
- def use_zone(time_zone); end
3717
- def zone; end
3718
- def zone=(time_zone); end
3719
- def zone_default; end
3720
- def zone_default=(_arg0); end
3721
- end
3722
- end
3723
-
3724
- Time::COMMON_YEAR_DAYS_IN_MONTH = T.let(T.unsafe(nil), Array)
3725
- Time::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
3726
-
3727
- class TrueClass
3728
- include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
3729
- include ::SafeType::BooleanMixin
3730
-
3731
- def as_json(options = T.unsafe(nil)); end
3732
- def blank?; end
3733
- def to_param; end
3734
- end
3735
-
3736
- module URI
3737
- include ::URI::RFC2396_REGEXP
3738
- extend ::URI::Escape
3739
-
3740
- class << self
3741
- def parser; end
3742
- end
3743
- end
3744
-
3745
- class URI::File < ::URI::Generic
3746
- def check_password(user); end
3747
- def check_user(user); end
3748
- def check_userinfo(user); end
3749
- def set_host(v); end
3750
- def set_password(v); end
3751
- def set_port(v); end
3752
- def set_user(v); end
3753
- def set_userinfo(v); end
3754
-
3755
- class << self
3756
- def build(args); end
3757
- end
3758
- end
3759
-
3760
- URI::File::COMPONENT = T.let(T.unsafe(nil), Array)
3761
-
3762
- class URI::Generic
3763
- include ::URI::RFC2396_REGEXP
3764
- include ::URI
3765
-
3766
- def as_json(options = T.unsafe(nil)); end
3767
- end
3768
-
3769
- URI::Parser = URI::RFC2396_Parser
3770
- URI::REGEXP = URI::RFC2396_REGEXP
3771
-
3772
- class URI::RFC2396_Parser
3773
- include ::URI::RFC2396_REGEXP
3774
- end
3775
-
3776
- class UnboundMethod
3777
- def duplicable?; end
3778
- end