sorbet-rails 0.5.1 → 0.5.2

data/spec/support/v6.0/sorbet/rbi/gems/web-console.rbi

@@ -1,72 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/web-console/all/web-console.rbi
-#
-# web-console-4.0.0
-module WebConsole
-  def self.logger; end
-  extend ActiveSupport::Autoload
-end
-class WebConsole::Railtie < Rails::Railtie
-end
-module Kernel
-  def console(binding = nil); end
-  def self.console(binding = nil); end
-end
-class Binding
-  def console; end
-end
-module WebConsole::Interceptor
-  def self.call(request, exception); end
-end
-class WebConsole::Middleware
-  def acceptable_content_type?(headers); end
-  def binding_change_re; end
-  def call(env); end
-  def call_app(env); end
-  def change_stack_trace(id, request); end
-  def create_regular_or_whiny_request(env); end
-  def id_for_repl_session_stack_frame_change(request); end
-  def id_for_repl_session_update(request); end
-  def initialize(app); end
-  def json_response(opts = nil); end
-  def json_response_with_session(id, request, opts = nil); end
-  def mount_point; end
-  def mount_point=(obj); end
-  def repl_sessions_re; end
-  def respond_with_unacceptable_request; end
-  def respond_with_unavailable_session(id); end
-  def self.mount_point; end
-  def self.mount_point=(obj); end
-  def self.whiny_requests; end
-  def self.whiny_requests=(obj); end
-  def update_re; end
-  def update_repl_session(id, request); end
-  def whiny_requests; end
-  def whiny_requests=(obj); end
-end
-class WebConsole::Permissions
-  def coerce_network_to_ipaddr(network); end
-  def human_readable_ipaddr(ipaddr); end
-  def include?(network); end
-  def initialize(networks = nil); end
-  def normalize_networks(networks); end
-  def to_s; end
-end
-class WebConsole::Request < ActionDispatch::Request
-  def permissions; end
-  def permissions=(obj); end
-  def permitted?; end
-  def self.permissions; end
-  def self.permissions=(obj); end
-  def strict_remote_ip; end
-end
-class WebConsole::Request::GetSecureIp < ActionDispatch::RemoteIp::GetIp
-  def filter_proxies(ips); end
-  def initialize(req, proxies); end
-end

data/spec/support/v6.0/sorbet/rbi/gems/zeitwerk.rbi

