titleist 0.1.1 → 1.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (109) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/tests.yml +19 -0
  3. data/.gitignore +1 -2
  4. data/.rubocop.yml +26 -1
  5. data/.ruby-version +1 -1
  6. data/Gemfile +13 -2
  7. data/README.md +95 -25
  8. data/Rakefile +17 -6
  9. data/docs/index.md +7 -0
  10. data/lib/generators/titleist/titleist_generator.rb +3 -0
  11. data/lib/titleist.rb +14 -9
  12. data/lib/titleist/controller.rb +36 -0
  13. data/lib/titleist/engine.rb +10 -4
  14. data/lib/titleist/helper.rb +23 -0
  15. data/lib/titleist/title.rb +52 -89
  16. data/lib/titleist/version.rb +5 -1
  17. data/rbi/sord.rbi +117 -0
  18. data/sorbet/config +2 -0
  19. data/sorbet/rbi/gems/actioncable.rbi +318 -0
  20. data/sorbet/rbi/gems/actionmailbox.rbi +56 -0
  21. data/sorbet/rbi/gems/actionmailer.rbi +446 -0
  22. data/sorbet/rbi/gems/actionpack.rbi +3411 -0
  23. data/sorbet/rbi/gems/actiontext.rbi +79 -0
  24. data/sorbet/rbi/gems/actionview.rbi +1185 -0
  25. data/sorbet/rbi/gems/activejob.rbi +362 -0
  26. data/sorbet/rbi/gems/activemodel.rbi +749 -0
  27. data/sorbet/rbi/gems/activerecord.rbi +5713 -0
  28. data/sorbet/rbi/gems/activestorage.rbi +221 -0
  29. data/sorbet/rbi/gems/activesupport.rbi +2437 -0
  30. data/sorbet/rbi/gems/addressable.rbi +146 -0
  31. data/sorbet/rbi/gems/ast.rbi +47 -0
  32. data/sorbet/rbi/gems/capybara.rbi +1787 -0
  33. data/sorbet/rbi/gems/childprocess.rbi +106 -0
  34. data/sorbet/rbi/gems/codeclimate-test-reporter.rbi +125 -0
  35. data/sorbet/rbi/gems/concurrent-ruby.rbi +1587 -0
  36. data/sorbet/rbi/gems/crass.rbi +92 -0
  37. data/sorbet/rbi/gems/docile.rbi +29 -0
  38. data/sorbet/rbi/gems/erubi.rbi +26 -0
  39. data/sorbet/rbi/gems/globalid.rbi +98 -0
  40. data/sorbet/rbi/gems/i18n.rbi +191 -0
  41. data/sorbet/rbi/gems/jaro_winkler.rbi +14 -0
  42. data/sorbet/rbi/gems/loofah.rbi +129 -0
  43. data/sorbet/rbi/gems/mail.rbi +1582 -0
  44. data/sorbet/rbi/gems/marcel.rbi +12 -0
  45. data/sorbet/rbi/gems/method_source.rbi +63 -0
  46. data/sorbet/rbi/gems/mini_mime.rbi +51 -0
  47. data/sorbet/rbi/gems/minitest.rbi +419 -0
  48. data/sorbet/rbi/gems/mocha.rbi +794 -0
  49. data/sorbet/rbi/gems/nio4r.rbi +67 -0
  50. data/sorbet/rbi/gems/nokogiri.rbi +1010 -0
  51. data/sorbet/rbi/gems/parallel.rbi +81 -0
  52. data/sorbet/rbi/gems/parser.rbi +920 -0
  53. data/sorbet/rbi/gems/public_suffix.rbi +103 -0
  54. data/sorbet/rbi/gems/puma.rbi +586 -0
  55. data/sorbet/rbi/gems/rack-test.rbi +161 -0
  56. data/sorbet/rbi/gems/rack.rbi +634 -0
  57. data/sorbet/rbi/gems/rails-dom-testing.rbi +67 -0
  58. data/sorbet/rbi/gems/rails-html-sanitizer.rbi +91 -0
  59. data/sorbet/rbi/gems/railties.rbi +834 -0
  60. data/sorbet/rbi/gems/rainbow.rbi +117 -0
  61. data/sorbet/rbi/gems/rake.rbi +269 -0
  62. data/sorbet/rbi/gems/regexp_parser.rbi +912 -0
  63. data/sorbet/rbi/gems/rubocop.rbi +7232 -0
  64. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  65. data/sorbet/rbi/gems/rubyzip.rbi +546 -0
  66. data/sorbet/rbi/gems/selenium-webdriver.rbi +1450 -0
  67. data/sorbet/rbi/gems/simplecov-html.rbi +30 -0
  68. data/sorbet/rbi/gems/simplecov.rbi +189 -0
  69. data/sorbet/rbi/gems/site_ruby.rbi +265 -0
  70. data/sorbet/rbi/gems/sprockets-rails.rbi +105 -0
  71. data/sorbet/rbi/gems/sprockets.rbi +753 -0
  72. data/sorbet/rbi/gems/sqlite3.rbi +353 -0
  73. data/sorbet/rbi/gems/thor.rbi +579 -0
  74. data/sorbet/rbi/gems/thread_safe.rbi +81 -0
  75. data/sorbet/rbi/gems/tzinfo.rbi +405 -0
  76. data/sorbet/rbi/gems/unicode-display_width.rbi +16 -0
  77. data/sorbet/rbi/gems/webdrivers.rbi +155 -0
  78. data/sorbet/rbi/gems/xpath.rbi +158 -0
  79. data/sorbet/rbi/gems/yard.rbi +1159 -0
  80. data/sorbet/rbi/hidden-definitions/errors.txt +14957 -0
  81. data/sorbet/rbi/hidden-definitions/hidden.rbi +24898 -0
  82. data/sorbet/rbi/sorbet-typed/lib/actionmailer/all/actionmailer.rbi +13 -0
  83. data/sorbet/rbi/sorbet-typed/lib/actionpack/all/actionpack.rbi +938 -0
  84. data/sorbet/rbi/sorbet-typed/lib/actionview/all/actionview.rbi +314 -0
  85. data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi +425 -0
  86. data/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi +17 -0
  87. data/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi +1425 -0
  88. data/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi +475 -0
  89. data/sorbet/rbi/sorbet-typed/lib/activestorage/>=6.0.0/activestorage.rbi +19 -0
  90. data/sorbet/rbi/sorbet-typed/lib/activestorage/all/activestorage.rbi +173 -0
  91. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +23 -0
  92. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +858 -0
  93. data/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi +8684 -0
  94. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +108 -0
  95. data/sorbet/rbi/sorbet-typed/lib/railties/all/railties.rbi +25 -0
  96. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +254 -0
  97. data/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi +4222 -0
  98. data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +111 -0
  99. data/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi +543 -0
  100. data/sorbet/rbi/todo.rbi +20 -0
  101. data/titleist.gemspec +3 -14
  102. metadata +96 -155
  103. data/.travis.yml +0 -45
  104. data/app/controllers/.keep +0 -0
  105. data/app/helpers/.keep +0 -0
  106. data/app/helpers/titleist_helper.rb +0 -47
  107. data/app/mailers/.keep +0 -0
  108. data/app/models/.keep +0 -0
  109. data/app/views/.keep +0 -0
