From 7ddddbde64bb61c2113121678c64b87b10c81cb0 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" Date: Thu, 24 Oct 2024 04:58:01 +0000 Subject: [PATCH] Update RBIs [dependabot skip] --- ...ack@7.1.3.4.rbi => actionpack@7.2.1.2.rbi} | 247 +++-- ...iew@7.1.3.4.rbi => actionview@7.2.1.2.rbi} | 443 ++++----- ...el@7.1.3.4.rbi => activemodel@7.2.1.2.rbi} | 74 +- ...d@7.1.3.4.rbi => activerecord@7.2.1.2.rbi} | 842 +++++++++++------- ...@7.1.3.4.rbi => activesupport@7.2.1.2.rbi} | 290 +++--- ...by@1.3.3.rbi => concurrent-ruby@1.3.4.rbi} | 4 + .../gems/{i18n@1.14.5.rbi => i18n@1.14.6.rbi} | 1 + sorbet/rbi/gems/logger@1.6.1.rbi | 114 +++ ...initest@5.24.1.rbi => minitest@5.25.1.rbi} | 2 +- sorbet/rbi/gems/mutex_m@0.2.0.rbi | 29 - .../gems/{rack@2.2.9.rbi => rack@2.2.10.rbi} | 6 +- .../{rackup@1.0.0.rbi => rackup@1.0.1.rbi} | 5 +- ...lties@7.1.3.4.rbi => railties@7.2.1.2.rbi} | 116 +-- .../gems/{rdoc@6.6.3.1.rbi => rdoc@6.7.0.rbi} | 4 +- .../{reline@0.5.0.rbi => reline@0.5.10.rbi} | 1 + sorbet/rbi/gems/securerandom@0.3.1.rbi | 49 + ...{stringio@3.1.0.rbi => stringio@3.1.1.rbi} | 1 + .../gems/{thor@1.3.1.rbi => thor@1.3.2.rbi} | 3 + sorbet/rbi/gems/useragent@0.16.10.rbi | 9 + .../{webrick@1.8.1.rbi => webrick@1.8.2.rbi} | 12 + ...zeitwerk@2.6.13.rbi => zeitwerk@2.7.1.rbi} | 67 +- 21 files changed, 1362 insertions(+), 957 deletions(-) rename sorbet/rbi/gems/{actionpack@7.1.3.4.rbi => actionpack@7.2.1.2.rbi} (96%) rename sorbet/rbi/gems/{actionview@7.1.3.4.rbi => actionview@7.2.1.2.rbi} (88%) rename sorbet/rbi/gems/{activemodel@7.1.3.4.rbi => activemodel@7.2.1.2.rbi} (95%) rename sorbet/rbi/gems/{activerecord@7.1.3.4.rbi => activerecord@7.2.1.2.rbi} (94%) rename sorbet/rbi/gems/{activesupport@7.1.3.4.rbi => activesupport@7.2.1.2.rbi} (95%) rename sorbet/rbi/gems/{concurrent-ruby@1.3.3.rbi => concurrent-ruby@1.3.4.rbi} (99%) rename sorbet/rbi/gems/{i18n@1.14.5.rbi => i18n@1.14.6.rbi} (99%) create mode 100644 sorbet/rbi/gems/logger@1.6.1.rbi rename sorbet/rbi/gems/{minitest@5.24.1.rbi => minitest@5.25.1.rbi} (99%) delete mode 100644 sorbet/rbi/gems/mutex_m@0.2.0.rbi rename sorbet/rbi/gems/{rack@2.2.9.rbi => rack@2.2.10.rbi} (99%) rename sorbet/rbi/gems/{rackup@1.0.0.rbi => rackup@1.0.1.rbi} (63%) rename sorbet/rbi/gems/{railties@7.1.3.4.rbi => railties@7.2.1.2.rbi} (93%) rename sorbet/rbi/gems/{rdoc@6.6.3.1.rbi => rdoc@6.7.0.rbi} (99%) rename sorbet/rbi/gems/{reline@0.5.0.rbi => reline@0.5.10.rbi} (99%) create mode 100644 sorbet/rbi/gems/securerandom@0.3.1.rbi rename sorbet/rbi/gems/{stringio@3.1.0.rbi => stringio@3.1.1.rbi} (99%) rename sorbet/rbi/gems/{thor@1.3.1.rbi => thor@1.3.2.rbi} (99%) create mode 100644 sorbet/rbi/gems/useragent@0.16.10.rbi rename sorbet/rbi/gems/{webrick@1.8.1.rbi => webrick@1.8.2.rbi} (97%) rename sorbet/rbi/gems/{zeitwerk@2.6.13.rbi => zeitwerk@2.7.1.rbi} (84%) diff --git a/sorbet/rbi/gems/actionpack@7.1.3.4.rbi b/sorbet/rbi/gems/actionpack@7.2.1.2.rbi similarity index 96% rename from sorbet/rbi/gems/actionpack@7.1.3.4.rbi rename to sorbet/rbi/gems/actionpack@7.2.1.2.rbi index 685c3f7fd..07ed3e955 100644 --- a/sorbet/rbi/gems/actionpack@7.1.3.4.rbi +++ b/sorbet/rbi/gems/actionpack@7.2.1.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `actionpack` gem. # Please instead update this file by running `bin/tapioca gem actionpack`. + module AbstractController extend ::ActiveSupport::Autoload @@ -41,7 +42,7 @@ class AbstractController::Base def formats=(_arg0); end def inspect; end def performed?; end - def process(action, *args, **_arg2); end + def process(action, *_arg1, **_arg2, &_arg3); end def response_body; end def response_body=(_arg0); end def send_action(*_arg0); end @@ -205,45 +206,45 @@ module AbstractController::Callbacks::ClassMethods end module AbstractController::Collector - def atom(*args, **_arg1, &block); end - def bmp(*args, **_arg1, &block); end - def css(*args, **_arg1, &block); end - def csv(*args, **_arg1, &block); end - def gif(*args, **_arg1, &block); end - def gzip(*args, **_arg1, &block); end - def html(*args, **_arg1, &block); end - def ics(*args, **_arg1, &block); end - def jpeg(*args, **_arg1, &block); end - def js(*args, **_arg1, &block); end - def json(*args, **_arg1, &block); end - def m4a(*args, **_arg1, &block); end - def mp3(*args, **_arg1, &block); end - def mp4(*args, **_arg1, &block); end - def mpeg(*args, **_arg1, &block); end - def multipart_form(*args, **_arg1, &block); end - def ogg(*args, **_arg1, &block); end - def otf(*args, **_arg1, &block); end - def pdf(*args, **_arg1, &block); end - def png(*args, **_arg1, &block); end - def rss(*args, **_arg1, &block); end - def svg(*args, **_arg1, &block); end - def text(*args, **_arg1, &block); end - def tiff(*args, **_arg1, &block); end - def ttf(*args, **_arg1, &block); end - def url_encoded_form(*args, **_arg1, &block); end - def vcf(*args, **_arg1, &block); end - def vtt(*args, **_arg1, &block); end - def webm(*args, **_arg1, &block); end - def webp(*args, **_arg1, &block); end - def woff(*args, **_arg1, &block); end - def woff2(*args, **_arg1, &block); end - def xml(*args, **_arg1, &block); end - def yaml(*args, **_arg1, &block); end - def zip(*args, **_arg1, &block); end - - private - - def method_missing(symbol, *args, **_arg2, &block); end + def atom(*_arg0, **_arg1, &_arg2); end + def bmp(*_arg0, **_arg1, &_arg2); end + def css(*_arg0, **_arg1, &_arg2); end + def csv(*_arg0, **_arg1, &_arg2); end + def gif(*_arg0, **_arg1, &_arg2); end + def gzip(*_arg0, **_arg1, &_arg2); end + def html(*_arg0, **_arg1, &_arg2); end + def ics(*_arg0, **_arg1, &_arg2); end + def jpeg(*_arg0, **_arg1, &_arg2); end + def js(*_arg0, **_arg1, &_arg2); end + def json(*_arg0, **_arg1, &_arg2); end + def m4a(*_arg0, **_arg1, &_arg2); end + def mp3(*_arg0, **_arg1, &_arg2); end + def mp4(*_arg0, **_arg1, &_arg2); end + def mpeg(*_arg0, **_arg1, &_arg2); end + def multipart_form(*_arg0, **_arg1, &_arg2); end + def ogg(*_arg0, **_arg1, &_arg2); end + def otf(*_arg0, **_arg1, &_arg2); end + def pdf(*_arg0, **_arg1, &_arg2); end + def png(*_arg0, **_arg1, &_arg2); end + def rss(*_arg0, **_arg1, &_arg2); end + def svg(*_arg0, **_arg1, &_arg2); end + def text(*_arg0, **_arg1, &_arg2); end + def tiff(*_arg0, **_arg1, &_arg2); end + def ttf(*_arg0, **_arg1, &_arg2); end + def url_encoded_form(*_arg0, **_arg1, &_arg2); end + def vcf(*_arg0, **_arg1, &_arg2); end + def vtt(*_arg0, **_arg1, &_arg2); end + def webm(*_arg0, **_arg1, &_arg2); end + def webp(*_arg0, **_arg1, &_arg2); end + def woff(*_arg0, **_arg1, &_arg2); end + def woff2(*_arg0, **_arg1, &_arg2); end + def xml(*_arg0, **_arg1, &_arg2); end + def yaml(*_arg0, **_arg1, &_arg2); end + def zip(*_arg0, **_arg1, &_arg2); end + + private + + def method_missing(symbol, *_arg1, **_arg2, &_arg3); end class << self def generate_method_for_mime(mime); end @@ -258,7 +259,6 @@ AbstractController::DoubleRenderError::DEFAULT_MESSAGE = T.let(T.unsafe(nil), St class AbstractController::Error < ::StandardError; end module AbstractController::Helpers - include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor extend ::ActiveSupport::Concern extend ::AbstractController::Helpers::Resolution include GeneratedInstanceMethods @@ -297,10 +297,6 @@ module AbstractController::Helpers::ClassMethods def define_helpers_module(klass, helpers = T.unsafe(nil)); end end -class AbstractController::Helpers::DeprecatedMissingHelperError < ::LoadError - def initialize(error, path); end -end - module AbstractController::Helpers::Resolution def all_helpers_from_path(path); end def helper_modules_from_paths(paths); end @@ -411,6 +407,7 @@ class ActionController::API < ::ActionController::Metal include ::ActionController::ConditionalGet include ::ActionController::BasicImplicitRender include ::ActionController::StrongParameters + include ::ActionController::RateLimiting include ::ActionController::DataStreaming include ::ActionController::DefaultHeaders include ::ActionController::Logging @@ -425,6 +422,7 @@ class ActionController::API < ::ActionController::Metal extend ::ActionController::Rendering::ClassMethods extend ::ActionController::Renderers::ClassMethods extend ::ActionController::ConditionalGet::ClassMethods + extend ::ActionController::RateLimiting::ClassMethods extend ::ActionController::DefaultHeaders::ClassMethods extend ::ActionController::Logging::ClassMethods extend ::ActiveSupport::Callbacks::ClassMethods @@ -494,6 +492,42 @@ end ActionController::API::MODULES = T.let(T.unsafe(nil), Array) class ActionController::ActionControllerError < ::StandardError; end +module ActionController::AllowBrowser + extend ::ActiveSupport::Concern + + mixes_in_class_methods ::ActionController::AllowBrowser::ClassMethods + + private + + def allow_browser(versions:, block:); end +end + +class ActionController::AllowBrowser::BrowserBlocker + def initialize(request, versions:); end + + def blocked?; end + def request; end + def versions; end + + private + + def bot?; end + def expanded_versions; end + def minimum_browser_version_for_browser; end + def normalized_browser_name; end + def parsed_user_agent; end + def unsupported_browser?; end + def user_agent_version_reported?; end + def version_below_minimum_required?; end + def version_guarded_browser?; end +end + +ActionController::AllowBrowser::BrowserBlocker::SETS = T.let(T.unsafe(nil), Hash) + +module ActionController::AllowBrowser::ClassMethods + def allow_browser(versions:, block: T.unsafe(nil), **options); end +end + module ActionController::ApiRendering extend ::ActiveSupport::Concern include ::ActionController::Rendering @@ -512,7 +546,6 @@ class ActionController::Base < ::ActionController::Metal include ::AbstractController::Rendering include ::AbstractController::Translation include ::AbstractController::AssetPaths - include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor include ::AbstractController::Helpers include ::ActionController::Helpers include ::ActionDispatch::Routing::PolymorphicRoutes @@ -548,6 +581,8 @@ class ActionController::Base < ::ActionController::Metal include ::ActionController::RequestForgeryProtection include ::ActionController::ContentSecurityPolicy include ::ActionController::PermissionsPolicy + include ::ActionController::RateLimiting + include ::ActionController::AllowBrowser include ::ActionController::Streaming include ::ActionController::DataStreaming include ::ActionController::HttpAuthentication::Basic::ControllerMethods @@ -580,6 +615,8 @@ class ActionController::Base < ::ActionController::Metal extend ::ActionController::RequestForgeryProtection::ClassMethods extend ::ActionController::ContentSecurityPolicy::ClassMethods extend ::ActionController::PermissionsPolicy::ClassMethods + extend ::ActionController::RateLimiting::ClassMethods + extend ::ActionController::AllowBrowser::ClassMethods extend ::ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods extend ::ActionController::DefaultHeaders::ClassMethods extend ::ActionController::Logging::ClassMethods @@ -592,7 +629,8 @@ class ActionController::Base < ::ActionController::Metal def _helper_methods; end def _helper_methods=(_arg0); end def _helper_methods?; end - def _layout_conditions(&block); end + def _layout_conditions; end + def _layout_conditions?; end def _process_action_callbacks; end def _renderers; end def _renderers=(_arg0); end @@ -615,8 +653,6 @@ class ActionController::Base < ::ActionController::Metal def csrf_token_storage_strategy=(value); end def default_asset_host_protocol; end def default_asset_host_protocol=(value); end - def default_protect_from_forgery; end - def default_protect_from_forgery=(value); end def default_static_extension; end def default_static_extension=(value); end def default_url_options; end @@ -715,8 +751,6 @@ class ActionController::Base < ::ActionController::Metal def csrf_token_storage_strategy=(value); end def default_asset_host_protocol; end def default_asset_host_protocol=(value); end - def default_protect_from_forgery; end - def default_protect_from_forgery=(value); end def default_static_extension; end def default_static_extension=(value); end def default_url_options; end @@ -772,15 +806,15 @@ class ActionController::Base < ::ActionController::Metal end module ActionController::Base::HelperMethods - def alert(*args, **_arg1, &block); end - def combined_fragment_cache_key(*args, **_arg1, &block); end - def content_security_policy?(*args, **_arg1, &block); end - def content_security_policy_nonce(*args, **_arg1, &block); end - def cookies(*args, **_arg1, &block); end - def form_authenticity_token(*args, **_arg1, &block); end - def notice(*args, **_arg1, &block); end - def protect_against_forgery?(*args, **_arg1, &block); end - def view_cache_dependencies(*args, **_arg1, &block); end + def alert(*_arg0, **_arg1, &_arg2); end + def combined_fragment_cache_key(*_arg0, **_arg1, &_arg2); end + def content_security_policy?(*_arg0, **_arg1, &_arg2); end + def content_security_policy_nonce(*_arg0, **_arg1, &_arg2); end + def cookies(*_arg0, **_arg1, &_arg2); end + def form_authenticity_token(*_arg0, **_arg1, &_arg2); end + def notice(*_arg0, **_arg1, &_arg2); end + def protect_against_forgery?(*_arg0, **_arg1, &_arg2); end + def view_cache_dependencies(*_arg0, **_arg1, &_arg2); end end ActionController::Base::MODULES = T.let(T.unsafe(nil), Array) @@ -1176,7 +1210,6 @@ end ActionController::HttpAuthentication::Token::TOKEN_KEY = T.let(T.unsafe(nil), String) ActionController::HttpAuthentication::Token::TOKEN_REGEX = T.let(T.unsafe(nil), Regexp) -ActionController::HttpAuthentication::Token::WHITESPACED_AUTHN_PAIR_DELIMITERS = T.let(T.unsafe(nil), Regexp) module ActionController::ImplicitRender include ::ActionController::BasicImplicitRender @@ -1424,7 +1457,7 @@ class ActionController::MimeResponds::Collector::VariantCollector def all(*args, &block); end def any(*args, &block); end - def method_missing(name, *args, &block); end + def method_missing(name, *_arg1, &block); end def variant; end private @@ -1557,6 +1590,8 @@ class ActionController::Parameters private + def _deep_transform_keys_in_object(object, &block); end + def _deep_transform_keys_in_object!(object, &block); end def array_of_permitted_scalars?(value); end def convert_hashes_to_parameters(key, value); end def convert_parameters_to_hashes(value, using, &block); end @@ -1578,7 +1613,7 @@ class ActionController::Parameters def action_on_unpermitted_parameters; end def action_on_unpermitted_parameters=(val); end def allow_deprecated_parameters_hash_equality; end - def allow_deprecated_parameters_hash_equality=(val); end + def allow_deprecated_parameters_hash_equality=(value); end def always_permitted_parameters; end def always_permitted_parameters=(val); end def hook_into_yaml_loading; end @@ -1631,18 +1666,11 @@ end ActionController::ParamsWrapper::EXCLUDE_PARAMETERS = T.let(T.unsafe(nil), Array) class ActionController::ParamsWrapper::Options < ::Struct - include ::Mutex_m - def initialize(name, format, include, exclude, klass, model); end def include; end - def lock; end - def locked?; end def model; end def name; end - def synchronize(&block); end - def try_lock; end - def unlock; end private @@ -1670,6 +1698,20 @@ module ActionController::Railties::Helpers def inherited(klass); end end +module ActionController::RateLimiting + extend ::ActiveSupport::Concern + + mixes_in_class_methods ::ActionController::RateLimiting::ClassMethods + + private + + def rate_limiting(to:, within:, by:, with:, store:); end +end + +module ActionController::RateLimiting::ClassMethods + def rate_limit(to:, within:, by: T.unsafe(nil), with: T.unsafe(nil), store: T.unsafe(nil), **options); end +end + module ActionController::Redirecting extend ::ActiveSupport::Concern include GeneratedInstanceMethods @@ -1723,7 +1765,7 @@ class ActionController::Renderer def controller; end def defaults; end def new(env = T.unsafe(nil)); end - def normalize_env(env, &block); end + def normalize_env(env, &_arg1); end def render(*args); end def render_to_string(*args); end def with_defaults(defaults); end @@ -1871,6 +1913,7 @@ module ActionController::RequestForgeryProtection def masked_authenticity_token(form_options: T.unsafe(nil)); end def non_xhr_javascript_response?; end def normalize_action_path(action_path); end + def normalize_relative_action_path(rel_action_path); end def per_form_csrf_token(session, action_path, method); end def protect_against_forgery?; end def real_csrf_token(_session = T.unsafe(nil)); end @@ -2232,7 +2275,6 @@ class ActionController::UrlGenerationError < ::ActionController::ActionControlle end module ActionDispatch - include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor extend ::ActiveSupport::Autoload def eager_load!; end @@ -2316,7 +2358,7 @@ module ActionDispatch::Assertions::RoutingAssertions def assert_generates(expected_path, options, defaults = T.unsafe(nil), extras = T.unsafe(nil), message = T.unsafe(nil)); end def assert_recognizes(expected_options, path, extras = T.unsafe(nil), msg = T.unsafe(nil)); end def assert_routing(path, options, defaults = T.unsafe(nil), extras = T.unsafe(nil), message = T.unsafe(nil)); end - def method_missing(selector, *args, **_arg2, &block); end + def method_missing(selector, *_arg1, **_arg2, &_arg3); end def setup; end def with_routing(&block); end @@ -2332,6 +2374,23 @@ module ActionDispatch::Assertions::RoutingAssertions::ClassMethods def with_routing(&block); end end +module ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting + extend ::ActiveSupport::Concern + + mixes_in_class_methods ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods + + def with_routing(&block); end + + private + + def create_routes; end + def reset_routes(old_routes, old_integration_session); end +end + +module ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods + def with_routing(&block); end +end + class ActionDispatch::AssumeSSL def initialize(app); end @@ -2654,7 +2713,6 @@ class ActionDispatch::DebugView < ::ActionView::Base end ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS = T.let(T.unsafe(nil), Array) -class ActionDispatch::DeprecatedIllegalStateError < ::StandardError; end class ActionDispatch::ExceptionWrapper def initialize(backtrace_cleaner, exception); end @@ -2967,10 +3025,8 @@ module ActionDispatch::Http::FilterParameters end ActionDispatch::Http::FilterParameters::ENV_MATCH = T.let(T.unsafe(nil), Array) -ActionDispatch::Http::FilterParameters::KV_RE = T.let(T.unsafe(nil), String) ActionDispatch::Http::FilterParameters::NULL_ENV_FILTER = T.let(T.unsafe(nil), ActiveSupport::ParameterFilter) ActionDispatch::Http::FilterParameters::NULL_PARAM_FILTER = T.let(T.unsafe(nil), ActiveSupport::ParameterFilter) -ActionDispatch::Http::FilterParameters::PAIR_RE = T.let(T.unsafe(nil), Regexp) module ActionDispatch::Http::FilterRedirect def filtered_location; end @@ -2979,6 +3035,7 @@ module ActionDispatch::Http::FilterRedirect def location_filter_match?; end def location_filters; end + def parameter_filtered_location; end end ActionDispatch::Http::FilterRedirect::FILTERED = T.let(T.unsafe(nil), String) @@ -3191,7 +3248,7 @@ module ActionDispatch::Integration::Runner private - def method_missing(method, *args, **_arg2, &block); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(method, _); end end @@ -3267,11 +3324,14 @@ class ActionDispatch::IntegrationTest < ::ActiveSupport::TestCase include ::ActionDispatch::Assertions include ::ActionDispatch::Integration::Runner include ::ActionController::TemplateAssertions + include ::ActionDispatch::TestHelpers::PageDumpHelper include ::ActionDispatch::IntegrationTest::Behavior include ::ActionDispatch::Routing::PolymorphicRoutes include ::ActionDispatch::Routing::UrlFor include ::ActionDispatch::IntegrationTest::UrlOptions + include ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting extend ::ActionDispatch::IntegrationTest::Behavior::ClassMethods + extend ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods end module ActionDispatch::IntegrationTest::Behavior @@ -3283,11 +3343,14 @@ module ActionDispatch::IntegrationTest::Behavior include ::ActionDispatch::Assertions include ::ActionDispatch::Integration::Runner include ::ActionController::TemplateAssertions + include ::ActionDispatch::TestHelpers::PageDumpHelper extend ::ActiveSupport::Concern include ::ActionDispatch::Routing::UrlFor include ::ActionDispatch::IntegrationTest::UrlOptions + include ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting mixes_in_class_methods ::ActionDispatch::IntegrationTest::Behavior::ClassMethods + mixes_in_class_methods ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods def app; end def document_root_element; end @@ -3361,6 +3424,7 @@ class ActionDispatch::Journey::Formatter def initialize(routes); end def clear; end + def eager_load!; end def generate(name, options, path_parameters); end def routes; end @@ -4054,11 +4118,8 @@ class ActionDispatch::PermissionsPolicy def picture_in_picture(*sources); end def screen_wake_lock(*sources); end def serial(*sources); end - def speaker(*sources); end def sync_xhr(*sources); end def usb(*sources); end - def vibrate(*sources); end - def vr(*sources); end def web_share(*sources); end private @@ -4211,8 +4272,6 @@ class ActionDispatch::Request def request_parameters=(params); end def reset_csrf_token; end def reset_session; end - def return_only_media_type_on_content_type; end - def return_only_media_type_on_content_type=(value); end def route_uri_pattern; end def route_uri_pattern=(pattern); end def routes; end @@ -4237,6 +4296,7 @@ class ActionDispatch::Request def check_method(name); end def default_session; end def read_body_stream; end + def reset_stream(body_stream); end class << self def empty; end @@ -4654,6 +4714,10 @@ class ActionDispatch::Routing::Mapper end end +class ActionDispatch::Routing::Mapper::BacktraceCleaner < ::ActiveSupport::BacktraceCleaner + def initialize; end +end + module ActionDispatch::Routing::Mapper::Base def default_url_options(options); end def default_url_options=(options); end @@ -5021,6 +5085,7 @@ class ActionDispatch::Routing::RouteSet def find_script_name(options); end def formatter; end def formatter=(_arg0); end + def from_requirements(requirements); end def generate_extras(options, recall = T.unsafe(nil)); end def generate_url_helpers(supports_path); end def inspect; end @@ -5469,6 +5534,20 @@ class ActionDispatch::Static def call(env); end end +module ActionDispatch::TestHelpers; end + +module ActionDispatch::TestHelpers::PageDumpHelper + def save_and_open_page(path = T.unsafe(nil)); end + + private + + def html_dump_default_path; end + def open_file(path); end + def save_page(path = T.unsafe(nil)); end +end + +class ActionDispatch::TestHelpers::PageDumpHelper::InvalidResponse < ::StandardError; end + module ActionDispatch::TestProcess include ::ActionDispatch::TestProcess::FixtureFile @@ -5589,7 +5668,7 @@ class Mime::NullType private - def method_missing(method, *args); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(method, _); end class << self @@ -5626,7 +5705,7 @@ class Mime::Type private - def method_missing(method, *args); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(method, include_private = T.unsafe(nil)); end def to_a; end def to_ary; end diff --git a/sorbet/rbi/gems/actionview@7.1.3.4.rbi b/sorbet/rbi/gems/actionview@7.2.1.2.rbi similarity index 88% rename from sorbet/rbi/gems/actionview@7.1.3.4.rbi rename to sorbet/rbi/gems/actionview@7.2.1.2.rbi index f4eaf45d3..52c3ab76b 100644 --- a/sorbet/rbi/gems/actionview@7.1.3.4.rbi +++ b/sorbet/rbi/gems/actionview@7.2.1.2.rbi @@ -4,8 +4,8 @@ # This is an autogenerated file for types exported from the `actionview` gem. # Please instead update this file by running `bin/tapioca gem actionview`. + class ActionController::Base < ::ActionController::Metal - include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor include ::ActionDispatch::Routing::PolymorphicRoutes include ::ActionController::Head include ::AbstractController::Caching::ConfigMethods @@ -17,7 +17,8 @@ class ActionController::Base < ::ActionController::Metal def _helper_methods; end def _helper_methods=(_arg0); end def _helper_methods?; end - def _layout_conditions(&block); end + def _layout_conditions; end + def _layout_conditions?; end def _process_action_callbacks; end def _renderers; end def _renderers=(_arg0); end @@ -40,8 +41,6 @@ class ActionController::Base < ::ActionController::Metal def csrf_token_storage_strategy=(value); end def default_asset_host_protocol; end def default_asset_host_protocol=(value); end - def default_protect_from_forgery; end - def default_protect_from_forgery=(value); end def default_static_extension; end def default_static_extension=(value); end def default_url_options; end @@ -140,8 +139,6 @@ class ActionController::Base < ::ActionController::Metal def csrf_token_storage_strategy=(value); end def default_asset_host_protocol; end def default_asset_host_protocol=(value); end - def default_protect_from_forgery; end - def default_protect_from_forgery=(value); end def default_static_extension; end def default_static_extension=(value); end def default_url_options; end @@ -395,6 +392,7 @@ class ActionView::CacheExpiry::ViewReloader private def all_view_paths; end + def build_watcher; end def dirs_to_watch; end def rebuild_watcher; end def reload!; end @@ -510,8 +508,8 @@ ActionView::DependencyTracker::ERBTracker::RENDER_ARGUMENTS = T.let(T.unsafe(nil ActionView::DependencyTracker::ERBTracker::STRING = T.let(T.unsafe(nil), Regexp) ActionView::DependencyTracker::ERBTracker::VARIABLE_OR_METHOD_CHAIN = T.let(T.unsafe(nil), Regexp) -class ActionView::DependencyTracker::RipperTracker - def initialize(name, template, view_paths = T.unsafe(nil)); end +class ActionView::DependencyTracker::RubyTracker + def initialize(name, template, view_paths = T.unsafe(nil), parser_class: T.unsafe(nil)); end def dependencies; end @@ -530,7 +528,7 @@ class ActionView::DependencyTracker::RipperTracker end end -ActionView::DependencyTracker::RipperTracker::EXPLICIT_DEPENDENCY = T.let(T.unsafe(nil), Regexp) +ActionView::DependencyTracker::RubyTracker::EXPLICIT_DEPENDENCY = T.let(T.unsafe(nil), Regexp) class ActionView::Digestor class << self @@ -1135,6 +1133,7 @@ module ActionView::Helpers::FormTagHelper def field_id(object_name, method_name, *suffixes, index: T.unsafe(nil), namespace: T.unsafe(nil)); end def field_name(object_name, method_name, *method_names, multiple: T.unsafe(nil), index: T.unsafe(nil)); end def field_set_tag(legend = T.unsafe(nil), options = T.unsafe(nil), &block); end + def fieldset_tag(legend = T.unsafe(nil), options = T.unsafe(nil), &block); end def file_field_tag(name, options = T.unsafe(nil)); end def form_tag(url_for_options = T.unsafe(nil), options = T.unsafe(nil), &block); end def hidden_field_tag(name, value = T.unsafe(nil), options = T.unsafe(nil)); end @@ -1285,10 +1284,12 @@ module ActionView::Helpers::TagHelper private def build_tag_values(*args); end + def ensure_valid_html5_tag_name(name); end def tag_builder; end class << self def build_tag_values(*args); end + def ensure_valid_html5_tag_name(name); end end end @@ -1304,23 +1305,154 @@ class ActionView::Helpers::TagHelper::TagBuilder def initialize(view_context); end + def a(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def abbr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def address(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def animate(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def animate_motion(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def animate_transform(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def area(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def article(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def aside(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end def attributes(attributes); end + def audio(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def b(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def base(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def bdi(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def bdo(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def blockquote(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def body(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end def boolean_tag_option(key); end + def br(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def button(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def canvas(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def caption(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def circle(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def cite(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def code(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def col(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def colgroup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end def content_tag_string(name, content, options, escape = T.unsafe(nil)); end - def p(*arguments, **options, &block); end + def data(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def datalist(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def dd(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def del(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def details(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def dfn(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def dialog(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def div(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def dl(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def dt(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def ellipse(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def em(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def embed(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def fieldset(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def figcaption(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def figure(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def footer(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def form(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def h1(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def h2(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def h3(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def h4(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def h5(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def h6(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def head(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def header(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def hgroup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def hr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def html(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def i(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def iframe(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def img(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def input(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def ins(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def kbd(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def keygen(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def label(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def legend(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def li(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def line(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def link(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def main(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def map(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def mark(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def menu(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def meta(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def meter(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def nav(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def noscript(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def object(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def ol(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def optgroup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def option(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def output(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def p(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def path(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def picture(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def polygon(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def polyline(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def portal(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def pre(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def progress(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def q(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def rect(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def rp(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def rt(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def ruby(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def s(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def samp(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def script(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def search(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def section(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def select(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def self_closing_tag_string(name, options, escape = T.unsafe(nil), tag_suffix = T.unsafe(nil)); end + def set(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def slot(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def small(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def source(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def span(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def stop(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def strong(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def style(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def sub(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def summary(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def sup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def table(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end def tag_option(key, value, escape); end def tag_options(options, escape = T.unsafe(nil)); end - def tag_string(name, content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end - - private - - def method_missing(called, *args, **options, &block); end + def tag_string(name, content = T.unsafe(nil), options, escape: T.unsafe(nil), &block); end + def tbody(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def td(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def template(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def textarea(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def tfoot(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def th(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def thead(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def time(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def title(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def tr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def track(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def u(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def ul(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def use(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def var(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def video(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def view(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + def wbr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end + + private + + def method_missing(called, *args, escape: T.unsafe(nil), **options, &block); end def prefix_tag_option(prefix, key, value, escape); end def respond_to_missing?(*args); end -end -ActionView::Helpers::TagHelper::TagBuilder::HTML_VOID_ELEMENTS = T.let(T.unsafe(nil), Set) -ActionView::Helpers::TagHelper::TagBuilder::SVG_SELF_CLOSING_ELEMENTS = T.let(T.unsafe(nil), Set) + class << self + def define_element(name, code_generator:, method_name: T.unsafe(nil)); end + def define_self_closing_element(name, code_generator:, method_name: T.unsafe(nil)); end + def define_void_element(name, code_generator:, method_name: T.unsafe(nil)); end + end +end module ActionView::Helpers::Tags extend ::ActiveSupport::Autoload @@ -1831,7 +1963,10 @@ module ActionView::Layouts def _layout_conditions?; end end - module GeneratedInstanceMethods; end + module GeneratedInstanceMethods + def _layout_conditions; end + def _layout_conditions?; end + end end module ActionView::Layouts::ClassMethods @@ -1875,6 +2010,7 @@ class ActionView::LogSubscriber::Start include ::ActionView::LogSubscriber::Utils def finish(name, id, payload); end + def silenced?(_); end def start(name, id, payload); end end @@ -2170,269 +2306,30 @@ end ActionView::RecordIdentifier::JOIN = T.let(T.unsafe(nil), String) ActionView::RecordIdentifier::NEW = T.let(T.unsafe(nil), String) +module ActionView::RenderParser; end +ActionView::RenderParser::ALL_KNOWN_KEYS = T.let(T.unsafe(nil), Array) -class ActionView::RenderParser +class ActionView::RenderParser::Base def initialize(name, code); end - def render_calls; end - private def directory; end - def layout_to_virtual_path(layout_path); end - def normalize_args(string, options_hash); end - def parse_hash(node); end - def parse_hash_to_symbols(node); end - def parse_render(node); end - def parse_render_from_options(options_hash); end - def parse_str(node); end - def parse_sym(node); end def partial_to_virtual_path(render_type, partial_path); end - def render_template_with_layout?(render_type, options_hash); end - def render_template_with_spacer?(options_hash); end - def resolve_path_directory(path); end end -ActionView::RenderParser::ALL_KNOWN_KEYS = T.let(T.unsafe(nil), Array) -ActionView::RenderParser::RENDER_TYPE_KEYS = T.let(T.unsafe(nil), Array) - -module ActionView::RenderParser::RipperASTParser - extend ::ActionView::RenderParser::RipperASTParser - - def parse_render_nodes(code); end -end - -class ActionView::RenderParser::RipperASTParser::Node < ::Array - def initialize(type, arr, opts = T.unsafe(nil)); end - - def argument_nodes; end - def call?; end - def call_method_name; end - def children; end - def fcall?; end - def fcall_named?(name); end - def hash?; end - def hash_from_body(body); end - def inspect; end - def string?; end - def symbol?; end - def to_hash; end - def to_string; end - def to_symbol; end - def type; end - def variable_name; end - def variable_reference?; end - def vcall?; end -end - -class ActionView::RenderParser::RipperASTParser::NodeParser < ::Ripper - def on_BEGIN(*args); end - def on_CHAR(tok); end - def on_END(*args); end - def on___end__(tok); end - def on_alias(*args); end - def on_alias_error(*args); end - def on_aref(*args); end - def on_aref_field(*args); end - def on_arg_ambiguous(*args); end - def on_arg_paren(*args); end - def on_args_add(list, item); end - def on_args_add_block(list, item); end - def on_args_add_star(list, item); end - def on_args_forward(*args); end - def on_args_new(*args); end - def on_array(*args); end - def on_aryptn(*args); end - def on_assign(*args); end - def on_assign_error(*args); end - def on_assoc_new(*args); end - def on_assoc_splat(*args); end - def on_assoclist_from_args(*args); end - def on_backref(tok); end - def on_backtick(tok); end - def on_bare_assoc_hash(*args); end - def on_begin(*args); end - def on_binary(*args); end - def on_block_var(*args); end - def on_blockarg(*args); end - def on_bodystmt(*args); end - def on_brace_block(*args); end - def on_break(*args); end - def on_call(*args); end - def on_case(*args); end - def on_class(*args); end - def on_class_name_error(*args); end - def on_comma(tok); end - def on_command(*args); end - def on_command_call(*args); end - def on_comment(tok); end - def on_const(tok); end - def on_const_path_field(*args); end - def on_const_path_ref(*args); end - def on_const_ref(*args); end - def on_cvar(tok); end - def on_def(*args); end - def on_defined(*args); end - def on_defs(*args); end - def on_do_block(*args); end - def on_dot2(*args); end - def on_dot3(*args); end - def on_dyna_symbol(*args); end - def on_else(*args); end - def on_elsif(*args); end - def on_embdoc(tok); end - def on_embdoc_beg(tok); end - def on_embdoc_end(tok); end - def on_embexpr_beg(tok); end - def on_embexpr_end(tok); end - def on_embvar(tok); end - def on_ensure(*args); end - def on_excessed_comma(*args); end - def on_fcall(*args); end - def on_field(*args); end - def on_float(tok); end - def on_fndptn(*args); end - def on_for(*args); end - def on_gvar(tok); end - def on_hash(*args); end - def on_heredoc_beg(tok); end - def on_heredoc_dedent(*args); end - def on_heredoc_end(tok); end - def on_hshptn(*args); end - def on_ident(tok); end - def on_if(*args); end - def on_if_mod(*args); end - def on_ifop(*args); end - def on_ignored_nl(tok); end - def on_ignored_sp(tok); end - def on_imaginary(tok); end - def on_in(*args); end - def on_int(tok); end - def on_ivar(tok); end - def on_kw(tok); end - def on_kwrest_param(*args); end - def on_label(tok); end - def on_label_end(tok); end - def on_lambda(*args); end - def on_lbrace(tok); end - def on_lbracket(tok); end - def on_lparen(tok); end - def on_magic_comment(*args); end - def on_massign(*args); end - def on_method_add_arg(list, item); end - def on_method_add_block(list, item); end - def on_mlhs_add(list, item); end - def on_mlhs_add_post(list, item); end - def on_mlhs_add_star(list, item); end - def on_mlhs_new(*args); end - def on_mlhs_paren(*args); end - def on_module(*args); end - def on_mrhs_add(list, item); end - def on_mrhs_add_star(list, item); end - def on_mrhs_new(*args); end - def on_mrhs_new_from_args(*args); end - def on_next(*args); end - def on_nl(tok); end - def on_nokw_param(*args); end - def on_op(tok); end - def on_opassign(*args); end - def on_operator_ambiguous(*args); end - def on_param_error(*args); end - def on_params(*args); end - def on_paren(*args); end - def on_parse_error(*args); end - def on_period(tok); end - def on_program(*args); end - def on_qsymbols_add(list, item); end - def on_qsymbols_beg(tok); end - def on_qsymbols_new(*args); end - def on_qwords_add(list, item); end - def on_qwords_beg(tok); end - def on_qwords_new(*args); end - def on_rational(tok); end - def on_rbrace(tok); end - def on_rbracket(tok); end - def on_redo(*args); end - def on_regexp_add(list, item); end - def on_regexp_beg(tok); end - def on_regexp_end(tok); end - def on_regexp_literal(*args); end - def on_regexp_new(*args); end - def on_rescue(*args); end - def on_rescue_mod(*args); end - def on_rest_param(*args); end - def on_retry(*args); end - def on_return(*args); end - def on_return0(*args); end - def on_rparen(tok); end - def on_sclass(*args); end - def on_semicolon(tok); end - def on_sp(tok); end - def on_stmts_add(list, item); end - def on_stmts_new(*args); end - def on_string_add(list, item); end - def on_string_concat(*args); end - def on_string_content(*args); end - def on_string_dvar(*args); end - def on_string_embexpr(*args); end - def on_string_literal(*args); end - def on_super(*args); end - def on_symbeg(tok); end - def on_symbol(*args); end - def on_symbol_literal(*args); end - def on_symbols_add(list, item); end - def on_symbols_beg(tok); end - def on_symbols_new(*args); end - def on_tlambda(tok); end - def on_tlambeg(tok); end - def on_top_const_field(*args); end - def on_top_const_ref(*args); end - def on_tstring_beg(tok); end - def on_tstring_content(tok); end - def on_tstring_end(tok); end - def on_unary(*args); end - def on_undef(*args); end - def on_unless(*args); end - def on_unless_mod(*args); end - def on_until(*args); end - def on_until_mod(*args); end - def on_var_alias(*args); end - def on_var_field(*args); end - def on_var_ref(*args); end - def on_vcall(*args); end - def on_void_stmt(*args); end - def on_when(*args); end - def on_while(*args); end - def on_while_mod(*args); end - def on_word_add(list, item); end - def on_word_new(*args); end - def on_words_add(list, item); end - def on_words_beg(tok); end - def on_words_new(*args); end - def on_words_sep(tok); end - def on_xstring_add(list, item); end - def on_xstring_literal(*args); end - def on_xstring_new(*args); end - def on_yield(*args); end - def on_yield0(*args); end - def on_zsuper(*args); end -end - -class ActionView::RenderParser::RipperASTParser::RenderCallExtractor < ::ActionView::RenderParser::RipperASTParser::NodeParser - def initialize(*args); end +ActionView::RenderParser::Default = ActionView::RenderParser::PrismRenderParser +class ActionView::RenderParser::PrismRenderParser < ::ActionView::RenderParser::Base def render_calls; end private - def on_arg_paren(content); end - def on_command(name, *args); end - def on_fcall(name, *args); end - def on_paren(content); end - def on_render_call(node); end + def render_call_options(node); end + def render_call_template(node); end end -ActionView::RenderParser::RipperASTParser::RenderCallExtractor::METHODS_TO_PARSE = T.let(T.unsafe(nil), Array) +ActionView::RenderParser::RENDER_TYPE_KEYS = T.let(T.unsafe(nil), Array) class ActionView::Renderer def initialize(lookup_context); end @@ -2443,15 +2340,14 @@ class ActionView::Renderer def render(context, options); end def render_body(context, options); end def render_partial(context, options, &block); end - def render_partial_to_object(context, options, &block); end - def render_template(context, options); end - def render_template_to_object(context, options); end def render_to_object(context, options); end private def collection_from_object(object); end def collection_from_options(options); end + def render_partial_to_object(context, options, &block); end + def render_template_to_object(context, options); end end module ActionView::Rendering @@ -2488,13 +2384,11 @@ module ActionView::Rendering::ClassMethods end class ActionView::Resolver - include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor - def all_template_paths; end def built_templates; end def caching; end def caching=(val); end - def caching?(&block); end + def caching?(&_arg0); end def clear_cache; end def find_all(name, prefix = T.unsafe(nil), partial = T.unsafe(nil), details = T.unsafe(nil), key = T.unsafe(nil), locals = T.unsafe(nil)); end @@ -2785,6 +2679,7 @@ end ActionView::Template::Inline::Finalizer = T.let(T.unsafe(nil), Proc) ActionView::Template::LEADING_ENCODING_REGEXP = T.let(T.unsafe(nil), Regexp) ActionView::Template::NONE = T.let(T.unsafe(nil), Object) +ActionView::Template::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array) class ActionView::Template::RawFile def initialize(filename); end @@ -2924,7 +2819,6 @@ class ActionView::TestCase < ::ActiveSupport::TestCase include ::Rails::Dom::Testing::Assertions::SelectorAssertions include ::Rails::Dom::Testing::Assertions include ::ActionDispatch::Assertions - include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor include ::AbstractController::Helpers include ::ActiveSupport::Benchmarkable include ::ActionView::Helpers::ActiveModelHelper @@ -3033,6 +2927,7 @@ module ActionView::TestCase::Behavior def output_buffer=(_arg0); end def render(options = T.unsafe(nil), local_assigns = T.unsafe(nil), &block); end def rendered; end + def rendered=(_arg0); end def rendered_views; end def request; end def request=(_arg0); end @@ -3043,7 +2938,7 @@ module ActionView::TestCase::Behavior def _user_defined_ivars; end def _view; end def document_root_element; end - def method_missing(selector, *args, **_arg2); end + def method_missing(selector, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(name, include_private = T.unsafe(nil)); end def view; end def view_assigns; end diff --git a/sorbet/rbi/gems/activemodel@7.1.3.4.rbi b/sorbet/rbi/gems/activemodel@7.2.1.2.rbi similarity index 95% rename from sorbet/rbi/gems/activemodel@7.1.3.4.rbi rename to sorbet/rbi/gems/activemodel@7.2.1.2.rbi index ebbce1e03..9b5fcf596 100644 --- a/sorbet/rbi/gems/activemodel@7.1.3.4.rbi +++ b/sorbet/rbi/gems/activemodel@7.2.1.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `activemodel` gem. # Please instead update this file by running `bin/tapioca gem activemodel`. + module ActiveModel extend ::ActiveSupport::Autoload @@ -189,8 +190,8 @@ module ActiveModel::AttributeMethods mixes_in_class_methods GeneratedClassMethods mixes_in_class_methods ::ActiveModel::AttributeMethods::ClassMethods - def attribute_missing(match, *args, **_arg2, &block); end - def method_missing(method, *args, **_arg2, &block); end + def attribute_missing(match, *_arg1, **_arg2, &_arg3); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def respond_to?(method, include_private_methods = T.unsafe(nil)); end def respond_to_without_attributes?(*_arg0); end @@ -236,7 +237,8 @@ module ActiveModel::AttributeMethods::ClassMethods def attribute_method_affix(*affixes); end def attribute_method_prefix(*prefixes, parameters: T.unsafe(nil)); end def attribute_method_suffix(*suffixes, parameters: T.unsafe(nil)); end - def define_attribute_method(attr_name, _owner: T.unsafe(nil)); end + def define_attribute_method(attr_name, _owner: T.unsafe(nil), as: T.unsafe(nil)); end + def define_attribute_method_pattern(pattern, attr_name, owner:, as:, override: T.unsafe(nil)); end def define_attribute_methods(*attr_names); end def eagerly_generate_alias_attribute_methods(new_name, old_name); end def generate_alias_attribute_methods(code_generator, new_name, old_name); end @@ -246,7 +248,9 @@ module ActiveModel::AttributeMethods::ClassMethods def attribute_method_patterns_cache; end def attribute_method_patterns_matching(method_name); end - def define_proxy_call(code_generator, name, proxy_target, parameters, *call_args, namespace:); end + def build_mangled_name(name); end + def define_call(code_generator, name, target_name, mangled_name, parameters, call_args, namespace:, as:); end + def define_proxy_call(code_generator, name, proxy_target, parameters, *call_args, namespace:, as: T.unsafe(nil)); end def generated_attribute_methods; end def inherited(base); end def instance_method_already_implemented?(method_name); end @@ -279,7 +283,6 @@ class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodPattern::Attri end end -ActiveModel::AttributeMethods::FORWARD_PARAMETERS = T.let(T.unsafe(nil), String) ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP = T.let(T.unsafe(nil), Regexp) class ActiveModel::AttributeMutationTracker @@ -318,23 +321,66 @@ module ActiveModel::AttributeRegistration::ClassMethods def _default_attributes; end def attribute(name, type = T.unsafe(nil), default: T.unsafe(nil), **options); end def attribute_types; end + def decorate_attributes(names = T.unsafe(nil), &decorator); end + def type_for_attribute(attribute_name, &block); end private - def apply_pending_attributes(attribute_set); end - def build_default_attributes; end - def pending_attribute(name); end + def apply_pending_attribute_modifications(attribute_set); end + def hook_attribute_type(attribute, type); end + def pending_attribute_modifications; end def reset_default_attributes; end + def reset_default_attributes!; end def resolve_attribute_name(name); end def resolve_type_name(name, **options); end end -class ActiveModel::AttributeRegistration::ClassMethods::PendingAttribute - def apply_to(attribute); end +class ActiveModel::AttributeRegistration::ClassMethods::PendingDecorator < ::Struct + def apply_to(attribute_set); end + def decorator; end + def decorator=(_); end + def names; end + def names=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +class ActiveModel::AttributeRegistration::ClassMethods::PendingDefault < ::Struct + def apply_to(attribute_set); end def default; end - def default=(_arg0); end + def default=(_); end + def name; end + def name=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +class ActiveModel::AttributeRegistration::ClassMethods::PendingType < ::Struct + def apply_to(attribute_set); end + def name; end + def name=(_); end def type; end - def type=(_arg0); end + def type=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end end class ActiveModel::AttributeSet @@ -442,7 +488,7 @@ module ActiveModel::Attributes::ClassMethods private - def define_method_attribute=(name, owner:); end + def define_method_attribute=(canonical_name, owner:, as: T.unsafe(nil)); end end class ActiveModel::BlockValidator < ::ActiveModel::EachValidator @@ -1159,7 +1205,7 @@ ActiveModel::Type::Integer::DEFAULT_LIMIT = T.let(T.unsafe(nil), Integer) class ActiveModel::Type::Registry def initialize; end - def lookup(symbol, *args, **_arg2); end + def lookup(symbol, *_arg1, **_arg2, &_arg3); end def register(type_name, klass = T.unsafe(nil), &block); end private diff --git a/sorbet/rbi/gems/activerecord@7.1.3.4.rbi b/sorbet/rbi/gems/activerecord@7.2.1.2.rbi similarity index 94% rename from sorbet/rbi/gems/activerecord@7.1.3.4.rbi rename to sorbet/rbi/gems/activerecord@7.2.1.2.rbi index a1acb1ffb..4c028ae56 100644 --- a/sorbet/rbi/gems/activerecord@7.1.3.4.rbi +++ b/sorbet/rbi/gems/activerecord@7.2.1.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `activerecord` gem. # Please instead update this file by running `bin/tapioca gem activerecord`. + module ActiveRecord include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor extend ::ActiveSupport::Autoload @@ -11,8 +12,10 @@ module ActiveRecord class << self def action_on_strict_loading_violation; end def action_on_strict_loading_violation=(_arg0); end + def after_all_transactions_commit(&block); end + def all_open_transactions; end def allow_deprecated_singular_associations_name; end - def allow_deprecated_singular_associations_name=(_arg0); end + def allow_deprecated_singular_associations_name=(value); end def application_record_class; end def application_record_class=(_arg0); end def async_query_executor; end @@ -22,7 +25,7 @@ module ActiveRecord def belongs_to_required_validates_foreign_key; end def belongs_to_required_validates_foreign_key=(_arg0); end def commit_transaction_on_non_local_return; end - def commit_transaction_on_non_local_return=(_arg0); end + def commit_transaction_on_non_local_return=(value); end def db_warnings_action; end def db_warnings_action=(action); end def db_warnings_ignore; end @@ -57,6 +60,10 @@ module ActiveRecord def marshalling_format_version=(value); end def migration_strategy; end def migration_strategy=(_arg0); end + def permanent_connection_checkout; end + def permanent_connection_checkout=(value); end + def protocol_adapters; end + def protocol_adapters=(_arg0); end def query_transformers; end def query_transformers=(_arg0); end def queues; end @@ -73,12 +80,12 @@ module ActiveRecord def schema_cache_ignored_tables=(_arg0); end def schema_format; end def schema_format=(_arg0); end - def suppress_multiple_database_warning; end - def suppress_multiple_database_warning=(value); end def timestamped_migrations; end def timestamped_migrations=(_arg0); end def use_yaml_unsafe_load; end def use_yaml_unsafe_load=(_arg0); end + def validate_migration_timestamps; end + def validate_migration_timestamps=(_arg0); end def verbose_query_logs; end def verbose_query_logs=(_arg0); end def verify_foreign_keys_for_fixtures; end @@ -182,17 +189,18 @@ module ActiveRecord::Associations end class ActiveRecord::Associations::AliasTracker - def initialize(connection, aliases); end + def initialize(table_alias_length, aliases); end def aliased_table_for(arel_table, table_name = T.unsafe(nil)); end def aliases; end private + def table_alias_for(table_name); end def truncate(name); end class << self - def create(connection, initial_table, joins, aliases = T.unsafe(nil)); end + def create(pool, initial_table, joins, aliases = T.unsafe(nil)); end def initial_count_for(connection, name, table_joins); end end end @@ -200,6 +208,7 @@ end class ActiveRecord::Associations::Association def initialize(owner, reflection); end + def collection?; end def create(attributes = T.unsafe(nil), &block); end def create!(attributes = T.unsafe(nil), &block); end def disable_joins; end @@ -455,6 +464,7 @@ end class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associations::Association def add_to_target(record, skip_callbacks: T.unsafe(nil), replace: T.unsafe(nil), &block); end def build(attributes = T.unsafe(nil), &block); end + def collection?; end def concat(*records); end def delete(*records); end def delete_all(dependent = T.unsafe(nil)); end @@ -467,6 +477,8 @@ class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associ def ids_writer(ids); end def include?(record); end def load_target; end + def nested_attributes_target; end + def nested_attributes_target=(_arg0); end def null_scope?; end def reader; end def replace(other_array); end @@ -677,6 +689,8 @@ class ActiveRecord::Associations::CollectionProxy < ::ActiveRecord::Relation def where_clause=(arg); end def with(*_arg0, **_arg1, &_arg2); end def with!(*_arg0, **_arg1, &_arg2); end + def with_recursive(*_arg0, **_arg1, &_arg2); end + def with_recursive!(*_arg0, **_arg1, &_arg2); end def with_values(*_arg0, **_arg1, &_arg2); end def with_values=(arg); end def without(*_arg0, **_arg1, &_arg2); end @@ -874,7 +888,7 @@ class ActiveRecord::Associations::JoinDependency::JoinAssociation < ::ActiveReco private - def append_constraints(join, constraints); end + def append_constraints(connection, join, constraints); end end class ActiveRecord::Associations::JoinDependency::JoinBase < ::ActiveRecord::Associations::JoinDependency::JoinPart @@ -903,6 +917,18 @@ class ActiveRecord::Associations::JoinDependency::JoinPart def table_name(*_arg0, **_arg1, &_arg2); end end +class ActiveRecord::Associations::NestedError < ::ActiveModel::NestedError + def initialize(association, inner_error); end + + private + + def association; end + def compute_attribute(inner_error); end + def index; end + def index_errors_setting; end + def ordered_records; end +end + class ActiveRecord::Associations::Preloader extend ::ActiveSupport::Autoload @@ -1049,6 +1075,7 @@ class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associat def build(attributes = T.unsafe(nil), &block); end def force_reload_reader; end def reader; end + def reset; end def writer(record); end private @@ -1108,14 +1135,10 @@ end class ActiveRecord::AsynchronousQueryInsideTransactionError < ::ActiveRecord::ActiveRecordError; end module ActiveRecord::AttributeAssignment - include ::ActiveModel::ForbiddenAttributesProtection - include ::ActiveModel::AttributeAssignment - private def _assign_attributes(attributes); end def assign_multiparameter_attributes(pairs); end - def assign_nested_parameter_attributes(pairs); end def execute_callstack_for_multiparameter_attributes(callstack); end def extract_callstack_for_multiparameter_attributes(pairs); end def find_parameter_position(multiparameter_name); end @@ -1171,7 +1194,9 @@ module ActiveRecord::AttributeMethods def attributes_for_update(attribute_names); end def attributes_with_values(attribute_names); end def format_for_inspect(name, value); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def pk_attribute?(name); end + def respond_to_missing?(name, include_private = T.unsafe(nil)); end class << self def dangerous_attribute_methods; end @@ -1242,11 +1267,13 @@ module ActiveRecord::AttributeMethods::ClassMethods def alias_attribute(new_name, old_name); end def alias_attribute_method_definition(code_generator, pattern, new_name, old_name); end def attribute_method?(attribute); end + def attribute_methods_generated?; end def attribute_names; end def dangerous_attribute_method?(name); end def dangerous_class_method?(method_name); end def define_attribute_methods; end def eagerly_generate_alias_attribute_methods(_new_name, _old_name); end + def generate_alias_attribute_methods(code_generator, new_name, old_name); end def generate_alias_attributes; end def has_attribute?(attr_name); end def initialize_generated_modules; end @@ -1259,6 +1286,17 @@ module ActiveRecord::AttributeMethods::ClassMethods def inherited(child_class); end end +module ActiveRecord::AttributeMethods::CompositePrimaryKey + def id; end + def id=(value); end + def id?; end + def id_before_type_cast; end + def id_for_database; end + def id_in_database; end + def id_was; end + def primary_key_values_present?; end +end + module ActiveRecord::AttributeMethods::Dirty extend ::ActiveSupport::Concern include GeneratedInstanceMethods @@ -1318,15 +1356,8 @@ module ActiveRecord::AttributeMethods::Dirty end end -class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module - include ::Mutex_m - - def lock; end - def locked?; end - def synchronize(&block); end - def try_lock; end - def unlock; end -end +class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module; end +ActiveRecord::AttributeMethods::GeneratedAttributeMethods::LOCK = T.let(T.unsafe(nil), Monitor) module ActiveRecord::AttributeMethods::PrimaryKey extend ::ActiveSupport::Concern @@ -1360,7 +1391,6 @@ module ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods private - def derive_primary_key(value); end def inherited(base); end end @@ -1397,7 +1427,7 @@ end module ActiveRecord::AttributeMethods::Read::ClassMethods private - def define_method_attribute(name, owner:); end + def define_method_attribute(canonical_name, owner:, as: T.unsafe(nil)); end end module ActiveRecord::AttributeMethods::Serialization @@ -1417,7 +1447,7 @@ module ActiveRecord::AttributeMethods::Serialization end module ActiveRecord::AttributeMethods::Serialization::ClassMethods - def serialize(attr_name, class_name_or_coder = T.unsafe(nil), coder: T.unsafe(nil), type: T.unsafe(nil), yaml: T.unsafe(nil), **options); end + def serialize(attr_name, coder: T.unsafe(nil), type: T.unsafe(nil), yaml: T.unsafe(nil), **options); end private @@ -1459,11 +1489,10 @@ module ActiveRecord::AttributeMethods::TimeZoneConversion end module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods - def define_attribute(name, cast_type, **_arg2); end - private def create_time_zone_conversion_attribute?(name, cast_type); end + def hook_attribute_type(name, cast_type); end end class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter @@ -1497,33 +1526,31 @@ end module ActiveRecord::AttributeMethods::Write::ClassMethods private - def define_method_attribute=(name, owner:); end + def define_method_attribute=(canonical_name, owner:, as: T.unsafe(nil)); end end module ActiveRecord::Attributes extend ::ActiveSupport::Concern - include GeneratedInstanceMethods + include ::ActiveModel::AttributeRegistration - mixes_in_class_methods GeneratedClassMethods + mixes_in_class_methods ::ActiveModel::AttributeRegistration::ClassMethods mixes_in_class_methods ::ActiveRecord::Attributes::ClassMethods - - module GeneratedClassMethods - def attributes_to_define_after_schema_loads; end - def attributes_to_define_after_schema_loads=(value); end - def attributes_to_define_after_schema_loads?; end - end - - module GeneratedInstanceMethods; end end module ActiveRecord::Attributes::ClassMethods - def attribute(name, cast_type = T.unsafe(nil), default: T.unsafe(nil), **options); end + def _default_attributes; end def define_attribute(name, cast_type, default: T.unsafe(nil), user_provided_default: T.unsafe(nil)); end - def load_schema!; end + + protected + + def reload_schema_from_cache(*_arg0); end private def define_default_attribute(name, value, type, from_user:); end + def reset_default_attributes; end + def resolve_type_name(name, **options); end + def type_for_column(connection, column); end end ActiveRecord::Attributes::ClassMethods::NO_DEFAULT_PROVIDED = T.let(T.unsafe(nil), Object) @@ -1547,13 +1574,11 @@ module ActiveRecord::AutosaveAssociation def around_save_collection_association; end def associated_records_to_validate_or_save(association, new_record, autosave); end def association_foreign_key_changed?(reflection, record, key); end - def association_valid?(reflection, record, index = T.unsafe(nil)); end + def association_valid?(association, record); end def compute_primary_key(reflection, record); end - def custom_validation_context?; end def init_internals; end def inverse_polymorphic_association_changed?(reflection, record); end def nested_records_changed_for_autosave?; end - def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute); end def save_belongs_to_association(reflection); end def save_collection_association(reflection); end def save_has_one_association(reflection); end @@ -1577,6 +1602,13 @@ module ActiveRecord::AutosaveAssociation::ClassMethods end class ActiveRecord::Base + include ::ActiveModel::Validations + include ::ActiveSupport::Callbacks + include ::ActiveModel::Validations::HelperMethods + include ::ActiveModel::Conversion + include ::ActiveModel::ForbiddenAttributesProtection + include ::ActiveModel::AttributeAssignment + include ::ActiveModel::API include ::ActiveModel::Access include ::ActiveRecord::Core include ::ActiveRecord::Persistence @@ -1587,16 +1619,11 @@ class ActiveRecord::Base include ::ActiveRecord::Scoping::Default include ::ActiveRecord::Scoping::Named include ::ActiveRecord::Sanitization - include ::ActiveModel::ForbiddenAttributesProtection - include ::ActiveModel::AttributeAssignment include ::ActiveRecord::AttributeAssignment - include ::ActiveModel::Conversion include ::ActiveRecord::Integration - include ::ActiveModel::Validations - include ::ActiveSupport::Callbacks - include ::ActiveModel::Validations::HelperMethods include ::ActiveRecord::Validations include ::ActiveRecord::CounterCache + include ::ActiveModel::AttributeRegistration include ::ActiveRecord::Attributes include ::ActiveRecord::Locking::Optimistic include ::ActiveRecord::Locking::Pessimistic @@ -1636,13 +1663,18 @@ class ActiveRecord::Base include ::ActiveRecord::Suppressor include ::ActiveRecord::Normalization include ::ActiveRecord::Marshalling::Methods + extend ::ActiveModel::Validations::ClassMethods extend ::ActiveModel::Naming - extend ::ActiveSupport::Benchmarkable + extend ::ActiveModel::Callbacks + extend ::ActiveSupport::Callbacks::ClassMethods extend ::ActiveSupport::DescendantsTracker + extend ::ActiveModel::Translation + extend ::ActiveModel::Validations::HelperMethods + extend ::ActiveModel::Conversion::ClassMethods + extend ::ActiveSupport::Benchmarkable extend ::ActiveRecord::ConnectionHandling extend ::ActiveRecord::QueryCache::ClassMethods extend ::ActiveRecord::Querying - extend ::ActiveModel::Translation extend ::ActiveRecord::Translation extend ::ActiveRecord::DynamicMatchers extend ::ActiveRecord::DelegatedType @@ -1659,14 +1691,10 @@ class ActiveRecord::Base extend ::ActiveRecord::Scoping::Default::ClassMethods extend ::ActiveRecord::Scoping::Named::ClassMethods extend ::ActiveRecord::Sanitization::ClassMethods - extend ::ActiveModel::Conversion::ClassMethods extend ::ActiveRecord::Integration::ClassMethods - extend ::ActiveModel::Validations::ClassMethods - extend ::ActiveModel::Callbacks - extend ::ActiveSupport::Callbacks::ClassMethods - extend ::ActiveModel::Validations::HelperMethods extend ::ActiveRecord::Validations::ClassMethods extend ::ActiveRecord::CounterCache::ClassMethods + extend ::ActiveModel::AttributeRegistration::ClassMethods extend ::ActiveRecord::Attributes::ClassMethods extend ::ActiveRecord::Locking::Optimistic::ClassMethods extend ::ActiveRecord::Encryption::EncryptableRecord::ClassMethods @@ -1734,13 +1762,17 @@ class ActiveRecord::Base def attribute_method_patterns?; end def automatic_scope_inversing; end def automatic_scope_inversing?; end + def automatically_invert_plural_associations; end + def automatically_invert_plural_associations?; end def cache_timestamp_format; end def cache_timestamp_format?; end def cache_versioning; end def cache_versioning?; end def collection_cache_versioning; end def collection_cache_versioning?; end - def column_for_attribute(name, &block); end + def column_for_attribute(name, &_arg1); end + def counter_cached_association_names; end + def counter_cached_association_names?; end def default_connection_handler; end def default_connection_handler?; end def default_role; end @@ -1752,7 +1784,7 @@ class ActiveRecord::Base def defined_enums; end def defined_enums?; end def destroy_association_async_batch_size; end - def destroy_association_async_job(&block); end + def destroy_association_async_job(&_arg0); end def encrypted_attributes; end def encrypted_attributes=(_arg0); end def encrypted_attributes?; end @@ -1762,7 +1794,7 @@ class ActiveRecord::Base def lock_optimistically?; end def logger; end def logger?; end - def model_name(&block); end + def model_name(&_arg0); end def nested_attributes_options; end def nested_attributes_options?; end def normalized_attributes; end @@ -1796,7 +1828,7 @@ class ActiveRecord::Base def time_zone_aware_attributes?; end def time_zone_aware_types; end def time_zone_aware_types?; end - def type_for_attribute(attr_name, &block); end + def type_for_attribute(*_arg0, **_arg1, &_arg2); end def validation_context; end private @@ -1869,12 +1901,15 @@ class ActiveRecord::Base def attribute_method_patterns; end def attribute_method_patterns=(value); end def attribute_method_patterns?; end - def attributes_to_define_after_schema_loads; end - def attributes_to_define_after_schema_loads=(value); end - def attributes_to_define_after_schema_loads?; end + def attributes_for_inspect; end + def attributes_for_inspect=(value); end + def attributes_for_inspect?; end def automatic_scope_inversing; end def automatic_scope_inversing=(value); end def automatic_scope_inversing?; end + def automatically_invert_plural_associations; end + def automatically_invert_plural_associations=(value); end + def automatically_invert_plural_associations?; end def before_create(*args, **options, &block); end def before_destroy(*args, **options, &block); end def before_save(*args, **options, &block); end @@ -1900,6 +1935,9 @@ class ActiveRecord::Base def connection_class_for_self; end def connection_handler; end def connection_handler=(handler); end + def counter_cached_association_names; end + def counter_cached_association_names=(value); end + def counter_cached_association_names?; end def current_preventing_writes; end def current_role; end def current_shard; end @@ -2064,6 +2102,7 @@ class ActiveRecord::Batches::BatchEnumerator def finish; end def relation; end def start; end + def touch_all(*_arg0, **_arg1, &_arg2); end def update_all(updates); end end @@ -2094,6 +2133,7 @@ module ActiveRecord::Calculations def aggregate_column(column_name); end def all_attributes?(column_names); end def build_count_subquery(relation, column_name, distinct); end + def build_count_subquery?(operation, column_name, distinct); end def distinct_select?(column_name); end def execute_grouped_calculation(operation, column_name, distinct); end def execute_simple_calculation(operation, column_name, distinct); end @@ -2216,6 +2256,11 @@ class ActiveRecord::ConfigurationError < ::ActiveRecord::ActiveRecordError; end module ActiveRecord::ConnectionAdapters extend ::ActiveSupport::Autoload + + class << self + def register(name, class_name, path = T.unsafe(nil)); end + def resolve(adapter_name); end + end end class ActiveRecord::ConnectionAdapters::AbstractAdapter @@ -2229,6 +2274,7 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter include ::ActiveRecord::ConnectionAdapters::Savepoints extend ::ActiveSupport::Callbacks::ClassMethods extend ::ActiveSupport::DescendantsTracker + extend ::ActiveRecord::ConnectionAdapters::Quoting::ClassMethods def initialize(config_or_deprecated_connection, deprecated_logger = T.unsafe(nil), deprecated_connection_options = T.unsafe(nil), deprecated_config = T.unsafe(nil)); end @@ -2242,7 +2288,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter def adapter_name; end def add_enum_value(*_arg0); end def advisory_locks_enabled?; end - def all_foreign_keys_valid?(*args, **_arg1, &block); end def async_enabled?; end def build_insert_sql(insert); end def case_insensitive_comparison(attribute, value); end @@ -2254,6 +2299,7 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter def clear_cache!(new_connection: T.unsafe(nil)); end def close; end def connect!; end + def connected?; end def connection_class; end def connection_retries; end def create(*_arg0, **_arg1, &_arg2); end @@ -2280,13 +2326,11 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter def in_use?; end def index_algorithms; end def insert(*_arg0, **_arg1, &_arg2); end - def internal_metadata; end + def inspect; end def lease; end def lock; end def lock_thread=(lock_thread); end def logger; end - def migration_context; end - def migrations_paths; end def owner; end def pool; end def pool=(value); end @@ -2311,7 +2355,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter def rollback_to_savepoint(*_arg0, **_arg1, &_arg2); end def savepoint_errors_invalidate_transactions?; end def schema_cache; end - def schema_migration; end def schema_version; end def seconds_idle; end def shard; end @@ -2358,7 +2401,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter def truncate_tables(*_arg0, **_arg1, &_arg2); end def unprepared_statement; end def update(*_arg0, **_arg1, &_arg2); end - def use_metadata_table?; end def valid_type?(type); end def verify!; end def visitor; end @@ -2428,9 +2470,7 @@ ActiveRecord::ConnectionAdapters::AbstractAdapter::DEFAULT_READ_QUERY = T.let(T. ActiveRecord::ConnectionAdapters::AbstractAdapter::EXCEPTION_IMMEDIATE = T.let(T.unsafe(nil), Hash) ActiveRecord::ConnectionAdapters::AbstractAdapter::EXCEPTION_NEVER = T.let(T.unsafe(nil), Hash) ActiveRecord::ConnectionAdapters::AbstractAdapter::EXTENDED_TYPE_MAPS = T.let(T.unsafe(nil), Concurrent::Map) -ActiveRecord::ConnectionAdapters::AbstractAdapter::FIBER_LOCK = T.let(T.unsafe(nil), ActiveSupport::Concurrency::LoadInterlockAwareMonitor) ActiveRecord::ConnectionAdapters::AbstractAdapter::SIMPLE_INT = T.let(T.unsafe(nil), Regexp) -ActiveRecord::ConnectionAdapters::AbstractAdapter::THREAD_LOCK = T.let(T.unsafe(nil), ActiveSupport::Concurrency::ThreadLoadInterlockAwareMonitor) ActiveRecord::ConnectionAdapters::AbstractAdapter::TYPE_MAP = T.let(T.unsafe(nil), ActiveRecord::Type::TypeMap) class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version @@ -2475,7 +2515,7 @@ class ActiveRecord::ConnectionAdapters::AlterTable end class ActiveRecord::ConnectionAdapters::BoundSchemaReflection - def initialize(abstract_schema_reflection, connection); end + def initialize(abstract_schema_reflection, pool); end def add(name); end def cached?(table_name); end @@ -2486,13 +2526,22 @@ class ActiveRecord::ConnectionAdapters::BoundSchemaReflection def columns_hash?(table_name); end def data_source_exists?(name); end def data_sources(name); end - def database_version; end def dump_to(filename); end def indexes(table_name); end def load!; end def primary_keys(table_name); end def size; end def version; end + + class << self + def for_lone_connection(abstract_schema_reflection, connection); end + end +end + +class ActiveRecord::ConnectionAdapters::BoundSchemaReflection::FakePool + def initialize(connection); end + + def with_connection; end end class ActiveRecord::ConnectionAdapters::ChangeColumnDefaultDefinition < ::Struct @@ -2641,7 +2690,6 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler def initialize; end def active_connections?(role = T.unsafe(nil)); end - def all_connection_pools; end def clear_active_connections!(role = T.unsafe(nil)); end def clear_all_connections!(role = T.unsafe(nil)); end def clear_reloadable_connections!(role = T.unsafe(nil)); end @@ -2656,12 +2704,11 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler def prevent_writes=(prevent_writes); end def remove_connection_pool(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end def retrieve_connection(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end - def retrieve_connection_pool(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end + def retrieve_connection_pool(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil), strict: T.unsafe(nil)); end private def connection_name_to_pool_manager; end - def deprecation_for_pool_handling(method); end def determine_owner_name(owner_name, config); end def disconnect_pool_from_pool_manager(pool_manager, role, shard); end def get_pool_manager(connection_name); end @@ -2670,8 +2717,6 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler def set_pool_manager(connection_name); end end -ActiveRecord::ConnectionAdapters::ConnectionHandler::FINALIZER = T.let(T.unsafe(nil), Proc) - class ActiveRecord::ConnectionAdapters::ConnectionHandler::StringConnectionName def initialize(name); end @@ -2681,18 +2726,20 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler::StringConnectionName end class ActiveRecord::ConnectionAdapters::ConnectionPool - include ::MonitorMixin include ::ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration + include ::MonitorMixin include ::ActiveRecord::ConnectionAdapters::AbstractPool - def initialize(pool_config); end + def initialize(*_arg0, **_arg1, &_arg2); end + def active_connection; end def active_connection?; end def async_executor; end def automatic_reconnect; end def automatic_reconnect=(_arg0); end def checkin(conn); end def checkout(checkout_timeout = T.unsafe(nil)); end + def checkout_and_verify(connection); end def checkout_timeout; end def checkout_timeout=(_arg0); end def clear_reloadable_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end @@ -2700,7 +2747,6 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool def connected?; end def connection; end def connection_class; end - def connection_klass(*args, **_arg1, &block); end def connections; end def db_config; end def discard!; end @@ -2709,21 +2755,31 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool def disconnect!; end def flush(minimum_idle = T.unsafe(nil)); end def flush!; end - def lock_thread=(lock_thread); end + def inspect; end + def internal_metadata; end + def lease_connection; end + def migration_context; end + def migrations_paths; end def num_waiting_in_queue; end + def permanent_lease?; end + def pin_connection!(lock_thread); end def pool_config; end def reap; end def reaper; end - def release_connection(owner_thread = T.unsafe(nil)); end + def release_connection(existing_lease = T.unsafe(nil)); end def remove(conn); end def role; end def schedule_query(future_result); end + def schema_cache; end + def schema_migration; end def schema_reflection(*_arg0, **_arg1, &_arg2); end - def schema_reflection=(arg); end + def schema_reflection=(schema_reflection); end + def server_version(*_arg0, **_arg1, &_arg2); end def shard; end def size; end def stat; end - def with_connection; end + def unpin_connection!; end + def with_connection(prevent_permanent_checkout: T.unsafe(nil)); end private @@ -2732,11 +2788,9 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end def build_async_executor; end def bulk_make_new_connections(num_new_conns_needed); end - def checkout_and_verify(c); end def checkout_for_exclusive_access(checkout_timeout); end def checkout_new_connection; end - def connection_cache_key(thread); end - def current_thread; end + def connection_lease; end def new_connection; end def release(conn, owner_thread = T.unsafe(nil)); end def remove_connection_from_thread_cache(conn, owner_thread = T.unsafe(nil)); end @@ -2766,6 +2820,24 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool::ConnectionLeasingQueue < def internal_poll(timeout); end end +class ActiveRecord::ConnectionAdapters::ConnectionPool::Lease + def initialize; end + + def clear(connection); end + def connection; end + def connection=(_arg0); end + def release; end + def sticky; end + def sticky=(_arg0); end +end + +class ActiveRecord::ConnectionAdapters::ConnectionPool::LeaseRegistry + def initialize; end + + def [](context); end + def clear; end +end + class ActiveRecord::ConnectionAdapters::ConnectionPool::Queue def initialize(lock = T.unsafe(nil)); end @@ -2803,6 +2875,14 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper end end +class ActiveRecord::ConnectionAdapters::ConnectionPool::WeakThreadKeyMap + def initialize; end + + def [](key); end + def []=(key, value); end + def clear; end +end + class ActiveRecord::ConnectionAdapters::CreateIndexDefinition < ::Struct def algorithm; end def algorithm=(_); end @@ -2862,7 +2942,7 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements def insert(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil), returning: T.unsafe(nil)); end def insert_fixture(fixture, table_name); end def insert_fixtures_set(fixture_set, tables_to_delete = T.unsafe(nil)); end - def internal_exec_query(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil)); end + def internal_exec_query(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end def mark_transaction_written_if_write(sql); end def materialize_transactions(*_arg0, **_arg1, &_arg2); end def open_transactions(*_arg0, **_arg1, &_arg2); end @@ -2876,7 +2956,7 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements def rollback_to_savepoint(name = T.unsafe(nil)); end def rollback_transaction(*_arg0, **_arg1, &_arg2); end def sanitize_limit(limit); end - def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end + def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end def select_one(arel, name = T.unsafe(nil), binds = T.unsafe(nil), async: T.unsafe(nil)); end def select_rows(arel, name = T.unsafe(nil), binds = T.unsafe(nil), async: T.unsafe(nil)); end def select_value(arel, name = T.unsafe(nil), binds = T.unsafe(nil), async: T.unsafe(nil)); end @@ -2908,10 +2988,10 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements def last_inserted_id(result); end def raw_execute(sql, name, async: T.unsafe(nil), allow_retry: T.unsafe(nil), materialize_transactions: T.unsafe(nil)); end def returning_column_values(result); end - def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil)); end + def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end def single_value_from_rows(rows); end def sql_for_insert(sql, pk, binds, returning); end - def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil)); end + def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil), allow_retry = T.unsafe(nil)); end def with_multi_statements; end end @@ -3001,37 +3081,45 @@ end class ActiveRecord::ConnectionAdapters::NullPool include ::ActiveRecord::ConnectionAdapters::AbstractPool + def initialize; end + def async_executor; end def checkin(_); end def connection_class; end def db_config; end + def dirties_query_cache; end def remove(_); end + def schema_cache; end def schema_reflection; end + def server_version(connection); end end ActiveRecord::ConnectionAdapters::NullPool::NULL_CONFIG = T.let(T.unsafe(nil), ActiveRecord::ConnectionAdapters::NullPool::NullConfig) class ActiveRecord::ConnectionAdapters::NullPool::NullConfig - def method_missing(*_arg0); end + def method_missing(*_arg0, **_arg1, &_arg2); end end class ActiveRecord::ConnectionAdapters::NullTransaction - def initialize; end - def add_record(record, _ = T.unsafe(nil)); end + def after_commit; end + def after_rollback; end + def before_commit; end def closed?; end def dirty!; end def dirty?; end def invalidate!; end def invalidated?; end def joinable?; end + def materialized?; end def open?; end def restartable?; end def state; end + def user_transaction; end end class ActiveRecord::ConnectionAdapters::PoolConfig - include ::Mutex_m + include ::MonitorMixin def initialize(connection_class, db_config, role, shard); end @@ -3041,16 +3129,13 @@ class ActiveRecord::ConnectionAdapters::PoolConfig def db_config; end def discard_pool!; end def disconnect!(automatic_reconnect: T.unsafe(nil)); end - def lock; end - def locked?; end def pool; end def role; end def schema_reflection; end def schema_reflection=(_arg0); end + def server_version(connection); end + def server_version=(_arg0); end def shard; end - def synchronize(&block); end - def try_lock; end - def unlock; end class << self def discard_pools!; end @@ -3089,21 +3174,22 @@ end module ActiveRecord::ConnectionAdapters::QueryCache def initialize(*_arg0); end - def cache; end + def cache(&block); end def clear_query_cache; end def disable_query_cache!; end def enable_query_cache!; end def query_cache; end + def query_cache=(_arg0); end def query_cache_enabled; end - def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end - def uncached; end + def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end + def uncached(dirties: T.unsafe(nil), &block); end private def cache_notification_info(sql, name, binds); end def cache_sql(sql, name, binds); end - def configure_query_cache!; end def lookup_sql_cache(sql, name, binds); end + def unset_query_cache!; end class << self def dirties_query_cache(base, *method_names); end @@ -3112,22 +3198,56 @@ module ActiveRecord::ConnectionAdapters::QueryCache end module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration - def initialize(*_arg0); end + def initialize(*_arg0, **_arg1, &_arg2); end + def checkout_and_verify(connection); end + def clear_query_cache; end + def dirties_query_cache; end + def disable_query_cache(dirties: T.unsafe(nil)); end def disable_query_cache!; end + def enable_query_cache; end def enable_query_cache!; end + def query_cache; end def query_cache_enabled; end end ActiveRecord::ConnectionAdapters::QueryCache::DEFAULT_SIZE = T.let(T.unsafe(nil), Integer) +class ActiveRecord::ConnectionAdapters::QueryCache::QueryCacheRegistry + def initialize; end + + def clear; end + def compute_if_absent(context); end +end + +class ActiveRecord::ConnectionAdapters::QueryCache::Store + def initialize(version, max_size); end + + def [](key); end + def clear; end + def compute_if_absent(key); end + def dirties; end + def dirties=(_arg0); end + def dirties?; end + def empty?; end + def enabled; end + def enabled=(_arg0); end + def enabled?; end + def size; end + + private + + def check_version; end +end + module ActiveRecord::ConnectionAdapters::Quoting + extend ::ActiveSupport::Concern + + mixes_in_class_methods ::ActiveRecord::ConnectionAdapters::Quoting::ClassMethods + def cast_bound_value(value); end - def column_name_matcher; end - def column_name_with_order_matcher; end def lookup_cast_type_from_column(column); end def quote(value); end - def quote_bound_value(value); end def quote_column_name(column_name); end def quote_default_expression(value, column); end def quote_string(s); end @@ -3147,11 +3267,14 @@ module ActiveRecord::ConnectionAdapters::Quoting def lookup_cast_type(sql_type); end def type_casted_binds(binds); end - def warn_quote_duration_deprecated; end end -ActiveRecord::ConnectionAdapters::Quoting::COLUMN_NAME = T.let(T.unsafe(nil), Regexp) -ActiveRecord::ConnectionAdapters::Quoting::COLUMN_NAME_WITH_ORDER = T.let(T.unsafe(nil), Regexp) +module ActiveRecord::ConnectionAdapters::Quoting::ClassMethods + def column_name_matcher; end + def column_name_with_order_matcher; end + def quote_column_name(column_name); end + def quote_table_name(table_name); end +end class ActiveRecord::ConnectionAdapters::RealTransaction < ::ActiveRecord::ConnectionAdapters::Transaction def commit; end @@ -3217,26 +3340,24 @@ end class ActiveRecord::ConnectionAdapters::SchemaCache def initialize; end - def add(connection, table_name); end - def add_all(connection); end + def add(pool, table_name); end + def add_all(pool); end def cached?(table_name); end def clear_data_source_cache!(_connection, name); end - def columns(connection, table_name); end - def columns_hash(connection, table_name); end - def columns_hash?(connection, table_name); end - def data_source_exists?(connection, name); end - def data_sources(*args, **_arg1, &block); end - def database_version(connection); end + def columns(pool, table_name); end + def columns_hash(pool, table_name); end + def columns_hash?(_pool, table_name); end + def data_source_exists?(pool, name); end def dump_to(filename); end def encode_with(coder); end - def indexes(connection, table_name); end + def indexes(pool, table_name); end def init_with(coder); end def marshal_dump; end def marshal_load(array); end - def primary_keys(connection, table_name); end + def primary_keys(pool, table_name); end def schema_version; end def size; end - def version(connection); end + def version(pool); end private @@ -3245,13 +3366,10 @@ class ActiveRecord::ConnectionAdapters::SchemaCache def ignored_table?(table_name); end def initialize_dup(other); end def open(filename); end - def prepare_data_sources(connection); end - def tables_to_cache(connection); end + def tables_to_cache(pool); end class << self def _load_from(filename); end - def load_from(*args, **_arg1, &block); end - def new(*args, **_arg1, &block); end private @@ -3329,29 +3447,27 @@ ActiveRecord::ConnectionAdapters::SchemaDumper::DEFAULT_DATETIME_PRECISION = T.l class ActiveRecord::ConnectionAdapters::SchemaReflection def initialize(cache_path, cache = T.unsafe(nil)); end - def add(connection, name); end + def add(pool, name); end def cached?(table_name); end def clear!; end - def clear_data_source_cache!(connection, name); end - def columns(connection, table_name); end - def columns_hash(connection, table_name); end - def columns_hash?(connection, table_name); end - def data_source_exists?(connection, name); end - def data_sources(connection, name); end - def database_version(connection); end - def dump_to(connection, filename); end - def indexes(connection, table_name); end - def load!(connection); end - def primary_keys(connection, table_name); end - def set_schema_cache(cache); end - def size(connection); end - def version(connection); end - - private - - def cache(connection); end + def clear_data_source_cache!(pool, name); end + def columns(pool, table_name); end + def columns_hash(pool, table_name); end + def columns_hash?(pool, table_name); end + def data_source_exists?(pool, name); end + def data_sources(pool, name); end + def dump_to(pool, filename); end + def indexes(pool, table_name); end + def load!(pool); end + def primary_keys(pool, table_name); end + def size(pool); end + def version(pool); end + + private + + def cache(pool); end def empty_cache; end - def load_cache(connection); end + def load_cache(pool); end def possible_cache_available?; end class << self @@ -3480,7 +3596,7 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements def remove_timestamps_for_alter(table_name, **options); end def rename_column_indexes(table_name, column_name, new_column_name); end def rename_column_sql(table_name, column_name, new_column_name); end - def rename_table_indexes(table_name, new_name); end + def rename_table_indexes(table_name, new_name, **options); end def strip_table_name_prefix_and_suffix(table_name); end def validate_change_column_null_argument!(value); end def validate_create_table_options!(options); end @@ -3621,6 +3737,9 @@ class ActiveRecord::ConnectionAdapters::Transaction def initialize(connection, isolation: T.unsafe(nil), joinable: T.unsafe(nil), run_commit_callbacks: T.unsafe(nil)); end def add_record(record, ensure_finalize = T.unsafe(nil)); end + def after_commit(&block); end + def after_rollback(&block); end + def before_commit(&block); end def before_commit_records; end def closed?; end def commit_records; end @@ -3642,9 +3761,14 @@ class ActiveRecord::ConnectionAdapters::Transaction def rollback_records; end def savepoint_name; end def state; end + def user_transaction; end def written; end def written=(_arg0); end + protected + + def append_callbacks(callbacks); end + private def prepare_instances_to_run_callbacks_on(records); end @@ -3652,6 +3776,14 @@ class ActiveRecord::ConnectionAdapters::Transaction def unique_records; end end +class ActiveRecord::ConnectionAdapters::Transaction::Callback + def initialize(event, callback); end + + def after_commit; end + def after_rollback; end + def before_commit; end +end + class ActiveRecord::ConnectionAdapters::TransactionInstrumenter def initialize(payload = T.unsafe(nil)); end @@ -3709,11 +3841,9 @@ end class ActiveRecord::ConnectionFailed < ::ActiveRecord::QueryAborted; end module ActiveRecord::ConnectionHandling - def clear_active_connections!(role = T.unsafe(nil)); end - def clear_all_connections!(role = T.unsafe(nil)); end + def adapter_class; end def clear_cache!; end def clear_query_caches_for_current_thread; end - def clear_reloadable_connections!(role = T.unsafe(nil)); end def connected?; end def connected_to(role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil), &blk); end def connected_to?(role:, shard: T.unsafe(nil)); end @@ -3726,18 +3856,20 @@ module ActiveRecord::ConnectionHandling def connection_specification_name=(_arg0); end def connects_to(database: T.unsafe(nil), shards: T.unsafe(nil)); end def establish_connection(config_or_env = T.unsafe(nil)); end - def flush_idle_connections!(role = T.unsafe(nil)); end + def lease_connection; end def primary_class?; end def prohibit_shard_swapping(enabled = T.unsafe(nil)); end - def remove_connection(name = T.unsafe(nil)); end + def release_connection; end + def remove_connection; end def retrieve_connection; end + def schema_cache; end def shard_swapping_prohibited?; end def while_preventing_writes(enabled = T.unsafe(nil), &block); end + def with_connection(prevent_permanent_checkout: T.unsafe(nil), &block); end private def append_to_connected_to_stack(entry); end - def deprecation_for_delegation(method); end def resolve_config_for_connection(config_or_env); end def with_role_and_shard(role, shard, prevent_writes); end end @@ -3771,6 +3903,7 @@ module ActiveRecord::Core def eql?(comparison_object); end def freeze; end def frozen?; end + def full_inspect; end def hash; end def init_with(coder, &block); end def init_with_attributes(attributes, new_record = T.unsafe(nil)); end @@ -3781,15 +3914,18 @@ module ActiveRecord::Core def readonly?; end def strict_loading!(value = T.unsafe(nil), mode: T.unsafe(nil)); end def strict_loading?; end + def strict_loading_all?; end def strict_loading_mode; end def strict_loading_n_plus_one_only?; end private + def attributes_for_inspect; end def custom_inspect_method_defined?; end def init_internals; end def initialize_dup(other); end def initialize_internals_callback; end + def inspect_with_attributes(attributes_to_list); end def inspection_filter; end def to_ary; end @@ -3797,6 +3933,9 @@ module ActiveRecord::Core def _destroy_association_async_job; end def _destroy_association_async_job=(value); end def _destroy_association_async_job?; end + def attributes_for_inspect; end + def attributes_for_inspect=(value); end + def attributes_for_inspect?; end def belongs_to_required_by_default; end def belongs_to_required_by_default=(value); end def belongs_to_required_by_default?; end @@ -3846,7 +3985,7 @@ end module ActiveRecord::Core::ClassMethods def arel_table; end - def cached_find_by_statement(key, &block); end + def cached_find_by_statement(connection, key, &block); end def filter_attributes; end def filter_attributes=(filter_attributes); end def find(*ids); end @@ -3882,22 +4021,29 @@ module ActiveRecord::CounterCache private def _create_record(attribute_names = T.unsafe(nil)); end + def _foreign_keys_equal?(fkey1, fkey2); end def destroy_row; end - def each_counter_cached_associations; end module GeneratedClassMethods def _counter_cache_columns; end def _counter_cache_columns=(value); end def _counter_cache_columns?; end + def counter_cached_association_names; end + def counter_cached_association_names=(value); end + def counter_cached_association_names?; end end - module GeneratedInstanceMethods; end + module GeneratedInstanceMethods + def counter_cached_association_names; end + def counter_cached_association_names?; end + end end module ActiveRecord::CounterCache::ClassMethods def counter_cache_column?(name); end def decrement_counter(counter_name, id, by: T.unsafe(nil), touch: T.unsafe(nil)); end def increment_counter(counter_name, id, by: T.unsafe(nil), touch: T.unsafe(nil)); end + def load_schema!; end def reset_counters(id, *counters, touch: T.unsafe(nil)); end def update_counters(id, counters); end end @@ -3949,6 +4095,7 @@ class ActiveRecord::DatabaseConfigurations::ConnectionUrlResolver def database_from_path; end def query_hash; end def raw_config; end + def resolved_adapter; end def uri; end def uri_parser; end end @@ -3958,24 +4105,27 @@ class ActiveRecord::DatabaseConfigurations::DatabaseConfig def _database=(database); end def adapter; end - def adapter_class_method; end - def adapter_method; end + def adapter_class; end def checkout_timeout; end def database; end def env_name; end def for_current_env?; end def host; end def idle_timeout; end + def inspect; end def max_queue; end def max_threads; end def migrations_paths; end def min_threads; end def name; end + def new_connection; end def pool; end def query_cache; end def reaping_frequency; end def replica?; end def schema_cache_path; end + def use_metadata_table?; end + def validate!; end end class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::DatabaseConfigurations::DatabaseConfig @@ -3987,7 +4137,7 @@ class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::Databas def configuration_hash; end def database; end def database_tasks?; end - def default_schema_cache_path; end + def default_schema_cache_path(db_dir = T.unsafe(nil)); end def host; end def idle_timeout; end def lazy_schema_cache_path; end @@ -4003,6 +4153,7 @@ class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::Databas def schema_cache_path; end def schema_dump(format = T.unsafe(nil)); end def socket; end + def use_metadata_table?; end private @@ -4019,6 +4170,7 @@ class ActiveRecord::DatabaseConfigurations::UrlConfig < ::ActiveRecord::Database private def build_url_hash; end + def to_boolean!(configuration_hash, key); end end class ActiveRecord::DatabaseConnectionError < ::ActiveRecord::ConnectionNotEstablished @@ -4030,6 +4182,7 @@ class ActiveRecord::DatabaseConnectionError < ::ActiveRecord::ConnectionNotEstab end end +class ActiveRecord::DatabaseVersionError < ::ActiveRecord::ActiveRecordError; end class ActiveRecord::Deadlocked < ::ActiveRecord::TransactionRollbackError; end module ActiveRecord::DelegatedType @@ -4059,6 +4212,7 @@ module ActiveRecord::Delegation def index(*_arg0, **_arg1, &_arg2); end def intersect?(*_arg0, **_arg1, &_arg2); end def join(*_arg0, **_arg1, &_arg2); end + def lease_connection(*_arg0, **_arg1, &_arg2); end def length(*_arg0, **_arg1, &_arg2); end def primary_key(*_arg0, **_arg1, &_arg2); end def reverse(*_arg0, **_arg1, &_arg2); end @@ -4073,6 +4227,7 @@ module ActiveRecord::Delegation def to_sentence(*_arg0, **_arg1, &_arg2); end def to_xml(*_arg0, **_arg1, &_arg2); end def transaction(*_arg0, **_arg1, &_arg2); end + def with_connection(*_arg0, **_arg1, &_arg2); end def |(*_arg0, **_arg1, &_arg2); end private @@ -4100,7 +4255,7 @@ module ActiveRecord::Delegation::ClassSpecificRelation private - def method_missing(method, *args, **_arg2, &block); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end end module ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods @@ -4123,21 +4278,15 @@ module ActiveRecord::Delegation::DelegateCache end class ActiveRecord::Delegation::GeneratedRelationMethods < ::Module - include ::Mutex_m - def generate_method(method); end - def lock; end - def locked?; end - def synchronize(&block); end - def try_lock; end - def unlock; end end +ActiveRecord::Delegation::GeneratedRelationMethods::MUTEX = T.let(T.unsafe(nil), Thread::Mutex) + class ActiveRecord::DeleteRestrictionError < ::ActiveRecord::ActiveRecordError def initialize(name = T.unsafe(nil)); end end -class ActiveRecord::DeprecatedActiveJobRequiredError < ::ActiveRecord::ActiveRecordError; end class ActiveRecord::DestroyAssociationAsyncError < ::StandardError; end class ActiveRecord::DisableJoinsAssociationRelation < ::ActiveRecord::Relation @@ -4161,7 +4310,7 @@ end module ActiveRecord::DynamicMatchers private - def method_missing(name, *arguments, &block); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(name, _); end end @@ -4456,7 +4605,7 @@ end ActiveRecord::Encryption::EncryptableRecord::ORIGINAL_ATTRIBUTE_PREFIX = T.let(T.unsafe(nil), String) -class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::Text +class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveModel::Type::Value include ::ActiveModel::Type::Helpers::Mutable def initialize(scheme:, cast_type: T.unsafe(nil), previous_type: T.unsafe(nil), default: T.unsafe(nil)); end @@ -4476,6 +4625,7 @@ class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::T def scheme; end def serialize(value); end def support_unencrypted_data?; end + def type(*_arg0, **_arg1, &_arg2); end def with_context(*_arg0, **_arg1, &_arg2); end private @@ -4483,8 +4633,10 @@ class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::T def build_previous_types_for(schemes); end def clean_text_scheme; end def decrypt(value); end + def decrypt_as_text(value); end def decryption_options; end def encrypt(value); end + def encrypt_as_text(value); end def encryption_options; end def encryptor; end def handle_deserialize_error(error, value); end @@ -4494,6 +4646,7 @@ class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::T def serialize_with_current(value); end def serialize_with_oldest(value); end def serialize_with_oldest?; end + def text_to_database_type(value); end def try_to_deserialize_with_previous_encrypted_types(value); end end @@ -4511,6 +4664,9 @@ class ActiveRecord::Encryption::EncryptingOnlyEncryptor < ::ActiveRecord::Encryp end class ActiveRecord::Encryption::Encryptor + def initialize(compress: T.unsafe(nil)); end + + def binary?; end def decrypt(encrypted_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end def encrypt(clear_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end def encrypted?(text); end @@ -4520,6 +4676,7 @@ class ActiveRecord::Encryption::Encryptor def build_encrypted_message(clear_text, key_provider:, cipher_options:); end def cipher; end def compress(data); end + def compress?; end def compress_if_worth_it(string); end def default_key_provider; end def deserialize_message(message); end @@ -4668,6 +4825,7 @@ class ActiveRecord::Encryption::Message end class ActiveRecord::Encryption::MessageSerializer + def binary?; end def dump(message); end def load(serialized_content); end @@ -4683,6 +4841,7 @@ class ActiveRecord::Encryption::MessageSerializer end class ActiveRecord::Encryption::NullEncryptor + def binary?; end def decrypt(encrypted_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end def encrypt(clean_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end def encrypted?(text); end @@ -4709,7 +4868,7 @@ class ActiveRecord::Encryption::Properties def iv; end def iv=(value); end def key?(*_arg0, **_arg1, &_arg2); end - def method_missing(method, *args, **_arg2, &block); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def to_h; end def validate_value_type(value); end @@ -4723,6 +4882,7 @@ ActiveRecord::Encryption::Properties::ALLOWED_VALUE_CLASSES = T.let(T.unsafe(nil ActiveRecord::Encryption::Properties::DEFAULT_PROPERTIES = T.let(T.unsafe(nil), Hash) class ActiveRecord::Encryption::ReadOnlyNullEncryptor + def binary?; end def decrypt(encrypted_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end def encrypt(clean_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end def encrypted?(text); end @@ -4746,19 +4906,22 @@ class ActiveRecord::Encryption::Scheme private - def build_key_provider; end def default_key_provider; end + def deterministic_key_provider; end + def key_provider_from_key; end def validate_config!; end end module ActiveRecord::Enum def enum(name = T.unsafe(nil), values = T.unsafe(nil), **options); end + def load_schema!; end private def _enum(name, values, prefix: T.unsafe(nil), suffix: T.unsafe(nil), scopes: T.unsafe(nil), instance_methods: T.unsafe(nil), validate: T.unsafe(nil), **options); end def _enum_methods_module; end def assert_valid_enum_definition_values(values); end + def assert_valid_enum_options(options); end def detect_enum_conflict!(enum_name, method_name, klass_method = T.unsafe(nil)); end def detect_negative_enum_conditions!(method_names); end def inherited(base); end @@ -4813,9 +4976,8 @@ module ActiveRecord::Explain private - def build_explain_clause(options = T.unsafe(nil)); end - def connection_explain(sql, binds, options); end - def render_bind(attr); end + def build_explain_clause(connection, options = T.unsafe(nil)); end + def render_bind(connection, attr); end end class ActiveRecord::ExplainRegistry @@ -4946,15 +5108,15 @@ class ActiveRecord::FixtureSet class << self def all_loaded_fixtures; end def all_loaded_fixtures=(val); end - def cache_fixtures(connection, fixtures_map); end - def cache_for_connection(connection); end - def cached_fixtures(connection, keys_to_fetch = T.unsafe(nil)); end + def cache_fixtures(connection_pool, fixtures_map); end + def cache_for_connection_pool(connection_pool); end + def cached_fixtures(connection_pool, keys_to_fetch = T.unsafe(nil)); end def composite_identify(label, key); end def context_class; end - def create_fixtures(fixtures_directories, fixture_set_names, class_names = T.unsafe(nil), config = T.unsafe(nil), &block); end + def create_fixtures(fixtures_directories, fixture_set_names, class_names = T.unsafe(nil), config = T.unsafe(nil)); end def default_fixture_model_name(fixture_set_name, config = T.unsafe(nil)); end def default_fixture_table_name(fixture_set_name, config = T.unsafe(nil)); end - def fixture_is_cached?(connection, table_name); end + def fixture_is_cached?(connection_pool, table_name); end def identify(label, column_type = T.unsafe(nil)); end def instantiate_all_loaded_fixtures(object, load_instances = T.unsafe(nil)); end def instantiate_fixtures(object, fixture_set, load_instances = T.unsafe(nil)); end @@ -4963,8 +5125,8 @@ class ActiveRecord::FixtureSet private def check_all_foreign_keys_valid!(conn); end - def insert(fixture_sets, connection); end - def read_and_insert(fixtures_directories, fixture_files, class_names, connection); end + def insert(fixture_sets, connection_pool); end + def read_and_insert(fixtures_directories, fixture_files, class_names, connection_pool); end def update_all_loaded_fixtures(fixtures_map); end end end @@ -5073,7 +5235,6 @@ class ActiveRecord::FutureResult def execute!(connection); end def execute_or_skip; end def lock_wait; end - def method_missing(method, *args, **_arg2, &block); end def pending?; end def result; end def schedule!(session); end @@ -5085,7 +5246,10 @@ class ActiveRecord::FutureResult def exec_query(connection, *args, **kwargs); end def execute_or_wait; end def execute_query(connection, async: T.unsafe(nil)); end - def respond_to_missing?(name, include_private = T.unsafe(nil)); end + + class << self + def wrap(result); end + end end class ActiveRecord::FutureResult::Canceled < ::ActiveRecord::ActiveRecordError; end @@ -5195,8 +5359,6 @@ class ActiveRecord::IllegalMigrationNameError < ::ActiveRecord::MigrationError def initialize(name = T.unsafe(nil)); end end -class ActiveRecord::ImmutableRelation < ::ActiveRecord::ActiveRecordError; end - module ActiveRecord::Inheritance extend ::ActiveSupport::Concern include GeneratedInstanceMethods @@ -5259,7 +5421,7 @@ module ActiveRecord::Inheritance::ClassMethods end class ActiveRecord::InsertAll - def initialize(model, inserts, on_duplicate:, update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end + def initialize(relation, connection, inserts, on_duplicate:, update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end def connection; end def execute; end @@ -5291,12 +5453,15 @@ class ActiveRecord::InsertAll def resolve_attribute_alias(attribute); end def resolve_attribute_aliases; end def resolve_sti; end - def scope_attributes; end def timestamps_for_create; end def to_sql; end def unique_by_columns; end def unique_indexes; end def verify_attributes(attributes); end + + class << self + def execute(relation, *_arg1, **_arg2, &_arg3); end + end end class ActiveRecord::InsertAll::Builder @@ -5374,12 +5539,11 @@ module ActiveRecord::Integration::ClassMethods end class ActiveRecord::InternalMetadata - def initialize(connection); end + def initialize(pool); end def [](key); end def []=(key, value); end def arel_table; end - def connection; end def count; end def create_table; end def create_table_and_set_flags(environment, schema_sha1 = T.unsafe(nil)); end @@ -5393,16 +5557,20 @@ class ActiveRecord::InternalMetadata private - def create_entry(key, value); end - def current_time; end - def select_entry(key); end - def update_entry(key, new_value); end - def update_or_create_entry(key, value); end + def create_entry(connection, key, value); end + def current_time(connection); end + def select_entry(connection, key); end + def update_entry(connection, key, new_value); end + def update_or_create_entry(connection, key, value); end end class ActiveRecord::InternalMetadata::NullInternalMetadata; end class ActiveRecord::InvalidForeignKey < ::ActiveRecord::WrappedDatabaseException; end +class ActiveRecord::InvalidMigrationTimestampError < ::ActiveRecord::MigrationError + def initialize(version = T.unsafe(nil), name = T.unsafe(nil)); end +end + class ActiveRecord::InverseOfAssociationNotFoundError < ::ActiveRecord::ActiveRecordError include ::DidYouMean::Correctable @@ -5479,7 +5647,6 @@ module ActiveRecord::Locking::Optimistic end module ActiveRecord::Locking::Optimistic::ClassMethods - def define_attribute(name, cast_type, **_arg2); end def locking_column; end def locking_column=(value); end def locking_enabled?; end @@ -5488,6 +5655,7 @@ module ActiveRecord::Locking::Optimistic::ClassMethods private + def hook_attribute_type(name, cast_type); end def inherited(base); end end @@ -5522,9 +5690,6 @@ class ActiveRecord::LogSubscriber < ::ActiveSupport::LogSubscriber def backtrace_cleaner=(value); end def backtrace_cleaner?; end def log_levels; end - def reset_runtime; end - def runtime; end - def runtime=(value); end end end @@ -5619,6 +5784,7 @@ class ActiveRecord::Migration def announce(message); end def connection; end + def connection_pool; end def copy(destination, sources, options = T.unsafe(nil)); end def disable_ddl_transaction; end def down; end @@ -5656,7 +5822,6 @@ class ActiveRecord::Migration class << self def [](version); end def check_all_pending!; end - def check_pending!(connection = T.unsafe(nil)); end def check_pending_migrations; end def current_version; end def delegate; end @@ -5667,7 +5832,7 @@ class ActiveRecord::Migration def inherited(subclass); end def load_schema_if_pending!; end def maintain_test_schema!; end - def method_missing(name, *args, **_arg2, &block); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def migrate(direction); end def nearest_delegate; end def valid_version_format?(version_string); end @@ -5780,7 +5945,7 @@ class ActiveRecord::Migration::CommandRecorder def invert_rename_index(args); end def invert_rename_table(args); end def invert_transaction(args, &block); end - def method_missing(method, *args, **_arg2, &block); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(method, _); end end @@ -5943,7 +6108,7 @@ module ActiveRecord::Migration::Compatibility::V6_1::TableDefinition def raise_on_if_exist_options(options); end end -class ActiveRecord::Migration::Compatibility::V7_0 < ::ActiveRecord::Migration::Current +class ActiveRecord::Migration::Compatibility::V7_0 < ::ActiveRecord::Migration::Compatibility::V7_1 include ::ActiveRecord::Migration::Compatibility::V7_0::LegacyIndexName def add_belongs_to(table_name, ref_name, **options); end @@ -5976,13 +6141,15 @@ module ActiveRecord::Migration::Compatibility::V7_0::TableDefinition def change(name, type, **options); end def column(name, type, **options); end def index(column_name, **options); end + def references(*args, **options); end private def raise_on_if_exist_options(options); end end -ActiveRecord::Migration::Compatibility::V7_1 = ActiveRecord::Migration::Current +class ActiveRecord::Migration::Compatibility::V7_1 < ::ActiveRecord::Migration::Current; end +ActiveRecord::Migration::Compatibility::V7_2 = ActiveRecord::Migration::Current class ActiveRecord::Migration::Current < ::ActiveRecord::Migration def change_table(table_name, **options); end @@ -5996,8 +6163,8 @@ class ActiveRecord::Migration::DefaultStrategy < ::ActiveRecord::Migration::Exec private def connection; end - def method_missing(method, *arguments, **_arg2, &block); end - def respond_to_missing?(method, *_arg1); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end + def respond_to_missing?(method, include_private = T.unsafe(nil)); end end class ActiveRecord::Migration::ExecutionStrategy @@ -6058,9 +6225,12 @@ class ActiveRecord::MigrationContext private def connection; end + def connection_pool; end def migration_files; end def move(direction, steps); end def parse_migration_filename(filename); end + def valid_migration_timestamp?(version); end + def validate_timestamp?; end end class ActiveRecord::MigrationError < ::ActiveRecord::ActiveRecordError @@ -6203,9 +6373,7 @@ module ActiveRecord::ModelSchema end module ActiveRecord::ModelSchema::ClassMethods - def _default_attributes; end - def _returning_columns_for_insert; end - def attribute_types; end + def _returning_columns_for_insert(connection); end def attributes_builder; end def column_defaults; end def column_for_attribute(name); end @@ -6233,7 +6401,6 @@ module ActiveRecord::ModelSchema::ClassMethods def table_exists?; end def table_name; end def table_name=(value); end - def type_for_attribute(attr_name, &block); end def yaml_encoder; end protected @@ -6243,11 +6410,11 @@ module ActiveRecord::ModelSchema::ClassMethods private - def _convert_type_from_options(type); end def compute_table_name; end def inherited(child_class); end def load_schema!; end def schema_loaded?; end + def type_for_column(connection, column); end def undecorated_table_name(model_name); end end @@ -6407,8 +6574,8 @@ class ActiveRecord::NotNullViolation < ::ActiveRecord::StatementInvalid; end class ActiveRecord::PendingMigrationConnection class << self def current_preventing_writes; end - def establish_temporary_connection(db_config, &block); end def primary_class?; end + def with_temporary_pool(db_config, &block); end end end @@ -6424,7 +6591,7 @@ class ActiveRecord::PendingMigrationError < ::ActiveRecord::MigrationError private - def connection; end + def connection_pool; end def detailed_migration_message(pending_migrations); end class << self @@ -6490,26 +6657,18 @@ end module ActiveRecord::Persistence::ClassMethods def _delete_record(constraints); end - def _insert_record(values, returning); end + def _insert_record(connection, values, returning); end def _update_record(values, constraints); end def build(attributes = T.unsafe(nil), &block); end def composite_query_constraints_list; end def create(attributes = T.unsafe(nil), &block); end def create!(attributes = T.unsafe(nil), &block); end - def delete(id_or_array); end - def destroy(id); end def has_query_constraints?; end - def insert(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end - def insert!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end - def insert_all(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end - def insert_all!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end def instantiate(attributes, column_types = T.unsafe(nil), &block); end def query_constraints(*columns_list); end def query_constraints_list; end def update(id = T.unsafe(nil), attributes); end def update!(id = T.unsafe(nil), attributes); end - def upsert(attributes, **kwargs); end - def upsert_all(attributes, on_duplicate: T.unsafe(nil), update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end private @@ -6682,7 +6841,7 @@ end module ActiveRecord::QueryCache::ClassMethods def cache(&block); end - def uncached(&block); end + def uncached(dirties: T.unsafe(nil), &block); end end class ActiveRecord::QueryCanceled < ::ActiveRecord::QueryAborted; end @@ -6697,6 +6856,7 @@ module ActiveRecord::QueryLogs def clear_cache; end def prepend_comment; end def prepend_comment=(val); end + def query_source_location; end def taggings; end def taggings=(val); end def tags; end @@ -6869,6 +7029,8 @@ module ActiveRecord::QueryMethods def where_clause=(value); end def with(*args); end def with!(*args); end + def with_recursive(*args); end + def with_recursive!(*args); end def with_values; end def with_values=(value); end def without(*records); end @@ -6884,24 +7046,30 @@ module ActiveRecord::QueryMethods def arel_column(field); end def arel_columns(columns); end - def assert_mutability!; end + def arel_columns_from_hash(fields); end + def assert_modifiable!; end def async; end - def build_arel(aliases = T.unsafe(nil)); end + def build_arel(connection, aliases = T.unsafe(nil)); end + def build_bound_sql_literal(statement, values); end def build_case_for_value_position(column, values); end def build_cast_value(name, value); end def build_from; end def build_join_buckets; end def build_join_dependencies; end def build_joins(join_sources, aliases = T.unsafe(nil)); end + def build_named_bound_sql_literal(statement, values); end def build_order(arel); end def build_select(arel); end def build_with(arel); end + def build_with_expression_from_value(value); end def build_with_join_node(name, kind = T.unsafe(nil)); end def build_with_value_from_hash(hash); end def check_if_method_has_arguments!(method_name, args, message = T.unsafe(nil)); end def column_references(order_args); end def does_not_support_reverse?(order); end def each_join_dependencies(join_dependencies = T.unsafe(nil), &block); end + def extract_table_name_from(string); end + def flattened_args(args); end def lookup_table_klass_from_join_dependencies(table_name); end def order_column(field); end def preprocess_order_args(order_args); end @@ -6913,7 +7081,6 @@ module ActiveRecord::QueryMethods def select_named_joins(join_names, stashed_joins = T.unsafe(nil), &block); end def structurally_incompatible_values_for(other); end def table_name_matches?(from); end - def transform_select_hash_values(fields); end def validate_order_args(args); end end @@ -6943,7 +7110,7 @@ end module ActiveRecord::Querying def _load_from_sql(result_set, &block); end - def _query_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end + def _query_by_sql(connection, sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end def and(*_arg0, **_arg1, &_arg2); end def annotate(*_arg0, **_arg1, &_arg2); end def any?(*_arg0, **_arg1, &_arg2); end @@ -6964,8 +7131,10 @@ module ActiveRecord::Querying def create_or_find_by(*_arg0, **_arg1, &_arg2); end def create_or_find_by!(*_arg0, **_arg1, &_arg2); end def create_with(*_arg0, **_arg1, &_arg2); end + def delete(*_arg0, **_arg1, &_arg2); end def delete_all(*_arg0, **_arg1, &_arg2); end def delete_by(*_arg0, **_arg1, &_arg2); end + def destroy(*_arg0, **_arg1, &_arg2); end def destroy_all(*_arg0, **_arg1, &_arg2); end def destroy_by(*_arg0, **_arg1, &_arg2); end def distinct(*_arg0, **_arg1, &_arg2); end @@ -6980,7 +7149,7 @@ module ActiveRecord::Querying def find(*_arg0, **_arg1, &_arg2); end def find_by(*_arg0, **_arg1, &_arg2); end def find_by!(*_arg0, **_arg1, &_arg2); end - def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), &block); end + def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), allow_retry: T.unsafe(nil), &block); end def find_each(*_arg0, **_arg1, &_arg2); end def find_in_batches(*_arg0, **_arg1, &_arg2); end def find_or_create_by(*_arg0, **_arg1, &_arg2); end @@ -7003,6 +7172,10 @@ module ActiveRecord::Querying def in_batches(*_arg0, **_arg1, &_arg2); end def in_order_of(*_arg0, **_arg1, &_arg2); end def includes(*_arg0, **_arg1, &_arg2); end + def insert(*_arg0, **_arg1, &_arg2); end + def insert!(*_arg0, **_arg1, &_arg2); end + def insert_all(*_arg0, **_arg1, &_arg2); end + def insert_all!(*_arg0, **_arg1, &_arg2); end def invert_where(*_arg0, **_arg1, &_arg2); end def joins(*_arg0, **_arg1, &_arg2); end def last(*_arg0, **_arg1, &_arg2); end @@ -7049,14 +7222,16 @@ module ActiveRecord::Querying def touch_all(*_arg0, **_arg1, &_arg2); end def unscope(*_arg0, **_arg1, &_arg2); end def update_all(*_arg0, **_arg1, &_arg2); end + def upsert(*_arg0, **_arg1, &_arg2); end + def upsert_all(*_arg0, **_arg1, &_arg2); end def where(*_arg0, **_arg1, &_arg2); end def with(*_arg0, **_arg1, &_arg2); end + def with_recursive(*_arg0, **_arg1, &_arg2); end def without(*_arg0, **_arg1, &_arg2); end end ActiveRecord::Querying::QUERYING_METHODS = T.let(T.unsafe(nil), Array) class ActiveRecord::Railtie < ::Rails::Railtie; end -ActiveRecord::Railtie::SQLITE3_PRODUCTION_WARN = T.let(T.unsafe(nil), String) class ActiveRecord::RangeError < ::ActiveRecord::StatementInvalid; end class ActiveRecord::ReadOnlyError < ::ActiveRecord::ActiveRecordError; end class ActiveRecord::ReadOnlyRecord < ::ActiveRecord::ActiveRecordError; end @@ -7144,6 +7319,9 @@ module ActiveRecord::Reflection def automatic_scope_inversing; end def automatic_scope_inversing=(value); end def automatic_scope_inversing?; end + def automatically_invert_plural_associations; end + def automatically_invert_plural_associations=(value); end + def automatically_invert_plural_associations?; end end module GeneratedInstanceMethods @@ -7153,6 +7331,8 @@ module ActiveRecord::Reflection def aggregate_reflections?; end def automatic_scope_inversing; end def automatic_scope_inversing?; end + def automatically_invert_plural_associations; end + def automatically_invert_plural_associations?; end end end @@ -7168,6 +7348,7 @@ class ActiveRecord::Reflection::AbstractReflection def constraints; end def counter_cache_column; end def counter_must_be_updated_by_has_many?; end + def has_active_cached_counter?; end def has_cached_counter?; end def inverse_of; end def inverse_updates_counter_cache?; end @@ -7268,6 +7449,7 @@ end module ActiveRecord::Reflection::ClassMethods def _reflect_on_association(association); end def clear_reflections_cache; end + def normalized_reflections; end def reflect_on_aggregation(aggregation); end def reflect_on_all_aggregations; end def reflect_on_all_associations(macro = T.unsafe(nil)); end @@ -7301,6 +7483,7 @@ class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::Ab def initialize(name, scope, options, active_record); end def ==(other_aggregation); end + def _klass(class_name); end def active_record; end def autosave=(autosave); end def compute_class(name); end @@ -7314,7 +7497,7 @@ class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::Ab private def derive_class_name; end - def validate_reflection!; end + def normalize_options(options); end end class ActiveRecord::Reflection::PolymorphicReflection < ::ActiveRecord::Reflection::AbstractReflection @@ -7352,6 +7535,7 @@ end class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::AbstractReflection def initialize(delegate_reflection); end + def _klass(*_arg0, **_arg1, &_arg2); end def active_record(*_arg0, **_arg1, &_arg2); end def active_record_primary_key(*_arg0, **_arg1, &_arg2); end def add_as_polymorphic_through(reflection, seed); end @@ -7428,6 +7612,8 @@ class ActiveRecord::Relation include ::ActiveRecord::SpawnMethods include ::ActiveRecord::Calculations include ::ActiveRecord::FinderMethods + include ::ActiveRecord::TokenFor::RelationMethods + include ::ActiveRecord::SignedId::RelationMethods extend ::ActiveRecord::Delegation::ClassMethods def initialize(klass, table: T.unsafe(nil), predicate_builder: T.unsafe(nil), values: T.unsafe(nil)); end @@ -7446,8 +7632,10 @@ class ActiveRecord::Relation def create!(attributes = T.unsafe(nil), &block); end def create_or_find_by(attributes, &block); end def create_or_find_by!(attributes, &block); end + def delete(id_or_array); end def delete_all; end def delete_by(*args); end + def destroy(id); end def destroy_all; end def destroy_by(*args); end def eager_loading?; end @@ -7462,6 +7650,10 @@ class ActiveRecord::Relation def first_or_create!(attributes = T.unsafe(nil), &block); end def first_or_initialize(attributes = T.unsafe(nil), &block); end def has_limit_or_offset?; end + def insert(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end + def insert!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end + def insert_all(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end + def insert_all!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end def inspect; end def joined_includes_values; end def klass; end @@ -7496,6 +7688,8 @@ class ActiveRecord::Relation def update!(id = T.unsafe(nil), attributes); end def update_all(updates); end def update_counters(counters); end + def upsert(attributes, **kwargs); end + def upsert_all(attributes, on_duplicate: T.unsafe(nil), update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end def values; end def values_for_queries; end def where_values_hash(relation_table_name = T.unsafe(nil)); end @@ -7529,6 +7723,24 @@ end ActiveRecord::Relation::CLAUSE_METHODS = T.let(T.unsafe(nil), Array) +class ActiveRecord::Relation::ExplainProxy + def initialize(relation, options); end + + def average(column_name); end + def count(column_name = T.unsafe(nil)); end + def first(limit = T.unsafe(nil)); end + def inspect; end + def last(limit = T.unsafe(nil)); end + def maximum(column_name); end + def minimum(column_name); end + def pluck(*column_names); end + def sum(identity_or_column = T.unsafe(nil)); end + + private + + def exec_explain(&block); end +end + class ActiveRecord::Relation::FromClause def initialize(value, name); end @@ -7544,7 +7756,7 @@ class ActiveRecord::Relation::FromClause end class ActiveRecord::Relation::HashMerger - def initialize(relation, hash, rewhere = T.unsafe(nil)); end + def initialize(relation, hash); end def hash; end def merge; end @@ -7556,7 +7768,7 @@ ActiveRecord::Relation::INVALID_METHODS_FOR_DELETE_ALL = T.let(T.unsafe(nil), Ar ActiveRecord::Relation::MULTI_VALUE_METHODS = T.let(T.unsafe(nil), Array) class ActiveRecord::Relation::Merger - def initialize(relation, other, rewhere = T.unsafe(nil)); end + def initialize(relation, other); end def merge; end def other; end @@ -7621,7 +7833,7 @@ class ActiveRecord::Relation::WhereClause def extract_attributes; end def hash; end def invert; end - def merge(other, rewhere = T.unsafe(nil)); end + def merge(other); end def or(other); end def to_h(table_name = T.unsafe(nil), equality_only: T.unsafe(nil)); end def |(other); end @@ -7641,7 +7853,6 @@ class ActiveRecord::Relation::WhereClause def extract_node_value(node); end def invert_predicate(node); end def non_empty_predicates; end - def predicates_unreferenced_by(other); end def predicates_with_wrapped_sql_literals; end def wrap_sql_literal(node); end @@ -7660,6 +7871,7 @@ class ActiveRecord::Result def [](idx); end def cancel; end def cast_values(type_overrides = T.unsafe(nil)); end + def column_indexes; end def column_types; end def columns; end def each(&block); end @@ -7686,6 +7898,7 @@ end ActiveRecord::Result::EMPTY = T.let(T.unsafe(nil), ActiveRecord::Result) ActiveRecord::Result::EMPTY_ASYNC = T.let(T.unsafe(nil), ActiveRecord::FutureResult::Complete) +ActiveRecord::Result::EMPTY_HASH = T.let(T.unsafe(nil), Hash) class ActiveRecord::Rollback < ::ActiveRecord::ActiveRecordError; end module ActiveRecord::RuntimeRegistry @@ -7693,7 +7906,14 @@ module ActiveRecord::RuntimeRegistry def async_sql_runtime; end def async_sql_runtime=(runtime); end + def cached_queries_count; end + def cached_queries_count=(count); end + def queries_count; end + def queries_count=(count); end def reset; end + def reset_cached_queries_count; end + def reset_queries_count; end + def reset_runtimes; end def sql_runtime; end def sql_runtime=(runtime); end end @@ -7725,11 +7945,11 @@ module ActiveRecord::Sanitization::ClassMethods private - def quote_bound_value(value, c = T.unsafe(nil)); end + def quote_bound_value(connection, value); end def raise_if_bind_arity_mismatch(statement, expected, provided); end - def replace_bind_variable(value, c = T.unsafe(nil)); end - def replace_bind_variables(statement, values); end - def replace_named_bind_variables(statement, bind_vars); end + def replace_bind_variable(connection, value); end + def replace_bind_variables(connection, statement, values); end + def replace_named_bind_variables(connection, statement, bind_vars); end end class ActiveRecord::Schema < ::ActiveRecord::Migration::Current @@ -7795,7 +8015,7 @@ class ActiveRecord::SchemaDumper class << self def chk_ignore_pattern; end def chk_ignore_pattern=(val); end - def dump(connection = T.unsafe(nil), stream = T.unsafe(nil), config = T.unsafe(nil)); end + def dump(pool = T.unsafe(nil), stream = T.unsafe(nil), config = T.unsafe(nil)); end def excl_ignore_pattern; end def excl_ignore_pattern=(val); end def fk_ignore_pattern; end @@ -7813,10 +8033,9 @@ class ActiveRecord::SchemaDumper end class ActiveRecord::SchemaMigration - def initialize(connection); end + def initialize(pool); end def arel_table; end - def connection; end def count; end def create_table; end def create_version(version); end @@ -8042,6 +8261,11 @@ module ActiveRecord::SignedId::ClassMethods def signed_id_verifier=(verifier); end end +module ActiveRecord::SignedId::RelationMethods + def find_signed(*_arg0, **_arg1, &_arg2); end + def find_signed!(*_arg0, **_arg1, &_arg2); end +end + class ActiveRecord::SoleRecordExceeded < ::ActiveRecord::ActiveRecordError def initialize(record = T.unsafe(nil)); end @@ -8070,7 +8294,7 @@ end class ActiveRecord::StatementCache def initialize(query_builder, bind_map, klass); end - def execute(params, connection, &block); end + def execute(params, connection, allow_retry: T.unsafe(nil), &block); end private @@ -8111,6 +8335,8 @@ class ActiveRecord::StatementCache::PartialQueryCollector def add_binds(binds, proc_for_binds = T.unsafe(nil)); end def preparable; end def preparable=(_arg0); end + def retryable; end + def retryable=(_arg0); end def value; end end @@ -8244,7 +8470,7 @@ class ActiveRecord::Tasks::DatabaseNotSupported < ::StandardError; end module ActiveRecord::Tasks::DatabaseTasks extend ::ActiveRecord::Tasks::DatabaseTasks - def cache_dump_filename(db_config_name, schema_cache_path: T.unsafe(nil)); end + def cache_dump_filename(db_config_or_name, schema_cache_path: T.unsafe(nil)); end def charset(configuration, *arguments); end def charset_current(env_name = T.unsafe(nil), db_name = T.unsafe(nil)); end def check_protected_environments!(environment = T.unsafe(nil)); end @@ -8258,14 +8484,14 @@ module ActiveRecord::Tasks::DatabaseTasks def create_current(environment = T.unsafe(nil), name = T.unsafe(nil)); end def database_configuration; end def database_configuration=(_arg0); end - def db_configs_with_versions(db_configs); end + def db_configs_with_versions(environment = T.unsafe(nil)); end def db_dir; end def db_dir=(_arg0); end def drop(configuration, *arguments); end def drop_all; end def drop_current(environment = T.unsafe(nil)); end def dump_schema(db_config, format = T.unsafe(nil)); end - def dump_schema_cache(conn, filename); end + def dump_schema_cache(conn_or_pool, filename); end def env; end def env=(_arg0); end def fixtures_path; end @@ -8278,6 +8504,7 @@ module ActiveRecord::Tasks::DatabaseTasks def migrate_status; end def migration_class; end def migration_connection; end + def migration_connection_pool; end def migrations_paths; end def migrations_paths=(_arg0); end def name; end @@ -8299,8 +8526,8 @@ module ActiveRecord::Tasks::DatabaseTasks def structure_load(configuration, *arguments); end def target_version; end def truncate_all(environment = T.unsafe(nil)); end - def with_temporary_connection(db_config, clobber: T.unsafe(nil)); end - def with_temporary_connection_for_each(env: T.unsafe(nil), name: T.unsafe(nil), clobber: T.unsafe(nil), &block); end + def with_temporary_connection(db_config, clobber: T.unsafe(nil), &block); end + def with_temporary_pool_for_each(env: T.unsafe(nil), name: T.unsafe(nil), clobber: T.unsafe(nil), &block); end private @@ -8309,9 +8536,11 @@ module ActiveRecord::Tasks::DatabaseTasks def configs_for(**options); end def database_adapter_for(db_config, *arguments); end def each_current_configuration(environment, name = T.unsafe(nil)); end + def each_current_environment(environment, &block); end def each_local_configuration; end def local_database?(db_config); end def resolve_configuration(configuration); end + def schema_cache_env; end def schema_sha1(file); end def structure_dump_flags_for(adapter); end def structure_load_flags_for(adapter); end @@ -8431,22 +8660,25 @@ module ActiveRecord::TestFixtures def after_teardown; end def before_setup; end - def enlist_fixture_connections; end - def fixture_path; end - def run_in_transaction?; end - def setup_fixtures(config = T.unsafe(nil)); end - def teardown_fixtures; end + def fixture(fixture_set_name, *fixture_names); end private def access_fixture(fs_name, *fixture_names); end + def active_record_fixture(fixture_set_name, *fixture_names); end def instantiate_fixtures; end + def invalidate_already_loaded_fixtures; end def load_fixtures(config); end def load_instances?; end - def method_missing(name, *args, **kwargs, &block); end - def respond_to_missing?(name, include_private = T.unsafe(nil)); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end + def respond_to_missing?(method, include_private = T.unsafe(nil)); end + def run_in_transaction?; end + def setup_fixtures(config = T.unsafe(nil)); end def setup_shared_connection_pool; end + def setup_transactional_fixtures; end + def teardown_fixtures; end def teardown_shared_connection_pool; end + def teardown_transactional_fixtures; end module GeneratedClassMethods def fixture_class_names; end @@ -8503,8 +8735,6 @@ module ActiveRecord::TestFixtures end module ActiveRecord::TestFixtures::ClassMethods - def fixture_path; end - def fixture_path=(path); end def fixtures(*fixture_set_names); end def set_fixture_class(class_names = T.unsafe(nil)); end def setup_fixture_accessors(fixture_set_names = T.unsafe(nil)); end @@ -8598,6 +8828,11 @@ module ActiveRecord::TokenFor::ClassMethods def generates_token_for(purpose, expires_in: T.unsafe(nil), &block); end end +module ActiveRecord::TokenFor::RelationMethods + def find_by_token_for(purpose, token); end + def find_by_token_for!(purpose, token); end +end + class ActiveRecord::TokenFor::TokenDefinition < ::Struct def block; end def block=(_); end @@ -8635,6 +8870,18 @@ module ActiveRecord::TouchLater def touch_deferred_attributes; end end +class ActiveRecord::Transaction + def initialize(internal_transaction); end + + def after_commit(&block); end + def after_rollback(&block); end + def blank?; end + def closed?; end + def open?; end + def uuid; end +end + +ActiveRecord::Transaction::NULL_TRANSACTION = T.let(T.unsafe(nil), ActiveRecord::Transaction) class ActiveRecord::TransactionIsolationError < ::ActiveRecord::ActiveRecordError; end class ActiveRecord::TransactionRollbackError < ::ActiveRecord::StatementInvalid; end @@ -8680,6 +8927,8 @@ module ActiveRecord::Transactions::ClassMethods def after_save_commit(*args, &block); end def after_update_commit(*args, &block); end def before_commit(*args, &block); end + def current_transaction; end + def set_callback(name, *filter_list, &block); end def transaction(**options, &block); end private @@ -8690,9 +8939,6 @@ module ActiveRecord::Transactions::ClassMethods end module ActiveRecord::Translation - include ::ActiveModel::Naming - include ::ActiveModel::Translation - def i18n_scope; end def lookup_ancestors; end end @@ -8895,7 +9141,6 @@ class ActiveRecord::TypeCaster::Connection private - def connection(*_arg0, **_arg1, &_arg2); end def table_name; end end @@ -8924,6 +9169,7 @@ class ActiveRecord::UnknownPrimaryKey < ::ActiveRecord::ActiveRecordError def model; end end +class ActiveRecord::UnmodifiableRelation < ::ActiveRecord::ActiveRecordError; end module ActiveRecord::VERSION; end ActiveRecord::VERSION::MAJOR = T.let(T.unsafe(nil), Integer) ActiveRecord::VERSION::MINOR = T.let(T.unsafe(nil), Integer) @@ -8933,20 +9179,10 @@ ActiveRecord::VERSION::TINY = T.let(T.unsafe(nil), Integer) module ActiveRecord::Validations extend ::ActiveSupport::Concern - include GeneratedInstanceMethods - include ::ActiveSupport::Callbacks - include ::ActiveModel::Validations::HelperMethods - include ::ActiveModel::Validations - mixes_in_class_methods GeneratedClassMethods - mixes_in_class_methods ::ActiveModel::Validations::ClassMethods - mixes_in_class_methods ::ActiveModel::Callbacks - mixes_in_class_methods ::ActiveSupport::Callbacks::ClassMethods - mixes_in_class_methods ::ActiveSupport::DescendantsTracker - mixes_in_class_methods ::ActiveModel::Translation - mixes_in_class_methods ::ActiveModel::Validations::HelperMethods mixes_in_class_methods ::ActiveRecord::Validations::ClassMethods + def custom_validation_context?; end def save(**options); end def save!(**options); end def valid?(context = T.unsafe(nil)); end @@ -8957,22 +9193,6 @@ module ActiveRecord::Validations def default_validation_context; end def perform_validations(options = T.unsafe(nil)); end def raise_validation_error; end - - module GeneratedClassMethods - def __callbacks; end - def __callbacks=(value); end - def __callbacks?; end - def _validators; end - def _validators=(value); end - def _validators?; end - end - - module GeneratedInstanceMethods - def __callbacks; end - def __callbacks?; end - def _validators; end - def _validators?; end - end end class ActiveRecord::Validations::AbsenceValidator < ::ActiveModel::Validations::AbsenceValidator @@ -8984,7 +9204,8 @@ class ActiveRecord::Validations::AssociatedValidator < ::ActiveModel::EachValida private - def valid_object?(record); end + def record_validation_context_for_association(record); end + def valid_object?(record, context); end end module ActiveRecord::Validations::ClassMethods @@ -9037,7 +9258,7 @@ module Arel class << self def arel_node?(value); end def fetch_attribute(value, &block); end - def sql(sql_string, *positional_binds, **named_binds); end + def sql(sql_string, *positional_binds, retryable: T.unsafe(nil), **named_binds); end def star; end end end @@ -9075,6 +9296,8 @@ class Arel::Collectors::Bind def <<(str); end def add_bind(bind); end def add_binds(binds, proc_for_binds = T.unsafe(nil)); end + def retryable; end + def retryable=(_arg0); end def value; end end @@ -9086,6 +9309,8 @@ class Arel::Collectors::Composite def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end def preparable; end def preparable=(_arg0); end + def retryable; end + def retryable=(retryable); end def value; end private @@ -9108,6 +9333,8 @@ class Arel::Collectors::SQLString < ::Arel::Collectors::PlainString def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end def preparable; end def preparable=(_arg0); end + def retryable; end + def retryable=(_arg0); end end class Arel::Collectors::SubstituteBinds @@ -9118,6 +9345,8 @@ class Arel::Collectors::SubstituteBinds def add_binds(binds, proc_for_binds = T.unsafe(nil)); end def preparable; end def preparable=(_arg0); end + def retryable; end + def retryable=(_arg0); end def value; end private @@ -9207,17 +9436,7 @@ class Arel::Nodes::Addition < ::Arel::Nodes::InfixOperation def initialize(left, right); end end -class Arel::Nodes::And < ::Arel::Nodes::NodeExpression - def initialize(children); end - - def ==(other); end - def children; end - def eql?(other); end - def fetch_attribute(&block); end - def hash; end - def left; end - def right; end -end +class Arel::Nodes::And < ::Arel::Nodes::Nary; end class Arel::Nodes::As < ::Arel::Nodes::Binary def to_cte; end @@ -9664,6 +9883,18 @@ class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window def initialize_copy(other); end end +class Arel::Nodes::Nary < ::Arel::Nodes::NodeExpression + def initialize(children); end + + def ==(other); end + def children; end + def eql?(other); end + def fetch_attribute(&block); end + def hash; end + def left; end + def right; end +end + class Arel::Nodes::Node include ::Arel::FactoryMethods @@ -9711,10 +9942,7 @@ end class Arel::Nodes::Offset < ::Arel::Nodes::Unary; end class Arel::Nodes::On < ::Arel::Nodes::Unary; end class Arel::Nodes::OptimizerHints < ::Arel::Nodes::Unary; end - -class Arel::Nodes::Or < ::Arel::Nodes::Binary - def fetch_attribute(&block); end -end +class Arel::Nodes::Or < ::Arel::Nodes::Nary; end class Arel::Nodes::Ordering < ::Arel::Nodes::Unary def nulls_first; end @@ -9825,9 +10053,12 @@ class Arel::Nodes::SqlLiteral < ::String include ::Arel::AliasPredication include ::Arel::OrderPredications + def initialize(string, retryable: T.unsafe(nil)); end + def +(other); end def encode_with(coder); end def fetch_attribute; end + def retryable; end end class Arel::Nodes::StringJoin < ::Arel::Nodes::Join @@ -10167,6 +10398,7 @@ class Arel::Visitors::Dot < ::Arel::Visitors::Visitor def visit_Arel_Nodes_NamedFunction(o); end def visit_Arel_Nodes_NamedWindow(o); end def visit_Arel_Nodes_NotRegexp(o); end + def visit_Arel_Nodes_Or(o); end def visit_Arel_Nodes_Ordering(o); end def visit_Arel_Nodes_Regexp(o); end def visit_Arel_Nodes_SelectCore(o); end @@ -10228,6 +10460,7 @@ class Arel::Visitors::MySQL < ::Arel::Visitors::ToSql def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end def visit_Arel_Nodes_NotRegexp(o, collector); end def visit_Arel_Nodes_NullsFirst(o, collector); end + def visit_Arel_Nodes_NullsLast(o, collector); end def visit_Arel_Nodes_Regexp(o, collector); end def visit_Arel_Nodes_SelectCore(o, collector); end def visit_Arel_Nodes_SelectStatement(o, collector); end @@ -10239,7 +10472,6 @@ class Arel::Visitors::PostgreSQL < ::Arel::Visitors::ToSql def bind_block; end def grouping_array_or_grouping_element(o, collector); end - def grouping_parentheses(o, collector); end def visit_Arel_Nodes_Cube(o, collector); end def visit_Arel_Nodes_DistinctOn(o, collector); end def visit_Arel_Nodes_DoesNotMatch(o, collector); end @@ -10280,6 +10512,7 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor def collect_ctes(children, collector); end def collect_nodes_for(nodes, collector, spacer, connector = T.unsafe(nil)); end def collect_optimizer_hints(o, collector); end + def grouping_parentheses(o, collector, always_wrap_selects = T.unsafe(nil)); end def has_group_by_and_having?(o); end def has_join_sources?(o); end def has_limit_or_offset_or_orders?(o); end @@ -10293,6 +10526,7 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor def quote(value); end def quote_column_name(name); end def quote_table_name(name); end + def require_parentheses?(o); end def sanitize_as_sql_comment(value); end def unboundable?(value); end def unsupported(o, collector); end diff --git a/sorbet/rbi/gems/activesupport@7.1.3.4.rbi b/sorbet/rbi/gems/activesupport@7.2.1.2.rbi similarity index 95% rename from sorbet/rbi/gems/activesupport@7.1.3.4.rbi rename to sorbet/rbi/gems/activesupport@7.2.1.2.rbi index ffaae2ab3..09cd6cd14 100644 --- a/sorbet/rbi/gems/activesupport@7.1.3.4.rbi +++ b/sorbet/rbi/gems/activesupport@7.2.1.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `activesupport` gem. # Please instead update this file by running `bin/tapioca gem activesupport`. + module ActiveSupport extend ::ActiveSupport::LazyLoadHooks extend ::ActiveSupport::Autoload @@ -81,7 +82,7 @@ class ActiveSupport::ArrayInquirer < ::Array private - def method_missing(name, *args); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(name, include_private = T.unsafe(nil)); end end @@ -91,10 +92,6 @@ module ActiveSupport::Autoload def autoload_under(path); end def eager_autoload; end def eager_load!; end - - class << self - def extended(base); end - end end class ActiveSupport::BacktraceCleaner @@ -110,10 +107,12 @@ class ActiveSupport::BacktraceCleaner private + def add_core_silencer; end def add_gem_filter; end def add_gem_silencer; end def add_stdlib_silencer; end def filter_backtrace(backtrace); end + def initialize_copy(_other); end def noise(backtrace); end def silence(backtrace); end end @@ -172,7 +171,7 @@ class ActiveSupport::BroadcastLogger def dispatch(&block); end def initialize_copy(other); end - def method_missing(name, *args, **kwargs, &block); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(method, include_all); end class << self @@ -381,19 +380,6 @@ module ActiveSupport::Cache::SerializerWithFallback end end -module ActiveSupport::Cache::SerializerWithFallback::Marshal61WithFallback - include ::ActiveSupport::Cache::SerializerWithFallback - extend ::ActiveSupport::Cache::SerializerWithFallback - extend ::ActiveSupport::Cache::SerializerWithFallback::Marshal61WithFallback - - def _load(payload); end - def dump(entry); end - def dump_compressed(entry, threshold); end - def dumped?(dumped); end -end - -ActiveSupport::Cache::SerializerWithFallback::Marshal61WithFallback::MARSHAL_SIGNATURE = T.let(T.unsafe(nil), String) - module ActiveSupport::Cache::SerializerWithFallback::Marshal70WithFallback include ::ActiveSupport::Cache::SerializerWithFallback extend ::ActiveSupport::Cache::SerializerWithFallback @@ -497,7 +483,7 @@ class ActiveSupport::Cache::Store def normalize_version(key, options = T.unsafe(nil)); end def read_entry(key, **options); end def read_multi_entries(names, **options); end - def save_block_result_to_cache(name, options); end + def save_block_result_to_cache(name, key, options); end def serialize_entry(entry, **options); end def validate_options(options); end def write_entry(key, entry, **options); end @@ -672,6 +658,7 @@ class ActiveSupport::Callbacks::Callback def apply(callback_sequence); end def chain_config; end + def compiled; end def current_scopes; end def duplicates?(other); end def filter; end @@ -727,9 +714,9 @@ end class ActiveSupport::Callbacks::CallbackSequence def initialize(nested = T.unsafe(nil), call_template = T.unsafe(nil), user_conditions = T.unsafe(nil)); end - def after(&after); end + def after(after); end def around(call_template, user_conditions); end - def before(&before); end + def before(before); end def expand_call_template(arg, block); end def final?; end def invoke_after(arg); end @@ -763,27 +750,31 @@ end module ActiveSupport::Callbacks::Filters; end class ActiveSupport::Callbacks::Filters::After - class << self - def build(callback_sequence, user_callback, user_conditions, chain_config); end + def initialize(user_callback, user_conditions, chain_config); end - private + def apply(callback_sequence); end + def call(env); end + def halting; end + def user_callback; end + def user_conditions; end +end - def conditional(callback_sequence, user_callback, user_conditions); end - def halting(callback_sequence, user_callback); end - def halting_and_conditional(callback_sequence, user_callback, user_conditions); end - def simple(callback_sequence, user_callback); end - end +class ActiveSupport::Callbacks::Filters::Around + def initialize(user_callback, user_conditions); end + + def apply(callback_sequence); end end class ActiveSupport::Callbacks::Filters::Before - class << self - def build(callback_sequence, user_callback, user_conditions, chain_config, filter, name); end - - private + def initialize(user_callback, user_conditions, chain_config, filter, name); end - def halting(callback_sequence, user_callback, halted_lambda, filter, name); end - def halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name); end - end + def apply(callback_sequence); end + def call(env); end + def filter; end + def halted_lambda; end + def name; end + def user_callback; end + def user_conditions; end end class ActiveSupport::Callbacks::Filters::Environment < ::Struct @@ -806,7 +797,7 @@ end class ActiveSupport::CodeGenerator def initialize(owner, path, line); end - def define_cached_method(name, namespace:, as: T.unsafe(nil), &block); end + def define_cached_method(canonical_name, namespace:, as: T.unsafe(nil), &block); end def execute; end class << self @@ -818,7 +809,7 @@ class ActiveSupport::CodeGenerator::MethodSet def initialize(namespace); end def apply(owner, path, line); end - def define_cached_method(name, as: T.unsafe(nil)); end + def define_cached_method(canonical_name, as: T.unsafe(nil)); end end ActiveSupport::CodeGenerator::MethodSet::METHOD_CACHES = T.let(T.unsafe(nil), Hash) @@ -976,13 +967,14 @@ class ActiveSupport::CurrentAttributes def _run_reset_callbacks(&block); end def attributes; end def attributes=(_arg0); end + def defaults; end + def defaults?; end def reset; end - def set(set_attributes); end + def set(attributes, &block); end private - def assign_attributes(new_attributes); end - def compute_attributes(keys); end + def resolve_defaults; end class << self def __callbacks; end @@ -991,9 +983,12 @@ class ActiveSupport::CurrentAttributes def _reset_callbacks; end def _reset_callbacks=(value); end def after_reset(*methods, &block); end - def attribute(*names); end + def attribute(*names, default: T.unsafe(nil)); end def before_reset(*methods, &block); end def clear_all; end + def defaults; end + def defaults=(value); end + def defaults?; end def instance; end def reset(*_arg0, **_arg1, &_arg2); end def reset_all; end @@ -1005,7 +1000,8 @@ class ActiveSupport::CurrentAttributes def current_instances; end def current_instances_key; end def generated_attribute_methods; end - def method_missing(name, *args, **_arg2, &block); end + def method_added(name); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(name, _); end end end @@ -1018,6 +1014,22 @@ module ActiveSupport::DeepMergeable def deep_merge?(other); end end +module ActiveSupport::Delegation + class << self + def generate(owner, methods, location: T.unsafe(nil), to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), nilable: T.unsafe(nil), private: T.unsafe(nil), as: T.unsafe(nil), signature: T.unsafe(nil)); end + def generate_method_missing(owner, target, allow_nil: T.unsafe(nil)); end + end +end + +ActiveSupport::Delegation::RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set) +ActiveSupport::Delegation::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array) + +class ActiveSupport::DelegationError < ::NoMethodError + class << self + def nil_target(method_name, target); end + end +end + module ActiveSupport::Dependencies class << self def _autoloaded_tracked_classes; end @@ -1060,13 +1072,10 @@ module ActiveSupport::Dependencies::RequireDependency end class ActiveSupport::Deprecation - include ::ActiveSupport::Deprecation::InstanceDelegator include ::ActiveSupport::Deprecation::Behavior include ::ActiveSupport::Deprecation::Reporting include ::ActiveSupport::Deprecation::Disallowed include ::ActiveSupport::Deprecation::MethodWrapper - extend ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods - extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end @@ -1074,27 +1083,7 @@ class ActiveSupport::Deprecation def deprecation_horizon=(_arg0); end class << self - def allow(*_arg0, **_arg1, &_arg2); end - def begin_silence(*_arg0, **_arg1, &_arg2); end - def behavior(*_arg0, **_arg1, &_arg2); end - def behavior=(arg); end - def debug(*_arg0, **_arg1, &_arg2); end - def debug=(arg); end - def deprecate_methods(*_arg0, **_arg1, &_arg2); end - def deprecation_horizon(*_arg0, **_arg1, &_arg2); end - def deprecation_horizon=(arg); end - def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end - def disallowed_behavior(*_arg0, **_arg1, &_arg2); end - def disallowed_behavior=(arg); end - def disallowed_warnings(*_arg0, **_arg1, &_arg2); end - def disallowed_warnings=(arg); end - def end_silence(*_arg0, **_arg1, &_arg2); end - def gem_name(*_arg0, **_arg1, &_arg2); end - def gem_name=(arg); end - def silence(*_arg0, **_arg1, &_arg2); end - def silenced(*_arg0, **_arg1, &_arg2); end - def silenced=(arg); end - def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end + def _instance; end end end @@ -1121,7 +1110,7 @@ module ActiveSupport::Deprecation::DeprecatedConstantAccessor end class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module - def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end + def initialize(old_const, new_const, deprecator, message: T.unsafe(nil)); end def append_features(base); end def class; end @@ -1136,7 +1125,7 @@ class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module private def const_missing(name); end - def method_missing(called, *args, &block); end + def method_missing(*_arg0, **_arg1, &_arg2); end def target; end class << self @@ -1145,7 +1134,7 @@ class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module end class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupport::Deprecation::DeprecationProxy - def initialize(instance, method, var = T.unsafe(nil), deprecator = T.unsafe(nil)); end + def initialize(instance, method, var = T.unsafe(nil), deprecator:); end private @@ -1154,7 +1143,7 @@ class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupp end class ActiveSupport::Deprecation::DeprecatedObjectProxy < ::ActiveSupport::Deprecation::DeprecationProxy - def initialize(object, message, deprecator = T.unsafe(nil)); end + def initialize(object, message, deprecator); end private @@ -1170,7 +1159,7 @@ class ActiveSupport::Deprecation::DeprecationProxy def method_missing(called, *args, &block); end class << self - def new(*args, &block); end + def new(*args, **kwargs, &block); end end end @@ -1203,28 +1192,7 @@ module ActiveSupport::Deprecation::Disallowed def explicitly_allowed?(message); end end -module ActiveSupport::Deprecation::InstanceDelegator - mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods - mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators - - class << self - def included(base); end - end -end - -module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods - def _instance; end - def include(included_module); end - def instance; end - def method_added(method_name); end -end - -ActiveSupport::Deprecation::InstanceDelegator::ClassMethods::MUTEX = T.let(T.unsafe(nil), Thread::Mutex) - -module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators - def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end - def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end -end +ActiveSupport::Deprecation::MUTEX = T.let(T.unsafe(nil), Thread::Mutex) module ActiveSupport::Deprecation::MethodWrapper def deprecate_methods(target_module, *method_names); end @@ -1299,6 +1267,7 @@ class ActiveSupport::Duration def <=>(other); end def ==(other); end def _parts; end + def abs(&_arg0); end def after(time = T.unsafe(nil)); end def ago(time = T.unsafe(nil)); end def as_json(options = T.unsafe(nil)); end @@ -1321,17 +1290,21 @@ class ActiveSupport::Duration def is_a?(klass); end def iso8601(precision: T.unsafe(nil)); end def kind_of?(klass); end + def negative?(&_arg0); end def parts; end + def positive?(&_arg0); end def since(time = T.unsafe(nil)); end + def to_f(&_arg0); end def to_i; end def to_s; end def until(time = T.unsafe(nil)); end def value; end def variable?; end + def zero?(&_arg0); end private - def method_missing(method, *args, &block); end + def method_missing(*_arg0, **_arg1, &_arg2); end def raise_type_error(other); end def respond_to_missing?(method, _); end def sum(sign, time = T.unsafe(nil)); end @@ -1449,7 +1422,7 @@ class ActiveSupport::EncryptedConfiguration < ::ActiveSupport::EncryptedFile def config; end def inspect; end - def method_missing(method, *args, **_arg2, &block); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def read; end def validate!; end @@ -1536,6 +1509,8 @@ ActiveSupport::EnvironmentInquirer::LOCAL_ENVIRONMENTS = T.let(T.unsafe(nil), Ar class ActiveSupport::ErrorReporter def initialize(*subscribers, logger: T.unsafe(nil)); end + def debug_mode; end + def debug_mode=(_arg0); end def disable(subscriber); end def handle(*error_classes, severity: T.unsafe(nil), context: T.unsafe(nil), fallback: T.unsafe(nil), source: T.unsafe(nil)); end def logger; end @@ -1544,11 +1519,14 @@ class ActiveSupport::ErrorReporter def report(error, handled: T.unsafe(nil), severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil)); end def set_context(*_arg0, **_arg1, &_arg2); end def subscribe(subscriber); end + def unexpected(error, severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil)); end def unsubscribe(subscriber); end end +ActiveSupport::ErrorReporter::DEFAULT_RESCUE = T.let(T.unsafe(nil), Array) ActiveSupport::ErrorReporter::DEFAULT_SOURCE = T.let(T.unsafe(nil), String) ActiveSupport::ErrorReporter::SEVERITIES = T.let(T.unsafe(nil), Array) +class ActiveSupport::ErrorReporter::UnexpectedError < ::Exception; end module ActiveSupport::ExecutionContext class << self @@ -1658,25 +1636,12 @@ module ActiveSupport::ForkTracker class << self def after_fork(&block); end def after_fork_callback; end - def check!; end def hook!; end def unregister(callback); end end end module ActiveSupport::ForkTracker::CoreExt - def fork(*_arg0, **_arg1, &_arg2); end -end - -module ActiveSupport::ForkTracker::CoreExtPrivate - include ::ActiveSupport::ForkTracker::CoreExt - - private - - def fork(*_arg0, **_arg1, &_arg2); end -end - -module ActiveSupport::ForkTracker::ModernCoreExt def _fork; end end @@ -1734,6 +1699,7 @@ class ActiveSupport::HashWithIndifferentAccess < ::Hash def to_hash; end def to_options; end def to_options!; end + def to_proc; end def transform_keys(hash = T.unsafe(nil), &block); end def transform_keys!(hash = T.unsafe(nil), &block); end def transform_values(&block); end @@ -1761,13 +1727,13 @@ ActiveSupport::HashWithIndifferentAccess::NOT_GIVEN = T.let(T.unsafe(nil), Objec module ActiveSupport::HtmlSafeTranslation extend ::ActiveSupport::HtmlSafeTranslation + def html_safe_translation_key?(key); end def translate(key, **options); end private def html_escape_translation_options(options); end def html_safe_translation(translation); end - def html_safe_translation_key?(key); end def i18n_option?(name); end end @@ -1849,7 +1815,20 @@ end class ActiveSupport::InheritableOptions < ::ActiveSupport::OrderedOptions def initialize(parent = T.unsafe(nil)); end + def ==(other); end + def each(&block); end def inheritable_copy; end + def inspect; end + def key?(key); end + def overridden?(key); end + def pretty_print(pp); end + def to_a; end + def to_h; end + def to_s; end + + private + + def own_key?(_arg0); end end module ActiveSupport::IsolatedExecutionState @@ -1985,8 +1964,6 @@ end ActiveSupport::LogSubscriber::BLACK = T.let(T.unsafe(nil), String) ActiveSupport::LogSubscriber::BLUE = T.let(T.unsafe(nil), String) -ActiveSupport::LogSubscriber::BOLD = T.let(T.unsafe(nil), ActiveSupport::Deprecation::DeprecatedObjectProxy) -ActiveSupport::LogSubscriber::CLEAR = T.let(T.unsafe(nil), ActiveSupport::Deprecation::DeprecatedObjectProxy) ActiveSupport::LogSubscriber::CYAN = T.let(T.unsafe(nil), String) ActiveSupport::LogSubscriber::GREEN = T.let(T.unsafe(nil), String) ActiveSupport::LogSubscriber::LEVEL_CHECKS = T.let(T.unsafe(nil), Hash) @@ -2007,6 +1984,7 @@ class ActiveSupport::Logger < ::Logger class << self def logger_outputs_to?(logger, *sources); end + def normalize_sources(sources); end def silencer; end def silencer=(val); end end @@ -2026,16 +2004,10 @@ end module ActiveSupport::LoggerThreadSafeLevel extend ::ActiveSupport::Concern - def debug?; end - def error?; end - def fatal?; end - def info?; end def level; end def local_level; end def local_level=(level); end def log_at(level); end - def unknown?; end - def warn?; end private @@ -2329,7 +2301,7 @@ class ActiveSupport::Multibyte::Chars def grapheme_length; end def limit(limit); end def match?(*_arg0, **_arg1, &_arg2); end - def method_missing(method, *args, &block); end + def method_missing(method, *_arg1, **_arg2, &_arg3); end def reverse; end def reverse!(*args); end def slice!(*args); end @@ -2385,14 +2357,13 @@ class ActiveSupport::Notifications::Event def initialize(name, start, ending, transaction_id, payload); end def allocations; end - def children; end def cpu_time; end def duration; end def end; end def finish!; end + def gc_time; end def idle_time; end def name; end - def parent_of?(event); end def payload; end def payload=(_arg0); end def record; end @@ -2405,10 +2376,10 @@ class ActiveSupport::Notifications::Event def now; end def now_allocations; end def now_cpu; end + def now_gc; end end class ActiveSupport::Notifications::Fanout - include ::Mutex_m include ::ActiveSupport::Notifications::FanoutIteration def initialize; end @@ -2421,15 +2392,10 @@ class ActiveSupport::Notifications::Fanout def inspect; end def listeners_for(name); end def listening?(name); end - def lock; end - def locked?; end def publish(name, *args); end def publish_event(event); end def start(name, id, payload); end def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end - def synchronize(&block); end - def try_lock; end - def unlock; end def unsubscribe(subscriber_or_name); end def wait; end end @@ -2760,7 +2726,7 @@ class ActiveSupport::OptionMerger private def method_missing(method, *arguments, &block); end - def respond_to_missing?(*arguments); end + def respond_to_missing?(*_arg0, **_arg1, &_arg2); end end class ActiveSupport::OrderedHash < ::Hash @@ -2778,7 +2744,7 @@ class ActiveSupport::OrderedOptions < ::Hash def dig(key, *identifiers); end def extractable_options?; end def inspect; end - def method_missing(name, *args); end + def method_missing(method, *args); end protected @@ -2810,6 +2776,10 @@ ActiveSupport::ParameterFilter::FILTERED = T.let(T.unsafe(nil), String) class ActiveSupport::ProxyObject < ::BasicObject def raise(*args); end + + class << self + def inherited(_subclass); end + end end class ActiveSupport::Railtie < ::Rails::Railtie; end @@ -2898,9 +2868,6 @@ module ActiveSupport::Rescuable::ClassMethods def find_rescue_handler(exception); end end -module ActiveSupport::RubyFeatures; end -ActiveSupport::RubyFeatures::CLASS_SUBCLASSES = T.let(T.unsafe(nil), TrueClass) - class ActiveSupport::SafeBuffer < ::String def initialize(str = T.unsafe(nil)); end @@ -2918,7 +2885,6 @@ class ActiveSupport::SafeBuffer < ::String def chop(*args, &block); end def chop!(*args); end def chr; end - def clone_empty; end def concat(value); end def delete(*args, &block); end def delete!(*args); end @@ -3012,7 +2978,7 @@ end class ActiveSupport::StringInquirer < ::String private - def method_missing(method_name, *arguments); end + def method_missing(method_name, *_arg1, **_arg2, &_arg3); end def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end end @@ -3051,7 +3017,6 @@ class ActiveSupport::SyntaxErrorProxy private def parse_message_for_trace; end - def source_location_eval?; end end class ActiveSupport::SyntaxErrorProxy::BacktraceLocation < ::Struct @@ -3109,6 +3074,7 @@ end class ActiveSupport::TestCase < ::Minitest::Test include ::ActiveSupport::Testing::SetupAndTeardown + include ::ActiveSupport::Testing::TestsWithoutAssertions include ::ActiveSupport::Testing::TaggedLogging include ::ActiveSupport::Callbacks include ::ActiveSupport::Testing::Assertions @@ -3196,7 +3162,7 @@ module ActiveSupport::Testing::ConstantLookup::ClassMethods end module ActiveSupport::Testing::ConstantStubbing - def stub_const(mod, constant, new_value); end + def stub_const(mod, constant, new_value, exists: T.unsafe(nil)); end end module ActiveSupport::Testing::Declarative @@ -3205,8 +3171,8 @@ end module ActiveSupport::Testing::Deprecation def assert_deprecated(match = T.unsafe(nil), deprecator = T.unsafe(nil), &block); end - def assert_not_deprecated(deprecator = T.unsafe(nil), &block); end - def collect_deprecations(deprecator = T.unsafe(nil)); end + def assert_not_deprecated(deprecator, &block); end + def collect_deprecations(deprecator); end end module ActiveSupport::Testing::ErrorReporterAssertions @@ -3287,6 +3253,7 @@ module ActiveSupport::Testing::Isolation::Subprocess end ActiveSupport::Testing::Isolation::Subprocess::ORIG_ARGV = T.let(T.unsafe(nil), Array) +class ActiveSupport::Testing::Isolation::SubprocessCrashed < ::StandardError; end class ActiveSupport::Testing::Parallelization def initialize(worker_count); end @@ -3413,6 +3380,10 @@ module ActiveSupport::Testing::TaggedLogging def tagged_logger; end end +module ActiveSupport::Testing::TestsWithoutAssertions + def after_teardown; end +end + module ActiveSupport::Testing::TimeHelpers def after_teardown; end def freeze_time(with_usec: T.unsafe(nil), &block); end @@ -3484,6 +3455,7 @@ class ActiveSupport::TimeWithZone def nsec; end def past?; end def period; end + def present?; end def prev_day?; end def respond_to?(sym, include_priv = T.unsafe(nil)); end def rfc2822; end @@ -3648,6 +3620,7 @@ module ActiveSupport::XmlMini def _dasherize(key); end def _parse_binary(bin, entity); end def _parse_file(file, entity); end + def _parse_hex_binary(bin); end def cast_backend_name_to_module(name); end def current_thread_backend; end def current_thread_backend=(name); end @@ -3701,13 +3674,13 @@ class Array def in_groups_of(number, fill_with = T.unsafe(nil), &block); end def including(*elements); end def inquiry; end + def present?; end def second; end def second_to_last; end def split(value = T.unsafe(nil), &block); end def third; end def third_to_last; end def to(position); end - def to_default_s(*args, **_arg1, &block); end def to_formatted_s(format = T.unsafe(nil)); end def to_fs(format = T.unsafe(nil)); end def to_param; end @@ -3772,9 +3745,9 @@ class Date def minus_with_duration(other); end def noon; end def plus_with_duration(other); end + def present?; end def readable_inspect; end def since(seconds); end - def to_default_s(*args, **_arg1, &block); end def to_formatted_s(format = T.unsafe(nil)); end def to_fs(format = T.unsafe(nil)); end def to_time(form = T.unsafe(nil)); end @@ -3927,12 +3900,12 @@ class DateTime < ::Date def midnight; end def noon; end def nsec; end + def present?; end def readable_inspect; end def seconds_since_midnight; end def seconds_until_end_of_day; end def since(seconds); end def subsec; end - def to_default_s(*args, **_arg1, &block); end def to_f; end def to_formatted_s(format = T.unsafe(nil)); end def to_fs(format = T.unsafe(nil)); end @@ -3960,6 +3933,7 @@ end module Digest::UUID class << self + def nil_uuid; end def uuid_from_hash(hash_class, namespace, name); end def uuid_v3(uuid_namespace, name); end def uuid_v4; end @@ -4037,6 +4011,7 @@ end class FalseClass def as_json(options = T.unsafe(nil)); end def blank?; end + def present?; end def to_param; end end @@ -4073,6 +4048,7 @@ class Hash def extract!(*keys); end def extractable_options?; end def nested_under_indifferent_access; end + def present?; end def reverse_merge(other_hash); end def reverse_merge!(other_hash); end def reverse_update(other_hash); end @@ -4307,7 +4283,7 @@ class Module def deep_dup; end def delegate(*methods, to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), private: T.unsafe(nil)); end def delegate_missing_to(target, allow_nil: T.unsafe(nil)); end - def deprecate(*method_names, deprecator: T.unsafe(nil), **options); end + def deprecate(*method_names, deprecator:, **options); end def mattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end def mattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end def mattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end @@ -4330,11 +4306,10 @@ class Module private def attr_internal_define(attr_name, type); end - def attr_internal_ivar_name(attr); end class << self def attr_internal_naming_format; end - def attr_internal_naming_format=(_arg0); end + def attr_internal_naming_format=(format); end end end @@ -4343,10 +4318,7 @@ module Module::Concerning def concerning(topic, prepend: T.unsafe(nil), &block); end end -Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array) -Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set) -class Module::DelegationError < ::NoMethodError; end -Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array) +Module::DelegationError = ActiveSupport::DelegationError class NameError < ::StandardError include ::ErrorHighlight::CoreExt @@ -4365,6 +4337,7 @@ NameError::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod) class NilClass def as_json(options = T.unsafe(nil)); end def blank?; end + def present?; end def to_param; end def try(*_arg0); end def try!(*_arg0); end @@ -4397,6 +4370,7 @@ class Numeric def minutes; end def petabyte; end def petabytes; end + def present?; end def second; end def seconds; end def terabyte; end @@ -4416,11 +4390,11 @@ Numeric::TERABYTE = T.let(T.unsafe(nil), Integer) Numeric::ZETTABYTE = T.let(T.unsafe(nil), Integer) class Object < ::BasicObject - include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::ActiveSupport::Dependencies::RequireDependency include ::Kernel include ::PP::ObjectMixin include ::ActiveSupport::Tryable + include ::ActiveSupport::ToJsonWithActiveSupportEncoder def acts_like?(duck); end def as_json(options = T.unsafe(nil)); end @@ -4445,7 +4419,7 @@ class Pathname end module Process - extend ::ActiveSupport::ForkTracker::ModernCoreExt + extend ::ActiveSupport::ForkTracker::CoreExt class << self def _fork; end @@ -4514,6 +4488,7 @@ class String def mb_chars; end def parameterize(separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end def pluralize(count = T.unsafe(nil), locale = T.unsafe(nil)); end + def present?; end def remove(*patterns); end def remove!(*patterns); end def safe_constantize; end @@ -4548,6 +4523,7 @@ class Symbol include ::Comparable def as_json(options = T.unsafe(nil)); end + def present?; end end class Thread @@ -4606,6 +4582,8 @@ class Time def next_year(years = T.unsafe(nil)); end def noon; end def plus_with_duration(other); end + def present?; end + def preserve_timezone; end def prev_day(days = T.unsafe(nil)); end def prev_month(months = T.unsafe(nil)); end def prev_year(years = T.unsafe(nil)); end @@ -4613,15 +4591,18 @@ class Time def seconds_since_midnight; end def seconds_until_end_of_day; end def since(seconds); end - def to_default_s(*args, **_arg1, &block); end def to_formatted_s(format = T.unsafe(nil)); end def to_fs(format = T.unsafe(nil)); end def to_time; end + private + + def active_support_local_zone; end + class << self def ===(other); end - def at(*args, **kwargs); end - def at_with_coercion(*args, **kwargs); end + def at(time_or_number, *args, **_arg2); end + def at_with_coercion(time_or_number, *args, **_arg2); end def current; end def days_in_month(month, year = T.unsafe(nil)); end def days_in_year(year = T.unsafe(nil)); end @@ -4642,6 +4623,7 @@ Time::DATE_FORMATS = T.let(T.unsafe(nil), Hash) class TrueClass def as_json(options = T.unsafe(nil)); end def blank?; end + def present?; end def to_param; end end diff --git a/sorbet/rbi/gems/concurrent-ruby@1.3.3.rbi b/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi similarity index 99% rename from sorbet/rbi/gems/concurrent-ruby@1.3.3.rbi rename to sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi index f1438c680..ae2e000d0 100644 --- a/sorbet/rbi/gems/concurrent-ruby@1.3.3.rbi +++ b/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `concurrent-ruby` gem. # Please instead update this file by running `bin/tapioca gem concurrent-ruby`. + module Concurrent extend ::Concurrent::Utility::EngineDetector extend ::Concurrent::Utility::NativeExtensionLoader @@ -29,6 +30,7 @@ module Concurrent def available_processor_count; end def call_dataflow(method, executor, *inputs, &block); end def cpu_quota; end + def cpu_shares; end def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end def dataflow(*inputs, &block); end @@ -2344,12 +2346,14 @@ class Concurrent::Utility::ProcessorCounter def available_processor_count; end def cpu_quota; end + def cpu_shares; end def physical_processor_count; end def processor_count; end private def compute_cpu_quota; end + def compute_cpu_shares; end def compute_physical_processor_count; end def compute_processor_count; end def run(command); end diff --git a/sorbet/rbi/gems/i18n@1.14.5.rbi b/sorbet/rbi/gems/i18n@1.14.6.rbi similarity index 99% rename from sorbet/rbi/gems/i18n@1.14.5.rbi rename to sorbet/rbi/gems/i18n@1.14.6.rbi index 6b48b83b6..6037095ff 100644 --- a/sorbet/rbi/gems/i18n@1.14.5.rbi +++ b/sorbet/rbi/gems/i18n@1.14.6.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `i18n` gem. # Please instead update this file by running `bin/tapioca gem i18n`. + module GetText; end class GetText::PoParser < ::Racc::Parser diff --git a/sorbet/rbi/gems/logger@1.6.1.rbi b/sorbet/rbi/gems/logger@1.6.1.rbi new file mode 100644 index 000000000..8a331890a --- /dev/null +++ b/sorbet/rbi/gems/logger@1.6.1.rbi @@ -0,0 +1,114 @@ +# typed: false + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `logger` gem. +# Please instead update this file by running `bin/tapioca gem logger`. + + +class Logger + include ::Logger::Severity + + def initialize(logdev, shift_age = T.unsafe(nil), shift_size = T.unsafe(nil), level: T.unsafe(nil), progname: T.unsafe(nil), formatter: T.unsafe(nil), datetime_format: T.unsafe(nil), binmode: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end + + def <<(msg); end + def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end + def close; end + def datetime_format; end + def datetime_format=(datetime_format); end + def debug(progname = T.unsafe(nil), &block); end + def debug!; end + def debug?; end + def error(progname = T.unsafe(nil), &block); end + def error!; end + def error?; end + def fatal(progname = T.unsafe(nil), &block); end + def fatal!; end + def fatal?; end + def formatter; end + def formatter=(_arg0); end + def info(progname = T.unsafe(nil), &block); end + def info!; end + def info?; end + def level; end + def level=(severity); end + def log(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end + def progname; end + def progname=(_arg0); end + def reopen(logdev = T.unsafe(nil)); end + def sev_threshold; end + def sev_threshold=(severity); end + def unknown(progname = T.unsafe(nil), &block); end + def warn(progname = T.unsafe(nil), &block); end + def warn!; end + def warn?; end + def with_level(severity); end + + private + + def format_message(severity, datetime, progname, msg); end + def format_severity(severity); end + def level_override; end +end + +class Logger::Formatter + def initialize; end + + def call(severity, time, progname, msg); end + def datetime_format; end + def datetime_format=(_arg0); end + + private + + def format_datetime(time); end + def msg2str(msg); end +end + +Logger::Formatter::DatetimeFormat = T.let(T.unsafe(nil), String) +Logger::Formatter::Format = T.let(T.unsafe(nil), String) + +class Logger::LogDevice + include ::Logger::Period + include ::MonitorMixin + + def initialize(log = T.unsafe(nil), shift_age: T.unsafe(nil), shift_size: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), binmode: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end + + def close; end + def dev; end + def filename; end + def reopen(log = T.unsafe(nil)); end + def write(message); end + + private + + def add_log_header(file); end + def check_shift_log; end + def create_logfile(filename); end + def lock_shift_log; end + def open_logfile(filename); end + def set_dev(log); end + def shift_log_age; end + def shift_log_period(period_end); end +end + +module Logger::Period + private + + def next_rotate_time(now, shift_age); end + def previous_period_end(now, shift_age); end + + class << self + def next_rotate_time(now, shift_age); end + def previous_period_end(now, shift_age); end + end +end + +Logger::Period::SiD = T.let(T.unsafe(nil), Integer) +Logger::SEV_LABEL = T.let(T.unsafe(nil), Array) + +module Logger::Severity + class << self + def coerce(severity); end + end +end + +Logger::Severity::LEVELS = T.let(T.unsafe(nil), Hash) diff --git a/sorbet/rbi/gems/minitest@5.24.1.rbi b/sorbet/rbi/gems/minitest@5.25.1.rbi similarity index 99% rename from sorbet/rbi/gems/minitest@5.24.1.rbi rename to sorbet/rbi/gems/minitest@5.25.1.rbi index bf4608132..60ce58f67 100644 --- a/sorbet/rbi/gems/minitest@5.24.1.rbi +++ b/sorbet/rbi/gems/minitest@5.25.1.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `minitest` gem. # Please instead update this file by running `bin/tapioca gem minitest`. + module Minitest class << self def __run(reporter, options); end @@ -313,7 +314,6 @@ class Minitest::Test < ::Minitest::Runnable def new_exception(klass, msg, bt, kill = T.unsafe(nil)); end def run; end def sanitize_exception(e); end - def with_info_handler(&block); end class << self def i_suck_and_my_tests_are_order_dependent!; end diff --git a/sorbet/rbi/gems/mutex_m@0.2.0.rbi b/sorbet/rbi/gems/mutex_m@0.2.0.rbi deleted file mode 100644 index e09a6072e..000000000 --- a/sorbet/rbi/gems/mutex_m@0.2.0.rbi +++ /dev/null @@ -1,29 +0,0 @@ -# typed: false - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `mutex_m` gem. -# Please instead update this file by running `bin/tapioca gem mutex_m`. - -module Mutex_m - def initialize(*args, **_arg1); end - - def mu_extended; end - def mu_lock; end - def mu_locked?; end - def mu_synchronize(&block); end - def mu_try_lock; end - def mu_unlock; end - def sleep(timeout = T.unsafe(nil)); end - - private - - def mu_initialize; end - - class << self - def append_features(cl); end - def define_aliases(cl); end - def extend_object(obj); end - end -end - -Mutex_m::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/rack@2.2.9.rbi b/sorbet/rbi/gems/rack@2.2.10.rbi similarity index 99% rename from sorbet/rbi/gems/rack@2.2.9.rbi rename to sorbet/rbi/gems/rack@2.2.10.rbi index 25b3f080b..0bcad4b38 100644 --- a/sorbet/rbi/gems/rack@2.2.9.rbi +++ b/sorbet/rbi/gems/rack@2.2.10.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `rack` gem. # Please instead update this file by running `bin/tapioca gem rack`. + module Rack class << self def release; end @@ -936,11 +937,7 @@ class Rack::Request def delete_param(k); end def params; end - def query; end def update_param(k, v); end - def version_supplied; end - def version_supplied=(_arg0); end - def xhr?; end class << self def ip_filter; end @@ -1617,6 +1614,7 @@ Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params Rack::Utils::NULL_BYTE = T.let(T.unsafe(nil), String) Rack::Utils::PATH_SEPS = T.let(T.unsafe(nil), Regexp) Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError +Rack::Utils::RFC2396_PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser) Rack::Utils::RFC2822_DAY_NAME = T.let(T.unsafe(nil), Array) Rack::Utils::RFC2822_MONTH_NAME = T.let(T.unsafe(nil), Array) Rack::Utils::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash) diff --git a/sorbet/rbi/gems/rackup@1.0.0.rbi b/sorbet/rbi/gems/rackup@1.0.1.rbi similarity index 63% rename from sorbet/rbi/gems/rackup@1.0.0.rbi rename to sorbet/rbi/gems/rackup@1.0.1.rbi index b7e4955f1..afb4e1370 100644 --- a/sorbet/rbi/gems/rackup@1.0.0.rbi +++ b/sorbet/rbi/gems/rackup@1.0.1.rbi @@ -4,5 +4,6 @@ # This is an autogenerated file for types exported from the `rackup` gem. # Please instead update this file by running `bin/tapioca gem rackup`. -# THIS IS AN EMPTY RBI FILE. -# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem + +module Rackup; end +Rackup::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/railties@7.1.3.4.rbi b/sorbet/rbi/gems/railties@7.2.1.2.rbi similarity index 93% rename from sorbet/rbi/gems/railties@7.1.3.4.rbi rename to sorbet/rbi/gems/railties@7.2.1.2.rbi index f9f1614b3..1d9dadb88 100644 --- a/sorbet/rbi/gems/railties@7.1.3.4.rbi +++ b/sorbet/rbi/gems/railties@7.2.1.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `railties` gem. # Please instead update this file by running `bin/tapioca gem railties`. + module Rails extend ::ActiveSupport::Autoload extend ::ActiveSupport::Benchmarkable @@ -66,6 +67,7 @@ class Rails::Application < ::Rails::Engine def message_verifier(verifier_name); end def message_verifiers; end def migration_railties; end + def name; end def rake_tasks(&block); end def reload_routes!; end def reloader; end @@ -78,8 +80,6 @@ class Rails::Application < ::Rails::Engine def sandbox=(_arg0); end def sandbox?; end def secret_key_base; end - def secrets; end - def secrets=(_arg0); end def server(&blk); end def to_app; end def watchable_args; end @@ -95,7 +95,6 @@ class Rails::Application < ::Rails::Engine def run_runner_blocks(app); end def run_server_blocks(app); end def run_tasks_blocks(app); end - def validate_secret_key_base(secret_key_base); end private @@ -103,8 +102,6 @@ class Rails::Application < ::Rails::Engine def build_request(env); end def coerce_same_site_protection(protection); end def filter_parameters; end - def generate_local_secret; end - def secrets_secret_key_base; end class << self def add_lib_to_load_path!(root); end @@ -171,8 +168,6 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration def dom_testing_default_html_version=(_arg0); end def eager_load; end def eager_load=(_arg0); end - def enable_dependency_loading; end - def enable_dependency_loading=(value); end def enable_reloading; end def enable_reloading=(value); end def encoding; end @@ -218,7 +213,7 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration def rake_eager_load; end def rake_eager_load=(_arg0); end def read_encrypted_secrets; end - def read_encrypted_secrets=(_arg0); end + def read_encrypted_secrets=(value); end def relative_url_root; end def relative_url_root=(_arg0); end def reload_classes_only_on_change; end @@ -229,7 +224,7 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration def sandbox_by_default; end def sandbox_by_default=(_arg0); end def secret_key_base; end - def secret_key_base=(_arg0); end + def secret_key_base=(new_secret_key_base); end def server_timing; end def server_timing=(_arg0); end def session_options; end @@ -242,10 +237,14 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration def time_zone=(_arg0); end def x; end def x=(_arg0); end + def yjit; end + def yjit=(_arg0); end private def credentials_defaults; end + def generate_local_secret; end + def generate_local_secret?; end end class Rails::Application::Configuration::Custom @@ -255,11 +254,9 @@ class Rails::Application::Configuration::Custom private - def respond_to_missing?(symbol, *_arg1); end + def respond_to_missing?(symbol, _); end end -Rails::Application::Configuration::ENABLE_DEPENDENCY_LOADING_WARNING = T.let(T.unsafe(nil), String) - class Rails::Application::DefaultMiddlewareStack def initialize(app, config, paths); end @@ -369,6 +366,10 @@ end class Rails::BacktraceCleaner < ::ActiveSupport::BacktraceCleaner def initialize; end + + def clean(backtrace, kind = T.unsafe(nil)); end + def clean_frame(frame, kind = T.unsafe(nil)); end + def filter(backtrace, kind = T.unsafe(nil)); end end Rails::BacktraceCleaner::APP_DIRS_PATTERN = T.let(T.unsafe(nil), Regexp) @@ -384,6 +385,7 @@ class Rails::Configuration::Generators def aliases=(_arg0); end def api_only; end def api_only=(_arg0); end + def apply_rubocop_autocorrect_after_generate!; end def colorize_logging; end def colorize_logging=(_arg0); end def fallbacks; end @@ -442,7 +444,7 @@ class Rails::Engine < ::Rails::Railtie def env_config; end def helpers; end def helpers_paths; end - def isolated?(&block); end + def isolated?(&_arg0); end def load_console(app = T.unsafe(nil)); end def load_generators(app = T.unsafe(nil)); end def load_runner(app = T.unsafe(nil)); end @@ -468,7 +470,7 @@ class Rails::Engine < ::Rails::Railtie def build_middleware; end def build_request(env); end def default_middleware_stack; end - def fixtures_in_root_and_not_in_vendor?(fixtures); end + def fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures); end def has_migrations?; end def load_config_initializer(initializer); end @@ -603,6 +605,7 @@ class Rails::Generators::Base < ::Thor::Group def class_collisions(*class_names); end def extract_last_module(nesting); end + def gem_ruby_version; end def indent(content, multiplier = T.unsafe(nil)); end def module_namespacing(&block); end def namespace; end @@ -666,11 +669,16 @@ class Rails::Generators::GeneratedAttribute def required?; end def rich_text?; end def singular_name; end + def to_s; end def token?; end def type; end def type=(_arg0); end def virtual?; end + private + + def print_attribute_options; end + class << self def dangerous_name?(name); end def parse(column_definition); end @@ -858,6 +866,8 @@ class Rails::MailersController < ::Rails::ApplicationController private def _layout(lookup_context, formats); end + def attachment_url(attachment); end + def attachments_for(email); end def find_part(format); end def find_preferred_part(*formats); end def find_preview; end @@ -876,8 +886,9 @@ end module Rails::MailersController::HelperMethods include ::ActionController::Base::HelperMethods - def locale_query(*args, **_arg1, &block); end - def part_query(*args, **_arg1, &block); end + def attachment_url(*_arg0, **_arg1, &_arg2); end + def locale_query(*_arg0, **_arg1, &_arg2); end + def part_query(*_arg0, **_arg1, &_arg2); end end module Rails::Paths; end @@ -945,6 +956,20 @@ class Rails::Paths::Root def filter_by(&block); end end +class Rails::PwaController < ::Rails::ApplicationController + def manifest; end + def service_worker; end + + private + + def _layout(lookup_context, formats); end + + class << self + def __callbacks; end + def middleware_stack; end + end +end + module Rails::Rack; end class Rails::Rack::Logger < ::ActiveSupport::LogSubscriber @@ -956,6 +981,7 @@ class Rails::Rack::Logger < ::ActiveSupport::LogSubscriber def call_app(request, env); end def compute_tags(request); end + def finish_request_instrumentation(handle, logger_tag_pop_count); end def logger; end def started_request_message(request); end end @@ -1008,7 +1034,7 @@ class Rails::Railtie private def generate_railtie_name(string); end - def method_missing(name, *args, **_arg2, &block); end + def method_missing(name, *_arg1, **_arg2, &_arg3); end def new(*_arg0); end def register_block_for(type, &blk); end def respond_to_missing?(name, _); end @@ -1044,33 +1070,6 @@ class Rails::Railtie::Configuration end end -class Rails::Secrets - class << self - def decrypt(data); end - def encrypt(data); end - def key; end - def parse(paths, env:); end - def read; end - def read_for_editing(&block); end - def root=(_arg0); end - def write(contents); end - - private - - def encryptor; end - def handle_missing_key; end - def key_path; end - def path; end - def preprocess(path); end - def read_key_file; end - def writing(contents); end - end -end - -class Rails::Secrets::MissingKeyError < ::RuntimeError - def initialize; end -end - class Rails::SourceAnnotationExtractor def initialize(tag); end @@ -1137,6 +1136,10 @@ class Rails::TestUnit::Filter def definition_for(method); end end +class Rails::TestUnit::InvalidTestError < ::StandardError + def initialize(path, suggestion); end +end + class Rails::TestUnit::Runner def filters; end @@ -1164,30 +1167,9 @@ end Rails::TestUnit::Runner::PATH_ARGUMENT_PATTERN = T.let(T.unsafe(nil), Regexp) Rails::TestUnit::Runner::TEST_FOLDERS = T.let(T.unsafe(nil), Array) -class Rails::TestUnit::TestParser < ::Ripper - def initialize(*_arg0); end - - def first_arg(arg, *_arg1); end - def just_lineno(*_arg0); end - def on_arg_paren(arg, *_arg1); end - def on_args_add(parts, part); end - def on_args_add_block(args, *rest); end - def on_args_new; end - def on_bodystmt(arg, *_arg1); end - def on_brace_block(*_arg0); end - def on_command(arg, *_arg1); end - def on_command_call(*_arg0, begin_lineno, _args); end - def on_def(begin_line, *_arg1); end - def on_do_block(*_arg0); end - def on_ident(*_arg0); end - def on_method_add_arg(arg, *_arg1); end - def on_method_add_block(begin_line, end_line); end - def on_stmts_add(arg, *_arg1); end - def on_stmts_new(*_arg0); end - def parse; end - +module Rails::TestUnit::TestParser class << self - def definition_for(method_obj); end + def definition_for(method); end end end diff --git a/sorbet/rbi/gems/rdoc@6.6.3.1.rbi b/sorbet/rbi/gems/rdoc@6.7.0.rbi similarity index 99% rename from sorbet/rbi/gems/rdoc@6.6.3.1.rbi rename to sorbet/rbi/gems/rdoc@6.7.0.rbi index 1052b4830..57a6cd73e 100644 --- a/sorbet/rbi/gems/rdoc@6.6.3.1.rbi +++ b/sorbet/rbi/gems/rdoc@6.7.0.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `rdoc` gem. # Please instead update this file by running `bin/tapioca gem rdoc`. + module ERB::Escape private @@ -297,7 +298,7 @@ class RDoc::Context < ::RDoc::CodeObject def current_section=(_arg0); end def defined_in?(file); end def display(method_attr); end - def each_ancestor; end + def each_ancestor(&_); end def each_attribute; end def each_classmodule(&block); end def each_constant; end @@ -1357,6 +1358,7 @@ class RDoc::Markup::ToBs < ::RDoc::Markup::ToRdoc def initialize(markup = T.unsafe(nil)); end def accept_heading(heading); end + def accept_list_item_start(list_item); end def annotate(tag); end def convert_regexp_handling(target); end def convert_string(string); end diff --git a/sorbet/rbi/gems/reline@0.5.0.rbi b/sorbet/rbi/gems/reline@0.5.10.rbi similarity index 99% rename from sorbet/rbi/gems/reline@0.5.0.rbi rename to sorbet/rbi/gems/reline@0.5.10.rbi index b8c01d40e..13fa313b6 100644 --- a/sorbet/rbi/gems/reline@0.5.0.rbi +++ b/sorbet/rbi/gems/reline@0.5.10.rbi @@ -4,5 +4,6 @@ # This is an autogenerated file for types exported from the `reline` gem. # Please instead update this file by running `bin/tapioca gem reline`. + # THIS IS AN EMPTY RBI FILE. # see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem diff --git a/sorbet/rbi/gems/securerandom@0.3.1.rbi b/sorbet/rbi/gems/securerandom@0.3.1.rbi new file mode 100644 index 000000000..2a4461059 --- /dev/null +++ b/sorbet/rbi/gems/securerandom@0.3.1.rbi @@ -0,0 +1,49 @@ +# typed: false + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `securerandom` gem. +# Please instead update this file by running `bin/tapioca gem securerandom`. + + +class Random::Base + include ::Random::Formatter + extend ::Random::Formatter + + def initialize(*_arg0); end + + def bytes(_arg0); end + def rand(*_arg0); end + def seed; end +end + +module Random::Formatter + def alphanumeric(n = T.unsafe(nil), chars: T.unsafe(nil)); end + def base64(n = T.unsafe(nil)); end + def hex(n = T.unsafe(nil)); end + def random_bytes(n = T.unsafe(nil)); end + def urlsafe_base64(n = T.unsafe(nil), padding = T.unsafe(nil)); end + def uuid; end + def uuid_v4; end + def uuid_v7(extra_timestamp_bits: T.unsafe(nil)); end + + private + + def choose(source, n); end + def gen_random(n); end +end + +module SecureRandom + extend ::Random::Formatter + + class << self + def bytes(n); end + def gen_random(n); end + + private + + def gen_random_openssl(n); end + def gen_random_urandom(n); end + end +end + +SecureRandom::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/stringio@3.1.0.rbi b/sorbet/rbi/gems/stringio@3.1.1.rbi similarity index 99% rename from sorbet/rbi/gems/stringio@3.1.0.rbi rename to sorbet/rbi/gems/stringio@3.1.1.rbi index 01a26ea58..0b17e9140 100644 --- a/sorbet/rbi/gems/stringio@3.1.0.rbi +++ b/sorbet/rbi/gems/stringio@3.1.1.rbi @@ -4,5 +4,6 @@ # This is an autogenerated file for types exported from the `stringio` gem. # Please instead update this file by running `bin/tapioca gem stringio`. + # THIS IS AN EMPTY RBI FILE. # see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem diff --git a/sorbet/rbi/gems/thor@1.3.1.rbi b/sorbet/rbi/gems/thor@1.3.2.rbi similarity index 99% rename from sorbet/rbi/gems/thor@1.3.1.rbi rename to sorbet/rbi/gems/thor@1.3.2.rbi index 40e048121..2c100c807 100644 --- a/sorbet/rbi/gems/thor@1.3.1.rbi +++ b/sorbet/rbi/gems/thor@1.3.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `thor` gem. # Please instead update this file by running `bin/tapioca gem thor`. + module LCSDiff protected @@ -28,6 +29,7 @@ class Thor def at_least_one(*args, &block); end def check_unknown_options!(options = T.unsafe(nil)); end def check_unknown_options?(config); end + def command_exists?(command_name); end def command_help(shell, command_name); end def default_command(meth = T.unsafe(nil)); end def default_task(meth = T.unsafe(nil)); end @@ -469,6 +471,7 @@ class Thor::Group class << self def class_options_help(shell, groups = T.unsafe(nil)); end + def command_exists?(command_name); end def desc(description = T.unsafe(nil)); end def get_options_from_invocations(group_options, base_options); end def handle_argument_error(command, error, _args, arity); end diff --git a/sorbet/rbi/gems/useragent@0.16.10.rbi b/sorbet/rbi/gems/useragent@0.16.10.rbi new file mode 100644 index 000000000..bf7b53fb2 --- /dev/null +++ b/sorbet/rbi/gems/useragent@0.16.10.rbi @@ -0,0 +1,9 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `useragent` gem. +# Please instead update this file by running `bin/tapioca gem useragent`. + + +# THIS IS AN EMPTY RBI FILE. +# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem diff --git a/sorbet/rbi/gems/webrick@1.8.1.rbi b/sorbet/rbi/gems/webrick@1.8.2.rbi similarity index 97% rename from sorbet/rbi/gems/webrick@1.8.1.rbi rename to sorbet/rbi/gems/webrick@1.8.2.rbi index 57cd05b22..d848dcae1 100644 --- a/sorbet/rbi/gems/webrick@1.8.1.rbi +++ b/sorbet/rbi/gems/webrick@1.8.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `webrick` gem. # Please instead update this file by running `bin/tapioca gem webrick`. + module WEBrick::AccessLog private @@ -272,6 +273,7 @@ class WEBrick::HTTPRequest def setup_forwarded_info; end end +WEBrick::HTTPRequest::HOST_PATTERN = T.let(T.unsafe(nil), Regexp) WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer) class WEBrick::HTTPResponse @@ -541,6 +543,10 @@ module WEBrick::HTTPUtils end end +class WEBrick::HTTPUtils::CookieHeader < ::Array + def join(separator = T.unsafe(nil)); end +end + class WEBrick::HTTPUtils::FormData < ::String def initialize(*args); end @@ -562,6 +568,12 @@ class WEBrick::HTTPUtils::FormData < ::String def next_data; end end +WEBrick::HTTPUtils::HEADER_CLASSES = T.let(T.unsafe(nil), Hash) + +class WEBrick::HTTPUtils::SplitHeader < ::Array + def join(separator = T.unsafe(nil)); end +end + module WEBrick::Utils private diff --git a/sorbet/rbi/gems/zeitwerk@2.6.13.rbi b/sorbet/rbi/gems/zeitwerk@2.7.1.rbi similarity index 84% rename from sorbet/rbi/gems/zeitwerk@2.6.13.rbi rename to sorbet/rbi/gems/zeitwerk@2.7.1.rbi index c8d8a2d69..2f05fc55f 100644 --- a/sorbet/rbi/gems/zeitwerk@2.6.13.rbi +++ b/sorbet/rbi/gems/zeitwerk@2.7.1.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `zeitwerk` gem. # Please instead update this file by running `bin/tapioca gem zeitwerk`. + module Kernel private @@ -14,31 +15,55 @@ module Kernel end end +class Module + include ::Mize::CacheMethods + include ::Zeitwerk::ConstAdded +end + module Zeitwerk class << self def with_loader; end end end +module Zeitwerk::ConstAdded + def const_added(cname); end +end + +class Zeitwerk::Cref + include ::Zeitwerk::RealModName + + def initialize(mod, cname); end + + def autoload(abspath); end + def autoload?; end + def cname; end + def defined?; end + def get; end + def mod; end + def path; end + def remove; end + def set(value); end +end + class Zeitwerk::Error < ::StandardError; end module Zeitwerk::ExplicitNamespace extend ::Zeitwerk::RealModName class << self - def __register(cpath, loader); end - def __registered?(cpath); end + def __clear; end + def __loader_for(mod, cname); end + def __register(cref, loader); end + def __registered?(cname_or_cpath); end def __unregister_loader(loader); end private - def cpaths; end - def disable_tracer_if_unneeded; end - def mutex; end - def register(cpath, loader); end - def registered?(cpath); end - def tracepoint_class_callback(event); end - def tracer; end + def clear; end + def loader_for(mod, cname); end + def register(cref, loader); end + def registered?(cname_or_cpath); end def unregister_loader(loader); end end end @@ -97,6 +122,7 @@ class Zeitwerk::Loader def __shadowed_file?(file); end def __shadowed_files; end def __to_unload; end + def all_expected_cpaths; end def cpath_expected_at(path); end def reload; end def setup; end @@ -107,25 +133,25 @@ class Zeitwerk::Loader private - def autoload_file(parent, cname, file); end - def autoload_path_set_by_me_for?(parent, cname); end - def autoload_subdir(parent, cname, subdir); end + def autoload_file(cref, file); end + def autoload_path_set_by_me_for?(cref); end + def autoload_subdir(cref, subdir); end def autoloaded_dirs; end def autoloads; end - def define_autoload(parent, cname, abspath); end + def define_autoload(cref, abspath); end def define_autoloads_for_dir(dir, parent); end def dirs_autoload_monitor; end def mutex; end def namespace_dirs; end - def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:); end + def promote_namespace_from_implicit_to_explicit(dir:, file:, cref:); end def raise_if_conflicting_directory(dir); end - def register_explicit_namespace(cpath); end + def register_explicit_namespace(cref); end def run_on_unload_callbacks(cpath, value, abspath); end def shadowed_file?(file); end def shadowed_files; end def to_unload; end - def unload_autoload(parent, cname); end - def unload_cref(parent, cname); end + def unload_autoload(cref); end + def unload_cref(cref); end class << self def all_dirs; end @@ -217,18 +243,13 @@ end module Zeitwerk::Loader::Helpers private - def cdef?(parent, cname); end - def cget(parent, cname); end def cname_for(basename, abspath); end - def cpath(parent, cname); end - def crem(parent, cname); end def dir?(path); end def has_at_least_one_ruby_file?(dir); end def hidden?(basename); end def log(message); end def ls(dir); end def ruby?(path); end - def strict_autoload_path(parent, cname); end def walk_up(abspath); end end @@ -250,7 +271,7 @@ module Zeitwerk::Registry class << self def autoloads; end def gem_loaders_by_root_file; end - def inception?(cpath); end + def inception?(cpath, registered_by_loader = T.unsafe(nil)); end def inceptions; end def loader_for(path); end def loader_for_gem(root_file, namespace:, warn_on_extra_files:); end