@@ -1,127 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/zeitwerk/all/zeitwerk.rbi
-#
-# zeitwerk-2.1.9
-module Zeitwerk::RealModName
-  def real_mod_name(mod); end
-end
-module Zeitwerk::Loader::Callbacks
-  def on_dir_autoloaded(dir); end
-  def on_file_autoloaded(file); end
-  def on_namespace_loaded(namespace); end
-  include Zeitwerk::RealModName
-end
-module Zeitwerk
-end
-class Zeitwerk::Loader
-  def actual_root_dirs; end
-  def autoload_file(parent, cname, file); end
-  def autoload_for?(parent, cname); end
-  def autoload_subdir(parent, cname, subdir); end
-  def autoloaded_dirs; end
-  def autoloads; end
-  def cdef?(parent, cname); end
-  def cpath(parent, cname); end
-  def dir?(path); end
-  def dirs; end
-  def do_not_eager_load(*paths); end
-  def do_preload; end
-  def do_preload_abspath(abspath); end
-  def do_preload_dir(dir); end
-  def do_preload_file(file); end
-  def eager_load; end
-  def eager_load_exclusions; end
-  def enable_reloading; end
-  def expand_glob_patterns(glob_patterns); end
-  def expand_paths(paths); end
-  def ignore(*glob_patterns); end
-  def ignored_glob_patterns; end
-  def ignored_paths; end
-  def inflector; end
-  def inflector=(arg0); end
-  def initialize; end
-  def lazy_subdirs; end
-  def log!; end
-  def log(message); end
-  def logger; end
-  def logger=(arg0); end
-  def ls(dir); end
-  def manages?(dir); end
-  def mutex2; end
-  def mutex; end
-  def preload(*paths); end
-  def preloads; end
-  def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:); end
-  def push_dir(path); end
-  def raise_if_conflicting_directory(dir); end
-  def recompute_ignored_paths; end
-  def register_explicit_namespace(cpath); end
-  def reload; end
-  def reloading_enabled?; end
-  def root_dirs; end
-  def ruby?(path); end
-  def self.all_dirs; end
-  def self.default_logger; end
-  def self.default_logger=(arg0); end
-  def self.eager_load_all; end
-  def self.for_gem; end
-  def self.mutex; end
-  def self.mutex=(arg0); end
-  def set_autoload(parent, cname, abspath); end
-  def set_autoloads_in_dir(dir, parent); end
-  def setup; end
-  def strict_autoload_path(parent, cname); end
-  def tag; end
-  def tag=(tag); end
-  def to_unload; end
-  def unload; end
-  def unload_autoload(parent, cname); end
-  def unload_cref(parent, cname); end
-  def unloadable_cpath?(cpath); end
-  def unloadable_cpaths; end
-  include Zeitwerk::Loader::Callbacks
-  include Zeitwerk::RealModName
-end
-module Zeitwerk::Registry
-  def self.autoloads; end
-  def self.inception?(cpath); end
-  def self.inceptions; end
-  def self.loader_for(path); end
-  def self.loader_for_gem(root_file); end
-  def self.loaders; end
-  def self.loaders_managing_gems; end
-  def self.on_unload(loader); end
-  def self.register_autoload(loader, realpath); end
-  def self.register_inception(cpath, realpath, loader); end
-  def self.register_loader(loader); end
-  def self.unregister_autoload(realpath); end
-end
-module Zeitwerk::ExplicitNamespace
-  def self.cpaths; end
-  def self.disable_tracer_if_unneeded; end
-  def self.mutex; end
-  def self.register(cpath, loader); end
-  def self.tracepoint_class_callback(event); end
-  def self.tracer; end
-  def self.unregister(loader); end
-end
-class Zeitwerk::Inflector
-  def camelize(basename, _abspath); end
-end
-class Zeitwerk::GemInflector < Zeitwerk::Inflector
-  def camelize(basename, abspath); end
-  def initialize(root_file); end
-end
-module Kernel
-  def zeitwerk_original_require(arg0); end
-end
-class Zeitwerk::Error < StandardError
-end
-class Zeitwerk::ReloadingDisabledError < Zeitwerk::Error
-end

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/actionmailer/all/actionmailer.rbi

@@ -1,13 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi sorbet-typed
-#
-# If you would like to make changes to this file, great! Please upstream any changes you make here:
-#
-#   https://github.com/sorbet/sorbet-typed/edit/master/lib/actionmailer/all/actionmailer.rbi
-#
-# typed: strong
-
-class ActionMailer::Base
-  sig { params(headers: T.untyped).returns(Mail::Message) }
-  def mail(headers = nil, &block); end
-end

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/actionpack/all/actionpack.rbi