@@ -0,0 +1,221 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strong
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activestorage/all/activestorage.rbi
9
+ #
10
+ # activestorage-6.0.2.1
11
+ module ActiveStorage
12
+ def analyzers; end
13
+ def analyzers=(obj); end
14
+ def binary_content_type; end
15
+ def binary_content_type=(obj); end
16
+ def content_types_allowed_inline; end
17
+ def content_types_allowed_inline=(obj); end
18
+ def content_types_to_serve_as_binary; end
19
+ def content_types_to_serve_as_binary=(obj); end
20
+ def logger; end
21
+ def logger=(obj); end
22
+ def paths; end
23
+ def paths=(obj); end
24
+ def previewers; end
25
+ def previewers=(obj); end
26
+ def queues; end
27
+ def queues=(obj); end
28
+ def replace_on_assign_to_many; end
29
+ def replace_on_assign_to_many=(obj); end
30
+ def routes_prefix; end
31
+ def routes_prefix=(obj); end
32
+ def self.analyzers; end
33
+ def self.analyzers=(obj); end
34
+ def self.binary_content_type; end
35
+ def self.binary_content_type=(obj); end
36
+ def self.content_types_allowed_inline; end
37
+ def self.content_types_allowed_inline=(obj); end
38
+ def self.content_types_to_serve_as_binary; end
39
+ def self.content_types_to_serve_as_binary=(obj); end
40
+ def self.gem_version; end
41
+ def self.logger; end
42
+ def self.logger=(obj); end
43
+ def self.paths; end
44
+ def self.paths=(obj); end
45
+ def self.previewers; end
46
+ def self.previewers=(obj); end
47
+ def self.queues; end
48
+ def self.queues=(obj); end
49
+ def self.railtie_helpers_paths; end
50
+ def self.railtie_namespace; end
51
+ def self.railtie_routes_url_helpers(include_path_helpers = nil); end
52
+ def self.replace_on_assign_to_many; end
53
+ def self.replace_on_assign_to_many=(obj); end
54
+ def self.routes_prefix; end
55
+ def self.routes_prefix=(obj); end
56
+ def self.service_urls_expire_in; end
57
+ def self.service_urls_expire_in=(obj); end
58
+ def self.table_name_prefix; end
59
+ def self.use_relative_model_naming?; end
60
+ def self.variable_content_types; end
61
+ def self.variable_content_types=(obj); end
62
+ def self.variant_processor; end
63
+ def self.variant_processor=(obj); end
64
+ def self.verifier; end
65
+ def self.verifier=(obj); end
66
+ def self.version; end
67
+ def service_urls_expire_in; end
68
+ def service_urls_expire_in=(obj); end
69
+ def variable_content_types; end
70
+ def variable_content_types=(obj); end
71
+ def variant_processor; end
72
+ def variant_processor=(obj); end
73
+ def verifier; end
74
+ def verifier=(obj); end
75
+ extend ActiveSupport::Autoload
76
+ end
77
+ module ActiveStorage::VERSION
78
+ end
79
+ class ActiveStorage::Error < StandardError
80
+ end
81
+ class ActiveStorage::InvariableError < ActiveStorage::Error
82
+ end
83
+ class ActiveStorage::UnpreviewableError < ActiveStorage::Error
84
+ end
85
+ class ActiveStorage::UnrepresentableError < ActiveStorage::Error
86
+ end
87
+ class ActiveStorage::IntegrityError < ActiveStorage::Error
88
+ end
89
+ class ActiveStorage::FileNotFoundError < ActiveStorage::Error
90
+ end
91
+ module ActiveStorage::Transformers
92
+ extend ActiveSupport::Autoload
93
+ end
94
+ class ActiveStorage::Previewer
95
+ def blob; end
96
+ def capture(*argv, to:); end
97
+ def download_blob_to_tempfile(&block); end
98
+ def draw(*argv); end
99
+ def initialize(blob); end
100
+ def instrument(operation, payload = nil, &block); end
101
+ def logger; end
102
+ def open_tempfile; end
103
+ def preview; end
104
+ def self.accept?(blob); end
105
+ def tmpdir; end
106
+ end
107
+ class ActiveStorage::Previewer::PopplerPDFPreviewer < ActiveStorage::Previewer
108
+ def draw_first_page_from(file, &block); end
109
+ def preview; end
110
+ def self.accept?(blob); end
111
+ def self.pdftoppm_exists?; end
112
+ def self.pdftoppm_path; end
113
+ end
114
+ class ActiveStorage::Previewer::MuPDFPreviewer < ActiveStorage::Previewer
115
+ def draw_first_page_from(file, &block); end
116
+ def preview; end
117
+ def self.accept?(blob); end
118
+ def self.mutool_exists?; end
119
+ def self.mutool_path; end
120
+ end
121
+ class ActiveStorage::Previewer::VideoPreviewer < ActiveStorage::Previewer
122
+ def draw_relevant_frame_from(file, &block); end
123
+ def ffmpeg_path; end
124
+ def preview; end
125
+ def self.accept?(blob); end
126
+ end
127
+ class ActiveStorage::Analyzer
128
+ def blob; end
129
+ def download_blob_to_tempfile(&block); end
130
+ def initialize(blob); end
131
+ def logger; end
132
+ def metadata; end
133
+ def self.accept?(blob); end
134
+ def tmpdir; end
135
+ end
136
+ class ActiveStorage::Analyzer::ImageAnalyzer < ActiveStorage::Analyzer
137
+ def metadata; end
138
+ def read_image; end
139
+ def rotated_image?(image); end
140
+ def self.accept?(blob); end
141
+ end
142
+ class ActiveStorage::Analyzer::VideoAnalyzer < ActiveStorage::Analyzer
143
+ def angle; end
144
+ def computed_height; end
145
+ def display_aspect_ratio; end
146
+ def display_height_scale; end
147
+ def duration; end
148
+ def encoded_height; end
149
+ def encoded_width; end
150
+ def ffprobe_path; end
151
+ def height; end
152
+ def metadata; end
153
+ def probe; end
154
+ def probe_from(file); end
155
+ def rotated?; end
156
+ def self.accept?(blob); end
157
+ def streams; end
158
+ def tags; end
159
+ def video_stream; end
160
+ def width; end
161
+ end
162
+ module ActiveStorage::Reflection
163
+ end
164
+ class ActiveStorage::Reflection::HasOneAttachedReflection < ActiveRecord::Reflection::MacroReflection
165
+ def macro; end
166
+ end
167
+ class ActiveStorage::Reflection::HasManyAttachedReflection < ActiveRecord::Reflection::MacroReflection
168
+ def macro; end
169
+ end
170
+ module ActiveStorage::Reflection::ReflectionExtension
171
+ def add_attachment_reflection(model, name, reflection); end
172
+ def reflection_class_for(macro); end
173
+ end
174
+ module ActiveStorage::Reflection::ActiveRecordExtensions
175
+ extend ActiveSupport::Concern
176
+ end
177
+ module ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods
178
+ def reflect_on_all_attachments; end
179
+ def reflect_on_attachment(attachment); end
180
+ end
181
+ class ActiveStorage::Engine < Rails::Engine
182
+ end
183
+ module ActiveStorage::Attached::Model
184
+ def attachment_changes; end
185
+ def reload(*arg0); end
186
+ extend ActiveSupport::Concern
187
+ end
188
+ module ActiveStorage::Attached::Model::ClassMethods
189
+ def has_many_attached(name, dependent: nil); end
190
+ def has_one_attached(name, dependent: nil); end
191
+ end
192
+ class ActiveStorage::Attached::One < ActiveStorage::Attached
193
+ def attach(attachable); end
194
+ def attached?; end
195
+ def attachment; end
196
+ def blank?; end
197
+ def detach; end
198
+ def method_missing(method, *args, &block); end
199
+ def purge; end
200
+ def purge_later; end
201
+ def respond_to_missing?(name, include_private = nil); end
202
+ def write_attachment(attachment); end
203
+ end
204
+ class ActiveStorage::Attached::Many < ActiveStorage::Attached
205
+ def attach(*attachables); end
206
+ def attached?; end
207
+ def attachments; end
208
+ def blobs; end
209
+ def detach; end
210
+ def method_missing(method, *args, &block); end
211
+ def respond_to_missing?(name, include_private = nil); end
212
+ end
213
+ module ActiveStorage::Attached::Changes
214
+ extend ActiveSupport::Autoload
215
+ end
216
+ class ActiveStorage::Attached
217
+ def change; end
218
+ def initialize(name, record); end
219
+ def name; end
220
+ def record; end
221
+ end
@@ -0,0 +1,2437 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activesupport/all/activesupport.rbi
9
+ #
10
+ # activesupport-6.0.2.1
11
+ class Hash
12
+ def _deep_transform_keys_in_object!(object, &block); end
13
+ def _deep_transform_keys_in_object(object, &block); end
14
+ def _deep_transform_values_in_object!(object, &block); end
15
+ def _deep_transform_values_in_object(object, &block); end
16
+ def as_json(options = nil); end
17
+ def assert_valid_keys(*valid_keys); end
18
+ def blank?; end
19
+ def deep_dup; end
20
+ def deep_merge!(other_hash, &block); end
21
+ def deep_merge(other_hash, &block); end
22
+ def deep_stringify_keys!; end
23
+ def deep_stringify_keys; end
24
+ def deep_symbolize_keys!; end
25
+ def deep_symbolize_keys; end
26
+ def deep_transform_keys!(&block); end
27
+ def deep_transform_keys(&block); end
28
+ def deep_transform_values!(&block); end
29
+ def deep_transform_values(&block); end
30
+ def except!(*keys); end
31
+ def except(*keys); end
32
+ def extract!(*keys); end
33
+ def extractable_options?; end
34
+ def nested_under_indifferent_access; end
35
+ def reverse_merge!(other_hash); end
36
+ def reverse_merge(other_hash); end
37
+ def reverse_update(other_hash); end
38
+ def self.from_xml(xml, disallowed_types = nil); end
39
+ def self.try_convert(arg0); end
40
+ def slice!(*keys); end
41
+ def stringify_keys!; end
42
+ def stringify_keys; end
43
+ def symbolize_keys!; end
44
+ def symbolize_keys; end
45
+ def to_options!; end
46
+ def to_options; end
47
+ def to_param(namespace = nil); end
48
+ def to_query(namespace = nil); end
49
+ def to_xml(options = nil); end
50
+ def with_defaults!(other_hash); end
51
+ def with_defaults(other_hash); end
52
+ def with_indifferent_access; end
53
+ end
54
+ module ActiveSupport
55
+ def parse_json_times; end
56
+ def parse_json_times=(obj); end
57
+ def self.eager_load!; end
58
+ def self.escape_html_entities_in_json(*args, &block); end
59
+ def self.escape_html_entities_in_json=(arg); end
60
+ def self.gem_version; end
61
+ def self.json_encoder(*args, &block); end
62
+ def self.json_encoder=(arg); end
63
+ def self.parse_json_times; end
64
+ def self.parse_json_times=(obj); end
65
+ def self.test_order; end
66
+ def self.test_order=(obj); end
67
+ def self.time_precision(*args, &block); end
68
+ def self.time_precision=(arg); end
69
+ def self.to_time_preserves_timezone; end
70
+ def self.to_time_preserves_timezone=(value); end
71
+ def self.use_standard_json_time_format(*args, &block); end
72
+ def self.use_standard_json_time_format=(arg); end
73
+ def self.version; end
74
+ def test_order; end
75
+ def test_order=(obj); end
76
+ extend ActiveSupport::Autoload
77
+ extend ActiveSupport::LazyLoadHooks
78
+ end
79
+ module ActiveSupport::LazyLoadHooks
80
+ def execute_hook(name, base, options, block); end
81
+ def on_load(name, options = nil, &block); end
82
+ def run_load_hooks(name, base = nil); end
83
+ def self.extended(base); end
84
+ def with_execution_control(name, block, once); end
85
+ end
86
+ module Kernel
87
+ def class_eval(*args, &block); end
88
+ def concern(topic, &module_definition); end
89
+ def enable_warnings; end
90
+ def self.concern(topic, &module_definition); end
91
+ def self.enable_warnings; end
92
+ def self.silence_warnings; end
93
+ def self.suppress(*exception_classes); end
94
+ def self.with_warnings(flag); end
95
+ def silence_warnings; end
96
+ def suppress(*exception_classes); end
97
+ def with_warnings(flag); end
98
+ end
99
+ class Module
100
+ def alias_attribute(new_name, old_name); end
101
+ def anonymous?; end
102
+ def attr_internal(*attrs); end
103
+ def attr_internal_accessor(*attrs); end
104
+ def attr_internal_define(attr_name, type); end
105
+ def attr_internal_ivar_name(attr); end
106
+ def attr_internal_reader(*attrs); end
107
+ def attr_internal_writer(*attrs); end
108
+ def cattr_accessor(*syms, instance_reader: nil, instance_writer: nil, instance_accessor: nil, default: nil, &blk); end
109
+ def cattr_reader(*syms, instance_reader: nil, instance_accessor: nil, default: nil); end
110
+ def cattr_writer(*syms, instance_writer: nil, instance_accessor: nil, default: nil); end
111
+ def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil); end
112
+ def delegate_missing_to(target); end
113
+ def deprecate(*method_names); end
114
+ def mattr_accessor(*syms, instance_reader: nil, instance_writer: nil, instance_accessor: nil, default: nil, &blk); end
115
+ def mattr_reader(*syms, instance_reader: nil, instance_accessor: nil, default: nil); end
116
+ def mattr_writer(*syms, instance_writer: nil, instance_accessor: nil, default: nil); end
117
+ def method_visibility(method); end
118
+ def module_parent; end
119
+ def module_parent_name; end
120
+ def module_parents; end
121
+ def parent; end
122
+ def parent_name; end
123
+ def parents; end
124
+ def redefine_method(method, &block); end
125
+ def redefine_singleton_method(method, &block); end
126
+ def remove_possible_method(method); end
127
+ def remove_possible_singleton_method(method); end
128
+ def self.attr_internal_naming_format; end
129
+ def self.attr_internal_naming_format=(arg0); end
130
+ def silence_redefinition_of_method(method); end
131
+ def thread_cattr_accessor(*syms, instance_reader: nil, instance_writer: nil, instance_accessor: nil); end
132
+ def thread_cattr_reader(*syms, instance_reader: nil, instance_accessor: nil); end
133
+ def thread_cattr_writer(*syms, instance_writer: nil, instance_accessor: nil); end
134
+ def thread_mattr_accessor(*syms, instance_reader: nil, instance_writer: nil, instance_accessor: nil); end
135
+ def thread_mattr_reader(*syms, instance_reader: nil, instance_accessor: nil); end
136
+ def thread_mattr_writer(*syms, instance_writer: nil, instance_accessor: nil); end
137
+ include ActiveSupport::Dependencies::ModuleConstMissing
138
+ include Module::Concerning
139
+ end
140
+ class Module::DelegationError < NoMethodError
141
+ end
142
+ class ActiveSupport::Deprecation
143
+ def self.behavior(*args, &block); end
144
+ def self.behavior=(arg); end
145
+ def self.debug(*args, &block); end
146
+ def self.debug=(arg); end
147
+ def self.deprecate_methods(*args, &block); end
148
+ def self.deprecation_horizon(*args, &block); end
149
+ def self.deprecation_horizon=(arg); end
150
+ def self.deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil); end
151
+ def self.gem_name(*args, &block); end
152
+ def self.gem_name=(arg); end
153
+ def self.initialize(*args, &block); end
154
+ def self.instance; end
155
+ def self.silence(*args, &block); end
156
+ def self.silenced(*args, &block); end
157
+ def self.silenced=(arg); end
158
+ def self.warn(message = nil, callstack = nil); end
159
+ extend ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
160
+ extend Singleton::SingletonClassMethods
161
+ include ActiveSupport::Deprecation::Behavior
162
+ include ActiveSupport::Deprecation::InstanceDelegator
163
+ include ActiveSupport::Deprecation::MethodWrapper
164
+ include ActiveSupport::Deprecation::Reporting
165
+ include Singleton
166
+ end
167
+ module ActiveSupport::Deprecation::InstanceDelegator
168
+ def self.included(base); end
169
+ end
170
+ module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
171
+ def include(included_module); end
172
+ def method_added(method_name); end
173
+ end
174
+ module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
175
+ def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil); end
176
+ def warn(message = nil, callstack = nil); end
177
+ end
178
+ module ActiveSupport::Notifications
179
+ def self.instrument(name, payload = nil); end
180
+ def self.instrumenter; end
181
+ def self.notifier; end
182
+ def self.notifier=(arg0); end
183
+ def self.publish(name, *args); end
184
+ def self.subscribe(*args, &block); end
185
+ def self.subscribed(callback, *args, &block); end
186
+ def self.unsubscribe(subscriber_or_name); end
187
+ end
188
+ class ActiveSupport::Notifications::Instrumenter
189
+ def finish(name, payload); end
190
+ def finish_with_state(listeners_state, name, payload); end
191
+ def id; end
192
+ def initialize(notifier); end
193
+ def instrument(name, payload = nil); end
194
+ def start(name, payload); end
195
+ def unique_id; end
196
+ end
197
+ class ActiveSupport::Notifications::Event
198
+ def <<(event); end
199
+ def allocations; end
200
+ def children; end
201
+ def cpu_time; end
202
+ def duration; end
203
+ def end; end
204
+ def end=(ending); end
205
+ def finish!; end
206
+ def idle_time; end
207
+ def initialize(name, start, ending, transaction_id, payload); end
208
+ def name; end
209
+ def now; end
210
+ def now_allocations; end
211
+ def now_cpu; end
212
+ def parent_of?(event); end
213
+ def payload; end
214
+ def self.clock_gettime_supported?; end
215
+ def start!; end
216
+ def time; end
217
+ def transaction_id; end
218
+ end
219
+ class ActiveSupport::Notifications::Fanout
220
+ def finish(name, id, payload, listeners = nil); end
221
+ def initialize; end
222
+ def listeners_for(name); end
223
+ def listening?(name); end
224
+ def lock; end
225
+ def locked?; end
226
+ def publish(name, *args); end
227
+ def start(name, id, payload); end
228
+ def subscribe(pattern = nil, callable = nil, &block); end
229
+ def synchronize(&block); end
230
+ def try_lock; end
231
+ def unlock; end
232
+ def unsubscribe(subscriber_or_name); end
233
+ def wait; end
234
+ include Mutex_m
235
+ end
236
+ module ActiveSupport::Notifications::Fanout::Subscribers
237
+ def self.event_object_subscriber(pattern, block); end
238
+ def self.new(pattern, listener); end
239
+ def self.wrap_all(pattern, subscriber); end
240
+ end
241
+ class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
242
+ def ===(name); end
243
+ def exclusions; end
244
+ def initialize(pattern); end
245
+ def pattern; end
246
+ def self.wrap(pattern); end
247
+ def unsubscribe!(name); end
248
+ end
249
+ class ActiveSupport::Notifications::Fanout::Subscribers::Evented
250
+ def finish(name, id, payload); end
251
+ def initialize(pattern, delegate); end
252
+ def matches?(name); end
253
+ def pattern; end
254
+ def publish(name, *args); end
255
+ def start(name, id, payload); end
256
+ def subscribed_to?(name); end
257
+ def unsubscribe!(name); end
258
+ end
259
+ class ActiveSupport::Notifications::Fanout::Subscribers::Timed < ActiveSupport::Notifications::Fanout::Subscribers::Evented
260
+ def finish(name, id, payload); end
261
+ def publish(name, *args); end
262
+ def start(name, id, payload); end
263
+ end
264
+ class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ActiveSupport::Notifications::Fanout::Subscribers::Evented
265
+ def build_event(name, id, payload); end
266
+ def finish(name, id, payload); end
267
+ def start(name, id, payload); end
268
+ end
269
+ class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
270
+ def finish(name, id, payload); end
271
+ def initialize(delegate); end
272
+ def matches?(arg0); end
273
+ def publish(name, *args); end
274
+ def start(name, id, payload); end
275
+ def subscribed_to?(name); end
276
+ def unsubscribe!(*arg0); end
277
+ end
278
+ module ActiveSupport::PerThreadRegistry
279
+ def instance; end
280
+ def method_missing(name, *args, &block); end
281
+ def self.extended(object); end
282
+ end
283
+ class ActiveSupport::Notifications::InstrumentationRegistry
284
+ def initialize; end
285
+ def instrumenter_for(notifier); end
286
+ extend ActiveSupport::PerThreadRegistry
287
+ end
288
+ class ActiveSupport::DeprecationException < StandardError
289
+ end
290
+ module ActiveSupport::Deprecation::Behavior
291
+ def arity_coerce(behavior); end
292
+ def behavior; end
293
+ def behavior=(behavior); end
294
+ def debug; end
295
+ def debug=(arg0); end
296
+ end
297
+ module ActiveSupport::Deprecation::Reporting
298
+ def _extract_callstack(callstack); end
299
+ def deprecated_method_warning(method_name, message = nil); end
300
+ def deprecation_caller_message(callstack); end
301
+ def deprecation_message(callstack, message = nil); end
302
+ def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil); end
303
+ def extract_callstack(callstack); end
304
+ def gem_name; end
305
+ def gem_name=(arg0); end
306
+ def ignored_callstack(path); end
307
+ def silence; end
308
+ def silenced; end
309
+ def silenced=(arg0); end
310
+ def warn(message = nil, callstack = nil); end
311
+ end
312
+ module ActiveSupport::Deprecation::DeprecatedConstantAccessor
313
+ def self.included(base); end
314
+ end
315
+ class Array
316
+ def as_json(options = nil); end
317
+ def blank?; end
318
+ def deep_dup; end
319
+ def excluding(*elements); end
320
+ def extract!; end
321
+ def extract_options!; end
322
+ def fifth; end
323
+ def forty_two; end
324
+ def fourth; end
325
+ def from(position); end
326
+ def in_groups(number, fill_with = nil); end
327
+ def in_groups_of(number, fill_with = nil); end
328
+ def including(*elements); end
329
+ def inquiry; end
330
+ def second; end
331
+ def second_to_last; end
332
+ def self.wrap(object); end
333
+ def split(value = nil); end
334
+ def third; end
335
+ def third_to_last; end
336
+ def to(position); end
337
+ def to_default_s; end
338
+ def to_formatted_s(format = nil); end
339
+ def to_param; end
340
+ def to_query(key); end
341
+ def to_sentence(options = nil); end
342
+ def to_xml(options = nil); end
343
+ def without(*elements); end
344
+ end
345
+ module ActiveSupport::Deprecation::MethodWrapper
346
+ def deprecate_methods(target_module, *method_names); end
347
+ end
348
+ class ActiveSupport::Deprecation::DeprecationProxy
349
+ def inspect; end
350
+ def method_missing(called, *args, &block); end
351
+ def self.new(*args, &block); end
352
+ end
353
+ class ActiveSupport::Deprecation::DeprecatedObjectProxy < ActiveSupport::Deprecation::DeprecationProxy
354
+ def initialize(object, message, deprecator = nil); end
355
+ def target; end
356
+ def warn(callstack, called, args); end
357
+ end
358
+ class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ActiveSupport::Deprecation::DeprecationProxy
359
+ def initialize(instance, method, var = nil, deprecator = nil); end
360
+ def target; end
361
+ def warn(callstack, called, args); end
362
+ end
363
+ class ActiveSupport::Deprecation::DeprecatedConstantProxy < Module
364
+ def class; end
365
+ def const_missing(name); end
366
+ def initialize(old_const, new_const, deprecator = nil, message: nil); end
367
+ def inspect; end
368
+ def method_missing(called, *args, &block); end
369
+ def self.new(*args, &block); end
370
+ def target; end
371
+ end
372
+ module ActiveSupport::Inflector
373
+ def apply_inflections(word, rules, locale = nil); end
374
+ def camelize(term, uppercase_first_letter = nil); end
375
+ def classify(table_name); end
376
+ def const_regexp(camel_cased_word); end
377
+ def constantize(camel_cased_word); end
378
+ def dasherize(underscored_word); end
379
+ def deconstantize(path); end
380
+ def demodulize(path); end
381
+ def foreign_key(class_name, separate_class_name_and_id_with_underscore = nil); end
382
+ def humanize(lower_case_and_underscored_word, capitalize: nil, keep_id_suffix: nil); end
383
+ def inflections(locale = nil); end
384
+ def ordinal(number); end
385
+ def ordinalize(number); end
386
+ def parameterize(string, separator: nil, preserve_case: nil, locale: nil); end
387
+ def pluralize(word, locale = nil); end
388
+ def safe_constantize(camel_cased_word); end
389
+ def singularize(word, locale = nil); end
390
+ def tableize(class_name); end
391
+ def titleize(word, keep_id_suffix: nil); end
392
+ def transliterate(string, replacement = nil, locale: nil); end
393
+ def underscore(camel_cased_word); end
394
+ def upcase_first(string); end
395
+ extend ActiveSupport::Inflector
396
+ extend ActiveSupport::Inflector
397
+ end
398
+ class ActiveSupport::Inflector::Inflections
399
+ def acronym(word); end
400
+ def acronyms; end
401
+ def acronyms_camelize_regex; end
402
+ def acronyms_underscore_regex; end
403
+ def clear(scope = nil); end
404
+ def define_acronym_regex_patterns; end
405
+ def human(rule, replacement); end
406
+ def humans; end
407
+ def initialize; end
408
+ def initialize_dup(orig); end
409
+ def irregular(singular, plural); end
410
+ def plural(rule, replacement); end
411
+ def plurals; end
412
+ def self.instance(locale = nil); end
413
+ def singular(rule, replacement); end
414
+ def singulars; end
415
+ def uncountable(*words); end
416
+ def uncountables; end
417
+ end
418
+ class ActiveSupport::Inflector::Inflections::Uncountables < Array
419
+ def <<(*word); end
420
+ def add(words); end
421
+ def delete(entry); end
422
+ def initialize; end
423
+ def to_regex(string); end
424
+ def uncountable?(str); end
425
+ end
426
+ module ActiveSupport::Autoload
427
+ def autoload(const_name, path = nil); end
428
+ def autoload_at(path); end
429
+ def autoload_under(path); end
430
+ def autoloads; end
431
+ def eager_autoload; end
432
+ def eager_load!; end
433
+ def self.extended(base); end
434
+ end
435
+ module ActiveSupport::VERSION
436
+ end
437
+ module ActiveSupport::Concern
438
+ def append_features(base); end
439
+ def class_methods(&class_methods_module_definition); end
440
+ def included(base = nil, &block); end
441
+ def self.extended(base); end
442
+ end
443
+ class ActiveSupport::Concern::MultipleIncludedBlocks < StandardError
444
+ def initialize; end
445
+ end
446
+ module ActiveSupport::LoggerThreadSafeLevel
447
+ def add(severity, message = nil, progname = nil, &block); end
448
+ def after_initialize; end
449
+ def debug?; end
450
+ def error?; end
451
+ def fatal?; end
452
+ def info?; end
453
+ def level; end
454
+ def local_level; end
455
+ def local_level=(level); end
456
+ def local_log_id; end
457
+ def unknown?; end
458
+ def warn?; end
459
+ extend ActiveSupport::Concern
460
+ end
461
+ module LoggerSilence
462
+ extend ActiveSupport::Concern
463
+ end
464
+ module ActiveSupport::LoggerSilence
465
+ def silence(temporary_level = nil); end
466
+ extend ActiveSupport::Concern
467
+ end
468
+ class ActiveSupport::Logger < Logger
469
+ def initialize(*args); end
470
+ def self.broadcast(logger); end
471
+ def self.local_levels; end
472
+ def self.local_levels=(obj); end
473
+ def self.logger_outputs_to?(logger, *sources); end
474
+ def self.silencer; end
475
+ def self.silencer=(obj); end
476
+ def silencer; end
477
+ def silencer=(obj); end
478
+ include ActiveSupport::LoggerSilence
479
+ include ActiveSupport::LoggerThreadSafeLevel
480
+ end
481
+ class ActiveSupport::Logger::SimpleFormatter < Logger::Formatter
482
+ def call(severity, timestamp, progname, msg); end
483
+ end
484
+ module DateAndTime
485
+ end
486
+ module DateAndTime::Compatibility
487
+ def preserve_timezone; end
488
+ def self.preserve_timezone; end
489
+ def self.preserve_timezone=(obj); end
490
+ end
491
+ class Object < BasicObject
492
+ def acts_like?(duck); end
493
+ def as_json(options = nil); end
494
+ def blank?; end
495
+ def deep_dup; end
496
+ def duplicable?; end
497
+ def html_safe?; end
498
+ def in?(another_object); end
499
+ def instance_values; end
500
+ def instance_variable_names; end
501
+ def presence; end
502
+ def presence_in(another_object); end
503
+ def present?; end
504
+ def to_param; end
505
+ def to_query(key); end
506
+ def with_options(options, &block); end
507
+ include ActiveSupport::Dependencies::Loadable
508
+ include ActiveSupport::Tryable
509
+ end
510
+ class NilClass
511
+ def as_json(options = nil); end
512
+ def blank?; end
513
+ def to_param; end
514
+ def try!(method_name = nil, *args); end
515
+ def try(method_name = nil, *args); end
516
+ end
517
+ class FalseClass
518
+ def as_json(options = nil); end
519
+ def blank?; end
520
+ def to_param; end
521
+ end
522
+ class TrueClass
523
+ def as_json(options = nil); end
524
+ def blank?; end
525
+ def to_param; end
526
+ end
527
+ class String
528
+ def acts_like_string?; end
529
+ def as_json(options = nil); end
530
+ def at(position); end
531
+ def blank?; end
532
+ def camelcase(first_letter = nil); end
533
+ def camelize(first_letter = nil); end
534
+ def classify; end
535
+ def constantize; end
536
+ def dasherize; end
537
+ def deconstantize; end
538
+ def demodulize; end
539
+ def ends_with?(*arg0); end
540
+ def exclude?(string); end
541
+ def first(limit = nil); end
542
+ def foreign_key(separate_class_name_and_id_with_underscore = nil); end
543
+ def from(position); end
544
+ def html_safe; end
545
+ def humanize(capitalize: nil, keep_id_suffix: nil); end
546
+ def in_time_zone(zone = nil); end
547
+ def indent!(amount, indent_string = nil, indent_empty_lines = nil); end
548
+ def indent(amount, indent_string = nil, indent_empty_lines = nil); end
549
+ def inquiry; end
550
+ def is_utf8?; end
551
+ def last(limit = nil); end
552
+ def mb_chars; end
553
+ def parameterize(separator: nil, preserve_case: nil, locale: nil); end
554
+ def pluralize(count = nil, locale = nil); end
555
+ def remove!(*patterns); end
556
+ def remove(*patterns); end
557
+ def safe_constantize; end
558
+ def singularize(locale = nil); end
559
+ def squish!; end
560
+ def squish; end
561
+ def starts_with?(*arg0); end
562
+ def strip_heredoc; end
563
+ def tableize; end
564
+ def titlecase(keep_id_suffix: nil); end
565
+ def titleize(keep_id_suffix: nil); end
566
+ def to(position); end
567
+ def to_date; end
568
+ def to_datetime; end
569
+ def to_time(form = nil); end
570
+ def truncate(truncate_at, options = nil); end
571
+ def truncate_bytes(truncate_at, omission: nil); end
572
+ def truncate_words(words_count, options = nil); end
573
+ def underscore; end
574
+ def upcase_first; end
575
+ end
576
+ class Numeric
577
+ def as_json(options = nil); end
578
+ def blank?; end
579
+ def byte; end
580
+ def bytes; end
581
+ def day; end
582
+ def days; end
583
+ def exabyte; end
584
+ def exabytes; end
585
+ def fortnight; end
586
+ def fortnights; end
587
+ def gigabyte; end
588
+ def gigabytes; end
589
+ def hour; end
590
+ def hours; end
591
+ def html_safe?; end
592
+ def in_milliseconds; end
593
+ def kilobyte; end
594
+ def kilobytes; end
595
+ def megabyte; end
596
+ def megabytes; end
597
+ def minute; end
598
+ def minutes; end
599
+ def petabyte; end
600
+ def petabytes; end
601
+ def second; end
602
+ def seconds; end
603
+ def terabyte; end
604
+ def terabytes; end
605
+ def week; end
606
+ def weeks; end
607
+ end
608
+ class Time
609
+ def acts_like_time?; end
610
+ def advance(options); end
611
+ def ago(seconds); end
612
+ def as_json(options = nil); end
613
+ def at_beginning_of_day; end
614
+ def at_beginning_of_hour; end
615
+ def at_beginning_of_minute; end
616
+ def at_end_of_day; end
617
+ def at_end_of_hour; end
618
+ def at_end_of_minute; end
619
+ def at_midday; end
620
+ def at_middle_of_day; end
621
+ def at_midnight; end
622
+ def at_noon; end
623
+ def beginning_of_day; end
624
+ def beginning_of_hour; end
625
+ def beginning_of_minute; end
626
+ def blank?; end
627
+ def change(options); end
628
+ def compare_with_coercion(other); end
629
+ def compare_without_coercion(arg0); end
630
+ def end_of_day; end
631
+ def end_of_hour; end
632
+ def end_of_minute; end
633
+ def eql_with_coercion(other); end
634
+ def eql_without_coercion(arg0); end
635
+ def formatted_offset(colon = nil, alternate_utc_string = nil); end
636
+ def in(seconds); end
637
+ def midday; end
638
+ def middle_of_day; end
639
+ def midnight; end
640
+ def minus_with_coercion(other); end
641
+ def minus_with_duration(other); end
642
+ def minus_without_coercion(other); end
643
+ def minus_without_duration(arg0); end
644
+ def next_day(days = nil); end
645
+ def next_month(months = nil); end
646
+ def next_year(years = nil); end
647
+ def noon; end
648
+ def plus_with_duration(other); end
649
+ def plus_without_duration(arg0); end
650
+ def prev_day(days = nil); end
651
+ def prev_month(months = nil); end
652
+ def prev_year(years = nil); end
653
+ def rfc3339(fraction_digits = nil); end
654
+ def sec_fraction; end
655
+ def seconds_since_midnight; end
656
+ def seconds_until_end_of_day; end
657
+ def self.===(other); end
658
+ def self.at_with_coercion(*args); end
659
+ def self.at_without_coercion(*arg0); end
660
+ def self.current; end
661
+ def self.days_in_month(month, year = nil); end
662
+ def self.days_in_year(year = nil); end
663
+ def self.find_zone!(time_zone); end
664
+ def self.find_zone(time_zone); end
665
+ def self.rfc3339(str); end
666
+ def self.use_zone(time_zone); end
667
+ def self.zone; end
668
+ def self.zone=(time_zone); end
669
+ def self.zone_default; end
670
+ def self.zone_default=(arg0); end
671
+ def since(seconds); end
672
+ def to_default_s; end
673
+ def to_formatted_s(format = nil); end
674
+ include DateAndTime::Calculations
675
+ include DateAndTime::Compatibility
676
+ include DateAndTime::Zones
677
+ end
678
+ class ActiveSupport::KeyGenerator
679
+ def generate_key(salt, key_size = nil); end
680
+ def initialize(secret, options = nil); end
681
+ end
682
+ class ActiveSupport::CachingKeyGenerator
683
+ def generate_key(*args); end
684
+ def initialize(key_generator); end
685
+ end
686
+ module ActiveSupport::SecurityUtils
687
+ def fixed_length_secure_compare(a, b); end
688
+ def secure_compare(a, b); end
689
+ def self.fixed_length_secure_compare(a, b); end
690
+ def self.secure_compare(a, b); end
691
+ end
692
+ module ActiveSupport::Messages
693
+ end
694
+ class ActiveSupport::Messages::Metadata
695
+ def as_json(options = nil); end
696
+ def fresh?; end
697
+ def initialize(message, expires_at = nil, purpose = nil); end
698
+ def match?(purpose); end
699
+ def self.decode(message); end
700
+ def self.encode(message); end
701
+ def self.extract_metadata(message); end
702
+ def self.pick_expiry(expires_at, expires_in); end
703
+ def self.verify(message, purpose); end
704
+ def self.wrap(message, expires_at: nil, expires_in: nil, purpose: nil); end
705
+ def verify(purpose); end
706
+ end
707
+ module ActiveSupport::Messages::Rotator
708
+ def initialize(*arg0, **options); end
709
+ def rotate(*secrets, **options); end
710
+ def run_rotations(on_rotation); end
711
+ end
712
+ module ActiveSupport::Messages::Rotator::Encryptor
713
+ def build_rotation(secret = nil, sign_secret = nil, options); end
714
+ def decrypt_and_verify(*args, on_rotation: nil, **options); end
715
+ include ActiveSupport::Messages::Rotator
716
+ end
717
+ module ActiveSupport::Messages::Rotator::Verifier
718
+ def build_rotation(secret = nil, options); end
719
+ def verified(*args, on_rotation: nil, **options); end
720
+ include ActiveSupport::Messages::Rotator
721
+ end
722
+ class ActiveSupport::MessageVerifier
723
+ def decode(data); end
724
+ def encode(data); end
725
+ def generate(value, expires_at: nil, expires_in: nil, purpose: nil); end
726
+ def generate_digest(data); end
727
+ def initialize(*arg0, **options); end
728
+ def valid_message?(signed_message); end
729
+ def verified(*args, on_rotation: nil, **options); end
730
+ def verify(*args); end
731
+ end
732
+ class ActiveSupport::MessageVerifier::InvalidSignature < StandardError
733
+ end
734
+ class ActiveSupport::MessageEncryptor
735
+ def _decrypt(encrypted_message, purpose); end
736
+ def _encrypt(value, **metadata_options); end
737
+ def aead_mode?; end
738
+ def decrypt_and_verify(*args, on_rotation: nil, **options); end
739
+ def encrypt_and_sign(value, expires_at: nil, expires_in: nil, purpose: nil); end
740
+ def initialize(*arg0, **options); end
741
+ def new_cipher; end
742
+ def resolve_verifier; end
743
+ def self.default_cipher; end
744
+ def self.key_len(cipher = nil); end
745
+ def self.use_authenticated_message_encryption; end
746
+ def self.use_authenticated_message_encryption=(obj); end
747
+ def verifier; end
748
+ end
749
+ module ActiveSupport::MessageEncryptor::NullSerializer
750
+ def self.dump(value); end
751
+ def self.load(value); end
752
+ end
753
+ module ActiveSupport::MessageEncryptor::NullVerifier
754
+ def self.generate(value); end
755
+ def self.verify(value); end
756
+ end
757
+ class ActiveSupport::MessageEncryptor::InvalidMessage < StandardError
758
+ end
759
+ class ActiveSupport::EncryptedFile
760
+ def change(&block); end
761
+ def content_path; end
762
+ def decrypt(contents); end
763
+ def encrypt(contents); end
764
+ def encryptor; end
765
+ def env_key; end
766
+ def handle_missing_key; end
767
+ def initialize(content_path:, key_path:, env_key:, raise_if_missing_key:); end
768
+ def key; end
769
+ def key_path; end
770
+ def raise_if_missing_key; end
771
+ def read; end
772
+ def read_env_key; end
773
+ def read_key_file; end
774
+ def self.generate_key; end
775
+ def write(contents); end
776
+ def writing(contents); end
777
+ end
778
+ class ActiveSupport::EncryptedFile::MissingContentError < RuntimeError
779
+ def initialize(content_path); end
780
+ end
781
+ class ActiveSupport::EncryptedFile::MissingKeyError < RuntimeError
782
+ def initialize(key_path:, env_key:); end
783
+ end
784
+ class ActiveSupport::OrderedOptions < Hash
785
+ def [](key); end
786
+ def []=(key, value); end
787
+ def _get(arg0); end
788
+ def method_missing(name, *args); end
789
+ def respond_to_missing?(name, include_private); end
790
+ end
791
+ class ActiveSupport::InheritableOptions < ActiveSupport::OrderedOptions
792
+ def inheritable_copy; end
793
+ def initialize(parent = nil); end
794
+ end
795
+ class ActiveSupport::EncryptedConfiguration < ActiveSupport::EncryptedFile
796
+ def [](*args, &block); end
797
+ def config; end
798
+ def deserialize(config); end
799
+ def fetch(*args, &block); end
800
+ def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:); end
801
+ def method_missing(method, *args, &block); end
802
+ def options; end
803
+ def read; end
804
+ def respond_to_missing?(name, include_private = nil); end
805
+ def write(contents); end
806
+ end
807
+ class ActiveSupport::HashWithIndifferentAccess < Hash
808
+ def [](key); end
809
+ def []=(key, value); end
810
+ def assoc(key); end
811
+ def compact; end
812
+ def convert_key(key); end
813
+ def convert_value(value, options = nil); end
814
+ def deep_stringify_keys!; end
815
+ def deep_stringify_keys; end
816
+ def deep_symbolize_keys; end
817
+ def default(*args); end
818
+ def delete(key); end
819
+ def dig(*args); end
820
+ def dup; end
821
+ def except(*keys); end
822
+ def extractable_options?; end
823
+ def fetch(key, *extras); end
824
+ def fetch_values(*indices, &block); end
825
+ def has_key?(key); end
826
+ def include?(key); end
827
+ def initialize(constructor = nil); end
828
+ def key?(key); end
829
+ def member?(key); end
830
+ def merge!(other_hash); end
831
+ def merge(hash, &block); end
832
+ def nested_under_indifferent_access; end
833
+ def regular_update(*arg0); end
834
+ def regular_writer(arg0, arg1); end
835
+ def reject(*args, &block); end
836
+ def replace(other_hash); end
837
+ def reverse_merge!(other_hash); end
838
+ def reverse_merge(other_hash); end
839
+ def select(*args, &block); end
840
+ def self.[](*args); end
841
+ def set_defaults(target); end
842
+ def slice!(*keys); end
843
+ def slice(*keys); end
844
+ def store(key, value); end
845
+ def stringify_keys!; end
846
+ def stringify_keys; end
847
+ def symbolize_keys; end
848
+ def to_hash; end
849
+ def to_options!; end
850
+ def to_options; end
851
+ def transform_keys!; end
852
+ def transform_keys(*args, &block); end
853
+ def transform_values(*args, &block); end
854
+ def update(other_hash); end
855
+ def values_at(*keys); end
856
+ def with_defaults!(other_hash); end
857
+ def with_defaults(other_hash); end
858
+ def with_indifferent_access; end
859
+ def without(*keys); end
860
+ end
861
+ module ActiveSupport::Multibyte
862
+ def self.proxy_class; end
863
+ def self.proxy_class=(klass); end
864
+ end
865
+ class LoadError < ScriptError
866
+ def is_missing?(location); end
867
+ end
868
+ class NameError < StandardError
869
+ def missing_name; end
870
+ def missing_name?(name); end
871
+ end
872
+ module ActiveSupport::Concurrency
873
+ end
874
+ class ActiveSupport::Concurrency::ShareLock
875
+ def busy_for_exclusive?(purpose); end
876
+ def busy_for_sharing?(purpose); end
877
+ def eligible_waiters?(compatible); end
878
+ def exclusive(purpose: nil, compatible: nil, after_compatible: nil, no_wait: nil); end
879
+ def initialize; end
880
+ def raw_state; end
881
+ def sharing; end
882
+ def start_exclusive(purpose: nil, compatible: nil, no_wait: nil); end
883
+ def start_sharing; end
884
+ def stop_exclusive(compatible: nil); end
885
+ def stop_sharing; end
886
+ def wait_for(method); end
887
+ def yield_shares(purpose: nil, compatible: nil, block_share: nil); end
888
+ include MonitorMixin
889
+ end
890
+ module ActiveSupport::Dependencies
891
+ def _eager_load_paths; end
892
+ def _eager_load_paths=(obj); end
893
+ def autoload_module!(into, const_name, qualified_name, path_suffix); end
894
+ def autoload_once_paths; end
895
+ def autoload_once_paths=(obj); end
896
+ def autoload_paths; end
897
+ def autoload_paths=(obj); end
898
+ def autoloadable_module?(path_suffix); end
899
+ def autoloaded?(desc); end
900
+ def autoloaded_constants; end
901
+ def autoloaded_constants=(obj); end
902
+ def clear; end
903
+ def constant_watch_stack; end
904
+ def constant_watch_stack=(obj); end
905
+ def constantize(name); end
906
+ def depend_on(file_name, message = nil); end
907
+ def explicitly_unloadable_constants; end
908
+ def explicitly_unloadable_constants=(obj); end
909
+ def history; end
910
+ def history=(obj); end
911
+ def hook!; end
912
+ def interlock; end
913
+ def interlock=(obj); end
914
+ def load?; end
915
+ def load_file(path, const_paths = nil); end
916
+ def load_missing_constant(from_mod, const_name); end
917
+ def load_once_path?(path); end
918
+ def loadable_constants_for_path(path, bases = nil); end
919
+ def loaded; end
920
+ def loaded=(obj); end
921
+ def loading; end
922
+ def loading=(obj); end
923
+ def log(message); end
924
+ def logger; end
925
+ def logger=(obj); end
926
+ def mark_for_unload(const_desc); end
927
+ def mechanism; end
928
+ def mechanism=(obj); end
929
+ def new_constants_in(*descs); end
930
+ def qualified_const_defined?(path); end
931
+ def qualified_name_for(mod, name); end
932
+ def real_mod_name(mod); end
933
+ def reference(klass); end
934
+ def remove_constant(const); end
935
+ def remove_unloadable_constants!; end
936
+ def require_or_load(file_name, const_path = nil); end
937
+ def safe_constantize(name); end
938
+ def search_for_file(path_suffix); end
939
+ def self._eager_load_paths; end
940
+ def self._eager_load_paths=(obj); end
941
+ def self.autoload_once_paths; end
942
+ def self.autoload_once_paths=(obj); end
943
+ def self.autoload_paths; end
944
+ def self.autoload_paths=(obj); end
945
+ def self.autoloaded_constants; end
946
+ def self.autoloaded_constants=(obj); end
947
+ def self.constant_watch_stack; end
948
+ def self.constant_watch_stack=(obj); end
949
+ def self.explicitly_unloadable_constants; end
950
+ def self.explicitly_unloadable_constants=(obj); end
951
+ def self.history; end
952
+ def self.history=(obj); end
953
+ def self.interlock; end
954
+ def self.interlock=(obj); end
955
+ def self.load_interlock; end
956
+ def self.loaded; end
957
+ def self.loaded=(obj); end
958
+ def self.loading; end
959
+ def self.loading=(obj); end
960
+ def self.logger; end
961
+ def self.logger=(obj); end
962
+ def self.mechanism; end
963
+ def self.mechanism=(obj); end
964
+ def self.run_interlock; end
965
+ def self.unload_interlock; end
966
+ def self.verbose; end
967
+ def self.verbose=(obj); end
968
+ def self.warnings_on_first_load; end
969
+ def self.warnings_on_first_load=(obj); end
970
+ def to_constant_name(desc); end
971
+ def unhook!; end
972
+ def verbose; end
973
+ def verbose=(obj); end
974
+ def warnings_on_first_load; end
975
+ def warnings_on_first_load=(obj); end
976
+ def will_unload?(const_desc); end
977
+ extend ActiveSupport::Dependencies
978
+ end
979
+ class ActiveSupport::Dependencies::Interlock
980
+ def done_running; end
981
+ def done_unloading; end
982
+ def initialize; end
983
+ def loading; end
984
+ def permit_concurrent_loads; end
985
+ def raw_state(&block); end
986
+ def running; end
987
+ def start_running; end
988
+ def start_unloading; end
989
+ def unloading; end
990
+ end
991
+ class ActiveSupport::Dependencies::WatchStack
992
+ def each(&block); end
993
+ def initialize; end
994
+ def new_constants; end
995
+ def pop_modules(modules); end
996
+ def watch_namespaces(namespaces); end
997
+ def watching; end
998
+ def watching?; end
999
+ include Enumerable
1000
+ end
1001
+ module ActiveSupport::Dependencies::ModuleConstMissing
1002
+ def const_missing(const_name); end
1003
+ def guess_for_anonymous(const_name); end
1004
+ def self.append_features(base); end
1005
+ def self.exclude_from(base); end
1006
+ def self.include_into(base); end
1007
+ def unloadable(const_desc = nil); end
1008
+ end
1009
+ module ActiveSupport::Dependencies::Loadable
1010
+ def load(file, wrap = nil); end
1011
+ def load_dependency(file); end
1012
+ def require(file); end
1013
+ def require_dependency(file_name, message = nil); end
1014
+ def require_or_load(file_name); end
1015
+ def self.exclude_from(base); end
1016
+ def self.include_into(base); end
1017
+ def unloadable(const_desc); end
1018
+ end
1019
+ module ActiveSupport::Dependencies::Blamable
1020
+ def blame_file!(file); end
1021
+ def blamed_files; end
1022
+ def copy_blame!(exc); end
1023
+ def describe_blame; end
1024
+ end
1025
+ class ActiveSupport::Dependencies::ClassCache
1026
+ def [](key); end
1027
+ def clear!; end
1028
+ def empty?; end
1029
+ def get(key); end
1030
+ def initialize; end
1031
+ def key?(key); end
1032
+ def safe_get(key); end
1033
+ def store(klass); end
1034
+ end
1035
+ class Exception
1036
+ def as_json(options = nil); end
1037
+ include ActiveSupport::Dependencies::Blamable
1038
+ end
1039
+ module ActiveSupport::Dependencies::ZeitwerkIntegration
1040
+ def self.autoload_once?(autoload_path); end
1041
+ def self.decorate_dependencies; end
1042
+ def self.eager_load?(autoload_path); end
1043
+ def self.freeze_paths; end
1044
+ def self.setup_autoloaders(enable_reloading); end
1045
+ def self.take_over(enable_reloading:); end
1046
+ end
1047
+ module ActiveSupport::Dependencies::ZeitwerkIntegration::Decorations
1048
+ def autoloaded?(object); end
1049
+ def autoloaded_constants; end
1050
+ def clear; end
1051
+ def constantize(cpath); end
1052
+ def safe_constantize(cpath); end
1053
+ def unhook!; end
1054
+ def verbose=(verbose); end
1055
+ end
1056
+ module ActiveSupport::Dependencies::ZeitwerkIntegration::RequireDependency
1057
+ def require_dependency(filename); end
1058
+ end
1059
+ module ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
1060
+ def self.camelize(basename, _abspath); end
1061
+ def self.inflect(overrides); end
1062
+ end
1063
+ class Method
1064
+ def duplicable?; end
1065
+ end
1066
+ class UnboundMethod
1067
+ def duplicable?; end
1068
+ end
1069
+ module ActiveSupport::Tryable
1070
+ def try!(method_name = nil, *args, &b); end
1071
+ def try(method_name = nil, *args, &b); end
1072
+ end
1073
+ class Delegator < BasicObject
1074
+ include ActiveSupport::Tryable
1075
+ end
1076
+ class DateTime < Date
1077
+ def <=>(other); end
1078
+ def acts_like_date?; end
1079
+ def acts_like_time?; end
1080
+ def advance(options); end
1081
+ def ago(seconds); end
1082
+ def as_json(options = nil); end
1083
+ def at_beginning_of_day; end
1084
+ def at_beginning_of_hour; end
1085
+ def at_beginning_of_minute; end
1086
+ def at_end_of_day; end
1087
+ def at_end_of_hour; end
1088
+ def at_end_of_minute; end
1089
+ def at_midday; end
1090
+ def at_middle_of_day; end
1091
+ def at_midnight; end
1092
+ def at_noon; end
1093
+ def beginning_of_day; end
1094
+ def beginning_of_hour; end
1095
+ def beginning_of_minute; end
1096
+ def blank?; end
1097
+ def change(options); end
1098
+ def default_inspect; end
1099
+ def end_of_day; end
1100
+ def end_of_hour; end
1101
+ def end_of_minute; end
1102
+ def formatted_offset(colon = nil, alternate_utc_string = nil); end
1103
+ def getgm; end
1104
+ def getlocal(utc_offset = nil); end
1105
+ def getutc; end
1106
+ def gmtime; end
1107
+ def in(seconds); end
1108
+ def inspect; end
1109
+ def localtime(utc_offset = nil); end
1110
+ def midday; end
1111
+ def middle_of_day; end
1112
+ def midnight; end
1113
+ def noon; end
1114
+ def nsec; end
1115
+ def offset_in_seconds; end
1116
+ def readable_inspect; end
1117
+ def seconds_since_midnight; end
1118
+ def seconds_since_unix_epoch; end
1119
+ def seconds_until_end_of_day; end
1120
+ def self.civil_from_format(utc_or_local, year, month = nil, day = nil, hour = nil, min = nil, sec = nil); end
1121
+ def self.current; end
1122
+ def since(seconds); end
1123
+ def subsec; end
1124
+ def to_default_s; end
1125
+ def to_f; end
1126
+ def to_formatted_s(format = nil); end
1127
+ def to_i; end
1128
+ def usec; end
1129
+ def utc; end
1130
+ def utc?; end
1131
+ def utc_offset; end
1132
+ include DateAndTime::Compatibility
1133
+ end
1134
+ module ActiveSupport::XmlMini_REXML
1135
+ def collapse(element, depth); end
1136
+ def empty_content?(element); end
1137
+ def get_attributes(element); end
1138
+ def merge!(hash, key, value); end
1139
+ def merge_element!(hash, element, depth); end
1140
+ def merge_texts!(hash, element); end
1141
+ def parse(data); end
1142
+ extend ActiveSupport::XmlMini_REXML
1143
+ end
1144
+ module ActiveSupport::XmlMini
1145
+ def _dasherize(key); end
1146
+ def _parse_binary(bin, entity); end
1147
+ def _parse_file(file, entity); end
1148
+ def backend; end
1149
+ def backend=(name); end
1150
+ def cast_backend_name_to_module(name); end
1151
+ def current_thread_backend; end
1152
+ def current_thread_backend=(name); end
1153
+ def depth; end
1154
+ def depth=(arg0); end
1155
+ def parse(*args, &block); end
1156
+ def rename_key(key, options = nil); end
1157
+ def to_tag(key, value, options); end
1158
+ def with_backend(name); end
1159
+ extend ActiveSupport::XmlMini
1160
+ end
1161
+ module ActiveSupport::XmlMini::FileLike
1162
+ def content_type; end
1163
+ def content_type=(arg0); end
1164
+ def original_filename; end
1165
+ def original_filename=(arg0); end
1166
+ end
1167
+ class ActiveSupport::Duration
1168
+ def %(other); end
1169
+ def *(other); end
1170
+ def +(other); end
1171
+ def -(other); end
1172
+ def -@; end
1173
+ def /(other); end
1174
+ def <=>(other); end
1175
+ def ==(other); end
1176
+ def after(time = nil); end
1177
+ def ago(time = nil); end
1178
+ def as_json(options = nil); end
1179
+ def before(time = nil); end
1180
+ def coerce(other); end
1181
+ def encode_with(coder); end
1182
+ def eql?(other); end
1183
+ def from_now(time = nil); end
1184
+ def hash; end
1185
+ def init_with(coder); end
1186
+ def initialize(value, parts); end
1187
+ def inspect; end
1188
+ def instance_of?(klass); end
1189
+ def is_a?(klass); end
1190
+ def iso8601(precision: nil); end
1191
+ def kind_of?(klass); end
1192
+ def method_missing(method, *args, &block); end
1193
+ def parts; end
1194
+ def parts=(arg0); end
1195
+ def raise_type_error(other); end
1196
+ def respond_to_missing?(method, _); end
1197
+ def self.===(other); end
1198
+ def self.build(value); end
1199
+ def self.calculate_total_seconds(parts); end
1200
+ def self.days(value); end
1201
+ def self.hours(value); end
1202
+ def self.minutes(value); end
1203
+ def self.months(value); end
1204
+ def self.parse(iso8601duration); end
1205
+ def self.seconds(value); end
1206
+ def self.weeks(value); end
1207
+ def self.years(value); end
1208
+ def since(time = nil); end
1209
+ def sum(sign, time = nil); end
1210
+ def to_i; end
1211
+ def to_s; end
1212
+ def until(time = nil); end
1213
+ def value; end
1214
+ def value=(arg0); end
1215
+ end
1216
+ class ActiveSupport::Duration::Scalar < Numeric
1217
+ def %(other); end
1218
+ def *(other); end
1219
+ def +(other); end
1220
+ def -(other); end
1221
+ def -@; end
1222
+ def /(other); end
1223
+ def <=>(other); end
1224
+ def calculate(op, other); end
1225
+ def coerce(other); end
1226
+ def initialize(value); end
1227
+ def raise_type_error(other); end
1228
+ def to_f(*args, &block); end
1229
+ def to_i(*args, &block); end
1230
+ def to_s(*args, &block); end
1231
+ def value; end
1232
+ end
1233
+ class ActiveSupport::TimeZone
1234
+ def <=>(zone); end
1235
+ def =~(re); end
1236
+ def at(*args); end
1237
+ def encode_with(coder); end
1238
+ def formatted_offset(colon = nil, alternate_utc_string = nil); end
1239
+ def init_with(coder); end
1240
+ def initialize(name, utc_offset = nil, tzinfo = nil); end
1241
+ def iso8601(str); end
1242
+ def local(*args); end
1243
+ def local_to_utc(time, dst = nil); end
1244
+ def name; end
1245
+ def now; end
1246
+ def parse(str, now = nil); end
1247
+ def parts_to_time(parts, now); end
1248
+ def period_for_local(time, dst = nil); end
1249
+ def period_for_utc(time); end
1250
+ def periods_for_local(time); end
1251
+ def rfc3339(str); end
1252
+ def self.[](arg); end
1253
+ def self.all; end
1254
+ def self.clear; end
1255
+ def self.country_zones(country_code); end
1256
+ def self.create(*arg0); end
1257
+ def self.find_tzinfo(name); end
1258
+ def self.load_country_zones(code); end
1259
+ def self.new(name); end
1260
+ def self.seconds_to_utc_offset(seconds, colon = nil); end
1261
+ def self.us_zones; end
1262
+ def self.zones_map; end
1263
+ def strptime(str, format, now = nil); end
1264
+ def time_now; end
1265
+ def to_s; end
1266
+ def today; end
1267
+ def tomorrow; end
1268
+ def tzinfo; end
1269
+ def utc_offset; end
1270
+ def utc_to_local(time); end
1271
+ def yesterday; end
1272
+ include Comparable
1273
+ end
1274
+ class ActiveSupport::TimeWithZone
1275
+ def +(other); end
1276
+ def -(other); end
1277
+ def <=>(other); end
1278
+ def acts_like_time?; end
1279
+ def advance(options); end
1280
+ def after?(arg0); end
1281
+ def ago(other); end
1282
+ def as_json(options = nil); end
1283
+ def before?(arg0); end
1284
+ def between?(min, max); end
1285
+ def blank?; end
1286
+ def change(options); end
1287
+ def comparable_time; end
1288
+ def day; end
1289
+ def dst?; end
1290
+ def duration_of_variable_length?(obj); end
1291
+ def encode_with(coder); end
1292
+ def eql?(other); end
1293
+ def formatted_offset(colon = nil, alternate_utc_string = nil); end
1294
+ def freeze; end
1295
+ def future?; end
1296
+ def get_period_and_ensure_valid_local_time(period); end
1297
+ def getgm; end
1298
+ def getlocal(utc_offset = nil); end
1299
+ def getutc; end
1300
+ def gmt?; end
1301
+ def gmt_offset; end
1302
+ def gmtime; end
1303
+ def gmtoff; end
1304
+ def hash; end
1305
+ def hour; end
1306
+ def httpdate; end
1307
+ def in(other); end
1308
+ def in_time_zone(new_zone = nil); end
1309
+ def init_with(coder); end
1310
+ def initialize(utc_time, time_zone, local_time = nil, period = nil); end
1311
+ def inspect; end
1312
+ def is_a?(klass); end
1313
+ def isdst; end
1314
+ def iso8601(fraction_digits = nil); end
1315
+ def kind_of?(klass); end
1316
+ def localtime(utc_offset = nil); end
1317
+ def marshal_dump; end
1318
+ def marshal_load(variables); end
1319
+ def mday; end
1320
+ def method_missing(sym, *args, &block); end
1321
+ def min; end
1322
+ def mon; end
1323
+ def month; end
1324
+ def nsec; end
1325
+ def past?; end
1326
+ def period; end
1327
+ def respond_to?(sym, include_priv = nil); end
1328
+ def respond_to_missing?(sym, include_priv); end
1329
+ def rfc2822; end
1330
+ def rfc3339(fraction_digits = nil); end
1331
+ def rfc822; end
1332
+ def sec; end
1333
+ def self.name; end
1334
+ def since(other); end
1335
+ def strftime(format); end
1336
+ def time; end
1337
+ def time_zone; end
1338
+ def to_a; end
1339
+ def to_date; end
1340
+ def to_datetime; end
1341
+ def to_f; end
1342
+ def to_formatted_s(format = nil); end
1343
+ def to_i; end
1344
+ def to_r; end
1345
+ def to_s(format = nil); end
1346
+ def to_time; end
1347
+ def today?; end
1348
+ def transfer_time_values_to_utc_constructor(time); end
1349
+ def tv_sec; end
1350
+ def usec; end
1351
+ def utc; end
1352
+ def utc?; end
1353
+ def utc_offset; end
1354
+ def wday; end
1355
+ def wrap_with_time_zone(time); end
1356
+ def xmlschema(fraction_digits = nil); end
1357
+ def yday; end
1358
+ def year; end
1359
+ def zone; end
1360
+ include Comparable
1361
+ end
1362
+ module DateAndTime::Zones
1363
+ def in_time_zone(zone = nil); end
1364
+ def time_with_zone(time, zone); end
1365
+ end
1366
+ module DateAndTime::Calculations
1367
+ def after?(date_or_time); end
1368
+ def all_day; end
1369
+ def all_month; end
1370
+ def all_quarter; end
1371
+ def all_week(start_day = nil); end
1372
+ def all_year; end
1373
+ def at_beginning_of_month; end
1374
+ def at_beginning_of_quarter; end
1375
+ def at_beginning_of_week(start_day = nil); end
1376
+ def at_beginning_of_year; end
1377
+ def at_end_of_month; end
1378
+ def at_end_of_quarter; end
1379
+ def at_end_of_week(start_day = nil); end
1380
+ def at_end_of_year; end
1381
+ def before?(date_or_time); end
1382
+ def beginning_of_month; end
1383
+ def beginning_of_quarter; end
1384
+ def beginning_of_week(start_day = nil); end
1385
+ def beginning_of_year; end
1386
+ def copy_time_to(other); end
1387
+ def days_ago(days); end
1388
+ def days_since(days); end
1389
+ def days_span(day); end
1390
+ def days_to_week_start(start_day = nil); end
1391
+ def end_of_month; end
1392
+ def end_of_quarter; end
1393
+ def end_of_week(start_day = nil); end
1394
+ def end_of_year; end
1395
+ def first_hour(date_or_time); end
1396
+ def future?; end
1397
+ def last_hour(date_or_time); end
1398
+ def last_month; end
1399
+ def last_quarter; end
1400
+ def last_week(start_day = nil, same_time: nil); end
1401
+ def last_weekday; end
1402
+ def last_year; end
1403
+ def monday; end
1404
+ def months_ago(months); end
1405
+ def months_since(months); end
1406
+ def next_occurring(day_of_week); end
1407
+ def next_quarter; end
1408
+ def next_week(given_day_in_next_week = nil, same_time: nil); end
1409
+ def next_weekday; end
1410
+ def on_weekday?; end
1411
+ def on_weekend?; end
1412
+ def past?; end
1413
+ def prev_occurring(day_of_week); end
1414
+ def prev_quarter; end
1415
+ def prev_week(start_day = nil, same_time: nil); end
1416
+ def prev_weekday; end
1417
+ def sunday; end
1418
+ def today?; end
1419
+ def tomorrow; end
1420
+ def weeks_ago(weeks); end
1421
+ def weeks_since(weeks); end
1422
+ def years_ago(years); end
1423
+ def years_since(years); end
1424
+ def yesterday; end
1425
+ end
1426
+ class Date
1427
+ def acts_like_date?; end
1428
+ def advance(options); end
1429
+ def ago(seconds); end
1430
+ def as_json(options = nil); end
1431
+ def at_beginning_of_day; end
1432
+ def at_end_of_day; end
1433
+ def at_midday; end
1434
+ def at_middle_of_day; end
1435
+ def at_midnight; end
1436
+ def at_noon; end
1437
+ def beginning_of_day; end
1438
+ def blank?; end
1439
+ def change(options); end
1440
+ def compare_with_coercion(other); end
1441
+ def compare_without_coercion(arg0); end
1442
+ def default_inspect; end
1443
+ def end_of_day; end
1444
+ def in(seconds); end
1445
+ def midday; end
1446
+ def middle_of_day; end
1447
+ def midnight; end
1448
+ def minus_with_duration(other); end
1449
+ def minus_without_duration(arg0); end
1450
+ def noon; end
1451
+ def plus_with_duration(other); end
1452
+ def plus_without_duration(arg0); end
1453
+ def readable_inspect; end
1454
+ def self.beginning_of_week; end
1455
+ def self.beginning_of_week=(week_start); end
1456
+ def self.beginning_of_week_default; end
1457
+ def self.beginning_of_week_default=(arg0); end
1458
+ def self.current; end
1459
+ def self.find_beginning_of_week!(week_start); end
1460
+ def self.tomorrow; end
1461
+ def self.yesterday; end
1462
+ def since(seconds); end
1463
+ def to_default_s; end
1464
+ def to_formatted_s(format = nil); end
1465
+ include DateAndTime::Calculations
1466
+ include DateAndTime::Zones
1467
+ end
1468
+ class Integer < Numeric
1469
+ def month; end
1470
+ def months; end
1471
+ def multiple_of?(number); end
1472
+ def ordinal; end
1473
+ def ordinalize; end
1474
+ def year; end
1475
+ def years; end
1476
+ end
1477
+ class ActiveSupport::XMLConverter
1478
+ def become_array?(value); end
1479
+ def become_content?(value); end
1480
+ def become_empty_string?(value); end
1481
+ def become_hash?(value); end
1482
+ def deep_to_h(value); end
1483
+ def garbage?(value); end
1484
+ def initialize(xml, disallowed_types = nil); end
1485
+ def normalize_keys(params); end
1486
+ def nothing?(value); end
1487
+ def process_array(value); end
1488
+ def process_content(value); end
1489
+ def process_hash(value); end
1490
+ def to_h; end
1491
+ end
1492
+ class ActiveSupport::XMLConverter::DisallowedType < StandardError
1493
+ def initialize(type); end
1494
+ end
1495
+ module ActiveSupport::BigDecimalWithDefaultFormat
1496
+ def to_s(format = nil); end
1497
+ end
1498
+ module ActiveSupport::ToJsonWithActiveSupportEncoder
1499
+ def to_json(options = nil); end
1500
+ end
1501
+ class Struct
1502
+ def as_json(options = nil); end
1503
+ end
1504
+ class Symbol
1505
+ def as_json(options = nil); end
1506
+ end
1507
+ class Float < Numeric
1508
+ def as_json(options = nil); end
1509
+ end
1510
+ class BigDecimal < Numeric
1511
+ def as_json(options = nil); end
1512
+ end
1513
+ class Regexp
1514
+ def as_json(options = nil); end
1515
+ def multiline?; end
1516
+ end
1517
+ module Enumerable
1518
+ def _original_sum_with_required_identity(*arg0); end
1519
+ def as_json(options = nil); end
1520
+ def exclude?(object); end
1521
+ def excluding(*elements); end
1522
+ def including(*elements); end
1523
+ def index_by; end
1524
+ def index_with(default = nil); end
1525
+ def many?; end
1526
+ def pluck(*keys); end
1527
+ def without(*elements); end
1528
+ end
1529
+ class IO
1530
+ def as_json(options = nil); end
1531
+ end
1532
+ class Range
1533
+ def as_json(options = nil); end
1534
+ def overlaps?(other); end
1535
+ def sum(identity = nil); end
1536
+ end
1537
+ class URI::Generic
1538
+ def as_json(options = nil); end
1539
+ end
1540
+ class Pathname
1541
+ def as_json(options = nil); end
1542
+ end
1543
+ class Process::Status
1544
+ def as_json(options = nil); end
1545
+ end
1546
+ class ActiveSupport::OptionMerger
1547
+ def initialize(context, options); end
1548
+ def method_missing(method, *arguments, &block); end
1549
+ end
1550
+ module I18n
1551
+ end
1552
+ class I18n::Railtie < Rails::Railtie
1553
+ def self.include_fallbacks_module; end
1554
+ def self.init_fallbacks(fallbacks); end
1555
+ def self.initialize_i18n(app); end
1556
+ def self.validate_fallbacks(fallbacks); end
1557
+ def self.watched_dirs_with_extensions(paths); end
1558
+ end
1559
+ class ActiveSupport::Railtie < Rails::Railtie
1560
+ end
1561
+ class Class < Module
1562
+ def class_attribute(*attrs, instance_accessor: nil, instance_reader: nil, instance_writer: nil, instance_predicate: nil, default: nil); end
1563
+ def descendants; end
1564
+ def subclasses; end
1565
+ end
1566
+ class ActiveSupport::Messages::RotationConfiguration
1567
+ def encrypted; end
1568
+ def initialize; end
1569
+ def rotate(kind, *args); end
1570
+ def signed; end
1571
+ end
1572
+ module ActiveSupport::Multibyte::Unicode
1573
+ def compose(codepoints); end
1574
+ def decompose(type, codepoints); end
1575
+ def default_normalization_form; end
1576
+ def default_normalization_form=(arg0); end
1577
+ def downcase(string); end
1578
+ def normalize(string, form = nil); end
1579
+ def pack_graphemes(unpacked); end
1580
+ def recode_windows1252_chars(string); end
1581
+ def swapcase(string); end
1582
+ def tidy_bytes(string, force = nil); end
1583
+ def unpack_graphemes(string); end
1584
+ def upcase(string); end
1585
+ extend ActiveSupport::Multibyte::Unicode
1586
+ end
1587
+ class ERB
1588
+ end
1589
+ module ERB::Util
1590
+ def html_escape_once(s); end
1591
+ def json_escape(s); end
1592
+ def self.html_escape_once(s); end
1593
+ def self.json_escape(s); end
1594
+ def self.unwrapped_html_escape(s); end
1595
+ def unwrapped_html_escape(s); end
1596
+ end
1597
+ class ActiveSupport::SafeBuffer < String
1598
+ def %(args); end
1599
+ def *(*arg0); end
1600
+ def +(other); end
1601
+ def <<(value); end
1602
+ def [](*args); end
1603
+ def []=(*args); end
1604
+ def capitalize!(*args); end
1605
+ def capitalize(*args, &block); end
1606
+ def chomp!(*args); end
1607
+ def chomp(*args, &block); end
1608
+ def chop!(*args); end
1609
+ def chop(*args, &block); end
1610
+ def clone_empty; end
1611
+ def concat(value); end
1612
+ def delete!(*args); end
1613
+ def delete(*args, &block); end
1614
+ def delete_prefix!(*args); end
1615
+ def delete_prefix(*args, &block); end
1616
+ def delete_suffix!(*args); end
1617
+ def delete_suffix(*args, &block); end
1618
+ def downcase!(*args); end
1619
+ def downcase(*args, &block); end
1620
+ def encode_with(coder); end
1621
+ def gsub!(*args, &block); end
1622
+ def gsub(*args, &block); end
1623
+ def html_escape_interpolated_argument(arg); end
1624
+ def html_safe?; end
1625
+ def initialize(str = nil); end
1626
+ def initialize_copy(other); end
1627
+ def insert(index, value); end
1628
+ def lstrip!(*args); end
1629
+ def lstrip(*args, &block); end
1630
+ def next!(*args); end
1631
+ def next(*args, &block); end
1632
+ def original_concat(*arg0); end
1633
+ def prepend(value); end
1634
+ def replace(value); end
1635
+ def reverse!(*args); end
1636
+ def reverse(*args, &block); end
1637
+ def rstrip!(*args); end
1638
+ def rstrip(*args, &block); end
1639
+ def safe_concat(value); end
1640
+ def set_block_back_references(block, match_data); end
1641
+ def slice!(*args); end
1642
+ def slice(*args, &block); end
1643
+ def squeeze!(*args); end
1644
+ def squeeze(*args, &block); end
1645
+ def strip!(*args); end
1646
+ def strip(*args, &block); end
1647
+ def sub!(*args, &block); end
1648
+ def sub(*args, &block); end
1649
+ def succ!(*args); end
1650
+ def succ(*args, &block); end
1651
+ def swapcase!(*args); end
1652
+ def swapcase(*args, &block); end
1653
+ def to_param; end
1654
+ def to_s; end
1655
+ def tr!(*args); end
1656
+ def tr(*args, &block); end
1657
+ def tr_s!(*args); end
1658
+ def tr_s(*args, &block); end
1659
+ def unicode_normalize!(*args); end
1660
+ def unicode_normalize(*args, &block); end
1661
+ def upcase!(*args); end
1662
+ def upcase(*args, &block); end
1663
+ end
1664
+ class ActiveSupport::SafeBuffer::SafeConcatError < StandardError
1665
+ def initialize; end
1666
+ end
1667
+ class ActiveSupport::StringInquirer < String
1668
+ def method_missing(method_name, *arguments); end
1669
+ def respond_to_missing?(method_name, include_private = nil); end
1670
+ end
1671
+ module Module::Concerning
1672
+ def concern(topic, &module_definition); end
1673
+ def concerning(topic, &block); end
1674
+ end
1675
+ class ActiveSupport::ArrayInquirer < Array
1676
+ def any?(*candidates); end
1677
+ def method_missing(name, *args); end
1678
+ def respond_to_missing?(name, include_private = nil); end
1679
+ end
1680
+ module ActiveSupport::NumberHelper
1681
+ def number_to_currency(number, options = nil); end
1682
+ def number_to_delimited(number, options = nil); end
1683
+ def number_to_human(number, options = nil); end
1684
+ def number_to_human_size(number, options = nil); end
1685
+ def number_to_percentage(number, options = nil); end
1686
+ def number_to_phone(number, options = nil); end
1687
+ def number_to_rounded(number, options = nil); end
1688
+ extend ActiveSupport::Autoload
1689
+ extend ActiveSupport::NumberHelper
1690
+ end
1691
+ module ActiveSupport::NumericWithFormat
1692
+ def to_s(format = nil, options = nil); end
1693
+ end
1694
+ module URI
1695
+ def self.parser; end
1696
+ end
1697
+ class File < IO
1698
+ def self.atomic_write(file_name, temp_dir = nil); end
1699
+ def self.probe_stat_in(dir); end
1700
+ end
1701
+ module ActiveSupport::RangeWithFormat
1702
+ def to_default_s(format = nil); end
1703
+ def to_formatted_s(format = nil); end
1704
+ def to_s(format = nil); end
1705
+ end
1706
+ module ActiveSupport::CompareWithRange
1707
+ def ===(value); end
1708
+ def cover?(value); end
1709
+ def include?(value); end
1710
+ end
1711
+ module ActiveSupport::IncludeTimeWithZone
1712
+ def include?(value); end
1713
+ end
1714
+ module ActiveSupport::EachTimeWithZone
1715
+ def each(&block); end
1716
+ def ensure_iteration_allowed; end
1717
+ def step(n = nil, &block); end
1718
+ end
1719
+ module Benchmark
1720
+ def self.ms; end
1721
+ end
1722
+ module Digest
1723
+ end
1724
+ module Digest::UUID
1725
+ def self.uuid_from_hash(hash_class, uuid_namespace, name); end
1726
+ def self.uuid_v3(uuid_namespace, name); end
1727
+ def self.uuid_v4; end
1728
+ def self.uuid_v5(uuid_namespace, name); end
1729
+ end
1730
+ module ActiveSupport::MarshalWithAutoloading
1731
+ def load(source, proc = nil); end
1732
+ end
1733
+ module SecureRandom
1734
+ def self.base36(n = nil); end
1735
+ def self.base58(n = nil); end
1736
+ end
1737
+ class ActiveSupport::Concurrency::LoadInterlockAwareMonitor < Monitor
1738
+ def mon_enter; end
1739
+ end
1740
+ module ActiveSupport::DescendantsTracker
1741
+ def descendants; end
1742
+ def direct_descendants; end
1743
+ def inherited(base); end
1744
+ def self.accumulate_descendants(klass, acc); end
1745
+ def self.clear; end
1746
+ def self.descendants(klass); end
1747
+ def self.direct_descendants(klass); end
1748
+ def self.store_inherited(klass, descendant); end
1749
+ end
1750
+ class ActiveSupport::DescendantsTracker::DescendantsArray
1751
+ def <<(klass); end
1752
+ def cleanup!; end
1753
+ def each; end
1754
+ def initialize; end
1755
+ def initialize_copy(orig); end
1756
+ def refs_size; end
1757
+ def reject!; end
1758
+ include Enumerable
1759
+ end
1760
+ module ActiveSupport::Callbacks
1761
+ def halted_callback_hook(filter); end
1762
+ def run_callbacks(kind); end
1763
+ extend ActiveSupport::Concern
1764
+ end
1765
+ module ActiveSupport::Callbacks::Conditionals
1766
+ end
1767
+ class ActiveSupport::Callbacks::Conditionals::Value
1768
+ def call(target, value); end
1769
+ def initialize(&block); end
1770
+ end
1771
+ module ActiveSupport::Callbacks::Filters
1772
+ end
1773
+ class ActiveSupport::Callbacks::Filters::Environment < Struct
1774
+ def halted; end
1775
+ def halted=(_); end
1776
+ def self.[](*arg0); end
1777
+ def self.inspect; end
1778
+ def self.members; end
1779
+ def self.new(*arg0); end
1780
+ def target; end
1781
+ def target=(_); end
1782
+ def value; end
1783
+ def value=(_); end
1784
+ end
1785
+ class ActiveSupport::Callbacks::Filters::Before
1786
+ def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter); end
1787
+ def self.halting(callback_sequence, user_callback, halted_lambda, filter); end
1788
+ def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter); end
1789
+ end
1790
+ class ActiveSupport::Callbacks::Filters::After
1791
+ def self.build(callback_sequence, user_callback, user_conditions, chain_config); end
1792
+ def self.conditional(callback_sequence, user_callback, user_conditions); end
1793
+ def self.halting(callback_sequence, user_callback); end
1794
+ def self.halting_and_conditional(callback_sequence, user_callback, user_conditions); end
1795
+ def self.simple(callback_sequence, user_callback); end
1796
+ end
1797
+ class ActiveSupport::Callbacks::Callback
1798
+ def apply(callback_sequence); end
1799
+ def chain_config; end
1800
+ def check_conditionals(conditionals); end
1801
+ def compute_identifier(filter); end
1802
+ def conditions_lambdas; end
1803
+ def current_scopes; end
1804
+ def duplicates?(other); end
1805
+ def filter; end
1806
+ def initialize(name, filter, kind, options, chain_config); end
1807
+ def kind; end
1808
+ def kind=(arg0); end
1809
+ def matches?(_kind, _filter); end
1810
+ def merge_conditional_options(chain, if_option:, unless_option:); end
1811
+ def name; end
1812
+ def name=(arg0); end
1813
+ def raw_filter; end
1814
+ def self.build(chain, filter, kind, options); end
1815
+ end
1816
+ class ActiveSupport::Callbacks::CallTemplate
1817
+ def expand(target, value, block); end
1818
+ def initialize(target, method, arguments, block); end
1819
+ def inverted_lambda; end
1820
+ def make_lambda; end
1821
+ def self.build(filter, callback); end
1822
+ end
1823
+ class ActiveSupport::Callbacks::CallbackSequence
1824
+ def after(&after); end
1825
+ def around(call_template, user_conditions); end
1826
+ def before(&before); end
1827
+ def expand_call_template(arg, block); end
1828
+ def final?; end
1829
+ def initialize(nested = nil, call_template = nil, user_conditions = nil); end
1830
+ def invoke_after(arg); end
1831
+ def invoke_before(arg); end
1832
+ def nested; end
1833
+ def skip?(arg); end
1834
+ end
1835
+ class ActiveSupport::Callbacks::CallbackChain
1836
+ def append(*callbacks); end
1837
+ def append_one(callback); end
1838
+ def chain; end
1839
+ def clear; end
1840
+ def compile; end
1841
+ def config; end
1842
+ def default_terminator; end
1843
+ def delete(o); end
1844
+ def each(&block); end
1845
+ def empty?; end
1846
+ def index(o); end
1847
+ def initialize(name, config); end
1848
+ def initialize_copy(other); end
1849
+ def insert(index, o); end
1850
+ def name; end
1851
+ def prepend(*callbacks); end
1852
+ def prepend_one(callback); end
1853
+ def remove_duplicates(callback); end
1854
+ include Enumerable
1855
+ end
1856
+ module ActiveSupport::Callbacks::ClassMethods
1857
+ def __update_callbacks(name); end
1858
+ def define_callbacks(*names); end
1859
+ def get_callbacks(name); end
1860
+ def normalize_callback_params(filters, block); end
1861
+ def reset_callbacks(name); end
1862
+ def set_callback(name, *filter_list, &block); end
1863
+ def set_callbacks(name, callbacks); end
1864
+ def skip_callback(name, *filter_list, &block); end
1865
+ end
1866
+ module ActiveSupport::JSON
1867
+ def self.convert_dates_from(data); end
1868
+ def self.decode(json); end
1869
+ def self.encode(value, options = nil); end
1870
+ def self.parse_error; end
1871
+ end
1872
+ module ActiveSupport::JSON::Encoding
1873
+ def self.escape_html_entities_in_json; end
1874
+ def self.escape_html_entities_in_json=(arg0); end
1875
+ def self.json_encoder; end
1876
+ def self.json_encoder=(arg0); end
1877
+ def self.time_precision; end
1878
+ def self.time_precision=(arg0); end
1879
+ def self.use_standard_json_time_format; end
1880
+ def self.use_standard_json_time_format=(arg0); end
1881
+ end
1882
+ class ActiveSupport::JSON::Encoding::JSONGemEncoder
1883
+ def encode(value); end
1884
+ def initialize(options = nil); end
1885
+ def jsonify(value); end
1886
+ def options; end
1887
+ def stringify(jsonified); end
1888
+ end
1889
+ class ActiveSupport::JSON::Encoding::JSONGemEncoder::EscapedString < String
1890
+ def to_json(*arg0); end
1891
+ def to_s; end
1892
+ end
1893
+ class ActiveSupport::Multibyte::Chars
1894
+ def <=>(*args, &block); end
1895
+ def =~(*args, &block); end
1896
+ def acts_like_string?(*args, &block); end
1897
+ def as_json(options = nil); end
1898
+ def chars(string); end
1899
+ def compose; end
1900
+ def decompose; end
1901
+ def grapheme_length; end
1902
+ def initialize(string); end
1903
+ def limit(limit); end
1904
+ def method_missing(method, *args, &block); end
1905
+ def normalize(form = nil); end
1906
+ def respond_to_missing?(method, include_private); end
1907
+ def reverse!(*args); end
1908
+ def reverse; end
1909
+ def self.consumes?(string); end
1910
+ def slice!(*args); end
1911
+ def split(*args); end
1912
+ def tidy_bytes!(*args); end
1913
+ def tidy_bytes(force = nil); end
1914
+ def titlecase; end
1915
+ def titleize; end
1916
+ def to_s; end
1917
+ def to_str; end
1918
+ def wrapped_string; end
1919
+ include Comparable
1920
+ end
1921
+ module ActiveSupport::ActionableError
1922
+ def self.actions(error); end
1923
+ def self.dispatch(error, name); end
1924
+ extend ActiveSupport::Concern
1925
+ end
1926
+ class ActiveSupport::ActionableError::NonActionable < StandardError
1927
+ end
1928
+ module ActiveSupport::ActionableError::ClassMethods
1929
+ def action(name, &block); end
1930
+ end
1931
+ class ActiveSupport::ParameterFilter
1932
+ def compiled_filter; end
1933
+ def filter(params); end
1934
+ def filter_param(key, value); end
1935
+ def initialize(filters = nil, mask: nil); end
1936
+ end
1937
+ class ActiveSupport::ParameterFilter::CompiledFilter
1938
+ def blocks; end
1939
+ def call(params, parents = nil, original_params = nil); end
1940
+ def deep_regexps; end
1941
+ def initialize(regexps, deep_regexps, blocks, mask:); end
1942
+ def regexps; end
1943
+ def self.compile(filters, mask:); end
1944
+ def value_for_key(key, value, parents = nil, original_params = nil); end
1945
+ end
1946
+ module ActiveSupport::Benchmarkable
1947
+ def benchmark(message = nil, options = nil); end
1948
+ end
1949
+ class ActiveSupport::FileUpdateChecker
1950
+ def compile_ext(array); end
1951
+ def compile_glob(hash); end
1952
+ def escape(key); end
1953
+ def execute; end
1954
+ def execute_if_updated; end
1955
+ def initialize(files, dirs = nil, &block); end
1956
+ def max_mtime(paths); end
1957
+ def updated?; end
1958
+ def updated_at(paths); end
1959
+ def watched; end
1960
+ end
1961
+ class ActiveSupport::ExecutionWrapper
1962
+ def __callbacks; end
1963
+ def __callbacks?; end
1964
+ def _complete_callbacks; end
1965
+ def _run_callbacks; end
1966
+ def _run_complete_callbacks(&block); end
1967
+ def _run_run_callbacks(&block); end
1968
+ def complete!; end
1969
+ def hook_state; end
1970
+ def run!; end
1971
+ def self.__callbacks; end
1972
+ def self.__callbacks=(val); end
1973
+ def self.__callbacks?; end
1974
+ def self._complete_callbacks; end
1975
+ def self._complete_callbacks=(value); end
1976
+ def self._run_callbacks; end
1977
+ def self._run_callbacks=(value); end
1978
+ def self.active; end
1979
+ def self.active=(arg0); end
1980
+ def self.active?; end
1981
+ def self.inherited(other); end
1982
+ def self.register_hook(hook, outer: nil); end
1983
+ def self.run!; end
1984
+ def self.to_complete(*args, &block); end
1985
+ def self.to_run(*args, &block); end
1986
+ def self.wrap; end
1987
+ extend ActiveSupport::Callbacks::ClassMethods
1988
+ extend ActiveSupport::DescendantsTracker
1989
+ include ActiveSupport::Callbacks
1990
+ end
1991
+ class ActiveSupport::ExecutionWrapper::RunHook < Struct
1992
+ def before(target); end
1993
+ def hook; end
1994
+ def hook=(_); end
1995
+ def self.[](*arg0); end
1996
+ def self.inspect; end
1997
+ def self.members; end
1998
+ def self.new(*arg0); end
1999
+ end
2000
+ class ActiveSupport::ExecutionWrapper::CompleteHook < Struct
2001
+ def after(target); end
2002
+ def before(target); end
2003
+ def hook; end
2004
+ def hook=(_); end
2005
+ def self.[](*arg0); end
2006
+ def self.inspect; end
2007
+ def self.members; end
2008
+ def self.new(*arg0); end
2009
+ end
2010
+ class ActiveSupport::Executor < ActiveSupport::ExecutionWrapper
2011
+ end
2012
+ class ActiveSupport::Reloader < ActiveSupport::ExecutionWrapper
2013
+ def _class_unload_callbacks; end
2014
+ def _prepare_callbacks; end
2015
+ def _run_class_unload_callbacks(&block); end
2016
+ def _run_prepare_callbacks(&block); end
2017
+ def check; end
2018
+ def check=(val); end
2019
+ def check?; end
2020
+ def class_unload!(&block); end
2021
+ def complete!; end
2022
+ def executor; end
2023
+ def executor=(val); end
2024
+ def executor?; end
2025
+ def initialize; end
2026
+ def release_unload_lock!; end
2027
+ def require_unload_lock!; end
2028
+ def run!; end
2029
+ def self.__callbacks; end
2030
+ def self._class_unload_callbacks; end
2031
+ def self._class_unload_callbacks=(value); end
2032
+ def self._prepare_callbacks; end
2033
+ def self._prepare_callbacks=(value); end
2034
+ def self.after_class_unload(*args, &block); end
2035
+ def self.before_class_unload(*args, &block); end
2036
+ def self.check!; end
2037
+ def self.check; end
2038
+ def self.check=(val); end
2039
+ def self.check?; end
2040
+ def self.executor; end
2041
+ def self.executor=(val); end
2042
+ def self.executor?; end
2043
+ def self.prepare!; end
2044
+ def self.reload!; end
2045
+ def self.reloaded!; end
2046
+ def self.run!; end
2047
+ def self.to_prepare(*args, &block); end
2048
+ def self.wrap; end
2049
+ end
2050
+ module ActiveSupport::TaggedLogging
2051
+ def clear_tags!(*args, &block); end
2052
+ def flush; end
2053
+ def pop_tags(*args, &block); end
2054
+ def push_tags(*args, &block); end
2055
+ def self.new(logger); end
2056
+ def tagged(*tags); end
2057
+ end
2058
+ module ActiveSupport::TaggedLogging::Formatter
2059
+ def call(severity, timestamp, progname, msg); end
2060
+ def clear_tags!; end
2061
+ def current_tags; end
2062
+ def pop_tags(size = nil); end
2063
+ def push_tags(*tags); end
2064
+ def tagged(*tags); end
2065
+ def tags_text; end
2066
+ end
2067
+ module ActiveSupport::Cache
2068
+ def self.expand_cache_key(key, namespace = nil); end
2069
+ def self.lookup_store(*store_option); end
2070
+ def self.retrieve_cache_key(key); end
2071
+ def self.retrieve_store_class(store); end
2072
+ end
2073
+ module ActiveSupport::Cache::Strategy
2074
+ end
2075
+ class ActiveSupport::Cache::Store
2076
+ def cleanup(options = nil); end
2077
+ def clear(options = nil); end
2078
+ def decrement(name, amount = nil, options = nil); end
2079
+ def delete(name, options = nil); end
2080
+ def delete_entry(key, options); end
2081
+ def delete_matched(matcher, options = nil); end
2082
+ def exist?(name, options = nil); end
2083
+ def expanded_key(key); end
2084
+ def expanded_version(key); end
2085
+ def fetch(name, options = nil); end
2086
+ def fetch_multi(*names); end
2087
+ def get_entry_value(entry, name, options); end
2088
+ def handle_expired_entry(entry, key, options); end
2089
+ def increment(name, amount = nil, options = nil); end
2090
+ def initialize(options = nil); end
2091
+ def instrument(operation, key, options = nil); end
2092
+ def key_matcher(pattern, options); end
2093
+ def log; end
2094
+ def logger; end
2095
+ def logger=(obj); end
2096
+ def merged_options(call_options); end
2097
+ def mute; end
2098
+ def namespace_key(key, options = nil); end
2099
+ def normalize_key(key, options = nil); end
2100
+ def normalize_version(key, options = nil); end
2101
+ def options; end
2102
+ def read(name, options = nil); end
2103
+ def read_entry(key, options); end
2104
+ def read_multi(*names); end
2105
+ def read_multi_entries(names, options); end
2106
+ def save_block_result_to_cache(name, options); end
2107
+ def self.ensure_connection_pool_added!; end
2108
+ def self.logger; end
2109
+ def self.logger=(obj); end
2110
+ def self.retrieve_pool_options(options); end
2111
+ def silence!; end
2112
+ def silence; end
2113
+ def silence?; end
2114
+ def write(name, value, options = nil); end
2115
+ def write_entry(key, entry, options); end
2116
+ def write_multi(hash, options = nil); end
2117
+ def write_multi_entries(hash, options); end
2118
+ end
2119
+ class ActiveSupport::Cache::Entry
2120
+ def compress!(compress_threshold); end
2121
+ def compressed?; end
2122
+ def dup_value!; end
2123
+ def expired?; end
2124
+ def expires_at; end
2125
+ def expires_at=(value); end
2126
+ def initialize(value, compress: nil, compress_threshold: nil, version: nil, expires_in: nil, **arg5); end
2127
+ def mismatched?(version); end
2128
+ def size; end
2129
+ def uncompress(value); end
2130
+ def value; end
2131
+ def version; end
2132
+ end
2133
+ module ActiveSupport::Cache::Strategy::LocalCache
2134
+ def bypass_local_cache; end
2135
+ def cleanup(options = nil); end
2136
+ def clear(options = nil); end
2137
+ def decrement(name, amount = nil, options = nil); end
2138
+ def delete_entry(key, options); end
2139
+ def increment(name, amount = nil, options = nil); end
2140
+ def local_cache; end
2141
+ def local_cache_key; end
2142
+ def middleware; end
2143
+ def read_entry(key, options); end
2144
+ def read_multi_entries(keys, options); end
2145
+ def use_temporary_local_cache(temporary_cache); end
2146
+ def with_local_cache; end
2147
+ def write_cache_value(name, value, options); end
2148
+ def write_entry(key, entry, options); end
2149
+ end
2150
+ class ActiveSupport::Cache::Strategy::LocalCache::LocalCacheRegistry
2151
+ def cache_for(local_cache_key); end
2152
+ def initialize; end
2153
+ def self.cache_for(l); end
2154
+ def self.set_cache_for(l, v); end
2155
+ def set_cache_for(local_cache_key, value); end
2156
+ extend ActiveSupport::PerThreadRegistry
2157
+ end
2158
+ class ActiveSupport::Cache::Strategy::LocalCache::LocalStore < ActiveSupport::Cache::Store
2159
+ def clear(options = nil); end
2160
+ def delete_entry(key, options); end
2161
+ def fetch_entry(key, options = nil); end
2162
+ def initialize; end
2163
+ def read_entry(key, options); end
2164
+ def read_multi_entries(keys, options); end
2165
+ def synchronize; end
2166
+ def write_entry(key, value, options); end
2167
+ end
2168
+ class ActiveSupport::Cache::NullStore < ActiveSupport::Cache::Store
2169
+ def cleanup(options = nil); end
2170
+ def clear(options = nil); end
2171
+ def decrement(name, amount = nil, options = nil); end
2172
+ def delete_entry(key, options); end
2173
+ def delete_matched(matcher, options = nil); end
2174
+ def increment(name, amount = nil, options = nil); end
2175
+ def read_entry(key, options); end
2176
+ def self.supports_cache_versioning?; end
2177
+ def write_entry(key, entry, options); end
2178
+ end
2179
+ class ActiveSupport::Cache::Strategy::LocalCache::Middleware
2180
+ def call(env); end
2181
+ def initialize(name, local_cache_key); end
2182
+ def local_cache_key; end
2183
+ def name; end
2184
+ def new(app); end
2185
+ end
2186
+ class ActiveSupport::Subscriber
2187
+ def self.add_event_subscriber(event); end
2188
+ def self.attach_to(namespace, subscriber = nil, notifier = nil); end
2189
+ def self.detach_from(namespace, notifier = nil); end
2190
+ def self.find_attached_subscriber; end
2191
+ def self.invalid_event?(event); end
2192
+ def self.method_added(event); end
2193
+ def self.namespace; end
2194
+ def self.notifier; end
2195
+ def self.pattern_subscribed?(pattern); end
2196
+ def self.prepare_pattern(event); end
2197
+ def self.remove_event_subscriber(event); end
2198
+ def self.subscriber; end
2199
+ def self.subscribers; end
2200
+ end
2201
+ class ActiveSupport::SubscriberQueueRegistry
2202
+ def get_queue(queue_key); end
2203
+ def initialize; end
2204
+ extend ActiveSupport::PerThreadRegistry
2205
+ end
2206
+ class ActiveSupport::LogSubscriber < ActiveSupport::Subscriber
2207
+ def self.colorize_logging; end
2208
+ def self.colorize_logging=(obj); end
2209
+ def self.flush_all!; end
2210
+ def self.log_subscribers; end
2211
+ def self.logger; end
2212
+ def self.logger=(arg0); end
2213
+ end
2214
+ class ActiveSupport::BacktraceCleaner
2215
+ def add_filter(&block); end
2216
+ def add_gem_filter; end
2217
+ def add_gem_silencer; end
2218
+ def add_silencer(&block); end
2219
+ def add_stdlib_silencer; end
2220
+ def clean(backtrace, kind = nil); end
2221
+ def filter(backtrace, kind = nil); end
2222
+ def filter_backtrace(backtrace); end
2223
+ def initialize; end
2224
+ def noise(backtrace); end
2225
+ def remove_filters!; end
2226
+ def remove_silencers!; end
2227
+ def silence(backtrace); end
2228
+ end
2229
+ class ActiveSupport::Cache::MemoryStore < ActiveSupport::Cache::Store
2230
+ def cached_size(key, entry); end
2231
+ def cleanup(options = nil); end
2232
+ def clear(options = nil); end
2233
+ def decrement(name, amount = nil, options = nil); end
2234
+ def delete_entry(key, options); end
2235
+ def delete_matched(matcher, options = nil); end
2236
+ def increment(name, amount = nil, options = nil); end
2237
+ def initialize(options = nil); end
2238
+ def inspect; end
2239
+ def modify_value(name, amount, options); end
2240
+ def prune(target_size, max_time = nil); end
2241
+ def pruning?; end
2242
+ def read_entry(key, options); end
2243
+ def self.supports_cache_versioning?; end
2244
+ def synchronize(&block); end
2245
+ def write_entry(key, entry, options); end
2246
+ end
2247
+ class ActiveSupport::Digest
2248
+ def self.hash_digest_class; end
2249
+ def self.hash_digest_class=(klass); end
2250
+ def self.hexdigest(arg); end
2251
+ end
2252
+ module ActiveSupport::Rescuable
2253
+ def handler_for_rescue(exception); end
2254
+ def rescue_with_handler(exception); end
2255
+ extend ActiveSupport::Concern
2256
+ end
2257
+ module ActiveSupport::Rescuable::ClassMethods
2258
+ def constantize_rescue_handler_class(class_or_name); end
2259
+ def find_rescue_handler(exception); end
2260
+ def handler_for_rescue(exception, object: nil); end
2261
+ def rescue_from(*klasses, with: nil, &block); end
2262
+ def rescue_with_handler(exception, object: nil, visited_exceptions: nil); end
2263
+ end
2264
+ module ActiveSupport::Testing
2265
+ end
2266
+ module ActiveSupport::Testing::TaggedLogging
2267
+ def before_setup; end
2268
+ def tagged_logger; end
2269
+ def tagged_logger=(arg0); end
2270
+ end
2271
+ module ActiveSupport::Testing::SetupAndTeardown
2272
+ def after_teardown; end
2273
+ def before_setup; end
2274
+ def self.prepended(klass); end
2275
+ end
2276
+ module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
2277
+ def setup(*args, &block); end
2278
+ def teardown(*args, &block); end
2279
+ end
2280
+ module ActiveSupport::Testing::Assertions
2281
+ def assert_changes(expression, message = nil, from: nil, to: nil, &block); end
2282
+ def assert_difference(expression, *args, &block); end
2283
+ def assert_no_changes(expression, message = nil, &block); end
2284
+ def assert_no_difference(expression, message = nil, &block); end
2285
+ def assert_not(object, message = nil); end
2286
+ def assert_nothing_raised; end
2287
+ end
2288
+ module ActiveSupport::Testing::Deprecation
2289
+ def assert_deprecated(match = nil, deprecator = nil, &block); end
2290
+ def assert_not_deprecated(deprecator = nil, &block); end
2291
+ def collect_deprecations(deprecator = nil); end
2292
+ end
2293
+ module ActiveSupport::Testing::Declarative
2294
+ def test(name, &block); end
2295
+ end
2296
+ module ActiveSupport::Testing::Isolation
2297
+ def run; end
2298
+ def self.forking_env?; end
2299
+ def self.included(klass); end
2300
+ include ActiveSupport::Testing::Isolation::Forking
2301
+ end
2302
+ module ActiveSupport::Testing::Isolation::Forking
2303
+ def run_in_isolation(&blk); end
2304
+ end
2305
+ module ActiveSupport::Testing::Isolation::Subprocess
2306
+ def run_in_isolation(&blk); end
2307
+ end
2308
+ module ActiveSupport::Testing::ConstantLookup
2309
+ extend ActiveSupport::Concern
2310
+ end
2311
+ module ActiveSupport::Testing::ConstantLookup::ClassMethods
2312
+ def determine_constant_from_test_name(test_name); end
2313
+ end
2314
+ class ActiveSupport::Testing::SimpleStubs
2315
+ def initialize; end
2316
+ def stub_object(object, method_name, &block); end
2317
+ def stubbing(object, method_name); end
2318
+ def unstub_all!; end
2319
+ def unstub_object(stub); end
2320
+ end
2321
+ class ActiveSupport::Testing::SimpleStubs::Stub < Struct
2322
+ def method_name; end
2323
+ def method_name=(_); end
2324
+ def object; end
2325
+ def object=(_); end
2326
+ def original_method; end
2327
+ def original_method=(_); end
2328
+ def self.[](*arg0); end
2329
+ def self.inspect; end
2330
+ def self.members; end
2331
+ def self.new(*arg0); end
2332
+ end
2333
+ module ActiveSupport::Testing::TimeHelpers
2334
+ def after_teardown; end
2335
+ def freeze_time(&block); end
2336
+ def simple_stubs; end
2337
+ def travel(duration, &block); end
2338
+ def travel_back; end
2339
+ def travel_to(date_or_time); end
2340
+ def unfreeze_time; end
2341
+ end
2342
+ module ActiveSupport::Testing::FileFixtures
2343
+ def file_fixture(fixture_name); end
2344
+ extend ActiveSupport::Concern
2345
+ end
2346
+ class ActiveSupport::Testing::Parallelization
2347
+ def <<(work); end
2348
+ def add_setup_exception(result, setup_exception); end
2349
+ def after_fork(worker); end
2350
+ def after_fork_hooks; end
2351
+ def initialize(queue_size); end
2352
+ def run_cleanup(worker); end
2353
+ def run_cleanup_hooks; end
2354
+ def self.after_fork_hook(&blk); end
2355
+ def self.after_fork_hooks; end
2356
+ def self.run_cleanup_hook(&blk); end
2357
+ def self.run_cleanup_hooks; end
2358
+ def shutdown; end
2359
+ def start; end
2360
+ end
2361
+ class ActiveSupport::Testing::Parallelization::Server
2362
+ def <<(o); end
2363
+ def initialize; end
2364
+ def length; end
2365
+ def pop; end
2366
+ def record(reporter, result); end
2367
+ include DRb::DRbUndumped
2368
+ end
2369
+ class ActiveSupport::TestCase < Minitest::Test
2370
+ def __callbacks; end
2371
+ def __callbacks?; end
2372
+ def _run_setup_callbacks(&block); end
2373
+ def _run_teardown_callbacks(&block); end
2374
+ def _setup_callbacks; end
2375
+ def _teardown_callbacks; end
2376
+ def assert_no_match(matcher, obj, msg = nil); end
2377
+ def assert_not_empty(obj, msg = nil); end
2378
+ def assert_not_equal(exp, act, msg = nil); end
2379
+ def assert_not_in_delta(exp, act, delta = nil, msg = nil); end
2380
+ def assert_not_in_epsilon(a, b, epsilon = nil, msg = nil); end
2381
+ def assert_not_includes(collection, obj, msg = nil); end
2382
+ def assert_not_instance_of(cls, obj, msg = nil); end
2383
+ def assert_not_kind_of(cls, obj, msg = nil); end
2384
+ def assert_not_nil(obj, msg = nil); end
2385
+ def assert_not_operator(o1, op, o2 = nil, msg = nil); end
2386
+ def assert_not_predicate(o1, op, msg = nil); end
2387
+ def assert_not_respond_to(obj, meth, msg = nil); end
2388
+ def assert_not_same(exp, act, msg = nil); end
2389
+ def assert_raise(*exp); end
2390
+ def file_fixture_path; end
2391
+ def file_fixture_path?; end
2392
+ def method_name; end
2393
+ def self.__callbacks; end
2394
+ def self.__callbacks=(val); end
2395
+ def self.__callbacks?; end
2396
+ def self._setup_callbacks; end
2397
+ def self._setup_callbacks=(value); end
2398
+ def self._teardown_callbacks; end
2399
+ def self._teardown_callbacks=(value); end
2400
+ def self.file_fixture_path; end
2401
+ def self.file_fixture_path=(val); end
2402
+ def self.file_fixture_path?; end
2403
+ def self.parallelize(workers: nil, with: nil); end
2404
+ def self.parallelize_setup(&block); end
2405
+ def self.parallelize_teardown(&block); end
2406
+ def self.test_order; end
2407
+ def self.test_order=(new_order); end
2408
+ extend ActiveSupport::Callbacks::ClassMethods
2409
+ extend ActiveSupport::DescendantsTracker
2410
+ extend ActiveSupport::Testing::Declarative
2411
+ extend ActiveSupport::Testing::SetupAndTeardown::ClassMethods
2412
+ extend Rails::LineFiltering
2413
+ include ActiveSupport::Callbacks
2414
+ include ActiveSupport::Testing::Assertions
2415
+ include ActiveSupport::Testing::Deprecation
2416
+ include ActiveSupport::Testing::FileFixtures
2417
+ include ActiveSupport::Testing::TaggedLogging
2418
+ include ActiveSupport::Testing::TimeHelpers
2419
+ end
2420
+ module ActiveSupport::Configurable
2421
+ def config; end
2422
+ extend ActiveSupport::Concern
2423
+ end
2424
+ class ActiveSupport::Configurable::Configuration < ActiveSupport::InheritableOptions
2425
+ def compile_methods!; end
2426
+ def self.compile_methods!(keys); end
2427
+ end
2428
+ module ActiveSupport::Configurable::ClassMethods
2429
+ def config; end
2430
+ def config_accessor(*names, instance_reader: nil, instance_writer: nil, instance_accessor: nil); end
2431
+ def configure; end
2432
+ end
2433
+ module ActiveSupport::Testing::Stream
2434
+ def capture(stream); end
2435
+ def quietly; end
2436
+ def silence_stream(stream); end
2437
+ end