@@ -1,468 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi sorbet-typed
-#
-# If you would like to make changes to this file, great! Please upstream any changes you make here:
-#
-#   https://github.com/sorbet/sorbet-typed/edit/master/lib/actionpack/all/actionpack.rbi
-#
-# typed: false
-
-class ActionController::Base < ActionController::Metal
-end
-
-class AbstractController::Base < Object
-end
-
-class ActionController::Metal < AbstractController::Base
-  sig { returns(ActionDispatch::Request) }
-  def request(); end
-
-  sig { returns(ActionDispatch::Response) }
-  def response(); end
-
-  sig { returns(ActionController::Parameters) }
-  def params(); end
-end
-
-module ActionDispatch::Http::Parameters
-  sig { returns(ActionController::Parameters) }
-  def parameters(); end
-
-  # params is an alias of parameters
-  sig { returns(ActionController::Parameters) }
-  def params(); end
-end
-
-class ActionDispatch::Request
-end
-
-class ActionDispatch::Response
-end
-
-class ActionController::Parameters
-  sig { returns(T.self_type) }
-  def permit!; end
-
-  # You can pass _a lot_ of stuff to permit, so filters is left untyped for now.
-  sig { params(filters: T.untyped).returns(ActionController::Parameters) }
-  def permit(*filters); end
-
-  sig { returns(T::Boolean) }
-  def permitted?; end
-
-  sig { params(key: T.any(Symbol, T::Array[Symbol])).returns(ActionController::Parameters) }
-  def require(key); end
-
-  # required is an alias of require
-  sig { params(key: T.any(Symbol, T::Array[Symbol])).returns(ActionController::Parameters) }
-  def required(key); end
-
-  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
-  def to_h; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def to_hash; end
-
-  sig { params(args: String).returns(T.nilable(String)) }
-  def to_query(*args); end
-
-  # to_param is an alias of to_query
-  sig { params(args: String).returns(T.nilable(String)) }
-  def to_param(*args); end
-end
-
-module ActionController::StrongParameters
-  sig { returns(ActionController::Parameters) }
-  def params; end
-end
-
-class ActionDispatch::Routing::RouteSet
-  sig { params(blk: T.proc.bind(ActionDispatch::Routing::Mapper).void).void }
-  def draw(&blk); end
-end
-
-module ActionController::Flash::ClassMethods
-  sig { params(types: Symbol).void }
-  def add_flash_types(*types); end
-end
-
-module ActionController::RequestForgeryProtection::ClassMethods
-  sig do
-    params(
-      only: T.any(T::Array[Symbol], Symbol),
-      except: T.nilable(T.any(T::Array[Symbol], Symbol)),
-      if: T.untyped,
-      unless: T.untyped,
-      prepend: T.untyped,
-      with: T.nilable(Symbol),
-      exception: T.untyped,
-      reset_session: T.untyped,
-      null_session: T.untyped
-    ).void
-  end
-  def protect_from_forgery(
-    only: nil,
-    except: nil,
-    if: nil,
-    unless: nil,
-    prepend: false,
-    with: nil,
-    exception: nil,
-    reset_session: nil,
-    null_session: nil
-  ); end
-end
-
-module ActionDispatch::Routing::Mapper::HttpHelpers
-  # get, put, patch, post, and delete all have the same arguments as
-  # ActionDispatch::Routing::Mapper::Resources#match
-  sig do
-    params(
-      name: T.any(String, Symbol, T::Hash[String, String]),
-      controller: T.nilable(T.any(String, Symbol)),
-      action: T.nilable(T.any(String, Symbol)),
-      param: T.nilable(Symbol),
-      module: T.nilable(T.any(String, Symbol)),
-      as: T.nilable(T.any(String, Symbol)),
-      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
-      on: T.nilable(Symbol),
-      constraints: T.untyped,
-      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
-      anchor: T::Boolean,
-      format: T.nilable(T.any(String, T::Boolean)),
-      path: T.nilable(T.any(String, Symbol)),
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def delete(
-    name,
-    controller: nil,
-    action: nil,
-    param: :id,
-    module: nil,
-    as: nil,
-    via: nil,
-    to: nil,
-    on: nil,
-    constraints: nil,
-    defaults: nil,
-    anchor: true,
-    format: nil,
-    path: nil,
-    &block
-  ); end
-
-  sig do
-    params(
-      name: T.any(String, Symbol, T::Hash[String, String]),
-      controller: T.nilable(T.any(String, Symbol)),
-      action: T.nilable(T.any(String, Symbol)),
-      param: T.nilable(Symbol),
-      module: T.nilable(T.any(String, Symbol)),
-      as: T.nilable(T.any(String, Symbol)),
-      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
-      on: T.nilable(Symbol),
-      constraints: T.untyped,
-      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
-      anchor: T::Boolean,
-      format: T.nilable(T.any(String, T::Boolean)),
-      path: T.nilable(T.any(String, Symbol)),
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def get(
-    name,
-    controller: nil,
-    action: nil,
-    param: :id,
-    module: nil,
-    as: nil,
-    via: nil,
-    to: nil,
-    on: nil,
-    constraints: nil,
-    defaults: nil,
-    anchor: true,
-    format: nil,
-    path: nil,
-    &block
-  ); end
-
-  sig do
-    params(
-      name: T.any(String, Symbol, T::Hash[String, String]),
-      controller: T.nilable(T.any(String, Symbol)),
-      action: T.nilable(T.any(String, Symbol)),
-      param: T.nilable(Symbol),
-      module: T.nilable(T.any(String, Symbol)),
-      as: T.nilable(T.any(String, Symbol)),
-      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
-      on: T.nilable(Symbol),
-      constraints: T.untyped,
-      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
-      anchor: T::Boolean,
-      format: T.nilable(T.any(String, T::Boolean)),
-      path: T.nilable(T.any(String, Symbol)),
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def patch(
-    name,
-    controller: nil,
-    action: nil,
-    param: :id,
-    module: nil,
-    as: nil,
-    via: nil,
-    to: nil,
-    on: nil,
-    constraints: nil,
-    defaults: nil,
-    anchor: true,
-    format: nil,
-    path: nil,
-    &block
-  ); end
-
-  sig do
-    params(
-      name: T.any(String, Symbol, T::Hash[String, String]),
-      controller: T.nilable(T.any(String, Symbol)),
-      action: T.nilable(T.any(String, Symbol)),
-      param: T.nilable(Symbol),
-      module: T.nilable(T.any(String, Symbol)),
-      as: T.nilable(T.any(String, Symbol)),
-      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
-      on: T.nilable(Symbol),
-      constraints: T.untyped,
-      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
-      anchor: T::Boolean,
-      format: T.nilable(T.any(String, T::Boolean)),
-      path: T.nilable(T.any(String, Symbol)),
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def post(
-    name,
-    controller: nil,
-    action: nil,
-    param: :id,
-    module: nil,
-    as: nil,
-    via: nil,
-    to: nil,
-    on: nil,
-    constraints: nil,
-    defaults: nil,
-    anchor: true,
-    format: nil,
-    path: nil,
-    &block
-  ); end
-
-  sig do
-    params(
-      name: T.any(String, Symbol, T::Hash[String, String]),
-      controller: T.nilable(T.any(String, Symbol)),
-      action: T.nilable(T.any(String, Symbol)),
-      param: T.nilable(Symbol),
-      module: T.nilable(T.any(String, Symbol)),
-      as: T.nilable(T.any(String, Symbol)),
-      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
-      on: T.nilable(Symbol),
-      constraints: T.untyped,
-      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
-      anchor: T::Boolean,
-      format: T.nilable(T.any(String, T::Boolean)),
-      path: T.nilable(T.any(String, Symbol)),
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def put(
-    name,
-    controller: nil,
-    action: nil,
-    param: :id,
-    module: nil,
-    as: nil,
-    via: nil,
-    to: nil,
-    on: nil,
-    constraints: nil,
-    defaults: nil,
-    anchor: true,
-    format: nil,
-    path: nil,
-    &block
-  ); end
-end
-
-module ActionDispatch::Routing::Mapper::Resources
-  sig { params(name: T.untyped).returns(T.untyped) }
-  def action_path(name); end
-
-  sig { params(block: T.untyped).returns(T.untyped) }
-  def collection(&block); end
-
-  sig do
-    params(
-      name: T.any(String, Symbol, T::Hash[String, String]),
-      controller: T.nilable(T.any(String, Symbol)),
-      action: T.nilable(T.any(String, Symbol)),
-      param: T.nilable(Symbol),
-      module: T.nilable(T.any(String, Symbol)),
-      as: T.nilable(T.any(String, Symbol)),
-      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
-      on: T.nilable(Symbol),
-      constraints: T.untyped,
-      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
-      anchor: T::Boolean,
-      format: T.nilable(T.any(String, T::Boolean)),
-      path: T.nilable(T.any(String, Symbol)),
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def match(
-    name,
-    controller: nil,
-    action: nil,
-    param: :id,
-    module: nil,
-    as: nil,
-    via: nil,
-    to: nil,
-    on: nil,
-    constraints: nil,
-    defaults: nil,
-    anchor: true,
-    format: nil,
-    path: nil,
-    &block
-  ); end
-
-  sig { params(block: T.untyped).returns(T.untyped) }
-  def member(&block); end
-
-  # These are set to T.unsafe(nil) because they do actually have values, but they
-  # can't be determined statically. They take the value of path when no explicit
-  # values are provided.
-  sig do
-    params(
-      path: T.untyped,
-      as: T.untyped,
-      module: T.untyped,
-      shallow_path: T.untyped,
-      shallow_prefix: T.untyped,
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def namespace(
-    path,
-    as: T.unsafe(nil),
-    module: T.unsafe(nil),
-    shallow_path: T.unsafe(nil),
-    shallow_prefix: T.unsafe(nil),
-    &block
-  ); end
-
-  sig do
-    params(
-      resources: T.any(String, Symbol),
-      as: T.nilable(T.any(String, Symbol)),
-      controller: T.nilable(T.any(String, Symbol)),
-      concerns: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      param: T.nilable(Symbol),
-      path_names: T.untyped,
-      path: T.untyped,
-      only: T.nilable(T.any(
-        T::Array[T.any(String, Symbol)],
-        String,
-        Symbol
-      )),
-      except: T.nilable(T.any(
-        T::Array[T.any(String, Symbol)],
-        String,
-        Symbol
-      )),
-      shallow: T::Boolean,
-      shallow_path: T.nilable(String),
-      shallow_prefix: T.nilable(String),
-      format: T.untyped,
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def resource(
-    *resources,
-    as: nil,
-    controller: nil,
-    concerns: nil,
-    param: nil,
-    path_names: nil,
-    path: nil,
-    only: nil,
-    except: nil,
-    shallow: false,
-    shallow_path: nil,
-    shallow_prefix: nil,
-    format: nil,
-    &block
-  ); end
-
-  sig do
-    params(
-      resources: T.any(String, Symbol),
-      as: T.nilable(T.any(String, Symbol)),
-      controller: T.nilable(T.any(String, Symbol)),
-      concerns: T.nilable(T.any(Symbol, T::Array[Symbol])),
-      param: T.nilable(Symbol),
-      path_names: T.untyped,
-      path: T.untyped,
-      only: T.nilable(T.any(
-        T::Array[T.any(String, Symbol)],
-        String,
-        Symbol
-      )),
-      except: T.nilable(T.any(
-        T::Array[T.any(String, Symbol)],
-        String,
-        Symbol
-      )),
-      shallow: T::Boolean,
-      shallow_path: T.nilable(String),
-      shallow_prefix: T.nilable(String),
-      format: T.untyped,
-      block: T.untyped
-    ).returns(T.untyped)
-  end
-  def resources(
-    *resources,
-    as: nil,
-    controller: nil,
-    concerns: nil,
-    param: nil,
-    path_names: nil,
-    path: nil,
-    only: nil,
-    except: nil,
-    shallow: false,
-    shallow_path: nil,
-    shallow_prefix: nil,
-    format: nil,
-    &block
-  ); end
-
-  sig { params(path: String, to: T.untyped).returns(T.untyped) }
-  def root(path, to: nil); end
-
-  sig { returns(T.untyped) }
-  def shallow; end
-
-  sig { returns(T::Boolean) }
-  def shallow?; end
-end