1
0
mirror of https://github.com/cmur2/dyndnsd.git synced 2024-12-22 20:54:24 +01:00
dyndnsd/sorbet/rbi/hidden-definitions/hidden.rbi
2020-02-29 14:12:45 +01:00

30685 lines
568 KiB
Ruby

# This file is autogenerated. Do not edit it by hand. Regenerate it with:
# srb rbi hidden-definitions
# typed: autogenerated
module AST
end
class AST::Node
def +(array); end
def <<(element); end
def ==(other); end
def append(element); end
def assign_properties(properties); end
def children(); end
def clone(); end
def concat(array); end
def eql?(other); end
def fancy_type(); end
def initialize(type, children=T.unsafe(nil), properties=T.unsafe(nil)); end
def inspect(indent=T.unsafe(nil)); end
def to_a(); end
def to_ast(); end
def to_s(indent=T.unsafe(nil)); end
def to_sexp(indent=T.unsafe(nil)); end
def to_sexp_array(); end
def type(); end
def updated(type=T.unsafe(nil), children=T.unsafe(nil), properties=T.unsafe(nil)); end
end
class AST::Node
end
class AST::Processor
include ::AST::Processor::Mixin
end
module AST::Processor::Mixin
def handler_missing(node); end
def process(node); end
def process_all(nodes); end
end
module AST::Processor::Mixin
end
class AST::Processor
end
module AST::Sexp
def s(type, *children); end
end
module AST::Sexp
end
module AST
end
class Addrinfo
def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end
end
class Array
include ::JSON::Ext::Generator::GeneratorMethods::Array
def bsearch(); end
def bsearch_index(); end
def collect!(); end
def dig(*_); end
def flatten!(*_); end
def pack(*_); end
def place(*values); end
def replace(_); end
def replace_each_string(&block); end
def shelljoin(); end
def to_h(); end
end
class Array
def self.try_convert(_); end
end
class Atomic
def _compare_and_set(_, _1); end
def compare_and_set(expected, new); end
def compare_and_swap(expected, new); end
def get(); end
def get_and_set(_); end
def initialize(*_); end
def set(_); end
def swap(_); end
def try_update(); end
def update(); end
def value(); end
def value=(value); end
end
class Atomic::ConcurrentUpdateError
CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped)
end
class Atomic::ConcurrentUpdateError
end
class Atomic
end
BasicObject::BasicObject = BasicObject
class BasicSocket
def read_nonblock(len, str=T.unsafe(nil), exception: T.unsafe(nil)); end
end
class BigDecimal
def clone(); end
EXCEPTION_NaN = ::T.let(nil, ::T.untyped)
SIGN_NaN = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class BigDecimal
def self.new(*args, **kwargs); end
end
class Binding
def clone(); end
def irb(); end
end
module Bundler::Audit
VERSION = ::T.let(nil, ::T.untyped)
end
class Bundler::Audit::Advisory
def criticality(); end
def cve_id(); end
def osvdb_id(); end
def patched?(version); end
def unaffected?(version); end
def vulnerable?(version); end
end
class Bundler::Audit::Advisory
def self.load(path); end
end
class Bundler::Audit::Database
def advisories(&block); end
def advisories_for(name); end
def check_gem(gem); end
def each_advisory_path(&block); end
def each_advisory_path_for(name, &block); end
def initialize(path=T.unsafe(nil)); end
def path(); end
def size(); end
URL = ::T.let(nil, ::T.untyped)
USER_PATH = ::T.let(nil, ::T.untyped)
VENDORED_PATH = ::T.let(nil, ::T.untyped)
VENDORED_TIMESTAMP = ::T.let(nil, ::T.untyped)
end
class Bundler::Audit::Database
def self.path(); end
def self.update!(options=T.unsafe(nil)); end
end
module Bundler::Audit
end
class Bundler::Dependency
def branch(); end
def expanded_platforms(); end
def git(); end
end
Bundler::Deprecate = Gem::Deprecate
class Bundler::Env
end
class Bundler::Env
def self.environment(); end
def self.report(options=T.unsafe(nil)); end
def self.write(io); end
end
class Bundler::Fetcher
def fetch_spec(spec); end
def fetchers(); end
def http_proxy(); end
def initialize(remote); end
def specs(gem_names, source); end
def specs_with_retry(gem_names, source); end
def uri(); end
def use_api(); end
def user_agent(); end
FAIL_ERRORS = ::T.let(nil, ::T.untyped)
FETCHERS = ::T.let(nil, ::T.untyped)
HTTP_ERRORS = ::T.let(nil, ::T.untyped)
NET_ERRORS = ::T.let(nil, ::T.untyped)
end
class Bundler::Fetcher::AuthenticationRequiredError
def initialize(remote_uri); end
end
class Bundler::Fetcher::BadAuthenticationError
def initialize(remote_uri); end
end
class Bundler::Fetcher::Base
def api_fetcher?(); end
def available?(); end
def display_uri(); end
def downloader(); end
def fetch_uri(); end
def initialize(downloader, remote, display_uri); end
def remote(); end
def remote_uri(); end
end
class Bundler::Fetcher::Base
end
class Bundler::Fetcher::CertificateFailureError
def initialize(remote_uri); end
end
class Bundler::Fetcher::CompactIndex
def available?(*args, &blk); end
def fetch_spec(*args, &blk); end
def specs(*args, &blk); end
def specs_for_names(gem_names); end
end
class Bundler::Fetcher::CompactIndex::ClientFetcher
def call(path, headers); end
def fetcher(); end
def fetcher=(_); end
def ui(); end
def ui=(_); end
end
class Bundler::Fetcher::CompactIndex::ClientFetcher
def self.[](*_); end
def self.members(); end
end
class Bundler::Fetcher::CompactIndex
def self.compact_index_request(method_name); end
end
class Bundler::Fetcher::Dependency
def dependency_api_uri(gem_names=T.unsafe(nil)); end
def dependency_specs(gem_names); end
def get_formatted_specs_and_deps(gem_list); end
def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end
def unmarshalled_dep_gems(gem_names); end
end
class Bundler::Fetcher::Dependency
end
class Bundler::Fetcher::Downloader
def connection(); end
def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end
def initialize(connection, redirect_limit); end
def redirect_limit(); end
def request(uri, headers); end
end
class Bundler::Fetcher::Downloader
end
class Bundler::Fetcher::Index
def fetch_spec(spec); end
def specs(_gem_names); end
end
class Bundler::Fetcher::Index
end
class Bundler::Fetcher::SSLError
def initialize(msg=T.unsafe(nil)); end
end
class Bundler::Fetcher::TooManyRequestsError
end
class Bundler::Fetcher::TooManyRequestsError
end
class Bundler::Fetcher
def self.api_timeout(); end
def self.api_timeout=(api_timeout); end
def self.disable_endpoint(); end
def self.disable_endpoint=(disable_endpoint); end
def self.max_retries(); end
def self.max_retries=(max_retries); end
def self.redirect_limit(); end
def self.redirect_limit=(redirect_limit); end
end
module Bundler::FileUtils
VERSION = ::T.let(nil, ::T.untyped)
end
class Bundler::FileUtils::Entry_
def link(dest); end
end
module Bundler::FileUtils
def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end
def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
end
class Bundler::GemHelper
include ::Rake::DSL
include ::Rake::FileUtilsExt
include ::FileUtils
include ::FileUtils::StreamUtils_
def allowed_push_host(); end
def already_tagged?(); end
def base(); end
def build_gem(); end
def built_gem_path(); end
def clean?(); end
def committed?(); end
def gem_command(); end
def gem_key(); end
def gem_push?(); end
def gem_push_host(); end
def gemspec(); end
def git_push(remote=T.unsafe(nil)); end
def guard_clean(); end
def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end
def install(); end
def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end
def name(); end
def perform_git_push(options=T.unsafe(nil)); end
def rubygem_push(path); end
def sh(cmd, &block); end
def sh_with_input(cmd); end
def sh_with_status(cmd, &block); end
def spec_path(); end
def tag_version(); end
def version(); end
def version_tag(); end
end
class Bundler::GemHelper
def self.gemspec(&block); end
def self.install_tasks(opts=T.unsafe(nil)); end
def self.instance(); end
def self.instance=(instance); end
end
class Bundler::GemVersionPromoter
def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end
def level(); end
def level=(value); end
def locked_specs(); end
def major?(); end
def minor?(); end
def prerelease_specified(); end
def prerelease_specified=(prerelease_specified); end
def sort_versions(dep, spec_groups); end
def strict(); end
def strict=(strict); end
def unlock_gems(); end
DEBUG = ::T.let(nil, ::T.untyped)
end
class Bundler::GemVersionPromoter
end
class Bundler::Graph
def edge_options(); end
def groups(); end
def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end
def node_options(); end
def output_file(); end
def output_format(); end
def relations(); end
def viz(); end
GRAPH_NAME = ::T.let(nil, ::T.untyped)
end
class Bundler::Graph::GraphVizClient
def g(); end
def initialize(graph_instance); end
def run(); end
end
class Bundler::Graph::GraphVizClient
end
class Bundler::Graph
end
class Bundler::Index
include ::Enumerable
end
class Bundler::Injector
def initialize(deps, options=T.unsafe(nil)); end
def inject(gemfile_path, lockfile_path); end
def remove(gemfile_path, lockfile_path); end
INJECTED_GEMS = ::T.let(nil, ::T.untyped)
end
class Bundler::Injector
def self.inject(new_deps, options=T.unsafe(nil)); end
def self.remove(gems, options=T.unsafe(nil)); end
end
class Bundler::Installer
def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
def generate_standalone_bundler_executable_stubs(spec); end
def initialize(root, definition); end
def post_install_messages(); end
def run(options); end
end
class Bundler::Installer
def self.ambiguous_gems(); end
def self.ambiguous_gems=(ambiguous_gems); end
def self.install(root, definition, options=T.unsafe(nil)); end
end
class Bundler::Molinillo::DependencyGraph
include ::Enumerable
end
class Bundler::Molinillo::DependencyGraph::Log
extend ::Enumerable
end
class Bundler::Molinillo::DependencyGraph::Vertex
def _recursive_predecessors(vertices=T.unsafe(nil)); end
def _recursive_successors(vertices=T.unsafe(nil)); end
end
module Bundler::Plugin::API::Source
def ==(other); end
def app_cache_dirname(); end
def app_cache_path(custom_path=T.unsafe(nil)); end
def bundler_plugin_api_source?(); end
def cache(spec, custom_path=T.unsafe(nil)); end
def cached!(); end
def can_lock?(spec); end
def dependency_names(); end
def dependency_names=(dependency_names); end
def double_check_for(*_); end
def eql?(other); end
def fetch_gemspec_files(); end
def gem_install_dir(); end
def hash(); end
def include?(other); end
def initialize(opts); end
def install(spec, opts); end
def install_path(); end
def installed?(); end
def name(); end
def options(); end
def options_to_lock(); end
def post_install(spec, disable_exts=T.unsafe(nil)); end
def remote!(); end
def root(); end
def specs(); end
def to_lock(); end
def to_s(); end
def unlock!(); end
def unmet_deps(); end
def uri(); end
def uri_hash(); end
end
module Bundler::Plugin::API::Source
end
module Bundler::Plugin::Events
GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped)
GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped)
GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped)
GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
end
class Bundler::Plugin::Index
def installed_plugins(); end
def plugin_commands(plugin); end
end
class Bundler::Plugin::Index::CommandConflict
def initialize(plugin, commands); end
end
class Bundler::Plugin::Index::CommandConflict
end
class Bundler::Plugin::Index::SourceConflict
def initialize(plugin, sources); end
end
class Bundler::Plugin::Index::SourceConflict
end
class Bundler::Plugin::Installer
def install(names, options); end
def install_definition(definition); end
end
class Bundler::Plugin::Installer::Git
def generate_bin(spec, disable_extensions=T.unsafe(nil)); end
end
class Bundler::Plugin::Installer::Git
end
class Bundler::Plugin::Installer::Rubygems
end
class Bundler::Plugin::Installer::Rubygems
end
class Bundler::Plugin::Installer
end
class Bundler::Plugin::SourceList
end
class Bundler::Plugin::SourceList
end
module Bundler::Plugin
def self.list(); end
end
class Bundler::ProcessLock
end
class Bundler::ProcessLock
def self.lock(bundle_path=T.unsafe(nil)); end
end
class Bundler::Retry
def attempt(&block); end
def attempts(&block); end
def current_run(); end
def current_run=(current_run); end
def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end
def name(); end
def name=(name); end
def total_runs(); end
def total_runs=(total_runs); end
end
class Bundler::Retry
def self.attempts(); end
def self.default_attempts(); end
def self.default_retries(); end
end
class Bundler::RubyGemsGemInstaller
end
class Bundler::RubyGemsGemInstaller
end
class Bundler::RubygemsIntegration
def add_to_load_path(paths); end
def all_specs(); end
def backport_ext_builder_monitor(); end
def correct_for_windows_path(path); end
def default_stubs(); end
def find_name(name); end
def gem_remote_fetcher(); end
def plain_specs(); end
def plain_specs=(specs); end
def stub_rubygems(specs); end
def use_gemdeps(gemfile); end
end
class Bundler::Settings::Mirror
def ==(other); end
def fallback_timeout(); end
def fallback_timeout=(timeout); end
def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end
def uri(); end
def uri=(uri); end
def valid?(); end
def validate!(probe=T.unsafe(nil)); end
DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped)
end
class Bundler::Settings::Mirror
end
class Bundler::Settings::Mirrors
def each(&blk); end
def for(uri); end
def initialize(prober=T.unsafe(nil)); end
def parse(key, value); end
end
class Bundler::Settings::Mirrors
end
class Bundler::Settings::Validator
end
class Bundler::Settings::Validator::Rule
def description(); end
def fail!(key, value, *reasons); end
def initialize(keys, description, &validate); end
def k(key); end
def set(settings, key, value, *reasons); end
def validate!(key, value, settings); end
end
class Bundler::Settings::Validator::Rule
end
class Bundler::Settings::Validator
def self.validate!(key, value, settings); end
end
class Bundler::Source::Git
def glob(); end
end
class Bundler::SpecSet
include ::Enumerable
end
class Bundler::Thor
include ::Bundler::Thor::Base
include ::Bundler::Thor::Invocation
include ::Bundler::Thor::Shell
def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end
HELP_MAPPINGS = ::T.let(nil, ::T.untyped)
TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped)
THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end
module Bundler::Thor::Actions
def _cleanup_options_and_set(options, key); end
def _shared_configuration(); end
def action(instance); end
def add_file(destination, *args, &block); end
def add_link(destination, *args); end
def append_file(path, *args, &block); end
def append_to_file(path, *args, &block); end
def apply(path, config=T.unsafe(nil)); end
def behavior(); end
def behavior=(behavior); end
def chmod(path, mode, config=T.unsafe(nil)); end
def comment_lines(path, flag, *args); end
def copy_file(source, *args, &block); end
def create_file(destination, *args, &block); end
def create_link(destination, *args); end
def destination_root(); end
def destination_root=(root); end
def directory(source, *args, &block); end
def empty_directory(destination, config=T.unsafe(nil)); end
def find_in_source_paths(file); end
def get(source, *args, &block); end
def gsub_file(path, flag, *args, &block); end
def in_root(); end
def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
def inject_into_class(path, klass, *args, &block); end
def inject_into_file(destination, *args, &block); end
def inject_into_module(path, module_name, *args, &block); end
def insert_into_file(destination, *args, &block); end
def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end
def link_file(source, *args); end
def prepend_file(path, *args, &block); end
def prepend_to_file(path, *args, &block); end
def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end
def remove_dir(path, config=T.unsafe(nil)); end
def remove_file(path, config=T.unsafe(nil)); end
def run(command, config=T.unsafe(nil)); end
def run_ruby_script(command, config=T.unsafe(nil)); end
def source_paths(); end
def template(source, *args, &block); end
def thor(command, *args); end
def uncomment_lines(path, flag, *args); end
WARNINGS = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Actions::CapturableERB
end
class Bundler::Thor::Actions::CapturableERB
end
module Bundler::Thor::Actions::ClassMethods
def add_runtime_options!(); end
def source_paths(); end
def source_paths_for_search(); end
def source_root(path=T.unsafe(nil)); end
end
module Bundler::Thor::Actions::ClassMethods
end
class Bundler::Thor::Actions::CreateFile
def data(); end
def force_on_collision?(); end
def force_or_skip_or_conflict(force, skip, &block); end
def identical?(); end
def initialize(base, destination, data, config=T.unsafe(nil)); end
def on_conflict_behavior(&block); end
def render(); end
end
class Bundler::Thor::Actions::CreateFile
end
class Bundler::Thor::Actions::CreateLink
end
class Bundler::Thor::Actions::CreateLink
end
class Bundler::Thor::Actions::Directory
def execute!(); end
def file_level_lookup(previous_lookup); end
def files(lookup); end
def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end
def source(); end
end
class Bundler::Thor::Actions::Directory
end
class Bundler::Thor::Actions::EmptyDirectory
def base(); end
def config(); end
def convert_encoded_instructions(filename); end
def destination(); end
def destination=(destination); end
def exists?(); end
def given_destination(); end
def initialize(base, destination, config=T.unsafe(nil)); end
def invoke!(); end
def invoke_with_conflict_check(&block); end
def on_conflict_behavior(); end
def on_file_clash_behavior(); end
def pretend?(); end
def relative_destination(); end
def revoke!(); end
def say_status(status, color); end
end
class Bundler::Thor::Actions::EmptyDirectory
end
class Bundler::Thor::Actions::InjectIntoFile
def behavior(); end
def flag(); end
def initialize(base, destination, data, config); end
def replace!(regexp, string, force); end
def replacement(); end
def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
end
class Bundler::Thor::Actions::InjectIntoFile
end
module Bundler::Thor::Actions
def self.included(base); end
end
class Bundler::Thor::AmbiguousCommandError
end
class Bundler::Thor::AmbiguousCommandError
end
Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError
class Bundler::Thor::Argument
def banner(); end
def default(); end
def default_banner(); end
def description(); end
def enum(); end
def human_name(); end
def initialize(name, options=T.unsafe(nil)); end
def name(); end
def required(); end
def required?(); end
def show_default?(); end
def type(); end
def usage(); end
def valid_type?(type); end
def validate!(); end
VALID_TYPES = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Argument
end
class Bundler::Thor::Arguments
def initialize(arguments=T.unsafe(nil)); end
def parse(args); end
def remaining(); end
NUMERIC = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Arguments
def self.parse(*args); end
def self.split(args); end
end
module Bundler::Thor::Base
def args(); end
def args=(args); end
def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end
def options(); end
def options=(options); end
def parent_options(); end
def parent_options=(parent_options); end
end
module Bundler::Thor::Base::ClassMethods
def all_commands(); end
def all_tasks(); end
def allow_incompatible_default_type!(); end
def argument(name, options=T.unsafe(nil)); end
def arguments(); end
def attr_accessor(*_); end
def attr_reader(*_); end
def attr_writer(*_); end
def baseclass(); end
def basename(); end
def build_option(name, options, scope); end
def build_options(options, scope); end
def check_default_type(); end
def check_default_type!(); end
def check_unknown_options(); end
def check_unknown_options!(); end
def check_unknown_options?(config); end
def class_option(name, options=T.unsafe(nil)); end
def class_options(options=T.unsafe(nil)); end
def class_options_help(shell, groups=T.unsafe(nil)); end
def commands(); end
def create_command(meth); end
def create_task(meth); end
def disable_required_check?(command_name); end
def dispatch(command, given_args, given_opts, config); end
def exit_on_failure?(); end
def find_and_refresh_command(name); end
def find_and_refresh_task(name); end
def from_superclass(method, default=T.unsafe(nil)); end
def group(name=T.unsafe(nil)); end
def handle_argument_error(command, error, args, arity); end
def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end
def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end
def inherited(klass); end
def initialize_added(); end
def is_thor_reserved_word?(word, type); end
def method_added(meth); end
def namespace(name=T.unsafe(nil)); end
def no_commands(&block); end
def no_commands?(); end
def no_commands_context(); end
def no_tasks(&block); end
def print_options(shell, options, group_name=T.unsafe(nil)); end
def public_command(*names); end
def public_task(*names); end
def remove_argument(*names); end
def remove_class_option(*names); end
def remove_command(*names); end
def remove_task(*names); end
def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end
def stop_on_unknown_option?(command_name); end
def strict_args_position(); end
def strict_args_position!(); end
def strict_args_position?(config); end
def tasks(); end
end
module Bundler::Thor::Base::ClassMethods
end
module Bundler::Thor::Base
def self.included(base); end
def self.register_klass_file(klass); end
def self.shell(); end
def self.shell=(shell); end
def self.subclass_files(); end
def self.subclasses(); end
end
class Bundler::Thor::Command
def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def handle_argument_error?(instance, error, caller); end
def handle_no_method_error?(instance, error, caller); end
def hidden?(); end
def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end
def local_method?(instance, name); end
def not_debugging?(instance); end
def private_method?(instance); end
def public_method?(instance); end
def required_arguments_for(klass, usage); end
def required_options(); end
def run(instance, args=T.unsafe(nil)); end
def sans_backtrace(backtrace, caller); end
FILE_REGEXP = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Command
end
module Bundler::Thor::CoreExt
end
class Bundler::Thor::CoreExt::HashWithIndifferentAccess
def [](key); end
def []=(key, value); end
def convert_key(key); end
def delete(key); end
def fetch(key, *args); end
def initialize(hash=T.unsafe(nil)); end
def key?(key); end
def merge(other); end
def merge!(other); end
def method_missing(method, *args); end
def replace(other_hash); end
def reverse_merge(other); end
def reverse_merge!(other_hash); end
def values_at(*indices); end
end
class Bundler::Thor::CoreExt::HashWithIndifferentAccess
end
module Bundler::Thor::CoreExt
end
Bundler::Thor::Correctable = DidYouMean::Correctable
class Bundler::Thor::DynamicCommand
def initialize(name, options=T.unsafe(nil)); end
end
class Bundler::Thor::DynamicCommand
end
Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand
class Bundler::Thor::Error
end
class Bundler::Thor::Error
end
class Bundler::Thor::Group
include ::Bundler::Thor::Base
include ::Bundler::Thor::Invocation
include ::Bundler::Thor::Shell
def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end
end
class Bundler::Thor::Group
extend ::Bundler::Thor::Base::ClassMethods
extend ::Bundler::Thor::Invocation::ClassMethods
def self.banner(); end
def self.desc(description=T.unsafe(nil)); end
def self.get_options_from_invocations(group_options, base_options); end
def self.handle_argument_error(command, error, _args, arity); end
def self.help(shell); end
def self.invocation_blocks(); end
def self.invocations(); end
def self.invoke(*names, &block); end
def self.invoke_from_option(*names, &block); end
def self.printable_commands(*_); end
def self.printable_tasks(*_); end
def self.remove_invocation(*names); end
def self.self_command(); end
def self.self_task(); end
end
class Bundler::Thor::HiddenCommand
end
class Bundler::Thor::HiddenCommand
end
Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand
module Bundler::Thor::Invocation
def _parse_initialization_options(args, opts, config); end
def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end
def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end
def _shared_configuration(); end
def current_command_chain(); end
def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end
def invoke(name=T.unsafe(nil), *args); end
def invoke_all(); end
def invoke_command(command, *args); end
def invoke_task(command, *args); end
def invoke_with_padding(*args); end
end
module Bundler::Thor::Invocation::ClassMethods
def prepare_for_invocation(key, name); end
end
module Bundler::Thor::Invocation::ClassMethods
end
module Bundler::Thor::Invocation
def self.included(base); end
end
class Bundler::Thor::InvocationError
end
class Bundler::Thor::InvocationError
end
module Bundler::Thor::LineEditor
end
class Bundler::Thor::LineEditor::Basic
def initialize(prompt, options); end
def options(); end
def prompt(); end
def readline(); end
end
class Bundler::Thor::LineEditor::Basic
def self.available?(); end
end
class Bundler::Thor::LineEditor::Readline
end
class Bundler::Thor::LineEditor::Readline::PathCompletion
def initialize(text); end
def matches(); end
end
class Bundler::Thor::LineEditor::Readline::PathCompletion
end
class Bundler::Thor::LineEditor::Readline
end
module Bundler::Thor::LineEditor
def self.best_available(); end
def self.readline(prompt, options=T.unsafe(nil)); end
end
class Bundler::Thor::MalformattedArgumentError
end
class Bundler::Thor::MalformattedArgumentError
end
class Bundler::Thor::NestedContext
def enter(); end
def entered?(); end
end
class Bundler::Thor::NestedContext
end
class Bundler::Thor::NoKwargSpellChecker
def initialize(dictionary); end
end
class Bundler::Thor::NoKwargSpellChecker
end
class Bundler::Thor::Option
def aliases(); end
def array?(); end
def boolean?(); end
def dasherize(str); end
def dasherized?(); end
def group(); end
def hash?(); end
def hide(); end
def lazy_default(); end
def numeric?(); end
def repeatable(); end
def string?(); end
def switch_name(); end
def undasherize(str); end
def usage(padding=T.unsafe(nil)); end
def validate_default_type!(); end
VALID_TYPES = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Option
def self.parse(key, value); end
end
class Bundler::Thor::Options
def assign_result!(option, result); end
def check_unknown!(); end
def current_is_switch?(); end
def current_is_switch_formatted?(); end
def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end
def normalize_switch(arg); end
def parse_boolean(switch); end
def parse_peek(switch, option); end
def parsing_options?(); end
def switch?(arg); end
def switch_option(arg); end
EQ_RE = ::T.let(nil, ::T.untyped)
LONG_RE = ::T.let(nil, ::T.untyped)
OPTS_END = ::T.let(nil, ::T.untyped)
SHORT_NUM = ::T.let(nil, ::T.untyped)
SHORT_RE = ::T.let(nil, ::T.untyped)
SHORT_SQ_RE = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Options
def self.to_switches(options); end
end
module Bundler::Thor::RakeCompat
include ::Rake::DSL
include ::Rake::FileUtilsExt
include ::FileUtils
include ::FileUtils::StreamUtils_
end
module Bundler::Thor::RakeCompat
def self.included(base); end
def self.rake_classes(); end
end
class Bundler::Thor::RequiredArgumentMissingError
end
class Bundler::Thor::RequiredArgumentMissingError
end
module Bundler::Thor::Sandbox
end
module Bundler::Thor::Sandbox
end
module Bundler::Thor::Shell
def _shared_configuration(); end
def ask(*args, &block); end
def error(*args, &block); end
def file_collision(*args, &block); end
def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
def no?(*args, &block); end
def print_in_columns(*args, &block); end
def print_table(*args, &block); end
def print_wrapped(*args, &block); end
def say(*args, &block); end
def say_status(*args, &block); end
def set_color(*args, &block); end
def shell(); end
def shell=(shell); end
def terminal_width(*args, &block); end
def with_padding(); end
def yes?(*args, &block); end
SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Shell::Basic
def answer_match(possibilities, answer, case_insensitive); end
def as_unicode(); end
def ask(statement, *args); end
def ask_filtered(statement, color, options); end
def ask_simply(statement, color, options); end
def base(); end
def base=(base); end
def can_display_colors?(); end
def dynamic_width(); end
def dynamic_width_stty(); end
def dynamic_width_tput(); end
def error(statement); end
def file_collision(destination); end
def file_collision_help(); end
def git_merge_tool(); end
def indent(count=T.unsafe(nil)); end
def is?(value); end
def lookup_color(color); end
def merge(destination, content); end
def merge_tool(); end
def mute(); end
def mute?(); end
def no?(statement, color=T.unsafe(nil)); end
def padding(); end
def padding=(value); end
def prepare_message(message, *color); end
def print_in_columns(array); end
def print_table(array, options=T.unsafe(nil)); end
def print_wrapped(message, options=T.unsafe(nil)); end
def quiet?(); end
def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end
def say_status(status, message, log_status=T.unsafe(nil)); end
def set_color(string, *_); end
def show_diff(destination, content); end
def stderr(); end
def stdout(); end
def terminal_width(); end
def truncate(string, width); end
def unix?(); end
def yes?(statement, color=T.unsafe(nil)); end
DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Shell::Basic
end
class Bundler::Thor::Shell::Color
def are_colors_disabled?(); end
def diff_lcs_loaded?(); end
def output_diff_line(diff); end
def set_color(string, *colors); end
BLACK = ::T.let(nil, ::T.untyped)
BLUE = ::T.let(nil, ::T.untyped)
BOLD = ::T.let(nil, ::T.untyped)
CLEAR = ::T.let(nil, ::T.untyped)
CYAN = ::T.let(nil, ::T.untyped)
GREEN = ::T.let(nil, ::T.untyped)
MAGENTA = ::T.let(nil, ::T.untyped)
ON_BLACK = ::T.let(nil, ::T.untyped)
ON_BLUE = ::T.let(nil, ::T.untyped)
ON_CYAN = ::T.let(nil, ::T.untyped)
ON_GREEN = ::T.let(nil, ::T.untyped)
ON_MAGENTA = ::T.let(nil, ::T.untyped)
ON_RED = ::T.let(nil, ::T.untyped)
ON_WHITE = ::T.let(nil, ::T.untyped)
ON_YELLOW = ::T.let(nil, ::T.untyped)
RED = ::T.let(nil, ::T.untyped)
WHITE = ::T.let(nil, ::T.untyped)
YELLOW = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Shell::Color
end
class Bundler::Thor::Shell::HTML
def ask(statement, color=T.unsafe(nil)); end
def diff_lcs_loaded?(); end
def output_diff_line(diff); end
def set_color(string, *colors); end
BLACK = ::T.let(nil, ::T.untyped)
BLUE = ::T.let(nil, ::T.untyped)
BOLD = ::T.let(nil, ::T.untyped)
CYAN = ::T.let(nil, ::T.untyped)
GREEN = ::T.let(nil, ::T.untyped)
MAGENTA = ::T.let(nil, ::T.untyped)
ON_BLACK = ::T.let(nil, ::T.untyped)
ON_BLUE = ::T.let(nil, ::T.untyped)
ON_CYAN = ::T.let(nil, ::T.untyped)
ON_GREEN = ::T.let(nil, ::T.untyped)
ON_MAGENTA = ::T.let(nil, ::T.untyped)
ON_RED = ::T.let(nil, ::T.untyped)
ON_WHITE = ::T.let(nil, ::T.untyped)
ON_YELLOW = ::T.let(nil, ::T.untyped)
RED = ::T.let(nil, ::T.untyped)
WHITE = ::T.let(nil, ::T.untyped)
YELLOW = ::T.let(nil, ::T.untyped)
end
class Bundler::Thor::Shell::HTML
end
module Bundler::Thor::Shell
end
Bundler::Thor::Task = Bundler::Thor::Command
class Bundler::Thor::UndefinedCommandError
include ::DidYouMean::Correctable
def all_commands(); end
def command(); end
def initialize(command, all_commands, namespace); end
end
class Bundler::Thor::UndefinedCommandError::SpellChecker
def corrections(); end
def error(); end
def initialize(error); end
def spell_checker(); end
end
class Bundler::Thor::UndefinedCommandError::SpellChecker
end
class Bundler::Thor::UndefinedCommandError
end
Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError
class Bundler::Thor::UnknownArgumentError
include ::DidYouMean::Correctable
def initialize(switches, unknown); end
def switches(); end
def unknown(); end
end
class Bundler::Thor::UnknownArgumentError::SpellChecker
def corrections(); end
def error(); end
def initialize(error); end
def spell_checker(); end
end
class Bundler::Thor::UnknownArgumentError::SpellChecker
end
class Bundler::Thor::UnknownArgumentError
end
module Bundler::Thor::Util
end
module Bundler::Thor::Util
def self.camel_case(str); end
def self.escape_globs(path); end
def self.escape_html(string); end
def self.find_by_namespace(namespace); end
def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end
def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end
def self.globs_for(path); end
def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end
def self.namespace_from_thor_class(constant); end
def self.namespaces_in_content(contents, file=T.unsafe(nil)); end
def self.ruby_command(); end
def self.snake_case(str); end
def self.thor_classes_in(klass); end
def self.thor_root(); end
def self.thor_root_glob(); end
def self.user_home(); end
end
class Bundler::Thor
extend ::Bundler::Thor::Base::ClassMethods
extend ::Bundler::Thor::Invocation::ClassMethods
def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def self.check_unknown_options!(options=T.unsafe(nil)); end
def self.command_help(shell, command_name); end
def self.default_command(meth=T.unsafe(nil)); end
def self.default_task(meth=T.unsafe(nil)); end
def self.deprecation_warning(message); end
def self.desc(usage, description, options=T.unsafe(nil)); end
def self.disable_required_check(); end
def self.disable_required_check!(*command_names); end
def self.disable_required_check?(command); end
def self.dispatch(meth, given_args, given_opts, config); end
def self.dynamic_command_class(); end
def self.find_command_possibilities(meth); end
def self.find_task_possibilities(meth); end
def self.help(shell, subcommand=T.unsafe(nil)); end
def self.long_desc(long_description, options=T.unsafe(nil)); end
def self.map(mappings=T.unsafe(nil), **kw); end
def self.method_option(name, options=T.unsafe(nil)); end
def self.method_options(options=T.unsafe(nil)); end
def self.normalize_command_name(meth); end
def self.normalize_task_name(meth); end
def self.option(name, options=T.unsafe(nil)); end
def self.options(options=T.unsafe(nil)); end
def self.package_name(name, _=T.unsafe(nil)); end
def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end
def self.retrieve_command_name(args); end
def self.retrieve_task_name(args); end
def self.stop_on_unknown_option(); end
def self.stop_on_unknown_option!(*command_names); end
def self.stop_on_unknown_option?(command); end
def self.subcommand(subcommand, subcommand_class); end
def self.subcommand_classes(); end
def self.subcommand_help(cmd); end
def self.subcommands(); end
def self.subtask(subcommand, subcommand_class); end
def self.subtask_help(cmd); end
def self.subtasks(); end
def self.task_help(shell, command_name); end
end
class Bundler::UI::Shell
def add_color(string, *color); end
def ask(msg); end
def confirm(msg, newline=T.unsafe(nil)); end
def debug(msg, newline=T.unsafe(nil)); end
def debug?(); end
def error(msg, newline=T.unsafe(nil)); end
def info(msg, newline=T.unsafe(nil)); end
def initialize(options=T.unsafe(nil)); end
def level(name=T.unsafe(nil)); end
def level=(level); end
def no?(); end
def quiet?(); end
def shell=(shell); end
def silence(&blk); end
def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
def unprinted_warnings(); end
def warn(msg, newline=T.unsafe(nil)); end
def yes?(msg); end
LEVELS = ::T.let(nil, ::T.untyped)
end
class Bundler::UI::Shell
end
module Bundler::URI
include ::Bundler::URI::RFC2396_REGEXP
ABS_PATH = ::T.let(nil, ::T.untyped)
ABS_URI = ::T.let(nil, ::T.untyped)
ABS_URI_REF = ::T.let(nil, ::T.untyped)
DEFAULT_PARSER = ::T.let(nil, ::T.untyped)
ESCAPED = ::T.let(nil, ::T.untyped)
FRAGMENT = ::T.let(nil, ::T.untyped)
HOST = ::T.let(nil, ::T.untyped)
OPAQUE = ::T.let(nil, ::T.untyped)
PORT = ::T.let(nil, ::T.untyped)
QUERY = ::T.let(nil, ::T.untyped)
REGISTRY = ::T.let(nil, ::T.untyped)
REL_PATH = ::T.let(nil, ::T.untyped)
REL_URI = ::T.let(nil, ::T.untyped)
REL_URI_REF = ::T.let(nil, ::T.untyped)
RFC3986_PARSER = ::T.let(nil, ::T.untyped)
SCHEME = ::T.let(nil, ::T.untyped)
TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped)
TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped)
UNSAFE = ::T.let(nil, ::T.untyped)
URI_REF = ::T.let(nil, ::T.untyped)
USERINFO = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
VERSION_CODE = ::T.let(nil, ::T.untyped)
WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::BadURIError
end
class Bundler::URI::BadURIError
end
class Bundler::URI::Error
end
class Bundler::URI::Error
end
module Bundler::URI::Escape
def decode(*arg); end
def encode(*arg); end
def escape(*arg); end
def unescape(*arg); end
end
module Bundler::URI::Escape
end
class Bundler::URI::FTP
def set_typecode(v); end
def typecode(); end
def typecode=(typecode); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
TYPECODE = ::T.let(nil, ::T.untyped)
TYPECODE_PREFIX = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::FTP
def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
end
class Bundler::URI::File
def check_password(user); end
def check_user(user); end
def check_userinfo(user); end
def set_userinfo(v); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::File
end
class Bundler::URI::Generic
include ::Bundler::URI
include ::Bundler::URI::RFC2396_REGEXP
def +(oth); end
def -(oth); end
def ==(oth); end
def absolute(); end
def absolute?(); end
def coerce(oth); end
def component(); end
def component_ary(); end
def default_port(); end
def eql?(oth); end
def find_proxy(env=T.unsafe(nil)); end
def fragment(); end
def fragment=(v); end
def hierarchical?(); end
def host(); end
def host=(v); end
def hostname(); end
def hostname=(v); end
def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end
def merge(oth); end
def merge!(oth); end
def normalize(); end
def normalize!(); end
def opaque(); end
def opaque=(v); end
def parser(); end
def password(); end
def password=(password); end
def path(); end
def path=(v); end
def port(); end
def port=(v); end
def query(); end
def query=(v); end
def registry(); end
def registry=(v); end
def relative?(); end
def route_from(oth); end
def route_to(oth); end
def scheme(); end
def scheme=(v); end
def select(*components); end
def set_host(v); end
def set_opaque(v); end
def set_password(v); end
def set_path(v); end
def set_port(v); end
def set_registry(v); end
def set_scheme(v); end
def set_user(v); end
def set_userinfo(user, password=T.unsafe(nil)); end
def user(); end
def user=(user); end
def userinfo(); end
def userinfo=(userinfo); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
USE_REGISTRY = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::Generic
def self.build(args); end
def self.build2(args); end
def self.component(); end
def self.default_port(); end
def self.use_proxy?(hostname, addr, port, no_proxy); end
def self.use_registry(); end
end
class Bundler::URI::HTTP
def request_uri(); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::HTTP
end
class Bundler::URI::HTTPS
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::HTTPS
end
class Bundler::URI::InvalidComponentError
end
class Bundler::URI::InvalidComponentError
end
class Bundler::URI::InvalidURIError
end
class Bundler::URI::InvalidURIError
end
class Bundler::URI::LDAP
def attributes(); end
def attributes=(val); end
def dn(); end
def dn=(val); end
def extensions(); end
def extensions=(val); end
def filter(); end
def filter=(val); end
def initialize(*arg); end
def scope(); end
def scope=(val); end
def set_attributes(val); end
def set_dn(val); end
def set_extensions(val); end
def set_filter(val); end
def set_scope(val); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
SCOPE = ::T.let(nil, ::T.untyped)
SCOPE_BASE = ::T.let(nil, ::T.untyped)
SCOPE_ONE = ::T.let(nil, ::T.untyped)
SCOPE_SUB = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::LDAP
end
class Bundler::URI::LDAPS
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::LDAPS
end
class Bundler::URI::MailTo
def headers(); end
def headers=(v); end
def initialize(*arg); end
def set_headers(v); end
def set_to(v); end
def to(); end
def to=(v); end
def to_mailtext(); end
def to_rfc822text(); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
EMAIL_REGEXP = ::T.let(nil, ::T.untyped)
HEADER_REGEXP = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::MailTo
end
Bundler::URI::Parser = Bundler::URI::RFC2396_Parser
Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP
class Bundler::URI::RFC2396_Parser
include ::Bundler::URI::RFC2396_REGEXP
def escape(str, unsafe=T.unsafe(nil)); end
def extract(str, schemes=T.unsafe(nil)); end
def initialize(opts=T.unsafe(nil)); end
def join(*uris); end
def make_regexp(schemes=T.unsafe(nil)); end
def parse(uri); end
def pattern(); end
def regexp(); end
def split(uri); end
def unescape(str, escaped=T.unsafe(nil)); end
end
class Bundler::URI::RFC2396_Parser
end
module Bundler::URI::RFC2396_REGEXP
end
module Bundler::URI::RFC2396_REGEXP::PATTERN
ABS_PATH = ::T.let(nil, ::T.untyped)
ABS_URI = ::T.let(nil, ::T.untyped)
ALNUM = ::T.let(nil, ::T.untyped)
ALPHA = ::T.let(nil, ::T.untyped)
DOMLABEL = ::T.let(nil, ::T.untyped)
ESCAPED = ::T.let(nil, ::T.untyped)
FRAGMENT = ::T.let(nil, ::T.untyped)
HEX = ::T.let(nil, ::T.untyped)
HIER_PART = ::T.let(nil, ::T.untyped)
HOST = ::T.let(nil, ::T.untyped)
HOSTNAME = ::T.let(nil, ::T.untyped)
HOSTPORT = ::T.let(nil, ::T.untyped)
IPV4ADDR = ::T.let(nil, ::T.untyped)
IPV6ADDR = ::T.let(nil, ::T.untyped)
IPV6REF = ::T.let(nil, ::T.untyped)
NET_PATH = ::T.let(nil, ::T.untyped)
OPAQUE_PART = ::T.let(nil, ::T.untyped)
PATH_SEGMENTS = ::T.let(nil, ::T.untyped)
PORT = ::T.let(nil, ::T.untyped)
QUERY = ::T.let(nil, ::T.untyped)
REG_NAME = ::T.let(nil, ::T.untyped)
REL_PATH = ::T.let(nil, ::T.untyped)
REL_SEGMENT = ::T.let(nil, ::T.untyped)
REL_URI = ::T.let(nil, ::T.untyped)
RESERVED = ::T.let(nil, ::T.untyped)
SCHEME = ::T.let(nil, ::T.untyped)
TOPLABEL = ::T.let(nil, ::T.untyped)
UNRESERVED = ::T.let(nil, ::T.untyped)
URIC = ::T.let(nil, ::T.untyped)
URIC_NO_SLASH = ::T.let(nil, ::T.untyped)
URI_REF = ::T.let(nil, ::T.untyped)
USERINFO = ::T.let(nil, ::T.untyped)
X_ABS_URI = ::T.let(nil, ::T.untyped)
X_REL_URI = ::T.let(nil, ::T.untyped)
end
module Bundler::URI::RFC2396_REGEXP::PATTERN
end
module Bundler::URI::RFC2396_REGEXP
end
class Bundler::URI::RFC3986_Parser
def join(*uris); end
def parse(uri); end
def regexp(); end
def split(uri); end
RFC3986_URI = ::T.let(nil, ::T.untyped)
RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
end
class Bundler::URI::RFC3986_Parser
end
module Bundler::URI::Util
end
module Bundler::URI::Util
def self.make_components_hash(klass, array_hash); end
end
module Bundler::URI
extend ::Bundler::URI::Escape
def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end
def self.decode_www_form_component(str, enc=T.unsafe(nil)); end
def self.encode_www_form(enum, enc=T.unsafe(nil)); end
def self.encode_www_form_component(str, enc=T.unsafe(nil)); end
def self.extract(str, schemes=T.unsafe(nil), &block); end
def self.get_encoding(label); end
def self.join(*str); end
def self.parse(uri); end
def self.regexp(schemes=T.unsafe(nil)); end
def self.scheme_list(); end
def self.split(uri); end
end
module Bundler::VersionRanges
end
class Bundler::VersionRanges::NEq
def version(); end
def version=(_); end
end
class Bundler::VersionRanges::NEq
def self.[](*_); end
def self.members(); end
end
class Bundler::VersionRanges::ReqR
def cover?(v); end
def empty?(); end
def left(); end
def left=(_); end
def right(); end
def right=(_); end
def single?(); end
INFINITY = ::T.let(nil, ::T.untyped)
UNIVERSAL = ::T.let(nil, ::T.untyped)
ZERO = ::T.let(nil, ::T.untyped)
end
class Bundler::VersionRanges::ReqR::Endpoint
def inclusive(); end
def inclusive=(_); end
def version(); end
def version=(_); end
end
class Bundler::VersionRanges::ReqR::Endpoint
def self.[](*_); end
def self.members(); end
end
class Bundler::VersionRanges::ReqR
def self.[](*_); end
def self.members(); end
end
module Bundler::VersionRanges
def self.empty?(ranges, neqs); end
def self.for(requirement); end
def self.for_many(requirements); end
end
module Bundler
def self.original_exec(*args); end
def self.original_system(*args); end
def self.unbundled_env(); end
def self.unbundled_exec(*args); end
def self.unbundled_system(*args); end
def self.with_unbundled_env(); end
end
module CGI::HtmlExtension
def a(href=T.unsafe(nil)); end
def base(href=T.unsafe(nil)); end
def blockquote(cite=T.unsafe(nil)); end
def caption(align=T.unsafe(nil)); end
def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
def checkbox_group(name=T.unsafe(nil), *values); end
def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end
def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end
def html(attributes=T.unsafe(nil)); end
def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end
def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end
def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end
def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
def popup_menu(name=T.unsafe(nil), *values); end
def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
def radio_group(name=T.unsafe(nil), *values); end
def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end
def scrolling_list(name=T.unsafe(nil), *values); end
def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end
def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end
end
module CGI::HtmlExtension
end
class Class
def json_creatable?(); end
end
class Complex
def self.polar(*_); end
def self.rect(*_); end
def self.rectangular(*_); end
end
class ConcurrentRedBlackTree
end
class ConcurrentRedBlackTree::ConcurrentNode
def balanced_rotate(dir); end
def child(dir); end
def new_child(dir, node, color=T.unsafe(nil)); end
def new_children(dir, node, other, color=T.unsafe(nil)); end
def new_color(color); end
def new_value(value); end
def rebalance_for_delete(dir); end
def rebalance_for_insert(dir); end
def rotate(dir); end
EMPTY_CONCURRENT = ::T.let(nil, ::T.untyped)
LEFT = ::T.let(nil, ::T.untyped)
RIGHT = ::T.let(nil, ::T.untyped)
end
class ConcurrentRedBlackTree::ConcurrentNode::EmptyConcurrentNode
end
class ConcurrentRedBlackTree::ConcurrentNode::EmptyConcurrentNode
end
class ConcurrentRedBlackTree::ConcurrentNode
end
class ConcurrentRedBlackTree
end
class Date::Infinity
def initialize(d=T.unsafe(nil)); end
end
class Delegator
def !=(obj); end
def ==(obj); end
def __getobj__(); end
def __setobj__(obj); end
def eql?(obj); end
def initialize(obj); end
def marshal_dump(); end
def marshal_load(data); end
def method_missing(m, *args, &block); end
def methods(all=T.unsafe(nil)); end
def protected_methods(all=T.unsafe(nil)); end
def public_methods(all=T.unsafe(nil)); end
end
class Delegator
def self.const_missing(n); end
def self.delegating_block(mid); end
def self.public_api(); end
end
class DidYouMean::ClassNameChecker
def class_name(); end
def class_names(); end
def corrections(); end
def initialize(exception); end
def scopes(); end
end
module DidYouMean::Correctable
def corrections(); end
def original_message(); end
def spell_checker(); end
def to_s(); end
end
module DidYouMean::Jaro
def self.distance(str1, str2); end
end
module DidYouMean::JaroWinkler
def self.distance(str1, str2); end
end
class DidYouMean::KeyErrorChecker
def corrections(); end
def initialize(key_error); end
end
class DidYouMean::KeyErrorChecker
end
module DidYouMean::Levenshtein
def self.distance(str1, str2); end
def self.min3(a, b, c); end
end
class DidYouMean::MethodNameChecker
def corrections(); end
def initialize(exception); end
def method_name(); end
def method_names(); end
def receiver(); end
RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end
class DidYouMean::NullChecker
def corrections(); end
def initialize(*_); end
end
class DidYouMean::PlainFormatter
def message_for(corrections); end
end
class DidYouMean::PlainFormatter
end
class DidYouMean::VariableNameChecker
def corrections(); end
def cvar_names(); end
def initialize(exception); end
def ivar_names(); end
def lvar_names(); end
def method_names(); end
def name(); end
RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end
module DidYouMean
def self.formatter(); end
def self.formatter=(formatter); end
end
class Dir
def children(); end
def each_child(); end
end
class Dir
def self.children(*_); end
def self.each_child(*_); end
def self.empty?(_); end
def self.exists?(_); end
def self.tmpdir(); end
end
class Dyndnsd::Database
def [](*args, &block); end
def []=(*args, &block); end
def each(*args, &block); end
def has_key?(*args, &block); end
end
class Dyndnsd::DummyDatabase
def [](*args, &block); end
def []=(*args, &block); end
def each(*args, &block); end
def has_key?(*args, &block); end
end
class ERB
def def_method(mod, methodname, fname=T.unsafe(nil)); end
def def_module(methodname=T.unsafe(nil)); end
def result_with_hash(hash); end
end
class ERB::Compiler::Scanner
DEFAULT_ETAGS = ::T.let(nil, ::T.untyped)
DEFAULT_STAGS = ::T.let(nil, ::T.untyped)
end
Emitter = Psych::Stream::Emitter
class Encoding
def _dump(*_); end
end
class Encoding::Converter
def convert(_); end
def convpath(); end
def destination_encoding(); end
def finish(); end
def initialize(*_); end
def insert_output(_); end
def last_error(); end
def primitive_convert(*_); end
def primitive_errinfo(); end
def putback(*_); end
def replacement(); end
def replacement=(replacement); end
def source_encoding(); end
end
class Encoding::Converter
def self.asciicompat_encoding(_); end
def self.search_convpath(*_); end
end
class Encoding::InvalidByteSequenceError
def destination_encoding(); end
def destination_encoding_name(); end
def error_bytes(); end
def incomplete_input?(); end
def readagain_bytes(); end
def source_encoding(); end
def source_encoding_name(); end
end
class Encoding::UndefinedConversionError
def destination_encoding(); end
def destination_encoding_name(); end
def error_char(); end
def source_encoding(); end
def source_encoding_name(); end
end
class Encoding
def self._load(_); end
def self.locale_charmap(); end
end
module Enumerable
def chain(*_); end
def chunk(); end
def chunk_while(); end
def each_entry(*_); end
def grep_v(_); end
def slice_after(*_); end
def slice_before(*_); end
def slice_when(); end
def sum(*_); end
def to_set(klass=T.unsafe(nil), *args, &block); end
def uniq(); end
end
class Enumerator
def +(_); end
def each_with_index(); end
end
class Enumerator::ArithmeticSequence
def begin(); end
def each(&blk); end
def end(); end
def exclude_end?(); end
def last(*_); end
def step(); end
end
class Enumerator::ArithmeticSequence
end
class Enumerator::Chain
end
class Enumerator::Chain
end
class Enumerator::Generator
def each(*_, &blk); end
def initialize(*_); end
end
class Enumerator::Lazy
def chunk(*_); end
def chunk_while(*_); end
def force(*_); end
def slice_when(*_); end
end
Errno::EAUTH = Errno::NOERROR
Errno::EBADARCH = Errno::NOERROR
Errno::EBADEXEC = Errno::NOERROR
Errno::EBADMACHO = Errno::NOERROR
Errno::EBADRPC = Errno::NOERROR
Errno::ECAPMODE = Errno::NOERROR
Errno::EDEADLOCK = Errno::EDEADLK
Errno::EDEVERR = Errno::NOERROR
Errno::EDOOFUS = Errno::NOERROR
Errno::EFTYPE = Errno::NOERROR
Errno::EIPSEC = Errno::NOERROR
Errno::ELAST = Errno::NOERROR
Errno::ENEEDAUTH = Errno::NOERROR
Errno::ENOATTR = Errno::NOERROR
Errno::ENOPOLICY = Errno::NOERROR
Errno::ENOTCAPABLE = Errno::NOERROR
class Errno::ENOTSUP
Errno = ::T.let(nil, ::T.untyped)
end
class Errno::ENOTSUP
end
Errno::EPROCLIM = Errno::NOERROR
Errno::EPROCUNAVAIL = Errno::NOERROR
Errno::EPROGMISMATCH = Errno::NOERROR
Errno::EPROGUNAVAIL = Errno::NOERROR
Errno::EPWROFF = Errno::NOERROR
Errno::EQFULL = Errno::NOERROR
Errno::ERPCMISMATCH = Errno::NOERROR
Errno::ESHLIBVERS = Errno::NOERROR
class Etc::Group
def gid(); end
def gid=(_); end
def mem(); end
def mem=(_); end
def name(); end
def name=(_); end
def passwd(); end
def passwd=(_); end
end
class Etc::Group
extend ::Enumerable
def self.[](*_); end
def self.each(&blk); end
def self.members(); end
end
class Etc::Passwd
def dir=(_); end
def gecos(); end
def gecos=(_); end
def gid=(_); end
def name=(_); end
def passwd=(_); end
def shell=(_); end
def uid=(_); end
end
class Etc::Passwd
extend ::Enumerable
def self.[](*_); end
def self.each(&blk); end
def self.members(); end
end
class Exception
def full_message(*_); end
end
class Exception
def self.exception(*_); end
def self.to_tty?(); end
end
class ExitCalledError
end
class ExitCalledError
end
class FalseClass
include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
end
class Fiber
def resume(*_); end
end
class Fiber
def self.yield(*_); end
end
class File
RELATIVE_PARENTDIR = ::T.let(nil, ::T.untyped)
RELATIVE_SAMEDIR = ::T.let(nil, ::T.untyped)
Separator = ::T.let(nil, ::T.untyped)
end
class File::Stat
def size?(); end
end
class File
def self.cleanpath(path, rel_root=T.unsafe(nil)); end
def self.empty?(_); end
def self.exists?(_); end
def self.lutime(*_); end
def self.mkfifo(*_); end
def self.open!(file, *args, &block); end
def self.read_binary(file); end
def self.relative_path(from, to); end
end
FileList = Rake::FileList
module FileUtils
include ::FileUtils::StreamUtils_
def ruby(*args, **options, &block); end
def safe_ln(*args, **options); end
def sh(*cmd, &block); end
def split_all(path); end
LN_SUPPORTED = ::T.let(nil, ::T.untyped)
RUBY = ::T.let(nil, ::T.untyped)
end
module FileUtils::DryRun
include ::FileUtils
include ::FileUtils::StreamUtils_
include ::FileUtils::LowMethods
end
module FileUtils::DryRun
extend ::FileUtils::DryRun
extend ::FileUtils
extend ::FileUtils::StreamUtils_
extend ::FileUtils::LowMethods
end
module FileUtils::NoWrite
include ::FileUtils
include ::FileUtils::StreamUtils_
include ::FileUtils::LowMethods
end
module FileUtils::NoWrite
extend ::FileUtils::NoWrite
extend ::FileUtils
extend ::FileUtils::StreamUtils_
extend ::FileUtils::LowMethods
end
module FileUtils::Verbose
include ::FileUtils
include ::FileUtils::StreamUtils_
end
module FileUtils::Verbose
extend ::FileUtils::Verbose
extend ::FileUtils
extend ::FileUtils::StreamUtils_
end
module FileUtils
extend ::FileUtils::StreamUtils_
end
module Find
end
module Find
def self.find(*paths, ignore_error: T.unsafe(nil)); end
def self.prune(); end
end
class Float
include ::JSON::Ext::Generator::GeneratorMethods::Float
end
module Forwardable
def def_delegator(accessor, method, ali=T.unsafe(nil)); end
def def_delegators(accessor, *methods); end
def def_instance_delegator(accessor, method, ali=T.unsafe(nil)); end
def def_instance_delegators(accessor, *methods); end
def delegate(hash); end
def instance_delegate(hash); end
VERSION = ::T.let(nil, ::T.untyped)
end
module Forwardable
def self._compile_method(src, file, line); end
def self._delegator_method(obj, accessor, method, ali); end
def self._valid_method?(method); end
def self.debug(); end
def self.debug=(debug); end
end
module GC
def garbage_collect(*_); end
end
module GC
def self.latest_gc_info(*_); end
def self.stress=(stress); end
def self.verify_internal_consistency(); end
def self.verify_transient_heap_internal_consistency(); end
end
class Gem::Package::TarHeader
def self.oct_or_256based(str); end
end
class Gem::RemoteFetcher
def s3_uri_signer(uri); end
end
class Gem::RemoteFetcher::FetchError
def initialize(message, uri); end
def uri(); end
def uri=(uri); end
end
class Gem::RemoteFetcher::FetchError
end
class Gem::RemoteFetcher::UnknownHostError
end
class Gem::RemoteFetcher::UnknownHostError
end
class Gem::Resolver::Molinillo::DependencyGraph::Log
extend ::Enumerable
end
class Gem::S3URISigner
def initialize(uri); end
def sign(expiration=T.unsafe(nil)); end
def uri(); end
def uri=(uri); end
BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped)
EC2_METADATA_CREDENTIALS = ::T.let(nil, ::T.untyped)
end
class Gem::S3URISigner::ConfigurationError
def initialize(message); end
end
class Gem::S3URISigner::ConfigurationError
end
class Gem::S3URISigner::InstanceProfileError
def initialize(message); end
end
class Gem::S3URISigner::InstanceProfileError
end
class Gem::S3URISigner::S3Config
def access_key_id(); end
def access_key_id=(_); end
def region(); end
def region=(_); end
def secret_access_key(); end
def secret_access_key=(_); end
def security_token(); end
def security_token=(_); end
end
class Gem::S3URISigner::S3Config
def self.[](*_); end
def self.members(); end
end
class Gem::S3URISigner
end
class Gem::Specification
extend ::Enumerable
end
module Gem::Util
def self.correct_for_windows_path(path); end
end
module Gem
def self.source_index(); end
end
class Hash
include ::JSON::Ext::Generator::GeneratorMethods::Hash
def <(_); end
def <=(_); end
def >(_); end
def >=(_); end
def compact(); end
def compact!(); end
def default_proc(); end
def default_proc=(default_proc); end
def fetch_values(*_); end
def flatten(*_); end
def index(_); end
def replace(_); end
def slice(*_); end
def to_h(); end
def to_proc(); end
def transform_keys(); end
def transform_keys!(); end
def transform_values(); end
def transform_values!(); end
def update(*_); end
end
class Hash
def self.try_convert(_); end
end
module Hitimes
INSTANT_CONVERSION_FACTOR = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class Hitimes::Error
end
class Hitimes::Error
end
class Hitimes::Interval
def duration(); end
def duration_so_far(); end
def length(); end
def running?(); end
def split(); end
def start(); end
def start_instant(); end
def started?(); end
def stop(); end
def stop_instant(); end
def stopped?(); end
def to_f(); end
def to_seconds(); end
end
class Hitimes::Interval
def self.measure(); end
def self.now(); end
end
class Hitimes::Metric
def additional_data(); end
def initialize(name, additional_data=T.unsafe(nil)); end
def name(); end
def sampling_delta(); end
def sampling_start_time(); end
def sampling_stop_time(); end
def to_hash(); end
def utc_microseconds(); end
end
class Hitimes::Metric
end
class Hitimes::MutexedStats
def update(value); end
end
class Hitimes::MutexedStats
end
module Hitimes::Paths
end
module Hitimes::Paths
def self.lib_path(*args); end
def self.root_dir(); end
def self.sub_path(sub, *args); end
end
class Hitimes::Stats
def count(); end
def max(); end
def mean(); end
def min(); end
def rate(); end
def stddev(); end
def sum(); end
def sumsq(); end
def to_hash(*args); end
def to_json(*args); end
def update(_); end
STATS = ::T.let(nil, ::T.untyped)
end
class Hitimes::Stats
end
class Hitimes::TimedMetric
def count(*args, &block); end
def duration(*args, &block); end
def max(*args, &block); end
def mean(*args, &block); end
def measure(&block); end
def min(*args, &block); end
def rate(*args, &block); end
def running?(); end
def split(); end
def start(); end
def stats(); end
def stddev(*args, &block); end
def stop(); end
def sum(*args, &block); end
def sumsq(*args, &block); end
end
class Hitimes::TimedMetric
extend ::Forwardable
def self.now(name, additional_data=T.unsafe(nil)); end
end
class Hitimes::TimedValueMetric
def duration(); end
def measure(value, &block); end
def rate(); end
def running?(); end
def split(value); end
def start(); end
def stop(value); end
def timed_stats(); end
def unit_count(); end
def value_stats(); end
end
class Hitimes::TimedValueMetric
def self.now(name, additional_data=T.unsafe(nil)); end
end
class Hitimes::ValueMetric
def count(*args, &block); end
def max(*args, &block); end
def mean(*args, &block); end
def measure(value); end
def min(*args, &block); end
def stats(); end
def stddev(*args, &block); end
def sum(*args, &block); end
def sumsq(*args, &block); end
end
class Hitimes::ValueMetric
extend ::Forwardable
end
module Hitimes
def self.measure(&block); end
def self.raw_instant(); end
end
class IO
def beep(); end
def cooked(); end
def cooked!(); end
def cursor(); end
def cursor=(); end
def echo=(echo); end
def echo?(); end
def external_encoding(); end
def getch(*_); end
def getpass(*_); end
def goto(); end
def iflush(); end
def ioflush(); end
def noecho(); end
def nonblock(*_); end
def nonblock=(nonblock); end
def nonblock?(); end
def nread(); end
def oflush(); end
def pathconf(_); end
def pread(*_); end
def pressed?(); end
def pwrite(_, _1); end
def raw(*_); end
def raw!(*_); end
def ready?(); end
def wait(*_); end
def wait_readable(*_); end
def wait_writable(*_); end
def winsize(); end
def winsize=(winsize); end
def write_nonblock(buf, exception: T.unsafe(nil)); end
end
IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
class IO
def self.console(*_); end
def self.foreach(*_); end
end
class IPAddr
include ::Comparable
def &(other); end
def <<(num); end
def ==(other); end
def ===(other); end
def >>(num); end
def eql?(other); end
def family(); end
def hton(); end
def include?(other); end
def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
def ip6_arpa(); end
def ip6_int(); end
def ipv4?(); end
def ipv4_compat(); end
def ipv4_compat?(); end
def ipv4_mapped(); end
def ipv4_mapped?(); end
def ipv6?(); end
def link_local?(); end
def loopback?(); end
def mask(prefixlen); end
def mask!(mask); end
def native(); end
def prefix(); end
def prefix=(prefix); end
def private?(); end
def reverse(); end
def set(addr, *family); end
def succ(); end
def to_i(); end
def to_range(); end
def to_string(); end
def |(other); end
def ~(); end
IN4MASK = ::T.let(nil, ::T.untyped)
IN6FORMAT = ::T.let(nil, ::T.untyped)
IN6MASK = ::T.let(nil, ::T.untyped)
RE_IPV4ADDRLIKE = ::T.let(nil, ::T.untyped)
RE_IPV6ADDRLIKE_COMPRESSED = ::T.let(nil, ::T.untyped)
RE_IPV6ADDRLIKE_FULL = ::T.let(nil, ::T.untyped)
end
class IPAddr::AddressFamilyError
end
class IPAddr::AddressFamilyError
end
class IPAddr::Error
end
class IPAddr::Error
end
class IPAddr::InvalidAddressError
end
class IPAddr::InvalidAddressError
end
class IPAddr::InvalidPrefixError
end
class IPAddr::InvalidPrefixError
end
class IPAddr
def self.new_ntoh(addr); end
def self.ntop(addr); end
end
class Integer
include ::JSON::Ext::Generator::GeneratorMethods::Integer
def allbits?(_); end
def anybits?(_); end
def digits(*_); end
def nobits?(_); end
def pow(*_); end
def to_bn(); end
GMP_VERSION = ::T.let(nil, ::T.untyped)
end
class Integer
def self.sqrt(_); end
end
class JSON::Ext::Generator::State
def self.from_state(_); end
end
class JSON::Ext::Parser
def initialize(*_); end
end
JSON::Parser = JSON::Ext::Parser
JSON::State = JSON::Ext::Generator::State
JSON::UnparserError = JSON::GeneratorError
JSONTree = Psych::Visitors::JSONTree
module JaroWinkler
VERSION = ::T.let(nil, ::T.untyped)
end
class JaroWinkler::Error
end
class JaroWinkler::Error
end
class JaroWinkler::InvalidWeightError
end
class JaroWinkler::InvalidWeightError
end
module JaroWinkler
def self.distance(*_); end
def self.jaro_distance(*_); end
end
module Kernel
def gem(dep, *reqs); end
def itself(); end
def object_id(); end
def pretty_inspect(); end
def then(); end
def yield_self(); end
end
module Kernel
def self.at_exit(); end
end
class KeyError
include ::DidYouMean::Correctable
def key(); end
def receiver(); end
end
class LoadError
def path(); end
end
class LocalJumpError
def exit_value(); end
def reason(); end
end
class Logger
SEV_LABEL = ::T.let(nil, ::T.untyped)
end
class Logger::Formatter
Format = ::T.let(nil, ::T.untyped)
end
class Logger::LogDevice
include ::MonitorMixin
end
module Logger::Period
SiD = ::T.let(nil, ::T.untyped)
end
module Marshal
def self.restore(*_); end
end
module Metriks
VERSION = ::T.let(nil, ::T.untyped)
end
class Metriks::Counter
def clear(); end
def count(); end
def decrement(decr=T.unsafe(nil)); end
def increment(incr=T.unsafe(nil)); end
end
class Metriks::Counter
end
class Metriks::EWMA
def clear(); end
def initialize(alpha, interval); end
def rate(); end
def tick(); end
def update(value); end
FIFTEEN_MINUTES = ::T.let(nil, ::T.untyped)
FIVE_MINUTES = ::T.let(nil, ::T.untyped)
INTERVAL = ::T.let(nil, ::T.untyped)
M15_ALPHA = ::T.let(nil, ::T.untyped)
M1_ALPHA = ::T.let(nil, ::T.untyped)
M5_ALPHA = ::T.let(nil, ::T.untyped)
ONE_MINUTE = ::T.let(nil, ::T.untyped)
SECONDS_PER_MINUTE = ::T.let(nil, ::T.untyped)
end
class Metriks::EWMA
def self.new_m1(); end
def self.new_m15(); end
def self.new_m5(); end
end
class Metriks::ExponentiallyDecayingSample
def clear(); end
def initialize(reservoir_size, alpha, values=T.unsafe(nil)); end
def rescale(now, next_time); end
def size(); end
def snapshot(); end
def update(value, timestamp=T.unsafe(nil)); end
def weight(time); end
RESCALE_THRESHOLD = ::T.let(nil, ::T.untyped)
end
class Metriks::ExponentiallyDecayingSample
end
class Metriks::Gauge
def initialize(callable=T.unsafe(nil), &block); end
def set(val); end
def value(); end
end
class Metriks::Gauge
end
class Metriks::Histogram
def clear(); end
def count(); end
def initialize(sample); end
def max(); end
def max=(potential_max); end
def mean(); end
def min(); end
def min=(potential_min); end
def snapshot(); end
def stddev(); end
def sum(); end
def update(value); end
def update_variance(value); end
def variance(); end
DEFAULT_ALPHA = ::T.let(nil, ::T.untyped)
DEFAULT_SAMPLE_SIZE = ::T.let(nil, ::T.untyped)
end
class Metriks::Histogram
def self.new_exponentially_decaying(); end
def self.new_uniform(); end
end
class Metriks::Meter
def clear(); end
def count(); end
def fifteen_minute_rate(); end
def five_minute_rate(); end
def initialize(averager_klass=T.unsafe(nil)); end
def mark(val=T.unsafe(nil)); end
def mean_rate(); end
def one_minute_rate(); end
def stop(); end
def tick(); end
def tick_if_nessesary(); end
TICK_INTERVAL = ::T.let(nil, ::T.untyped)
end
class Metriks::Meter
end
class Metriks::Registry
def add(name, metric); end
def add_or_get(name, klass, &create_metric); end
def clear(); end
def counter(name); end
def each(&block); end
def gauge(name, callable=T.unsafe(nil), &block); end
def get(name); end
def histogram(name); end
def meter(name); end
def stop(); end
def timer(name); end
def utilization_timer(name); end
end
class Metriks::Registry
def self.default(); end
end
module Metriks::Reporter
end
class Metriks::Reporter::Graphite
def host(); end
def initialize(host, port, options=T.unsafe(nil)); end
def port(); end
def restart(); end
def socket(); end
def start(); end
def stop(); end
def write(); end
def write_metric(base_name, metric, keys, snapshot_keys=T.unsafe(nil)); end
end
class Metriks::Reporter::Graphite
end
class Metriks::Reporter::ProcTitle
def add(name, suffix=T.unsafe(nil), &block); end
def empty?(); end
def generate_title(); end
def initialize(options=T.unsafe(nil)); end
def restart(); end
def start(); end
def stop(); end
end
class Metriks::Reporter::ProcTitle
end
module Metriks::Reporter
end
class Metriks::Snapshot
def get_75th_percentile(); end
def get_95th_percentile(); end
def get_98th_percentile(); end
def get_999th_percentile(); end
def get_99th_percentile(); end
def initialize(values); end
def median(); end
def size(); end
def value(quantile); end
def values(); end
MEDIAN_Q = ::T.let(nil, ::T.untyped)
P75_Q = ::T.let(nil, ::T.untyped)
P95_Q = ::T.let(nil, ::T.untyped)
P98_Q = ::T.let(nil, ::T.untyped)
P999_Q = ::T.let(nil, ::T.untyped)
P99_Q = ::T.let(nil, ::T.untyped)
end
class Metriks::Snapshot
end
class Metriks::Timer
def clear(); end
def count(); end
def fifteen_minute_rate(); end
def five_minute_rate(); end
def initialize(histogram=T.unsafe(nil)); end
def max(); end
def mean(); end
def mean_rate(); end
def min(); end
def one_minute_rate(); end
def snapshot(); end
def stddev(); end
def stop(); end
def sum(); end
def time(callable=T.unsafe(nil), &block); end
def update(duration); end
end
class Metriks::Timer::Context
def initialize(timer); end
def restart(); end
def stop(); end
end
class Metriks::Timer::Context
end
class Metriks::Timer
end
class Metriks::UniformSample
def clear(); end
def initialize(reservoir_size); end
def size(); end
def snapshot(); end
def update(value); end
end
class Metriks::UniformSample
end
class Metriks::UtilizationTimer
def fifteen_minute_utilization(); end
def five_minute_utilization(); end
def initialize(); end
def mean_utilization(); end
def one_minute_utilization(); end
end
class Metriks::UtilizationTimer
end
module Metriks
def self.counter(name); end
def self.gauge(name, callable=T.unsafe(nil), &block); end
def self.get(name); end
def self.histogram(name); end
def self.meter(name); end
def self.timer(name); end
def self.utilization_timer(name); end
end
class Module
def class_name(); end
def context(*a, &b); end
def deprecate_constant(*_); end
def describe(*a, &b); end
def example_group(*a, &b); end
def fcontext(*a, &b); end
def fdescribe(*a, &b); end
def rake_extension(method); end
def shared_context(name, *args, &block); end
def shared_examples(name, *args, &block); end
def shared_examples_for(name, *args, &block); end
def undef_method(*_); end
def xcontext(*a, &b); end
def xdescribe(*a, &b); end
end
class Module
def self.used_modules(); end
end
class Monitor
def enter(); end
def exit(); end
def try_enter(); end
end
module MonitorMixin
def initialize(*args); end
def mon_enter(); end
def mon_exit(); end
def mon_locked?(); end
def mon_owned?(); end
def mon_synchronize(); end
def mon_try_enter(); end
def new_cond(); end
def synchronize(); end
def try_mon_enter(); end
EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
end
class MonitorMixin::ConditionVariable
def broadcast(); end
def initialize(monitor); end
def signal(); end
def wait(timeout=T.unsafe(nil)); end
def wait_until(); end
def wait_while(); end
end
module MonitorMixin
def self.extend_object(obj); end
end
class NameError
include ::DidYouMean::Correctable
def name(); end
def receiver(); end
end
class Net::BufferedIO
def write_timeout(); end
def write_timeout=(write_timeout); end
end
class Net::HTTP
def max_retries(); end
def max_retries=(retries); end
def max_version(); end
def max_version=(max_version); end
def min_version(); end
def min_version=(min_version); end
def write_timeout(); end
def write_timeout=(sec); end
ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped)
end
class Net::HTTPAlreadyReported
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPAlreadyReported
end
class Net::HTTPClientError
end
Net::HTTPClientErrorCode::EXCEPTION_TYPE = Net::HTTPServerException
class Net::HTTPClientError
end
Net::HTTPClientException = Net::HTTPServerException
class Net::HTTPEarlyHints
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPEarlyHints
end
Net::HTTPFatalErrorCode = Net::HTTPClientError
class Net::HTTPGatewayTimeout
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPGatewayTimeout
end
Net::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError
Net::HTTPInformationCode = Net::HTTPInformation
class Net::HTTPLoopDetected
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPLoopDetected
end
class Net::HTTPMisdirectedRequest
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPMisdirectedRequest
end
Net::HTTPMovedTemporarily = Net::HTTPFound
Net::HTTPMultipleChoice = Net::HTTPMultipleChoices
class Net::HTTPNotExtended
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPNotExtended
end
class Net::HTTPPayloadTooLarge
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPPayloadTooLarge
end
class Net::HTTPProcessing
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPProcessing
end
class Net::HTTPRangeNotSatisfiable
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPRangeNotSatisfiable
end
class Net::HTTPRedirection
end
Net::HTTPRedirectionCode::EXCEPTION_TYPE = Net::HTTPRetriableError
class Net::HTTPRedirection
end
class Net::HTTPRequestTimeout
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPRequestTimeout
end
Net::HTTPRequestURITooLarge = Net::HTTPURITooLong
Net::HTTPResponceReceiver = Net::HTTPResponse
Net::HTTPRetriableCode = Net::HTTPRedirection
class Net::HTTPServerError
end
Net::HTTPServerErrorCode::EXCEPTION_TYPE = Net::HTTPFatalError
class Net::HTTPServerError
end
class Net::HTTP
end
Net::HTTPSession::ProxyDelta = Net::HTTP::ProxyDelta
Net::HTTPSession::ProxyMod = Net::HTTP::ProxyDelta
class Net::HTTP
end
class Net::HTTPSuccess
end
Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError
class Net::HTTPSuccess
end
class Net::HTTPURITooLong
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPURITooLong
end
Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError
class Net::HTTPVariantAlsoNegotiates
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPVariantAlsoNegotiates
end
Net::NetPrivate::HTTPRequest = Net::HTTPRequest
Net::NetPrivate::Socket = Net::InternetMessageIO
Net::ProtocRetryError = Net::ProtoRetriableError
class Net::ReadTimeout
def initialize(io=T.unsafe(nil)); end
def io(); end
end
class Net::WriteTimeout
def initialize(io=T.unsafe(nil)); end
def io(); end
end
class Net::WriteTimeout
end
class NilClass
include ::JSON::Ext::Generator::GeneratorMethods::NilClass
def to_i(); end
end
class NoMethodError
def args(); end
def private_call?(); end
end
class Object
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
def dclone(); end
def to_yaml(options=T.unsafe(nil)); end
ARGF = ::T.let(nil, ::T.untyped)
ARGV = ::T.let(nil, ::T.untyped)
CROSS_COMPILING = ::T.let(nil, ::T.untyped)
CloseDiv = ::T.let(nil, ::T.untyped)
DecorativeClosing = ::T.let(nil, ::T.untyped)
ENV = ::T.let(nil, ::T.untyped)
OpenDiv = ::T.let(nil, ::T.untyped)
RUBY18 = ::T.let(nil, ::T.untyped)
RUBY19 = ::T.let(nil, ::T.untyped)
RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
RUBY_ENGINE = ::T.let(nil, ::T.untyped)
RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped)
RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped)
RUBY_PLATFORM = ::T.let(nil, ::T.untyped)
RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped)
RUBY_REVISION = ::T.let(nil, ::T.untyped)
RUBY_VERSION = ::T.let(nil, ::T.untyped)
STDERR = ::T.let(nil, ::T.untyped)
STDIN = ::T.let(nil, ::T.untyped)
STDOUT = ::T.let(nil, ::T.untyped)
StartPipe = ::T.let(nil, ::T.untyped)
TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
end
class Object
def self.yaml_tag(url); end
end
class ObjectSpace::WeakMap
def [](_); end
def []=(_, _1); end
def each(&blk); end
def each_key(); end
def each_pair(); end
def each_value(); end
def key?(_); end
def keys(); end
def length(); end
def size(); end
def values(); end
end
module ObjectSpace
def self.count_objects(*_); end
def self.define_finalizer(*_); end
def self.garbage_collect(*_); end
def self.undefine_finalizer(_); end
end
module Observable
def add_observer(observer, func=T.unsafe(nil)); end
def changed(state=T.unsafe(nil)); end
def changed?(); end
def count_observers(); end
def delete_observer(observer); end
def delete_observers(); end
def notify_observers(*arg); end
end
module Observable
end
class OpenSSL::ASN1::ASN1Data
def indefinite_length(); end
def indefinite_length=(indefinite_length); end
end
class OpenSSL::BN
def +@(); end
def -@(); end
def /(_); end
def negative?(); end
end
module OpenSSL::KDF
end
class OpenSSL::KDF::KDFError
end
class OpenSSL::KDF::KDFError
end
module OpenSSL::KDF
def self.hkdf(*_); end
def self.pbkdf2_hmac(*_); end
def self.scrypt(*_); end
end
class OpenSSL::OCSP::Request
def signed?(); end
end
OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo
class OpenSSL::PKey::EC
EXPLICIT_CURVE = ::T.let(nil, ::T.untyped)
end
class OpenSSL::PKey::EC::Point
def to_octet_string(_); end
end
class OpenSSL::PKey::RSA
def sign_pss(*_); end
def verify_pss(*_); end
end
module OpenSSL::SSL
OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped)
OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped)
OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped)
OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped)
OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped)
OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped)
OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped)
SSL2_VERSION = ::T.let(nil, ::T.untyped)
SSL3_VERSION = ::T.let(nil, ::T.untyped)
TLS1_1_VERSION = ::T.let(nil, ::T.untyped)
TLS1_2_VERSION = ::T.let(nil, ::T.untyped)
TLS1_VERSION = ::T.let(nil, ::T.untyped)
end
class OpenSSL::SSL::SSLContext
def add_certificate(*_); end
def alpn_protocols(); end
def alpn_protocols=(alpn_protocols); end
def alpn_select_cb(); end
def alpn_select_cb=(alpn_select_cb); end
def enable_fallback_scsv(); end
def max_version=(version); end
def min_version=(version); end
DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped)
end
class OpenSSL::SSL::SSLSocket
def alpn_protocol(); end
def tmp_key(); end
end
module OpenSSL::X509
V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
end
class OpenSSL::X509::Attribute
def ==(other); end
end
class OpenSSL::X509::CRL
def ==(other); end
end
class OpenSSL::X509::Extension
def ==(other); end
end
class OpenSSL::X509::Name
def to_utf8(); end
end
class OpenSSL::X509::Request
def ==(other); end
end
class OpenSSL::X509::Revoked
def ==(other); end
def to_der(); end
end
module OpenSSL
def self.fips_mode(); end
end
module OpenTracing
FORMAT_BINARY = ::T.let(nil, ::T.untyped)
FORMAT_RACK = ::T.let(nil, ::T.untyped)
FORMAT_TEXT_MAP = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class OpenTracing::Reference
def context(); end
def initialize(type, context); end
def type(); end
CHILD_OF = ::T.let(nil, ::T.untyped)
FOLLOWS_FROM = ::T.let(nil, ::T.untyped)
end
class OpenTracing::Reference
def self.child_of(context); end
def self.follows_from(context); end
end
class OpenTracing::Scope
def close(); end
def span(); end
NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
end
class OpenTracing::Scope
end
class OpenTracing::ScopeManager
def activate(span, finish_on_close: T.unsafe(nil)); end
def active(); end
NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
end
class OpenTracing::ScopeManager
end
class OpenTracing::Span
def context(); end
def finish(end_time: T.unsafe(nil)); end
def get_baggage_item(key); end
def log(event: T.unsafe(nil), timestamp: T.unsafe(nil), **fields); end
def log_kv(timestamp: T.unsafe(nil), **fields); end
def operation_name=(name); end
def set_baggage_item(key, value); end
def set_tag(key, value); end
NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
end
class OpenTracing::Span
end
class OpenTracing::SpanContext
def baggage(); end
def initialize(baggage: T.unsafe(nil)); end
NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
end
class OpenTracing::SpanContext
end
class OpenTracing::Tracer
def active_span(); end
def extract(format, carrier); end
def inject(span_context, format, carrier); end
def scope_manager(); end
def start_active_span(operation_name, child_of: T.unsafe(nil), references: T.unsafe(nil), start_time: T.unsafe(nil), tags: T.unsafe(nil), ignore_active_scope: T.unsafe(nil), finish_on_close: T.unsafe(nil)); end
def start_span(operation_name, child_of: T.unsafe(nil), references: T.unsafe(nil), start_time: T.unsafe(nil), tags: T.unsafe(nil), ignore_active_scope: T.unsafe(nil)); end
end
class OpenTracing::Tracer
end
module OpenTracing
def self.active_span(*args, &block); end
def self.extract(*args, &block); end
def self.global_tracer(); end
def self.global_tracer=(global_tracer); end
def self.inject(*args, &block); end
def self.scope_manager(*args, &block); end
def self.start_active_span(*args, &block); end
def self.start_span(*args, &block); end
end
module Parallel
Stop = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
Version = ::T.let(nil, ::T.untyped)
end
class Parallel::Break
end
class Parallel::Break
end
class Parallel::DeadWorker
end
class Parallel::DeadWorker
end
class Parallel::ExceptionWrapper
def exception(); end
def initialize(exception); end
end
class Parallel::ExceptionWrapper
end
class Parallel::JobFactory
def initialize(source, mutex); end
def next(); end
def pack(item, index); end
def size(); end
def unpack(data); end
end
class Parallel::JobFactory
end
class Parallel::Kill
end
class Parallel::Kill
end
module Parallel::ProcessorCount
def physical_processor_count(); end
def processor_count(); end
end
module Parallel::ProcessorCount
end
class Parallel::UndumpableException
def initialize(original); end
end
class Parallel::UndumpableException
end
class Parallel::UserInterruptHandler
INTERRUPT_SIGNAL = ::T.let(nil, ::T.untyped)
end
class Parallel::UserInterruptHandler
def self.kill(thing); end
def self.kill_on_ctrl_c(pids, options); end
end
class Parallel::Worker
def close_pipes(); end
def initialize(read, write, pid); end
def pid(); end
def read(); end
def stop(); end
def thread(); end
def thread=(thread); end
def work(data); end
def write(); end
end
class Parallel::Worker
end
module Parallel
extend ::Parallel::ProcessorCount
def self.all?(*args, &block); end
def self.any?(*args, &block); end
def self.each(array, options=T.unsafe(nil), &block); end
def self.each_with_index(array, options=T.unsafe(nil), &block); end
def self.flat_map(*args, &block); end
def self.in_processes(options=T.unsafe(nil), &block); end
def self.in_threads(options=T.unsafe(nil)); end
def self.map(source, options=T.unsafe(nil), &block); end
def self.map_with_index(array, options=T.unsafe(nil), &block); end
def self.worker_number(); end
def self.worker_number=(worker_num); end
end
ParseError = Racc::ParseError
module Parser
MESSAGES = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
module Parser::AST
end
class Parser::AST::Node
def loc(); end
def location(); end
end
class Parser::AST::Node
end
class Parser::AST::Processor
def on_alias(node); end
def on_and(node); end
def on_and_asgn(node); end
def on_arg(node); end
def on_arg_expr(node); end
def on_args(node); end
def on_argument(node); end
def on_array(node); end
def on_array_pattern(node); end
def on_array_pattern_with_tail(node); end
def on_back_ref(node); end
def on_begin(node); end
def on_block(node); end
def on_block_pass(node); end
def on_blockarg(node); end
def on_blockarg_expr(node); end
def on_break(node); end
def on_case(node); end
def on_case_match(node); end
def on_casgn(node); end
def on_class(node); end
def on_const(node); end
def on_const_pattern(node); end
def on_csend(node); end
def on_cvar(node); end
def on_cvasgn(node); end
def on_def(node); end
def on_defined?(node); end
def on_defs(node); end
def on_dstr(node); end
def on_dsym(node); end
def on_eflipflop(node); end
def on_empty_else(node); end
def on_ensure(node); end
def on_erange(node); end
def on_for(node); end
def on_gvar(node); end
def on_gvasgn(node); end
def on_hash(node); end
def on_hash_pattern(node); end
def on_if(node); end
def on_if_guard(node); end
def on_iflipflop(node); end
def on_in_match(node); end
def on_in_pattern(node); end
def on_index(node); end
def on_indexasgn(node); end
def on_irange(node); end
def on_ivar(node); end
def on_ivasgn(node); end
def on_kwarg(node); end
def on_kwbegin(node); end
def on_kwoptarg(node); end
def on_kwrestarg(node); end
def on_kwsplat(node); end
def on_lambda(node); end
def on_lvar(node); end
def on_lvasgn(node); end
def on_masgn(node); end
def on_match_alt(node); end
def on_match_as(node); end
def on_match_current_line(node); end
def on_match_rest(node); end
def on_match_var(node); end
def on_match_with_lvasgn(node); end
def on_mlhs(node); end
def on_module(node); end
def on_next(node); end
def on_not(node); end
def on_nth_ref(node); end
def on_numblock(node); end
def on_op_asgn(node); end
def on_optarg(node); end
def on_or(node); end
def on_or_asgn(node); end
def on_pair(node); end
def on_pin(node); end
def on_postexe(node); end
def on_preexe(node); end
def on_procarg0(node); end
def on_redo(node); end
def on_regexp(node); end
def on_resbody(node); end
def on_rescue(node); end
def on_restarg(node); end
def on_restarg_expr(node); end
def on_retry(node); end
def on_return(node); end
def on_sclass(node); end
def on_send(node); end
def on_shadowarg(node); end
def on_splat(node); end
def on_super(node); end
def on_undef(node); end
def on_unless_guard(node); end
def on_until(node); end
def on_until_post(node); end
def on_var(node); end
def on_vasgn(node); end
def on_when(node); end
def on_while(node); end
def on_while_post(node); end
def on_xstr(node); end
def on_yield(node); end
def process_argument_node(node); end
def process_regular_node(node); end
def process_var_asgn_node(node); end
def process_variable_node(node); end
end
class Parser::AST::Processor
end
module Parser::AST
end
class Parser::Base
def builder(); end
def context(); end
def current_arg_stack(); end
def diagnostics(); end
def initialize(builder=T.unsafe(nil)); end
def max_numparam_stack(); end
def parse(source_buffer); end
def parse_with_comments(source_buffer); end
def pattern_hash_keys(); end
def pattern_variables(); end
def reset(); end
def source_buffer(); end
def static_env(); end
def tokenize(source_buffer, recover=T.unsafe(nil)); end
end
class Parser::Base
def self.default_parser(); end
def self.parse(string, file=T.unsafe(nil), line=T.unsafe(nil)); end
def self.parse_file(filename); end
def self.parse_file_with_comments(filename); end
def self.parse_with_comments(string, file=T.unsafe(nil), line=T.unsafe(nil)); end
end
module Parser::Builders
end
class Parser::Builders::Default
def __ENCODING__(__ENCODING__t); end
def __FILE__(__FILE__t); end
def __LINE__(__LINE__t); end
def accessible(node); end
def alias(alias_t, to, from); end
def arg(name_t); end
def arg_expr(expr); end
def args(begin_t, args, end_t, check_args=T.unsafe(nil)); end
def array(begin_t, elements, end_t); end
def array_pattern(lbrack_t, elements, rbrack_t); end
def assign(lhs, eql_t, rhs); end
def assignable(node); end
def associate(begin_t, pairs, end_t); end
def attr_asgn(receiver, dot_t, selector_t); end
def back_ref(token); end
def begin(begin_t, body, end_t); end
def begin_body(compound_stmt, rescue_bodies=T.unsafe(nil), else_t=T.unsafe(nil), else_=T.unsafe(nil), ensure_t=T.unsafe(nil), ensure_=T.unsafe(nil)); end
def begin_keyword(begin_t, body, end_t); end
def binary_op(receiver, operator_t, arg); end
def block(method_call, begin_t, args, body, end_t); end
def block_pass(amper_t, arg); end
def blockarg(amper_t, name_t); end
def blockarg_expr(amper_t, expr); end
def call_lambda(lambda_t); end
def call_method(receiver, dot_t, selector_t, lparen_t=T.unsafe(nil), args=T.unsafe(nil), rparen_t=T.unsafe(nil)); end
def call_type_for_dot(dot_t); end
def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
def character(char_t); end
def complex(complex_t); end
def compstmt(statements); end
def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
def condition_mod(if_true, if_false, cond_t, cond); end
def const(name_t); end
def const_fetch(scope, t_colon2, name_t); end
def const_global(t_colon3, name_t); end
def const_op_assignable(node); end
def const_pattern(const, ldelim_t, pattern, rdelim_t); end
def cvar(token); end
def dedent_string(node, dedent_level); end
def def_class(class_t, name, lt_t, superclass, body, end_t); end
def def_method(def_t, name_t, args, body, end_t); end
def def_module(module_t, name, body, end_t); end
def def_sclass(class_t, lshft_t, expr, body, end_t); end
def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
def emit_file_line_as_literals(); end
def emit_file_line_as_literals=(emit_file_line_as_literals); end
def false(false_t); end
def float(float_t); end
def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
def forward_args(begin_t, dots_t, end_t); end
def forwarded_args(dots_t); end
def gvar(token); end
def hash_pattern(lbrace_t, kwargs, rbrace_t); end
def ident(token); end
def if_guard(if_t, if_body); end
def in_match(lhs, in_t, rhs); end
def in_pattern(in_t, pattern, guard, then_t, body); end
def index(receiver, lbrack_t, indexes, rbrack_t); end
def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
def integer(integer_t); end
def ivar(token); end
def keyword_cmd(type, keyword_t, lparen_t=T.unsafe(nil), args=T.unsafe(nil), rparen_t=T.unsafe(nil)); end
def kwarg(name_t); end
def kwnilarg(dstar_t, nil_t); end
def kwoptarg(name_t, value); end
def kwrestarg(dstar_t, name_t=T.unsafe(nil)); end
def kwsplat(dstar_t, arg); end
def logical_op(type, lhs, op_t, rhs); end
def loop(type, keyword_t, cond, do_t, body, end_t); end
def loop_mod(type, body, keyword_t, cond); end
def match_alt(left, pipe_t, right); end
def match_as(value, assoc_t, as); end
def match_hash_var(name_t); end
def match_hash_var_from_str(begin_t, strings, end_t); end
def match_label(label_type, label); end
def match_nil_pattern(dstar_t, nil_t); end
def match_op(receiver, match_t, arg); end
def match_pair(label_type, label, value); end
def match_rest(star_t, name_t=T.unsafe(nil)); end
def match_var(name_t); end
def match_with_trailing_comma(match); end
def multi_assign(lhs, eql_t, rhs); end
def multi_lhs(begin_t, items, end_t); end
def nil(nil_t); end
def not_op(not_t, begin_t=T.unsafe(nil), receiver=T.unsafe(nil), end_t=T.unsafe(nil)); end
def nth_ref(token); end
def numargs(max_numparam); end
def objc_kwarg(kwname_t, assoc_t, name_t); end
def objc_restarg(star_t, name=T.unsafe(nil)); end
def objc_varargs(pair, rest_of_varargs); end
def op_assign(lhs, op_t, rhs); end
def optarg(name_t, eql_t, value); end
def pair(key, assoc_t, value); end
def pair_keyword(key_t, value); end
def pair_list_18(list); end
def pair_quoted(begin_t, parts, end_t, value); end
def parser(); end
def parser=(parser); end
def pin(pin_t, var); end
def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
def procarg0(arg); end
def range_exclusive(lhs, dot3_t, rhs); end
def range_inclusive(lhs, dot2_t, rhs); end
def rational(rational_t); end
def regexp_compose(begin_t, parts, end_t, options); end
def regexp_options(regopt_t); end
def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
def restarg(star_t, name_t=T.unsafe(nil)); end
def restarg_expr(star_t, expr=T.unsafe(nil)); end
def self(token); end
def shadowarg(name_t); end
def splat(star_t, arg=T.unsafe(nil)); end
def string(string_t); end
def string_compose(begin_t, parts, end_t); end
def string_internal(string_t); end
def symbol(symbol_t); end
def symbol_compose(begin_t, parts, end_t); end
def symbol_internal(symbol_t); end
def symbols_compose(begin_t, parts, end_t); end
def ternary(cond, question_t, if_true, colon_t, if_false); end
def true(true_t); end
def unary_num(unary_t, numeric); end
def unary_op(op_t, receiver); end
def undef_method(undef_t, names); end
def unless_guard(unless_t, unless_body); end
def when(when_t, patterns, then_t, body); end
def word(parts); end
def words_compose(begin_t, parts, end_t); end
def xstring_compose(begin_t, parts, end_t); end
end
class Parser::Builders::Default
def self.emit_arg_inside_procarg0(); end
def self.emit_arg_inside_procarg0=(emit_arg_inside_procarg0); end
def self.emit_encoding(); end
def self.emit_encoding=(emit_encoding); end
def self.emit_index(); end
def self.emit_index=(emit_index); end
def self.emit_lambda(); end
def self.emit_lambda=(emit_lambda); end
def self.emit_procarg0(); end
def self.emit_procarg0=(emit_procarg0); end
def self.modernize(); end
end
module Parser::Builders
end
class Parser::ClobberingError
end
class Parser::ClobberingError
end
class Parser::Context
def class_definition_allowed?(); end
def dynamic_const_definition_allowed?(); end
def in_block?(); end
def in_class?(); end
def in_dynamic_block?(); end
def in_lambda?(); end
def indirectly_in_def?(); end
def module_definition_allowed?(); end
def pop(); end
def push(state); end
def reset(); end
def stack(); end
end
class Parser::Context
end
class Parser::CurrentArgStack
def pop(); end
def push(value); end
def reset(); end
def set(value); end
def stack(); end
def top(); end
end
class Parser::CurrentArgStack
end
module Parser::Deprecation
def warn_of_deprecation(); end
def warned_of_deprecation=(warned_of_deprecation); end
end
module Parser::Deprecation
end
class Parser::Diagnostic
def arguments(); end
def highlights(); end
def initialize(level, reason, arguments, location, highlights=T.unsafe(nil)); end
def level(); end
def location(); end
def message(); end
def reason(); end
def render(); end
LEVELS = ::T.let(nil, ::T.untyped)
end
class Parser::Diagnostic::Engine
def all_errors_are_fatal(); end
def all_errors_are_fatal=(all_errors_are_fatal); end
def consumer(); end
def consumer=(consumer); end
def ignore?(diagnostic); end
def ignore_warnings(); end
def ignore_warnings=(ignore_warnings); end
def initialize(consumer=T.unsafe(nil)); end
def process(diagnostic); end
def raise?(diagnostic); end
end
class Parser::Diagnostic::Engine
end
class Parser::Diagnostic
end
class Parser::Lexer
def advance(); end
def arg_or_cmdarg(cmd_state); end
def cmdarg(); end
def cmdarg=(cmdarg); end
def command_start(); end
def command_start=(command_start); end
def comments(); end
def comments=(comments); end
def cond(); end
def cond=(cond); end
def context(); end
def context=(context); end
def dedent_level(); end
def diagnostic(type, reason, arguments=T.unsafe(nil), location=T.unsafe(nil), highlights=T.unsafe(nil)); end
def diagnostics(); end
def diagnostics=(diagnostics); end
def emit(type, value=T.unsafe(nil), s=T.unsafe(nil), e=T.unsafe(nil)); end
def emit_comment(s=T.unsafe(nil), e=T.unsafe(nil)); end
def emit_do(do_block=T.unsafe(nil)); end
def emit_table(table, s=T.unsafe(nil), e=T.unsafe(nil)); end
def encode_escape(ord); end
def encoding(); end
def eof_codepoint?(point); end
def force_utf32(); end
def force_utf32=(force_utf32); end
def in_kwarg(); end
def in_kwarg=(in_kwarg); end
def initialize(version); end
def literal(); end
def next_state_for_literal(literal); end
def pop_cmdarg(); end
def pop_cond(); end
def pop_literal(); end
def push_cmdarg(); end
def push_cond(); end
def push_literal(*args); end
def range(s=T.unsafe(nil), e=T.unsafe(nil)); end
def reset(reset_state=T.unsafe(nil)); end
def source_buffer(); end
def source_buffer=(source_buffer); end
def stack_pop(); end
def state(); end
def state=(state); end
def static_env(); end
def static_env=(static_env); end
def tok(s=T.unsafe(nil), e=T.unsafe(nil)); end
def tokens(); end
def tokens=(tokens); end
def version?(*versions); end
ESCAPES = ::T.let(nil, ::T.untyped)
KEYWORDS = ::T.let(nil, ::T.untyped)
KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped)
LEX_STATES = ::T.let(nil, ::T.untyped)
PUNCTUATION = ::T.let(nil, ::T.untyped)
PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped)
REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped)
end
class Parser::Lexer::Dedenter
def dedent(string); end
def initialize(dedent_level); end
def interrupt(); end
TAB_WIDTH = ::T.let(nil, ::T.untyped)
end
class Parser::Lexer::Dedenter
end
class Parser::Lexer::Literal
def backslash_delimited?(); end
def clear_buffer(); end
def coerce_encoding(string); end
def dedent_level(); end
def delimiter?(delimiter); end
def emit(token, type, s, e); end
def emit_start_tok(); end
def end_interp_brace_and_try_closing(); end
def extend_content(); end
def extend_space(ts, te); end
def extend_string(string, ts, te); end
def flush_string(); end
def heredoc?(); end
def heredoc_e(); end
def infer_indent_level(line); end
def initialize(lexer, str_type, delimiter, str_s, heredoc_e=T.unsafe(nil), indent=T.unsafe(nil), dedent_body=T.unsafe(nil), label_allowed=T.unsafe(nil)); end
def interpolate?(); end
def munge_escape?(character); end
def nest_and_try_closing(delimiter, ts, te, lookahead=T.unsafe(nil)); end
def plain_heredoc?(); end
def regexp?(); end
def saved_herebody_s(); end
def saved_herebody_s=(saved_herebody_s); end
def squiggly_heredoc?(); end
def start_interp_brace(); end
def str_s(); end
def supports_line_continuation_via_slash?(); end
def type(); end
def words?(); end
DELIMITERS = ::T.let(nil, ::T.untyped)
TYPES = ::T.let(nil, ::T.untyped)
end
class Parser::Lexer::Literal
end
class Parser::Lexer::StackState
def active?(); end
def clear(); end
def empty?(); end
def initialize(name); end
def lexpop(); end
def pop(); end
def push(bit); end
end
class Parser::Lexer::StackState
end
class Parser::Lexer
def self.lex_en_expr_arg(); end
def self.lex_en_expr_arg=(lex_en_expr_arg); end
def self.lex_en_expr_beg(); end
def self.lex_en_expr_beg=(lex_en_expr_beg); end
def self.lex_en_expr_cmdarg(); end
def self.lex_en_expr_cmdarg=(lex_en_expr_cmdarg); end
def self.lex_en_expr_dot(); end
def self.lex_en_expr_dot=(lex_en_expr_dot); end
def self.lex_en_expr_end(); end
def self.lex_en_expr_end=(lex_en_expr_end); end
def self.lex_en_expr_endarg(); end
def self.lex_en_expr_endarg=(lex_en_expr_endarg); end
def self.lex_en_expr_endfn(); end
def self.lex_en_expr_endfn=(lex_en_expr_endfn); end
def self.lex_en_expr_fname(); end
def self.lex_en_expr_fname=(lex_en_expr_fname); end
def self.lex_en_expr_labelarg(); end
def self.lex_en_expr_labelarg=(lex_en_expr_labelarg); end
def self.lex_en_expr_mid(); end
def self.lex_en_expr_mid=(lex_en_expr_mid); end
def self.lex_en_expr_value(); end
def self.lex_en_expr_value=(lex_en_expr_value); end
def self.lex_en_expr_variable(); end
def self.lex_en_expr_variable=(lex_en_expr_variable); end
def self.lex_en_interp_backslash_delimited(); end
def self.lex_en_interp_backslash_delimited=(lex_en_interp_backslash_delimited); end
def self.lex_en_interp_backslash_delimited_words(); end
def self.lex_en_interp_backslash_delimited_words=(lex_en_interp_backslash_delimited_words); end
def self.lex_en_interp_string(); end
def self.lex_en_interp_string=(lex_en_interp_string); end
def self.lex_en_interp_words(); end
def self.lex_en_interp_words=(lex_en_interp_words); end
def self.lex_en_leading_dot(); end
def self.lex_en_leading_dot=(lex_en_leading_dot); end
def self.lex_en_line_begin(); end
def self.lex_en_line_begin=(lex_en_line_begin); end
def self.lex_en_line_comment(); end
def self.lex_en_line_comment=(lex_en_line_comment); end
def self.lex_en_plain_backslash_delimited(); end
def self.lex_en_plain_backslash_delimited=(lex_en_plain_backslash_delimited); end
def self.lex_en_plain_backslash_delimited_words(); end
def self.lex_en_plain_backslash_delimited_words=(lex_en_plain_backslash_delimited_words); end
def self.lex_en_plain_string(); end
def self.lex_en_plain_string=(lex_en_plain_string); end
def self.lex_en_plain_words(); end
def self.lex_en_plain_words=(lex_en_plain_words); end
def self.lex_en_regexp_modifiers(); end
def self.lex_en_regexp_modifiers=(lex_en_regexp_modifiers); end
def self.lex_error(); end
def self.lex_error=(lex_error); end
def self.lex_start(); end
def self.lex_start=(lex_start); end
end
class Parser::MaxNumparamStack
def has_numparams?(); end
def has_ordinary_params!(); end
def has_ordinary_params?(); end
def pop(); end
def push(); end
def register(numparam); end
def stack(); end
def top(); end
end
class Parser::MaxNumparamStack
end
module Parser::Meta
NODE_TYPES = ::T.let(nil, ::T.untyped)
end
module Parser::Meta
end
class Parser::Rewriter
def assignment?(node); end
def initialize(*_); end
def insert_after(range, content); end
def insert_before(range, content); end
def remove(range); end
def replace(range, content); end
def rewrite(source_buffer, ast); end
def wrap(range, before, after); end
DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
end
class Parser::Rewriter
extend ::Parser::Deprecation
end
module Parser::Source
end
class Parser::Source::Buffer
def column_for_position(position); end
def decompose_position(position); end
def first_line(); end
def initialize(name, first_line=T.unsafe(nil)); end
def last_line(); end
def line_for_position(position); end
def line_range(lineno); end
def name(); end
def raw_source=(input); end
def read(); end
def slice(range); end
def source(); end
def source=(input); end
def source_line(lineno); end
def source_lines(); end
def source_range(); end
ENCODING_RE = ::T.let(nil, ::T.untyped)
end
class Parser::Source::Buffer
def self.recognize_encoding(string); end
def self.reencode_string(input); end
end
class Parser::Source::Comment
def ==(other); end
def document?(); end
def initialize(range); end
def inline?(); end
def loc(); end
def location(); end
def text(); end
def type(); end
end
class Parser::Source::Comment::Associator
def associate(); end
def associate_locations(); end
def initialize(ast, comments); end
def skip_directives(); end
def skip_directives=(skip_directives); end
MAGIC_COMMENT_RE = ::T.let(nil, ::T.untyped)
end
class Parser::Source::Comment::Associator
end
class Parser::Source::Comment
def self.associate(ast, comments); end
def self.associate_locations(ast, comments); end
end
class Parser::Source::Map
def ==(other); end
def column(); end
def expression(); end
def first_line(); end
def initialize(expression); end
def last_column(); end
def last_line(); end
def line(); end
def node(); end
def node=(node); end
def to_hash(); end
def update_expression(expression_l); end
def with(&block); end
def with_expression(expression_l); end
end
class Parser::Source::Map::Collection
def begin(); end
def end(); end
def initialize(begin_l, end_l, expression_l); end
end
class Parser::Source::Map::Collection
end
class Parser::Source::Map::Condition
def begin(); end
def else(); end
def end(); end
def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
def keyword(); end
end
class Parser::Source::Map::Condition
end
class Parser::Source::Map::Constant
def double_colon(); end
def initialize(double_colon, name, expression); end
def name(); end
def operator(); end
def update_operator(operator_l); end
def with_operator(operator_l); end
end
class Parser::Source::Map::Constant
end
class Parser::Source::Map::Definition
def end(); end
def initialize(keyword_l, operator_l, name_l, end_l); end
def keyword(); end
def name(); end
def operator(); end
end
class Parser::Source::Map::Definition
end
class Parser::Source::Map::For
def begin(); end
def end(); end
def in(); end
def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
def keyword(); end
end
class Parser::Source::Map::For
end
class Parser::Source::Map::Heredoc
def heredoc_body(); end
def heredoc_end(); end
def initialize(begin_l, body_l, end_l); end
end
class Parser::Source::Map::Heredoc
end
class Parser::Source::Map::Index
def begin(); end
def end(); end
def initialize(begin_l, end_l, expression_l); end
def operator(); end
def update_operator(operator_l); end
def with_operator(operator_l); end
end
class Parser::Source::Map::Index
end
class Parser::Source::Map::Keyword
def begin(); end
def end(); end
def initialize(keyword_l, begin_l, end_l, expression_l); end
def keyword(); end
end
class Parser::Source::Map::Keyword
end
class Parser::Source::Map::ObjcKwarg
def argument(); end
def initialize(keyword_l, operator_l, argument_l, expression_l); end
def keyword(); end
def operator(); end
end
class Parser::Source::Map::ObjcKwarg
end
class Parser::Source::Map::Operator
def initialize(operator, expression); end
def operator(); end
end
class Parser::Source::Map::Operator
end
class Parser::Source::Map::RescueBody
def assoc(); end
def begin(); end
def initialize(keyword_l, assoc_l, begin_l, expression_l); end
def keyword(); end
end
class Parser::Source::Map::RescueBody
end
class Parser::Source::Map::Send
def begin(); end
def dot(); end
def end(); end
def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
def operator(); end
def selector(); end
def update_operator(operator_l); end
def with_operator(operator_l); end
end
class Parser::Source::Map::Send
end
class Parser::Source::Map::Ternary
def colon(); end
def initialize(question_l, colon_l, expression_l); end
def question(); end
end
class Parser::Source::Map::Ternary
end
class Parser::Source::Map::Variable
def initialize(name_l, expression_l=T.unsafe(nil)); end
def name(); end
def operator(); end
def update_operator(operator_l); end
def with_operator(operator_l); end
end
class Parser::Source::Map::Variable
end
class Parser::Source::Map
end
class Parser::Source::Range
include ::Comparable
def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
def begin(); end
def begin_pos(); end
def column(); end
def column_range(); end
def contained?(other); end
def contains?(other); end
def crossing?(other); end
def disjoint?(other); end
def empty?(); end
def end(); end
def end_pos(); end
def first_line(); end
def initialize(source_buffer, begin_pos, end_pos); end
def intersect(other); end
def is?(*what); end
def join(other); end
def last_column(); end
def last_line(); end
def length(); end
def line(); end
def overlaps?(other); end
def resize(new_size); end
def size(); end
def source(); end
def source_buffer(); end
def source_line(); end
def to_a(); end
def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
end
class Parser::Source::Range
end
class Parser::Source::Rewriter
def diagnostics(); end
def initialize(source_buffer); end
def insert_after(range, content); end
def insert_after_multi(range, content); end
def insert_before(range, content); end
def insert_before_multi(range, content); end
def process(); end
def remove(range); end
def replace(range, content); end
def source_buffer(); end
def transaction(); end
def wrap(range, before, after); end
DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
end
class Parser::Source::Rewriter::Action
include ::Comparable
def allow_multiple_insertions(); end
def allow_multiple_insertions?(); end
def initialize(range, replacement=T.unsafe(nil), allow_multiple_insertions=T.unsafe(nil), order=T.unsafe(nil)); end
def order(); end
def range(); end
def replacement(); end
end
class Parser::Source::Rewriter::Action
end
class Parser::Source::Rewriter
extend ::Parser::Deprecation
end
class Parser::Source::TreeRewriter
def diagnostics(); end
def in_transaction?(); end
def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
def insert_after(range, content); end
def insert_after_multi(range, text); end
def insert_before(range, content); end
def insert_before_multi(range, text); end
def process(); end
def remove(range); end
def replace(range, content); end
def source_buffer(); end
def transaction(); end
def wrap(range, insert_before, insert_after); end
ACTIONS = ::T.let(nil, ::T.untyped)
DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped)
end
class Parser::Source::TreeRewriter::Action
def call_enforcer_for_merge(action); end
def combine(action); end
def do_combine(action); end
def fuse_deletions(action, fusible, other_sibblings); end
def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
def insert_after(); end
def insert_before(); end
def insertion?(); end
def merge(action); end
def ordered_replacements(); end
def place_in_hierarchy(action); end
def range(); end
def relationship_with(action); end
def replacement(); end
def swallow(children); end
def with(range: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
end
class Parser::Source::TreeRewriter::Action
end
class Parser::Source::TreeRewriter
extend ::Parser::Deprecation
end
module Parser::Source
end
class Parser::StaticEnvironment
def declare(name); end
def declare_forward_args(); end
def declared?(name); end
def declared_forward_args?(); end
def extend_dynamic(); end
def extend_static(); end
def reset(); end
def unextend(); end
FORWARD_ARGS = ::T.let(nil, ::T.untyped)
end
class Parser::StaticEnvironment
end
class Parser::SyntaxError
def diagnostic(); end
def initialize(diagnostic); end
end
class Parser::SyntaxError
end
class Parser::TreeRewriter
def assignment?(node); end
def insert_after(range, content); end
def insert_before(range, content); end
def remove(range); end
def replace(range, content); end
def rewrite(source_buffer, ast, **policy); end
def wrap(range, before, after); end
end
class Parser::TreeRewriter
end
class Parser::VariablesStack
def declare(name); end
def declared?(name); end
def pop(); end
def push(); end
def reset(); end
end
class Parser::VariablesStack
end
module Parser
end
class Pathname
def empty?(); end
def fnmatch?(*_); end
def glob(*_); end
def make_symlink(_); end
end
class Proc
def <<(_); end
def ===(*_); end
def >>(_); end
def clone(); end
def yield(*_); end
end
module Process::Sys
def self.getegid(); end
end
class Process::Tms
def cstime(); end
def cstime=(_); end
def cutime(); end
def cutime=(_); end
def stime(); end
def stime=(_); end
def utime(); end
def utime=(_); end
end
class Process::Tms
def self.[](*_); end
def self.members(); end
end
module Process
def self.last_status(); end
def self.setpgrp(); end
end
class ProgressBar
end
class ProgressBar::Base
def autofinish(); end
def autofinish=(autofinish); end
def autostart(); end
def autostart=(autostart); end
def bar(); end
def bar=(bar); end
def clear(*args, &block); end
def decrement(); end
def finish(); end
def finished(); end
def finished=(finished); end
def finished?(); end
def format(other); end
def format=(other); end
def increment(); end
def initialize(options=T.unsafe(nil)); end
def log(*args, &block); end
def output(); end
def output=(output); end
def pause(); end
def paused?(); end
def percentage(); end
def percentage=(percentage); end
def progress(*args, &block); end
def progress=(new_progress); end
def progress_mark=(mark); end
def progressable(); end
def progressable=(progressable); end
def rate(); end
def rate=(rate); end
def refresh(*args, &block); end
def remainder_mark=(mark); end
def reset(); end
def resume(); end
def start(options=T.unsafe(nil)); end
def started?(); end
def stop(); end
def stopped?(); end
def time(); end
def time=(time); end
def timer(); end
def timer=(timer); end
def title(); end
def title=(title); end
def title_comp(); end
def title_comp=(title_comp); end
def to_h(); end
def to_s(new_format=T.unsafe(nil)); end
def total(*args, &block); end
def total=(new_total); end
def update_progress(*args); end
end
class ProgressBar::Base
extend ::Forwardable
end
module ProgressBar::Calculators
end
class ProgressBar::Calculators::Length
def calculate_length(); end
def current_length(); end
def current_length=(current_length); end
def initialize(options=T.unsafe(nil)); end
def length(); end
def length_changed?(); end
def length_override(); end
def length_override=(other); end
def output(); end
def output=(output); end
def reset_length(); end
end
class ProgressBar::Calculators::Length
end
class ProgressBar::Calculators::RunningAverage
end
class ProgressBar::Calculators::RunningAverage
def self.calculate(current_average, new_value_to_average, smoothing_factor); end
end
module ProgressBar::Calculators
end
module ProgressBar::Components
end
class ProgressBar::Components::Bar
def initialize(options=T.unsafe(nil)); end
def length(); end
def length=(length); end
def progress(); end
def progress=(progress); end
def progress_mark(); end
def progress_mark=(progress_mark); end
def remainder_mark(); end
def remainder_mark=(remainder_mark); end
def to_s(options=T.unsafe(nil)); end
def upa_steps(); end
def upa_steps=(upa_steps); end
DEFAULT_PROGRESS_MARK = ::T.let(nil, ::T.untyped)
DEFAULT_REMAINDER_MARK = ::T.let(nil, ::T.untyped)
DEFAULT_UPA_STEPS = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Components::Bar
end
class ProgressBar::Components::Percentage
def initialize(options=T.unsafe(nil)); end
def progress(); end
def progress=(progress); end
end
class ProgressBar::Components::Percentage
end
class ProgressBar::Components::Rate
def initialize(options=T.unsafe(nil)); end
def progress(); end
def progress=(progress); end
def rate_scale(); end
def rate_scale=(rate_scale); end
def started_at(); end
def started_at=(started_at); end
def stopped_at(); end
def stopped_at=(stopped_at); end
def timer(); end
def timer=(timer); end
end
class ProgressBar::Components::Rate
end
class ProgressBar::Components::Time
def elapsed_with_label(); end
def estimated_with_friendly_oob(); end
def estimated_with_label(); end
def estimated_with_no_oob(); end
def estimated_with_unknown_oob(); end
def initialize(options=T.unsafe(nil)); end
def out_of_bounds_time_format(); end
def out_of_bounds_time_format=(format); end
def progress(); end
def progress=(progress); end
def timer(); end
def timer=(timer); end
ELAPSED_LABEL = ::T.let(nil, ::T.untyped)
ESTIMATED_LABEL = ::T.let(nil, ::T.untyped)
NO_TIME_ELAPSED_TEXT = ::T.let(nil, ::T.untyped)
OOB_FRIENDLY_TIME_TEXT = ::T.let(nil, ::T.untyped)
OOB_LIMIT_IN_HOURS = ::T.let(nil, ::T.untyped)
OOB_TIME_FORMATS = ::T.let(nil, ::T.untyped)
OOB_UNKNOWN_TIME_TEXT = ::T.let(nil, ::T.untyped)
TIME_FORMAT = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Components::Time
end
class ProgressBar::Components::Title
def initialize(options=T.unsafe(nil)); end
def title(); end
def title=(title); end
DEFAULT_TITLE = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Components::Title
end
module ProgressBar::Components
end
module ProgressBar::Format
end
class ProgressBar::Format::Formatter
end
class ProgressBar::Format::Formatter
def self.process(format_string, max_length, bar); end
end
class ProgressBar::Format::Molecule
def bar_molecule?(); end
def full_key(); end
def initialize(letter); end
def key(); end
def key=(key); end
def lookup_value(environment, length=T.unsafe(nil)); end
def method_name(); end
def method_name=(method_name); end
def non_bar_molecule?(); end
BAR_MOLECULES = ::T.let(nil, ::T.untyped)
MOLECULES = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Format::Molecule
end
class ProgressBar::Format::String
def bar_molecule_placeholder_length(); end
def bar_molecules(); end
def displayable_length(); end
def molecules(); end
def non_bar_molecules(); end
ANSI_SGR_PATTERN = ::T.let(nil, ::T.untyped)
MOLECULE_PATTERN = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Format::String
end
module ProgressBar::Format
end
class ProgressBar::InvalidProgressError
end
class ProgressBar::InvalidProgressError
end
class ProgressBar::Output
def bar(); end
def bar=(bar); end
def clear_string(); end
def initialize(options=T.unsafe(nil)); end
def length(); end
def length_calculator(); end
def length_calculator=(length_calculator); end
def log(string); end
def refresh(options=T.unsafe(nil)); end
def stream(); end
def stream=(stream); end
def throttle(); end
def throttle=(throttle); end
def with_refresh(); end
DEFAULT_OUTPUT_STREAM = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Output
def self.detect(options=T.unsafe(nil)); end
end
module ProgressBar::Outputs
end
class ProgressBar::Outputs::NonTty
def bar_update_string(); end
def clear(); end
def default_format(); end
def eol(); end
def last_update_length(); end
def last_update_length=(last_update_length); end
def refresh_with_format_change(*_); end
def resolve_format(*_); end
DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Outputs::NonTty
end
class ProgressBar::Outputs::Tty
def bar_update_string(); end
def clear(); end
def default_format(); end
def eol(); end
def refresh_with_format_change(); end
def resolve_format(other_format); end
DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Outputs::Tty
end
module ProgressBar::Outputs
end
class ProgressBar::Progress
def absolute(); end
def decrement(); end
def finish(); end
def finished?(); end
def increment(); end
def initialize(options=T.unsafe(nil)); end
def none?(); end
def percentage_completed(); end
def percentage_completed_with_precision(); end
def progress(); end
def progress=(new_progress); end
def reset(); end
def running_average(); end
def running_average=(running_average); end
def smoothing(); end
def smoothing=(smoothing); end
def start(options=T.unsafe(nil)); end
def starting_position(); end
def starting_position=(starting_position); end
def total(); end
def total=(new_total); end
def total_with_unknown_indicator(); end
def unknown?(); end
DEFAULT_BEGINNING_POSITION = ::T.let(nil, ::T.untyped)
DEFAULT_SMOOTHING = ::T.let(nil, ::T.untyped)
DEFAULT_TOTAL = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Progress
end
module ProgressBar::Refinements
end
module ProgressBar::Refinements::Enumerator
end
module ProgressBar::Refinements::Enumerator
end
module ProgressBar::Refinements
end
class ProgressBar::Throttle
def choke(options=T.unsafe(nil)); end
def initialize(options=T.unsafe(nil)); end
def rate(); end
def rate=(rate); end
def started_at(); end
def started_at=(started_at); end
def stopped_at(); end
def stopped_at=(stopped_at); end
def timer(); end
def timer=(timer); end
end
class ProgressBar::Throttle
end
class ProgressBar::Time
def initialize(time=T.unsafe(nil)); end
def now(); end
def time(); end
def time=(time); end
def unmocked_time_method(); end
TIME_MOCKING_LIBRARY_METHODS = ::T.let(nil, ::T.untyped)
end
class ProgressBar::Time
end
class ProgressBar::Timer
def divide_seconds(seconds); end
def elapsed_seconds(); end
def elapsed_whole_seconds(); end
def initialize(options=T.unsafe(nil)); end
def pause(); end
def reset(); end
def reset?(); end
def restart(); end
def resume(); end
def start(); end
def started?(); end
def started_at(); end
def started_at=(started_at); end
def stop(); end
def stopped?(); end
def stopped_at(); end
def stopped_at=(stopped_at); end
def time(); end
def time=(time); end
end
class ProgressBar::Timer
end
class ProgressBar
def self.create(*args); end
end
module Psych
LIBYAML_VERSION = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class Psych::BadAlias
end
class Psych::BadAlias
end
class Psych::ClassLoader
def big_decimal(); end
def complex(); end
def date(); end
def date_time(); end
def exception(); end
def load(klassname); end
def object(); end
def psych_omap(); end
def psych_set(); end
def range(); end
def rational(); end
def regexp(); end
def struct(); end
def symbol(); end
def symbolize(sym); end
BIG_DECIMAL = ::T.let(nil, ::T.untyped)
CACHE = ::T.let(nil, ::T.untyped)
COMPLEX = ::T.let(nil, ::T.untyped)
DATE = ::T.let(nil, ::T.untyped)
DATE_TIME = ::T.let(nil, ::T.untyped)
EXCEPTION = ::T.let(nil, ::T.untyped)
OBJECT = ::T.let(nil, ::T.untyped)
PSYCH_OMAP = ::T.let(nil, ::T.untyped)
PSYCH_SET = ::T.let(nil, ::T.untyped)
RANGE = ::T.let(nil, ::T.untyped)
RATIONAL = ::T.let(nil, ::T.untyped)
REGEXP = ::T.let(nil, ::T.untyped)
STRUCT = ::T.let(nil, ::T.untyped)
SYMBOL = ::T.let(nil, ::T.untyped)
end
class Psych::ClassLoader::Restricted
def initialize(classes, symbols); end
end
class Psych::ClassLoader::Restricted
end
class Psych::ClassLoader
end
class Psych::Coder
def [](k); end
def []=(k, v); end
def add(k, v); end
def implicit(); end
def implicit=(implicit); end
def initialize(tag); end
def map(tag=T.unsafe(nil), style=T.unsafe(nil)); end
def map=(map); end
def object(); end
def object=(object); end
def represent_map(tag, map); end
def represent_object(tag, obj); end
def represent_scalar(tag, value); end
def represent_seq(tag, list); end
def scalar(*args); end
def scalar=(value); end
def seq(); end
def seq=(list); end
def style(); end
def style=(style); end
def tag(); end
def tag=(tag); end
def type(); end
end
class Psych::Coder
end
class Psych::DisallowedClass
def initialize(klass_name); end
end
class Psych::DisallowedClass
end
class Psych::Emitter
def alias(_); end
def canonical(); end
def canonical=(canonical); end
def end_document(_); end
def indentation(); end
def indentation=(indentation); end
def initialize(*_); end
def line_width(); end
def line_width=(line_width); end
def scalar(_, _1, _2, _3, _4, _5); end
def start_document(_, _1, _2); end
def start_mapping(_, _1, _2, _3); end
def start_sequence(_, _1, _2, _3); end
def start_stream(_); end
end
class Psych::Emitter
end
class Psych::Exception
end
class Psych::Exception
end
class Psych::Handler
def alias(anchor); end
def empty(); end
def end_document(implicit); end
def end_mapping(); end
def end_sequence(); end
def end_stream(); end
def event_location(start_line, start_column, end_line, end_column); end
def scalar(value, anchor, tag, plain, quoted, style); end
def start_document(version, tag_directives, implicit); end
def start_mapping(anchor, tag, implicit, style); end
def start_sequence(anchor, tag, implicit, style); end
def start_stream(encoding); end
def streaming?(); end
EVENTS = ::T.let(nil, ::T.untyped)
OPTIONS = ::T.let(nil, ::T.untyped)
end
class Psych::Handler::DumperOptions
def canonical(); end
def canonical=(canonical); end
def indentation(); end
def indentation=(indentation); end
def line_width(); end
def line_width=(line_width); end
end
class Psych::Handler::DumperOptions
end
class Psych::Handler
end
module Psych::Handlers
end
class Psych::Handlers::DocumentStream
def initialize(&block); end
end
class Psych::Handlers::DocumentStream
end
module Psych::Handlers
end
module Psych::JSON
end
module Psych::JSON::RubyEvents
def visit_DateTime(o); end
def visit_String(o); end
def visit_Symbol(o); end
def visit_Time(o); end
end
module Psych::JSON::RubyEvents
end
class Psych::JSON::Stream
include ::Psych::Streaming
end
class Psych::JSON::Stream::Emitter
include ::Psych::JSON::YAMLEvents
end
class Psych::JSON::Stream::Emitter
end
class Psych::JSON::Stream
extend ::Psych::Streaming::ClassMethods
end
class Psych::JSON::TreeBuilder
include ::Psych::JSON::YAMLEvents
end
class Psych::JSON::TreeBuilder
end
module Psych::JSON::YAMLEvents
def end_document(implicit_end=T.unsafe(nil)); end
def scalar(value, anchor, tag, plain, quoted, style); end
def start_document(version, tag_directives, implicit); end
def start_mapping(anchor, tag, implicit, style); end
def start_sequence(anchor, tag, implicit, style); end
end
module Psych::JSON::YAMLEvents
end
module Psych::JSON
end
module Psych::Nodes
end
class Psych::Nodes::Alias
def anchor(); end
def anchor=(anchor); end
def initialize(anchor); end
end
class Psych::Nodes::Alias
end
class Psych::Nodes::Document
def implicit(); end
def implicit=(implicit); end
def implicit_end(); end
def implicit_end=(implicit_end); end
def initialize(version=T.unsafe(nil), tag_directives=T.unsafe(nil), implicit=T.unsafe(nil)); end
def root(); end
def tag_directives(); end
def tag_directives=(tag_directives); end
def version(); end
def version=(version); end
end
class Psych::Nodes::Document
end
class Psych::Nodes::Mapping
def anchor(); end
def anchor=(anchor); end
def implicit(); end
def implicit=(implicit); end
def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
def style(); end
def style=(style); end
def tag=(tag); end
ANY = ::T.let(nil, ::T.untyped)
BLOCK = ::T.let(nil, ::T.untyped)
FLOW = ::T.let(nil, ::T.untyped)
end
class Psych::Nodes::Mapping
end
class Psych::Nodes::Node
include ::Enumerable
def alias?(); end
def children(); end
def document?(); end
def each(&block); end
def end_column(); end
def end_column=(end_column); end
def end_line(); end
def end_line=(end_line); end
def mapping?(); end
def scalar?(); end
def sequence?(); end
def start_column(); end
def start_column=(start_column); end
def start_line(); end
def start_line=(start_line); end
def stream?(); end
def tag(); end
def to_ruby(); end
def to_yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
def transform(); end
def yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
end
class Psych::Nodes::Node
end
class Psych::Nodes::Scalar
def anchor(); end
def anchor=(anchor); end
def initialize(value, anchor=T.unsafe(nil), tag=T.unsafe(nil), plain=T.unsafe(nil), quoted=T.unsafe(nil), style=T.unsafe(nil)); end
def plain(); end
def plain=(plain); end
def quoted(); end
def quoted=(quoted); end
def style(); end
def style=(style); end
def tag=(tag); end
def value(); end
def value=(value); end
ANY = ::T.let(nil, ::T.untyped)
DOUBLE_QUOTED = ::T.let(nil, ::T.untyped)
FOLDED = ::T.let(nil, ::T.untyped)
LITERAL = ::T.let(nil, ::T.untyped)
PLAIN = ::T.let(nil, ::T.untyped)
SINGLE_QUOTED = ::T.let(nil, ::T.untyped)
end
class Psych::Nodes::Scalar
end
class Psych::Nodes::Sequence
def anchor(); end
def anchor=(anchor); end
def implicit(); end
def implicit=(implicit); end
def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
def style(); end
def style=(style); end
def tag=(tag); end
ANY = ::T.let(nil, ::T.untyped)
BLOCK = ::T.let(nil, ::T.untyped)
FLOW = ::T.let(nil, ::T.untyped)
end
class Psych::Nodes::Sequence
end
class Psych::Nodes::Stream
def encoding(); end
def encoding=(encoding); end
def initialize(encoding=T.unsafe(nil)); end
ANY = ::T.let(nil, ::T.untyped)
UTF16BE = ::T.let(nil, ::T.untyped)
UTF16LE = ::T.let(nil, ::T.untyped)
UTF8 = ::T.let(nil, ::T.untyped)
end
class Psych::Nodes::Stream
end
module Psych::Nodes
end
class Psych::Omap
end
class Psych::Omap
end
class Psych::Parser
def external_encoding=(external_encoding); end
def handler(); end
def handler=(handler); end
def initialize(handler=T.unsafe(nil)); end
def mark(); end
def parse(*_); end
ANY = ::T.let(nil, ::T.untyped)
UTF16BE = ::T.let(nil, ::T.untyped)
UTF16LE = ::T.let(nil, ::T.untyped)
UTF8 = ::T.let(nil, ::T.untyped)
end
class Psych::Parser::Mark
end
class Psych::Parser::Mark
end
class Psych::Parser
end
class Psych::ScalarScanner
def class_loader(); end
def initialize(class_loader); end
def parse_int(string); end
def parse_time(string); end
def tokenize(string); end
FLOAT = ::T.let(nil, ::T.untyped)
INTEGER = ::T.let(nil, ::T.untyped)
TIME = ::T.let(nil, ::T.untyped)
end
class Psych::ScalarScanner
end
class Psych::Set
end
class Psych::Set
end
class Psych::Stream
include ::Psych::Streaming
end
class Psych::Stream::Emitter
def end_document(implicit_end=T.unsafe(nil)); end
end
class Psych::Stream::Emitter
end
class Psych::Stream
extend ::Psych::Streaming::ClassMethods
end
module Psych::Streaming
def start(encoding=T.unsafe(nil)); end
end
module Psych::Streaming::ClassMethods
def new(io); end
end
module Psych::Streaming::ClassMethods
end
module Psych::Streaming
end
class Psych::SyntaxError
def column(); end
def context(); end
def file(); end
def initialize(file, line, col, offset, problem, context); end
def line(); end
def offset(); end
def problem(); end
end
class Psych::SyntaxError
end
class Psych::TreeBuilder
def end_document(implicit_end=T.unsafe(nil)); end
def root(); end
end
class Psych::TreeBuilder
end
module Psych::Visitors
end
class Psych::Visitors::DepthFirst
def initialize(block); end
end
class Psych::Visitors::DepthFirst
end
class Psych::Visitors::Emitter
def initialize(io, options=T.unsafe(nil)); end
def visit_Psych_Nodes_Alias(o); end
def visit_Psych_Nodes_Document(o); end
def visit_Psych_Nodes_Mapping(o); end
def visit_Psych_Nodes_Scalar(o); end
def visit_Psych_Nodes_Sequence(o); end
def visit_Psych_Nodes_Stream(o); end
end
class Psych::Visitors::Emitter
end
class Psych::Visitors::JSONTree
include ::Psych::JSON::RubyEvents
end
class Psych::Visitors::JSONTree
def self.create(options=T.unsafe(nil)); end
end
class Psych::Visitors::NoAliasRuby
end
class Psych::Visitors::NoAliasRuby
end
class Psych::Visitors::ToRuby
def class_loader(); end
def initialize(ss, class_loader); end
def visit_Psych_Nodes_Alias(o); end
def visit_Psych_Nodes_Document(o); end
def visit_Psych_Nodes_Mapping(o); end
def visit_Psych_Nodes_Scalar(o); end
def visit_Psych_Nodes_Sequence(o); end
def visit_Psych_Nodes_Stream(o); end
SHOVEL = ::T.let(nil, ::T.untyped)
end
class Psych::Visitors::ToRuby
def self.create(); end
end
class Psych::Visitors::Visitor
def accept(target); end
DISPATCH = ::T.let(nil, ::T.untyped)
end
class Psych::Visitors::Visitor
end
class Psych::Visitors::YAMLTree
def <<(object); end
def finish(); end
def finished(); end
def finished?(); end
def initialize(emitter, ss, options); end
def push(object); end
def start(encoding=T.unsafe(nil)); end
def started(); end
def started?(); end
def tree(); end
def visit_Array(o); end
def visit_BasicObject(o); end
def visit_BigDecimal(o); end
def visit_Class(o); end
def visit_Complex(o); end
def visit_Date(o); end
def visit_DateTime(o); end
def visit_Delegator(o); end
def visit_Encoding(o); end
def visit_Enumerator(o); end
def visit_Exception(o); end
def visit_FalseClass(o); end
def visit_Float(o); end
def visit_Hash(o); end
def visit_Integer(o); end
def visit_Module(o); end
def visit_NameError(o); end
def visit_NilClass(o); end
def visit_Object(o); end
def visit_Psych_Omap(o); end
def visit_Psych_Set(o); end
def visit_Range(o); end
def visit_Rational(o); end
def visit_Regexp(o); end
def visit_String(o); end
def visit_Struct(o); end
def visit_Symbol(o); end
def visit_Time(o); end
def visit_TrueClass(o); end
end
class Psych::Visitors::YAMLTree
def self.create(options=T.unsafe(nil), emitter=T.unsafe(nil)); end
end
module Psych::Visitors
end
module Psych
def self.add_builtin_type(type_tag, &block); end
def self.add_domain_type(domain, type_tag, &block); end
def self.add_tag(tag, klass); end
def self.domain_types(); end
def self.domain_types=(domain_types); end
def self.dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end
def self.dump_stream(*objects); end
def self.dump_tags(); end
def self.dump_tags=(dump_tags); end
def self.libyaml_version(); end
def self.load(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
def self.load_file(filename, fallback: T.unsafe(nil)); end
def self.load_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
def self.load_tags(); end
def self.load_tags=(load_tags); end
def self.parse(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
def self.parse_file(filename, fallback: T.unsafe(nil)); end
def self.parse_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), &block); end
def self.parser(); end
def self.remove_type(type_tag); end
def self.safe_load(yaml, legacy_permitted_classes=T.unsafe(nil), legacy_permitted_symbols=T.unsafe(nil), legacy_aliases=T.unsafe(nil), legacy_filename=T.unsafe(nil), permitted_classes: T.unsafe(nil), permitted_symbols: T.unsafe(nil), aliases: T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
def self.to_json(object); end
end
module REXML
COPYRIGHT = ::T.let(nil, ::T.untyped)
Copyright = ::T.let(nil, ::T.untyped)
DATE = ::T.let(nil, ::T.untyped)
REVISION = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
Version = ::T.let(nil, ::T.untyped)
end
class REXML::AttlistDecl
include ::Enumerable
def [](key); end
def each(&block); end
def element_name(); end
def include?(key); end
def initialize(source); end
def node_type(); end
def write(out, indent=T.unsafe(nil)); end
end
class REXML::AttlistDecl
end
class REXML::Attribute
include ::REXML::Node
include ::REXML::Namespace
include ::REXML::XMLTokens
def ==(other); end
def clone(); end
def doctype(); end
def element(); end
def element=(element); end
def initialize(first, second=T.unsafe(nil), parent=T.unsafe(nil)); end
def namespace(arg=T.unsafe(nil)); end
def node_type(); end
def normalized=(normalized); end
def remove(); end
def to_s(); end
def to_string(); end
def value(); end
def write(output, indent=T.unsafe(nil)); end
def xpath(); end
NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
PATTERN = ::T.let(nil, ::T.untyped)
end
class REXML::Attribute
end
class REXML::Attributes
def <<(attribute); end
def [](name); end
def []=(name, value); end
def add(attribute); end
def delete(attribute); end
def delete_all(name); end
def each_attribute(); end
def get_attribute(name); end
def get_attribute_ns(namespace, name); end
def initialize(element); end
def namespaces(); end
def prefixes(); end
end
class REXML::Attributes
end
class REXML::CData
def initialize(first, whitespace=T.unsafe(nil), parent=T.unsafe(nil)); end
def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
ILLEGAL = ::T.let(nil, ::T.untyped)
START = ::T.let(nil, ::T.untyped)
STOP = ::T.let(nil, ::T.untyped)
end
class REXML::CData
end
class REXML::Child
include ::REXML::Node
def bytes(); end
def document(); end
def initialize(parent=T.unsafe(nil)); end
def next_sibling(); end
def next_sibling=(other); end
def parent(); end
def parent=(other); end
def previous_sibling(); end
def previous_sibling=(other); end
def remove(); end
def replace_with(child); end
end
class REXML::Child
end
class REXML::Comment
include ::Comparable
def ==(other); end
def clone(); end
def initialize(first, second=T.unsafe(nil)); end
def node_type(); end
def string(); end
def string=(string); end
def to_s(); end
def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
START = ::T.let(nil, ::T.untyped)
STOP = ::T.let(nil, ::T.untyped)
end
class REXML::Comment
end
class REXML::Declaration
def initialize(src); end
def to_s(); end
def write(output, indent); end
end
class REXML::Declaration
end
class REXML::DocType
include ::REXML::XMLTokens
def add(child); end
def attribute_of(element, attribute); end
def attributes_of(element); end
def clone(); end
def context(); end
def entities(); end
def entity(name); end
def external_id(); end
def initialize(first, parent=T.unsafe(nil)); end
def name(); end
def namespaces(); end
def node_type(); end
def notation(name); end
def notations(); end
def public(); end
def system(); end
def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped)
PUBLIC = ::T.let(nil, ::T.untyped)
START = ::T.let(nil, ::T.untyped)
STOP = ::T.let(nil, ::T.untyped)
SYSTEM = ::T.let(nil, ::T.untyped)
end
class REXML::DocType
end
class REXML::Document
def <<(child); end
def add(child); end
def add_element(arg=T.unsafe(nil), arg2=T.unsafe(nil)); end
def doctype(); end
def encoding(); end
def entity_expansion_count(); end
def initialize(source=T.unsafe(nil), context=T.unsafe(nil)); end
def record_entity_expansion(); end
def stand_alone?(); end
def version(); end
def write(*arguments); end
def xml_decl(); end
DECLARATION = ::T.let(nil, ::T.untyped)
end
class REXML::Document
def self.entity_expansion_limit(); end
def self.entity_expansion_limit=(val); end
def self.entity_expansion_text_limit(); end
def self.entity_expansion_text_limit=(val); end
def self.parse_stream(source, listener); end
end
class REXML::Element
include ::REXML::Namespace
include ::REXML::XMLTokens
def [](name_or_index); end
def add_attribute(key, value=T.unsafe(nil)); end
def add_attributes(hash); end
def add_element(element, attrs=T.unsafe(nil)); end
def add_namespace(prefix, uri=T.unsafe(nil)); end
def add_text(text); end
def attribute(name, namespace=T.unsafe(nil)); end
def attributes(); end
def cdatas(); end
def clone(); end
def comments(); end
def context(); end
def context=(context); end
def delete_attribute(key); end
def delete_element(element); end
def delete_namespace(namespace=T.unsafe(nil)); end
def each_element(xpath=T.unsafe(nil), &block); end
def each_element_with_attribute(key, value=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end
def each_element_with_text(text=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end
def elements(); end
def get_elements(xpath); end
def get_text(path=T.unsafe(nil)); end
def has_attributes?(); end
def has_elements?(); end
def has_text?(); end
def ignore_whitespace_nodes(); end
def initialize(arg=T.unsafe(nil), parent=T.unsafe(nil), context=T.unsafe(nil)); end
def instructions(); end
def namespace(prefix=T.unsafe(nil)); end
def namespaces(); end
def next_element(); end
def node_type(); end
def prefixes(); end
def previous_element(); end
def raw(); end
def root(); end
def root_node(); end
def text(path=T.unsafe(nil)); end
def text=(text); end
def texts(); end
def whitespace(); end
def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
def xpath(); end
UNDEFINED = ::T.let(nil, ::T.untyped)
end
class REXML::Element
end
class REXML::ElementDecl
end
class REXML::ElementDecl
end
class REXML::Elements
include ::Enumerable
def <<(element=T.unsafe(nil)); end
def [](index, name=T.unsafe(nil)); end
def []=(index, element); end
def add(element=T.unsafe(nil)); end
def collect(xpath=T.unsafe(nil)); end
def delete(element); end
def delete_all(xpath); end
def each(xpath=T.unsafe(nil), &blk); end
def empty?(); end
def index(element); end
def initialize(parent); end
def inject(xpath=T.unsafe(nil), initial=T.unsafe(nil)); end
def size(); end
def to_a(xpath=T.unsafe(nil)); end
end
class REXML::Elements
end
module REXML::Encoding
def decode(string); end
def encode(string); end
def encoding(); end
def encoding=(encoding); end
end
module REXML::Encoding
end
class REXML::Entity
include ::REXML::XMLTokens
def external(); end
def initialize(stream, value=T.unsafe(nil), parent=T.unsafe(nil), reference=T.unsafe(nil)); end
def name(); end
def ndata(); end
def normalized(); end
def pubid(); end
def ref(); end
def to_s(); end
def unnormalized(); end
def value(); end
def write(out, indent=T.unsafe(nil)); end
ENTITYDECL = ::T.let(nil, ::T.untyped)
ENTITYDEF = ::T.let(nil, ::T.untyped)
ENTITYVALUE = ::T.let(nil, ::T.untyped)
EXTERNALID = ::T.let(nil, ::T.untyped)
GEDECL = ::T.let(nil, ::T.untyped)
NDATADECL = ::T.let(nil, ::T.untyped)
PEDECL = ::T.let(nil, ::T.untyped)
PEDEF = ::T.let(nil, ::T.untyped)
PEREFERENCE = ::T.let(nil, ::T.untyped)
PEREFERENCE_RE = ::T.let(nil, ::T.untyped)
PUBIDCHAR = ::T.let(nil, ::T.untyped)
PUBIDLITERAL = ::T.let(nil, ::T.untyped)
SYSTEMLITERAL = ::T.let(nil, ::T.untyped)
end
class REXML::Entity
def self.matches?(string); end
end
module REXML::EntityConst
AMP = ::T.let(nil, ::T.untyped)
APOS = ::T.let(nil, ::T.untyped)
GT = ::T.let(nil, ::T.untyped)
LT = ::T.let(nil, ::T.untyped)
QUOT = ::T.let(nil, ::T.untyped)
end
module REXML::EntityConst
end
class REXML::ExternalEntity
def initialize(src); end
def to_s(); end
def write(output, indent); end
end
class REXML::ExternalEntity
end
module REXML::Formatters
end
class REXML::Formatters::Default
def initialize(ie_hack=T.unsafe(nil)); end
def write(node, output); end
def write_cdata(node, output); end
def write_comment(node, output); end
def write_document(node, output); end
def write_element(node, output); end
def write_instruction(node, output); end
def write_text(node, output); end
end
class REXML::Formatters::Default
end
class REXML::Formatters::Pretty
def compact(); end
def compact=(compact); end
def initialize(indentation=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
def width(); end
def width=(width); end
end
class REXML::Formatters::Pretty
end
module REXML::Formatters
end
module REXML::Functions
INTERNAL_METHODS = ::T.let(nil, ::T.untyped)
end
module REXML::Functions
def self.boolean(object=T.unsafe(nil)); end
def self.ceiling(number); end
def self.compare_language(lang1, lang2); end
def self.concat(*objects); end
def self.contains(string, test); end
def self.context=(value); end
def self.count(node_set); end
def self.false(); end
def self.floor(number); end
def self.get_namespace(node_set=T.unsafe(nil)); end
def self.id(object); end
def self.lang(language); end
def self.last(); end
def self.local_name(node_set=T.unsafe(nil)); end
def self.name(node_set=T.unsafe(nil)); end
def self.namespace_context(); end
def self.namespace_context=(x); end
def self.namespace_uri(node_set=T.unsafe(nil)); end
def self.normalize_space(string=T.unsafe(nil)); end
def self.not(object); end
def self.number(object=T.unsafe(nil)); end
def self.position(); end
def self.processing_instruction(node); end
def self.round(number); end
def self.send(name, *args); end
def self.singleton_method_added(name); end
def self.starts_with(string, test); end
def self.string(object=T.unsafe(nil)); end
def self.string_length(string); end
def self.string_value(o); end
def self.substring(string, start, length=T.unsafe(nil)); end
def self.substring_after(string, test); end
def self.substring_before(string, test); end
def self.sum(nodes); end
def self.text(); end
def self.translate(string, tr1, tr2); end
def self.true(); end
def self.variables(); end
def self.variables=(x); end
end
class REXML::IOSource
def initialize(arg, block_size=T.unsafe(nil), encoding=T.unsafe(nil)); end
end
class REXML::IOSource
end
class REXML::Instruction
def ==(other); end
def clone(); end
def content(); end
def content=(content); end
def initialize(target, content=T.unsafe(nil)); end
def node_type(); end
def target(); end
def target=(target); end
def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
START = ::T.let(nil, ::T.untyped)
STOP = ::T.let(nil, ::T.untyped)
end
class REXML::Instruction
end
module REXML::Namespace
include ::REXML::XMLTokens
def expanded_name(); end
def fully_expanded_name(); end
def has_name?(other, ns=T.unsafe(nil)); end
def local_name(); end
def name(); end
def name=(name); end
def prefix(); end
def prefix=(prefix); end
NAMESPLIT = ::T.let(nil, ::T.untyped)
end
module REXML::Namespace
end
module REXML::Node
def each_recursive(&block); end
def find_first_recursive(&block); end
def indent(to, ind); end
def index_in_parent(); end
def next_sibling_node(); end
def parent?(); end
def previous_sibling_node(); end
def to_s(indent=T.unsafe(nil)); end
end
module REXML::Node
end
class REXML::NotationDecl
def initialize(name, middle, pub, sys); end
def name(); end
def public(); end
def public=(public); end
def system(); end
def system=(system); end
def to_s(); end
def write(output, indent=T.unsafe(nil)); end
end
class REXML::NotationDecl
end
class REXML::Output
include ::REXML::Encoding
def <<(content); end
def initialize(real_IO, encd=T.unsafe(nil)); end
end
class REXML::Output
end
class REXML::Parent
include ::Enumerable
def <<(object); end
def [](index); end
def []=(*args); end
def add(object); end
def children(); end
def deep_clone(); end
def delete(object); end
def delete_at(index); end
def delete_if(&block); end
def each(&block); end
def each_child(&block); end
def each_index(&block); end
def index(child); end
def insert_after(child1, child2); end
def insert_before(child1, child2); end
def length(); end
def push(object); end
def replace_child(to_replace, replacement); end
def size(); end
def to_a(); end
def unshift(object); end
end
class REXML::Parent
end
class REXML::ParseException
def context(); end
def continued_exception(); end
def continued_exception=(continued_exception); end
def initialize(message, source=T.unsafe(nil), parser=T.unsafe(nil), exception=T.unsafe(nil)); end
def line(); end
def parser(); end
def parser=(parser); end
def position(); end
def source(); end
def source=(source); end
end
class REXML::ParseException
end
module REXML::Parsers
end
class REXML::Parsers::BaseParser
def add_listener(listener); end
def empty?(); end
def entity(reference, entities); end
def has_next?(); end
def initialize(source); end
def normalize(input, entities=T.unsafe(nil), entity_filter=T.unsafe(nil)); end
def peek(depth=T.unsafe(nil)); end
def position(); end
def pull(); end
def source(); end
def stream=(source); end
def unnormalize(string, entities=T.unsafe(nil), filter=T.unsafe(nil)); end
def unshift(token); end
ATTDEF = ::T.let(nil, ::T.untyped)
ATTDEF_RE = ::T.let(nil, ::T.untyped)
ATTLISTDECL_PATTERN = ::T.let(nil, ::T.untyped)
ATTLISTDECL_START = ::T.let(nil, ::T.untyped)
ATTRIBUTE_PATTERN = ::T.let(nil, ::T.untyped)
ATTTYPE = ::T.let(nil, ::T.untyped)
ATTVALUE = ::T.let(nil, ::T.untyped)
CDATA_END = ::T.let(nil, ::T.untyped)
CDATA_PATTERN = ::T.let(nil, ::T.untyped)
CDATA_START = ::T.let(nil, ::T.untyped)
CLOSE_MATCH = ::T.let(nil, ::T.untyped)
COMBININGCHAR = ::T.let(nil, ::T.untyped)
COMMENT_PATTERN = ::T.let(nil, ::T.untyped)
COMMENT_START = ::T.let(nil, ::T.untyped)
DEFAULTDECL = ::T.let(nil, ::T.untyped)
DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped)
DIGIT = ::T.let(nil, ::T.untyped)
DOCTYPE_END = ::T.let(nil, ::T.untyped)
DOCTYPE_PATTERN = ::T.let(nil, ::T.untyped)
DOCTYPE_START = ::T.let(nil, ::T.untyped)
ELEMENTDECL_PATTERN = ::T.let(nil, ::T.untyped)
ELEMENTDECL_START = ::T.let(nil, ::T.untyped)
ENCODING = ::T.let(nil, ::T.untyped)
ENTITYDECL = ::T.let(nil, ::T.untyped)
ENTITYDEF = ::T.let(nil, ::T.untyped)
ENTITYVALUE = ::T.let(nil, ::T.untyped)
ENTITY_START = ::T.let(nil, ::T.untyped)
ENUMERATEDTYPE = ::T.let(nil, ::T.untyped)
ENUMERATION = ::T.let(nil, ::T.untyped)
EREFERENCE = ::T.let(nil, ::T.untyped)
EXTENDER = ::T.let(nil, ::T.untyped)
EXTERNALID = ::T.let(nil, ::T.untyped)
GEDECL = ::T.let(nil, ::T.untyped)
IDENTITY = ::T.let(nil, ::T.untyped)
INSTRUCTION_PATTERN = ::T.let(nil, ::T.untyped)
INSTRUCTION_START = ::T.let(nil, ::T.untyped)
LETTER = ::T.let(nil, ::T.untyped)
NAME = ::T.let(nil, ::T.untyped)
NAMECHAR = ::T.let(nil, ::T.untyped)
NCNAME_STR = ::T.let(nil, ::T.untyped)
NDATADECL = ::T.let(nil, ::T.untyped)
NMTOKEN = ::T.let(nil, ::T.untyped)
NMTOKENS = ::T.let(nil, ::T.untyped)
NOTATIONDECL_START = ::T.let(nil, ::T.untyped)
NOTATIONTYPE = ::T.let(nil, ::T.untyped)
PEDECL = ::T.let(nil, ::T.untyped)
PEDEF = ::T.let(nil, ::T.untyped)
PEREFERENCE = ::T.let(nil, ::T.untyped)
PUBIDCHAR = ::T.let(nil, ::T.untyped)
PUBIDLITERAL = ::T.let(nil, ::T.untyped)
PUBLIC = ::T.let(nil, ::T.untyped)
QNAME = ::T.let(nil, ::T.untyped)
QNAME_STR = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
REFERENCE_RE = ::T.let(nil, ::T.untyped)
STANDALONE = ::T.let(nil, ::T.untyped)
SYSTEM = ::T.let(nil, ::T.untyped)
SYSTEMENTITY = ::T.let(nil, ::T.untyped)
SYSTEMLITERAL = ::T.let(nil, ::T.untyped)
TAG_MATCH = ::T.let(nil, ::T.untyped)
TEXT_PATTERN = ::T.let(nil, ::T.untyped)
UNAME_STR = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
XMLDECL_PATTERN = ::T.let(nil, ::T.untyped)
XMLDECL_START = ::T.let(nil, ::T.untyped)
end
class REXML::Parsers::BaseParser
end
class REXML::Parsers::StreamParser
def add_listener(listener); end
def initialize(source, listener); end
def parse(); end
end
class REXML::Parsers::StreamParser
end
class REXML::Parsers::TreeParser
def add_listener(listener); end
def initialize(source, build_context=T.unsafe(nil)); end
def parse(); end
end
class REXML::Parsers::TreeParser
end
class REXML::Parsers::XPathParser
include ::REXML::XMLTokens
def abbreviate(path); end
def expand(path); end
def namespaces=(namespaces); end
def parse(path); end
def predicate(path); end
def predicate_to_string(path, &block); end
AXIS = ::T.let(nil, ::T.untyped)
LITERAL = ::T.let(nil, ::T.untyped)
LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped)
NODE_TYPE = ::T.let(nil, ::T.untyped)
NT = ::T.let(nil, ::T.untyped)
NUMBER = ::T.let(nil, ::T.untyped)
PI = ::T.let(nil, ::T.untyped)
PREFIX_WILDCARD = ::T.let(nil, ::T.untyped)
QNAME = ::T.let(nil, ::T.untyped)
VARIABLE_REFERENCE = ::T.let(nil, ::T.untyped)
end
class REXML::Parsers::XPathParser
end
module REXML::Parsers
end
module REXML::Security
end
module REXML::Security
def self.entity_expansion_limit(); end
def self.entity_expansion_limit=(val); end
def self.entity_expansion_text_limit(); end
def self.entity_expansion_text_limit=(val); end
end
class REXML::Source
include ::REXML::Encoding
def buffer(); end
def consume(pattern); end
def current_line(); end
def empty?(); end
def encoding=(enc); end
def initialize(arg, encoding=T.unsafe(nil)); end
def line(); end
def match(pattern, cons=T.unsafe(nil)); end
def match_to(char, pattern); end
def match_to_consume(char, pattern); end
def position(); end
def read(); end
def scan(pattern, cons=T.unsafe(nil)); end
end
class REXML::Source
end
class REXML::SourceFactory
end
class REXML::SourceFactory
def self.create_from(arg); end
end
class REXML::Text
include ::Comparable
def <<(to_append); end
def clone(); end
def doctype(); end
def empty?(); end
def indent_text(string, level=T.unsafe(nil), style=T.unsafe(nil), indentfirstline=T.unsafe(nil)); end
def initialize(arg, respect_whitespace=T.unsafe(nil), parent=T.unsafe(nil), raw=T.unsafe(nil), entity_filter=T.unsafe(nil), illegal=T.unsafe(nil)); end
def node_type(); end
def parent=(parent); end
def raw(); end
def raw=(raw); end
def to_s(); end
def value(); end
def value=(val); end
def wrap(string, width, addnewline=T.unsafe(nil)); end
def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
def write_with_substitution(out, input); end
def xpath(); end
EREFERENCE = ::T.let(nil, ::T.untyped)
NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
NUMERICENTITY = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
SETUTITSBUS = ::T.let(nil, ::T.untyped)
SLAICEPS = ::T.let(nil, ::T.untyped)
SPECIALS = ::T.let(nil, ::T.untyped)
SUBSTITUTES = ::T.let(nil, ::T.untyped)
VALID_CHAR = ::T.let(nil, ::T.untyped)
VALID_XML_CHARS = ::T.let(nil, ::T.untyped)
end
class REXML::Text
def self.check(string, pattern, doctype); end
def self.expand(ref, doctype, filter); end
def self.normalize(input, doctype=T.unsafe(nil), entity_filter=T.unsafe(nil)); end
def self.read_with_substitution(input, illegal=T.unsafe(nil)); end
def self.unnormalize(string, doctype=T.unsafe(nil), filter=T.unsafe(nil), illegal=T.unsafe(nil)); end
end
class REXML::UndefinedNamespaceException
def initialize(prefix, source, parser); end
end
class REXML::UndefinedNamespaceException
end
module REXML::Validation
end
class REXML::Validation::ValidationException
def initialize(msg); end
end
class REXML::Validation::ValidationException
end
module REXML::Validation
end
class REXML::XMLDecl
include ::REXML::Encoding
def ==(other); end
def clone(); end
def dowrite(); end
def encoding=(enc); end
def initialize(version=T.unsafe(nil), encoding=T.unsafe(nil), standalone=T.unsafe(nil)); end
def node_type(); end
def nowrite(); end
def old_enc=(encoding); end
def stand_alone?(); end
def standalone(); end
def standalone=(standalone); end
def version(); end
def version=(version); end
def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
def writeencoding(); end
def writethis(); end
def xmldecl(version, encoding, standalone); end
DEFAULT_ENCODING = ::T.let(nil, ::T.untyped)
DEFAULT_STANDALONE = ::T.let(nil, ::T.untyped)
DEFAULT_VERSION = ::T.let(nil, ::T.untyped)
START = ::T.let(nil, ::T.untyped)
STOP = ::T.let(nil, ::T.untyped)
end
class REXML::XMLDecl
def self.default(); end
end
module REXML::XMLTokens
NAME = ::T.let(nil, ::T.untyped)
NAMECHAR = ::T.let(nil, ::T.untyped)
NAME_CHAR = ::T.let(nil, ::T.untyped)
NAME_START_CHAR = ::T.let(nil, ::T.untyped)
NAME_STR = ::T.let(nil, ::T.untyped)
NCNAME_STR = ::T.let(nil, ::T.untyped)
NMTOKEN = ::T.let(nil, ::T.untyped)
NMTOKENS = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
end
module REXML::XMLTokens
end
class REXML::XPath
include ::REXML::Functions
EMPTY_HASH = ::T.let(nil, ::T.untyped)
end
class REXML::XPath
def self.each(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil), &block); end
def self.first(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end
def self.match(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end
end
class REXML::XPathNode
def context(); end
def initialize(node, context=T.unsafe(nil)); end
def position(); end
def raw_node(); end
end
class REXML::XPathNode
end
class REXML::XPathParser
include ::REXML::XMLTokens
def []=(variable_name, value); end
def first(path_stack, node); end
def get_first(path, nodeset); end
def initialize(strict: T.unsafe(nil)); end
def match(path_stack, nodeset); end
def namespaces=(namespaces=T.unsafe(nil)); end
def parse(path, nodeset); end
def predicate(path, nodeset); end
def variables=(vars=T.unsafe(nil)); end
DEBUG = ::T.let(nil, ::T.untyped)
LITERAL = ::T.let(nil, ::T.untyped)
end
class REXML::XPathParser
end
module REXML
end
module RSpec
MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
end
class RSpec::CallerFilter
ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped)
IGNORE_REGEX = ::T.let(nil, ::T.untyped)
LIB_REGEX = ::T.let(nil, ::T.untyped)
RSPEC_LIBS = ::T.let(nil, ::T.untyped)
end
class RSpec::CallerFilter
def self.first_non_rspec_line(skip_frames=T.unsafe(nil), increment=T.unsafe(nil)); end
end
module RSpec::Core
end
class RSpec::Core::AnonymousExampleGroup
end
class RSpec::Core::AnonymousExampleGroup
end
class RSpec::Core::BacktraceFormatter
def backtrace_line(line); end
def exclude?(line); end
def exclusion_patterns(); end
def exclusion_patterns=(exclusion_patterns); end
def filter_gem(gem_name); end
def format_backtrace(backtrace, options=T.unsafe(nil)); end
def full_backtrace=(full_backtrace); end
def full_backtrace?(); end
def inclusion_patterns(); end
def inclusion_patterns=(inclusion_patterns); end
end
class RSpec::Core::BacktraceFormatter
end
class RSpec::Core::Configuration
include ::RSpec::Core::Hooks
include ::RSpec::Core::Configuration::Readers
def add_formatter(formatter, output=T.unsafe(nil)); end
def add_setting(name, opts=T.unsafe(nil)); end
def after(scope=T.unsafe(nil), *meta, &block); end
def alias_example_group_to(new_name, *args); end
def alias_example_to(name, *args); end
def alias_it_behaves_like_to(new_name, report_label=T.unsafe(nil)); end
def alias_it_should_behave_like_to(new_name, report_label=T.unsafe(nil)); end
def append_after(scope=T.unsafe(nil), *meta, &block); end
def append_before(scope=T.unsafe(nil), *meta, &block); end
def apply_derived_metadata_to(metadata); end
def around(scope=T.unsafe(nil), *meta, &block); end
def backtrace_exclusion_patterns(); end
def backtrace_exclusion_patterns=(patterns); end
def backtrace_formatter(); end
def backtrace_inclusion_patterns(); end
def backtrace_inclusion_patterns=(patterns); end
def before(scope=T.unsafe(nil), *meta, &block); end
def bisect_runner(); end
def bisect_runner=(value); end
def bisect_runner_class(); end
def color(); end
def color=(color); end
def color_enabled?(output=T.unsafe(nil)); end
def color_mode(); end
def color_mode=(color_mode); end
def configure_example(example, example_hooks); end
def configure_expectation_framework(); end
def configure_group(group); end
def configure_mock_framework(); end
def default_color=(default_color); end
def default_color?(); end
def default_formatter(); end
def default_formatter=(value); end
def default_path=(path); end
def default_path?(); end
def define_derived_metadata(*filters, &block); end
def deprecation_stream=(value); end
def detail_color=(detail_color); end
def detail_color?(); end
def disable_monkey_patching(); end
def disable_monkey_patching!(); end
def disable_monkey_patching=(disable_monkey_patching); end
def drb=(drb); end
def drb?(); end
def drb_port=(drb_port); end
def drb_port?(); end
def dry_run=(dry_run); end
def dry_run?(); end
def error_stream=(error_stream); end
def error_stream?(); end
def example_status_persistence_file_path=(value); end
def exclude_pattern=(value); end
def exclusion_filter(); end
def exclusion_filter=(filter); end
def expect_with(*frameworks); end
def expectation_framework=(framework); end
def expectation_frameworks(); end
def expose_current_running_example_as(method_name); end
def expose_dsl_globally=(value); end
def expose_dsl_globally?(); end
def extend(mod, *filters); end
def fail_fast=(value); end
def fail_if_no_examples=(fail_if_no_examples); end
def fail_if_no_examples?(); end
def failure_color=(failure_color); end
def failure_color?(); end
def failure_exit_code=(failure_exit_code); end
def failure_exit_code?(); end
def files_or_directories_to_run=(*files); end
def files_to_run(); end
def files_to_run=(files_to_run); end
def filter(); end
def filter=(filter); end
def filter_gems_from_backtrace(*gem_names); end
def filter_manager(); end
def filter_manager=(filter_manager); end
def filter_run(*args); end
def filter_run_excluding(*args); end
def filter_run_including(*args); end
def filter_run_when_matching(*args); end
def fixed_color=(fixed_color); end
def fixed_color?(); end
def force(hash); end
def format_docstrings(&block); end
def format_docstrings_block(); end
def formatter=(formatter, output=T.unsafe(nil)); end
def formatter_loader(); end
def formatters(); end
def full_backtrace=(true_or_false); end
def full_backtrace?(); end
def full_description(); end
def full_description=(description); end
def in_project_source_dir_regex(); end
def include(mod, *filters); end
def include_context(shared_group_name, *filters); end
def inclusion_filter(); end
def inclusion_filter=(filter); end
def last_run_statuses(); end
def libs=(libs); end
def load_spec_files(); end
def loaded_spec_files(); end
def max_displayed_failure_line_count=(max_displayed_failure_line_count); end
def max_displayed_failure_line_count?(); end
def mock_framework(); end
def mock_framework=(framework); end
def mock_with(framework); end
def on_example_group_definition(&block); end
def on_example_group_definition_callbacks(); end
def only_failures?(); end
def only_failures_but_not_configured?(); end
def order=(*args, &block); end
def ordering_manager(); end
def ordering_registry(*args, &block); end
def output_stream=(value); end
def pattern=(value); end
def pending_color=(pending_color); end
def pending_color?(); end
def prepend(mod, *filters); end
def prepend_after(scope=T.unsafe(nil), *meta, &block); end
def prepend_before(scope=T.unsafe(nil), *meta, &block); end
def profile_examples=(profile_examples); end
def profile_examples?(); end
def project_source_dirs=(project_source_dirs); end
def project_source_dirs?(); end
def raise_errors_for_deprecations!(); end
def raise_on_warning=(value); end
def register_ordering(*args, &block); end
def reporter(); end
def requires=(paths); end
def reset(); end
def reset_filters(); end
def reset_reporter(); end
def run_all_when_everything_filtered=(run_all_when_everything_filtered); end
def run_all_when_everything_filtered?(); end
def seed(*args, &block); end
def seed=(*args, &block); end
def seed_used?(*args, &block); end
def shared_context_metadata_behavior=(value); end
def silence_filter_announcements=(silence_filter_announcements); end
def silence_filter_announcements?(); end
def spec_files_with_failures(); end
def start_time=(start_time); end
def start_time?(); end
def static_config_filter_manager(); end
def static_config_filter_manager=(static_config_filter_manager); end
def success_color=(success_color); end
def success_color?(); end
def threadsafe=(threadsafe); end
def threadsafe?(); end
def treat_symbols_as_metadata_keys_with_true_values=(_value); end
def tty=(tty); end
def tty?(); end
def warnings=(value); end
def warnings?(); end
def when_first_matching_example_defined(*filters); end
def with_suite_hooks(); end
def world(); end
def world=(world); end
DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped)
FAILED_STATUS = ::T.let(nil, ::T.untyped)
MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped)
PASSED_STATUS = ::T.let(nil, ::T.untyped)
PENDING_STATUS = ::T.let(nil, ::T.untyped)
RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
UNKNOWN_STATUS = ::T.let(nil, ::T.untyped)
VALID_STATUSES = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Configuration::DeprecationReporterBuffer
def deprecation(*args); end
def play_onto(reporter); end
end
class RSpec::Core::Configuration::DeprecationReporterBuffer
end
module RSpec::Core::Configuration::ExposeCurrentExample
end
module RSpec::Core::Configuration::ExposeCurrentExample
end
class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError
end
class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError
end
module RSpec::Core::Configuration::Readers
def default_color(); end
def default_path(); end
def deprecation_stream(); end
def detail_color(); end
def drb(); end
def drb_port(); end
def dry_run(); end
def error_stream(); end
def example_status_persistence_file_path(); end
def exclude_pattern(); end
def fail_fast(); end
def fail_if_no_examples(); end
def failure_color(); end
def failure_exit_code(); end
def fixed_color(); end
def libs(); end
def max_displayed_failure_line_count(); end
def only_failures(); end
def output_stream(); end
def pattern(); end
def pending_color(); end
def profile_examples(); end
def project_source_dirs(); end
def requires(); end
def run_all_when_everything_filtered(); end
def shared_context_metadata_behavior(); end
def silence_filter_announcements(); end
def start_time(); end
def success_color(); end
def threadsafe(); end
def tty(); end
end
module RSpec::Core::Configuration::Readers
end
class RSpec::Core::Configuration
def self.add_read_only_setting(name, opts=T.unsafe(nil)); end
def self.add_setting(name, opts=T.unsafe(nil)); end
def self.define_aliases(name, alias_name); end
def self.define_predicate_for(*names); end
def self.define_reader(name); end
def self.delegate_to_ordering_manager(*methods); end
end
class RSpec::Core::ConfigurationOptions
def args(); end
def configure(config); end
def configure_filter_manager(filter_manager); end
def initialize(args); end
def options(); end
OPTIONS_ORDER = ::T.let(nil, ::T.untyped)
UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped)
UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::ConfigurationOptions
end
module RSpec::Core::DSL
end
module RSpec::Core::DSL
def self.change_global_dsl(&changes); end
def self.example_group_aliases(); end
def self.expose_example_group_alias(name); end
def self.expose_example_group_alias_globally(method_name); end
def self.expose_globally!(); end
def self.exposed_globally?(); end
def self.remove_globally!(); end
def self.top_level(); end
def self.top_level=(top_level); end
end
class RSpec::Core::DeprecationError
end
class RSpec::Core::DeprecationError
end
class RSpec::Core::DidYouMean
def call(); end
def initialize(relative_file_name); end
def relative_file_name(); end
end
class RSpec::Core::DidYouMean
end
class RSpec::Core::Example
def clock(); end
def clock=(clock); end
def description(); end
def display_exception(); end
def display_exception=(ex); end
def duplicate_with(metadata_overrides=T.unsafe(nil)); end
def example_group(); end
def example_group_instance(); end
def exception(); end
def execution_result(); end
def fail_with_exception(reporter, exception); end
def file_path(); end
def full_description(); end
def id(); end
def initialize(example_group_class, description, user_metadata, example_block=T.unsafe(nil)); end
def inspect_output(); end
def instance_exec(*args, &block); end
def location(); end
def location_rerun_argument(); end
def metadata(); end
def pending(); end
def pending?(); end
def reporter(); end
def rerun_argument(); end
def run(example_group_instance, reporter); end
def set_aggregate_failures_exception(exception); end
def set_exception(exception); end
def skip(); end
def skip_with_exception(reporter, exception); end
def skipped?(); end
def update_inherited_metadata(updates); end
end
RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
class RSpec::Core::Example::ExecutionResult
include ::RSpec::Core::HashImitatable
def ensure_timing_set(clock); end
def example_skipped?(); end
def exception(); end
def exception=(exception); end
def finished_at(); end
def finished_at=(finished_at); end
def pending_exception(); end
def pending_exception=(pending_exception); end
def pending_fixed(); end
def pending_fixed=(pending_fixed); end
def pending_fixed?(); end
def pending_message(); end
def pending_message=(pending_message); end
def record_finished(status, finished_at); end
def run_time(); end
def run_time=(run_time); end
def started_at(); end
def started_at=(started_at); end
def status(); end
def status=(status); end
end
class RSpec::Core::Example::ExecutionResult
extend ::RSpec::Core::HashImitatable::ClassMethods
end
class RSpec::Core::Example::Procsy
def <<(*a, &b); end
def ===(*a, &b); end
def >>(*a, &b); end
def [](*a, &b); end
def arity(*a, &b); end
def binding(*a, &b); end
def call(*args, &block); end
def clock(*a, &b); end
def clock=(*a, &b); end
def clone(*a, &b); end
def curry(*a, &b); end
def description(*a, &b); end
def dup(*a, &b); end
def duplicate_with(*a, &b); end
def example(); end
def example_group(*a, &b); end
def example_group_instance(*a, &b); end
def exception(*a, &b); end
def executed?(); end
def execution_result(*a, &b); end
def file_path(*a, &b); end
def full_description(*a, &b); end
def hash(*a, &b); end
def id(*a, &b); end
def initialize(example, &block); end
def inspect_output(*a, &b); end
def lambda?(*a, &b); end
def location(*a, &b); end
def location_rerun_argument(*a, &b); end
def metadata(*a, &b); end
def parameters(*a, &b); end
def pending(*a, &b); end
def pending?(*a, &b); end
def reporter(*a, &b); end
def rerun_argument(*a, &b); end
def run(*args, &block); end
def skip(*a, &b); end
def skipped?(*a, &b); end
def source_location(*a, &b); end
def to_proc(); end
def update_inherited_metadata(*a, &b); end
def wrap(&block); end
def yield(*a, &b); end
end
class RSpec::Core::Example::Procsy
end
class RSpec::Core::Example
def self.delegate_to_metadata(key); end
def self.parse_id(id); end
end
class RSpec::Core::ExampleGroup
include ::RSpec::Core::MemoizedHelpers
include ::RSpec::Core::Pending
def described_class(); end
def initialize(inspect_output=T.unsafe(nil)); end
INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::ExampleGroup::WrongScopeError
end
class RSpec::Core::ExampleGroup::WrongScopeError
end
class RSpec::Core::ExampleGroup
extend ::RSpec::Core::Hooks
extend ::RSpec::Core::MemoizedHelpers::ClassMethods
extend ::RSpec::Core::SharedExampleGroup
def self.add_example(example); end
def self.before_context_ivars(); end
def self.children(); end
def self.context(*args, &example_group_block); end
def self.currently_executing_a_context_hook?(); end
def self.declaration_locations(); end
def self.define_example_group_method(name, metadata=T.unsafe(nil)); end
def self.define_example_method(name, extra_options=T.unsafe(nil)); end
def self.define_nested_shared_group_method(new_name, report_label=T.unsafe(nil)); end
def self.delegate_to_metadata(*names); end
def self.descendant_filtered_examples(); end
def self.descendants(); end
def self.describe(*args, &example_group_block); end
def self.described_class(); end
def self.description(); end
def self.each_instance_variable_for_example(group); end
def self.ensure_example_groups_are_configured(); end
def self.example(*all_args, &block); end
def self.example_group(*args, &example_group_block); end
def self.examples(); end
def self.fcontext(*args, &example_group_block); end
def self.fdescribe(*args, &example_group_block); end
def self.fexample(*all_args, &block); end
def self.file_path(); end
def self.filtered_examples(); end
def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
def self.fit(*all_args, &block); end
def self.focus(*all_args, &block); end
def self.for_filtered_examples(reporter, &block); end
def self.fspecify(*all_args, &block); end
def self.id(); end
def self.idempotently_define_singleton_method(name, &definition); end
def self.include_context(name, *args, &block); end
def self.include_examples(name, *args, &block); end
def self.it(*all_args, &block); end
def self.it_behaves_like(name, *args, &customization_block); end
def self.it_should_behave_like(name, *args, &customization_block); end
def self.location(); end
def self.metadata(); end
def self.next_runnable_index_for(file); end
def self.ordering_strategy(); end
def self.parent_groups(); end
def self.pending(*all_args, &block); end
def self.remove_example(example); end
def self.reset_memoized(); end
def self.run(reporter=T.unsafe(nil)); end
def self.run_after_context_hooks(example_group_instance); end
def self.run_before_context_hooks(example_group_instance); end
def self.run_examples(reporter); end
def self.set_it_up(description, args, registration_collection, &example_group_block); end
def self.set_ivars(instance, ivars); end
def self.skip(*all_args, &block); end
def self.specify(*all_args, &block); end
def self.store_before_context_ivars(example_group_instance); end
def self.subclass(parent, description, args, registration_collection, &example_group_block); end
def self.superclass_before_context_ivars(); end
def self.superclass_metadata(); end
def self.top_level?(); end
def self.top_level_description(); end
def self.traverse_tree_until(&block); end
def self.update_inherited_metadata(updates); end
def self.with_replaced_metadata(meta); end
def self.xcontext(*args, &example_group_block); end
def self.xdescribe(*args, &example_group_block); end
def self.xexample(*all_args, &block); end
def self.xit(*all_args, &block); end
def self.xspecify(*all_args, &block); end
end
class RSpec::Core::ExampleStatusPersister
def initialize(examples, file_name); end
def persist(); end
end
class RSpec::Core::ExampleStatusPersister
def self.load_from(file_name); end
def self.persist(examples, file_name); end
end
RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
class RSpec::Core::FilterManager
def add_ids(rerun_path, scoped_ids); end
def add_location(file_path, line_numbers); end
def empty?(); end
def exclude(*args); end
def exclude_only(*args); end
def exclude_with_low_priority(*args); end
def exclusions(); end
def include(*args); end
def include_only(*args); end
def include_with_low_priority(*args); end
def inclusions(); end
def prune(examples); end
end
class RSpec::Core::FilterManager
end
class RSpec::Core::FilterRules
def [](key); end
def add(updated); end
def add_with_low_priority(updated); end
def clear(); end
def delete(key); end
def description(); end
def each_pair(&block); end
def empty?(); end
def fetch(*args, &block); end
def include_example?(example); end
def initialize(rules=T.unsafe(nil)); end
def opposite(); end
def opposite=(opposite); end
def rules(); end
def use_only(updated); end
PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped)
PROJECT_DIR = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::FilterRules
def self.build(); end
end
module RSpec::Core::FilterableItemRepository
end
class RSpec::Core::FilterableItemRepository::QueryOptimized
def items_for(metadata); end
end
class RSpec::Core::FilterableItemRepository::QueryOptimized
end
class RSpec::Core::FilterableItemRepository::UpdateOptimized
def append(item, metadata); end
def delete(item, metadata); end
def initialize(applies_predicate); end
def items_and_filters(); end
def items_for(request_meta); end
def prepend(item, metadata); end
end
class RSpec::Core::FilterableItemRepository::UpdateOptimized
end
module RSpec::Core::FilterableItemRepository
end
module RSpec::Core::FlatMap
end
module RSpec::Core::FlatMap
def self.flat_map(array, &block); end
end
module RSpec::Core::Formatters
end
class RSpec::Core::Formatters::BaseBisectFormatter
def example_failed(notification); end
def example_finished(notification); end
def initialize(expected_failures); end
def start_dump(_notification); end
end
class RSpec::Core::Formatters::BaseBisectFormatter
def self.inherited(formatter); end
end
class RSpec::Core::Formatters::BaseFormatter
def close(_notification); end
def example_group(); end
def example_group=(example_group); end
def example_group_started(notification); end
def initialize(output); end
def output(); end
def start(notification); end
end
class RSpec::Core::Formatters::BaseFormatter
end
class RSpec::Core::Formatters::BaseTextFormatter
def dump_failures(notification); end
def dump_pending(notification); end
def dump_summary(summary); end
def message(notification); end
def seed(notification); end
end
class RSpec::Core::Formatters::BaseTextFormatter
end
class RSpec::Core::Formatters::BisectDRbFormatter
def initialize(_output); end
def notify_results(results); end
end
class RSpec::Core::Formatters::BisectDRbFormatter
end
module RSpec::Core::Formatters::ConsoleCodes
VT100_CODES = ::T.let(nil, ::T.untyped)
VT100_CODE_VALUES = ::T.let(nil, ::T.untyped)
end
module RSpec::Core::Formatters::ConsoleCodes
def self.config_colors_to_methods(); end
def self.console_code_for(code_or_symbol); end
def self.wrap(text, code_or_symbol); end
end
class RSpec::Core::Formatters::DeprecationFormatter
def count(); end
def deprecation(notification); end
def deprecation_message_for(data); end
def deprecation_stream(); end
def deprecation_summary(_notification); end
def initialize(deprecation_stream, summary_stream); end
def output(); end
def printer(); end
def summary_stream(); end
DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped)
RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped)
TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
def deprecation_formatter(); end
def deprecation_stream(); end
def deprecation_summary(); end
def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
def print_deferred_deprecation_warnings(); end
def print_deprecation_message(data); end
def stash_deprecation_message(deprecation_message); end
def summary_stream(); end
TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
end
class RSpec::Core::Formatters::DeprecationFormatter::FileStream
def initialize(file); end
def puts(*args); end
def summarize(summary_stream, deprecation_count); end
end
class RSpec::Core::Formatters::DeprecationFormatter::FileStream
end
class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage
def initialize(data); end
def too_many_warnings_message(); end
def type(); end
def type=(_); end
end
class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
def deprecation_formatter(); end
def deprecation_stream(); end
def deprecation_summary(); end
def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
def print_deprecation_message(data); end
def summary_stream(); end
end
class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
end
class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
def puts(message); end
def summarize(summary_stream, deprecation_count); end
end
class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
end
class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage
def initialize(data); end
def too_many_warnings_message(); end
def type(); end
def type=(_); end
end
class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Formatters::DeprecationFormatter
end
class RSpec::Core::Formatters::DocumentationFormatter
def example_failed(failure); end
def example_group_finished(_notification); end
def example_passed(passed); end
def example_pending(pending); end
def example_started(_notification); end
end
class RSpec::Core::Formatters::DocumentationFormatter
end
class RSpec::Core::Formatters::ExceptionPresenter
def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end
def colorized_message_lines(colorizer=T.unsafe(nil)); end
def description(); end
def example(); end
def exception(); end
def formatted_backtrace(exception=T.unsafe(nil)); end
def formatted_cause(exception); end
def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end
def fully_formatted_lines(failure_number, colorizer); end
def initialize(exception, example, options=T.unsafe(nil)); end
def message_lines(); end
PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Formatters::ExceptionPresenter::Factory
def build(); end
def initialize(example); end
end
class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
def initialize(parent); end
def with_truncated_backtrace(child); end
end
class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
end
module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
end
module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
def self.format_backtrace(*_); end
end
class RSpec::Core::Formatters::ExceptionPresenter::Factory
end
class RSpec::Core::Formatters::ExceptionPresenter
end
class RSpec::Core::Formatters::FailureListFormatter
def dump_profile(_profile); end
def example_failed(failure); end
def message(_message); end
end
class RSpec::Core::Formatters::FailureListFormatter
end
class RSpec::Core::Formatters::FallbackMessageFormatter
def initialize(output); end
def message(notification); end
def output(); end
end
class RSpec::Core::Formatters::FallbackMessageFormatter
end
module RSpec::Core::Formatters::Helpers
DEFAULT_PRECISION = ::T.let(nil, ::T.untyped)
SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped)
end
module RSpec::Core::Formatters::Helpers
def self.format_duration(duration); end
def self.format_seconds(float, precision=T.unsafe(nil)); end
def self.organize_ids(ids); end
def self.pluralize(count, string); end
end
class RSpec::Core::Formatters::HtmlFormatter
def dump_summary(summary); end
def example_failed(failure); end
def example_passed(passed); end
def example_pending(pending); end
def example_started(_notification); end
def start_dump(_notification); end
end
class RSpec::Core::Formatters::HtmlFormatter
end
class RSpec::Core::Formatters::JsonFormatter
def dump_profile(profile); end
def dump_profile_slowest_example_groups(profile); end
def dump_profile_slowest_examples(profile); end
def dump_summary(summary); end
def message(notification); end
def output_hash(); end
def seed(notification); end
def stop(notification); end
end
class RSpec::Core::Formatters::JsonFormatter
end
class RSpec::Core::Formatters::Loader
def add(formatter_to_use, *paths); end
def default_formatter(); end
def default_formatter=(default_formatter); end
def formatters(); end
def initialize(reporter); end
def prepare_default(output_stream, deprecation_stream); end
def reporter(); end
def setup_default(output_stream, deprecation_stream); end
end
class RSpec::Core::Formatters::Loader
def self.formatters(); end
end
class RSpec::Core::Formatters::ProfileFormatter
def dump_profile(profile); end
def initialize(output); end
def output(); end
end
class RSpec::Core::Formatters::ProfileFormatter
end
class RSpec::Core::Formatters::ProgressFormatter
def example_failed(_notification); end
def example_passed(_notification); end
def example_pending(_notification); end
def start_dump(_notification); end
end
class RSpec::Core::Formatters::ProgressFormatter
end
class RSpec::Core::Formatters::SnippetExtractor
def beginning_line_number(); end
def expression_lines(); end
def initialize(source, beginning_line_number, max_line_count=T.unsafe(nil)); end
def max_line_count(); end
def source(); end
end
class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError
end
class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError
end
class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError
end
class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError
end
class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError
end
class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError
end
class RSpec::Core::Formatters::SnippetExtractor
def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=T.unsafe(nil)); end
def self.extract_line_at(file_path, line_number); end
def self.least_indentation_from(lines); end
def self.source_from_file(path); end
end
class RSpec::Core::Formatters::SyntaxHighlighter
def highlight(lines); end
def initialize(configuration); end
end
module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
RESET_CODE = ::T.let(nil, ::T.untyped)
end
module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
def self.highlight_syntax(lines); end
end
module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
end
module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
def self.highlight_syntax(lines); end
end
RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
class RSpec::Core::Formatters::SyntaxHighlighter
def self.attempt_to_add_rspec_terms_to_coderay_keywords(); end
end
module RSpec::Core::Formatters
def self.register(formatter_class, *notifications); end
end
module RSpec::Core::HashImitatable
def <(*args, &block); end
def <=(*args, &block); end
def >(*args, &block); end
def >=(*args, &block); end
def [](key); end
def []=(key, value); end
def all?(*args, &block); end
def any?(*args, &block); end
def assoc(*args, &block); end
def chain(*args, &block); end
def chunk(*args, &block); end
def chunk_while(*args, &block); end
def clear(*args, &block); end
def collect(*args, &block); end
def collect_concat(*args, &block); end
def compact(*args, &block); end
def compact!(*args, &block); end
def compare_by_identity(*args, &block); end
def compare_by_identity?(*args, &block); end
def count(*args, &block); end
def cycle(*args, &block); end
def default(*args, &block); end
def default=(*args, &block); end
def default_proc(*args, &block); end
def default_proc=(*args, &block); end
def delete(*args, &block); end
def delete_if(*args, &block); end
def detect(*args, &block); end
def dig(*args, &block); end
def drop(*args, &block); end
def drop_while(*args, &block); end
def each(*args, &block); end
def each_cons(*args, &block); end
def each_entry(*args, &block); end
def each_key(*args, &block); end
def each_pair(*args, &block); end
def each_slice(*args, &block); end
def each_value(*args, &block); end
def each_with_index(*args, &block); end
def each_with_object(*args, &block); end
def empty?(*args, &block); end
def entries(*args, &block); end
def fetch(*args, &block); end
def fetch_values(*args, &block); end
def filter(*args, &block); end
def filter!(*args, &block); end
def find(*args, &block); end
def find_all(*args, &block); end
def find_index(*args, &block); end
def first(*args, &block); end
def flat_map(*args, &block); end
def flatten(*args, &block); end
def grep(*args, &block); end
def grep_v(*args, &block); end
def group_by(*args, &block); end
def has_key?(*args, &block); end
def has_value?(*args, &block); end
def include?(*args, &block); end
def index(*args, &block); end
def inject(*args, &block); end
def invert(*args, &block); end
def keep_if(*args, &block); end
def key(*args, &block); end
def key?(*args, &block); end
def keys(*args, &block); end
def lazy(*args, &block); end
def length(*args, &block); end
def map(*args, &block); end
def max(*args, &block); end
def max_by(*args, &block); end
def member?(*args, &block); end
def merge(*args, &block); end
def merge!(*args, &block); end
def min(*args, &block); end
def min_by(*args, &block); end
def minmax(*args, &block); end
def minmax_by(*args, &block); end
def none?(*args, &block); end
def one?(*args, &block); end
def partition(*args, &block); end
def rassoc(*args, &block); end
def reduce(*args, &block); end
def rehash(*args, &block); end
def reject(*args, &block); end
def reject!(*args, &block); end
def replace(*args, &block); end
def reverse_each(*args, &block); end
def select(*args, &block); end
def select!(*args, &block); end
def shift(*args, &block); end
def size(*args, &block); end
def slice(*args, &block); end
def slice_after(*args, &block); end
def slice_before(*args, &block); end
def slice_when(*args, &block); end
def sort(*args, &block); end
def sort_by(*args, &block); end
def store(*args, &block); end
def sum(*args, &block); end
def take(*args, &block); end
def take_while(*args, &block); end
def to_a(*args, &block); end
def to_h(); end
def to_hash(*args, &block); end
def to_proc(*args, &block); end
def to_set(*args, &block); end
def transform_keys(*args, &block); end
def transform_keys!(*args, &block); end
def transform_values(*args, &block); end
def transform_values!(*args, &block); end
def uniq(*args, &block); end
def update(*args, &block); end
def value?(*args, &block); end
def values(*args, &block); end
def values_at(*args, &block); end
def zip(*args, &block); end
end
module RSpec::Core::HashImitatable::ClassMethods
def attr_accessor(*names); end
def hash_attribute_names(); end
end
module RSpec::Core::HashImitatable::ClassMethods
end
module RSpec::Core::HashImitatable
def self.included(klass); end
end
module RSpec::Core::Hooks
def after(*args, &block); end
def append_after(*args, &block); end
def append_before(*args, &block); end
def around(*args, &block); end
def before(*args, &block); end
def hooks(); end
def prepend_after(*args, &block); end
def prepend_before(*args, &block); end
end
class RSpec::Core::Hooks::AfterContextHook
def run(example); end
end
class RSpec::Core::Hooks::AfterContextHook
end
class RSpec::Core::Hooks::AfterHook
def run(example); end
end
class RSpec::Core::Hooks::AfterHook
end
class RSpec::Core::Hooks::AroundHook
def execute_with(example, procsy); end
def hook_description(); end
end
class RSpec::Core::Hooks::AroundHook
end
class RSpec::Core::Hooks::BeforeHook
def run(example); end
end
class RSpec::Core::Hooks::BeforeHook
end
class RSpec::Core::Hooks::Hook
def block(); end
def block=(_); end
def options(); end
def options=(_); end
end
class RSpec::Core::Hooks::Hook
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Hooks::HookCollections
def all_hooks_for(position, scope); end
def initialize(owner, filterable_item_repo_class); end
def matching_hooks_for(position, scope, example_or_group); end
def processable_hooks_for(position, scope, host); end
def register(prepend_or_append, position, *args, &block); end
def register_global_singleton_context_hooks(example, globals); end
def register_globals(host, globals); end
def run(position, scope, example_or_group); end
def run_owned_hooks_for(position, scope, example_or_group); end
EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped)
HOOK_TYPES = ::T.let(nil, ::T.untyped)
SCOPES = ::T.let(nil, ::T.untyped)
SCOPE_ALIASES = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Hooks::HookCollections
end
module RSpec::Core::Hooks
end
class RSpec::Core::InclusionRules
def add(*args); end
def add_with_low_priority(*args); end
def split_file_scoped_rules(); end
def standalone?(); end
end
class RSpec::Core::InclusionRules
end
module RSpec::Core::Invocations
end
class RSpec::Core::Invocations::Bisect
def call(options, err, out); end
end
class RSpec::Core::Invocations::Bisect
end
class RSpec::Core::Invocations::DRbWithFallback
def call(options, err, out); end
end
class RSpec::Core::Invocations::DRbWithFallback
end
class RSpec::Core::Invocations::InitializeProject
def call(*_args); end
end
class RSpec::Core::Invocations::InitializeProject
end
class RSpec::Core::Invocations::PrintHelp
def call(_options, _err, out); end
def hidden_options(); end
def hidden_options=(_); end
def parser(); end
def parser=(_); end
end
class RSpec::Core::Invocations::PrintHelp
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Invocations::PrintVersion
def call(_options, _err, out); end
end
class RSpec::Core::Invocations::PrintVersion
end
module RSpec::Core::Invocations
end
class RSpec::Core::LegacyExampleGroupHash
include ::RSpec::Core::HashImitatable
def initialize(metadata); end
end
class RSpec::Core::LegacyExampleGroupHash
extend ::RSpec::Core::HashImitatable::ClassMethods
end
module RSpec::Core::MemoizedHelpers
def initialize(*_); end
def is_expected(); end
def should(matcher=T.unsafe(nil), message=T.unsafe(nil)); end
def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil)); end
def subject(); end
end
module RSpec::Core::MemoizedHelpers::ClassMethods
def let(name, &block); end
def let!(name, &block); end
def subject(name=T.unsafe(nil), &block); end
def subject!(name=T.unsafe(nil), &block); end
end
module RSpec::Core::MemoizedHelpers::ClassMethods
end
class RSpec::Core::MemoizedHelpers::ContextHookMemoized
end
class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After
end
class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After
def self.article(); end
def self.hook_expression(); end
def self.hook_intention(); end
end
class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before
end
class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before
def self.article(); end
def self.hook_expression(); end
def self.hook_intention(); end
end
class RSpec::Core::MemoizedHelpers::ContextHookMemoized
def self.fetch_or_store(key, &_block); end
def self.isolate_for_context_hook(example_group_instance); end
end
class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
def fetch_or_store(key); end
end
class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
end
class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
def fetch_or_store(key); end
end
class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
end
module RSpec::Core::MemoizedHelpers
def self.define_helpers_on(example_group); end
def self.get_constant_or_yield(example_group, name); end
def self.module_for(example_group); end
end
module RSpec::Core::Metadata
RESERVED_KEYS = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Metadata::ExampleGroupHash
end
class RSpec::Core::Metadata::ExampleGroupHash
def self.backwards_compatibility_default_proc(&example_group_selector); end
def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
def self.hash_with_backwards_compatibility_default_proc(); end
end
class RSpec::Core::Metadata::ExampleHash
end
class RSpec::Core::Metadata::ExampleHash
def self.create(group_metadata, user_metadata, index_provider, description, block); end
end
class RSpec::Core::Metadata::HashPopulator
def block(); end
def description_args(); end
def initialize(metadata, user_metadata, index_provider, description_args, block); end
def metadata(); end
def populate(); end
def user_metadata(); end
end
class RSpec::Core::Metadata::HashPopulator
end
module RSpec::Core::Metadata
def self.ascend(metadata); end
def self.ascending(metadata); end
def self.build_hash_from(args, warn_about_example_group_filtering=T.unsafe(nil)); end
def self.deep_hash_dup(object); end
def self.id_from(metadata); end
def self.location_tuple_from(metadata); end
def self.relative_path(line); end
def self.relative_path_regex(); end
end
module RSpec::Core::MetadataFilter
end
module RSpec::Core::MetadataFilter
def self.apply?(predicate, filters, metadata); end
def self.filter_applies?(key, filter_value, metadata); end
def self.silence_metadata_example_group_deprecations(); end
end
class RSpec::Core::MultipleExceptionError
include ::RSpec::Core::MultipleExceptionError::InterfaceTag
def aggregation_block_label(); end
def aggregation_metadata(); end
def all_exceptions(); end
def exception_count_description(); end
def failures(); end
def initialize(*exceptions); end
def other_errors(); end
def summary(); end
end
module RSpec::Core::MultipleExceptionError::InterfaceTag
def add(exception); end
end
module RSpec::Core::MultipleExceptionError::InterfaceTag
def self.for(ex); end
end
class RSpec::Core::MultipleExceptionError
end
module RSpec::Core::Notifications
end
class RSpec::Core::Notifications::CustomNotification
end
class RSpec::Core::Notifications::CustomNotification
def self.for(options=T.unsafe(nil)); end
end
class RSpec::Core::Notifications::DeprecationNotification
def call_site(); end
def call_site=(_); end
def deprecated(); end
def deprecated=(_); end
def message(); end
def message=(_); end
def replacement(); end
def replacement=(_); end
end
class RSpec::Core::Notifications::DeprecationNotification
def self.[](*_); end
def self.from_hash(data); end
def self.members(); end
end
class RSpec::Core::Notifications::ExampleNotification
def example(); end
def example=(_); end
end
class RSpec::Core::Notifications::ExampleNotification
def self.[](*_); end
def self.for(example); end
def self.members(); end
end
class RSpec::Core::Notifications::ExamplesNotification
def examples(); end
def failed_examples(); end
def failure_notifications(); end
def fully_formatted_failed_examples(colorizer=T.unsafe(nil)); end
def fully_formatted_pending_examples(colorizer=T.unsafe(nil)); end
def initialize(reporter); end
def notifications(); end
def pending_examples(); end
def pending_notifications(); end
end
class RSpec::Core::Notifications::ExamplesNotification
end
class RSpec::Core::Notifications::FailedExampleNotification
def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end
def colorized_message_lines(colorizer=T.unsafe(nil)); end
def description(); end
def exception(); end
def formatted_backtrace(); end
def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end
def fully_formatted_lines(failure_number, colorizer=T.unsafe(nil)); end
def initialize(example, exception_presenter=T.unsafe(nil)); end
def message_lines(); end
end
class RSpec::Core::Notifications::FailedExampleNotification
end
class RSpec::Core::Notifications::GroupNotification
def group(); end
def group=(_); end
end
class RSpec::Core::Notifications::GroupNotification
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Notifications::MessageNotification
def message(); end
def message=(_); end
end
class RSpec::Core::Notifications::MessageNotification
def self.[](*_); end
def self.members(); end
end
module RSpec::Core::Notifications::NullColorizer
end
module RSpec::Core::Notifications::NullColorizer
def self.wrap(line, _code_or_symbol); end
end
class RSpec::Core::Notifications::NullNotification
end
class RSpec::Core::Notifications::NullNotification
end
class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification
end
class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification
end
class RSpec::Core::Notifications::PendingExampleFixedNotification
end
class RSpec::Core::Notifications::PendingExampleFixedNotification
end
class RSpec::Core::Notifications::ProfileNotification
def duration(); end
def examples(); end
def initialize(duration, examples, number_of_examples, example_groups); end
def number_of_examples(); end
def percentage(); end
def slow_duration(); end
def slowest_examples(); end
def slowest_groups(); end
end
class RSpec::Core::Notifications::ProfileNotification
end
class RSpec::Core::Notifications::SeedNotification
def fully_formatted(); end
def seed(); end
def seed=(_); end
def seed_used?(); end
def used=(_); end
end
class RSpec::Core::Notifications::SeedNotification
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Notifications::SkippedExampleNotification
def fully_formatted(pending_number, colorizer=T.unsafe(nil)); end
end
class RSpec::Core::Notifications::SkippedExampleNotification
end
class RSpec::Core::Notifications::StartNotification
def count(); end
def count=(_); end
def load_time(); end
def load_time=(_); end
end
class RSpec::Core::Notifications::StartNotification
def self.[](*_); end
def self.members(); end
end
class RSpec::Core::Notifications::SummaryNotification
include ::RSpec::Core::ShellEscape
def colorized_rerun_commands(colorizer=T.unsafe(nil)); end
def colorized_totals_line(colorizer=T.unsafe(nil)); end
def duration(); end
def duration=(_); end
def errors_outside_of_examples_count(); end
def errors_outside_of_examples_count=(_); end
def example_count(); end
def examples(); end
def examples=(_); end
def failed_examples(); end
def failed_examples=(_); end
def failure_count(); end
def formatted_duration(); end
def formatted_load_time(); end
def fully_formatted(colorizer=T.unsafe(nil)); end
def load_time(); end
def load_time=(_); end
def pending_count(); end
def pending_examples(); end
def pending_examples=(_); end
def totals_line(); end
end
class RSpec::Core::Notifications::SummaryNotification
def self.[](*_); end
def self.members(); end
end
module RSpec::Core::Notifications
end
class RSpec::Core::NullReporter
end
class RSpec::Core::NullReporter
end
module RSpec::Core::Ordering
end
class RSpec::Core::Ordering::ConfigurationManager
def force(hash); end
def order=(type); end
def ordering_registry(); end
def register_ordering(name, strategy=T.unsafe(nil)); end
def seed(); end
def seed=(seed); end
def seed_used?(); end
end
class RSpec::Core::Ordering::ConfigurationManager
end
class RSpec::Core::Ordering::Custom
def initialize(callable); end
def order(list); end
end
class RSpec::Core::Ordering::Custom
end
class RSpec::Core::Ordering::Identity
def order(items); end
end
class RSpec::Core::Ordering::Identity
end
class RSpec::Core::Ordering::Random
def initialize(configuration); end
def order(items); end
def used?(); end
MAX_32_BIT = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Ordering::Random
end
class RSpec::Core::Ordering::Registry
def fetch(name, &fallback); end
def initialize(configuration); end
def register(sym, strategy); end
def used_random_seed?(); end
end
class RSpec::Core::Ordering::Registry
end
module RSpec::Core::Ordering
end
class RSpec::Core::OutputWrapper
def <<(*args, &block); end
def advise(*args, &block); end
def autoclose=(*args, &block); end
def autoclose?(*args, &block); end
def binmode(*args, &block); end
def binmode?(*args, &block); end
def bytes(*args, &block); end
def chars(*args, &block); end
def close(*args, &block); end
def close_on_exec=(*args, &block); end
def close_on_exec?(*args, &block); end
def close_read(*args, &block); end
def close_write(*args, &block); end
def closed?(*args, &block); end
def codepoints(*args, &block); end
def each(*args, &block); end
def each_byte(*args, &block); end
def each_char(*args, &block); end
def each_codepoint(*args, &block); end
def each_line(*args, &block); end
def eof(*args, &block); end
def eof?(*args, &block); end
def external_encoding(*args, &block); end
def fcntl(*args, &block); end
def fdatasync(*args, &block); end
def fileno(*args, &block); end
def flush(*args, &block); end
def fsync(*args, &block); end
def getbyte(*args, &block); end
def getc(*args, &block); end
def gets(*args, &block); end
def initialize(output); end
def inspect(*args, &block); end
def internal_encoding(*args, &block); end
def ioctl(*args, &block); end
def isatty(*args, &block); end
def lineno(*args, &block); end
def lineno=(*args, &block); end
def lines(*args, &block); end
def method_missing(name, *args, &block); end
def nread(*args, &block); end
def output(); end
def output=(output); end
def pathconf(*args, &block); end
def pid(*args, &block); end
def pos(*args, &block); end
def pos=(*args, &block); end
def pread(*args, &block); end
def print(*args, &block); end
def printf(*args, &block); end
def putc(*args, &block); end
def puts(*args, &block); end
def pwrite(*args, &block); end
def read(*args, &block); end
def read_nonblock(*args, &block); end
def readbyte(*args, &block); end
def readchar(*args, &block); end
def readline(*args, &block); end
def readlines(*args, &block); end
def readpartial(*args, &block); end
def ready?(*args, &block); end
def reopen(*args, &block); end
def respond_to?(name, priv=T.unsafe(nil)); end
def rewind(*args, &block); end
def seek(*args, &block); end
def set_encoding(*args, &block); end
def stat(*args, &block); end
def sync(*args, &block); end
def sync=(*args, &block); end
def sysread(*args, &block); end
def sysseek(*args, &block); end
def syswrite(*args, &block); end
def tell(*args, &block); end
def to_i(*args, &block); end
def to_io(*args, &block); end
def tty?(*args, &block); end
def ungetbyte(*args, &block); end
def ungetc(*args, &block); end
def wait(*args, &block); end
def wait_readable(*args, &block); end
def wait_writable(*args, &block); end
def write(*args, &block); end
def write_nonblock(*args, &block); end
end
class RSpec::Core::OutputWrapper
end
class RSpec::Core::Parser
def initialize(original_args); end
def original_args(); end
def parse(source=T.unsafe(nil)); end
end
class RSpec::Core::Parser
def self.parse(args, source=T.unsafe(nil)); end
end
module RSpec::Core::Pending
def pending(message=T.unsafe(nil)); end
def skip(message=T.unsafe(nil)); end
NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped)
NO_REASON_GIVEN = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Pending::PendingExampleFixedError
end
class RSpec::Core::Pending::PendingExampleFixedError
end
class RSpec::Core::Pending::SkipDeclaredInExample
def argument(); end
def initialize(argument); end
end
class RSpec::Core::Pending::SkipDeclaredInExample
end
module RSpec::Core::Pending
def self.mark_fixed!(example); end
def self.mark_pending!(example, message_or_bool); end
def self.mark_skipped!(example, message_or_bool); end
end
class RSpec::Core::Profiler
def example_group_finished(notification); end
def example_group_started(notification); end
def example_groups(); end
def example_started(notification); end
NOTIFICATIONS = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Profiler
end
class RSpec::Core::Reporter
def abort_with(msg, exit_status); end
def close_after(); end
def deprecation(hash); end
def example_failed(example); end
def example_finished(example); end
def example_group_finished(group); end
def example_group_started(group); end
def example_passed(example); end
def example_pending(example); end
def example_started(example); end
def examples(); end
def exit_early(exit_code); end
def fail_fast_limit_met?(); end
def failed_examples(); end
def finish(); end
def initialize(configuration); end
def message(message); end
def notify(event, notification); end
def notify_non_example_exception(exception, context_description); end
def pending_examples(); end
def prepare_default(loader, output_stream, deprecation_stream); end
def publish(event, options=T.unsafe(nil)); end
def register_listener(listener, *notifications); end
def registered_listeners(notification); end
def report(expected_example_count); end
def start(expected_example_count, time=T.unsafe(nil)); end
def stop(); end
RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped)
end
class RSpec::Core::Reporter
end
module RSpec::Core::RubyProject
end
module RSpec::Core::RubyProject
def self.add_dir_to_load_path(dir); end
def self.add_to_load_path(*dirs); end
def self.ascend_until(); end
def self.determine_root(); end
def self.find_first_parent_containing(dir); end
def self.root(); end
end
class RSpec::Core::Runner
def configuration(); end
def configure(err, out); end
def initialize(options, configuration=T.unsafe(nil), world=T.unsafe(nil)); end
def options(); end
def run(err, out); end
def run_specs(example_groups); end
def setup(err, out); end
def world(); end
end
class RSpec::Core::Runner
def self.autorun(); end
def self.autorun_disabled?(); end
def self.disable_autorun!(); end
def self.handle_interrupt(); end
def self.installed_at_exit?(); end
def self.invoke(); end
def self.perform_at_exit(); end
def self.run(args, err=T.unsafe(nil), out=T.unsafe(nil)); end
def self.running_in_drb?(); end
def self.trap_interrupt(); end
end
class RSpec::Core::Set
include ::Enumerable
def <<(key); end
def clear(); end
def delete(key); end
def each(&block); end
def empty?(); end
def include?(key); end
def initialize(array=T.unsafe(nil)); end
def merge(values); end
end
class RSpec::Core::Set
end
module RSpec::Core::SharedContext
def __shared_context_recordings(); end
def after(*args, &block); end
def append_after(*args, &block); end
def append_before(*args, &block); end
def around(*args, &block); end
def before(*args, &block); end
def context(*args, &block); end
def describe(*args, &block); end
def hooks(*args, &block); end
def included(group); end
def let(*args, &block); end
def let!(*args, &block); end
def prepend_after(*args, &block); end
def prepend_before(*args, &block); end
def subject(*args, &block); end
def subject!(*args, &block); end
end
class RSpec::Core::SharedContext::Recording
def args(); end
def args=(_); end
def block(); end
def block=(_); end
def method_name(); end
def method_name=(_); end
def playback_onto(group); end
end
class RSpec::Core::SharedContext::Recording
def self.[](*_); end
def self.members(); end
end
module RSpec::Core::SharedContext
def self.record(methods); end
end
module RSpec::Core::SharedExampleGroup
def shared_context(name, *args, &block); end
def shared_examples(name, *args, &block); end
def shared_examples_for(name, *args, &block); end
end
class RSpec::Core::SharedExampleGroup::Registry
def add(context, name, *metadata_args, &block); end
def find(lookup_contexts, name); end
end
class RSpec::Core::SharedExampleGroup::Registry
end
module RSpec::Core::SharedExampleGroup::TopLevelDSL
end
module RSpec::Core::SharedExampleGroup::TopLevelDSL
def self.definitions(); end
def self.expose_globally!(); end
def self.exposed_globally?(); end
def self.remove_globally!(); end
end
module RSpec::Core::SharedExampleGroup
end
class RSpec::Core::SharedExampleGroupInclusionStackFrame
def description(); end
def formatted_inclusion_location(); end
def inclusion_location(); end
def initialize(shared_group_name, inclusion_location); end
def shared_group_name(); end
end
class RSpec::Core::SharedExampleGroupInclusionStackFrame
def self.current_backtrace(); end
def self.shared_example_group_inclusions(); end
def self.with_frame(name, location); end
end
class RSpec::Core::SharedExampleGroupModule
def definition(); end
def include_in(klass, inclusion_line, args, customization_block); end
def included(klass); end
def initialize(description, definition, metadata); end
end
class RSpec::Core::SharedExampleGroupModule
end
module RSpec::Core::ShellEscape
SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped)
end
module RSpec::Core::ShellEscape
def self.conditionally_quote(id); end
def self.escape(shell_command); end
def self.quote(argument); end
def self.shell_allows_unquoted_ids?(); end
end
class RSpec::Core::SuiteHookContext
def initialize(hook_description, reporter); end
end
class RSpec::Core::SuiteHookContext
end
class RSpec::Core::Time
end
class RSpec::Core::Time
def self.now(); end
end
module RSpec::Core::Version
STRING = ::T.let(nil, ::T.untyped)
end
module RSpec::Core::Version
end
module RSpec::Core::Warnings
def deprecate(deprecated, data=T.unsafe(nil)); end
def warn_deprecation(message, opts=T.unsafe(nil)); end
def warn_with(message, options=T.unsafe(nil)); end
end
module RSpec::Core::Warnings
end
class RSpec::Core::World
def all_example_groups(); end
def all_examples(); end
def announce_exclusion_filter(announcements); end
def announce_filters(); end
def announce_inclusion_filter(announcements); end
def everything_filtered_message(); end
def example_count(groups=T.unsafe(nil)); end
def example_groups(); end
def exclusion_filter(); end
def filter_manager(); end
def filtered_examples(); end
def inclusion_filter(); end
def initialize(configuration=T.unsafe(nil)); end
def non_example_failure(); end
def non_example_failure=(non_example_failure); end
def num_example_groups_defined_in(file); end
def ordered_example_groups(); end
def preceding_declaration_line(absolute_file_name, filter_line); end
def prepare_example_filtering(); end
def record(example_group); end
def registered_example_group_files(); end
def report_filter_message(message); end
def reporter(); end
def reset(); end
def shared_example_group_registry(); end
def source_from_file(path); end
def syntax_highlighter(); end
def traverse_example_group_trees_until(&block); end
def wants_to_quit(); end
def wants_to_quit=(wants_to_quit); end
end
module RSpec::Core::World::Null
end
module RSpec::Core::World::Null
def self.all_example_groups(); end
def self.example_groups(); end
def self.non_example_failure(); end
def self.non_example_failure=(_); end
def self.registered_example_group_files(); end
def self.traverse_example_group_trees_until(); end
end
class RSpec::Core::World
end
module RSpec::Core
def self.path_to_executable(); end
end
module RSpec::ExampleGroups
end
module RSpec::ExampleGroups
extend ::RSpec::Support::RecursiveConstMethods
def self.assign_const(group); end
def self.base_name_for(group); end
def self.constant_scope_for(group); end
def self.disambiguate(name, const_scope); end
def self.remove_all_constants(); end
end
RSpec::SharedContext = RSpec::Core::SharedContext
module RSpec::Support
DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped)
DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped)
end
module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
AVOID_RESCUING = ::T.let(nil, ::T.untyped)
end
module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
def self.===(exception); end
end
class RSpec::Support::ComparableVersion
include ::Comparable
def initialize(string); end
def segments(); end
def string(); end
end
class RSpec::Support::ComparableVersion
end
class RSpec::Support::Differ
def color?(); end
def diff(actual, expected); end
def diff_as_object(actual, expected); end
def diff_as_string(actual, expected); end
def initialize(opts=T.unsafe(nil)); end
end
class RSpec::Support::Differ
end
class RSpec::Support::DirectoryMaker
end
class RSpec::Support::DirectoryMaker
def self.mkdir_p(path); end
end
class RSpec::Support::EncodedString
def <<(string); end
def ==(*args, &block); end
def empty?(*args, &block); end
def encoding(*args, &block); end
def eql?(*args, &block); end
def initialize(string, encoding=T.unsafe(nil)); end
def lines(*args, &block); end
def source_encoding(); end
def split(regex_or_string); end
def to_str(); end
REPLACE = ::T.let(nil, ::T.untyped)
US_ASCII = ::T.let(nil, ::T.untyped)
UTF_8 = ::T.let(nil, ::T.untyped)
end
class RSpec::Support::EncodedString
def self.pick_encoding(source_a, source_b); end
end
RSpec::Support::Mutex = Thread::Mutex
module RSpec::Support::OS
end
module RSpec::Support::OS
def self.windows?(); end
def self.windows_file_path?(); end
end
module RSpec::Support::RecursiveConstMethods
def const_defined_on?(mod, const_name); end
def constants_defined_on(mod); end
def get_const_defined_on(mod, const_name); end
def normalize_const_name(const_name); end
def recursive_const_defined?(const_name); end
def recursive_const_get(const_name); end
end
module RSpec::Support::RecursiveConstMethods
end
class RSpec::Support::ReentrantMutex
def synchronize(); end
end
class RSpec::Support::ReentrantMutex
end
module RSpec::Support::Ruby
end
module RSpec::Support::Ruby
def self.jruby?(); end
def self.jruby_9000?(); end
def self.jruby_version(); end
def self.mri?(); end
def self.non_mri?(); end
def self.rbx?(); end
end
module RSpec::Support::RubyFeatures
end
module RSpec::Support::RubyFeatures
def self.caller_locations_supported?(); end
def self.fork_supported?(); end
def self.kw_args_supported?(); end
def self.module_prepends_supported?(); end
def self.module_refinement_supported?(); end
def self.optional_and_splat_args_supported?(); end
def self.required_kw_args_supported?(); end
def self.ripper_supported?(); end
def self.supports_exception_cause?(); end
def self.supports_rebinding_module_methods?(); end
def self.supports_taint?(); end
end
module RSpec::Support::Version
STRING = ::T.let(nil, ::T.untyped)
end
module RSpec::Support::Version
end
module RSpec::Support::Warnings
def deprecate(deprecated, options=T.unsafe(nil)); end
def warn_deprecation(message, options=T.unsafe(nil)); end
def warn_with(message, options=T.unsafe(nil)); end
def warning(text, options=T.unsafe(nil)); end
end
module RSpec::Support::Warnings
end
module RSpec::Support
def self.class_of(object); end
def self.define_optimized_require_for_rspec(lib, &require_relative); end
def self.deregister_matcher_definition(&block); end
def self.failure_notifier(); end
def self.failure_notifier=(callable); end
def self.is_a_matcher?(object); end
def self.matcher_definitions(); end
def self.method_handle_for(object, method_name); end
def self.notify_failure(failure, options=T.unsafe(nil)); end
def self.register_matcher_definition(&block); end
def self.require_rspec_core(f); end
def self.require_rspec_support(f); end
def self.rspec_description_for_object(object); end
def self.thread_local_data(); end
def self.warning_notifier(); end
def self.warning_notifier=(warning_notifier); end
def self.with_failure_notifier(callable); end
end
module RSpec::Version
STRING = ::T.let(nil, ::T.untyped)
end
module RSpec::Version
end
module RSpec
extend ::RSpec::Support::Warnings
extend ::RSpec::Core::Warnings
def self.clear_examples(); end
def self.configuration(); end
def self.configuration=(configuration); end
def self.configure(); end
def self.const_missing(name); end
def self.context(*args, &example_group_block); end
def self.current_example(); end
def self.current_example=(example); end
def self.describe(*args, &example_group_block); end
def self.example_group(*args, &example_group_block); end
def self.fcontext(*args, &example_group_block); end
def self.fdescribe(*args, &example_group_block); end
def self.reset(); end
def self.world(); end
def self.world=(world); end
def self.xcontext(*args, &example_group_block); end
def self.xdescribe(*args, &example_group_block); end
end
module Racc
Racc_No_Extensions = ::T.let(nil, ::T.untyped)
end
class Racc::CparseParams
end
class Racc::CparseParams
end
class Racc::Parser
Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped)
Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped)
Racc_Runtime_Revision = ::T.let(nil, ::T.untyped)
Racc_Runtime_Type = ::T.let(nil, ::T.untyped)
Racc_Runtime_Version = ::T.let(nil, ::T.untyped)
Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped)
end
module Rack
CACHE_CONTROL = ::T.let(nil, ::T.untyped)
CONTENT_LENGTH = ::T.let(nil, ::T.untyped)
CONTENT_TYPE = ::T.let(nil, ::T.untyped)
DELETE = ::T.let(nil, ::T.untyped)
ETAG = ::T.let(nil, ::T.untyped)
EXPIRES = ::T.let(nil, ::T.untyped)
GET = ::T.let(nil, ::T.untyped)
HEAD = ::T.let(nil, ::T.untyped)
HTTPS = ::T.let(nil, ::T.untyped)
HTTP_COOKIE = ::T.let(nil, ::T.untyped)
HTTP_HOST = ::T.let(nil, ::T.untyped)
HTTP_PORT = ::T.let(nil, ::T.untyped)
HTTP_VERSION = ::T.let(nil, ::T.untyped)
LINK = ::T.let(nil, ::T.untyped)
OPTIONS = ::T.let(nil, ::T.untyped)
PATCH = ::T.let(nil, ::T.untyped)
PATH_INFO = ::T.let(nil, ::T.untyped)
POST = ::T.let(nil, ::T.untyped)
PUT = ::T.let(nil, ::T.untyped)
QUERY_STRING = ::T.let(nil, ::T.untyped)
RACK_ERRORS = ::T.let(nil, ::T.untyped)
RACK_HIJACK = ::T.let(nil, ::T.untyped)
RACK_HIJACK_IO = ::T.let(nil, ::T.untyped)
RACK_INPUT = ::T.let(nil, ::T.untyped)
RACK_IS_HIJACK = ::T.let(nil, ::T.untyped)
RACK_LOGGER = ::T.let(nil, ::T.untyped)
RACK_METHODOVERRIDE_ORIGINAL_METHOD = ::T.let(nil, ::T.untyped)
RACK_MULTIPART_BUFFER_SIZE = ::T.let(nil, ::T.untyped)
RACK_MULTIPART_TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped)
RACK_MULTIPROCESS = ::T.let(nil, ::T.untyped)
RACK_MULTITHREAD = ::T.let(nil, ::T.untyped)
RACK_RECURSIVE_INCLUDE = ::T.let(nil, ::T.untyped)
RACK_REQUEST_COOKIE_HASH = ::T.let(nil, ::T.untyped)
RACK_REQUEST_COOKIE_STRING = ::T.let(nil, ::T.untyped)
RACK_REQUEST_FORM_HASH = ::T.let(nil, ::T.untyped)
RACK_REQUEST_FORM_INPUT = ::T.let(nil, ::T.untyped)
RACK_REQUEST_FORM_VARS = ::T.let(nil, ::T.untyped)
RACK_REQUEST_QUERY_HASH = ::T.let(nil, ::T.untyped)
RACK_REQUEST_QUERY_STRING = ::T.let(nil, ::T.untyped)
RACK_RUNONCE = ::T.let(nil, ::T.untyped)
RACK_SESSION = ::T.let(nil, ::T.untyped)
RACK_SESSION_OPTIONS = ::T.let(nil, ::T.untyped)
RACK_SESSION_UNPACKED_COOKIE_DATA = ::T.let(nil, ::T.untyped)
RACK_SHOWSTATUS_DETAIL = ::T.let(nil, ::T.untyped)
RACK_TEMPFILES = ::T.let(nil, ::T.untyped)
RACK_URL_SCHEME = ::T.let(nil, ::T.untyped)
RACK_VERSION = ::T.let(nil, ::T.untyped)
RELEASE = ::T.let(nil, ::T.untyped)
REQUEST_METHOD = ::T.let(nil, ::T.untyped)
REQUEST_PATH = ::T.let(nil, ::T.untyped)
SCRIPT_NAME = ::T.let(nil, ::T.untyped)
SERVER_NAME = ::T.let(nil, ::T.untyped)
SERVER_PORT = ::T.let(nil, ::T.untyped)
SERVER_PROTOCOL = ::T.let(nil, ::T.untyped)
SET_COOKIE = ::T.let(nil, ::T.untyped)
TRACE = ::T.let(nil, ::T.untyped)
TRANSFER_ENCODING = ::T.let(nil, ::T.untyped)
UNLINK = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class Rack::Auth::AbstractHandler
def initialize(app, realm=T.unsafe(nil), &authenticator); end
def realm(); end
def realm=(realm); end
end
class Rack::Auth::AbstractHandler
end
class Rack::Auth::AbstractRequest
def initialize(env); end
def params(); end
def parts(); end
def provided?(); end
def request(); end
def scheme(); end
def valid?(); end
AUTHORIZATION_KEYS = ::T.let(nil, ::T.untyped)
end
class Rack::Auth::AbstractRequest
end
class Rack::Auth::Basic
def call(env); end
end
class Rack::Auth::Basic::Request
def basic?(); end
def credentials(); end
def username(); end
end
class Rack::Auth::Basic::Request
end
module Rack::Auth::Digest
end
class Rack::Auth::Digest::MD5
def call(env); end
def initialize(app, realm=T.unsafe(nil), opaque=T.unsafe(nil), &authenticator); end
def opaque(); end
def opaque=(opaque); end
def passwords_hashed=(passwords_hashed); end
def passwords_hashed?(); end
QOP = ::T.let(nil, ::T.untyped)
end
class Rack::Auth::Digest::MD5
end
class Rack::Auth::Digest::Nonce
def digest(); end
def fresh?(); end
def initialize(timestamp=T.unsafe(nil), given_digest=T.unsafe(nil)); end
def stale?(); end
def valid?(); end
end
class Rack::Auth::Digest::Nonce
def self.parse(string); end
def self.private_key(); end
def self.private_key=(private_key); end
def self.time_limit(); end
def self.time_limit=(time_limit); end
end
class Rack::Auth::Digest::Params
def [](k); end
def []=(k, v); end
def initialize(); end
def quote(str); end
UNQUOTED = ::T.let(nil, ::T.untyped)
end
class Rack::Auth::Digest::Params
def self.dequote(str); end
def self.parse(str); end
def self.split_header_value(str); end
end
class Rack::Auth::Digest::Request
def correct_uri?(); end
def digest?(); end
def method(); end
def method_missing(sym, *args); end
def nonce(); end
def respond_to?(sym, *_); end
end
class Rack::Auth::Digest::Request
end
module Rack::Auth::Digest
end
class Rack::BodyProxy
def close(); end
def closed?(); end
def initialize(body, &block); end
def method_missing(method_name, *args, &block); end
end
class Rack::BodyProxy
end
class Rack::Builder
def call(env); end
def freeze_app(); end
def initialize(default_app=T.unsafe(nil), &block); end
def map(path, &block); end
def run(app); end
def to_app(); end
def use(middleware, *args, &block); end
def warmup(prc=T.unsafe(nil), &block); end
UTF_8_BOM = ::T.let(nil, ::T.untyped)
end
class Rack::Builder
def self.app(default_app=T.unsafe(nil), &block); end
def self.load_file(path, opts=T.unsafe(nil)); end
def self.new_from_string(builder_script, file=T.unsafe(nil)); end
def self.parse_file(config, opts=T.unsafe(nil)); end
end
class Rack::Cascade
def <<(app); end
def add(app); end
def apps(); end
def call(env); end
def include?(app); end
def initialize(apps, cascade_for=T.unsafe(nil)); end
NotFound = ::T.let(nil, ::T.untyped)
end
class Rack::Cascade
end
class Rack::Chunked
include ::Rack::Utils
def call(env); end
def chunkable_version?(ver); end
def initialize(app); end
end
class Rack::Chunked::Body
def close(); end
def each(&block); end
def initialize(body); end
TAIL = ::T.let(nil, ::T.untyped)
TERM = ::T.let(nil, ::T.untyped)
end
class Rack::Chunked::Body
end
class Rack::Chunked::TrailerBody
end
class Rack::Chunked::TrailerBody
end
class Rack::Chunked
end
class Rack::CommonLogger
def call(env); end
def initialize(app, logger=T.unsafe(nil)); end
FORMAT = ::T.let(nil, ::T.untyped)
end
class Rack::CommonLogger
end
class Rack::ConditionalGet
def call(env); end
def initialize(app); end
end
class Rack::ConditionalGet
end
class Rack::Config
def call(env); end
def initialize(app, &block); end
end
class Rack::Config
end
class Rack::ContentLength
include ::Rack::Utils
def call(env); end
def initialize(app); end
end
class Rack::ContentLength
end
class Rack::ContentType
include ::Rack::Utils
def call(env); end
def initialize(app, content_type=T.unsafe(nil)); end
end
class Rack::ContentType
end
class Rack::Deflater
def call(env); end
def initialize(app, options=T.unsafe(nil)); end
end
class Rack::Deflater::GzipStream
def close(); end
def each(&block); end
def initialize(body, mtime, sync); end
def write(data); end
end
class Rack::Deflater::GzipStream
end
class Rack::Deflater
end
class Rack::Directory
def call(env); end
def check_bad_request(path_info); end
def check_forbidden(path_info); end
def entity_not_found(path_info); end
def filesize_format(int); end
def get(env); end
def initialize(root, app=T.unsafe(nil)); end
def list_directory(path_info, path, script_name); end
def list_path(env, path, path_info, script_name); end
def root(); end
def stat(path); end
DIR_FILE = ::T.let(nil, ::T.untyped)
DIR_PAGE_FOOTER = ::T.let(nil, ::T.untyped)
DIR_PAGE_HEADER = ::T.let(nil, ::T.untyped)
FILESIZE_FORMAT = ::T.let(nil, ::T.untyped)
end
class Rack::Directory::DirectoryBody
end
class Rack::Directory::DirectoryBody
end
class Rack::Directory
end
class Rack::ETag
def call(env); end
def initialize(app, no_cache_control=T.unsafe(nil), cache_control=T.unsafe(nil)); end
DEFAULT_CACHE_CONTROL = ::T.let(nil, ::T.untyped)
ETAG_STRING = ::T.let(nil, ::T.untyped)
end
class Rack::ETag
end
class Rack::Events
def call(env); end
def initialize(app, handlers); end
end
module Rack::Events::Abstract
def on_commit(req, res); end
def on_error(req, res, e); end
def on_finish(req, res); end
def on_send(req, res); end
def on_start(req, res); end
end
module Rack::Events::Abstract
end
class Rack::Events::BufferedResponse
def body(); end
def initialize(status, headers, body); end
def to_a(); end
end
class Rack::Events::BufferedResponse
end
class Rack::Events::EventedBodyProxy
def each(&blk); end
def initialize(body, request, response, handlers, &block); end
def request(); end
def response(); end
end
class Rack::Events::EventedBodyProxy
end
class Rack::Events
end
Rack::File = Rack::Files
class Rack::Files
def call(env); end
def get(env); end
def initialize(root, headers=T.unsafe(nil), default_mime=T.unsafe(nil)); end
def root(); end
def serving(request, path); end
ALLOWED_VERBS = ::T.let(nil, ::T.untyped)
ALLOW_HEADER = ::T.let(nil, ::T.untyped)
MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
end
class Rack::Files::BaseIterator
def bytesize(); end
def close(); end
def each(&blk); end
def initialize(path, ranges, options); end
def options(); end
def path(); end
def ranges(); end
end
class Rack::Files::BaseIterator
end
class Rack::Files::Iterator
def to_path(); end
end
class Rack::Files::Iterator
end
class Rack::Files
def self.method_added(name); end
end
class Rack::ForwardRequest
def env(); end
def initialize(url, env=T.unsafe(nil)); end
def url(); end
end
class Rack::ForwardRequest
end
module Rack::Handler
end
class Rack::Handler::CGI
end
class Rack::Handler::CGI
def self.run(app, **options); end
def self.send_body(body); end
def self.send_headers(status, headers); end
def self.serve(app); end
end
class Rack::Handler::WEBrick
def initialize(server, app); end
end
class Rack::Handler::WEBrick
def self.run(app, **options); end
def self.shutdown(); end
def self.valid_options(); end
end
module Rack::Handler
def self.default(); end
def self.get(server); end
def self.pick(server_names); end
def self.register(server, klass); end
def self.try_require(prefix, const_name); end
end
class Rack::Head
def call(env); end
def initialize(app); end
end
class Rack::Head
end
class Rack::Lint
include ::Rack::Lint::Assertion
def _call(env); end
def call(env=T.unsafe(nil)); end
def check_content_length(status, headers); end
def check_content_type(status, headers); end
def check_env(env); end
def check_error(error); end
def check_headers(header); end
def check_hijack(env); end
def check_hijack_response(headers, env); end
def check_input(input); end
def check_status(status); end
def close(); end
def each(&blk); end
def initialize(app); end
def verify_content_length(bytes); end
end
module Rack::Lint::Assertion
def assert(message); end
end
module Rack::Lint::Assertion
end
class Rack::Lint::ErrorWrapper
include ::Rack::Lint::Assertion
def close(*args); end
def flush(); end
def initialize(error); end
def puts(str); end
def write(str); end
end
class Rack::Lint::ErrorWrapper
end
class Rack::Lint::HijackWrapper
include ::Rack::Lint::Assertion
def close(*args, &block); end
def close_read(*args, &block); end
def close_write(*args, &block); end
def closed?(*args, &block); end
def flush(*args, &block); end
def initialize(io); end
def read(*args, &block); end
def read_nonblock(*args, &block); end
def write(*args, &block); end
def write_nonblock(*args, &block); end
REQUIRED_METHODS = ::T.let(nil, ::T.untyped)
end
class Rack::Lint::HijackWrapper
extend ::Forwardable
end
class Rack::Lint::InputWrapper
include ::Rack::Lint::Assertion
def close(*args); end
def each(*args, &blk); end
def gets(*args); end
def initialize(input); end
def read(*args); end
def rewind(*args); end
end
class Rack::Lint::InputWrapper
end
class Rack::Lint::LintError
end
class Rack::Lint::LintError
end
class Rack::Lint
end
class Rack::Lock
def call(env); end
def initialize(app, mutex=T.unsafe(nil)); end
end
class Rack::Lock
end
class Rack::Logger
def call(env); end
def initialize(app, level=T.unsafe(nil)); end
end
class Rack::Logger
end
class Rack::MediaType
SPLIT_PATTERN = ::T.let(nil, ::T.untyped)
end
class Rack::MediaType
def self.params(content_type); end
def self.type(content_type); end
end
class Rack::MethodOverride
def call(env); end
def initialize(app); end
def method_override(env); end
ALLOWED_METHODS = ::T.let(nil, ::T.untyped)
HTTP_METHODS = ::T.let(nil, ::T.untyped)
HTTP_METHOD_OVERRIDE_HEADER = ::T.let(nil, ::T.untyped)
METHOD_OVERRIDE_PARAM_KEY = ::T.let(nil, ::T.untyped)
end
class Rack::MethodOverride
end
module Rack::Mime
MIME_TYPES = ::T.let(nil, ::T.untyped)
end
module Rack::Mime
def self.match?(value, matcher); end
def self.mime_type(ext, fallback=T.unsafe(nil)); end
end
class Rack::MockRequest
def delete(uri, opts=T.unsafe(nil)); end
def get(uri, opts=T.unsafe(nil)); end
def head(uri, opts=T.unsafe(nil)); end
def initialize(app); end
def options(uri, opts=T.unsafe(nil)); end
def patch(uri, opts=T.unsafe(nil)); end
def post(uri, opts=T.unsafe(nil)); end
def put(uri, opts=T.unsafe(nil)); end
def request(method=T.unsafe(nil), uri=T.unsafe(nil), opts=T.unsafe(nil)); end
DEFAULT_ENV = ::T.let(nil, ::T.untyped)
end
class Rack::MockRequest::FatalWarner
def flush(); end
def puts(warning); end
def string(); end
def write(warning); end
end
class Rack::MockRequest::FatalWarner
end
class Rack::MockRequest::FatalWarning
end
class Rack::MockRequest::FatalWarning
end
class Rack::MockRequest
def self.env_for(uri=T.unsafe(nil), opts=T.unsafe(nil)); end
def self.parse_uri_rfc2396(uri); end
end
class Rack::MockResponse
def =~(other); end
def cookie(name); end
def cookies(); end
def errors(); end
def errors=(errors); end
def initialize(status, headers, body, errors=T.unsafe(nil)); end
def match(other); end
def original_headers(); end
end
class Rack::MockResponse
def self.[](*_); end
end
class Rack::MockSession
def after_request(&block); end
def clear_cookies(); end
def cookie_jar(); end
def cookie_jar=(cookie_jar); end
def default_host(); end
def initialize(app, default_host=T.unsafe(nil)); end
def last_request(); end
def last_response(); end
def request(uri, env); end
def set_cookie(cookie, uri=T.unsafe(nil)); end
end
class Rack::MockSession
end
module Rack::Multipart
ATTRIBUTE = ::T.let(nil, ::T.untyped)
ATTRIBUTE_CHAR = ::T.let(nil, ::T.untyped)
BROKEN_QUOTED = ::T.let(nil, ::T.untyped)
BROKEN_UNQUOTED = ::T.let(nil, ::T.untyped)
CONDISP = ::T.let(nil, ::T.untyped)
DISPPARM = ::T.let(nil, ::T.untyped)
EOL = ::T.let(nil, ::T.untyped)
EXTENDED_INITIAL_NAME = ::T.let(nil, ::T.untyped)
EXTENDED_INITIAL_PARAMETER = ::T.let(nil, ::T.untyped)
EXTENDED_INITIAL_VALUE = ::T.let(nil, ::T.untyped)
EXTENDED_OTHER_NAME = ::T.let(nil, ::T.untyped)
EXTENDED_OTHER_PARAMETER = ::T.let(nil, ::T.untyped)
EXTENDED_OTHER_VALUE = ::T.let(nil, ::T.untyped)
EXTENDED_PARAMETER = ::T.let(nil, ::T.untyped)
MULTIPART = ::T.let(nil, ::T.untyped)
MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
MULTIPART_CONTENT_DISPOSITION = ::T.let(nil, ::T.untyped)
MULTIPART_CONTENT_ID = ::T.let(nil, ::T.untyped)
MULTIPART_CONTENT_TYPE = ::T.let(nil, ::T.untyped)
REGULAR_PARAMETER = ::T.let(nil, ::T.untyped)
REGULAR_PARAMETER_NAME = ::T.let(nil, ::T.untyped)
RFC2183 = ::T.let(nil, ::T.untyped)
SECTION = ::T.let(nil, ::T.untyped)
TOKEN = ::T.let(nil, ::T.untyped)
VALUE = ::T.let(nil, ::T.untyped)
end
class Rack::Multipart::Generator
def dump(); end
def initialize(params, first=T.unsafe(nil)); end
end
class Rack::Multipart::Generator
end
class Rack::Multipart::MultipartPartLimitError
end
class Rack::Multipart::MultipartPartLimitError
end
class Rack::Multipart::Parser
def initialize(boundary, tempfile, bufsize, query_parser); end
def on_read(content); end
def result(); end
def state(); end
BOUNDARY_REGEX = ::T.let(nil, ::T.untyped)
BUFSIZE = ::T.let(nil, ::T.untyped)
CHARSET = ::T.let(nil, ::T.untyped)
EMPTY = ::T.let(nil, ::T.untyped)
TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped)
TEXT_PLAIN = ::T.let(nil, ::T.untyped)
end
class Rack::Multipart::Parser::BoundedIO
def initialize(io, content_length); end
def read(size, outbuf=T.unsafe(nil)); end
def rewind(); end
end
class Rack::Multipart::Parser::BoundedIO
end
class Rack::Multipart::Parser::Collector
include ::Enumerable
def each(&blk); end
def initialize(tempfile); end
def on_mime_body(mime_index, content); end
def on_mime_finish(mime_index); end
def on_mime_head(mime_index, head, filename, content_type, name); end
end
class Rack::Multipart::Parser::Collector::BufferPart
def close(); end
def file?(); end
end
class Rack::Multipart::Parser::Collector::BufferPart
end
class Rack::Multipart::Parser::Collector::MimePart
def get_data(); end
end
class Rack::Multipart::Parser::Collector::MimePart
end
class Rack::Multipart::Parser::Collector::TempfilePart
def close(); end
def file?(); end
end
class Rack::Multipart::Parser::Collector::TempfilePart
end
class Rack::Multipart::Parser::Collector
end
class Rack::Multipart::Parser::MultipartInfo
def params(); end
def params=(_); end
def tmp_files(); end
def tmp_files=(_); end
end
class Rack::Multipart::Parser::MultipartInfo
def self.[](*_); end
def self.members(); end
end
class Rack::Multipart::Parser
def self.parse(io, content_length, content_type, tmpfile, bufsize, qp); end
def self.parse_boundary(content_type); end
end
class Rack::Multipart::UploadedFile
def content_type(); end
def content_type=(content_type); end
def initialize(filepath=T.unsafe(nil), ct=T.unsafe(nil), bin=T.unsafe(nil), path: T.unsafe(nil), content_type: T.unsafe(nil), binary: T.unsafe(nil), filename: T.unsafe(nil), io: T.unsafe(nil)); end
def local_path(); end
def method_missing(method_name, *args, &block); end
def original_filename(); end
def path(); end
def respond_to?(*args); end
end
class Rack::Multipart::UploadedFile
end
module Rack::Multipart
def self.build_multipart(params, first=T.unsafe(nil)); end
def self.extract_multipart(req, params=T.unsafe(nil)); end
def self.parse_multipart(env, params=T.unsafe(nil)); end
end
class Rack::NullLogger
def <<(msg); end
def add(severity, message=T.unsafe(nil), progname=T.unsafe(nil), &block); end
def call(env); 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 error(progname=T.unsafe(nil), &block); end
def error?(); end
def fatal(progname=T.unsafe(nil), &block); end
def fatal?(); end
def formatter(); end
def formatter=(formatter); end
def info(progname=T.unsafe(nil), &block); end
def info?(); end
def initialize(app); end
def level(); end
def level=(level); end
def progname(); end
def progname=(progname); end
def sev_threshold(); end
def sev_threshold=(sev_threshold); end
def unknown(progname=T.unsafe(nil), &block); end
def warn(progname=T.unsafe(nil), &block); end
def warn?(); end
end
class Rack::NullLogger
end
class Rack::QueryParser
def initialize(params_class, key_space_limit, param_depth_limit); end
def key_space_limit(); end
def make_params(); end
def new_depth_limit(param_depth_limit); end
def new_space_limit(key_space_limit); end
def normalize_params(params, name, v, depth); end
def param_depth_limit(); end
def parse_nested_query(qs, d=T.unsafe(nil)); end
def parse_query(qs, d=T.unsafe(nil), &unescaper); end
COMMON_SEP = ::T.let(nil, ::T.untyped)
DEFAULT_SEP = ::T.let(nil, ::T.untyped)
end
class Rack::QueryParser::InvalidParameterError
end
class Rack::QueryParser::InvalidParameterError
end
class Rack::QueryParser::ParameterTypeError
end
class Rack::QueryParser::ParameterTypeError
end
class Rack::QueryParser::Params
def [](key); end
def []=(key, value); end
def initialize(limit); end
def key?(key); end
def to_h(); end
def to_params_hash(); end
end
class Rack::QueryParser::Params
end
class Rack::QueryParser
def self.make_default(key_space_limit, param_depth_limit); end
end
class Rack::Recursive
def _call(env); end
def call(env); end
def include(env, path); end
def initialize(app); end
end
class Rack::Recursive
end
class Rack::Reloader
def call(env); end
def initialize(app, cooldown=T.unsafe(nil), backend=T.unsafe(nil)); end
def reload!(stderr=T.unsafe(nil)); end
def safe_load(file, mtime, stderr=T.unsafe(nil)); end
end
module Rack::Reloader::Stat
def figure_path(file, paths); end
def rotation(); end
def safe_stat(file); end
end
module Rack::Reloader::Stat
end
class Rack::Reloader
end
class Rack::Request
include ::Rack::Request::Env
include ::Rack::Request::Helpers
ALLOWED_SCHEMES = ::T.let(nil, ::T.untyped)
SCHEME_WHITELIST = ::T.let(nil, ::T.untyped)
end
module Rack::Request::Env
def add_header(key, v); end
def delete_header(name); end
def each_header(&block); end
def env(); end
def fetch_header(name, &block); end
def get_header(name); end
def has_header?(name); end
def initialize(env); end
def set_header(name, v); end
end
module Rack::Request::Env
end
module Rack::Request::Helpers
def GET(); end
def POST(); end
def [](key); end
def []=(key, value); end
def accept_encoding(); end
def accept_language(); end
def authority(); end
def base_url(); end
def body(); end
def content_charset(); end
def content_length(); end
def content_type(); end
def cookies(); end
def delete?(); end
def delete_param(k); end
def form_data?(); end
def forwarded_authority(); end
def forwarded_for(); end
def forwarded_port(); end
def fullpath(); end
def get?(); end
def head?(); end
def host(); end
def host_authority(); end
def host_with_port(authority=T.unsafe(nil)); end
def hostname(); end
def ip(); end
def link?(); end
def logger(); end
def media_type(); end
def media_type_params(); end
def multithread?(); end
def options?(); end
def params(); end
def parseable_data?(); end
def patch?(); end
def path(); end
def path_info(); end
def path_info=(s); end
def port(); end
def post?(); end
def put?(); end
def query_string(); end
def referer(); end
def referrer(); end
def request_method(); end
def scheme(); end
def script_name(); end
def script_name=(s); end
def server_authority(); end
def server_name(); end
def server_port(); end
def session(); end
def session_options(); end
def ssl?(); end
def trace?(); end
def trusted_proxy?(ip); end
def unlink?(); end
def update_param(k, v); end
def url(); end
def user_agent(); end
def values_at(*keys); end
def xhr?(); end
DEFAULT_PORTS = ::T.let(nil, ::T.untyped)
FORM_DATA_MEDIA_TYPES = ::T.let(nil, ::T.untyped)
HTTP_X_FORWARDED_FOR = ::T.let(nil, ::T.untyped)
HTTP_X_FORWARDED_HOST = ::T.let(nil, ::T.untyped)
HTTP_X_FORWARDED_PORT = ::T.let(nil, ::T.untyped)
HTTP_X_FORWARDED_PROTO = ::T.let(nil, ::T.untyped)
HTTP_X_FORWARDED_SCHEME = ::T.let(nil, ::T.untyped)
HTTP_X_FORWARDED_SSL = ::T.let(nil, ::T.untyped)
PARSEABLE_DATA_MEDIA_TYPES = ::T.let(nil, ::T.untyped)
end
module Rack::Request::Helpers
end
class Rack::Request
def self.ip_filter(); end
def self.ip_filter=(ip_filter); end
end
class Rack::Response
include ::Rack::Response::Helpers
def [](key); end
def []=(key, v); end
def body(); end
def body=(body); end
def chunked?(); end
def close(); end
def delete_header(key); end
def each(&callback); end
def empty?(); end
def finish(&block); end
def get_header(key); end
def has_header?(key); end
def header(); end
def headers(); end
def initialize(body=T.unsafe(nil), status=T.unsafe(nil), headers=T.unsafe(nil)); end
def length(); end
def length=(length); end
def redirect(target, status=T.unsafe(nil)); end
def set_header(key, v); end
def status(); end
def status=(status); end
def to_a(&block); end
def write(chunk); end
CHUNKED = ::T.let(nil, ::T.untyped)
STATUS_WITH_NO_ENTITY_BODY = ::T.let(nil, ::T.untyped)
end
module Rack::Response::Helpers
def accepted?(); end
def add_header(key, v); end
def append(chunk); end
def bad_request?(); end
def buffered_body!(); end
def cache!(duration=T.unsafe(nil), directive: T.unsafe(nil)); end
def cache_control(); end
def cache_control=(v); end
def client_error?(); end
def content_length(); end
def content_type(); end
def content_type=(content_type); end
def created?(); end
def delete_cookie(key, value=T.unsafe(nil)); end
def do_not_cache!(); end
def etag(); end
def etag=(v); end
def forbidden?(); end
def include?(header); end
def informational?(); end
def invalid?(); end
def location(); end
def location=(location); end
def media_type(); end
def media_type_params(); end
def method_not_allowed?(); end
def moved_permanently?(); end
def no_content?(); end
def not_found?(); end
def ok?(); end
def precondition_failed?(); end
def redirect?(); end
def redirection?(); end
def server_error?(); end
def set_cookie(key, value); end
def set_cookie_header(); end
def set_cookie_header=(v); end
def successful?(); end
def unauthorized?(); end
def unprocessable?(); end
end
module Rack::Response::Helpers
end
class Rack::Response::Raw
include ::Rack::Response::Helpers
def delete_header(key); end
def get_header(key); end
def has_header?(key); end
def headers(); end
def initialize(status, headers); end
def set_header(key, v); end
def status(); end
def status=(status); end
end
class Rack::Response::Raw
end
class Rack::Response
def self.[](status, headers, body); end
end
class Rack::RewindableInput
def close(); end
def each(&block); end
def gets(); end
def initialize(io); end
def read(*args); end
def rewind(); end
end
class Rack::RewindableInput
end
class Rack::Runtime
def call(env); end
def initialize(app, name=T.unsafe(nil)); end
FORMAT_STRING = ::T.let(nil, ::T.untyped)
HEADER_NAME = ::T.let(nil, ::T.untyped)
end
class Rack::Runtime
end
class Rack::Sendfile
def call(env); end
def initialize(app, variation=T.unsafe(nil), mappings=T.unsafe(nil)); end
end
class Rack::Sendfile
end
class Rack::Server
def app(); end
def default_options(); end
def initialize(options=T.unsafe(nil)); end
def middleware(); end
def options(); end
def options=(options); end
def server(); end
def start(&block); end
end
class Rack::Server::Options
def handler_opts(options); end
def parse!(args); end
end
class Rack::Server::Options
end
class Rack::Server
def self.default_middleware_by_environment(); end
def self.logging_middleware(); end
def self.middleware(); end
def self.start(options=T.unsafe(nil)); end
end
module Rack::Session
end
class Rack::Session::Abstract::Persisted
def call(env); end
def commit_session(req, res); end
def context(env, app=T.unsafe(nil)); end
def default_options(); end
def initialize(app, options=T.unsafe(nil)); end
def key(); end
def sid_secure(); end
DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end
class Rack::Session::Abstract::Persisted
end
class Rack::Session::Abstract::PersistedSecure
def extract_session_id(*_); end
def generate_sid(*_); end
end
class Rack::Session::Abstract::PersistedSecure
end
class Rack::Session::Cookie
def coder(); end
end
class Rack::Session::Cookie::Base64
def decode(str); end
def encode(str); end
end
class Rack::Session::Cookie::Base64::JSON
def encode(obj); end
end
class Rack::Session::Cookie::Base64::JSON
end
class Rack::Session::Cookie::Base64::Marshal
end
class Rack::Session::Cookie::Base64::Marshal
end
class Rack::Session::Cookie::Base64::ZipJSON
def encode(obj); end
end
class Rack::Session::Cookie::Base64::ZipJSON
end
class Rack::Session::Cookie::Base64
end
class Rack::Session::Cookie::Identity
def decode(str); end
def encode(str); end
end
class Rack::Session::Cookie::Identity
end
class Rack::Session::Cookie::SessionId
def cookie_value(); end
def initialize(session_id, cookie_value); end
end
class Rack::Session::Cookie::SessionId
end
class Rack::Session::Cookie
end
class Rack::Session::Pool
def delete_session(req, session_id, options); end
def find_session(req, sid); end
def generate_sid(); end
def mutex(); end
def pool(); end
def with_lock(req); end
def write_session(req, session_id, new_session, options); end
DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end
class Rack::Session::Pool
end
module Rack::Session
end
class Rack::ShowExceptions
def call(env); end
def dump_exception(exception); end
def h(obj); end
def initialize(app); end
def prefers_plaintext?(env); end
def pretty(env, exception); end
def template(); end
CONTEXT = ::T.let(nil, ::T.untyped)
TEMPLATE = ::T.let(nil, ::T.untyped)
end
class Rack::ShowExceptions
end
class Rack::ShowStatus
def call(env); end
def h(obj); end
def initialize(app); end
TEMPLATE = ::T.let(nil, ::T.untyped)
end
class Rack::ShowStatus
end
class Rack::Static
def add_index_root?(path); end
def applicable_rules(path); end
def call(env); end
def can_serve(path); end
def initialize(app, options=T.unsafe(nil)); end
def overwrite_file_path(path); end
def route_file(path); end
end
class Rack::Static
end
class Rack::TempfileReaper
def call(env); end
def initialize(app); end
end
class Rack::TempfileReaper
end
module Rack::Test
DEFAULT_HOST = ::T.let(nil, ::T.untyped)
MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class Rack::Test::Cookie
include ::Rack::Utils
def default_uri(); end
def domain(); end
def empty?(); end
def expired?(); end
def expires(); end
def http_only?(); end
def initialize(raw, uri=T.unsafe(nil), default_host=T.unsafe(nil)); end
def matches?(uri); end
def name(); end
def path(); end
def raw(); end
def replaces?(other); end
def secure?(); end
def to_h(); end
def to_hash(); end
def valid?(uri); end
def value(); end
end
class Rack::Test::Cookie
end
class Rack::Test::CookieJar
def <<(new_cookie); end
def [](name); end
def []=(name, value); end
def delete(name); end
def for(uri); end
def get_cookie(name); end
def hash_for(uri=T.unsafe(nil)); end
def initialize(cookies=T.unsafe(nil), default_host=T.unsafe(nil)); end
def merge(raw_cookies, uri=T.unsafe(nil)); end
def to_hash(); end
DELIMITER = ::T.let(nil, ::T.untyped)
end
class Rack::Test::CookieJar
end
class Rack::Test::Error
end
class Rack::Test::Error
end
module Rack::Test::Methods
def _current_session_names(); end
def authorize(*args, &block); end
def basic_authorize(*args, &block); end
def build_rack_mock_session(); end
def build_rack_test_session(name); end
def clear_cookies(*args, &block); end
def current_session(); end
def custom_request(*args, &block); end
def delete(*args, &block); end
def digest_authorize(*args, &block); end
def env(*args, &block); end
def follow_redirect!(*args, &block); end
def get(*args, &block); end
def head(*args, &block); end
def header(*args, &block); end
def last_request(*args, &block); end
def last_response(*args, &block); end
def options(*args, &block); end
def patch(*args, &block); end
def post(*args, &block); end
def put(*args, &block); end
def rack_mock_session(name=T.unsafe(nil)); end
def rack_test_session(name=T.unsafe(nil)); end
def request(*args, &block); end
def set_cookie(*args, &block); end
def with_session(name); end
METHODS = ::T.let(nil, ::T.untyped)
end
module Rack::Test::Methods
extend ::Forwardable
end
class Rack::Test::MockDigestRequest
def initialize(params); end
def method(); end
def method_missing(sym); end
def response(password); end
end
class Rack::Test::MockDigestRequest
end
class Rack::Test::Session
include ::Rack::Test::Utils
include ::Rack::Utils
def authorize(username, password); end
def basic_authorize(username, password); end
def clear_cookies(*args, &block); end
def custom_request(verb, uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def delete(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def digest_authorize(username, password); end
def env(name, value); end
def follow_redirect!(); end
def get(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def head(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def header(name, value); end
def initialize(mock_session); end
def last_request(*args, &block); end
def last_response(*args, &block); end
def options(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def patch(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def post(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def put(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
def request(uri, env=T.unsafe(nil), &block); end
def set_cookie(*args, &block); end
end
class Rack::Test::Session
extend ::Forwardable
end
class Rack::Test::UploadedFile
def content_type(); end
def content_type=(content_type); end
def initialize(content, content_type=T.unsafe(nil), binary=T.unsafe(nil), original_filename: T.unsafe(nil)); end
def local_path(); end
def method_missing(method_name, *args, &block); end
def original_filename(); end
def path(); end
def tempfile(); end
end
class Rack::Test::UploadedFile
def self.actually_finalize(file); end
def self.finalize(file); end
end
module Rack::Test::Utils
include ::Rack::Utils
end
module Rack::Test::Utils
extend ::Rack::Utils
def self.build_file_part(parameter_name, uploaded_file); end
def self.build_multipart(params, first=T.unsafe(nil), multipart=T.unsafe(nil)); end
def self.build_parts(parameters); end
def self.build_primitive_part(parameter_name, value); end
def self.get_parts(parameters); end
end
module Rack::Test
def self.encoding_aware_strings?(); end
end
class Rack::Tracer
def call(env); end
def initialize(app, tracer: T.unsafe(nil), on_start_span: T.unsafe(nil), on_finish_span: T.unsafe(nil), trust_incoming_span: T.unsafe(nil), errors: T.unsafe(nil)); end
REQUEST_METHOD = ::T.let(nil, ::T.untyped)
REQUEST_URI = ::T.let(nil, ::T.untyped)
end
class Rack::Tracer
end
class Rack::URLMap
def call(env); end
def initialize(map=T.unsafe(nil)); end
def remap(map); end
end
class Rack::URLMap
end
module Rack::Utils
COMMON_SEP = ::T.let(nil, ::T.untyped)
DEFAULT_SEP = ::T.let(nil, ::T.untyped)
ESCAPE_HTML = ::T.let(nil, ::T.untyped)
ESCAPE_HTML_PATTERN = ::T.let(nil, ::T.untyped)
HTTP_STATUS_CODES = ::T.let(nil, ::T.untyped)
NULL_BYTE = ::T.let(nil, ::T.untyped)
PATH_SEPS = ::T.let(nil, ::T.untyped)
STATUS_WITH_NO_ENTITY_BODY = ::T.let(nil, ::T.untyped)
SYMBOL_TO_STATUS_CODE = ::T.let(nil, ::T.untyped)
end
class Rack::Utils::Context
def app(); end
def call(env); end
def context(env, app=T.unsafe(nil)); end
def for(); end
def initialize(app_f, app_r); end
def recontext(app); end
end
class Rack::Utils::Context
end
class Rack::Utils::HeaderHash
def [](k); end
def []=(k, v); end
def delete(k); end
def has_key?(k); end
def include?(k); end
def initialize(hash=T.unsafe(nil)); end
def key?(k); end
def member?(k); end
def merge(other); end
def merge!(other); end
def names(); end
def replace(other); end
end
class Rack::Utils::HeaderHash
def self.[](headers); end
end
Rack::Utils::InvalidParameterError = Rack::QueryParser::InvalidParameterError
Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params
Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError
module Rack::Utils
def self.add_cookie_to_header(header, key, value); end
def self.add_remove_cookie_to_header(header, key, value=T.unsafe(nil)); end
def self.best_q_match(q_value_header, available_mimes); end
def self.build_nested_query(value, prefix=T.unsafe(nil)); end
def self.build_query(params); end
def self.byte_ranges(env, size); end
def self.clean_path_info(path_info); end
def self.clock_time(); end
def self.default_query_parser(); end
def self.default_query_parser=(default_query_parser); end
def self.delete_cookie_header!(header, key, value=T.unsafe(nil)); end
def self.escape(s); end
def self.escape_html(string); end
def self.escape_path(s); end
def self.get_byte_ranges(http_range, size); end
def self.key_space_limit(); end
def self.key_space_limit=(v); end
def self.make_delete_cookie_header(header, key, value); end
def self.multipart_part_limit(); end
def self.multipart_part_limit=(multipart_part_limit); end
def self.param_depth_limit(); end
def self.param_depth_limit=(v); end
def self.parse_cookies(env); end
def self.parse_cookies_header(header); end
def self.parse_nested_query(qs, d=T.unsafe(nil)); end
def self.parse_query(qs, d=T.unsafe(nil), &unescaper); end
def self.q_values(q_value_header); end
def self.rfc2109(time); end
def self.rfc2822(time); end
def self.secure_compare(a, b); end
def self.select_best_encoding(available_encodings, accept_encoding); end
def self.set_cookie_header!(header, key, value); end
def self.status_code(status); end
def self.unescape(s, encoding=T.unsafe(nil)); end
def self.unescape_path(s); end
def self.valid_path?(path); end
end
module Rack
def self.release(); end
def self.version(); end
end
class Rainbow::Color::RGB
def self.to_ansi_domain(value); end
end
class Rainbow::NullPresenter
def method_missing(method_name, *args); end
end
class Rainbow::Presenter
def method_missing(method_name, *args); end
end
class Rainbow::StringUtils
def self.uncolor(string); end
end
module Rainbow
def self.new(); end
end
module Rake
EARLY = ::T.let(nil, ::T.untyped)
EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped)
LATE = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class Rake::Application
include ::Rake::TaskManager
include ::Rake::TraceOutput
def add_import(fn); end
def add_loader(ext, loader); end
def collect_command_line_tasks(args); end
def default_task_name(); end
def deprecate(old_usage, new_usage, call_site); end
def display_cause_details(ex); end
def display_error_message(ex); end
def display_exception_backtrace(ex); end
def display_exception_details(ex); end
def display_exception_details_seen(); end
def display_exception_message_details(ex); end
def display_prerequisites(); end
def display_tasks_and_comments(); end
def dynamic_width(); end
def dynamic_width_stty(); end
def dynamic_width_tput(); end
def exit_because_of_exception(ex); end
def find_rakefile_location(); end
def handle_options(argv); end
def has_cause?(ex); end
def have_rakefile(); end
def init(app_name=T.unsafe(nil), argv=T.unsafe(nil)); end
def invoke_task(task_string); end
def load_imports(); end
def load_rakefile(); end
def name(); end
def options(); end
def original_dir(); end
def parse_task_string(string); end
def print_rakefile_directory(location); end
def rake_require(file_name, paths=T.unsafe(nil), loaded=T.unsafe(nil)); end
def rakefile(); end
def rakefile_location(backtrace=T.unsafe(nil)); end
def raw_load_rakefile(); end
def run(argv=T.unsafe(nil)); end
def run_with_threads(); end
def set_default_options(); end
def standard_exception_handling(); end
def standard_rake_options(); end
def system_dir(); end
def terminal_columns(); end
def terminal_columns=(terminal_columns); end
def terminal_width(); end
def thread_pool(); end
def top_level(); end
def top_level_tasks(); end
def trace(*strings); end
def truncate(string, width); end
def truncate_output?(); end
def tty_output=(tty_output); end
def tty_output?(); end
def unix?(); end
def windows?(); end
DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped)
end
class Rake::Application
end
module Rake::Backtrace
SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped)
SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped)
SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped)
SYS_KEYS = ::T.let(nil, ::T.untyped)
SYS_PATHS = ::T.let(nil, ::T.untyped)
end
module Rake::Backtrace
def self.collapse(backtrace); end
end
module Rake::Cloneable
end
module Rake::Cloneable
end
class Rake::CommandLineOptionError
end
class Rake::CommandLineOptionError
end
class Rake::CpuCounter
def count(); end
def count_with_default(default=T.unsafe(nil)); end
end
class Rake::CpuCounter
def self.count(); end
end
module Rake::DSL
include ::Rake::FileUtilsExt
include ::FileUtils
include ::FileUtils::StreamUtils_
end
module Rake::DSL
end
class Rake::DefaultLoader
def load(fn); end
end
class Rake::DefaultLoader
end
class Rake::EarlyTime
include ::Comparable
include ::Singleton
end
class Rake::EarlyTime
extend ::Singleton::SingletonClassMethods
def self.instance(); end
end
class Rake::FileCreationTask
end
class Rake::FileCreationTask
end
class Rake::FileList
include ::Rake::Cloneable
def &(*args, &block); end
def *(other); end
def +(*args, &block); end
def -(*args, &block); end
def <<(obj); end
def ==(array); end
def [](*args, &block); end
def []=(*args, &block); end
def add(*filenames); end
def all?(*args, &block); end
def any?(*args, &block); end
def append(*args, &block); end
def assoc(*args, &block); end
def at(*args, &block); end
def bsearch(*args, &block); end
def bsearch_index(*args, &block); end
def chain(*args, &block); end
def chunk(*args, &block); end
def chunk_while(*args, &block); end
def clear(*args, &block); end
def clear_exclude(); end
def collect(*args, &block); end
def collect!(*args, &block); end
def collect_concat(*args, &block); end
def combination(*args, &block); end
def compact(*args, &block); end
def compact!(*args, &block); end
def concat(*args, &block); end
def count(*args, &block); end
def cycle(*args, &block); end
def delete(*args, &block); end
def delete_at(*args, &block); end
def delete_if(*args, &block); end
def detect(*args, &block); end
def difference(*args, &block); end
def dig(*args, &block); end
def drop(*args, &block); end
def drop_while(*args, &block); end
def each(*args, &block); end
def each_cons(*args, &block); end
def each_entry(*args, &block); end
def each_index(*args, &block); end
def each_slice(*args, &block); end
def each_with_index(*args, &block); end
def each_with_object(*args, &block); end
def egrep(pattern, *options); end
def empty?(*args, &block); end
def entries(*args, &block); end
def exclude(*patterns, &block); end
def excluded_from_list?(fn); end
def existing(); end
def existing!(); end
def ext(newext=T.unsafe(nil)); end
def fetch(*args, &block); end
def fill(*args, &block); end
def filter(*args, &block); end
def filter!(*args, &block); end
def find(*args, &block); end
def find_all(*args, &block); end
def find_index(*args, &block); end
def first(*args, &block); end
def flat_map(*args, &block); end
def flatten(*args, &block); end
def flatten!(*args, &block); end
def grep(*args, &block); end
def grep_v(*args, &block); end
def group_by(*args, &block); end
def gsub(pat, rep); end
def gsub!(pat, rep); end
def import(array); end
def include(*filenames); end
def include?(*args, &block); end
def index(*args, &block); end
def initialize(*patterns); end
def inject(*args, &block); end
def insert(*args, &block); end
def inspect(*args, &block); end
def is_a?(klass); end
def join(*args, &block); end
def keep_if(*args, &block); end
def kind_of?(klass); end
def last(*args, &block); end
def lazy(*args, &block); end
def length(*args, &block); end
def map(*args, &block); end
def map!(*args, &block); end
def max(*args, &block); end
def max_by(*args, &block); end
def member?(*args, &block); end
def min(*args, &block); end
def min_by(*args, &block); end
def minmax(*args, &block); end
def minmax_by(*args, &block); end
def none?(*args, &block); end
def one?(*args, &block); end
def pack(*args, &block); end
def partition(&block); end
def pathmap(spec=T.unsafe(nil), &block); end
def permutation(*args, &block); end
def pop(*args, &block); end
def prepend(*args, &block); end
def product(*args, &block); end
def push(*args, &block); end
def rassoc(*args, &block); end
def reduce(*args, &block); end
def reject(*args, &block); end
def reject!(*args, &block); end
def repeated_combination(*args, &block); end
def repeated_permutation(*args, &block); end
def replace(*args, &block); end
def resolve(); end
def reverse(*args, &block); end
def reverse!(*args, &block); end
def reverse_each(*args, &block); end
def rindex(*args, &block); end
def rotate(*args, &block); end
def rotate!(*args, &block); end
def sample(*args, &block); end
def select(*args, &block); end
def select!(*args, &block); end
def shift(*args, &block); end
def shuffle(*args, &block); end
def shuffle!(*args, &block); end
def size(*args, &block); end
def slice(*args, &block); end
def slice!(*args, &block); end
def slice_after(*args, &block); end
def slice_before(*args, &block); end
def slice_when(*args, &block); end
def sort(*args, &block); end
def sort!(*args, &block); end
def sort_by(*args, &block); end
def sort_by!(*args, &block); end
def sub(pat, rep); end
def sub!(pat, rep); end
def sum(*args, &block); end
def take(*args, &block); end
def take_while(*args, &block); end
def to_a(); end
def to_ary(); end
def to_h(*args, &block); end
def to_set(*args, &block); end
def transpose(*args, &block); end
def union(*args, &block); end
def uniq(*args, &block); end
def uniq!(*args, &block); end
def unshift(*args, &block); end
def values_at(*args, &block); end
def zip(*args, &block); end
def |(*args, &block); end
ARRAY_METHODS = ::T.let(nil, ::T.untyped)
DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped)
DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped)
DELEGATING_METHODS = ::T.let(nil, ::T.untyped)
GLOB_PATTERN = ::T.let(nil, ::T.untyped)
MUST_DEFINE = ::T.let(nil, ::T.untyped)
MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped)
SPECIAL_RETURN = ::T.let(nil, ::T.untyped)
end
class Rake::FileList
def self.[](*args); end
def self.glob(pattern, *args); end
end
class Rake::FileTask
end
class Rake::FileTask
end
module Rake::FileUtilsExt
include ::FileUtils
include ::FileUtils::StreamUtils_
def cd(*args, **options, &block); end
def chdir(*args, **options, &block); end
def chmod(*args, **options, &block); end
def chmod_R(*args, **options, &block); end
def chown(*args, **options, &block); end
def chown_R(*args, **options, &block); end
def copy(*args, **options, &block); end
def cp(*args, **options, &block); end
def cp_lr(*args, **options, &block); end
def cp_r(*args, **options, &block); end
def install(*args, **options, &block); end
def link(*args, **options, &block); end
def ln(*args, **options, &block); end
def ln_s(*args, **options, &block); end
def ln_sf(*args, **options, &block); end
def makedirs(*args, **options, &block); end
def mkdir(*args, **options, &block); end
def mkdir_p(*args, **options, &block); end
def mkpath(*args, **options, &block); end
def move(*args, **options, &block); end
def mv(*args, **options, &block); end
def nowrite(value=T.unsafe(nil)); end
def rake_check_options(options, *optdecl); end
def rake_output_message(message); end
def remove(*args, **options, &block); end
def rm(*args, **options, &block); end
def rm_f(*args, **options, &block); end
def rm_r(*args, **options, &block); end
def rm_rf(*args, **options, &block); end
def rmdir(*args, **options, &block); end
def rmtree(*args, **options, &block); end
def safe_unlink(*args, **options, &block); end
def symlink(*args, **options, &block); end
def touch(*args, **options, &block); end
def verbose(value=T.unsafe(nil)); end
def when_writing(msg=T.unsafe(nil)); end
DEFAULT = ::T.let(nil, ::T.untyped)
end
module Rake::FileUtilsExt
extend ::Rake::FileUtilsExt
extend ::FileUtils
extend ::FileUtils::StreamUtils_
def self.nowrite_flag(); end
def self.nowrite_flag=(nowrite_flag); end
def self.verbose_flag(); end
def self.verbose_flag=(verbose_flag); end
end
class Rake::InvocationChain
def append(invocation); end
def member?(invocation); end
EMPTY = ::T.let(nil, ::T.untyped)
end
class Rake::InvocationChain::EmptyInvocationChain
def append(invocation); end
def member?(obj); end
end
class Rake::InvocationChain::EmptyInvocationChain
end
class Rake::InvocationChain
def self.append(invocation, chain); end
end
module Rake::InvocationExceptionMixin
def chain(); end
def chain=(value); end
end
module Rake::InvocationExceptionMixin
end
class Rake::LateTime
include ::Comparable
include ::Singleton
end
class Rake::LateTime
extend ::Singleton::SingletonClassMethods
def self.instance(); end
end
class Rake::LinkedList
include ::Enumerable
def ==(other); end
def conj(item); end
def each(&blk); end
def empty?(); end
def head(); end
def initialize(head, tail=T.unsafe(nil)); end
def tail(); end
EMPTY = ::T.let(nil, ::T.untyped)
end
class Rake::LinkedList::EmptyLinkedList
def initialize(); end
end
class Rake::LinkedList::EmptyLinkedList
end
class Rake::LinkedList
def self.cons(head, tail); end
def self.empty(); end
def self.make(*args); end
end
class Rake::MultiTask
end
class Rake::MultiTask
end
class Rake::NameSpace
def [](name); end
def initialize(task_manager, scope_list); end
def scope(); end
def tasks(); end
end
class Rake::NameSpace
end
module Rake::PrivateReader
end
module Rake::PrivateReader::ClassMethods
def private_reader(*names); end
end
module Rake::PrivateReader::ClassMethods
end
module Rake::PrivateReader
def self.included(base); end
end
class Rake::Promise
def initialize(args, &block); end
def recorder(); end
def recorder=(recorder); end
def value(); end
def work(); end
NOT_SET = ::T.let(nil, ::T.untyped)
end
class Rake::Promise
end
class Rake::PseudoStatus
def >>(n); end
def exited?(); end
def exitstatus(); end
def initialize(code=T.unsafe(nil)); end
def stopped?(); end
def to_i(); end
end
class Rake::PseudoStatus
end
class Rake::RuleRecursionOverflowError
def add_target(target); end
def initialize(*args); end
end
class Rake::RuleRecursionOverflowError
end
class Rake::Scope
def path(); end
def path_with_task_name(task_name); end
def trim(n); end
EMPTY = ::T.let(nil, ::T.untyped)
end
class Rake::Scope::EmptyScope
def path(); end
def path_with_task_name(task_name); end
end
class Rake::Scope::EmptyScope
end
class Rake::Scope
end
class Rake::Task
def actions(); end
def add_description(description); end
def all_prerequisite_tasks(); end
def already_invoked(); end
def application(); end
def application=(application); end
def arg_description(); end
def arg_names(); end
def clear(); end
def clear_actions(); end
def clear_args(); end
def clear_comments(); end
def clear_prerequisites(); end
def collect_prerequisites(seen); end
def comment(); end
def comment=(comment); end
def enhance(deps=T.unsafe(nil), &block); end
def execute(args=T.unsafe(nil)); end
def full_comment(); end
def initialize(task_name, app); end
def investigation(); end
def invoke(*args); end
def invoke_prerequisites(task_args, invocation_chain); end
def invoke_prerequisites_concurrently(task_args, invocation_chain); end
def invoke_with_call_chain(task_args, invocation_chain); end
def locations(); end
def name(); end
def name_with_args(); end
def needed?(); end
def order_only_prerequisites(); end
def prereqs(); end
def prerequisite_tasks(); end
def prerequisites(); end
def reenable(); end
def scope(); end
def set_arg_names(args); end
def source(); end
def sources(); end
def sources=(sources); end
def timestamp(); end
def |(deps); end
end
class Rake::Task
def self.[](task_name); end
def self.clear(); end
def self.create_rule(*args, &block); end
def self.define_task(*args, &block); end
def self.format_deps(deps); end
def self.scope_name(scope, task_name); end
def self.task_defined?(task_name); end
def self.tasks(); end
end
class Rake::TaskArgumentError
end
class Rake::TaskArgumentError
end
class Rake::TaskArguments
include ::Enumerable
def [](index); end
def each(&block); end
def extras(); end
def fetch(*args, &block); end
def has_key?(key); end
def initialize(names, values, parent=T.unsafe(nil)); end
def key?(key); end
def lookup(name); end
def method_missing(sym, *args); end
def names(); end
def new_scope(names); end
def to_a(); end
def to_hash(); end
def values_at(*keys); end
def with_defaults(defaults); end
end
class Rake::TaskArguments
end
module Rake::TaskManager
def [](task_name, scopes=T.unsafe(nil)); end
def clear(); end
def create_rule(*args, &block); end
def current_scope(); end
def define_task(task_class, *args, &block); end
def enhance_with_matching_rule(task_name, level=T.unsafe(nil)); end
def generate_did_you_mean_suggestions(task_name); end
def generate_message_for_undefined_task(task_name); end
def in_namespace(name); end
def initialize(); end
def intern(task_class, task_name); end
def last_description(); end
def last_description=(last_description); end
def lookup(task_name, initial_scope=T.unsafe(nil)); end
def resolve_args(args); end
def synthesize_file_task(task_name); end
def tasks(); end
def tasks_in_scope(scope); end
end
module Rake::TaskManager
def self.record_task_metadata(); end
def self.record_task_metadata=(record_task_metadata); end
end
class Rake::ThreadHistoryDisplay
include ::Rake::PrivateReader
def initialize(stats); end
def show(); end
end
class Rake::ThreadHistoryDisplay
extend ::Rake::PrivateReader::ClassMethods
end
class Rake::ThreadPool
def future(*args, &block); end
def gather_history(); end
def history(); end
def initialize(thread_count); end
def join(); end
def statistics(); end
end
class Rake::ThreadPool
end
module Rake::TraceOutput
def trace_on(out, *strings); end
end
module Rake::TraceOutput
end
module Rake::Version
BUILD = ::T.let(nil, ::T.untyped)
MAJOR = ::T.let(nil, ::T.untyped)
MINOR = ::T.let(nil, ::T.untyped)
NUMBERS = ::T.let(nil, ::T.untyped)
OTHER = ::T.let(nil, ::T.untyped)
end
module Rake::Version
end
module Rake::Win32
end
class Rake::Win32::Win32HomeError
end
class Rake::Win32::Win32HomeError
end
module Rake::Win32
def self.normalize(path); end
def self.win32_system_dir(); end
def self.windows?(); end
end
module Rake
extend ::Rake::FileUtilsExt
extend ::FileUtils
extend ::FileUtils::StreamUtils_
def self.add_rakelib(*files); end
def self.application(); end
def self.application=(app); end
def self.each_dir_parent(dir); end
def self.from_pathname(path); end
def self.load_rakefile(path); end
def self.original_dir(); end
def self.suggested_thread_count(); end
def self.with_application(block_application=T.unsafe(nil)); end
end
RakeFileUtils = Rake::FileUtilsExt
module Random::Formatter
def alphanumeric(n=T.unsafe(nil)); end
ALPHANUMERIC = ::T.let(nil, ::T.untyped)
end
class Random
def self.bytes(_); end
def self.urandom(_); end
end
class Range
def %(_); end
def entries(); end
def to_a(); end
end
module RbConfig
def self.expand(val, config=T.unsafe(nil)); end
def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
def self.ruby(); end
end
class RedBlackTree
include ::Enumerable
def [](key); end
def []=(key, value); end
def clear(); end
def default(); end
def default=(default); end
def default_proc(); end
def delete(key); end
def dump_sexp(); end
def dump_tree(io=T.unsafe(nil)); end
def each(&block); end
def each_key(); end
def each_pair(&block); end
def each_value(); end
def empty?(); end
def has_key?(key); end
def initialize(default=T.unsafe(nil), &block); end
def insert(key, value); end
def key?(key); end
def keys(); end
def length(); end
def root(); end
def size(); end
def to_hash(); end
def values(); end
DEFAULT = ::T.let(nil, ::T.untyped)
end
class RedBlackTree::Node
def balanced_rotate_left(); end
def balanced_rotate_right(); end
def black?(); end
def check_height(); end
def children_color?(color); end
def color(); end
def color=(color); end
def color_flip(other); end
def delete(key); end
def delete_min(); end
def dump_sexp(); end
def dump_tree(io, indent=T.unsafe(nil)); end
def each(&block); end
def each_key(); end
def each_value(); end
def empty?(); end
def initialize(key, value, left, right, color=T.unsafe(nil)); end
def insert(key, value); end
def key(); end
def keys(); end
def left(); end
def left=(left); end
def pullup_red(); end
def rebalance_for_left_delete(); end
def rebalance_for_right_delete(); end
def red?(); end
def retrieve(key); end
def right(); end
def right=(right); end
def rotate_left(); end
def rotate_right(); end
def set_root(); end
def size(); end
def value(); end
def values(); end
EMPTY = ::T.let(nil, ::T.untyped)
UNDEFINED = ::T.let(nil, ::T.untyped)
end
class RedBlackTree::Node::EmptyNode
def initialize(); end
end
class RedBlackTree::Node::EmptyNode
end
class RedBlackTree::Node
end
class RedBlackTree
end
class Resolv::DNS
def extract_resources(msg, name, typeclass); end
def fetch_resource(name, typeclass); end
def lazy_initialize(); end
def make_tcp_requester(host, port); end
def make_udp_requester(); end
RequestID = ::T.let(nil, ::T.untyped)
RequestIDMutex = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Config
def generate_candidates(name); end
def generate_timeouts(); end
def initialize(config_info=T.unsafe(nil)); end
def lazy_initialize(); end
def nameserver_port(); end
def resolv(name); end
def single?(); end
def timeouts=(values); end
InitialTimeout = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Config::NXDomain
end
class Resolv::DNS::Config::NXDomain
end
class Resolv::DNS::Config::OtherResolvError
end
class Resolv::DNS::Config::OtherResolvError
end
class Resolv::DNS::Config
def self.default_config_hash(filename=T.unsafe(nil)); end
def self.parse_resolv_conf(filename); end
end
module Resolv::DNS::Label
end
class Resolv::DNS::Label::Str
def ==(other); end
def downcase(); end
def eql?(other); end
def initialize(string); end
def string(); end
end
class Resolv::DNS::Label::Str
end
module Resolv::DNS::Label
def self.split(arg); end
end
class Resolv::DNS::Message
def ==(other); end
def aa(); end
def aa=(aa); end
def add_additional(name, ttl, data); end
def add_answer(name, ttl, data); end
def add_authority(name, ttl, data); end
def add_question(name, typeclass); end
def additional(); end
def answer(); end
def authority(); end
def each_additional(); end
def each_answer(); end
def each_authority(); end
def each_question(); end
def each_resource(); end
def encode(); end
def id(); end
def id=(id); end
def initialize(id=T.unsafe(nil)); end
def opcode(); end
def opcode=(opcode); end
def qr(); end
def qr=(qr); end
def question(); end
def ra(); end
def ra=(ra); end
def rcode(); end
def rcode=(rcode); end
def rd(); end
def rd=(rd); end
def tc(); end
def tc=(tc); end
end
class Resolv::DNS::Message::MessageDecoder
def get_bytes(len=T.unsafe(nil)); end
def get_label(); end
def get_labels(); end
def get_length16(); end
def get_name(); end
def get_question(); end
def get_rr(); end
def get_string(); end
def get_string_list(); end
def get_unpack(template); end
def initialize(data); end
end
class Resolv::DNS::Message::MessageDecoder
end
class Resolv::DNS::Message::MessageEncoder
def put_bytes(d); end
def put_label(d); end
def put_labels(d); end
def put_length16(); end
def put_name(d); end
def put_pack(template, *d); end
def put_string(d); end
def put_string_list(ds); end
end
class Resolv::DNS::Message::MessageEncoder
end
class Resolv::DNS::Message
def self.decode(m); end
end
class Resolv::DNS::Name
def ==(other); end
def [](i); end
def eql?(other); end
def length(); end
def to_a(); end
end
module Resolv::DNS::OpCode
IQuery = ::T.let(nil, ::T.untyped)
Notify = ::T.let(nil, ::T.untyped)
Query = ::T.let(nil, ::T.untyped)
Status = ::T.let(nil, ::T.untyped)
Update = ::T.let(nil, ::T.untyped)
end
module Resolv::DNS::OpCode
end
class Resolv::DNS::Query
def encode_rdata(msg); end
end
class Resolv::DNS::Query
def self.decode_rdata(msg); end
end
module Resolv::DNS::RCode
BADALG = ::T.let(nil, ::T.untyped)
BADKEY = ::T.let(nil, ::T.untyped)
BADMODE = ::T.let(nil, ::T.untyped)
BADNAME = ::T.let(nil, ::T.untyped)
BADSIG = ::T.let(nil, ::T.untyped)
BADTIME = ::T.let(nil, ::T.untyped)
BADVERS = ::T.let(nil, ::T.untyped)
FormErr = ::T.let(nil, ::T.untyped)
NXDomain = ::T.let(nil, ::T.untyped)
NXRRSet = ::T.let(nil, ::T.untyped)
NoError = ::T.let(nil, ::T.untyped)
NotAuth = ::T.let(nil, ::T.untyped)
NotImp = ::T.let(nil, ::T.untyped)
NotZone = ::T.let(nil, ::T.untyped)
Refused = ::T.let(nil, ::T.untyped)
ServFail = ::T.let(nil, ::T.untyped)
YXDomain = ::T.let(nil, ::T.untyped)
YXRRSet = ::T.let(nil, ::T.untyped)
end
module Resolv::DNS::RCode
end
class Resolv::DNS::Requester
def close(); end
def request(sender, tout); end
def sender_for(addr, msg); end
end
class Resolv::DNS::Requester::ConnectedUDP
def initialize(host, port=T.unsafe(nil)); end
def lazy_initialize(); end
def recv_reply(readable_socks); end
def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end
end
class Resolv::DNS::Requester::ConnectedUDP::Sender
def data(); end
def send(); end
end
class Resolv::DNS::Requester::ConnectedUDP::Sender
end
class Resolv::DNS::Requester::ConnectedUDP
end
class Resolv::DNS::Requester::MDNSOneShot
end
class Resolv::DNS::Requester::MDNSOneShot
end
class Resolv::DNS::Requester::RequestError
end
class Resolv::DNS::Requester::RequestError
end
class Resolv::DNS::Requester::Sender
def initialize(msg, data, sock); end
end
class Resolv::DNS::Requester::Sender
end
class Resolv::DNS::Requester::TCP
def initialize(host, port=T.unsafe(nil)); end
def recv_reply(readable_socks); end
def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end
end
class Resolv::DNS::Requester::TCP::Sender
def data(); end
def send(); end
end
class Resolv::DNS::Requester::TCP::Sender
end
class Resolv::DNS::Requester::TCP
end
class Resolv::DNS::Requester::UnconnectedUDP
def initialize(*nameserver_port); end
def lazy_initialize(); end
def recv_reply(readable_socks); end
def sender(msg, data, host, port=T.unsafe(nil)); end
end
class Resolv::DNS::Requester::UnconnectedUDP::Sender
def data(); end
def initialize(msg, data, sock, host, port); end
def send(); end
end
class Resolv::DNS::Requester::UnconnectedUDP::Sender
end
class Resolv::DNS::Requester::UnconnectedUDP
end
class Resolv::DNS::Requester
end
class Resolv::DNS::Resource
def ==(other); end
def eql?(other); end
ClassHash = ::T.let(nil, ::T.untyped)
ClassInsensitiveTypes = ::T.let(nil, ::T.untyped)
ClassValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::ANY
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::CNAME
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::Generic
def self.create(type_value, class_value); end
end
class Resolv::DNS::Resource::HINFO
TypeValue = ::T.let(nil, ::T.untyped)
end
module Resolv::DNS::Resource::IN
ClassValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::A
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::AAAA
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::ANY
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::ANY
end
class Resolv::DNS::Resource::IN::CNAME
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::CNAME
end
class Resolv::DNS::Resource::IN::HINFO
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::HINFO
end
class Resolv::DNS::Resource::IN::LOC
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::LOC
end
class Resolv::DNS::Resource::IN::MINFO
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::MINFO
end
class Resolv::DNS::Resource::IN::MX
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::MX
end
class Resolv::DNS::Resource::IN::NS
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::NS
end
class Resolv::DNS::Resource::IN::PTR
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::PTR
end
class Resolv::DNS::Resource::IN::SOA
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::SOA
end
class Resolv::DNS::Resource::IN::SRV
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::TXT
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::IN::TXT
end
class Resolv::DNS::Resource::IN::WKS
ClassValue = ::T.let(nil, ::T.untyped)
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::LOC
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::MINFO
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::MX
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::NS
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::PTR
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::SOA
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource::TXT
TypeValue = ::T.let(nil, ::T.untyped)
end
class Resolv::DNS::Resource
def self.get_class(type_value, class_value); end
end
class Resolv::DNS
def self.allocate_request_id(host, port); end
def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
def self.free_request_id(host, port, id); end
def self.random(arg); end
end
class Resolv::Hosts
def lazy_initialize(); end
end
class Resolv::IPv4
def ==(other); end
def eql?(other); end
end
class Resolv::IPv6
def ==(other); end
def eql?(other); end
end
class Resolv::LOC::Alt
def ==(other); end
def eql?(other); end
end
class Resolv::LOC::Coord
def ==(other); end
def eql?(other); end
end
class Resolv::LOC::Size
def ==(other); end
def eql?(other); end
end
module RuboCop
end
module RuboCop::AST
end
class RuboCop::AST::AliasNode
def new_identifier(); end
def old_identifier(); end
end
class RuboCop::AST::AliasNode
end
class RuboCop::AST::AndNode
include ::RuboCop::AST::BinaryOperatorNode
include ::RuboCop::AST::PredicateOperatorNode
def alternate_operator(); end
def inverse_operator(); end
end
class RuboCop::AST::AndNode
end
class RuboCop::AST::ArgsNode
include ::RuboCop::AST::CollectionNode
def empty_and_without_delimiters?(); end
end
class RuboCop::AST::ArgsNode
end
class RuboCop::AST::ArrayNode
def bracketed?(); end
def percent_literal?(type=T.unsafe(nil)); end
def square_brackets?(); end
def values(); end
PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::ArrayNode
end
module RuboCop::AST::BasicLiteralNode
def value(); end
end
module RuboCop::AST::BasicLiteralNode
end
module RuboCop::AST::BinaryOperatorNode
def conditions(); end
def lhs(); end
def rhs(); end
end
module RuboCop::AST::BinaryOperatorNode
end
class RuboCop::AST::BlockNode
include ::RuboCop::AST::MethodIdentifierPredicates
def arguments(); end
def arguments?(); end
def body(); end
def braces?(); end
def closing_delimiter(); end
def delimiters(); end
def keywords?(); end
def lambda?(); end
def method_name(); end
def opening_delimiter(); end
def send_node(); end
def void_context?(); end
VOID_CONTEXT_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::BlockNode
end
class RuboCop::AST::BreakNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
include ::RuboCop::AST::ParameterizedNode
end
class RuboCop::AST::BreakNode
end
class RuboCop::AST::Builder
NODE_MAP = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::Builder
end
class RuboCop::AST::CaseNode
include ::RuboCop::AST::ConditionalNode
def each_when(); end
def else?(); end
def else_branch(); end
def keyword(); end
def when_branches(); end
end
class RuboCop::AST::CaseNode
end
class RuboCop::AST::ClassNode
def body(); end
def identifier(); end
def parent_class(); end
end
class RuboCop::AST::ClassNode
end
module RuboCop::AST::CollectionNode
def &(*args, &block); end
def *(*args, &block); end
def +(*args, &block); end
def -(*args, &block); end
def <<(*args, &block); end
def [](*args, &block); end
def []=(*args, &block); end
def all?(*args, &block); end
def any?(*args, &block); end
def append(*args, &block); end
def assoc(*args, &block); end
def at(*args, &block); end
def bsearch(*args, &block); end
def bsearch_index(*args, &block); end
def chain(*args, &block); end
def chunk(*args, &block); end
def chunk_while(*args, &block); end
def clear(*args, &block); end
def collect(*args, &block); end
def collect!(*args, &block); end
def collect_concat(*args, &block); end
def combination(*args, &block); end
def compact(*args, &block); end
def compact!(*args, &block); end
def concat(*args, &block); end
def count(*args, &block); end
def cycle(*args, &block); end
def delete(*args, &block); end
def delete_at(*args, &block); end
def delete_if(*args, &block); end
def detect(*args, &block); end
def difference(*args, &block); end
def dig(*args, &block); end
def drop(*args, &block); end
def drop_while(*args, &block); end
def each(*args, &block); end
def each_cons(*args, &block); end
def each_entry(*args, &block); end
def each_index(*args, &block); end
def each_slice(*args, &block); end
def each_with_index(*args, &block); end
def each_with_object(*args, &block); end
def empty?(*args, &block); end
def entries(*args, &block); end
def fetch(*args, &block); end
def fill(*args, &block); end
def filter(*args, &block); end
def filter!(*args, &block); end
def find(*args, &block); end
def find_all(*args, &block); end
def find_index(*args, &block); end
def first(*args, &block); end
def flat_map(*args, &block); end
def flatten(*args, &block); end
def flatten!(*args, &block); end
def grep(*args, &block); end
def grep_v(*args, &block); end
def group_by(*args, &block); end
def include?(*args, &block); end
def index(*args, &block); end
def inject(*args, &block); end
def insert(*args, &block); end
def join(*args, &block); end
def keep_if(*args, &block); end
def last(*args, &block); end
def lazy(*args, &block); end
def length(*args, &block); end
def map(*args, &block); end
def map!(*args, &block); end
def max(*args, &block); end
def max_by(*args, &block); end
def member?(*args, &block); end
def min(*args, &block); end
def min_by(*args, &block); end
def minmax(*args, &block); end
def minmax_by(*args, &block); end
def none?(*args, &block); end
def one?(*args, &block); end
def pack(*args, &block); end
def partition(*args, &block); end
def permutation(*args, &block); end
def pop(*args, &block); end
def prepend(*args, &block); end
def product(*args, &block); end
def push(*args, &block); end
def rassoc(*args, &block); end
def reduce(*args, &block); end
def reject(*args, &block); end
def reject!(*args, &block); end
def repeated_combination(*args, &block); end
def repeated_permutation(*args, &block); end
def replace(*args, &block); end
def reverse(*args, &block); end
def reverse!(*args, &block); end
def reverse_each(*args, &block); end
def rindex(*args, &block); end
def rotate(*args, &block); end
def rotate!(*args, &block); end
def sample(*args, &block); end
def select(*args, &block); end
def select!(*args, &block); end
def shelljoin(*args, &block); end
def shift(*args, &block); end
def shuffle(*args, &block); end
def shuffle!(*args, &block); end
def size(*args, &block); end
def slice(*args, &block); end
def slice!(*args, &block); end
def slice_after(*args, &block); end
def slice_before(*args, &block); end
def slice_when(*args, &block); end
def sort(*args, &block); end
def sort!(*args, &block); end
def sort_by(*args, &block); end
def sort_by!(*args, &block); end
def sum(*args, &block); end
def take(*args, &block); end
def take_while(*args, &block); end
def to_ary(*args, &block); end
def to_h(*args, &block); end
def to_set(*args, &block); end
def transpose(*args, &block); end
def union(*args, &block); end
def uniq(*args, &block); end
def uniq!(*args, &block); end
def unshift(*args, &block); end
def values_at(*args, &block); end
def zip(*args, &block); end
def |(*args, &block); end
ARRAY_METHODS = ::T.let(nil, ::T.untyped)
end
module RuboCop::AST::CollectionNode
extend ::Forwardable
end
module RuboCop::AST::ConditionalNode
def body(); end
def condition(); end
def multiline_condition?(); end
def single_line_condition?(); end
end
module RuboCop::AST::ConditionalNode
end
class RuboCop::AST::DefNode
include ::RuboCop::AST::ParameterizedNode
include ::RuboCop::AST::MethodIdentifierPredicates
def argument_forwarding?(); end
def arguments(); end
def body(); end
def method_name(); end
def receiver(); end
def void_context?(); end
end
class RuboCop::AST::DefNode
end
class RuboCop::AST::DefinedNode
include ::RuboCop::AST::ParameterizedNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
end
class RuboCop::AST::DefinedNode
end
class RuboCop::AST::EnsureNode
def body(); end
end
class RuboCop::AST::EnsureNode
end
class RuboCop::AST::FloatNode
include ::RuboCop::AST::NumericNode
end
class RuboCop::AST::FloatNode
end
class RuboCop::AST::ForNode
def body(); end
def collection(); end
def do?(); end
def keyword(); end
def variable(); end
def void_context?(); end
end
class RuboCop::AST::ForNode
end
class RuboCop::AST::ForwardArgsNode
include ::RuboCop::AST::CollectionNode
end
class RuboCop::AST::ForwardArgsNode
end
module RuboCop::AST::HashElementNode
def delimiter_delta(other); end
def key(); end
def key_delta(other, alignment=T.unsafe(nil)); end
def same_line?(other); end
def value(); end
def value_delta(other); end
end
module RuboCop::AST::HashElementNode
end
class RuboCop::AST::HashNode
def braces?(); end
def each_key(); end
def each_pair(); end
def each_value(); end
def empty?(); end
def keys(); end
def mixed_delimiters?(); end
def pairs(); end
def pairs_on_same_line?(); end
def values(); end
end
class RuboCop::AST::HashNode
end
class RuboCop::AST::IfNode
include ::RuboCop::AST::ConditionalNode
include ::RuboCop::AST::ModifierNode
def branches(); end
def each_branch(); end
def else?(); end
def else_branch(); end
def elsif?(); end
def elsif_conditional?(); end
def if?(); end
def if_branch(); end
def inverse_keyword(); end
def keyword(); end
def nested_conditional?(); end
def ternary?(); end
def unless?(); end
end
class RuboCop::AST::IfNode
end
class RuboCop::AST::IntNode
include ::RuboCop::AST::NumericNode
end
class RuboCop::AST::IntNode
end
class RuboCop::AST::KeywordSplatNode
include ::RuboCop::AST::HashElementNode
def colon?(); end
def hash_rocket?(); end
def operator(); end
DOUBLE_SPLAT = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::KeywordSplatNode
end
module RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
def access_modifier?(); end
def adjacent_def_modifier?(node=T.unsafe(nil)); end
def arguments(); end
def arithmetic_operation?(); end
def assignment?(); end
def bare_access_modifier?(); end
def bare_access_modifier_declaration?(node=T.unsafe(nil)); end
def binary_operation?(); end
def block_literal?(); end
def block_node(); end
def command?(name); end
def const_receiver?(); end
def def_modifier?(); end
def dot?(); end
def double_colon?(); end
def implicit_call?(); end
def lambda?(); end
def lambda_literal?(); end
def macro?(); end
def macro_scope?(node=T.unsafe(nil)); end
def method_name(); end
def non_bare_access_modifier?(); end
def non_bare_access_modifier_declaration?(node=T.unsafe(nil)); end
def receiver(); end
def self_receiver?(); end
def setter_method?(); end
def special_modifier?(); end
def unary_operation?(); end
ARITHMETIC_OPERATORS = ::T.let(nil, ::T.untyped)
SPECIAL_MODIFIERS = ::T.let(nil, ::T.untyped)
end
module RuboCop::AST::MethodDispatchNode
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::AST::MethodIdentifierPredicates
def assignment_method?(); end
def bang_method?(); end
def camel_case_method?(); end
def comparison_method?(); end
def const_receiver?(); end
def enumerator_method?(); end
def method?(name); end
def negation_method?(); end
def operator_method?(); end
def predicate_method?(); end
def prefix_bang?(); end
def prefix_not?(); end
def self_receiver?(); end
ENUMERATOR_METHODS = ::T.let(nil, ::T.untyped)
OPERATOR_METHODS = ::T.let(nil, ::T.untyped)
end
module RuboCop::AST::MethodIdentifierPredicates
end
module RuboCop::AST::ModifierNode
def modifier_form?(); end
end
module RuboCop::AST::ModifierNode
end
class RuboCop::AST::ModuleNode
def body(); end
def identifier(); end
end
class RuboCop::AST::ModuleNode
end
class RuboCop::AST::Node
include ::RuboCop::AST::Sexp
def __ENCODING___type?(); end
def __FILE___type?(); end
def __LINE___type?(); end
def alias_type?(); end
def ancestors(); end
def and_asgn_type?(); end
def and_type?(); end
def arg_expr_type?(); end
def arg_type?(); end
def args_type?(); end
def argument?(); end
def array_pattern_type?(); end
def array_pattern_with_tail_type?(); end
def array_type?(); end
def assignment?(); end
def assignment_or_similar?(node=T.unsafe(nil)); end
def back_ref_type?(); end
def basic_conditional?(); end
def basic_literal?(); end
def begin_type?(); end
def block_pass_type?(); end
def block_type?(); end
def blockarg_expr_type?(); end
def blockarg_type?(); end
def boolean_type?(); end
def break_type?(); end
def call_type?(); end
def case_match_type?(); end
def case_type?(); end
def casgn_type?(); end
def cbase_type?(); end
def chained?(); end
def child_nodes(); end
def class_constructor?(node=T.unsafe(nil)); end
def class_type?(); end
def complete!(); end
def complete?(); end
def complex_type?(); end
def conditional?(); end
def const_name(); end
def const_pattern_type?(); end
def const_type?(); end
def csend_type?(); end
def cvar_type?(); end
def cvasgn_type?(); end
def def_type?(); end
def defined_module(); end
def defined_module_name(); end
def defined_type?(); end
def defs_type?(); end
def descendants(); end
def dstr_type?(); end
def dsym_type?(); end
def each_ancestor(*types, &block); end
def each_child_node(*types); end
def each_descendant(*types, &block); end
def each_node(*types, &block); end
def eflipflop_type?(); end
def empty_else_type?(); end
def empty_source?(); end
def ensure_type?(); end
def equals_asgn?(); end
def erange_type?(); end
def false_type?(); end
def falsey_literal?(); end
def first_line(); end
def float_type?(); end
def for_type?(); end
def forward_args_type?(); end
def forwarded_args_type?(); end
def guard_clause?(node=T.unsafe(nil)); end
def gvar_type?(); end
def gvasgn_type?(); end
def hash_pattern_type?(); end
def hash_type?(); end
def ident_type?(); end
def if_guard_type?(); end
def if_type?(); end
def iflipflop_type?(); end
def immutable_literal?(); end
def in_match_type?(); end
def in_pattern_type?(); end
def index_type?(); end
def indexasgn_type?(); end
def int_type?(); end
def irange_type?(); end
def ivar_type?(); end
def ivasgn_type?(); end
def keyword?(); end
def kwarg_type?(); end
def kwbegin_type?(); end
def kwnilarg_type?(); end
def kwoptarg_type?(); end
def kwrestarg_type?(); end
def kwsplat_type?(); end
def lambda?(node=T.unsafe(nil)); end
def lambda_or_proc?(node=T.unsafe(nil)); end
def lambda_type?(); end
def last_line(); end
def line_count(); end
def literal?(); end
def lvar_type?(); end
def lvasgn_type?(); end
def masgn_type?(); end
def match_alt_type?(); end
def match_as_type?(); end
def match_current_line_type?(); end
def match_nil_pattern_type?(); end
def match_rest_type?(); end
def match_var_type?(); end
def match_with_lvasgn_type?(); end
def match_with_trailing_comma_type?(); end
def mlhs_type?(); end
def module_type?(); end
def multiline?(); end
def mutable_literal?(); end
def new_class_or_module_block?(node=T.unsafe(nil)); end
def next_type?(); end
def nil_type?(); end
def node_parts(); end
def nonempty_line_count(); end
def not_type?(); end
def nth_ref_type?(); end
def numargs_type?(); end
def numblock_type?(); end
def numeric_type?(); end
def objc_kwarg_type?(); end
def objc_restarg_type?(); end
def objc_varargs_type?(); end
def op_asgn_type?(); end
def operator_keyword?(); end
def optarg_type?(); end
def or_asgn_type?(); end
def or_type?(); end
def pair_type?(); end
def parent(); end
def parent=(node); end
def parent_module_name(); end
def parenthesized_call?(); end
def pin_type?(); end
def postexe_type?(); end
def preexe_type?(); end
def proc?(node=T.unsafe(nil)); end
def procarg0_type?(); end
def pure?(); end
def range_type?(); end
def rational_type?(); end
def receiver(node=T.unsafe(nil)); end
def recursive_basic_literal?(); end
def recursive_literal?(); end
def redo_type?(); end
def reference?(); end
def regexp_type?(); end
def regopt_type?(); end
def resbody_type?(); end
def rescue_type?(); end
def restarg_expr_type?(); end
def restarg_type?(); end
def retry_type?(); end
def return_type?(); end
def root_type?(); end
def sclass_type?(); end
def self_type?(); end
def send_type?(); end
def shadowarg_type?(); end
def shorthand_asgn?(); end
def sibling_index(); end
def single_line?(); end
def source(); end
def source_length(); end
def source_range(); end
def special_keyword?(); end
def splat_type?(); end
def str_content(node=T.unsafe(nil)); end
def str_type?(); end
def super_type?(); end
def sym_type?(); end
def true_type?(); end
def truthy_literal?(); end
def undef_type?(); end
def unless_guard_type?(); end
def until_post_type?(); end
def until_type?(); end
def value_used?(); end
def variable?(); end
def visit_descendants(types, &block); end
def when_type?(); end
def while_post_type?(); end
def while_type?(); end
def xstr_type?(); end
def yield_type?(); end
def zsuper_type?(); end
ASSIGNMENTS = ::T.let(nil, ::T.untyped)
BASIC_CONDITIONALS = ::T.let(nil, ::T.untyped)
BASIC_LITERALS = ::T.let(nil, ::T.untyped)
COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped)
COMPOSITE_LITERALS = ::T.let(nil, ::T.untyped)
CONDITIONALS = ::T.let(nil, ::T.untyped)
EQUALS_ASSIGNMENTS = ::T.let(nil, ::T.untyped)
FALSEY_LITERALS = ::T.let(nil, ::T.untyped)
IMMUTABLE_LITERALS = ::T.let(nil, ::T.untyped)
KEYWORDS = ::T.let(nil, ::T.untyped)
LITERALS = ::T.let(nil, ::T.untyped)
MUTABLE_LITERALS = ::T.let(nil, ::T.untyped)
OPERATOR_KEYWORDS = ::T.let(nil, ::T.untyped)
REFERENCES = ::T.let(nil, ::T.untyped)
SHORTHAND_ASSIGNMENTS = ::T.let(nil, ::T.untyped)
SPECIAL_KEYWORDS = ::T.let(nil, ::T.untyped)
TRUTHY_LITERALS = ::T.let(nil, ::T.untyped)
VARIABLES = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::Node
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::AST::NumericNode
def sign?(); end
SIGN_REGEX = ::T.let(nil, ::T.untyped)
end
module RuboCop::AST::NumericNode
end
class RuboCop::AST::OrNode
include ::RuboCop::AST::BinaryOperatorNode
include ::RuboCop::AST::PredicateOperatorNode
def alternate_operator(); end
def inverse_operator(); end
end
class RuboCop::AST::OrNode
end
class RuboCop::AST::PairNode
include ::RuboCop::AST::HashElementNode
def colon?(); end
def delimiter(with_spacing=T.unsafe(nil)); end
def hash_rocket?(); end
def inverse_delimiter(with_spacing=T.unsafe(nil)); end
def value_on_new_line?(); end
COLON = ::T.let(nil, ::T.untyped)
HASH_ROCKET = ::T.let(nil, ::T.untyped)
SPACED_COLON = ::T.let(nil, ::T.untyped)
SPACED_HASH_ROCKET = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::PairNode
end
module RuboCop::AST::ParameterizedNode
def arguments?(); end
def block_argument?(); end
def first_argument(); end
def last_argument(); end
def parenthesized?(); end
def rest_argument?(); end
def splat_argument?(); end
end
module RuboCop::AST::ParameterizedNode
end
module RuboCop::AST::PredicateOperatorNode
def logical_operator?(); end
def operator(); end
def semantic_operator?(); end
LOGICAL_AND = ::T.let(nil, ::T.untyped)
LOGICAL_OR = ::T.let(nil, ::T.untyped)
SEMANTIC_AND = ::T.let(nil, ::T.untyped)
SEMANTIC_OR = ::T.let(nil, ::T.untyped)
end
module RuboCop::AST::PredicateOperatorNode
end
class RuboCop::AST::RangeNode
def begin(); end
def end(); end
end
class RuboCop::AST::RangeNode
end
class RuboCop::AST::RegexpNode
def content(); end
def regopt(); end
def to_regexp(); end
OPTIONS = ::T.let(nil, ::T.untyped)
end
class RuboCop::AST::RegexpNode
end
class RuboCop::AST::ResbodyNode
def body(); end
def exception_variable(); end
end
class RuboCop::AST::ResbodyNode
end
class RuboCop::AST::RetryNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
include ::RuboCop::AST::ParameterizedNode
end
class RuboCop::AST::RetryNode
end
class RuboCop::AST::ReturnNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
include ::RuboCop::AST::ParameterizedNode
end
class RuboCop::AST::ReturnNode
end
class RuboCop::AST::SelfClassNode
def body(); end
def identifier(); end
end
class RuboCop::AST::SelfClassNode
end
class RuboCop::AST::SendNode
include ::RuboCop::AST::ParameterizedNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
end
class RuboCop::AST::SendNode
end
module RuboCop::AST::Sexp
def s(type, *children); end
end
module RuboCop::AST::Sexp
end
class RuboCop::AST::StrNode
include ::RuboCop::AST::BasicLiteralNode
def heredoc?(); end
end
class RuboCop::AST::StrNode
end
class RuboCop::AST::SuperNode
include ::RuboCop::AST::ParameterizedNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
end
class RuboCop::AST::SuperNode
end
class RuboCop::AST::SymbolNode
include ::RuboCop::AST::BasicLiteralNode
end
class RuboCop::AST::SymbolNode
end
module RuboCop::AST::Traversal
def on_alias(node); end
def on_and(node); end
def on_and_asgn(node); end
def on_arg(node); end
def on_arg_expr(node); end
def on_args(node); end
def on_array(node); end
def on_array_pattern(node); end
def on_array_pattern_with_tail(node); end
def on_back_ref(node); end
def on_begin(node); end
def on_block(node); end
def on_block_pass(node); end
def on_blockarg(node); end
def on_break(node); end
def on_case(node); end
def on_case_match(node); end
def on_casgn(node); end
def on_cbase(node); end
def on_class(node); end
def on_complex(node); end
def on_const(node); end
def on_const_pattern(node); end
def on_csend(node); end
def on_cvar(node); end
def on_cvasgn(node); end
def on_def(node); end
def on_defined?(node); end
def on_defs(node); end
def on_dstr(node); end
def on_dsym(node); end
def on_eflipflop(node); end
def on_ensure(node); end
def on_erange(node); end
def on_false(node); end
def on_float(node); end
def on_for(node); end
def on_forward_args(node); end
def on_forwarded_args(node); end
def on_gvar(node); end
def on_gvasgn(node); end
def on_hash(node); end
def on_hash_pattern(node); end
def on_if(node); end
def on_if_guard(node); end
def on_iflipflop(node); end
def on_in_match(node); end
def on_in_pattern(node); end
def on_int(node); end
def on_irange(node); end
def on_ivar(node); end
def on_ivasgn(node); end
def on_kwarg(node); end
def on_kwbegin(node); end
def on_kwoptarg(node); end
def on_kwrestarg(node); end
def on_kwsplat(node); end
def on_lambda(node); end
def on_lvar(node); end
def on_lvasgn(node); end
def on_masgn(node); end
def on_match_alt(node); end
def on_match_as(node); end
def on_match_current_line(node); end
def on_match_nil_pattern(node); end
def on_match_rest(node); end
def on_match_var(node); end
def on_match_with_lvasgn(node); end
def on_match_with_trailing_comma(node); end
def on_mlhs(node); end
def on_module(node); end
def on_next(node); end
def on_nil(node); end
def on_not(node); end
def on_nth_ref(node); end
def on_numblock(node); end
def on_op_asgn(node); end
def on_optarg(node); end
def on_or(node); end
def on_or_asgn(node); end
def on_pair(node); end
def on_pin(node); end
def on_postexe(node); end
def on_preexe(node); end
def on_rational(node); end
def on_redo(node); end
def on_regexp(node); end
def on_regopt(node); end
def on_resbody(node); end
def on_rescue(node); end
def on_restarg(node); end
def on_retry(node); end
def on_return(node); end
def on_sclass(node); end
def on_self(node); end
def on_send(node); end
def on_shadowarg(node); end
def on_splat(node); end
def on_str(node); end
def on_super(node); end
def on_sym(node); end
def on_true(node); end
def on_undef(node); end
def on_unless_guard(node); end
def on_until(node); end
def on_until_post(node); end
def on_when(node); end
def on_while(node); end
def on_while_post(node); end
def on_xstr(node); end
def on_yield(node); end
def on_zsuper(node); end
def walk(node); end
MANY_CHILD_NODES = ::T.let(nil, ::T.untyped)
NO_CHILD_NODES = ::T.let(nil, ::T.untyped)
ONE_CHILD_NODE = ::T.let(nil, ::T.untyped)
SECOND_CHILD_ONLY = ::T.let(nil, ::T.untyped)
end
module RuboCop::AST::Traversal
end
class RuboCop::AST::UntilNode
include ::RuboCop::AST::ConditionalNode
include ::RuboCop::AST::ModifierNode
def do?(); end
def inverse_keyword(); end
def keyword(); end
end
class RuboCop::AST::UntilNode
end
class RuboCop::AST::WhenNode
def body(); end
def branch_index(); end
def conditions(); end
def each_condition(); end
def then?(); end
end
class RuboCop::AST::WhenNode
end
class RuboCop::AST::WhileNode
include ::RuboCop::AST::ConditionalNode
include ::RuboCop::AST::ModifierNode
def do?(); end
def inverse_keyword(); end
def keyword(); end
end
class RuboCop::AST::WhileNode
end
class RuboCop::AST::YieldNode
include ::RuboCop::AST::ParameterizedNode
include ::RuboCop::AST::MethodDispatchNode
include ::RuboCop::AST::MethodIdentifierPredicates
end
class RuboCop::AST::YieldNode
end
module RuboCop::AST
end
class RuboCop::CLI
def config_store(); end
def options(); end
def run(args=T.unsafe(nil)); end
STATUS_ERROR = ::T.let(nil, ::T.untyped)
STATUS_INTERRUPTED = ::T.let(nil, ::T.untyped)
STATUS_OFFENSES = ::T.let(nil, ::T.untyped)
STATUS_SUCCESS = ::T.let(nil, ::T.untyped)
end
module RuboCop::CLI::Command
end
class RuboCop::CLI::Command::AutoGenerateConfig
def run(); end
PHASE_1 = ::T.let(nil, ::T.untyped)
PHASE_1_DISABLED = ::T.let(nil, ::T.untyped)
PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped)
PHASE_2 = ::T.let(nil, ::T.untyped)
end
class RuboCop::CLI::Command::AutoGenerateConfig
end
class RuboCop::CLI::Command::Base
def env(); end
def initialize(env); end
end
class RuboCop::CLI::Command::Base
def self.by_command_name(name); end
def self.command_name(); end
def self.command_name=(command_name); end
def self.inherited(subclass); end
end
class RuboCop::CLI::Command::ExecuteRunner
include ::RuboCop::Formatter::TextUtil
def run(); end
end
class RuboCop::CLI::Command::ExecuteRunner
end
class RuboCop::CLI::Command::InitDotfile
def run(); end
DOTFILE = ::T.let(nil, ::T.untyped)
end
class RuboCop::CLI::Command::InitDotfile
end
class RuboCop::CLI::Command::ShowCops
def run(); end
end
class RuboCop::CLI::Command::ShowCops
end
class RuboCop::CLI::Command::Version
def run(); end
end
class RuboCop::CLI::Command::Version
end
module RuboCop::CLI::Command
def self.run(env, name); end
end
class RuboCop::CLI::Environment
def config_store(); end
def initialize(options, config_store, paths); end
def options(); end
def paths(); end
def run(name); end
end
class RuboCop::CLI::Environment
end
class RuboCop::CLI::Finished
end
class RuboCop::CLI::Finished
end
class RuboCop::CLI
end
class RuboCop::CachedData
def from_json(text); end
def initialize(filename); end
def to_json(offenses); end
end
class RuboCop::CachedData
end
class RuboCop::CommentConfig
def cop_disabled_line_ranges(); end
def cop_enabled_at_line?(cop, line_number); end
def extra_enabled_comments(); end
def initialize(processed_source); end
def processed_source(); end
COMMENT_DIRECTIVE_REGEXP = ::T.let(nil, ::T.untyped)
COPS_PATTERN = ::T.let(nil, ::T.untyped)
COP_NAMES_PATTERN = ::T.let(nil, ::T.untyped)
COP_NAME_PATTERN = ::T.let(nil, ::T.untyped)
REDUNDANT_DISABLE = ::T.let(nil, ::T.untyped)
end
class RuboCop::CommentConfig::CopAnalysis
def line_ranges(); end
def line_ranges=(_); end
def start_line_number(); end
def start_line_number=(_); end
end
class RuboCop::CommentConfig::CopAnalysis
def self.[](*_); end
def self.members(); end
end
class RuboCop::CommentConfig
end
class RuboCop::Config
include ::RuboCop::PathUtil
include ::RuboCop::FileFinder
def [](*args, &block); end
def []=(*args, &block); end
def add_excludes_from_higher_level(highest_config); end
def allowed_camel_case_file?(file); end
def base_dir_for_path_parameters(); end
def bundler_lock_file_path(); end
def check(); end
def delete(*args, &block); end
def deprecation_check(); end
def each(*args, &block); end
def each_key(*args, &block); end
def file_to_exclude?(file); end
def file_to_include?(file); end
def for_all_cops(); end
def for_cop(cop); end
def for_department(department_name); end
def initialize(hash=T.unsafe(nil), loaded_path=T.unsafe(nil)); end
def internal?(); end
def key?(*args, &block); end
def keys(*args, &block); end
def loaded_path(); end
def make_excludes_absolute(); end
def map(*args, &block); end
def merge(*args, &block); end
def path_relative_to_config(path); end
def patterns_to_exclude(); end
def patterns_to_include(); end
def possibly_include_hidden?(); end
def signature(); end
def smart_loaded_path(); end
def target_rails_version(); end
def target_ruby_version(*args, &block); end
def to_h(*args, &block); end
def to_hash(*args, &block); end
def validate(*args, &block); end
DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped)
end
class RuboCop::Config
extend ::Forwardable
def self.create(hash, path); end
end
class RuboCop::ConfigLoader
AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped)
DEFAULT_FILE = ::T.let(nil, ::T.untyped)
DOTFILE = ::T.let(nil, ::T.untyped)
RUBOCOP_HOME = ::T.let(nil, ::T.untyped)
XDG_CONFIG = ::T.let(nil, ::T.untyped)
end
class RuboCop::ConfigLoader
extend ::RuboCop::FileFinder
def self.add_excludes_from_files(config, config_file); end
def self.add_inheritance_from_auto_generated_file(); end
def self.add_missing_namespaces(path, hash); end
def self.auto_gen_config(); end
def self.auto_gen_config=(auto_gen_config); end
def self.auto_gen_config?(); end
def self.clear_options(); end
def self.configuration_file_for(target_dir); end
def self.configuration_from_file(config_file); end
def self.debug(); end
def self.debug=(debug); end
def self.debug?(); end
def self.default_configuration(); end
def self.default_configuration=(default_configuration); end
def self.ignore_parent_exclusion(); end
def self.ignore_parent_exclusion=(ignore_parent_exclusion); end
def self.ignore_parent_exclusion?(); end
def self.load_file(file); end
def self.merge(base_hash, derived_hash); end
def self.merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end
def self.options_config(); end
def self.options_config=(options_config); end
def self.warn_on_pending_cops(config); end
end
class RuboCop::ConfigLoaderResolver
def merge(base_hash, derived_hash, **opts); end
def merge_with_default(config, config_file, unset_nil:); end
def resolve_inheritance(path, hash, file, debug); end
def resolve_inheritance_from_gems(hash); end
def resolve_requires(path, hash); end
end
class RuboCop::ConfigLoaderResolver
end
class RuboCop::ConfigNotFoundError
end
class RuboCop::ConfigNotFoundError
end
class RuboCop::ConfigObsoletion
def initialize(config); end
def reject_obsolete_cops_and_parameters(); end
MOVED_COPS = ::T.let(nil, ::T.untyped)
OBSOLETE_COPS = ::T.let(nil, ::T.untyped)
OBSOLETE_ENFORCED_STYLES = ::T.let(nil, ::T.untyped)
OBSOLETE_PARAMETERS = ::T.let(nil, ::T.untyped)
REMOVED_COPS = ::T.let(nil, ::T.untyped)
REMOVED_COPS_WITH_REASON = ::T.let(nil, ::T.untyped)
RENAMED_COPS = ::T.let(nil, ::T.untyped)
SPLIT_COPS = ::T.let(nil, ::T.untyped)
end
class RuboCop::ConfigObsoletion
end
class RuboCop::ConfigStore
def for(file_or_dir); end
def force_default_config!(); end
def options_config=(options_config); end
end
class RuboCop::ConfigStore
end
class RuboCop::ConfigValidator
def for_all_cops(*args, &block); end
def initialize(config); end
def smart_loaded_path(*args, &block); end
def target_ruby_version(); end
def validate(); end
def validate_section_presence(name); end
COMMON_PARAMS = ::T.let(nil, ::T.untyped)
INTERNAL_PARAMS = ::T.let(nil, ::T.untyped)
end
class RuboCop::ConfigValidator
extend ::Forwardable
end
module RuboCop::Cop
end
module RuboCop::Cop::Alignment
SPACE = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Alignment
end
class RuboCop::Cop::AlignmentCorrector
end
class RuboCop::Cop::AlignmentCorrector
extend ::RuboCop::Cop::RangeHelp
extend ::RuboCop::Cop::Alignment
def self.align_end(processed_source, node, align_to); end
def self.correct(processed_source, node, column_delta); end
def self.processed_source(); end
end
class RuboCop::Cop::AmbiguousCopName
def initialize(name, origin, badges); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::AmbiguousCopName
end
module RuboCop::Cop::ArrayMinSize
end
module RuboCop::Cop::ArrayMinSize
end
module RuboCop::Cop::ArraySyntax
end
module RuboCop::Cop::ArraySyntax
end
module RuboCop::Cop::AutocorrectLogic
def autocorrect?(); end
def autocorrect_enabled?(); end
def autocorrect_requested?(); end
def correctable?(); end
def disable_offense(node); end
def disable_uncorrectable?(); end
def safe_autocorrect?(); end
def support_autocorrect?(); end
end
module RuboCop::Cop::AutocorrectLogic
end
class RuboCop::Cop::Badge
def ==(other); end
def cop_name(); end
def department(); end
def eql?(other); end
def initialize(department, cop_name); end
def match?(other); end
def qualified?(); end
def with_department(department); end
end
class RuboCop::Cop::Badge::InvalidBadge
def initialize(token); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Badge::InvalidBadge
end
class RuboCop::Cop::Badge
def self.for(class_name); end
def self.parse(identifier); end
end
module RuboCop::Cop::Bundler
end
class RuboCop::Cop::Bundler::DuplicatedGem
include ::RuboCop::Cop::RangeHelp
def gem_declarations(node0); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Bundler::DuplicatedGem
end
class RuboCop::Cop::Bundler::GemComment
include ::RuboCop::Cop::DefNode
def gem_declaration?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Bundler::GemComment
end
class RuboCop::Cop::Bundler::InsecureProtocolSource
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def insecure_protocol_source?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Bundler::InsecureProtocolSource
end
class RuboCop::Cop::Bundler::OrderedGems
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::OrderedGemNode
def autocorrect(node); end
def gem_declarations(node0); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Bundler::OrderedGems
end
module RuboCop::Cop::Bundler
end
module RuboCop::Cop::CheckAssignment
def on_and_asgn(node); end
def on_casgn(node); end
def on_cvasgn(node); end
def on_gvasgn(node); end
def on_ivasgn(node); end
def on_lvasgn(node); end
def on_masgn(node); end
def on_op_asgn(node); end
def on_or_asgn(node); end
def on_send(node); end
end
module RuboCop::Cop::CheckAssignment
def self.extract_rhs(node); end
end
module RuboCop::Cop::CheckLineBreakable
def extract_breakable_node(node, max); end
end
module RuboCop::Cop::CheckLineBreakable
end
module RuboCop::Cop::ClassishLength
include ::RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
end
module RuboCop::Cop::ClassishLength
end
module RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
end
module RuboCop::Cop::CodeLength
end
class RuboCop::Cop::Commissioner
include ::RuboCop::AST::Traversal
def errors(); end
def initialize(cops, forces=T.unsafe(nil), options=T.unsafe(nil)); end
def investigate(processed_source); end
end
class RuboCop::Cop::Commissioner
end
class RuboCop::Cop::ConditionCorrector
end
class RuboCop::Cop::ConditionCorrector
def self.correct_negative_condition(node); end
end
module RuboCop::Cop::ConfigurableEnforcedStyle
def alternative_style(); end
def alternative_styles(); end
def ambiguous_style_detected(*possibilities); end
def conflicting_styles_detected(); end
def correct_style_detected(); end
def detected_style(); end
def detected_style=(style); end
def no_acceptable_style!(); end
def no_acceptable_style?(); end
def opposite_style_detected(); end
def style(); end
def style_configured?(); end
def style_detected(detected); end
def style_parameter_name(); end
def supported_styles(); end
def unexpected_style_detected(unexpected); end
def unrecognized_style_detected(); end
end
module RuboCop::Cop::ConfigurableEnforcedStyle
end
module RuboCop::Cop::ConfigurableFormatting
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def check_name(node, name, name_range); end
def class_emitter_method?(node, name); end
def report_opposing_styles(node, name); end
def valid_name?(node, name, given_style=T.unsafe(nil)); end
end
module RuboCop::Cop::ConfigurableFormatting
end
module RuboCop::Cop::ConfigurableMax
end
module RuboCop::Cop::ConfigurableMax
end
module RuboCop::Cop::ConfigurableNaming
include ::RuboCop::Cop::ConfigurableFormatting
include ::RuboCop::Cop::ConfigurableEnforcedStyle
FORMATS = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::ConfigurableNaming
end
module RuboCop::Cop::ConfigurableNumbering
include ::RuboCop::Cop::ConfigurableFormatting
include ::RuboCop::Cop::ConfigurableEnforcedStyle
FORMATS = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::ConfigurableNumbering
end
class RuboCop::Cop::Cop
include ::RuboCop::AST::Sexp
include ::RuboCop::Cop::Util
include ::RuboCop::PathUtil
include ::RuboCop::Cop::IgnoredNode
include ::RuboCop::Cop::AutocorrectLogic
def add_offense(node, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil)); end
def config(); end
def config_to_allow_offenses(); end
def config_to_allow_offenses=(hash); end
def cop_config(); end
def cop_name(); end
def correct(node); end
def corrections(); end
def disable_uncorrectable(node); end
def duplicate_location?(location); end
def excluded_file?(file); end
def external_dependency_checksum(); end
def find_location(node, loc); end
def initialize(config=T.unsafe(nil), options=T.unsafe(nil)); end
def join_force?(_force_class); end
def message(_node=T.unsafe(nil)); end
def name(); end
def offenses(); end
def parse(source, path=T.unsafe(nil)); end
def processed_source(); end
def processed_source=(processed_source); end
def reason_to_not_correct(node); end
def relevant_file?(file); end
def target_rails_version(); end
def target_ruby_version(); end
end
class RuboCop::Cop::Cop::Correction
def call(corrector); end
def cop(); end
def cop=(_); end
def lambda=(_); end
def node(); end
def node=(_); end
end
class RuboCop::Cop::Cop::Correction
def self.[](*_); end
def self.members(); end
end
class RuboCop::Cop::Cop
extend ::RuboCop::AST::Sexp
extend ::RuboCop::NodePattern::Macros
def self.all(); end
def self.autocorrect_incompatible_with(); end
def self.badge(); end
def self.cop_name(); end
def self.department(); end
def self.inherited(subclass); end
def self.lint?(); end
def self.match?(given_names); end
def self.qualified_cop_name(name, origin); end
def self.registry(); end
end
class RuboCop::Cop::Corrector
def corrections(); end
def diagnostics(); end
def initialize(source_buffer, corrections=T.unsafe(nil)); end
def insert_after(range, content); end
def insert_before(range, content); end
def remove(range); end
def remove_leading(range, size); end
def remove_preceding(range, size); end
def remove_trailing(range, size); end
def replace(range, content); end
def rewrite(); end
end
class RuboCop::Cop::Corrector
end
module RuboCop::Cop::DefNode
def non_public_modifier?(node=T.unsafe(nil)); end
NON_PUBLIC_MODIFIERS = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::DefNode
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::DocumentationComment
include ::RuboCop::Cop::Style::AnnotationComment
end
module RuboCop::Cop::DocumentationComment
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::Duplication
end
module RuboCop::Cop::Duplication
end
class RuboCop::Cop::EachToForCorrector
def call(corrector); end
def initialize(block_node); end
CORRECTION_WITHOUT_ARGUMENTS = ::T.let(nil, ::T.untyped)
CORRECTION_WITH_ARGUMENTS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::EachToForCorrector
extend ::RuboCop::NodePattern::Macros
end
class RuboCop::Cop::EmptyLineCorrector
end
class RuboCop::Cop::EmptyLineCorrector
def self.correct(node); end
def self.insert_before(node); end
end
module RuboCop::Cop::EmptyParameter
def empty_arguments?(node=T.unsafe(nil)); end
end
module RuboCop::Cop::EmptyParameter
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::EndKeywordAlignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::EndKeywordAlignment
end
module RuboCop::Cop::EnforceSuperclass
def on_class(node); end
def on_send(node); end
end
module RuboCop::Cop::EnforceSuperclass
def self.included(base); end
end
module RuboCop::Cop::FirstElementLineBreak
end
module RuboCop::Cop::FirstElementLineBreak
end
class RuboCop::Cop::ForToEachCorrector
def call(corrector); end
def initialize(for_node); end
CORRECTION = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::ForToEachCorrector
extend ::RuboCop::NodePattern::Macros
end
class RuboCop::Cop::Force
def cops(); end
def initialize(cops); end
def investigate(_processed_source); end
def name(); end
def run_hook(method_name, *args); end
end
class RuboCop::Cop::Force
def self.all(); end
def self.force_name(); end
def self.inherited(subclass); end
end
module RuboCop::Cop::FrozenStringLiteral
FROZEN_STRING_LITERAL = ::T.let(nil, ::T.untyped)
FROZEN_STRING_LITERAL_ENABLED = ::T.let(nil, ::T.untyped)
FROZEN_STRING_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::FrozenStringLiteral
def self.frozen_string_literal_comment_exists?(); end
end
module RuboCop::Cop::Gemspec
end
class RuboCop::Cop::Gemspec::DuplicatedAssignment
include ::RuboCop::Cop::RangeHelp
def assignment_method_declarations(node0); end
def gem_specification(node0); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Gemspec::DuplicatedAssignment
end
class RuboCop::Cop::Gemspec::OrderedDependencies
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::OrderedGemNode
def autocorrect(node); end
def dependency_declarations(node0); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Gemspec::OrderedDependencies
end
class RuboCop::Cop::Gemspec::RequiredRubyVersion
def investigate(processed_source); end
def required_ruby_version(node0); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Gemspec::RequiredRubyVersion
end
class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage
def gem_specification?(node0); end
def on_const(node); end
def ruby_version?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage
end
module RuboCop::Cop::Gemspec
end
class RuboCop::Cop::Generator
def initialize(name, github_user, output: T.unsafe(nil)); end
def inject_config(config_file_path: T.unsafe(nil)); end
def inject_require(root_file_path: T.unsafe(nil)); end
def todo(); end
def write_source(); end
def write_spec(); end
CONFIGURATION_ADDED_MESSAGE = ::T.let(nil, ::T.untyped)
SOURCE_TEMPLATE = ::T.let(nil, ::T.untyped)
SPEC_TEMPLATE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Generator::ConfigurationInjector
def initialize(configuration_file_path:, badge:, version_added:); end
def inject(); end
TEMPLATE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Generator::ConfigurationInjector
end
class RuboCop::Cop::Generator::RequireFileInjector
def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end
def inject(); end
REQUIRE_PATH = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Generator::RequireFileInjector
end
class RuboCop::Cop::Generator
end
module RuboCop::Cop::HashAlignmentStyles
end
class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
def checkable_layout?(_node); end
def deltas(first_pair, current_pair); end
def deltas_for_first_pair(first_pair, _node); end
end
class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
end
class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
def deltas_for_first_pair(*_nodes); end
end
class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
end
class RuboCop::Cop::HashAlignmentStyles::TableAlignment
include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
def deltas_for_first_pair(first_pair, node); end
end
class RuboCop::Cop::HashAlignmentStyles::TableAlignment
end
module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
def checkable_layout?(node); end
def deltas(first_pair, current_pair); end
end
module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
end
module RuboCop::Cop::HashAlignmentStyles
end
module RuboCop::Cop::HashTransformMethod
def autocorrect(node); end
def on_block(node); end
def on_csend(node); end
def on_send(node); end
end
class RuboCop::Cop::HashTransformMethod::Autocorrection
def block_node(); end
def block_node=(_); end
def leading(); end
def leading=(_); end
def match(); end
def match=(_); end
def set_new_arg_name(transformed_argname, corrector); end
def set_new_body_expression(transforming_body_expr, corrector); end
def set_new_method_name(new_method_name, corrector); end
def strip_prefix_and_suffix(node, corrector); end
def trailing(); end
def trailing=(_); end
end
class RuboCop::Cop::HashTransformMethod::Autocorrection
def self.[](*_); end
def self.from_each_with_object(node, match); end
def self.from_hash_brackets_map(node, match); end
def self.from_map_to_h(node, match); end
def self.members(); end
end
class RuboCop::Cop::HashTransformMethod::Captures
def noop_transformation?(); end
def transformation_uses_both_args?(); end
def transformed_argname(); end
def transformed_argname=(_); end
def transforming_body_expr(); end
def transforming_body_expr=(_); end
def unchanged_body_expr(); end
def unchanged_body_expr=(_); end
end
class RuboCop::Cop::HashTransformMethod::Captures
def self.[](*_); end
def self.members(); end
end
module RuboCop::Cop::HashTransformMethod
end
module RuboCop::Cop::Heredoc
def on_dstr(node); end
def on_heredoc(_node); end
def on_str(node); end
def on_xstr(node); end
OPENING_DELIMITER = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Heredoc
end
module RuboCop::Cop::IgnoredMethods
end
module RuboCop::Cop::IgnoredMethods
end
module RuboCop::Cop::IgnoredNode
def ignore_node(node); end
def ignored_node?(node); end
def part_of_ignored_node?(node); end
end
module RuboCop::Cop::IgnoredNode
end
module RuboCop::Cop::IgnoredPattern
end
module RuboCop::Cop::IgnoredPattern
end
module RuboCop::Cop::IntegerNode
end
module RuboCop::Cop::IntegerNode
end
module RuboCop::Cop::Interpolation
def on_dstr(node); end
def on_dsym(node); end
def on_node_with_interpolations(node); end
def on_regexp(node); end
def on_xstr(node); end
end
module RuboCop::Cop::Interpolation
end
class RuboCop::Cop::LambdaLiteralToMethodCorrector
def call(corrector); end
def initialize(block_node); end
end
class RuboCop::Cop::LambdaLiteralToMethodCorrector
end
module RuboCop::Cop::Layout
end
class RuboCop::Cop::Layout::AccessModifierIndentation
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
def on_class(node); end
def on_module(node); end
def on_sclass(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::AccessModifierIndentation
end
class RuboCop::Cop::Layout::ArgumentAlignment
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ArgumentAlignment
end
class RuboCop::Cop::Layout::ArrayAlignment
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_array(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ArrayAlignment
end
class RuboCop::Cop::Layout::AssignmentIndentation
include ::RuboCop::Cop::CheckAssignment
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def check_assignment(node, rhs); end
def leftmost_multiple_assignment(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::AssignmentIndentation
end
class RuboCop::Cop::Layout::BlockAlignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def block_end_align_target?(node=T.unsafe(nil), param1); end
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::BlockAlignment
end
class RuboCop::Cop::Layout::BlockEndNewline
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::BlockEndNewline
end
class RuboCop::Cop::Layout::CaseIndentation
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_case(case_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::CaseIndentation
end
class RuboCop::Cop::Layout::ClassStructure
def autocorrect(node); end
def on_class(class_node); end
def visibility_block?(node=T.unsafe(nil)); end
HUMANIZED_NODE_TYPE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
VISIBILITY_SCOPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ClassStructure
end
class RuboCop::Cop::Layout::ClosingHeredocIndentation
include ::RuboCop::Cop::Heredoc
def autocorrect(node); end
def on_heredoc(node); end
MSG = ::T.let(nil, ::T.untyped)
MSG_ARG = ::T.let(nil, ::T.untyped)
SIMPLE_HEREDOC = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ClosingHeredocIndentation
end
class RuboCop::Cop::Layout::ClosingParenthesisIndentation
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_begin(node); end
def on_csend(node); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
MSG_ALIGN = ::T.let(nil, ::T.untyped)
MSG_INDENT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ClosingParenthesisIndentation
end
class RuboCop::Cop::Layout::CommentIndentation
include ::RuboCop::Cop::Alignment
def autocorrect(comment); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::CommentIndentation
end
class RuboCop::Cop::Layout::ConditionPosition
def on_if(node); end
def on_until(node); end
def on_while(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ConditionPosition
end
class RuboCop::Cop::Layout::DefEndAlignment
include ::RuboCop::Cop::EndKeywordAlignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::DefEndAlignment
end
class RuboCop::Cop::Layout::DotPosition
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
end
class RuboCop::Cop::Layout::DotPosition
end
class RuboCop::Cop::Layout::ElseAlignment
include ::RuboCop::Cop::EndKeywordAlignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::CheckAssignment
def autocorrect(node); end
def on_case(node); end
def on_if(node, base=T.unsafe(nil)); end
def on_rescue(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ElseAlignment
end
class RuboCop::Cop::Layout::EmptyComment
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyComment
end
class RuboCop::Cop::Layout::EmptyLineAfterGuardClause
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_if(node); end
END_OF_HEREDOC_LINE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLineAfterGuardClause
end
class RuboCop::Cop::Layout::EmptyLineAfterMagicComment
include ::RuboCop::Cop::RangeHelp
def autocorrect(token); end
def investigate(source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLineAfterMagicComment
end
class RuboCop::Cop::Layout::EmptyLineBetweenDefs
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def check_defs(nodes); end
def on_begin(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLineBetweenDefs
end
class RuboCop::Cop::Layout::EmptyLines
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
LINE_OFFSET = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLines
end
class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
def on_class(node); end
def on_module(node); end
def on_sclass(node); end
def on_send(node); end
MSG_AFTER = ::T.let(nil, ::T.untyped)
MSG_AFTER_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped)
MSG_BEFORE_AND_AFTER = ::T.let(nil, ::T.untyped)
MSG_BEFORE_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier
end
class RuboCop::Cop::Layout::EmptyLinesAroundArguments
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundArguments
end
class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody
include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_kwbegin(node); end
KIND = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody
end
class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody
include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
KIND = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody
end
module RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def constant_definition?(node=T.unsafe(nil)); end
def empty_line_required?(node=T.unsafe(nil)); end
MSG_DEFERRED = ::T.let(nil, ::T.untyped)
MSG_EXTRA = ::T.let(nil, ::T.untyped)
MSG_MISSING = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Layout::EmptyLinesAroundBody
extend ::RuboCop::NodePattern::Macros
end
class RuboCop::Cop::Layout::EmptyLinesAroundClassBody
include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_class(node); end
def on_sclass(node); end
KIND = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundClassBody
end
class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords
include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
def on_kwbegin(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords
end
class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody
include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
KIND = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody
end
class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody
include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_module(node); end
KIND = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody
end
class RuboCop::Cop::Layout::EndAlignment
include ::RuboCop::Cop::CheckAssignment
include ::RuboCop::Cop::EndKeywordAlignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_case(node); end
def on_class(node); end
def on_if(node); end
def on_module(node); end
def on_until(node); end
def on_while(node); end
end
class RuboCop::Cop::Layout::EndAlignment
end
class RuboCop::Cop::Layout::EndOfLine
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def investigate(processed_source); end
def offense_message(line); end
def unimportant_missing_cr?(index, last_line, line); end
MSG_DETECTED = ::T.let(nil, ::T.untyped)
MSG_MISSING = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::EndOfLine
end
class RuboCop::Cop::Layout::ExtraSpacing
include ::RuboCop::Cop::PrecedingFollowingAlignment
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
MSG_UNALIGNED_ASGN = ::T.let(nil, ::T.untyped)
MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ExtraSpacing
end
class RuboCop::Cop::Layout::FirstArgumentIndentation
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def eligible_method_call?(node=T.unsafe(nil)); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstArgumentIndentation
end
class RuboCop::Cop::Layout::FirstArrayElementIndentation
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::MultilineElementIndentation
def autocorrect(node); end
def on_array(node); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstArrayElementIndentation
end
class RuboCop::Cop::Layout::FirstArrayElementLineBreak
include ::RuboCop::Cop::FirstElementLineBreak
def autocorrect(node); end
def on_array(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstArrayElementLineBreak
end
class RuboCop::Cop::Layout::FirstHashElementIndentation
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::MultilineElementIndentation
def autocorrect(node); end
def on_csend(node); end
def on_hash(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstHashElementIndentation
end
class RuboCop::Cop::Layout::FirstHashElementLineBreak
include ::RuboCop::Cop::FirstElementLineBreak
def autocorrect(node); end
def on_hash(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstHashElementLineBreak
end
class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak
include ::RuboCop::Cop::FirstElementLineBreak
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
def on_super(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak
end
class RuboCop::Cop::Layout::FirstMethodParameterLineBreak
include ::RuboCop::Cop::FirstElementLineBreak
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstMethodParameterLineBreak
end
class RuboCop::Cop::Layout::FirstParameterIndentation
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::MultilineElementIndentation
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::FirstParameterIndentation
end
class RuboCop::Cop::Layout::HashAlignment
include ::RuboCop::Cop::HashAlignmentStyles
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def column_deltas(); end
def column_deltas=(column_deltas); end
def offences_by(); end
def offences_by=(offences_by); end
def on_hash(node); end
def on_send(node); end
def on_super(node); end
def on_yield(node); end
MESSAGES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::HashAlignment
end
class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis
end
class RuboCop::Cop::Layout::HeredocIndentation
include ::RuboCop::Cop::Heredoc
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_heredoc(node); end
LIBRARY_MSG = ::T.let(nil, ::T.untyped)
RUBY23_TYPE_MSG = ::T.let(nil, ::T.untyped)
RUBY23_WIDTH_MSG = ::T.let(nil, ::T.untyped)
STRIP_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::HeredocIndentation
end
class RuboCop::Cop::Layout::IndentationConsistency
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_begin(node); end
def on_kwbegin(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::IndentationConsistency
end
class RuboCop::Cop::Layout::IndentationWidth
include ::RuboCop::Cop::EndKeywordAlignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::CheckAssignment
include ::RuboCop::Cop::IgnoredPattern
def access_modifier?(node=T.unsafe(nil)); end
def autocorrect(node); end
def on_block(node); end
def on_case(case_node); end
def on_class(node); end
def on_csend(node); end
def on_def(node); end
def on_defs(node); end
def on_ensure(node); end
def on_for(node); end
def on_if(node, base=T.unsafe(nil)); end
def on_kwbegin(node); end
def on_module(node); end
def on_resbody(node); end
def on_rescue(node); end
def on_sclass(node); end
def on_until(node, base=T.unsafe(nil)); end
def on_while(node, base=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::IndentationWidth
end
class RuboCop::Cop::Layout::InitialIndentation
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(_processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::InitialIndentation
end
class RuboCop::Cop::Layout::LeadingCommentSpace
include ::RuboCop::Cop::RangeHelp
def autocorrect(comment); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::LeadingCommentSpace
end
class RuboCop::Cop::Layout::LeadingEmptyLines
def autocorrect(node); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::LeadingEmptyLines
end
class RuboCop::Cop::Layout::LineLength
include ::RuboCop::Cop::CheckLineBreakable
include ::RuboCop::Cop::ConfigurableMax
include ::RuboCop::Cop::IgnoredPattern
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::LineLengthHelp
def autocorrect(range); end
def investigate(processed_source); end
def investigate_post_walk(processed_source); end
def on_array(node); end
def on_block(node); end
def on_hash(node); end
def on_potential_breakable_node(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::LineLength
end
class RuboCop::Cop::Layout::MultilineArrayBraceLayout
include ::RuboCop::Cop::MultilineLiteralBraceLayout
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_array(node); end
ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineArrayBraceLayout
end
class RuboCop::Cop::Layout::MultilineArrayLineBreaks
include ::RuboCop::Cop::MultilineElementLineBreaks
def autocorrect(node); end
def on_array(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineArrayLineBreaks
end
class RuboCop::Cop::Layout::MultilineAssignmentLayout
include ::RuboCop::Cop::CheckAssignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def check_assignment(node, rhs); end
def check_by_enforced_style(node, rhs); end
def check_new_line_offense(node, rhs); end
def check_same_line_offense(node, rhs); end
NEW_LINE_OFFENSE = ::T.let(nil, ::T.untyped)
SAME_LINE_OFFENSE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineAssignmentLayout
end
class RuboCop::Cop::Layout::MultilineBlockLayout
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
ARG_MSG = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
PIPE_SIZE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineBlockLayout
end
class RuboCop::Cop::Layout::MultilineHashBraceLayout
include ::RuboCop::Cop::MultilineLiteralBraceLayout
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_hash(node); end
ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineHashBraceLayout
end
class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks
include ::RuboCop::Cop::MultilineElementLineBreaks
def autocorrect(node); end
def on_hash(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks
end
class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks
include ::RuboCop::Cop::MultilineElementLineBreaks
def autocorrect(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks
end
class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout
include ::RuboCop::Cop::MultilineLiteralBraceLayout
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_send(node); end
ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout
end
class RuboCop::Cop::Layout::MultilineMethodCallIndentation
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::MultilineExpressionIndentation
def autocorrect(node); end
def validate_config(); end
end
class RuboCop::Cop::Layout::MultilineMethodCallIndentation
end
class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout
include ::RuboCop::Cop::MultilineLiteralBraceLayout
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout
end
class RuboCop::Cop::Layout::MultilineOperationIndentation
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::MultilineExpressionIndentation
def autocorrect(node); end
def on_and(node); end
def on_or(node); end
def validate_config(); end
end
class RuboCop::Cop::Layout::MultilineOperationIndentation
end
class RuboCop::Cop::Layout::ParameterAlignment
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::ParameterAlignment
end
class RuboCop::Cop::Layout::RescueEnsureAlignment
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def investigate(processed_source); end
def on_ensure(node); end
def on_resbody(node); end
ALTERNATIVE_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped)
ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
RUBY_2_5_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::RescueEnsureAlignment
end
class RuboCop::Cop::Layout::SpaceAfterColon
def autocorrect(range); end
def on_kwoptarg(node); end
def on_pair(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAfterColon
end
class RuboCop::Cop::Layout::SpaceAfterComma
include ::RuboCop::Cop::SpaceAfterPunctuation
def autocorrect(comma); end
def kind(token); end
def space_style_before_rcurly(); end
end
class RuboCop::Cop::Layout::SpaceAfterComma
end
class RuboCop::Cop::Layout::SpaceAfterMethodName
include ::RuboCop::Cop::RangeHelp
def autocorrect(pos_before_left_paren); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAfterMethodName
end
class RuboCop::Cop::Layout::SpaceAfterNot
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
def whitespace_after_operator?(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAfterNot
end
class RuboCop::Cop::Layout::SpaceAfterSemicolon
include ::RuboCop::Cop::SpaceAfterPunctuation
def autocorrect(semicolon); end
def kind(token); end
def space_style_before_rcurly(); end
end
class RuboCop::Cop::Layout::SpaceAfterSemicolon
end
class RuboCop::Cop::Layout::SpaceAroundBlockParameters
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(target); end
def on_block(node); end
end
class RuboCop::Cop::Layout::SpaceAroundBlockParameters
end
class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(range); end
def on_optarg(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault
end
class RuboCop::Cop::Layout::SpaceAroundKeyword
def autocorrect(range); end
def on_and(node); end
def on_block(node); end
def on_break(node); end
def on_case(node); end
def on_defined?(node); end
def on_ensure(node); end
def on_for(node); end
def on_if(node); end
def on_kwbegin(node); end
def on_next(node); end
def on_or(node); end
def on_postexe(node); end
def on_preexe(node); end
def on_resbody(node); end
def on_rescue(node); end
def on_return(node); end
def on_send(node); end
def on_super(node); end
def on_until(node); end
def on_when(node); end
def on_while(node); end
def on_yield(node); end
def on_zsuper(node); end
ACCEPT_LEFT_PAREN = ::T.let(nil, ::T.untyped)
ACCEPT_LEFT_SQUARE_BRACKET = ::T.let(nil, ::T.untyped)
ACCEPT_NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped)
DO = ::T.let(nil, ::T.untyped)
MSG_AFTER = ::T.let(nil, ::T.untyped)
MSG_BEFORE = ::T.let(nil, ::T.untyped)
NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped)
SAFE_NAVIGATION = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAroundKeyword
end
class RuboCop::Cop::Layout::SpaceAroundOperators
include ::RuboCop::Cop::PrecedingFollowingAlignment
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::RationalLiteral
def autocorrect(range); end
def on_and(node); end
def on_and_asgn(node); end
def on_assignment(node); end
def on_binary(node); end
def on_casgn(node); end
def on_class(node); end
def on_cvasgn(node); end
def on_gvasgn(node); end
def on_if(node); end
def on_ivasgn(node); end
def on_lvasgn(node); end
def on_masgn(node); end
def on_op_asgn(node); end
def on_or(node); end
def on_or_asgn(node); end
def on_pair(node); end
def on_resbody(node); end
def on_send(node); end
def on_special_asgn(node); end
EXCESSIVE_SPACE = ::T.let(nil, ::T.untyped)
IRREGULAR_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAroundOperators
end
class RuboCop::Cop::Layout::SpaceBeforeBlockBraces
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def on_block(node); end
DETECTED_MSG = ::T.let(nil, ::T.untyped)
MISSING_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceBeforeBlockBraces
end
class RuboCop::Cop::Layout::SpaceBeforeComma
include ::RuboCop::Cop::SpaceBeforePunctuation
include ::RuboCop::Cop::RangeHelp
def autocorrect(space); end
def kind(token); end
end
class RuboCop::Cop::Layout::SpaceBeforeComma
end
class RuboCop::Cop::Layout::SpaceBeforeComment
def autocorrect(range); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceBeforeComment
end
class RuboCop::Cop::Layout::SpaceBeforeFirstArg
include ::RuboCop::Cop::PrecedingFollowingAlignment
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceBeforeFirstArg
end
class RuboCop::Cop::Layout::SpaceBeforeSemicolon
include ::RuboCop::Cop::SpaceBeforePunctuation
include ::RuboCop::Cop::RangeHelp
def autocorrect(space); end
def kind(token); end
end
class RuboCop::Cop::Layout::SpaceBeforeSemicolon
end
class RuboCop::Cop::Layout::SpaceInLambdaLiteral
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(lambda_node); end
def on_send(node); end
MSG_REQUIRE_NO_SPACE = ::T.let(nil, ::T.untyped)
MSG_REQUIRE_SPACE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInLambdaLiteral
end
class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_array(node); end
EMPTY_MSG = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets
end
class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral
include ::RuboCop::Cop::MatchRange
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_array(node); end
def on_percent_literal(node); end
MSG = ::T.let(nil, ::T.untyped)
MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral
end
class RuboCop::Cop::Layout::SpaceInsideBlockBraces
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def on_block(node); end
end
class RuboCop::Cop::Layout::SpaceInsideBlockBraces
end
class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(range); end
def on_hash(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces
end
class RuboCop::Cop::Layout::SpaceInsideParens
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(range); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
MSG_SPACE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideParens
end
class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters
include ::RuboCop::Cop::MatchRange
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_array(node); end
def on_percent_literal(node); end
def on_xstr(node); end
BEGIN_REGEX = ::T.let(nil, ::T.untyped)
END_REGEX = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters
end
class RuboCop::Cop::Layout::SpaceInsideRangeLiteral
def autocorrect(node); end
def on_erange(node); end
def on_irange(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideRangeLiteral
end
class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_send(node); end
BRACKET_METHODS = ::T.let(nil, ::T.untyped)
EMPTY_MSG = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets
end
class RuboCop::Cop::Layout::SpaceInsideStringInterpolation
include ::RuboCop::Cop::Interpolation
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(begin_node); end
def on_interpolation(begin_node); end
NO_SPACE_MSG = ::T.let(nil, ::T.untyped)
SPACE_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceInsideStringInterpolation
end
class RuboCop::Cop::Layout::Tab
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::Tab
end
class RuboCop::Cop::Layout::TrailingEmptyLines
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
end
class RuboCop::Cop::Layout::TrailingEmptyLines
end
class RuboCop::Cop::Layout::TrailingWhitespace
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::TrailingWhitespace
end
module RuboCop::Cop::Layout
end
class RuboCop::Cop::LineBreakCorrector
end
class RuboCop::Cop::LineBreakCorrector
extend ::RuboCop::Cop::Alignment
extend ::RuboCop::Cop::TrailingBody
extend ::RuboCop::Cop::Util
extend ::RuboCop::PathUtil
def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end
def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end
def self.move_comment(eol_comment:, node:, corrector:); end
def self.processed_source(); end
end
module RuboCop::Cop::LineLengthHelp
end
module RuboCop::Cop::LineLengthHelp
end
module RuboCop::Cop::Lint
end
class RuboCop::Cop::Lint::AmbiguousBlockAssociation
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::AmbiguousBlockAssociation
end
class RuboCop::Cop::Lint::AmbiguousOperator
include ::RuboCop::Cop::ParserDiagnostic
AMBIGUITIES = ::T.let(nil, ::T.untyped)
MSG_FORMAT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::AmbiguousOperator
end
class RuboCop::Cop::Lint::AmbiguousRegexpLiteral
include ::RuboCop::Cop::ParserDiagnostic
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::AmbiguousRegexpLiteral
end
class RuboCop::Cop::Lint::AssignmentInCondition
include ::RuboCop::Cop::SafeAssignment
def on_if(node); end
def on_until(node); end
def on_while(node); end
ASGN_TYPES = ::T.let(nil, ::T.untyped)
MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped)
MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::AssignmentInCondition
end
class RuboCop::Cop::Lint::BigDecimalNew
def autocorrect(node); end
def big_decimal_new(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::BigDecimalNew
end
class RuboCop::Cop::Lint::BooleanSymbol
def boolean_symbol?(node=T.unsafe(nil)); end
def on_sym(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::BooleanSymbol
end
class RuboCop::Cop::Lint::CircularArgumentReference
def on_kwoptarg(node); end
def on_optarg(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::CircularArgumentReference
end
class RuboCop::Cop::Lint::Debugger
def binding_irb_call?(node=T.unsafe(nil)); end
def debugger_call?(node=T.unsafe(nil)); end
def kernel?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::Debugger
end
class RuboCop::Cop::Lint::DeprecatedClassMethods
def autocorrect(node); end
def on_send(node); end
DEPRECATED_METHODS_OBJECT = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
include ::RuboCop::AST::Sexp
def class_constant(); end
def class_nodes(); end
def deprecated_method(); end
def initialize(deprecated:, replacement:, class_constant: T.unsafe(nil)); end
def replacement_method(); end
end
class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
end
class RuboCop::Cop::Lint::DeprecatedClassMethods
end
class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor
def on_def(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor
end
class RuboCop::Cop::Lint::DuplicateCaseCondition
def on_case(case_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::DuplicateCaseCondition
end
class RuboCop::Cop::Lint::DuplicateHashKey
include ::RuboCop::Cop::Duplication
def on_hash(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::DuplicateHashKey
end
class RuboCop::Cop::Lint::DuplicateMethods
def alias_method?(node=T.unsafe(nil)); end
def attr?(node=T.unsafe(nil)); end
def method_alias?(node=T.unsafe(nil)); end
def on_alias(node); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
def sym_name(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::DuplicateMethods
end
class RuboCop::Cop::Lint::EachWithObjectArgument
def each_with_object?(node=T.unsafe(nil)); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EachWithObjectArgument
end
class RuboCop::Cop::Lint::ElseLayout
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ElseLayout
end
class RuboCop::Cop::Lint::EmptyEnsure
def autocorrect(node); end
def on_ensure(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EmptyEnsure
end
class RuboCop::Cop::Lint::EmptyExpression
def on_begin(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EmptyExpression
end
class RuboCop::Cop::Lint::EmptyInterpolation
include ::RuboCop::Cop::Interpolation
def autocorrect(node); end
def on_interpolation(begin_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EmptyInterpolation
end
class RuboCop::Cop::Lint::EmptyWhen
def on_case(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EmptyWhen
end
class RuboCop::Cop::Lint::EndInMethod
def on_postexe(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EndInMethod
end
class RuboCop::Cop::Lint::EnsureReturn
def on_ensure(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EnsureReturn
end
class RuboCop::Cop::Lint::ErbNewArguments
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def erb_new_with_non_keyword_arguments(node=T.unsafe(nil)); end
def on_send(node); end
MESSAGES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ErbNewArguments
extend ::RuboCop::Cop::TargetRubyVersion
end
class RuboCop::Cop::Lint::FlipFlop
def on_eflipflop(node); end
def on_iflipflop(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::FlipFlop
end
class RuboCop::Cop::Lint::FloatOutOfRange
def on_float(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::FloatOutOfRange
end
class RuboCop::Cop::Lint::FormatParameterMismatch
def called_on_string?(node=T.unsafe(nil)); end
def on_send(node); end
KERNEL = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
SHOVEL = ::T.let(nil, ::T.untyped)
STRING_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::FormatParameterMismatch
end
class RuboCop::Cop::Lint::HeredocMethodCallPosition
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::HeredocMethodCallPosition
end
class RuboCop::Cop::Lint::ImplicitStringConcatenation
def on_dstr(node); end
FOR_ARRAY = ::T.let(nil, ::T.untyped)
FOR_METHOD = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ImplicitStringConcatenation
end
class RuboCop::Cop::Lint::IneffectiveAccessModifier
def on_class(node); end
def on_module(node); end
def private_class_methods(node0); end
ALTERNATIVE_PRIVATE = ::T.let(nil, ::T.untyped)
ALTERNATIVE_PROTECTED = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::IneffectiveAccessModifier
end
class RuboCop::Cop::Lint::InheritException
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def class_new_call?(node=T.unsafe(nil)); end
def on_class(node); end
def on_send(node); end
ILLEGAL_CLASSES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
PREFERRED_BASE_CLASS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::InheritException
end
class RuboCop::Cop::Lint::InterpolationCheck
def heredoc?(node); end
def on_str(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::InterpolationCheck
end
class RuboCop::Cop::Lint::LiteralAsCondition
def message(node); end
def on_case(case_node); end
def on_if(node); end
def on_send(node); end
def on_until(node); end
def on_until_post(node); end
def on_while(node); end
def on_while_post(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::LiteralAsCondition
end
class RuboCop::Cop::Lint::LiteralInInterpolation
include ::RuboCop::Cop::Interpolation
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_interpolation(begin_node); end
COMPOSITE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::LiteralInInterpolation
end
class RuboCop::Cop::Lint::Loop
def on_until_post(node); end
def on_while_post(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::Loop
end
class RuboCop::Cop::Lint::MissingCopEnableDirective
include ::RuboCop::Cop::RangeHelp
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
MSG_BOUND = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::MissingCopEnableDirective
end
class RuboCop::Cop::Lint::MultipleComparison
def autocorrect(node); end
def multiple_compare?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::MultipleComparison
end
class RuboCop::Cop::Lint::NestedMethodDefinition
def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end
def eval_call?(node=T.unsafe(nil)); end
def exec_call?(node=T.unsafe(nil)); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NestedMethodDefinition
end
class RuboCop::Cop::Lint::NestedPercentLiteral
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def on_array(node); end
def on_percent_literal(node); end
MSG = ::T.let(nil, ::T.untyped)
PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
REGEXES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NestedPercentLiteral
end
class RuboCop::Cop::Lint::NextWithoutAccumulator
def on_block(node); end
def on_body_of_reduce(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NextWithoutAccumulator
end
class RuboCop::Cop::Lint::NonDeterministicRequireOrder
def autocorrect(node); end
def loop_variable(node=T.unsafe(nil)); end
def on_block(node); end
def unsorted_dir_block?(node=T.unsafe(nil)); end
def unsorted_dir_each?(node=T.unsafe(nil)); end
def var_is_required?(node0, param1); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NonDeterministicRequireOrder
end
class RuboCop::Cop::Lint::NonLocalExitFromIterator
def chained_send?(node=T.unsafe(nil)); end
def define_method?(node=T.unsafe(nil)); end
def on_return(return_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NonLocalExitFromIterator
end
class RuboCop::Cop::Lint::NumberConversion
def autocorrect(node); end
def datetime?(node=T.unsafe(nil)); end
def on_send(node); end
def to_method(node=T.unsafe(nil)); end
CONVERSION_METHOD_CLASS_MAPPING = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NumberConversion
end
class RuboCop::Cop::Lint::OrderedMagicComments
include ::RuboCop::Cop::FrozenStringLiteral
def autocorrect(_node); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::OrderedMagicComments
end
class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression
include ::RuboCop::Cop::RangeHelp
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression
end
class RuboCop::Cop::Lint::PercentStringArray
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_array(node); end
def on_percent_literal(node); end
LEADING_QUOTE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
QUOTES_AND_COMMAS = ::T.let(nil, ::T.untyped)
TRAILING_QUOTE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::PercentStringArray
end
class RuboCop::Cop::Lint::PercentSymbolArray
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_array(node); end
def on_percent_literal(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::PercentSymbolArray
end
class RuboCop::Cop::Lint::RandOne
def on_send(node); end
def rand_one?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RandOne
end
class RuboCop::Cop::Lint::RedundantCopDisableDirective
include ::RuboCop::NameSimilarity
include ::RuboCop::Cop::RangeHelp
def autocorrect(args); end
def check(offenses, cop_disabled_line_ranges, comments); end
COP_NAME = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantCopDisableDirective
end
class RuboCop::Cop::Lint::RedundantCopEnableDirective
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
def autocorrect(comment_and_name); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantCopEnableDirective
end
class RuboCop::Cop::Lint::RedundantRequireStatement
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
def unnecessary_require_statement?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantRequireStatement
end
class RuboCop::Cop::Lint::RedundantSplatExpansion
def array_new?(node=T.unsafe(nil)); end
def autocorrect(node); end
def literal_expansion(node=T.unsafe(nil)); end
def on_splat(node); end
ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped)
ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped)
PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped)
PERCENT_I = ::T.let(nil, ::T.untyped)
PERCENT_W = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantSplatExpansion
end
class RuboCop::Cop::Lint::RedundantStringCoercion
include ::RuboCop::Cop::Interpolation
def autocorrect(node); end
def on_interpolation(begin_node); end
def to_s_without_args?(node=T.unsafe(nil)); end
MSG_DEFAULT = ::T.let(nil, ::T.untyped)
MSG_SELF = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantStringCoercion
end
class RuboCop::Cop::Lint::RedundantWithIndex
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
def redundant_with_index?(node=T.unsafe(nil)); end
MSG_EACH_WITH_INDEX = ::T.let(nil, ::T.untyped)
MSG_WITH_INDEX = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantWithIndex
end
class RuboCop::Cop::Lint::RedundantWithObject
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
def redundant_with_object?(node=T.unsafe(nil)); end
MSG_EACH_WITH_OBJECT = ::T.let(nil, ::T.untyped)
MSG_WITH_OBJECT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RedundantWithObject
end
class RuboCop::Cop::Lint::RegexpAsCondition
def on_match_current_line(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RegexpAsCondition
end
class RuboCop::Cop::Lint::RequireParentheses
include ::RuboCop::Cop::RangeHelp
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RequireParentheses
end
class RuboCop::Cop::Lint::RescueException
def on_resbody(node); end
def targets_exception?(rescue_arg_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RescueException
end
class RuboCop::Cop::Lint::RescueType
include ::RuboCop::Cop::RescueNode
def autocorrect(node); end
def on_resbody(node); end
INVALID_TYPES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::RescueType
end
class RuboCop::Cop::Lint::ReturnInVoidContext
def on_return(return_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ReturnInVoidContext
end
class RuboCop::Cop::Lint::SafeNavigationChain
include ::RuboCop::Cop::NilMethods
def bad_method?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::SafeNavigationChain
end
class RuboCop::Cop::Lint::SafeNavigationConsistency
include ::RuboCop::Cop::NilMethods
def autocorrect(node); end
def check(node); end
def on_csend(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::SafeNavigationConsistency
end
class RuboCop::Cop::Lint::SafeNavigationWithEmpty
def on_if(node); end
def safe_navigation_empty_in_conditional?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::SafeNavigationWithEmpty
end
class RuboCop::Cop::Lint::ScriptPermission
def autocorrect(node); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
SHEBANG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ScriptPermission
end
class RuboCop::Cop::Lint::SendWithMixinArgument
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
def send_with_mixin_argument?(node=T.unsafe(nil)); end
MIXIN_METHODS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::SendWithMixinArgument
end
class RuboCop::Cop::Lint::ShadowedArgument
def after_leaving_scope(scope, _variable_table); end
def join_force?(force_class); end
def uses_var?(node0, param1); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ShadowedArgument
end
class RuboCop::Cop::Lint::ShadowedException
include ::RuboCop::Cop::RescueNode
include ::RuboCop::Cop::RangeHelp
def on_rescue(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ShadowedException
end
class RuboCop::Cop::Lint::ShadowingOuterLocalVariable
def before_declaring_variable(variable, variable_table); end
def join_force?(force_class); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ShadowingOuterLocalVariable
end
class RuboCop::Cop::Lint::SuppressedException
def on_resbody(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::SuppressedException
end
class RuboCop::Cop::Lint::Syntax
def add_offense_from_diagnostic(diagnostic, ruby_version); end
def add_offense_from_error(error); end
ERROR_SOURCE_RANGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::Syntax::PseudoSourceRange
def begin_pos(); end
def begin_pos=(_); end
def column(); end
def column=(_); end
def end_pos(); end
def end_pos=(_); end
def line(); end
def line=(_); end
def source_line(); end
def source_line=(_); end
end
class RuboCop::Cop::Lint::Syntax::PseudoSourceRange
def self.[](*_); end
def self.members(); end
end
class RuboCop::Cop::Lint::Syntax
def self.offenses_from_processed_source(processed_source, config, options); end
end
class RuboCop::Cop::Lint::ToJSON
def autocorrect(node); end
def on_def(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ToJSON
end
class RuboCop::Cop::Lint::UnderscorePrefixedVariableName
def after_leaving_scope(scope, _variable_table); end
def check_variable(variable); end
def join_force?(force_class); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UnderscorePrefixedVariableName
end
class RuboCop::Cop::Lint::UnifiedInteger
def autocorrect(node); end
def fixnum_or_bignum_const(node=T.unsafe(nil)); end
def on_const(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UnifiedInteger
end
class RuboCop::Cop::Lint::UnreachableCode
def flow_command?(node=T.unsafe(nil)); end
def on_begin(node); end
def on_kwbegin(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UnreachableCode
end
module RuboCop::Cop::Lint::UnusedArgument
def after_leaving_scope(scope, _variable_table); end
def join_force?(force_class); end
end
module RuboCop::Cop::Lint::UnusedArgument
extend ::RuboCop::NodePattern::Macros
end
class RuboCop::Cop::Lint::UnusedBlockArgument
include ::RuboCop::Cop::Lint::UnusedArgument
def autocorrect(node); end
end
class RuboCop::Cop::Lint::UnusedBlockArgument
end
class RuboCop::Cop::Lint::UnusedMethodArgument
include ::RuboCop::Cop::Lint::UnusedArgument
def autocorrect(node); end
end
class RuboCop::Cop::Lint::UnusedMethodArgument
end
class RuboCop::Cop::Lint::UriEscapeUnescape
def on_send(node); end
def uri_escape_unescape?(node=T.unsafe(nil)); end
ALTERNATE_METHODS_OF_URI_ESCAPE = ::T.let(nil, ::T.untyped)
ALTERNATE_METHODS_OF_URI_UNESCAPE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UriEscapeUnescape
end
class RuboCop::Cop::Lint::UriRegexp
def autocorrect(node); end
def on_send(node); end
def uri_regexp_with_argument?(node=T.unsafe(nil)); end
def uri_regexp_without_argument?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UriRegexp
end
class RuboCop::Cop::Lint::UselessAccessModifier
def class_or_instance_eval?(node=T.unsafe(nil)); end
def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end
def dynamic_method_definition?(node=T.unsafe(nil)); end
def on_block(node); end
def on_class(node); end
def on_module(node); end
def on_sclass(node); end
def static_method_definition?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UselessAccessModifier
end
class RuboCop::Cop::Lint::UselessAssignment
include ::RuboCop::NameSimilarity
def after_leaving_scope(scope, _variable_table); end
def check_for_unused_assignments(variable); end
def collect_variable_like_names(scope); end
def join_force?(force_class); end
def message_for_useless_assignment(assignment); end
def message_specification(assignment, variable); end
def multiple_assignment_message(variable_name); end
def operator_assignment_message(scope, assignment); end
def return_value_node_of_scope(scope); end
def similar_name_message(variable); end
def variable_like_method_invocation?(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UselessAssignment
end
class RuboCop::Cop::Lint::UselessComparison
def on_send(node); end
def useless_comparison?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
OPS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UselessComparison
end
class RuboCop::Cop::Lint::UselessElseWithoutRescue
include ::RuboCop::Cop::ParserDiagnostic
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UselessElseWithoutRescue
end
class RuboCop::Cop::Lint::UselessSetterCall
def on_def(node); end
def on_defs(node); end
def setter_call_to_local_variable?(node=T.unsafe(nil)); end
ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker
def constructor?(node); end
def contain_local_object?(variable_name); end
def initialize(body_node); end
def process_assignment(asgn_node, rhs_node); end
def process_assignment_node(node); end
def process_binary_operator_assignment(op_asgn_node); end
def process_logical_operator_assignment(asgn_node); end
def process_multiple_assignment(masgn_node); end
def scan(node, &block); end
end
class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker
end
class RuboCop::Cop::Lint::UselessSetterCall
end
class RuboCop::Cop::Lint::Void
def on_begin(node); end
def on_block(node); end
def on_kwbegin(node); end
BINARY_OPERATORS = ::T.let(nil, ::T.untyped)
DEFINED_MSG = ::T.let(nil, ::T.untyped)
LIT_MSG = ::T.let(nil, ::T.untyped)
NONMUTATING_METHODS = ::T.let(nil, ::T.untyped)
NONMUTATING_MSG = ::T.let(nil, ::T.untyped)
OPERATORS = ::T.let(nil, ::T.untyped)
OP_MSG = ::T.let(nil, ::T.untyped)
SELF_MSG = ::T.let(nil, ::T.untyped)
UNARY_OPERATORS = ::T.let(nil, ::T.untyped)
VAR_MSG = ::T.let(nil, ::T.untyped)
VOID_CONTEXT_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::Void
end
module RuboCop::Cop::Lint
end
module RuboCop::Cop::MatchRange
include ::RuboCop::Cop::RangeHelp
end
module RuboCop::Cop::MatchRange
end
class RuboCop::Cop::MessageAnnotator
def annotate(message); end
def config(); end
def cop_config(); end
def cop_name(); end
def initialize(config, cop_name, cop_config, options); end
def options(); end
def urls(); end
end
class RuboCop::Cop::MessageAnnotator
def self.style_guide_urls(); end
end
module RuboCop::Cop::MethodComplexity
include ::RuboCop::Cop::ConfigurableMax
def define_method?(node=T.unsafe(nil)); end
def on_block(node); end
def on_def(node); end
def on_defs(node); end
end
module RuboCop::Cop::MethodComplexity
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::MethodPreference
end
module RuboCop::Cop::MethodPreference
end
module RuboCop::Cop::Metrics
end
class RuboCop::Cop::Metrics::AbcSize
include ::RuboCop::Cop::MethodComplexity
include ::RuboCop::Cop::ConfigurableMax
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::AbcSize
end
class RuboCop::Cop::Metrics::BlockLength
include ::RuboCop::Cop::TooManyLines
include ::RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
def on_block(node); end
LABEL = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::BlockLength
end
class RuboCop::Cop::Metrics::BlockNesting
include ::RuboCop::Cop::ConfigurableMax
def investigate(processed_source); end
NESTING_BLOCKS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::BlockNesting
end
class RuboCop::Cop::Metrics::ClassLength
include ::RuboCop::Cop::ClassishLength
include ::RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
def class_definition?(node=T.unsafe(nil)); end
def on_casgn(node); end
def on_class(node); end
end
class RuboCop::Cop::Metrics::ClassLength
end
class RuboCop::Cop::Metrics::CyclomaticComplexity
include ::RuboCop::Cop::MethodComplexity
include ::RuboCop::Cop::ConfigurableMax
COUNTED_NODES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::CyclomaticComplexity
end
class RuboCop::Cop::Metrics::MethodLength
include ::RuboCop::Cop::TooManyLines
include ::RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
def on_block(node); end
def on_def(node); end
def on_defs(node); end
LABEL = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::MethodLength
end
class RuboCop::Cop::Metrics::ModuleLength
include ::RuboCop::Cop::ClassishLength
include ::RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
def module_definition?(node=T.unsafe(nil)); end
def on_casgn(node); end
def on_module(node); end
end
class RuboCop::Cop::Metrics::ModuleLength
end
class RuboCop::Cop::Metrics::ParameterLists
include ::RuboCop::Cop::ConfigurableMax
def argument_to_lambda_or_proc?(node=T.unsafe(nil)); end
def on_args(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::ParameterLists
end
class RuboCop::Cop::Metrics::PerceivedComplexity
include ::RuboCop::Cop::MethodComplexity
include ::RuboCop::Cop::ConfigurableMax
COUNTED_NODES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::PerceivedComplexity
end
module RuboCop::Cop::Metrics::Utils
end
class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
def calculate(); end
def else_branch?(node); end
def evaluate_branch_nodes(node); end
def evaluate_condition_node(node); end
def initialize(node); end
BRANCH_NODES = ::T.let(nil, ::T.untyped)
CONDITION_NODES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
def self.calculate(node); end
end
module RuboCop::Cop::Metrics::Utils
end
module RuboCop::Cop::Metrics
end
module RuboCop::Cop::Migration
end
class RuboCop::Cop::Migration::DepartmentName
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
DISABLE_COMMENT_FORMAT = ::T.let(nil, ::T.untyped)
DISABLING_COPS_CONTENT_TOKEN = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Migration::DepartmentName
end
module RuboCop::Cop::Migration
end
module RuboCop::Cop::MinBodyLength
end
module RuboCop::Cop::MinBodyLength
end
module RuboCop::Cop::MultilineElementIndentation
end
module RuboCop::Cop::MultilineElementIndentation
end
module RuboCop::Cop::MultilineElementLineBreaks
end
module RuboCop::Cop::MultilineElementLineBreaks
end
module RuboCop::Cop::MultilineExpressionIndentation
def on_send(node); end
ASSIGNMENT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
DEFAULT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
KEYWORD_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
KEYWORD_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
UNALIGNED_RHS_TYPES = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::MultilineExpressionIndentation
end
class RuboCop::Cop::MultilineLiteralBraceCorrector
include ::RuboCop::Cop::MultilineLiteralBraceLayout
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def call(corrector); end
def initialize(node, processed_source); end
end
class RuboCop::Cop::MultilineLiteralBraceCorrector
end
module RuboCop::Cop::MultilineLiteralBraceLayout
include ::RuboCop::Cop::ConfigurableEnforcedStyle
end
module RuboCop::Cop::MultilineLiteralBraceLayout
end
module RuboCop::Cop::Naming
end
class RuboCop::Cop::Naming::AccessorMethodName
def on_def(node); end
def on_defs(node); end
MSG_READER = ::T.let(nil, ::T.untyped)
MSG_WRITER = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::AccessorMethodName
end
class RuboCop::Cop::Naming::AsciiIdentifiers
include ::RuboCop::Cop::RangeHelp
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::AsciiIdentifiers
end
class RuboCop::Cop::Naming::BinaryOperatorParameterName
def on_def(node); end
def op_method_candidate?(node=T.unsafe(nil)); end
BLACKLISTED = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
OP_LIKE_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::BinaryOperatorParameterName
end
class RuboCop::Cop::Naming::BlockParameterName
include ::RuboCop::Cop::UncommunicativeName
def on_block(node); end
end
class RuboCop::Cop::Naming::BlockParameterName
end
class RuboCop::Cop::Naming::ClassAndModuleCamelCase
def on_class(node); end
def on_module(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::ClassAndModuleCamelCase
end
class RuboCop::Cop::Naming::ConstantName
def class_or_struct_return_method?(node=T.unsafe(nil)); end
def literal_receiver?(node=T.unsafe(nil)); end
def on_casgn(node); end
MSG = ::T.let(nil, ::T.untyped)
SNAKE_CASE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::ConstantName
end
class RuboCop::Cop::Naming::FileName
include ::RuboCop::Cop::RangeHelp
def investigate(processed_source); end
MSG_NO_DEFINITION = ::T.let(nil, ::T.untyped)
MSG_REGEX = ::T.let(nil, ::T.untyped)
MSG_SNAKE_CASE = ::T.let(nil, ::T.untyped)
SNAKE_CASE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::FileName
end
class RuboCop::Cop::Naming::HeredocDelimiterCase
include ::RuboCop::Cop::Heredoc
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def on_heredoc(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::HeredocDelimiterCase
end
class RuboCop::Cop::Naming::HeredocDelimiterNaming
include ::RuboCop::Cop::Heredoc
def on_heredoc(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::HeredocDelimiterNaming
end
class RuboCop::Cop::Naming::MemoizedInstanceVariableName
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def memoized?(node=T.unsafe(nil)); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
UNDERSCORE_REQUIRED = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::MemoizedInstanceVariableName
end
class RuboCop::Cop::Naming::MethodName
include ::RuboCop::Cop::ConfigurableNaming
include ::RuboCop::Cop::ConfigurableFormatting
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::IgnoredPattern
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::MethodName
end
class RuboCop::Cop::Naming::MethodParameterName
include ::RuboCop::Cop::UncommunicativeName
def on_def(node); end
def on_defs(node); end
end
class RuboCop::Cop::Naming::MethodParameterName
end
class RuboCop::Cop::Naming::PredicateName
def dynamic_method_define(node=T.unsafe(nil)); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
end
class RuboCop::Cop::Naming::PredicateName
end
class RuboCop::Cop::Naming::RescuedExceptionsVariableName
def autocorrect(node); end
def on_resbody(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::RescuedExceptionsVariableName
end
class RuboCop::Cop::Naming::VariableName
include ::RuboCop::Cop::ConfigurableNaming
include ::RuboCop::Cop::ConfigurableFormatting
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def on_arg(node); end
def on_blockarg(node); end
def on_cvasgn(node); end
def on_ivasgn(node); end
def on_kwarg(node); end
def on_kwoptarg(node); end
def on_kwrestarg(node); end
def on_lvar(node); end
def on_lvasgn(node); end
def on_optarg(node); end
def on_restarg(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::VariableName
end
class RuboCop::Cop::Naming::VariableNumber
include ::RuboCop::Cop::ConfigurableNumbering
include ::RuboCop::Cop::ConfigurableFormatting
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def on_arg(node); end
def on_cvasgn(node); end
def on_ivasgn(node); end
def on_lvasgn(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Naming::VariableNumber
end
module RuboCop::Cop::Naming
end
module RuboCop::Cop::NegativeConditional
def empty_condition?(node=T.unsafe(nil)); end
def single_negative?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::NegativeConditional
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::NilMethods
end
module RuboCop::Cop::NilMethods
end
class RuboCop::Cop::Offense
include ::Comparable
def ==(other); end
def column(); end
def column_length(); end
def column_range(); end
def cop_name(); end
def correctable?(); end
def corrected?(); end
def corrected_with_todo?(); end
def disabled?(); end
def eql?(other); end
def first_line(); end
def highlighted_area(); end
def initialize(severity, location, message, cop_name, status=T.unsafe(nil)); end
def last_column(); end
def last_line(); end
def line(); end
def location(); end
def message(); end
def real_column(); end
def severity(); end
def source_line(); end
def status(); end
COMPARISON_ATTRIBUTES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Offense
end
module RuboCop::Cop::OnNormalIfUnless
def on_if(node); end
end
module RuboCop::Cop::OnNormalIfUnless
end
class RuboCop::Cop::OrderedGemCorrector
end
class RuboCop::Cop::OrderedGemCorrector
extend ::RuboCop::Cop::OrderedGemNode
def self.comments_as_separators(); end
def self.correct(processed_source, node, previous_declaration, comments_as_separators); end
def self.processed_source(); end
end
module RuboCop::Cop::OrderedGemNode
end
module RuboCop::Cop::OrderedGemNode
end
module RuboCop::Cop::Parentheses
end
module RuboCop::Cop::Parentheses
end
class RuboCop::Cop::ParenthesesCorrector
end
class RuboCop::Cop::ParenthesesCorrector
def self.correct(node); end
end
module RuboCop::Cop::ParserDiagnostic
def investigate(processed_source); end
end
module RuboCop::Cop::ParserDiagnostic
end
module RuboCop::Cop::PercentArray
end
module RuboCop::Cop::PercentArray
end
module RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
end
module RuboCop::Cop::PercentLiteral
end
class RuboCop::Cop::PercentLiteralCorrector
include ::RuboCop::Cop::Util
include ::RuboCop::PathUtil
def config(); end
def correct(node, char); end
def initialize(config, preferred_delimiters); end
def preferred_delimiters(); end
end
class RuboCop::Cop::PercentLiteralCorrector
end
module RuboCop::Cop::PrecedingFollowingAlignment
end
module RuboCop::Cop::PrecedingFollowingAlignment
end
class RuboCop::Cop::PreferredDelimiters
def config(); end
def delimiters(); end
def initialize(type, config, preferred_delimiters); end
def type(); end
PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::PreferredDelimiters
end
class RuboCop::Cop::PunctuationCorrector
end
class RuboCop::Cop::PunctuationCorrector
def self.add_space(token); end
def self.remove_space(space_before); end
def self.swap_comma(range); end
end
module RuboCop::Cop::RangeHelp
BYTE_ORDER_MARK = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::RangeHelp
end
module RuboCop::Cop::RationalLiteral
def rational_literal?(node=T.unsafe(nil)); end
end
module RuboCop::Cop::RationalLiteral
extend ::RuboCop::NodePattern::Macros
end
class RuboCop::Cop::Registry
def ==(other); end
def contains_cop_matching?(names); end
def cops(); end
def department_missing?(badge, name); end
def departments(); end
def each(&block); end
def enabled(config, only, only_safe=T.unsafe(nil)); end
def enabled?(cop, config, only_safe); end
def enlist(cop); end
def find_by_cop_name(cop_name); end
def initialize(cops=T.unsafe(nil)); end
def length(); end
def names(); end
def print_warning(name, path); end
def qualified_cop_name(name, path, shall_warn=T.unsafe(nil)); end
def select(&block); end
def sort!(); end
def to_h(); end
def unqualified_cop_names(); end
def with_department(department); end
def without_department(department); end
end
class RuboCop::Cop::Registry
end
module RuboCop::Cop::RescueNode
def investigate(processed_source); end
end
module RuboCop::Cop::RescueNode
end
module RuboCop::Cop::SafeAssignment
def empty_condition?(node=T.unsafe(nil)); end
def safe_assignment?(node=T.unsafe(nil)); end
def setter_method?(node=T.unsafe(nil)); end
end
module RuboCop::Cop::SafeAssignment
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::Security
end
class RuboCop::Cop::Security::Eval
def eval?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Security::Eval
end
class RuboCop::Cop::Security::JSONLoad
def autocorrect(node); end
def json_load(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Security::JSONLoad
end
class RuboCop::Cop::Security::MarshalLoad
def marshal_load(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Security::MarshalLoad
end
class RuboCop::Cop::Security::Open
def on_send(node); end
def open?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Security::Open
end
class RuboCop::Cop::Security::YAMLLoad
def autocorrect(node); end
def on_send(node); end
def yaml_load(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Security::YAMLLoad
end
module RuboCop::Cop::Security
end
class RuboCop::Cop::Severity
include ::Comparable
def ==(other); end
def code(); end
def initialize(name_or_code); end
def level(); end
def name(); end
CODE_TABLE = ::T.let(nil, ::T.untyped)
NAMES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Severity
def self.name_from_code(code); end
end
module RuboCop::Cop::SpaceAfterPunctuation
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::SpaceAfterPunctuation
end
module RuboCop::Cop::SpaceBeforePunctuation
include ::RuboCop::Cop::RangeHelp
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::SpaceBeforePunctuation
end
class RuboCop::Cop::SpaceCorrector
end
class RuboCop::Cop::SpaceCorrector
extend ::RuboCop::Cop::SurroundingSpace
extend ::RuboCop::Cop::RangeHelp
def self.add_space(processed_source, corrector, left_token, right_token); end
def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end
def self.processed_source(); end
def self.remove_space(processed_source, corrector, left_token, right_token); end
end
module RuboCop::Cop::StatementModifier
end
module RuboCop::Cop::StatementModifier
end
module RuboCop::Cop::StringHelp
def on_regexp(node); end
def on_str(node); end
end
module RuboCop::Cop::StringHelp
end
class RuboCop::Cop::StringLiteralCorrector
end
class RuboCop::Cop::StringLiteralCorrector
extend ::RuboCop::Cop::Util
extend ::RuboCop::PathUtil
def self.correct(node, style); end
end
module RuboCop::Cop::StringLiteralsHelp
include ::RuboCop::Cop::StringHelp
end
module RuboCop::Cop::StringLiteralsHelp
end
module RuboCop::Cop::Style
end
class RuboCop::Cop::Style::AccessModifierDeclarations
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def on_send(node); end
GROUP_STYLE_MESSAGE = ::T.let(nil, ::T.untyped)
INLINE_STYLE_MESSAGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::AccessModifierDeclarations
end
class RuboCop::Cop::Style::Alias
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def identifier(node=T.unsafe(nil)); end
def on_alias(node); end
def on_send(node); end
MSG_ALIAS = ::T.let(nil, ::T.untyped)
MSG_ALIAS_METHOD = ::T.let(nil, ::T.untyped)
MSG_SYMBOL_ARGS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Alias
end
class RuboCop::Cop::Style::AndOr
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_and(node); end
def on_if(node); end
def on_or(node); end
def on_until(node); end
def on_until_post(node); end
def on_while(node); end
def on_while_post(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::AndOr
end
module RuboCop::Cop::Style::AnnotationComment
end
module RuboCop::Cop::Style::AnnotationComment
end
class RuboCop::Cop::Style::ArrayJoin
def autocorrect(node); end
def join_candidate?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ArrayJoin
end
class RuboCop::Cop::Style::AsciiComments
include ::RuboCop::Cop::RangeHelp
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::AsciiComments
end
class RuboCop::Cop::Style::Attr
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def class_eval?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Attr
end
class RuboCop::Cop::Style::AutoResourceCleanup
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
TARGET_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::AutoResourceCleanup
end
class RuboCop::Cop::Style::BarePercentLiterals
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_dstr(node); end
def on_str(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::BarePercentLiterals
end
class RuboCop::Cop::Style::BeginBlock
def on_preexe(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::BeginBlock
end
class RuboCop::Cop::Style::BlockComments
include ::RuboCop::Cop::RangeHelp
def autocorrect(comment); end
def investigate(processed_source); end
BEGIN_LENGTH = ::T.let(nil, ::T.untyped)
END_LENGTH = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::BlockComments
end
class RuboCop::Cop::Style::BlockDelimiters
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::IgnoredMethods
def autocorrect(node); end
def on_block(node); end
def on_send(node); end
ALWAYS_BRACES_MESSAGE = ::T.let(nil, ::T.untyped)
BRACES_REQUIRED_MESSAGE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::BlockDelimiters
end
class RuboCop::Cop::Style::CaseCorrector
end
class RuboCop::Cop::Style::CaseCorrector
extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
def self.correct(cop, node); end
def self.move_assignment_inside_condition(node); end
end
class RuboCop::Cop::Style::CaseEquality
def case_equality?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::CaseEquality
end
class RuboCop::Cop::Style::CharacterLiteral
include ::RuboCop::Cop::StringHelp
def autocorrect(node); end
def correct_style_detected(); end
def offense?(node); end
def opposite_style_detected(); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::CharacterLiteral
end
class RuboCop::Cop::Style::ClassAndModuleChildren
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_class(node); end
def on_module(node); end
COMPACT_MSG = ::T.let(nil, ::T.untyped)
NESTED_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ClassAndModuleChildren
end
class RuboCop::Cop::Style::ClassCheck
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def class_check?(node=T.unsafe(nil)); end
def message(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ClassCheck
end
class RuboCop::Cop::Style::ClassMethods
def autocorrect(node); end
def on_class(node); end
def on_module(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ClassMethods
end
class RuboCop::Cop::Style::ClassVars
def message(node); end
def on_cvasgn(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ClassVars
end
class RuboCop::Cop::Style::CollectionMethods
include ::RuboCop::Cop::MethodPreference
def autocorrect(node); end
def on_block(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::CollectionMethods
end
class RuboCop::Cop::Style::ColonMethodCall
def autocorrect(node); end
def java_type_node?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ColonMethodCall
end
class RuboCop::Cop::Style::ColonMethodDefinition
def autocorrect(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ColonMethodDefinition
end
class RuboCop::Cop::Style::CommandLiteral
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_xstr(node); end
MSG_USE_BACKTICKS = ::T.let(nil, ::T.untyped)
MSG_USE_PERCENT_X = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::CommandLiteral
end
class RuboCop::Cop::Style::CommentAnnotation
include ::RuboCop::Cop::Style::AnnotationComment
include ::RuboCop::Cop::RangeHelp
def autocorrect(comment); end
def investigate(processed_source); end
MISSING_NOTE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::CommentAnnotation
end
class RuboCop::Cop::Style::CommentedKeyword
def investigate(processed_source); end
ALLOWED_COMMENTS = ::T.let(nil, ::T.untyped)
KEYWORDS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::CommentedKeyword
end
class RuboCop::Cop::Style::ConditionalAssignment
include ::RuboCop::Cop::Style::ConditionalAssignmentHelper
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def assignment_type?(node=T.unsafe(nil)); end
def autocorrect(node); end
def candidate_condition?(node=T.unsafe(nil)); end
def on_and_asgn(node); end
def on_case(node); end
def on_casgn(node); end
def on_cvasgn(node); end
def on_gvasgn(node); end
def on_if(node); end
def on_ivasgn(node); end
def on_lvasgn(node); end
def on_masgn(node); end
def on_op_asgn(node); end
def on_or_asgn(node); end
def on_send(node); end
ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
ASSIGN_TO_CONDITION_MSG = ::T.let(nil, ::T.untyped)
ENABLED = ::T.let(nil, ::T.untyped)
INDENTATION_WIDTH = ::T.let(nil, ::T.untyped)
LINE_LENGTH = ::T.let(nil, ::T.untyped)
MAX = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
SINGLE_LINE_CONDITIONS_ONLY = ::T.let(nil, ::T.untyped)
VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
WIDTH = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ConditionalAssignment
end
module RuboCop::Cop::Style::ConditionalAssignmentHelper
def end_with_eq?(sym); end
def expand_elses(branch); end
def expand_when_branches(when_branches); end
def indent(cop, source); end
def lhs(node); end
def tail(branch); end
ALIGN_WITH = ::T.let(nil, ::T.untyped)
END_ALIGNMENT = ::T.let(nil, ::T.untyped)
EQUAL = ::T.let(nil, ::T.untyped)
KEYWORD = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Style::ConditionalAssignmentHelper
extend ::RuboCop::NodePattern::Macros
end
module RuboCop::Cop::Style::ConditionalCorrectorHelper
def assignment(node); end
def correct_branches(corrector, branches); end
def correct_if_branches(corrector, cop, node); end
def remove_whitespace_in_branches(corrector, branch, condition, column); end
def replace_branch_assignment(corrector, branch); end
def white_space_range(node, column); end
end
module RuboCop::Cop::Style::ConditionalCorrectorHelper
end
class RuboCop::Cop::Style::ConstantVisibility
def on_casgn(node); end
def visibility_declaration_for?(node=T.unsafe(nil), param1); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ConstantVisibility
end
class RuboCop::Cop::Style::Copyright
include ::RuboCop::Cop::RangeHelp
def autocorrect(token); end
def investigate(processed_source); end
AUTOCORRECT_EMPTY_WARNING = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Copyright
end
class RuboCop::Cop::Style::DateTime
def date_time?(node=T.unsafe(nil)); end
def historic_date?(node=T.unsafe(nil)); end
def on_send(node); end
def to_datetime?(node=T.unsafe(nil)); end
CLASS_MSG = ::T.let(nil, ::T.untyped)
COERCION_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::DateTime
end
class RuboCop::Cop::Style::DefWithParentheses
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::DefWithParentheses
end
class RuboCop::Cop::Style::Dir
def autocorrect(node); end
def dir_replacement?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Dir
end
class RuboCop::Cop::Style::Documentation
include ::RuboCop::Cop::DocumentationComment
include ::RuboCop::Cop::Style::AnnotationComment
def constant_definition?(node=T.unsafe(nil)); end
def on_class(node); end
def on_module(node); end
def outer_module(node0); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Documentation
end
class RuboCop::Cop::Style::DocumentationMethod
include ::RuboCop::Cop::DocumentationComment
include ::RuboCop::Cop::Style::AnnotationComment
include ::RuboCop::Cop::DefNode
def module_function_node?(node=T.unsafe(nil)); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::DocumentationMethod
end
class RuboCop::Cop::Style::DoubleCopDisableDirective
def autocorrect(comment); end
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::DoubleCopDisableDirective
end
class RuboCop::Cop::Style::DoubleNegation
def double_negative?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::DoubleNegation
end
class RuboCop::Cop::Style::EachForSimpleLoop
def autocorrect(node); end
def offending_each_range(node=T.unsafe(nil)); end
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EachForSimpleLoop
end
class RuboCop::Cop::Style::EachWithObject
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def each_with_object_candidate?(node=T.unsafe(nil)); end
def on_block(node); end
METHODS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EachWithObject
end
class RuboCop::Cop::Style::EmptyBlockParameter
include ::RuboCop::Cop::EmptyParameter
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EmptyBlockParameter
end
class RuboCop::Cop::Style::EmptyCaseCondition
include ::RuboCop::Cop::RangeHelp
def autocorrect(case_node); end
def on_case(case_node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EmptyCaseCondition
end
class RuboCop::Cop::Style::EmptyElse
include ::RuboCop::Cop::OnNormalIfUnless
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_case(node); end
def on_normal_if_unless(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EmptyElse
end
class RuboCop::Cop::Style::EmptyLambdaParameter
include ::RuboCop::Cop::EmptyParameter
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EmptyLambdaParameter
end
class RuboCop::Cop::Style::EmptyLiteral
include ::RuboCop::Cop::FrozenStringLiteral
include ::RuboCop::Cop::RangeHelp
def array_node(node=T.unsafe(nil)); end
def array_with_block(node=T.unsafe(nil)); end
def autocorrect(node); end
def hash_node(node=T.unsafe(nil)); end
def hash_with_block(node=T.unsafe(nil)); end
def on_send(node); end
def str_node(node=T.unsafe(nil)); end
ARR_MSG = ::T.let(nil, ::T.untyped)
HASH_MSG = ::T.let(nil, ::T.untyped)
STR_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EmptyLiteral
end
class RuboCop::Cop::Style::EmptyMethod
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG_COMPACT = ::T.let(nil, ::T.untyped)
MSG_EXPANDED = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EmptyMethod
end
class RuboCop::Cop::Style::Encoding
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
ENCODING_PATTERN = ::T.let(nil, ::T.untyped)
MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
SHEBANG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Encoding
end
class RuboCop::Cop::Style::EndBlock
def on_postexe(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EndBlock
end
class RuboCop::Cop::Style::EvalWithLocation
def eval_without_location?(node=T.unsafe(nil)); end
def line_with_offset?(node=T.unsafe(nil), param1, param2); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
MSG_INCORRECT_LINE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EvalWithLocation
end
class RuboCop::Cop::Style::EvenOdd
def autocorrect(node); end
def even_odd_candidate?(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::EvenOdd
end
class RuboCop::Cop::Style::ExpandPathArguments
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def file_expand_path(node=T.unsafe(nil)); end
def on_send(node); end
def pathname_new_parent_expand_path(node=T.unsafe(nil)); end
def pathname_parent_expand_path(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
PATHNAME_MSG = ::T.let(nil, ::T.untyped)
PATHNAME_NEW_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ExpandPathArguments
end
class RuboCop::Cop::Style::FloatDivision
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def any_coerce?(node=T.unsafe(nil)); end
def both_coerce?(node=T.unsafe(nil)); end
def left_coerce?(node=T.unsafe(nil)); end
def on_send(node); end
def right_coerce?(node=T.unsafe(nil)); end
end
class RuboCop::Cop::Style::FloatDivision
end
class RuboCop::Cop::Style::For
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
def on_for(node); end
EACH_LENGTH = ::T.let(nil, ::T.untyped)
PREFER_EACH = ::T.let(nil, ::T.untyped)
PREFER_FOR = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::For
end
class RuboCop::Cop::Style::FormatString
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def formatter(node=T.unsafe(nil)); end
def message(detected_style); end
def method_name(style_name); end
def on_send(node); end
def variable_argument?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::FormatString
end
class RuboCop::Cop::Style::FormatStringToken
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def format_string_in_typical_context?(node=T.unsafe(nil)); end
def on_str(node); end
end
class RuboCop::Cop::Style::FormatStringToken
end
class RuboCop::Cop::Style::FrozenStringLiteralComment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::FrozenStringLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def investigate(processed_source); end
MSG_DISABLED = ::T.let(nil, ::T.untyped)
MSG_MISSING = ::T.let(nil, ::T.untyped)
MSG_MISSING_TRUE = ::T.let(nil, ::T.untyped)
MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
SHEBANG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::FrozenStringLiteralComment
end
class RuboCop::Cop::Style::GlobalVars
def allowed_var?(global_var); end
def check(node); end
def on_gvar(node); end
def on_gvasgn(node); end
def user_vars(); end
BUILT_IN_VARS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::GlobalVars
end
class RuboCop::Cop::Style::GuardClause
include ::RuboCop::Cop::MinBodyLength
include ::RuboCop::Cop::StatementModifier
def on_def(node); end
def on_defs(node); end
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::GuardClause
end
class RuboCop::Cop::Style::HashEachMethods
include ::RuboCop::Cop::Lint::UnusedArgument
def autocorrect(node); end
def kv_each(node=T.unsafe(nil)); end
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::HashEachMethods
end
class RuboCop::Cop::Style::HashSyntax
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def hash_rockets_check(pairs); end
def no_mixed_keys_check(pairs); end
def on_hash(node); end
def ruby19_check(pairs); end
def ruby19_no_mixed_keys_check(pairs); end
MSG_19 = ::T.let(nil, ::T.untyped)
MSG_HASH_ROCKETS = ::T.let(nil, ::T.untyped)
MSG_NO_MIXED_KEYS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::HashSyntax
end
class RuboCop::Cop::Style::HashTransformKeys
include ::RuboCop::Cop::HashTransformMethod
def on_bad_each_with_object(node=T.unsafe(nil)); end
def on_bad_hash_brackets_map(node=T.unsafe(nil)); end
def on_bad_map_to_h(node=T.unsafe(nil)); end
end
class RuboCop::Cop::Style::HashTransformKeys
extend ::RuboCop::Cop::TargetRubyVersion
end
class RuboCop::Cop::Style::HashTransformValues
include ::RuboCop::Cop::HashTransformMethod
def on_bad_each_with_object(node=T.unsafe(nil)); end
def on_bad_hash_brackets_map(node=T.unsafe(nil)); end
def on_bad_map_to_h(node=T.unsafe(nil)); end
end
class RuboCop::Cop::Style::HashTransformValues
extend ::RuboCop::Cop::TargetRubyVersion
end
class RuboCop::Cop::Style::IdenticalConditionalBranches
def on_case(node); end
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::IdenticalConditionalBranches
end
class RuboCop::Cop::Style::IfCorrector
end
class RuboCop::Cop::Style::IfCorrector
extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
def self.correct(cop, node); end
def self.move_assignment_inside_condition(node); end
end
class RuboCop::Cop::Style::IfInsideElse
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::IfInsideElse
end
class RuboCop::Cop::Style::IfUnlessModifier
include ::RuboCop::Cop::StatementModifier
include ::RuboCop::Cop::LineLengthHelp
include ::RuboCop::Cop::IgnoredPattern
def autocorrect(node); end
def on_if(node); end
ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
MSG_USE_MODIFIER = ::T.let(nil, ::T.untyped)
MSG_USE_NORMAL = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::IfUnlessModifier
end
class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless
include ::RuboCop::Cop::StatementModifier
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless
end
class RuboCop::Cop::Style::IfWithSemicolon
include ::RuboCop::Cop::OnNormalIfUnless
def on_normal_if_unless(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::IfWithSemicolon
end
class RuboCop::Cop::Style::ImplicitRuntimeError
def implicit_runtime_error_raise_or_fail(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ImplicitRuntimeError
end
class RuboCop::Cop::Style::InfiniteLoop
def after_leaving_scope(scope, _variable_table); end
def autocorrect(node); end
def join_force?(force_class); end
def on_until(node); end
def on_until_post(node); end
def on_while(node); end
def on_while_post(node); end
LEADING_SPACE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::InfiniteLoop
end
class RuboCop::Cop::Style::InlineComment
def investigate(processed_source); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::InlineComment
end
class RuboCop::Cop::Style::InverseMethods
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def correct_inverse_block(node); end
def correct_inverse_method(node); end
def correct_inverse_selector(block, corrector); end
def inverse_block?(node=T.unsafe(nil)); end
def inverse_candidate?(node=T.unsafe(nil)); end
def on_block(node); end
def on_send(node); end
CAMEL_CASE = ::T.let(nil, ::T.untyped)
CLASS_COMPARISON_METHODS = ::T.let(nil, ::T.untyped)
EQUALITY_METHODS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
NEGATED_EQUALITY_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::InverseMethods
end
class RuboCop::Cop::Style::IpAddresses
include ::RuboCop::Cop::StringHelp
def correct_style_detected(); end
def offense?(node); end
def opposite_style_detected(); end
IPV6_MAX_SIZE = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::IpAddresses
end
class RuboCop::Cop::Style::Lambda
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_block(node); end
LITERAL_MESSAGE = ::T.let(nil, ::T.untyped)
METHOD_MESSAGE = ::T.let(nil, ::T.untyped)
OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Lambda
end
class RuboCop::Cop::Style::LambdaCall
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_send(node); end
end
class RuboCop::Cop::Style::LambdaCall
end
class RuboCop::Cop::Style::LineEndConcatenation
include ::RuboCop::Cop::RangeHelp
def autocorrect(operator_range); end
def investigate(processed_source); end
COMPLEX_STRING_BEGIN_TOKEN = ::T.let(nil, ::T.untyped)
COMPLEX_STRING_END_TOKEN = ::T.let(nil, ::T.untyped)
CONCAT_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
HIGH_PRECEDENCE_OP_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
QUOTE_DELIMITERS = ::T.let(nil, ::T.untyped)
SIMPLE_STRING_TOKEN_TYPE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::LineEndConcatenation
end
class RuboCop::Cop::Style::MethodCallWithArgsParentheses
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::IgnoredMethods
include ::RuboCop::Cop::IgnoredPattern
def autocorrect(_node); end
def initialize(*_); end
end
module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
def autocorrect(node); end
def message(_node=T.unsafe(nil)); end
def on_csend(node); end
def on_send(node); end
def on_super(node); end
def on_yield(node); end
TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
end
module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
def autocorrect(node); end
def message(_node=T.unsafe(nil)); end
def on_csend(node); end
def on_send(node); end
def on_super(node); end
def on_yield(node); end
end
module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
end
class RuboCop::Cop::Style::MethodCallWithArgsParentheses
end
class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses
include ::RuboCop::Cop::IgnoredMethods
def autocorrect(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses
end
class RuboCop::Cop::Style::MethodCalledOnDoEndBlock
include ::RuboCop::Cop::RangeHelp
def on_block(node); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MethodCalledOnDoEndBlock
end
class RuboCop::Cop::Style::MethodDefParentheses
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG_MISSING = ::T.let(nil, ::T.untyped)
MSG_PRESENT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MethodDefParentheses
end
class RuboCop::Cop::Style::MethodMissingSuper
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MethodMissingSuper
end
class RuboCop::Cop::Style::MinMax
def autocorrect(node); end
def min_max_candidate(node=T.unsafe(nil)); end
def on_array(node); end
def on_return(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MinMax
end
class RuboCop::Cop::Style::MissingElse
include ::RuboCop::Cop::OnNormalIfUnless
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def on_case(node); end
def on_normal_if_unless(node); end
MSG = ::T.let(nil, ::T.untyped)
MSG_EMPTY = ::T.let(nil, ::T.untyped)
MSG_NIL = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MissingElse
end
class RuboCop::Cop::Style::MissingRespondToMissing
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MissingRespondToMissing
end
class RuboCop::Cop::Style::MixinGrouping
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_class(node); end
def on_module(node); end
MIXIN_METHODS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MixinGrouping
end
class RuboCop::Cop::Style::MixinUsage
def include_statement(node=T.unsafe(nil)); end
def on_send(node); end
def wrapped_macro_scope?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MixinUsage
end
class RuboCop::Cop::Style::ModuleFunction
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def extend_self_node?(node=T.unsafe(nil)); end
def module_function_node?(node=T.unsafe(nil)); end
def on_module(node); end
def private_directive?(node=T.unsafe(nil)); end
EXTEND_SELF_MSG = ::T.let(nil, ::T.untyped)
MODULE_FUNCTION_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ModuleFunction
end
class RuboCop::Cop::Style::MultilineBlockChain
include ::RuboCop::Cop::RangeHelp
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineBlockChain
end
class RuboCop::Cop::Style::MultilineIfModifier
include ::RuboCop::Cop::StatementModifier
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineIfModifier
end
class RuboCop::Cop::Style::MultilineIfThen
include ::RuboCop::Cop::OnNormalIfUnless
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_normal_if_unless(node); end
MSG = ::T.let(nil, ::T.untyped)
NON_MODIFIER_THEN = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineIfThen
end
class RuboCop::Cop::Style::MultilineMemoization
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_or_asgn(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineMemoization
end
class RuboCop::Cop::Style::MultilineMethodSignature
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineMethodSignature
end
class RuboCop::Cop::Style::MultilineTernaryOperator
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineTernaryOperator
end
class RuboCop::Cop::Style::MultilineWhenThen
include ::RuboCop::Cop::RangeHelp
def accept_node_type?(node); end
def autocorrect(node); end
def on_when(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultilineWhenThen
end
class RuboCop::Cop::Style::MultipleComparison
def on_or(node); end
def simple_comparison?(node=T.unsafe(nil)); end
def simple_double_comparison?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MultipleComparison
end
class RuboCop::Cop::Style::MutableConstant
include ::RuboCop::Cop::FrozenStringLiteral
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_casgn(node); end
def on_or_asgn(node); end
def operation_produces_immutable_object?(node=T.unsafe(nil)); end
def range_enclosed_in_parentheses?(node=T.unsafe(nil)); end
def splat_value(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MutableConstant
end
class RuboCop::Cop::Style::NegatedIf
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::NegativeConditional
def autocorrect(node); end
def on_if(node); end
end
class RuboCop::Cop::Style::NegatedIf
end
class RuboCop::Cop::Style::NegatedUnless
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::NegativeConditional
def autocorrect(node); end
def on_if(node); end
end
class RuboCop::Cop::Style::NegatedUnless
end
class RuboCop::Cop::Style::NegatedWhile
include ::RuboCop::Cop::NegativeConditional
def autocorrect(node); end
def on_until(node); end
def on_while(node); end
end
class RuboCop::Cop::Style::NegatedWhile
end
class RuboCop::Cop::Style::NestedModifier
include ::RuboCop::Cop::RangeHelp
def add_parentheses_to_method_arguments(send_node); end
def autocorrect(node); end
def check(node); end
def left_hand_operand(node, operator); end
def modifier?(node); end
def new_expression(inner_node); end
def on_if(node); end
def on_until(node); end
def on_while(node); end
def replacement_operator(keyword); end
def requires_parens?(node); end
def right_hand_operand(node, left_hand_keyword); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NestedModifier
end
class RuboCop::Cop::Style::NestedParenthesizedCalls
include ::RuboCop::Cop::RangeHelp
def autocorrect(nested); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NestedParenthesizedCalls
end
class RuboCop::Cop::Style::NestedTernaryOperator
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NestedTernaryOperator
end
class RuboCop::Cop::Style::Next
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::MinBodyLength
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def investigate(_processed_source); end
def on_block(node); end
def on_for(node); end
def on_until(node); end
def on_while(node); end
EXIT_TYPES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Next
end
class RuboCop::Cop::Style::NilComparison
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def nil_check?(node=T.unsafe(nil)); end
def nil_comparison?(node=T.unsafe(nil)); end
def on_send(node); end
EXPLICIT_MSG = ::T.let(nil, ::T.untyped)
PREDICATE_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NilComparison
end
class RuboCop::Cop::Style::NonNilCheck
def autocorrect(node); end
def nil_check?(node=T.unsafe(nil)); end
def not_and_nil_check?(node=T.unsafe(nil)); end
def not_equal_to_nil?(node=T.unsafe(nil)); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
def unless_check?(node=T.unsafe(nil)); end
end
class RuboCop::Cop::Style::NonNilCheck
end
class RuboCop::Cop::Style::Not
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
OPPOSITE_METHODS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Not
end
class RuboCop::Cop::Style::NumericLiteralPrefix
include ::RuboCop::Cop::IntegerNode
def autocorrect(node); end
def on_int(node); end
BINARY_MSG = ::T.let(nil, ::T.untyped)
BINARY_REGEX = ::T.let(nil, ::T.untyped)
DECIMAL_MSG = ::T.let(nil, ::T.untyped)
DECIMAL_REGEX = ::T.let(nil, ::T.untyped)
HEX_MSG = ::T.let(nil, ::T.untyped)
HEX_REGEX = ::T.let(nil, ::T.untyped)
OCTAL_MSG = ::T.let(nil, ::T.untyped)
OCTAL_REGEX = ::T.let(nil, ::T.untyped)
OCTAL_ZERO_ONLY_MSG = ::T.let(nil, ::T.untyped)
OCTAL_ZERO_ONLY_REGEX = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NumericLiteralPrefix
end
class RuboCop::Cop::Style::NumericLiterals
include ::RuboCop::Cop::ConfigurableMax
include ::RuboCop::Cop::IntegerNode
def autocorrect(node); end
def on_float(node); end
def on_int(node); end
DELIMITER_REGEXP = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NumericLiterals
end
class RuboCop::Cop::Style::NumericPredicate
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::IgnoredMethods
def autocorrect(node); end
def comparison(node=T.unsafe(nil)); end
def inverted_comparison(node=T.unsafe(nil)); end
def on_send(node); end
def predicate(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
REPLACEMENTS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::NumericPredicate
end
class RuboCop::Cop::Style::OneLineConditional
include ::RuboCop::Cop::OnNormalIfUnless
def autocorrect(node); end
def on_normal_if_unless(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::OneLineConditional
end
class RuboCop::Cop::Style::OptionHash
def on_args(node); end
def option_hash(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::OptionHash
end
class RuboCop::Cop::Style::OptionalArguments
def on_def(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::OptionalArguments
end
class RuboCop::Cop::Style::OrAssignment
def autocorrect(node); end
def on_cvasgn(node); end
def on_gvasgn(node); end
def on_if(node); end
def on_ivasgn(node); end
def on_lvasgn(node); end
def ternary_assignment?(node=T.unsafe(nil)); end
def unless_assignment?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::OrAssignment
end
class RuboCop::Cop::Style::ParallelAssignment
include ::RuboCop::Cop::RescueNode
def autocorrect(node); end
def implicit_self_getter?(node=T.unsafe(nil)); end
def on_masgn(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
include ::TSort
def accesses?(rhs, lhs); end
def dependency?(lhs, rhs); end
def initialize(assignments); end
def matching_calls(node0, param1, param2); end
def tsort_each_child(assignment); end
def uses_var?(node0, param1); end
def var_name(node=T.unsafe(nil)); end
end
class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
extend ::RuboCop::NodePattern::Macros
end
class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
include ::RuboCop::Cop::Alignment
def assignment(); end
def config(); end
def correction(); end
def correction_range(); end
def initialize(node, config, new_elements); end
def node(); end
end
class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
end
class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector
end
class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector
end
class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector
end
class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector
end
class RuboCop::Cop::Style::ParallelAssignment
end
class RuboCop::Cop::Style::ParenthesesAroundCondition
include ::RuboCop::Cop::SafeAssignment
include ::RuboCop::Cop::Parentheses
def autocorrect(node); end
def control_op_condition(node=T.unsafe(nil)); end
def on_if(node); end
def on_until(node); end
def on_while(node); end
end
class RuboCop::Cop::Style::ParenthesesAroundCondition
end
class RuboCop::Cop::Style::PercentLiteralDelimiters
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def message(node); end
def on_array(node); end
def on_dstr(node); end
def on_regexp(node); end
def on_str(node); end
def on_sym(node); end
def on_xstr(node); end
end
class RuboCop::Cop::Style::PercentLiteralDelimiters
end
class RuboCop::Cop::Style::PercentQLiterals
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_str(node); end
LOWER_CASE_Q_MSG = ::T.let(nil, ::T.untyped)
UPPER_CASE_Q_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::PercentQLiterals
end
class RuboCop::Cop::Style::PerlBackrefs
def autocorrect(node); end
def on_nth_ref(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::PerlBackrefs
end
class RuboCop::Cop::Style::PreferredHashMethods
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::PreferredHashMethods
end
class RuboCop::Cop::Style::Proc
def autocorrect(node); end
def on_block(node); end
def proc_new?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Proc
end
class RuboCop::Cop::Style::RaiseArgs
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_send(node); end
COMPACT_MSG = ::T.let(nil, ::T.untyped)
EXPLODED_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RaiseArgs
end
class RuboCop::Cop::Style::RandomWithOffset
def autocorrect(node); end
def integer_op_rand?(node=T.unsafe(nil)); end
def namespace(node=T.unsafe(nil)); end
def on_send(node); end
def rand_modified?(node=T.unsafe(nil)); end
def rand_op_integer?(node=T.unsafe(nil)); end
def random_call(node=T.unsafe(nil)); end
def to_int(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RandomWithOffset
end
class RuboCop::Cop::Style::RedundantBegin
def autocorrect(node); end
def on_block(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantBegin
end
class RuboCop::Cop::Style::RedundantCapitalW
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_array(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantCapitalW
end
class RuboCop::Cop::Style::RedundantCondition
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_if(node); end
MSG = ::T.let(nil, ::T.untyped)
REDUNDANT_CONDITION = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantCondition
end
class RuboCop::Cop::Style::RedundantConditional
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_if(node); end
def redundant_condition?(node=T.unsafe(nil)); end
def redundant_condition_inverted?(node=T.unsafe(nil)); end
COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantConditional
end
class RuboCop::Cop::Style::RedundantException
def autocorrect(node); end
def compact?(node=T.unsafe(nil)); end
def exploded?(node=T.unsafe(nil)); end
def on_send(node); end
MSG_1 = ::T.let(nil, ::T.untyped)
MSG_2 = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantException
end
class RuboCop::Cop::Style::RedundantFreeze
include ::RuboCop::Cop::FrozenStringLiteral
def autocorrect(node); end
def on_send(node); end
def operation_produces_immutable_object?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantFreeze
end
class RuboCop::Cop::Style::RedundantInterpolation
include ::RuboCop::Cop::PercentLiteral
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_dstr(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantInterpolation
end
class RuboCop::Cop::Style::RedundantParentheses
include ::RuboCop::Cop::Parentheses
def arg_in_call_with_block?(node=T.unsafe(nil)); end
def autocorrect(node); end
def first_send_argument?(node=T.unsafe(nil)); end
def first_super_argument?(node=T.unsafe(nil)); end
def method_node_and_args(node=T.unsafe(nil)); end
def on_begin(node); end
def range_end?(node=T.unsafe(nil)); end
def rescue?(node=T.unsafe(nil)); end
def square_brackets?(node=T.unsafe(nil)); end
end
class RuboCop::Cop::Style::RedundantParentheses
end
class RuboCop::Cop::Style::RedundantPercentQ
def autocorrect(node); end
def on_dstr(node); end
def on_str(node); end
DYNAMIC_MSG = ::T.let(nil, ::T.untyped)
EMPTY = ::T.let(nil, ::T.untyped)
ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped)
PERCENT_Q = ::T.let(nil, ::T.untyped)
QUOTE = ::T.let(nil, ::T.untyped)
SINGLE_QUOTE = ::T.let(nil, ::T.untyped)
STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantPercentQ
end
class RuboCop::Cop::Style::RedundantReturn
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
MULTI_RETURN_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantReturn
end
class RuboCop::Cop::Style::RedundantSelf
def autocorrect(node); end
def on_and_asgn(node); end
def on_args(node); end
def on_block(node); end
def on_blockarg(node); end
def on_def(node); end
def on_defs(node); end
def on_lvasgn(node); end
def on_masgn(node); end
def on_op_asgn(node); end
def on_or_asgn(node); end
def on_send(node); end
KERNEL_METHODS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantSelf
end
class RuboCop::Cop::Style::RedundantSort
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
def redundant_sort?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantSort
end
class RuboCop::Cop::Style::RedundantSortBy
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_block(node); end
def redundant_sort_by(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantSortBy
end
class RuboCop::Cop::Style::RegexpLiteral
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_regexp(node); end
MSG_USE_PERCENT_R = ::T.let(nil, ::T.untyped)
MSG_USE_SLASHES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RegexpLiteral
end
class RuboCop::Cop::Style::RescueModifier
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::RescueNode
def autocorrect(node); end
def on_resbody(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RescueModifier
end
class RuboCop::Cop::Style::RescueStandardError
include ::RuboCop::Cop::RescueNode
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_resbody(node); end
def rescue_standard_error?(node=T.unsafe(nil)); end
def rescue_without_error_class?(node=T.unsafe(nil)); end
MSG_EXPLICIT = ::T.let(nil, ::T.untyped)
MSG_IMPLICIT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RescueStandardError
end
class RuboCop::Cop::Style::ReturnNil
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def chained_send?(node=T.unsafe(nil)); end
def define_method?(node=T.unsafe(nil)); end
def on_return(node); end
def return_nil_node?(node=T.unsafe(nil)); end
def return_node?(node=T.unsafe(nil)); end
RETURN_MSG = ::T.let(nil, ::T.untyped)
RETURN_NIL_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ReturnNil
end
class RuboCop::Cop::Style::SafeNavigation
include ::RuboCop::Cop::NilMethods
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def check_node(node); end
def modifier_if_safe_navigation_candidate(node=T.unsafe(nil)); end
def not_nil_check?(node=T.unsafe(nil)); end
def on_and(node); end
def on_if(node); end
def use_var_only_in_unless_modifier?(node, variable); end
LOGIC_JUMP_KEYWORDS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SafeNavigation
end
class RuboCop::Cop::Style::Sample
def autocorrect(node); end
def on_send(node); end
def sample_candidate?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Sample
end
class RuboCop::Cop::Style::SelfAssignment
def autocorrect(node); end
def on_cvasgn(node); end
def on_ivasgn(node); end
def on_lvasgn(node); end
MSG = ::T.let(nil, ::T.untyped)
OPS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SelfAssignment
end
class RuboCop::Cop::Style::Semicolon
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def investigate(processed_source); end
def on_begin(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Semicolon
end
class RuboCop::Cop::Style::Send
def on_csend(node); end
def on_send(node); end
def sending?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Send
end
class RuboCop::Cop::Style::SignalException
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def custom_fail_methods(node0); end
def investigate(processed_source); end
def kernel_call?(node=T.unsafe(nil), param1); end
def on_rescue(node); end
def on_send(node); end
FAIL_MSG = ::T.let(nil, ::T.untyped)
RAISE_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SignalException
end
class RuboCop::Cop::Style::SingleLineBlockParams
def on_block(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SingleLineBlockParams
end
class RuboCop::Cop::Style::SingleLineMethods
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SingleLineMethods
end
class RuboCop::Cop::Style::SpecialGlobalVars
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def message(node); end
def on_gvar(node); end
ENGLISH_VARS = ::T.let(nil, ::T.untyped)
MSG_BOTH = ::T.let(nil, ::T.untyped)
MSG_ENGLISH = ::T.let(nil, ::T.untyped)
MSG_REGULAR = ::T.let(nil, ::T.untyped)
NON_ENGLISH_VARS = ::T.let(nil, ::T.untyped)
PERL_VARS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SpecialGlobalVars
end
class RuboCop::Cop::Style::StabbyLambdaParentheses
include ::RuboCop::Cop::ConfigurableEnforcedStyle
def autocorrect(node); end
def on_send(node); end
MSG_NO_REQUIRE = ::T.let(nil, ::T.untyped)
MSG_REQUIRE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::StabbyLambdaParentheses
end
class RuboCop::Cop::Style::StderrPuts
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_send(node); end
def stderr_puts?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::StderrPuts
end
class RuboCop::Cop::Style::StringHashKeys
def autocorrect(node); end
def on_pair(node); end
def receive_environments_method?(node=T.unsafe(nil)); end
def string_hash_key?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::StringHashKeys
end
class RuboCop::Cop::Style::StringLiterals
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::StringLiteralsHelp
include ::RuboCop::Cop::StringHelp
def autocorrect(node); end
def on_dstr(node); end
MSG_INCONSISTENT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::StringLiterals
end
class RuboCop::Cop::Style::StringLiteralsInInterpolation
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::StringLiteralsHelp
include ::RuboCop::Cop::StringHelp
def autocorrect(node); end
end
class RuboCop::Cop::Style::StringLiteralsInInterpolation
end
class RuboCop::Cop::Style::StringMethods
include ::RuboCop::Cop::MethodPreference
def autocorrect(node); end
def on_csend(node); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::StringMethods
end
class RuboCop::Cop::Style::Strip
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def lstrip_rstrip(node=T.unsafe(nil)); end
def on_send(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::Strip
end
class RuboCop::Cop::Style::StructInheritance
def on_class(node); end
def struct_constructor?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::StructInheritance
end
class RuboCop::Cop::Style::SymbolArray
include ::RuboCop::Cop::ArrayMinSize
include ::RuboCop::Cop::ArraySyntax
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::PercentArray
def autocorrect(node); end
def on_array(node); end
ARRAY_MSG = ::T.let(nil, ::T.untyped)
PERCENT_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SymbolArray
def self.largest_brackets(); end
def self.largest_brackets=(largest_brackets); end
end
class RuboCop::Cop::Style::SymbolLiteral
def autocorrect(node); end
def on_sym(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SymbolLiteral
end
class RuboCop::Cop::Style::SymbolProc
include ::RuboCop::Cop::RangeHelp
include ::RuboCop::Cop::IgnoredMethods
def autocorrect(node); end
def destructuring_block_argument?(argument_node); end
def on_block(node); end
def proc_node?(node=T.unsafe(nil)); end
def symbol_proc?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
SUPER_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::SymbolProc
end
class RuboCop::Cop::Style::TernaryCorrector
end
class RuboCop::Cop::Style::TernaryCorrector
extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
def self.correct(node); end
def self.move_assignment_inside_condition(node); end
end
class RuboCop::Cop::Style::TernaryParentheses
include ::RuboCop::Cop::SafeAssignment
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def method_name(node=T.unsafe(nil)); end
def on_if(node); end
def only_closing_parenthesis_is_last_line?(condition); end
MSG = ::T.let(nil, ::T.untyped)
MSG_COMPLEX = ::T.let(nil, ::T.untyped)
NON_COMPLEX_TYPES = ::T.let(nil, ::T.untyped)
VARIABLE_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TernaryParentheses
end
class RuboCop::Cop::Style::TrailingBodyOnClass
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::TrailingBody
def autocorrect(node); end
def on_class(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TrailingBodyOnClass
end
class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::TrailingBody
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition
end
class RuboCop::Cop::Style::TrailingBodyOnModule
include ::RuboCop::Cop::Alignment
include ::RuboCop::Cop::TrailingBody
def autocorrect(node); end
def on_module(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TrailingBodyOnModule
end
class RuboCop::Cop::Style::TrailingCommaInArguments
include ::RuboCop::Cop::TrailingComma
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def on_csend(node); end
def on_send(node); end
end
class RuboCop::Cop::Style::TrailingCommaInArguments
end
class RuboCop::Cop::Style::TrailingCommaInArrayLiteral
include ::RuboCop::Cop::TrailingComma
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def on_array(node); end
end
class RuboCop::Cop::Style::TrailingCommaInArrayLiteral
end
class RuboCop::Cop::Style::TrailingCommaInHashLiteral
include ::RuboCop::Cop::TrailingComma
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(range); end
def on_hash(node); end
end
class RuboCop::Cop::Style::TrailingCommaInHashLiteral
end
class RuboCop::Cop::Style::TrailingMethodEndStatement
include ::RuboCop::Cop::Alignment
def autocorrect(node); end
def on_def(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TrailingMethodEndStatement
end
class RuboCop::Cop::Style::TrailingUnderscoreVariable
include ::RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_masgn(node); end
MSG = ::T.let(nil, ::T.untyped)
UNDERSCORE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TrailingUnderscoreVariable
end
class RuboCop::Cop::Style::TrivialAccessors
def autocorrect(node); end
def looks_like_trivial_writer?(node=T.unsafe(nil)); end
def on_def(node); end
def on_defs(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::TrivialAccessors
end
class RuboCop::Cop::Style::UnlessElse
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def on_if(node); end
def range_between_condition_and_else(node, condition); end
def range_between_else_and_end(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::UnlessElse
end
class RuboCop::Cop::Style::UnpackFirst
def autocorrect(node); end
def on_send(node); end
def unpack_and_first_element?(node=T.unsafe(nil)); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::UnpackFirst
extend ::RuboCop::Cop::TargetRubyVersion
end
class RuboCop::Cop::Style::VariableInterpolation
include ::RuboCop::Cop::Interpolation
def autocorrect(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::VariableInterpolation
end
class RuboCop::Cop::Style::WhenThen
def autocorrect(node); end
def on_when(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::WhenThen
end
class RuboCop::Cop::Style::WhileUntilDo
def autocorrect(node); end
def handle(node); end
def on_until(node); end
def on_while(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::WhileUntilDo
end
class RuboCop::Cop::Style::WhileUntilModifier
include ::RuboCop::Cop::StatementModifier
def autocorrect(node); end
def on_until(node); end
def on_while(node); end
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::WhileUntilModifier
end
class RuboCop::Cop::Style::WordArray
include ::RuboCop::Cop::ArrayMinSize
include ::RuboCop::Cop::ArraySyntax
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::PercentArray
def autocorrect(node); end
def on_array(node); end
ARRAY_MSG = ::T.let(nil, ::T.untyped)
PERCENT_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::WordArray
def self.largest_brackets(); end
def self.largest_brackets=(largest_brackets); end
end
class RuboCop::Cop::Style::YodaCondition
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
def autocorrect(node); end
def file_constant_equal_program_name?(node=T.unsafe(nil)); end
def on_send(node); end
EQUALITY_OPERATORS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
NONCOMMUTATIVE_OPERATORS = ::T.let(nil, ::T.untyped)
PROGRAM_NAMES = ::T.let(nil, ::T.untyped)
REVERSE_COMPARISON = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::YodaCondition
end
class RuboCop::Cop::Style::ZeroLengthPredicate
def autocorrect(node); end
def non_polymorphic_collection?(node=T.unsafe(nil)); end
def nonzero_length_predicate(node=T.unsafe(nil)); end
def on_send(node); end
def other_receiver(node=T.unsafe(nil)); end
def zero_length_predicate(node=T.unsafe(nil)); end
def zero_length_receiver(node=T.unsafe(nil)); end
NONZERO_MSG = ::T.let(nil, ::T.untyped)
ZERO_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ZeroLengthPredicate
end
module RuboCop::Cop::Style
end
module RuboCop::Cop::SurroundingSpace
include ::RuboCop::Cop::RangeHelp
NO_SPACE_COMMAND = ::T.let(nil, ::T.untyped)
SINGLE_SPACE_REGEXP = ::T.let(nil, ::T.untyped)
SPACE_COMMAND = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::SurroundingSpace
end
module RuboCop::Cop::TargetRubyVersion
def minimum_target_ruby_version(version); end
def support_target_ruby_version?(version); end
end
module RuboCop::Cop::TargetRubyVersion
end
class RuboCop::Cop::Team
def autocorrect(buffer, cops); end
def autocorrect?(); end
def cops(); end
def debug?(); end
def errors(); end
def external_dependency_checksum(); end
def forces(); end
def forces_for(cops); end
def initialize(cop_classes, config, options=T.unsafe(nil)); end
def inspect_file(processed_source); end
def updated_source_file(); end
def updated_source_file?(); end
def warnings(); end
DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Team::Investigation
def errors(); end
def errors=(_); end
def offenses(); end
def offenses=(_); end
end
class RuboCop::Cop::Team::Investigation
def self.[](*_); end
def self.members(); end
end
class RuboCop::Cop::Team
end
module RuboCop::Cop::TooManyLines
include ::RuboCop::Cop::CodeLength
include ::RuboCop::Cop::ConfigurableMax
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::TooManyLines
end
module RuboCop::Cop::TrailingBody
def body_on_first_line?(node, body); end
def first_part_of(body); end
def trailing_body?(node); end
end
module RuboCop::Cop::TrailingBody
end
module RuboCop::Cop::TrailingComma
include ::RuboCop::Cop::ConfigurableEnforcedStyle
include ::RuboCop::Cop::RangeHelp
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::TrailingComma
end
module RuboCop::Cop::UncommunicativeName
def check(node, args); end
CASE_MSG = ::T.let(nil, ::T.untyped)
FORBIDDEN_MSG = ::T.let(nil, ::T.untyped)
LENGTH_MSG = ::T.let(nil, ::T.untyped)
NUM_MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::UncommunicativeName
end
class RuboCop::Cop::UnusedArgCorrector
end
class RuboCop::Cop::UnusedArgCorrector
extend ::RuboCop::Cop::RangeHelp
def self.correct(processed_source, node); end
def self.correct_for_blockarg_type(node); end
def self.processed_source(); end
end
module RuboCop::Cop::Util
include ::RuboCop::PathUtil
LITERAL_REGEX = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Util
def self.begins_its_line?(range); end
def self.comment_line?(line_source); end
def self.double_quotes_required?(string); end
def self.escape_string(string); end
def self.first_part_of_call_chain(node); end
def self.interpret_string_escapes(string); end
def self.line_range(node); end
def self.needs_escaping?(string); end
def self.on_node(syms, sexp, excludes=T.unsafe(nil), &block); end
def self.parentheses?(node); end
def self.same_line?(node1, node2); end
def self.to_string_literal(string); end
def self.to_supported_styles(enforced_style); end
def self.tokens(node); end
def self.trim_string_interporation_escape_character(str); end
end
module RuboCop::Cop::Utils
end
class RuboCop::Cop::Utils::FormatString
def format_sequences(); end
def initialize(string); end
def max_digit_dollar_num(); end
def named_interpolation?(); end
DIGIT_DOLLAR = ::T.let(nil, ::T.untyped)
FLAG = ::T.let(nil, ::T.untyped)
NAME = ::T.let(nil, ::T.untyped)
NUMBER = ::T.let(nil, ::T.untyped)
NUMBER_ARG = ::T.let(nil, ::T.untyped)
PRECISION = ::T.let(nil, ::T.untyped)
SEQUENCE = ::T.let(nil, ::T.untyped)
TEMPLATE_NAME = ::T.let(nil, ::T.untyped)
TYPE = ::T.let(nil, ::T.untyped)
WIDTH = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Utils::FormatString::FormatSequence
def annotated?(); end
def arity(); end
def begin_pos(); end
def end_pos(); end
def flags(); end
def initialize(match); end
def max_digit_dollar_num(); end
def name(); end
def percent?(); end
def precision(); end
def style(); end
def template?(); end
def type(); end
def width(); end
end
class RuboCop::Cop::Utils::FormatString::FormatSequence
end
class RuboCop::Cop::Utils::FormatString
end
module RuboCop::Cop::Utils
end
class RuboCop::Cop::VariableForce
def investigate(processed_source); end
def process_node(node); end
def variable_table(); end
ARGUMENT_DECLARATION_TYPES = ::T.let(nil, ::T.untyped)
LOGICAL_OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
LOOP_TYPES = ::T.let(nil, ::T.untyped)
MULTIPLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped)
OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped)
REGEXP_NAMED_CAPTURE_TYPE = ::T.let(nil, ::T.untyped)
RESCUE_TYPE = ::T.let(nil, ::T.untyped)
SCOPE_TYPES = ::T.let(nil, ::T.untyped)
SEND_TYPE = ::T.let(nil, ::T.untyped)
TWISTED_SCOPE_TYPES = ::T.let(nil, ::T.untyped)
VARIABLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped)
VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
VARIABLE_REFERENCE_TYPE = ::T.let(nil, ::T.untyped)
ZERO_ARITY_SUPER_TYPE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::VariableForce::Assignment
include ::RuboCop::Cop::VariableForce::Branchable
def initialize(node, variable); end
def meta_assignment_node(); end
def multiple_assignment?(); end
def name(); end
def node(); end
def operator(); end
def operator_assignment?(); end
def reference!(node); end
def referenced(); end
def referenced?(); end
def references(); end
def regexp_named_capture?(); end
def scope(); end
def used?(); end
def variable(); end
MULTIPLE_LEFT_HAND_SIDE_TYPE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::VariableForce::Assignment
end
class RuboCop::Cop::VariableForce::AssignmentReference
def assignment?(); end
def node(); end
def node=(_); end
end
class RuboCop::Cop::VariableForce::AssignmentReference
def self.[](*_); end
def self.members(); end
end
module RuboCop::Cop::VariableForce::Branch
CLASSES_BY_TYPE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::VariableForce::Branch::And
include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
def left_body?(); end
def right_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::And
end
class RuboCop::Cop::VariableForce::Branch::Base
def ==(other); end
def always_run?(); end
def branched?(); end
def child_node(); end
def child_node=(_); end
def control_node(); end
def each_ancestor(include_self: T.unsafe(nil), &block); end
def eql?(other); end
def exclusive_with?(other); end
def may_jump_to_other_branch?(); end
def may_run_incompletely?(); end
def parent(); end
def scope(); end
def scope=(_); end
end
class RuboCop::Cop::VariableForce::Branch::Base
def self.[](*_); end
def self.classes(); end
def self.define_predicate(name, child_index: T.unsafe(nil)); end
def self.inherited(subclass); end
def self.members(); end
def self.type(); end
end
class RuboCop::Cop::VariableForce::Branch::Case
def else_body?(); end
def target?(); end
def when_clause?(); end
end
class RuboCop::Cop::VariableForce::Branch::Case
end
class RuboCop::Cop::VariableForce::Branch::Ensure
include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
def ensure_body?(); end
def main_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::Ensure
end
module RuboCop::Cop::VariableForce::Branch::ExceptionHandler
def may_jump_to_other_branch?(); end
def may_run_incompletely?(); end
end
module RuboCop::Cop::VariableForce::Branch::ExceptionHandler
end
class RuboCop::Cop::VariableForce::Branch::For
def collection?(); end
def element?(); end
def loop_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::For
end
class RuboCop::Cop::VariableForce::Branch::If
include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
def falsey_body?(); end
def truthy_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::If
end
module RuboCop::Cop::VariableForce::Branch::LogicalOperator
def always_run?(); end
end
module RuboCop::Cop::VariableForce::Branch::LogicalOperator
end
class RuboCop::Cop::VariableForce::Branch::Or
include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
def left_body?(); end
def right_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::Or
end
class RuboCop::Cop::VariableForce::Branch::Rescue
include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
def else_body?(); end
def main_body?(); end
def rescue_clause?(); end
end
class RuboCop::Cop::VariableForce::Branch::Rescue
end
module RuboCop::Cop::VariableForce::Branch::SimpleConditional
def always_run?(); end
def conditional_clause?(); end
end
module RuboCop::Cop::VariableForce::Branch::SimpleConditional
end
class RuboCop::Cop::VariableForce::Branch::Until
include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
def loop_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::Until
end
class RuboCop::Cop::VariableForce::Branch::UntilPost
include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
def loop_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::UntilPost
end
class RuboCop::Cop::VariableForce::Branch::While
include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
def loop_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::While
end
class RuboCop::Cop::VariableForce::Branch::WhilePost
include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
def loop_body?(); end
end
class RuboCop::Cop::VariableForce::Branch::WhilePost
end
module RuboCop::Cop::VariableForce::Branch
def self.of(target_node, scope: T.unsafe(nil)); end
end
module RuboCop::Cop::VariableForce::Branchable
def branch(); end
def run_exclusively_with?(other); end
end
module RuboCop::Cop::VariableForce::Branchable
end
class RuboCop::Cop::VariableForce::Reference
include ::RuboCop::Cop::VariableForce::Branchable
def explicit?(); end
def initialize(node, scope); end
def node(); end
def scope(); end
VARIABLE_REFERENCE_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::VariableForce::Reference
end
class RuboCop::Cop::VariableForce::Scope
def ==(other); end
def body_node(); end
def each_node(&block); end
def include?(target_node); end
def initialize(node); end
def naked_top_level(); end
def naked_top_level?(); end
def name(); end
def node(); end
def variables(); end
OUTER_SCOPE_CHILD_INDICES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::VariableForce::Scope
end
class RuboCop::Cop::VariableForce::Variable
def argument?(); end
def assign(node); end
def assignments(); end
def block_argument?(); end
def capture_with_block!(); end
def captured_by_block(); end
def captured_by_block?(); end
def declaration_node(); end
def explicit_block_local_variable?(); end
def in_modifier_if?(assignment); end
def initialize(name, declaration_node, scope); end
def keyword_argument?(); end
def method_argument?(); end
def name(); end
def reference!(node); end
def referenced?(); end
def references(); end
def scope(); end
def should_be_unused?(); end
def used?(); end
VARIABLE_DECLARATION_TYPES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::VariableForce::Variable
end
class RuboCop::Cop::VariableForce::VariableReference
def assignment?(); end
def name(); end
def name=(_); end
end
class RuboCop::Cop::VariableForce::VariableReference
def self.[](*_); end
def self.members(); end
end
class RuboCop::Cop::VariableForce::VariableTable
def accessible_variables(); end
def assign_to_variable(name, node); end
def current_scope(); end
def current_scope_level(); end
def declare_variable(name, node); end
def find_variable(name); end
def initialize(hook_receiver=T.unsafe(nil)); end
def invoke_hook(hook_name, *args); end
def pop_scope(); end
def push_scope(scope_node); end
def reference_variable(name, node); end
def scope_stack(); end
def variable_exist?(name); end
end
class RuboCop::Cop::VariableForce::VariableTable
end
class RuboCop::Cop::VariableForce
end
module RuboCop::Cop
end
class RuboCop::Error
end
class RuboCop::Error
end
class RuboCop::ErrorWithAnalyzedFileLocation
def column(); end
def cop(); end
def initialize(cause:, node:, cop:); end
def line(); end
end
class RuboCop::ErrorWithAnalyzedFileLocation
end
module RuboCop::FileFinder
def find_file_upwards(filename, start_dir); end
def find_files_upwards(filename, start_dir); end
end
module RuboCop::FileFinder
def self.root_level=(level); end
def self.root_level?(path); end
end
module RuboCop::Formatter
end
class RuboCop::Formatter::AutoGenConfigFormatter
end
class RuboCop::Formatter::AutoGenConfigFormatter
end
class RuboCop::Formatter::BaseFormatter
def file_finished(file, offenses); end
def file_started(file, options); end
def finished(inspected_files); end
def initialize(output, options=T.unsafe(nil)); end
def options(); end
def output(); end
def started(target_files); end
end
class RuboCop::Formatter::BaseFormatter
end
class RuboCop::Formatter::ClangStyleFormatter
ELLIPSES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::ClangStyleFormatter
end
module RuboCop::Formatter::Colorizable
def black(string); end
def blue(string); end
def colorize(string, *args); end
def cyan(string); end
def green(string); end
def magenta(string); end
def rainbow(); end
def red(string); end
def white(string); end
def yellow(string); end
end
module RuboCop::Formatter::Colorizable
end
class RuboCop::Formatter::DisabledConfigFormatter
def file_started(_file, _file_info); end
def finished(_inspected_files); end
HEADING = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::DisabledConfigFormatter
def self.config_to_allow_offenses(); end
def self.config_to_allow_offenses=(config_to_allow_offenses); end
def self.detected_styles(); end
def self.detected_styles=(detected_styles); end
end
class RuboCop::Formatter::DisabledLinesFormatter
include ::RuboCop::PathUtil
include ::RuboCop::Formatter::Colorizable
def cop_disabled_line_ranges(); end
def finished(_inspected_files); end
def started(_target_files); end
end
class RuboCop::Formatter::DisabledLinesFormatter
end
class RuboCop::Formatter::EmacsStyleFormatter
end
class RuboCop::Formatter::EmacsStyleFormatter
end
class RuboCop::Formatter::FileListFormatter
end
class RuboCop::Formatter::FileListFormatter
end
class RuboCop::Formatter::FormatterSet
def add_formatter(formatter_type, output_path=T.unsafe(nil)); end
def close_output_files(); end
def file_finished(file, offenses); end
def file_started(file, options); end
def finished(*args); end
def initialize(options=T.unsafe(nil)); end
def started(*args); end
BUILTIN_FORMATTERS_FOR_KEYS = ::T.let(nil, ::T.untyped)
FORMATTER_APIS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::FormatterSet
end
class RuboCop::Formatter::FuubarStyleFormatter
def initialize(*output); end
def progressbar_color(); end
def started(target_files); end
def with_color(); end
RESET_SEQUENCE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::FuubarStyleFormatter
end
class RuboCop::Formatter::HTMLFormatter
def files(); end
def render_html(); end
def summary(); end
ELLIPSES = ::T.let(nil, ::T.untyped)
TEMPLATE_PATH = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::HTMLFormatter::Color
def alpha(); end
def alpha=(_); end
def blue(); end
def blue=(_); end
def fade_out(amount); end
def green(); end
def green=(_); end
def red(); end
def red=(_); end
end
class RuboCop::Formatter::HTMLFormatter::Color
def self.[](*_); end
def self.members(); end
end
class RuboCop::Formatter::HTMLFormatter::ERBContext
include ::RuboCop::PathUtil
include ::RuboCop::Formatter::TextUtil
def base64_encoded_logo_image(); end
def decorated_message(offense); end
def escape(string); end
def files(); end
def highlighted_source_line(offense); end
def hightlight_source_tag(offense); end
def initialize(files, summary); end
def possible_ellipses(location); end
def source_after_highlight(offense); end
def source_before_highlight(offense); end
def summary(); end
LOGO_IMAGE_PATH = ::T.let(nil, ::T.untyped)
SEVERITY_COLORS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::HTMLFormatter::ERBContext
end
class RuboCop::Formatter::HTMLFormatter
end
class RuboCop::Formatter::JSONFormatter
include ::RuboCop::PathUtil
def hash_for_file(file, offenses); end
def hash_for_location(offense); end
def hash_for_offense(offense); end
def metadata_hash(); end
def output_hash(); end
end
class RuboCop::Formatter::JSONFormatter
end
class RuboCop::Formatter::JUnitFormatter
def finished(_inspected_files); end
end
class RuboCop::Formatter::JUnitFormatter
end
class RuboCop::Formatter::OffenseCountFormatter
def file_finished(_file, offenses); end
def finished(_inspected_files); end
def offense_counts(); end
def ordered_offense_counts(offense_counts); end
def report_summary(offense_counts); end
def total_offense_count(offense_counts); end
end
class RuboCop::Formatter::OffenseCountFormatter
end
class RuboCop::Formatter::PacmanFormatter
include ::RuboCop::Formatter::TextUtil
def cols(); end
def file_started(_file, _options); end
def next_step(offenses); end
def pacdots(number); end
def progress_line(); end
def progress_line=(progress_line); end
def started(target_files); end
def step(character); end
def update_progress_line(); end
FALLBACK_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
GHOST = ::T.let(nil, ::T.untyped)
PACDOT = ::T.let(nil, ::T.untyped)
PACMAN = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::PacmanFormatter
end
class RuboCop::Formatter::ProgressFormatter
include ::RuboCop::Formatter::TextUtil
def report_file_as_mark(offenses); end
def started(target_files); end
DOT = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::ProgressFormatter
end
class RuboCop::Formatter::QuietFormatter
end
class RuboCop::Formatter::QuietFormatter
end
class RuboCop::Formatter::SimpleTextFormatter
include ::RuboCop::Formatter::Colorizable
include ::RuboCop::PathUtil
def report_file(file, offenses); end
def report_summary(file_count, offense_count, correction_count); end
def started(_target_files); end
COLOR_FOR_SEVERITY = ::T.let(nil, ::T.untyped)
end
class RuboCop::Formatter::SimpleTextFormatter::Report
include ::RuboCop::Formatter::Colorizable
include ::RuboCop::Formatter::TextUtil
def initialize(file_count, offense_count, correction_count, rainbow); end
def summary(); end
end
class RuboCop::Formatter::SimpleTextFormatter::Report
end
class RuboCop::Formatter::SimpleTextFormatter
end
class RuboCop::Formatter::TapFormatter
def started(target_files); end
end
class RuboCop::Formatter::TapFormatter
end
module RuboCop::Formatter::TextUtil
end
module RuboCop::Formatter::TextUtil
def self.pluralize(number, thing, options=T.unsafe(nil)); end
end
class RuboCop::Formatter::WorstOffendersFormatter
def finished(_inspected_files); end
def offense_counts(); end
def ordered_offense_counts(offense_counts); end
def report_summary(offense_counts); end
def total_offense_count(offense_counts); end
end
class RuboCop::Formatter::WorstOffendersFormatter
end
module RuboCop::Formatter
end
class RuboCop::IncorrectCopNameError
end
class RuboCop::IncorrectCopNameError
end
class RuboCop::MagicComment
def any?(); end
def encoding_specified?(); end
def frozen_string_literal(); end
def frozen_string_literal?(); end
def frozen_string_literal_specified?(); end
def initialize(comment); end
def valid_literal_value?(); end
TOKEN = ::T.let(nil, ::T.untyped)
end
class RuboCop::MagicComment::EditorComment
end
class RuboCop::MagicComment::EditorComment
end
class RuboCop::MagicComment::EmacsComment
def encoding(); end
FORMAT = ::T.let(nil, ::T.untyped)
OPERATOR = ::T.let(nil, ::T.untyped)
SEPARATOR = ::T.let(nil, ::T.untyped)
end
class RuboCop::MagicComment::EmacsComment
end
class RuboCop::MagicComment::SimpleComment
def encoding(); end
end
class RuboCop::MagicComment::SimpleComment
end
class RuboCop::MagicComment::VimComment
def encoding(); end
FORMAT = ::T.let(nil, ::T.untyped)
OPERATOR = ::T.let(nil, ::T.untyped)
SEPARATOR = ::T.let(nil, ::T.untyped)
end
class RuboCop::MagicComment::VimComment
end
class RuboCop::MagicComment
def self.parse(comment); end
end
module RuboCop::NameSimilarity
def find_similar_name(target_name, scope); end
MINIMUM_SIMILARITY_TO_SUGGEST = ::T.let(nil, ::T.untyped)
end
module RuboCop::NameSimilarity
end
class RuboCop::NodePattern
def ==(other); end
def eql?(other); end
def initialize(str); end
def marshal_dump(); end
def marshal_load(pattern); end
def match(*args); end
def pattern(); end
end
class RuboCop::NodePattern::Invalid
end
class RuboCop::NodePattern::Invalid
end
module RuboCop::NodePattern::Macros
def def_node_matcher(method_name, pattern_str); end
def def_node_search(method_name, pattern_str); end
def node_search(method_name, compiler, on_match, prelude, called_from); end
def node_search_all(method_name, compiler, called_from); end
def node_search_body(method_name, trailing_params, prelude, match_code, on_match); end
def node_search_first(method_name, compiler, called_from); end
end
module RuboCop::NodePattern::Macros
end
class RuboCop::NodePattern
def self.descend(element, &block); end
end
class RuboCop::OptionArgumentError
end
class RuboCop::OptionArgumentError
end
class RuboCop::Options
def parse(command_line_args); end
DEFAULT_MAXIMUM_EXCLUSION_ITEMS = ::T.let(nil, ::T.untyped)
EXITING_OPTIONS = ::T.let(nil, ::T.untyped)
E_STDIN_NO_PATH = ::T.let(nil, ::T.untyped)
end
class RuboCop::Options
end
module RuboCop::OptionsHelp
FORMATTER_OPTION_LIST = ::T.let(nil, ::T.untyped)
MAX_EXCL = ::T.let(nil, ::T.untyped)
TEXT = ::T.let(nil, ::T.untyped)
end
module RuboCop::OptionsHelp
end
class RuboCop::OptionsValidator
def boolean_or_empty_cache?(); end
def display_only_fail_level_offenses_with_autocorrect?(); end
def except_syntax?(); end
def incompatible_options(); end
def initialize(options); end
def only_includes_redundant_disable?(); end
def validate_auto_correct(); end
def validate_auto_gen_config(); end
def validate_compatibility(); end
def validate_cop_options(); end
def validate_exclude_limit_option(); end
def validate_parallel(); end
def validate_parallel_with_combo_option(); end
end
class RuboCop::OptionsValidator
def self.validate_cop_list(names); end
end
module RuboCop::PathUtil
end
module RuboCop::PathUtil
def self.absolute?(path); end
def self.chdir(dir, &block); end
def self.hidden_dir?(path); end
def self.hidden_file_in_not_hidden_dir?(pattern, path); end
def self.match_path?(pattern, path); end
def self.pwd(); end
def self.relative_path(path, base_dir=T.unsafe(nil)); end
def self.reset_pwd(); end
def self.smart_path(path); end
end
module RuboCop::Platform
end
module RuboCop::Platform
def self.windows?(); end
end
class RuboCop::ProcessedSource
def [](*args); end
def ast(); end
def ast_with_comments(); end
def blank?(); end
def buffer(); end
def checksum(); end
def comment_config(); end
def commented?(source_range); end
def comments(); end
def comments_before_line(line); end
def current_line(token); end
def diagnostics(); end
def disabled_line_ranges(); end
def each_comment(); end
def each_token(); end
def file_path(); end
def find_comment(); end
def find_token(); end
def following_line(token); end
def initialize(source, ruby_version, path=T.unsafe(nil)); end
def line_indentation(line_number); end
def lines(); end
def parser_error(); end
def path(); end
def preceding_line(token); end
def raw_source(); end
def ruby_version(); end
def start_with?(string); end
def tokens(); end
def valid_syntax?(); end
STRING_SOURCE_NAME = ::T.let(nil, ::T.untyped)
end
class RuboCop::ProcessedSource
def self.from_file(path, ruby_version); end
end
class RuboCop::RemoteConfig
def file(); end
def inherit_from_remote(file, path); end
def initialize(url, base_dir); end
def uri(); end
CACHE_LIFETIME = ::T.let(nil, ::T.untyped)
end
class RuboCop::RemoteConfig
end
class RuboCop::ResultCache
def initialize(file, team, options, config_store, cache_root=T.unsafe(nil)); end
def load(); end
def save(offenses); end
def valid?(); end
NON_CHANGING = ::T.let(nil, ::T.untyped)
end
class RuboCop::ResultCache
def self.allow_symlinks_in_cache_location?(config_store); end
def self.cache_root(config_store); end
def self.cleanup(config_store, verbose, cache_root=T.unsafe(nil)); end
def self.inhibit_cleanup(); end
def self.inhibit_cleanup=(inhibit_cleanup); end
def self.source_checksum(); end
def self.source_checksum=(source_checksum); end
end
class RuboCop::Runner
def aborting=(aborting); end
def aborting?(); end
def errors(); end
def initialize(options, config_store); end
def run(paths); end
def warnings(); end
MAX_ITERATIONS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Runner::InfiniteCorrectionLoop
def initialize(path, offenses); end
def offenses(); end
end
class RuboCop::Runner::InfiniteCorrectionLoop
end
class RuboCop::Runner
end
class RuboCop::StringInterpreter
STRING_ESCAPES = ::T.let(nil, ::T.untyped)
STRING_ESCAPE_REGEX = ::T.let(nil, ::T.untyped)
end
class RuboCop::StringInterpreter
def self.interpret(string); end
end
module RuboCop::StringUtil
end
module RuboCop::StringUtil
def self.similarity(string_a, string_b); end
end
class RuboCop::TargetFinder
def all_cops_include(); end
def configured_include?(file); end
def debug?(); end
def excluded_dirs(base_dir); end
def fail_fast?(); end
def find(args); end
def find_files(base_dir, flags); end
def force_exclusion?(); end
def included_file?(file); end
def initialize(config_store, options=T.unsafe(nil)); end
def process_explicit_path(path); end
def ruby_executable?(file); end
def ruby_extension?(file); end
def ruby_extensions(); end
def ruby_file?(file); end
def ruby_filename?(file); end
def ruby_filenames(); end
def ruby_interpreters(file); end
def stdin?(); end
def target_files_in_dir(base_dir=T.unsafe(nil)); end
def to_inspect?(file, hidden_files, base_dir_config); end
def toplevel_dirs(base_dir, flags); end
end
class RuboCop::TargetFinder
end
class RuboCop::TargetRuby
def initialize(config); end
def rubocop_version_with_support(); end
def source(); end
def supported?(); end
def version(); end
DEFAULT_VERSION = ::T.let(nil, ::T.untyped)
end
class RuboCop::TargetRuby::BundlerLockFile
end
class RuboCop::TargetRuby::BundlerLockFile
end
class RuboCop::TargetRuby::Default
end
class RuboCop::TargetRuby::Default
end
class RuboCop::TargetRuby::RuboCopConfig
end
class RuboCop::TargetRuby::RuboCopConfig
end
class RuboCop::TargetRuby::RubyVersionFile
FILENAME = ::T.let(nil, ::T.untyped)
end
class RuboCop::TargetRuby::RubyVersionFile
end
class RuboCop::TargetRuby::Source
def initialize(config); end
def name(); end
def version(); end
end
class RuboCop::TargetRuby::Source
end
class RuboCop::TargetRuby
def self.supported_versions(); end
end
class RuboCop::Token
def begin_pos(); end
def column(); end
def comma?(); end
def comment?(); end
def end?(); end
def end_pos(); end
def equal_sign?(); end
def initialize(pos, type, text); end
def left_array_bracket?(); end
def left_brace?(); end
def left_bracket?(); end
def left_curly_brace?(); end
def left_parens?(); end
def left_ref_bracket?(); end
def line(); end
def pos(); end
def rescue_modifier?(); end
def right_bracket?(); end
def right_curly_brace?(); end
def right_parens?(); end
def semicolon?(); end
def space_after?(); end
def space_before?(); end
def text(); end
def type(); end
end
class RuboCop::Token
def self.from_parser_token(parser_token); end
end
class RuboCop::ValidationError
end
class RuboCop::ValidationError
end
module RuboCop::Version
MSG = ::T.let(nil, ::T.untyped)
STRING = ::T.let(nil, ::T.untyped)
end
module RuboCop::Version
def self.version(debug=T.unsafe(nil)); end
end
class RuboCop::Warning
end
class RuboCop::Warning
end
module RuboCop::YAMLDuplicationChecker
end
module RuboCop::YAMLDuplicationChecker
def self.check(yaml_string, filename, &on_duplicated); end
end
module RuboCop
end
module RubyVM::AbstractSyntaxTree
end
class RubyVM::AbstractSyntaxTree::Node
def children(); end
def first_column(); end
def first_lineno(); end
def last_column(); end
def last_lineno(); end
def pretty_print_children(q, names=T.unsafe(nil)); end
def type(); end
end
class RubyVM::AbstractSyntaxTree::Node
end
module RubyVM::AbstractSyntaxTree
def self.of(_); end
def self.parse(_); end
def self.parse_file(_); end
end
class RubyVM::InstructionSequence
def absolute_path(); end
def base_label(); end
def disasm(); end
def disassemble(); end
def each_child(); end
def eval(); end
def first_lineno(); end
def label(); end
def path(); end
def to_a(); end
def to_binary(*_); end
def trace_points(); end
end
class RubyVM::InstructionSequence
def self.compile(*_); end
def self.compile_file(*_); end
def self.compile_option(); end
def self.compile_option=(compile_option); end
def self.disasm(_); end
def self.disassemble(_); end
def self.load_from_binary(_); end
def self.load_from_binary_extra_data(_); end
def self.of(_); end
end
module RubyVM::MJIT
end
module RubyVM::MJIT
def self.enabled?(); end
def self.pause(*_); end
def self.resume(); end
end
class RubyVM
def self.resolve_feature_path(_); end
def self.stat(*_); end
end
ScanError = StringScanner::Error
module SecureRandom
def self.bytes(n); end
end
class Set
def ==(other); end
def ===(o); end
def compare_by_identity(); end
def compare_by_identity?(); end
def divide(&func); end
def eql?(o); end
def flatten_merge(set, seen=T.unsafe(nil)); end
def pretty_print(pp); end
def pretty_print_cycle(pp); end
def reset(); end
InspectKey = ::T.let(nil, ::T.untyped)
end
module Shellwords
end
module Shellwords
def self.escape(str); end
def self.join(array); end
def self.shellescape(str); end
def self.shelljoin(array); end
def self.shellsplit(line); end
def self.shellwords(line); end
def self.split(line); end
end
class SignalException
def signm(); end
def signo(); end
end
module SingleForwardable
def def_delegator(accessor, method, ali=T.unsafe(nil)); end
def def_delegators(accessor, *methods); end
def def_single_delegator(accessor, method, ali=T.unsafe(nil)); end
def def_single_delegators(accessor, *methods); end
def delegate(hash); end
def single_delegate(hash); end
end
module Singleton
def _dump(depth=T.unsafe(nil)); end
def clone(); end
def dup(); end
end
module Singleton::SingletonClassMethods
def _load(str); end
def clone(); end
end
module Singleton
def self.__init__(klass); end
end
class Socket
IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
SO_BPF_EXTENSIONS = ::T.let(nil, ::T.untyped)
end
module Socket::Constants
IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
SO_BPF_EXTENSIONS = ::T.let(nil, ::T.untyped)
end
module Solargraph
VERSION = ::T.let(nil, ::T.untyped)
VIEWS_PATH = ::T.let(nil, ::T.untyped)
YARDOC_PATH = ::T.let(nil, ::T.untyped)
YARD_EXTENSION_FILE = ::T.let(nil, ::T.untyped)
end
class Solargraph::ApiMap
include ::Solargraph::ApiMap::SourceToYard
include ::Solargraph::ApiMap::BundlerMethods
def bundled?(filename); end
def catalog(bundle); end
def clip(cursor); end
def clip_at(filename, position); end
def cursor_at(filename, position); end
def document(path); end
def document_symbols(filename); end
def get_class_variable_pins(namespace); end
def get_complex_type_methods(type, context=T.unsafe(nil), internal=T.unsafe(nil)); end
def get_constants(namespace, *contexts); end
def get_global_variable_pins(); end
def get_instance_variable_pins(namespace, scope=T.unsafe(nil)); end
def get_method_stack(fqns, name, scope: T.unsafe(nil)); end
def get_methods(fqns, scope: T.unsafe(nil), visibility: T.unsafe(nil), deep: T.unsafe(nil)); end
def get_path_pins(path); end
def get_path_suggestions(path); end
def get_symbols(); end
def implicit(); end
def index(pins); end
def initialize(pins: T.unsafe(nil)); end
def local_path_hash(); end
def locate_pins(location); end
def map(source); end
def named_macro(name); end
def namespace_exists?(name, context=T.unsafe(nil)); end
def namespaces(); end
def pins(); end
def qualify(namespace, context=T.unsafe(nil)); end
def query_symbols(query); end
def require_reference_at(location); end
def search(query); end
def source_map(filename); end
def source_maps(); end
def super_and_sub?(sup, sub); end
def unresolved_requires(); end
def workspaced?(filename); end
end
module Solargraph::ApiMap::BundlerMethods
end
module Solargraph::ApiMap::BundlerMethods
def self.require_from_bundle(directory); end
def self.reset_require_from_bundle(); end
end
class Solargraph::ApiMap::Cache
def clear(); end
def empty?(); end
def get_constants(namespace, context); end
def get_methods(fqns, scope, visibility, deep); end
def get_qualified_namespace(name, context); end
def get_receiver_definition(path); end
def receiver_defined?(path); end
def set_constants(namespace, context, value); end
def set_methods(fqns, scope, visibility, deep, value); end
def set_qualified_namespace(name, context, value); end
def set_receiver_definition(path, pin); end
end
class Solargraph::ApiMap::Cache
end
module Solargraph::ApiMap::SourceToYard
def code_object_at(path); end
def code_object_paths(); end
def rake_yard(store); end
end
module Solargraph::ApiMap::SourceToYard
end
class Solargraph::ApiMap::Store
def block_pins(); end
def domains(fqns); end
def get_class_variables(fqns); end
def get_constants(fqns, visibility=T.unsafe(nil)); end
def get_extends(fqns); end
def get_includes(fqns); end
def get_instance_variables(fqns, scope=T.unsafe(nil)); end
def get_methods(fqns, scope: T.unsafe(nil), visibility: T.unsafe(nil)); end
def get_path_pins(path); end
def get_superclass(fqns); end
def get_symbols(); end
def initialize(pins=T.unsafe(nil)); end
def method_pins(); end
def named_macros(); end
def namespace_exists?(fqns); end
def namespace_pins(); end
def namespaces(); end
def pins(); end
end
class Solargraph::ApiMap::Store
end
class Solargraph::ApiMap
def self.keywords(); end
def self.load(directory); end
end
class Solargraph::Bundle
def initialize(workspace: T.unsafe(nil), opened: T.unsafe(nil)); end
def opened(); end
def sources(); end
def workspace(); end
end
class Solargraph::Bundle
end
class Solargraph::BundleNotFoundError
end
class Solargraph::BundleNotFoundError
end
class Solargraph::ComplexType
def [](index); end
def all?(&block); end
def each(&block); end
def first(); end
def initialize(types=T.unsafe(nil)); end
def length(); end
def map(&block); end
def method_missing(name, *args, &block); end
def qualify(api_map, context=T.unsafe(nil)); end
def select(&block); end
def self_to(dst); end
def selfy?(); end
BOOLEAN = ::T.let(nil, ::T.untyped)
NIL = ::T.let(nil, ::T.untyped)
ROOT = ::T.let(nil, ::T.untyped)
SELF = ::T.let(nil, ::T.untyped)
SYMBOL = ::T.let(nil, ::T.untyped)
UNDEFINED = ::T.let(nil, ::T.untyped)
VOID = ::T.let(nil, ::T.untyped)
end
module Solargraph::ComplexType::TypeMethods
def ==(other); end
def defined?(); end
def duck_type?(); end
def fixed_parameters?(); end
def hash_parameters?(); end
def key_types(); end
def list_parameters?(); end
def name(); end
def namespace(); end
def nil_type?(); end
def parameters?(); end
def qualify(api_map, context=T.unsafe(nil)); end
def rooted?(); end
def scope(); end
def substring(); end
def subtypes(); end
def tag(); end
def undefined?(); end
def value_types(); end
def void?(); end
end
module Solargraph::ComplexType::TypeMethods
end
class Solargraph::ComplexType::UniqueType
include ::Solargraph::ComplexType::TypeMethods
def initialize(name, substring=T.unsafe(nil)); end
def self_to(dst); end
def selfy?(); end
BOOLEAN = ::T.let(nil, ::T.untyped)
UNDEFINED = ::T.let(nil, ::T.untyped)
end
class Solargraph::ComplexType::UniqueType
end
class Solargraph::ComplexType
def self.parse(*strings, partial: T.unsafe(nil)); end
def self.try_parse(*strings); end
end
class Solargraph::ComplexTypeError
end
class Solargraph::ComplexTypeError
end
module Solargraph::Convention
end
class Solargraph::Convention::Base
def environ(); end
def match?(source); end
def process(); end
EMPTY_ENVIRON = ::T.let(nil, ::T.untyped)
end
class Solargraph::Convention::Base
end
class Solargraph::Convention::Gemfile
end
class Solargraph::Convention::Gemfile
end
class Solargraph::Convention::Gemspec
end
class Solargraph::Convention::Gemspec
end
class Solargraph::Convention::Rspec
end
class Solargraph::Convention::Rspec
end
module Solargraph::Convention
def self.for(source); end
def self.register(convention); end
end
module Solargraph::CoreFills
KEYWORDS = ::T.let(nil, ::T.untyped)
OVERRIDES = ::T.let(nil, ::T.untyped)
end
class Solargraph::CoreFills::Override
def delete(); end
def initialize(location, name, tags, delete=T.unsafe(nil)); end
def tags(); end
end
class Solargraph::CoreFills::Override
def self.from_comment(name, comment); end
def self.method_return(name, *tags, delete: T.unsafe(nil)); end
end
module Solargraph::CoreFills
end
module Solargraph::Diagnostics
end
class Solargraph::Diagnostics::Base
def args(); end
def diagnose(source, api_map); end
def initialize(*args); end
end
class Solargraph::Diagnostics::Base
end
class Solargraph::Diagnostics::RequireNotFound
end
class Solargraph::Diagnostics::RequireNotFound
end
class Solargraph::Diagnostics::Rubocop
include ::Solargraph::Diagnostics::RubocopHelpers
def diagnose(source, _api_map); end
SEVERITIES = ::T.let(nil, ::T.untyped)
end
class Solargraph::Diagnostics::Rubocop
end
module Solargraph::Diagnostics::RubocopHelpers
end
module Solargraph::Diagnostics::RubocopHelpers
def self.find_rubocop_file(filename); end
def self.fix_drive_letter(path); end
def self.generate_options(filename, code); end
def self.redirect_stdout(); end
end
module Solargraph::Diagnostics::Severities
ERROR = ::T.let(nil, ::T.untyped)
HINT = ::T.let(nil, ::T.untyped)
INFORMATION = ::T.let(nil, ::T.untyped)
WARNING = ::T.let(nil, ::T.untyped)
end
module Solargraph::Diagnostics::Severities
end
class Solargraph::Diagnostics::TypeCheck
end
class Solargraph::Diagnostics::TypeCheck
end
class Solargraph::Diagnostics::UpdateErrors
end
class Solargraph::Diagnostics::UpdateErrors
end
module Solargraph::Diagnostics
def self.register(name, klass); end
def self.reporter(name); end
def self.reporters(); end
end
class Solargraph::DiagnosticsError
end
class Solargraph::DiagnosticsError
end
class Solargraph::Documentor
def document(); end
def initialize(directory, rebuild: T.unsafe(nil), out: T.unsafe(nil)); end
RDOC_GEMS = ::T.let(nil, ::T.untyped)
end
class Solargraph::Documentor
def self.specs_from_bundle(directory); end
end
class Solargraph::Environ
def clear(); end
def domains(); end
def initialize(requires: T.unsafe(nil), domains: T.unsafe(nil), overrides: T.unsafe(nil)); end
def merge(other); end
def overrides(); end
def requires(); end
end
class Solargraph::Environ
end
class Solargraph::FileNotFoundError
end
class Solargraph::FileNotFoundError
end
class Solargraph::InvalidOffsetError
end
class Solargraph::InvalidOffsetError
end
module Solargraph::LanguageServer
end
module Solargraph::LanguageServer::CompletionItemKinds
CLASS = ::T.let(nil, ::T.untyped)
COLOR = ::T.let(nil, ::T.untyped)
CONSTANT = ::T.let(nil, ::T.untyped)
CONSTRUCTOR = ::T.let(nil, ::T.untyped)
ENUM = ::T.let(nil, ::T.untyped)
ENUM_MEMBER = ::T.let(nil, ::T.untyped)
EVENT = ::T.let(nil, ::T.untyped)
FIELD = ::T.let(nil, ::T.untyped)
FILE = ::T.let(nil, ::T.untyped)
FOLDER = ::T.let(nil, ::T.untyped)
FUNCTION = ::T.let(nil, ::T.untyped)
INTERFACE = ::T.let(nil, ::T.untyped)
KEYWORD = ::T.let(nil, ::T.untyped)
METHOD = ::T.let(nil, ::T.untyped)
MODULE = ::T.let(nil, ::T.untyped)
OPERATOR = ::T.let(nil, ::T.untyped)
PROPERTY = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
SNIPPET = ::T.let(nil, ::T.untyped)
STRUCT = ::T.let(nil, ::T.untyped)
TEXT = ::T.let(nil, ::T.untyped)
TYPE_PARAMETER = ::T.let(nil, ::T.untyped)
UNIT = ::T.let(nil, ::T.untyped)
VALUE = ::T.let(nil, ::T.untyped)
VARIABLE = ::T.let(nil, ::T.untyped)
end
module Solargraph::LanguageServer::CompletionItemKinds
end
module Solargraph::LanguageServer::ErrorCodes
INTERNAL_ERROR = ::T.let(nil, ::T.untyped)
INVALID_PARAMS = ::T.let(nil, ::T.untyped)
INVALID_REQUEST = ::T.let(nil, ::T.untyped)
METHOD_NOT_FOUND = ::T.let(nil, ::T.untyped)
PARSE_ERROR = ::T.let(nil, ::T.untyped)
REQUEST_CANCELLED = ::T.let(nil, ::T.untyped)
SERVER_ERROR_END = ::T.let(nil, ::T.untyped)
SERVER_ERROR_START = ::T.let(nil, ::T.untyped)
SERVER_NOT_INITIALIZED = ::T.let(nil, ::T.untyped)
UNKNOWN_ERROR_CODE = ::T.let(nil, ::T.untyped)
end
module Solargraph::LanguageServer::ErrorCodes
end
class Solargraph::LanguageServer::Host
include ::Solargraph::LanguageServer::UriHelpers
include ::Solargraph::Logging
include ::Solargraph::LanguageServer::Host::Dispatch
include ::Observable
def allow_registration(method); end
def can_register?(method); end
def cancel(id); end
def cancel?(id); end
def catalog(); end
def change(params); end
def clear(id); end
def client_capabilities(); end
def client_capabilities=(client_capabilities); end
def close(uri); end
def completions_at(uri, line, column); end
def configure(update); end
def create(uri); end
def default_configuration(); end
def definitions_at(uri, line, column); end
def delete(uri); end
def diagnose(uri); end
def document(query); end
def document_symbols(uri); end
def flush(); end
def folders(); end
def folding_ranges(uri); end
def locate_pins(params); end
def open(uri, text, version); end
def open?(uri); end
def open_from_disk(uri); end
def options(); end
def pending_requests(); end
def prepare(directory, name=T.unsafe(nil)); end
def prepare_folders(array); end
def query_symbols(query); end
def queue(message); end
def read_text(uri); end
def receive(request); end
def references_from(uri, line, column, strip: T.unsafe(nil)); end
def register_capabilities(methods); end
def registered?(method); end
def remove(directory); end
def remove_folders(array); end
def search(query); end
def send_notification(method, params); end
def send_request(method, params, &block); end
def show_message(text, type=T.unsafe(nil)); end
def show_message_request(text, type, actions, &block); end
def signatures_at(uri, line, column); end
def start(); end
def stop(); end
def stopped?(); end
def synchronizing?(); end
def unregister_capabilities(methods); end
end
class Solargraph::LanguageServer::Host::Cataloger
def initialize(host); end
def start(); end
def stop(); end
def stopped?(); end
def tick(); end
end
class Solargraph::LanguageServer::Host::Cataloger
end
class Solargraph::LanguageServer::Host::Diagnoser
def initialize(host); end
def schedule(uri); end
def start(); end
def stop(); end
def stopped?(); end
def tick(); end
end
class Solargraph::LanguageServer::Host::Diagnoser
end
module Solargraph::LanguageServer::Host::Dispatch
def explicit_library_for(uri); end
def generic_library(); end
def generic_library_for(uri); end
def implicit_library_for(uri); end
def libraries(); end
def library_for(uri); end
def sources(); end
def update_libraries(uri); end
end
module Solargraph::LanguageServer::Host::Dispatch
end
class Solargraph::LanguageServer::Host::Sources
include ::Observable
include ::Solargraph::LanguageServer::UriHelpers
def async_update(uri, updater); end
def clear(); end
def close(uri); end
def find(uri); end
def include?(uri); end
def open(uri, text, version); end
def open_from_disk(uri); end
def start(); end
def stop(); end
def stopped?(); end
def tick(); end
def update(uri, updater); end
end
class Solargraph::LanguageServer::Host::Sources
end
class Solargraph::LanguageServer::Host
end
module Solargraph::LanguageServer::Message
end
class Solargraph::LanguageServer::Message::Base
def error(); end
def host(); end
def id(); end
def initialize(host, request); end
def method(); end
def params(); end
def post_initialize(); end
def process(); end
def request(); end
def result(); end
def send_response(); end
def set_error(code, message); end
def set_result(data); end
end
class Solargraph::LanguageServer::Message::Base
end
class Solargraph::LanguageServer::Message::CancelRequest
end
class Solargraph::LanguageServer::Message::CancelRequest
end
module Solargraph::LanguageServer::Message::CompletionItem
end
class Solargraph::LanguageServer::Message::CompletionItem::Resolve
end
class Solargraph::LanguageServer::Message::CompletionItem::Resolve
end
module Solargraph::LanguageServer::Message::CompletionItem
end
class Solargraph::LanguageServer::Message::ExitNotification
end
class Solargraph::LanguageServer::Message::ExitNotification
end
module Solargraph::LanguageServer::Message::Extended
end
class Solargraph::LanguageServer::Message::Extended::CheckGemVersion
def initialize(host, request, current: T.unsafe(nil), available: T.unsafe(nil)); end
GEM_ZERO = ::T.let(nil, ::T.untyped)
end
class Solargraph::LanguageServer::Message::Extended::CheckGemVersion
def self.fetcher(); end
def self.fetcher=(obj); end
end
class Solargraph::LanguageServer::Message::Extended::Document
end
class Solargraph::LanguageServer::Message::Extended::Document
end
class Solargraph::LanguageServer::Message::Extended::DocumentGems
end
class Solargraph::LanguageServer::Message::Extended::DocumentGems
end
class Solargraph::LanguageServer::Message::Extended::DownloadCore
end
class Solargraph::LanguageServer::Message::Extended::DownloadCore
end
class Solargraph::LanguageServer::Message::Extended::Environment
end
class Solargraph::LanguageServer::Message::Extended::Environment
end
class Solargraph::LanguageServer::Message::Extended::Search
end
class Solargraph::LanguageServer::Message::Extended::Search
end
module Solargraph::LanguageServer::Message::Extended
end
class Solargraph::LanguageServer::Message::Initialize
end
class Solargraph::LanguageServer::Message::Initialize
end
class Solargraph::LanguageServer::Message::Initialized
end
class Solargraph::LanguageServer::Message::Initialized
end
class Solargraph::LanguageServer::Message::MethodNotFound
end
class Solargraph::LanguageServer::Message::MethodNotFound
end
class Solargraph::LanguageServer::Message::MethodNotImplemented
end
class Solargraph::LanguageServer::Message::MethodNotImplemented
end
class Solargraph::LanguageServer::Message::Shutdown
end
class Solargraph::LanguageServer::Message::Shutdown
end
module Solargraph::LanguageServer::Message::TextDocument
end
class Solargraph::LanguageServer::Message::TextDocument::Base
include ::Solargraph::LanguageServer::UriHelpers
def filename(); end
end
class Solargraph::LanguageServer::Message::TextDocument::Base
end
class Solargraph::LanguageServer::Message::TextDocument::CodeAction
end
class Solargraph::LanguageServer::Message::TextDocument::CodeAction
end
class Solargraph::LanguageServer::Message::TextDocument::Completion
def empty_result(incomplete=T.unsafe(nil)); end
end
class Solargraph::LanguageServer::Message::TextDocument::Completion
end
class Solargraph::LanguageServer::Message::TextDocument::Definition
end
class Solargraph::LanguageServer::Message::TextDocument::Definition
end
class Solargraph::LanguageServer::Message::TextDocument::DidChange
end
class Solargraph::LanguageServer::Message::TextDocument::DidChange
end
class Solargraph::LanguageServer::Message::TextDocument::DidClose
end
class Solargraph::LanguageServer::Message::TextDocument::DidClose
end
class Solargraph::LanguageServer::Message::TextDocument::DidOpen
end
class Solargraph::LanguageServer::Message::TextDocument::DidOpen
end
class Solargraph::LanguageServer::Message::TextDocument::DidSave
end
class Solargraph::LanguageServer::Message::TextDocument::DidSave
end
class Solargraph::LanguageServer::Message::TextDocument::DocumentSymbol
include ::Solargraph::LanguageServer::UriHelpers
end
class Solargraph::LanguageServer::Message::TextDocument::DocumentSymbol
end
class Solargraph::LanguageServer::Message::TextDocument::FoldingRange
end
class Solargraph::LanguageServer::Message::TextDocument::FoldingRange
end
class Solargraph::LanguageServer::Message::TextDocument::Formatting
include ::Solargraph::Diagnostics::RubocopHelpers
end
class Solargraph::LanguageServer::Message::TextDocument::Formatting
end
class Solargraph::LanguageServer::Message::TextDocument::Hover
end
class Solargraph::LanguageServer::Message::TextDocument::Hover
end
class Solargraph::LanguageServer::Message::TextDocument::OnTypeFormatting
end
class Solargraph::LanguageServer::Message::TextDocument::OnTypeFormatting
end
class Solargraph::LanguageServer::Message::TextDocument::PrepareRename
end
class Solargraph::LanguageServer::Message::TextDocument::PrepareRename
end
class Solargraph::LanguageServer::Message::TextDocument::References
end
class Solargraph::LanguageServer::Message::TextDocument::References
end
class Solargraph::LanguageServer::Message::TextDocument::Rename
end
class Solargraph::LanguageServer::Message::TextDocument::Rename
end
class Solargraph::LanguageServer::Message::TextDocument::SignatureHelp
end
class Solargraph::LanguageServer::Message::TextDocument::SignatureHelp
end
module Solargraph::LanguageServer::Message::TextDocument
end
module Solargraph::LanguageServer::Message::Workspace
end
class Solargraph::LanguageServer::Message::Workspace::DidChangeConfiguration
end
class Solargraph::LanguageServer::Message::Workspace::DidChangeConfiguration
end
class Solargraph::LanguageServer::Message::Workspace::DidChangeWatchedFiles
include ::Solargraph::LanguageServer::UriHelpers
CHANGED = ::T.let(nil, ::T.untyped)
CREATED = ::T.let(nil, ::T.untyped)
DELETED = ::T.let(nil, ::T.untyped)
end
class Solargraph::LanguageServer::Message::Workspace::DidChangeWatchedFiles
end
class Solargraph::LanguageServer::Message::Workspace::DidChangeWorkspaceFolders
end
class Solargraph::LanguageServer::Message::Workspace::DidChangeWorkspaceFolders
end
class Solargraph::LanguageServer::Message::Workspace::WorkspaceSymbol
include ::Solargraph::LanguageServer::UriHelpers
end
class Solargraph::LanguageServer::Message::Workspace::WorkspaceSymbol
end
module Solargraph::LanguageServer::Message::Workspace
end
module Solargraph::LanguageServer::Message
def self.register(path, message_class); end
def self.select(path); end
end
module Solargraph::LanguageServer::MessageTypes
ERROR = ::T.let(nil, ::T.untyped)
INFO = ::T.let(nil, ::T.untyped)
LOG = ::T.let(nil, ::T.untyped)
WARNING = ::T.let(nil, ::T.untyped)
end
module Solargraph::LanguageServer::MessageTypes
end
class Solargraph::LanguageServer::Request
def initialize(id, &block); end
def process(result); end
def send_response(); end
end
class Solargraph::LanguageServer::Request
end
module Solargraph::LanguageServer::SymbolKinds
ARRAY = ::T.let(nil, ::T.untyped)
BOOLEAN = ::T.let(nil, ::T.untyped)
CLASS = ::T.let(nil, ::T.untyped)
CONSTANT = ::T.let(nil, ::T.untyped)
CONSTRUCTOR = ::T.let(nil, ::T.untyped)
ENUM = ::T.let(nil, ::T.untyped)
ENUM_MEMBER = ::T.let(nil, ::T.untyped)
EVENT = ::T.let(nil, ::T.untyped)
FIELD = ::T.let(nil, ::T.untyped)
FILE = ::T.let(nil, ::T.untyped)
FUNCTION = ::T.let(nil, ::T.untyped)
INTERFACE = ::T.let(nil, ::T.untyped)
KEY = ::T.let(nil, ::T.untyped)
METHOD = ::T.let(nil, ::T.untyped)
MODULE = ::T.let(nil, ::T.untyped)
NAMESPACE = ::T.let(nil, ::T.untyped)
NULL = ::T.let(nil, ::T.untyped)
NUMBER = ::T.let(nil, ::T.untyped)
OBJECT = ::T.let(nil, ::T.untyped)
OPERATOR = ::T.let(nil, ::T.untyped)
PACKAGE = ::T.let(nil, ::T.untyped)
PROPERTY = ::T.let(nil, ::T.untyped)
STRING = ::T.let(nil, ::T.untyped)
STRUCT = ::T.let(nil, ::T.untyped)
TYPE_PARAMETER = ::T.let(nil, ::T.untyped)
VARIABLE = ::T.let(nil, ::T.untyped)
end
module Solargraph::LanguageServer::SymbolKinds
end
module Solargraph::LanguageServer::Transport
end
module Solargraph::LanguageServer::Transport::Adapter
def closing(); end
def opening(); end
def receiving(data); end
def sending(data); end
def update(); end
end
module Solargraph::LanguageServer::Transport::Adapter
end
class Solargraph::LanguageServer::Transport::DataReader
def receive(data); end
def set_message_handler(&block); end
end
class Solargraph::LanguageServer::Transport::DataReader
end
module Solargraph::LanguageServer::Transport
end
module Solargraph::LanguageServer::UriHelpers
end
module Solargraph::LanguageServer::UriHelpers
def self.file_to_uri(file); end
def self.uri_to_file(uri); end
end
module Solargraph::LanguageServer
end
class Solargraph::Library
include ::Solargraph::Logging
def attach(source); end
def attached?(filename); end
def catalog(); end
def close(filename); end
def completions_at(filename, line, column); end
def contain?(filename); end
def create(filename, text); end
def create_from_disk(filename); end
def current(); end
def definitions_at(filename, line, column); end
def delete(filename); end
def detach(filename); end
def diagnose(filename); end
def document(query); end
def document_symbols(filename); end
def folding_ranges(filename); end
def get_path_pins(path); end
def initialize(workspace=T.unsafe(nil), name=T.unsafe(nil)); end
def locate_pins(location); end
def locate_ref(location); end
def merge(source); end
def name(); end
def open?(filename); end
def path_pins(path); end
def query_symbols(query); end
def read_text(filename); end
def references_from(filename, line, column, strip: T.unsafe(nil)); end
def search(query); end
def signatures_at(filename, line, column); end
def synchronized?(); end
def workspace(); end
end
class Solargraph::Library
def self.load(directory=T.unsafe(nil), name=T.unsafe(nil)); end
end
class Solargraph::Location
def ==(other); end
def filename(); end
def initialize(filename, range); end
def range(); end
def to_hash(); end
end
class Solargraph::Location
end
module Solargraph::Logging
DEFAULT_LOG_LEVEL = ::T.let(nil, ::T.untyped)
LOG_LEVELS = ::T.let(nil, ::T.untyped)
end
module Solargraph::Logging
def self.logger(); end
end
class Solargraph::Page
def initialize(directory=T.unsafe(nil)); end
def render(template, layout: T.unsafe(nil), locals: T.unsafe(nil)); end
end
class Solargraph::Page
def self.select_template(directories, name); end
end
module Solargraph::Pin
ROOT_PIN = ::T.let(nil, ::T.untyped)
end
class Solargraph::Pin::Attribute
def access(); end
def initialize(access: T.unsafe(nil), **splat); end
end
class Solargraph::Pin::Attribute
end
class Solargraph::Pin::Base
include ::Solargraph::Pin::Common
include ::Solargraph::Pin::Conversions
include ::Solargraph::Pin::Documenting
def ==(other); end
def code_object(); end
def completion_item_kind(); end
def deprecated?(); end
def directives(); end
def docstring(); end
def filename(); end
def identity(); end
def infer(api_map); end
def initialize(location: T.unsafe(nil), closure: T.unsafe(nil), name: T.unsafe(nil), comments: T.unsafe(nil)); end
def macros(); end
def maybe_directives?(); end
def nearly?(other); end
def probe(api_map); end
def probed=(probed); end
def probed?(); end
def proxied=(proxied); end
def proxied?(); end
def proxy(return_type); end
def realize(api_map); end
def return_type=(return_type); end
def symbol_kind(); end
def try_merge!(pin); end
def typify(api_map); end
def variable?(); end
end
class Solargraph::Pin::Base
end
class Solargraph::Pin::BaseMethod
def initialize(visibility: T.unsafe(nil), **splat); end
def parameter_names(); end
def parameters(); end
def visibility(); end
end
class Solargraph::Pin::BaseMethod
end
class Solargraph::Pin::BaseVariable
include ::Solargraph::Source::NodeMethods
def assignment(); end
def initialize(assignment: T.unsafe(nil), **splat); end
def nil_assignment?(); end
def signature(); end
end
class Solargraph::Pin::BaseVariable
end
class Solargraph::Pin::Block
def initialize(receiver: T.unsafe(nil), args: T.unsafe(nil), **splat); end
def parameter_names(); end
def parameters(); end
def rebind(context); end
def rebound?(); end
def receiver(); end
end
class Solargraph::Pin::Block
end
class Solargraph::Pin::ClassVariable
end
class Solargraph::Pin::ClassVariable
end
class Solargraph::Pin::Closure
def gates(); end
def initialize(scope: T.unsafe(nil), **splat); end
def scope(); end
end
class Solargraph::Pin::Closure
end
module Solargraph::Pin::Common
def binder(); end
def closure(); end
def comments(); end
def context(); end
def full_context(); end
def location(); end
def name(); end
def namespace(); end
def path(); end
def return_type(); end
end
module Solargraph::Pin::Common
end
class Solargraph::Pin::Constant
def initialize(visibility: T.unsafe(nil), **splat); end
def visibility(); end
end
class Solargraph::Pin::Constant
end
module Solargraph::Pin::Conversions
def completion_item(); end
def detail(); end
def link_documentation(); end
def reset_conversions(); end
def resolve_completion_item(); end
def signature_help(); end
def text_documentation(); end
end
module Solargraph::Pin::Conversions
end
module Solargraph::Pin::Documenting
def documentation(); end
end
module Solargraph::Pin::Documenting
end
class Solargraph::Pin::DuckMethod
end
class Solargraph::Pin::DuckMethod
end
class Solargraph::Pin::GlobalVariable
end
class Solargraph::Pin::GlobalVariable
end
class Solargraph::Pin::InstanceVariable
def scope(); end
end
class Solargraph::Pin::InstanceVariable
end
class Solargraph::Pin::Keyword
def initialize(name); end
end
class Solargraph::Pin::Keyword
end
class Solargraph::Pin::KeywordParam
end
class Solargraph::Pin::KeywordParam
end
class Solargraph::Pin::LocalVariable
include ::Solargraph::Pin::Localized
def initialize(assignment: T.unsafe(nil), presence: T.unsafe(nil), **splat); end
end
class Solargraph::Pin::LocalVariable
end
module Solargraph::Pin::Localized
def presence(); end
def visible_at?(other_loc); end
def visible_from?(other, position); end
end
module Solargraph::Pin::Localized
end
class Solargraph::Pin::Method
include ::Solargraph::Source::NodeMethods
def initialize(args: T.unsafe(nil), node: T.unsafe(nil), **splat); end
def node(); end
def overloads(); end
end
class Solargraph::Pin::Method
end
class Solargraph::Pin::MethodAlias
def initialize(scope: T.unsafe(nil), original: T.unsafe(nil), **splat); end
def original(); end
end
class Solargraph::Pin::MethodAlias
end
class Solargraph::Pin::Namespace
def domains(); end
def initialize(type: T.unsafe(nil), visibility: T.unsafe(nil), gates: T.unsafe(nil), **splat); end
def type(); end
def visibility(); end
end
class Solargraph::Pin::Namespace
end
class Solargraph::Pin::Parameter
def index(); end
end
class Solargraph::Pin::Parameter
end
class Solargraph::Pin::ProxyType
def initialize(return_type: T.unsafe(nil), **splat); end
end
class Solargraph::Pin::ProxyType
def self.anonymous(return_type); end
end
class Solargraph::Pin::Reference
end
class Solargraph::Pin::Reference
end
class Solargraph::Pin::Singleton
def initialize(name: T.unsafe(nil), location: T.unsafe(nil), closure: T.unsafe(nil)); end
end
class Solargraph::Pin::Singleton
end
class Solargraph::Pin::Symbol
def initialize(location, name); end
def visibility(); end
end
class Solargraph::Pin::Symbol
end
module Solargraph::Pin::YardPin
end
class Solargraph::Pin::YardPin::Constant
include ::Solargraph::Pin::YardPin::YardMixin
def initialize(code_object, closure=T.unsafe(nil), spec=T.unsafe(nil)); end
end
class Solargraph::Pin::YardPin::Constant
end
class Solargraph::Pin::YardPin::Method
include ::Solargraph::Pin::YardPin::YardMixin
def initialize(code_object, name=T.unsafe(nil), scope=T.unsafe(nil), visibility=T.unsafe(nil), closure=T.unsafe(nil), spec=T.unsafe(nil)); end
end
class Solargraph::Pin::YardPin::Method
end
class Solargraph::Pin::YardPin::Namespace
include ::Solargraph::Pin::YardPin::YardMixin
def initialize(code_object, spec); end
end
class Solargraph::Pin::YardPin::Namespace
end
module Solargraph::Pin::YardPin::YardMixin
def code_object(); end
def comments(); end
def location(); end
def spec(); end
end
module Solargraph::Pin::YardPin::YardMixin
end
module Solargraph::Pin::YardPin
end
module Solargraph::Pin
end
class Solargraph::Position
def ==(other); end
def character(); end
def column(); end
def initialize(line, character); end
def line(); end
def to_hash(); end
end
class Solargraph::Position
def self.from_offset(text, offset); end
def self.line_char_to_offset(text, line, character); end
def self.normalize(object); end
def self.to_offset(text, position); end
end
class Solargraph::Range
def ==(other); end
def contain?(position); end
def ending(); end
def include?(position); end
def initialize(start, ending); end
def start(); end
def to_hash(); end
end
class Solargraph::Range
def self.from_expr(expr); end
def self.from_node(node); end
def self.from_to(l1, c1, l2, c2); end
end
module Solargraph::ServerMethods
def available_port(); end
end
module Solargraph::ServerMethods
end
class Solargraph::Shell
include ::Solargraph::ServerMethods
def available_cores(); end
def bundle(); end
def clear(); end
def config(directory=T.unsafe(nil)); end
def download_core(version=T.unsafe(nil)); end
def list_cores(); end
def rdoc(gem, version=T.unsafe(nil)); end
def reporters(); end
def scan(); end
def socket(); end
def stdio(); end
def typecheck(*files); end
def uncache(*gems); end
def version(); end
end
class Solargraph::Shell
end
class Solargraph::Source
include ::Solargraph::Source::EncodingFixes
include ::Solargraph::Source::NodeMethods
def associated_comments(); end
def at(range); end
def code(); end
def code=(code); end
def code_for(node); end
def comment_at?(position); end
def comments(); end
def comments=(comments); end
def comments_for(node); end
def cursor_at(position); end
def error_ranges(); end
def error_ranges=(error_ranges); end
def filename(); end
def filename=(filename); end
def finish_synchronize(); end
def folding_ranges(); end
def from_to(l1, c1, l2, c2); end
def initialize(code, filename=T.unsafe(nil), version=T.unsafe(nil)); end
def last_updater(); end
def last_updater=(last_updater); end
def location(); end
def node(); end
def node=(node); end
def node_at(line, column); end
def parsed=(parsed); end
def parsed?(); end
def references(name); end
def repaired(); end
def repaired=(repaired); end
def repaired?(); end
def start_synchronize(updater); end
def string_at?(position); end
def synchronize(updater); end
def synchronized=(synchronized); end
def synchronized?(); end
def tree_at(line, column); end
def version(); end
def version=(version); end
FOLDING_NODE_TYPES = ::T.let(nil, ::T.untyped)
end
class Solargraph::Source::Chain
def base(); end
def constant?(); end
def define(api_map, name_pin, locals); end
def defined?(); end
def infer(api_map, name_pin, locals); end
def initialize(links); end
def links(); end
def literal?(); end
def undefined?(); end
UNDEFINED_CALL = ::T.let(nil, ::T.untyped)
UNDEFINED_CONSTANT = ::T.let(nil, ::T.untyped)
end
class Solargraph::Source::Chain::BlockVariable
end
class Solargraph::Source::Chain::BlockVariable
end
class Solargraph::Source::Chain::Call
def arguments(); end
def initialize(word, arguments=T.unsafe(nil), with_block=T.unsafe(nil)); end
def with_block?(); end
end
class Solargraph::Source::Chain::Call
end
class Solargraph::Source::Chain::ClassVariable
end
class Solargraph::Source::Chain::ClassVariable
end
class Solargraph::Source::Chain::Constant
def initialize(word); end
end
class Solargraph::Source::Chain::Constant
end
class Solargraph::Source::Chain::GlobalVariable
end
class Solargraph::Source::Chain::GlobalVariable
end
class Solargraph::Source::Chain::Head
end
class Solargraph::Source::Chain::Head
end
class Solargraph::Source::Chain::InstanceVariable
end
class Solargraph::Source::Chain::InstanceVariable
end
class Solargraph::Source::Chain::Link
def ==(other); end
def constant?(); end
def initialize(word=T.unsafe(nil)); end
def last_context(); end
def last_context=(last_context); end
def resolve(api_map, name_pin, locals); end
def undefined?(); end
def word(); end
end
class Solargraph::Source::Chain::Link
end
class Solargraph::Source::Chain::Literal
def initialize(type); end
end
class Solargraph::Source::Chain::Literal
end
class Solargraph::Source::Chain::Or
def initialize(links); end
end
class Solargraph::Source::Chain::Or
end
class Solargraph::Source::Chain::Variable
end
class Solargraph::Source::Chain::Variable
end
class Solargraph::Source::Chain
end
class Solargraph::Source::Change
include ::Solargraph::Source::EncodingFixes
def initialize(range, new_text); end
def new_text(); end
def range(); end
def repair(text); end
def write(text, nullable=T.unsafe(nil)); end
end
class Solargraph::Source::Change
end
class Solargraph::Source::Cursor
def argument?(); end
def chain(); end
def comment?(); end
def end_of_word(); end
def filename(); end
def initialize(source, position); end
def node(); end
def node_position(); end
def position(); end
def range(); end
def receiver(); end
def recipient(); end
def recipient_node(); end
def source(); end
def start_of_constant?(); end
def start_of_word(); end
def string?(); end
def word(); end
end
class Solargraph::Source::Cursor
end
module Solargraph::Source::EncodingFixes
end
module Solargraph::Source::EncodingFixes
def self.normalize(string); end
end
class Solargraph::Source::FlawedBuilder
end
class Solargraph::Source::FlawedBuilder
end
class Solargraph::Source::NodeChainer
include ::Solargraph::Source::NodeMethods
def chain(); end
def initialize(node, filename=T.unsafe(nil), in_block=T.unsafe(nil)); end
end
class Solargraph::Source::NodeChainer
def self.chain(node, filename=T.unsafe(nil), in_block=T.unsafe(nil)); end
def self.load_string(code); end
end
module Solargraph::Source::NodeMethods
NIL_NODE = ::T.let(nil, ::T.untyped)
end
module Solargraph::Source::NodeMethods
def self.const_from(node); end
def self.drill_signature(node, signature); end
def self.get_node_end_position(node); end
def self.get_node_start_position(node); end
def self.infer_literal_node_type(node); end
def self.pack_name(node); end
def self.resolve_node_signature(node); end
def self.returns_from(node); end
def self.unpack_name(node); end
end
class Solargraph::Source::SourceChainer
include ::Solargraph::Source::NodeMethods
def chain(); end
def initialize(source, position); end
end
class Solargraph::Source::SourceChainer
def self.chain(source, position); end
end
class Solargraph::Source::Updater
def changes(); end
def filename(); end
def initialize(filename, version, changes); end
def repair(text); end
def version(); end
def write(text, nullable=T.unsafe(nil)); end
end
class Solargraph::Source::Updater
end
class Solargraph::Source
def self.load(filename); end
def self.load_string(code, filename=T.unsafe(nil), version=T.unsafe(nil)); end
def self.parse(code, filename=T.unsafe(nil), line=T.unsafe(nil)); end
def self.parse_docstring(comments); end
def self.parse_with_comments(code, filename=T.unsafe(nil)); end
def self.parser(); end
end
class Solargraph::SourceMap
def code(); end
def cursor_at(position); end
def document_symbols(); end
def environ(); end
def filename(); end
def first_pin(path); end
def initialize(source, pins, locals); end
def locals(); end
def locals_at(location); end
def locate_block_pin(line, character); end
def locate_named_path_pin(line, character); end
def locate_pins(location); end
def pins(); end
def query_symbols(query); end
def references(name); end
def requires(); end
def source(); end
def try_merge!(other_map); end
end
class Solargraph::SourceMap::Clip
def complete(); end
def define(); end
def gates(); end
def in_block?(); end
def infer(); end
def initialize(api_map, cursor); end
def locals(); end
def signify(); end
end
class Solargraph::SourceMap::Clip
end
class Solargraph::SourceMap::Completion
def initialize(pins, range); end
def pins(); end
def range(); end
end
class Solargraph::SourceMap::Completion
end
class Solargraph::SourceMap::Mapper
include ::Solargraph::Source::NodeMethods
def closure_at(position); end
def find_directive_line_number(comment, tag, start); end
def map(source); end
def pins(); end
def process_comment(source_position, comment_position, comment); end
def process_comment_directives(); end
def process_directive(source_position, comment_position, directive); end
def remove_inline_comment_hashes(comment); end
def unmap(filename, code); end
MACRO_REGEXP = ::T.let(nil, ::T.untyped)
end
class Solargraph::SourceMap::Mapper
def self.map(source); end
end
module Solargraph::SourceMap::NodeProcessor
end
class Solargraph::SourceMap::NodeProcessor::AliasNode
end
class Solargraph::SourceMap::NodeProcessor::AliasNode
end
class Solargraph::SourceMap::NodeProcessor::ArgsNode
end
class Solargraph::SourceMap::NodeProcessor::ArgsNode
end
class Solargraph::SourceMap::NodeProcessor::Base
include ::Solargraph::Source::NodeMethods
def initialize(node, region, pins, locals); end
def locals(); end
def node(); end
def pins(); end
def process(); end
def region(); end
end
class Solargraph::SourceMap::NodeProcessor::Base
end
class Solargraph::SourceMap::NodeProcessor::BeginNode
end
class Solargraph::SourceMap::NodeProcessor::BeginNode
end
class Solargraph::SourceMap::NodeProcessor::BlockNode
end
class Solargraph::SourceMap::NodeProcessor::BlockNode
end
class Solargraph::SourceMap::NodeProcessor::CasgnNode
end
class Solargraph::SourceMap::NodeProcessor::CasgnNode
end
class Solargraph::SourceMap::NodeProcessor::CvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::CvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::DefNode
end
class Solargraph::SourceMap::NodeProcessor::DefNode
end
class Solargraph::SourceMap::NodeProcessor::DefsNode
end
class Solargraph::SourceMap::NodeProcessor::DefsNode
end
class Solargraph::SourceMap::NodeProcessor::GvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::GvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::IvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::IvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::LvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::LvasgnNode
end
class Solargraph::SourceMap::NodeProcessor::NamespaceNode
end
class Solargraph::SourceMap::NodeProcessor::NamespaceNode
end
class Solargraph::SourceMap::NodeProcessor::OrasgnNode
end
class Solargraph::SourceMap::NodeProcessor::OrasgnNode
end
class Solargraph::SourceMap::NodeProcessor::ResbodyNode
end
class Solargraph::SourceMap::NodeProcessor::ResbodyNode
end
class Solargraph::SourceMap::NodeProcessor::SclassNode
end
class Solargraph::SourceMap::NodeProcessor::SclassNode
end
class Solargraph::SourceMap::NodeProcessor::SendNode
end
class Solargraph::SourceMap::NodeProcessor::SendNode
end
class Solargraph::SourceMap::NodeProcessor::SymNode
end
class Solargraph::SourceMap::NodeProcessor::SymNode
end
module Solargraph::SourceMap::NodeProcessor
def self.process(node, region=T.unsafe(nil), pins=T.unsafe(nil), locals=T.unsafe(nil)); end
end
class Solargraph::SourceMap::Region
def closure(); end
def code_for(node); end
def filename(); end
def initialize(source: T.unsafe(nil), closure: T.unsafe(nil), scope: T.unsafe(nil), visibility: T.unsafe(nil)); end
def scope(); end
def source(); end
def update(closure: T.unsafe(nil), scope: T.unsafe(nil), visibility: T.unsafe(nil)); end
def visibility(); end
end
class Solargraph::SourceMap::Region
end
class Solargraph::SourceMap
def self.load(filename); end
def self.load_string(code, filename=T.unsafe(nil)); end
def self.map(source); end
end
class Solargraph::SourceNotAvailableError
end
class Solargraph::SourceNotAvailableError
end
class Solargraph::TypeChecker
def filename(); end
def initialize(filename, api_map: T.unsafe(nil)); end
def param_type_problems(); end
def return_type_problems(); end
def strict_type_problems(); end
end
class Solargraph::TypeChecker::ParamDef
def initialize(name, type); end
def name(); end
def type(); end
end
class Solargraph::TypeChecker::ParamDef
def self.from(pin); end
end
class Solargraph::TypeChecker::Problem
def initialize(location, message, pin: T.unsafe(nil), suggestion: T.unsafe(nil)); end
def location(); end
def message(); end
def pin(); end
def suggestion(); end
end
class Solargraph::TypeChecker::Problem
end
class Solargraph::TypeChecker
def self.load(filename); end
def self.load_string(code, filename=T.unsafe(nil)); end
end
class Solargraph::Workspace
def config(); end
def directory(); end
def filenames(); end
def gemspec?(); end
def gemspecs(); end
def has_file?(filename); end
def initialize(directory=T.unsafe(nil), config=T.unsafe(nil)); end
def merge(source); end
def remove(filename); end
def require_paths(); end
def source(filename); end
def sources(); end
def synchronize!(updater); end
def would_merge?(filename); end
def would_require?(path); end
end
class Solargraph::Workspace::Config
def allow?(filename); end
def calculated(); end
def directory(); end
def domains(); end
def excluded(); end
def included(); end
def initialize(directory=T.unsafe(nil)); end
def max_files(); end
def raw_data(); end
def reporters(); end
def require_paths(); end
def required(); end
MAX_FILES = ::T.let(nil, ::T.untyped)
end
class Solargraph::Workspace::Config
end
class Solargraph::Workspace
end
class Solargraph::WorkspaceTooLargeError
end
class Solargraph::WorkspaceTooLargeError
end
class Solargraph::YardMap
def change(new_requires, new_gemset); end
def core_pins(); end
def gemset(); end
def initialize(required: T.unsafe(nil), gemset: T.unsafe(nil), with_dependencies: T.unsafe(nil)); end
def load_yardoc(y); end
def path_pin(path); end
def pins(); end
def require_reference(path); end
def required(); end
def unresolved_requires(); end
def with_dependencies=(with_dependencies); end
def with_dependencies?(); end
def yardocs(); end
end
class Solargraph::YardMap::Cache
def get_path_pins(path); end
def set_path_pins(path, pins); end
end
class Solargraph::YardMap::Cache
end
module Solargraph::YardMap::CoreDocs
DEFAULT = ::T.let(nil, ::T.untyped)
SOURCE = ::T.let(nil, ::T.untyped)
end
module Solargraph::YardMap::CoreDocs
def self.available(); end
def self.best_download(current=T.unsafe(nil)); end
def self.best_match(); end
def self.cache_dir(); end
def self.clear(); end
def self.download(version); end
def self.require_minimum(); end
def self.valid?(ver); end
def self.versions(); end
def self.yardoc_file(ver=T.unsafe(nil)); end
def self.yardoc_stdlib_file(ver=T.unsafe(nil)); end
end
module Solargraph::YardMap::CoreGen
end
module Solargraph::YardMap::CoreGen
def self.generate_docs(ruby_dir, dest_dir); end
def self.generate_gzip(ruby_dir, ver_name=T.unsafe(nil), dest_dir=T.unsafe(nil)); end
end
class Solargraph::YardMap::Mapper
def generate_pins(code_object); end
def initialize(code_objects, spec=T.unsafe(nil)); end
def map(); end
end
class Solargraph::YardMap::Mapper
end
module Solargraph::YardMap::RdocToYard
end
module Solargraph::YardMap::RdocToYard
extend ::Solargraph::ApiMap::SourceToYard
def self.base_name(mod); end
def self.commentary(cmnt); end
def self.find_file(obj); end
def self.locate(obj); end
def self.run(spec); end
end
class Solargraph::YardMap
end
module Solargraph
def self.logger(); end
end
class Sorbet::Private::ConstantLookupCache
def all_module_aliases(); end
def all_module_names(); end
def all_named_modules(); end
def class_by_name(name); end
def name_by_class(klass); end
DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::ConstantLookupCache::ConstantEntry
def aliases(); end
def aliases=(_); end
def const(); end
def const=(_); end
def const_name(); end
def const_name=(_); end
def found_name(); end
def found_name=(_); end
def owner(); end
def owner=(_); end
def primary_name(); end
def primary_name=(_); end
end
class Sorbet::Private::ConstantLookupCache::ConstantEntry
def self.[](*_); end
def self.members(); end
end
class Sorbet::Private::ConstantLookupCache
end
class Sorbet::Private::CreateConfig
include ::Sorbet::Private::StepInterface
SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped)
SORBET_DIR = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::CreateConfig
def self.main(); end
def self.output_file(); end
end
class Sorbet::Private::FetchRBIs
include ::Sorbet::Private::StepInterface
HEADER = ::T.let(nil, ::T.untyped)
RBI_CACHE_DIR = ::T.let(nil, ::T.untyped)
SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped)
SORBET_DIR = ::T.let(nil, ::T.untyped)
SORBET_RBI_LIST = ::T.let(nil, ::T.untyped)
SORBET_RBI_SORBET_TYPED = ::T.let(nil, ::T.untyped)
SORBET_TYPED_REPO = ::T.let(nil, ::T.untyped)
SORBET_TYPED_REVISION = ::T.let(nil, ::T.untyped)
XDG_CACHE_HOME = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::FetchRBIs
def self.fetch_sorbet_typed(); end
def self.main(); end
def self.matching_version_directories(root, version); end
def self.output_file(); end
def self.paths_for_gem_version(gemspec); end
def self.paths_for_ruby_version(ruby_version); end
def self.vendor_rbis_within_paths(vendor_paths); end
end
class Sorbet::Private::FindGemRBIs
include ::Sorbet::Private::StepInterface
GEM_DIR = ::T.let(nil, ::T.untyped)
HEADER = ::T.let(nil, ::T.untyped)
RBI_CACHE_DIR = ::T.let(nil, ::T.untyped)
XDG_CACHE_HOME = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::FindGemRBIs
def self.main(); end
def self.output_file(); end
def self.paths_within_gem_sources(gemspec); end
end
module Sorbet::Private::GemGeneratorTracepoint
include ::Sorbet::Private::StepInterface
OUTPUT = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
def defs(); end
def defs=(_); end
def id(); end
def id=(_); end
def klass(); end
def klass=(_); end
end
class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
def self.[](*_); end
def self.members(); end
end
class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
def initialize(files:, delegate_classes:); end
def serialize(output_dir); end
BAD_METHODS = ::T.let(nil, ::T.untyped)
HEADER = ::T.let(nil, ::T.untyped)
SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
end
class Sorbet::Private::GemGeneratorTracepoint::Tracer
end
class Sorbet::Private::GemGeneratorTracepoint::Tracer
def self.add_to_context(item); end
def self.disable_tracepoints(); end
def self.finish(); end
def self.install_tracepoints(); end
def self.on_method_added(mod, method, singleton); end
def self.on_module_created(mod); end
def self.on_module_extended(extended, extender); end
def self.on_module_included(included, includer); end
def self.pre_cache_module_methods(); end
def self.register_delegate_class(klass, delegate); end
def self.start(); end
def self.trace(); end
def self.trace_results(); end
end
module Sorbet::Private::GemGeneratorTracepoint
def self.main(output_dir=T.unsafe(nil)); end
def self.output_file(); end
end
class Sorbet::Private::GemLoader
GEM_LOADER = ::T.let(nil, ::T.untyped)
NO_GEM = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::GemLoader
def self.my_require(gem); end
def self.require_all_gems(); end
def self.require_gem(gem); end
end
class Sorbet::Private::HiddenMethodFinder
include ::Sorbet::Private::StepInterface
def all_modules_and_aliases(); end
def capture_stderr(); end
def constant_cache(); end
def gen_source_rbi(classes, aliases); end
def looks_like_stub_name(name); end
def main(); end
def mk_dir(); end
def read_constants(); end
def real_name(mod); end
def require_everything(); end
def rm_dir(); end
def serialize_alias(source_entry, rbi_entry, my_klass, source_symbols, rbi_symbols); end
def serialize_class(source_entry, rbi_entry, klass, source_symbols, rbi_symbols, source_by_name); end
def serialize_constants(source, rbi, klass, is_singleton, source_symbols, rbi_symbols); end
def symbols_id_to_name(entry, prefix); end
def write_constants(); end
def write_diff(source, rbi); end
BLACKLIST = ::T.let(nil, ::T.untyped)
DIFF_RBI = ::T.let(nil, ::T.untyped)
ERRORS_RBI = ::T.let(nil, ::T.untyped)
HEADER = ::T.let(nil, ::T.untyped)
HIDDEN_RBI = ::T.let(nil, ::T.untyped)
PATH = ::T.let(nil, ::T.untyped)
RBI_CONSTANTS = ::T.let(nil, ::T.untyped)
RBI_CONSTANTS_ERR = ::T.let(nil, ::T.untyped)
SOURCE_CONSTANTS = ::T.let(nil, ::T.untyped)
SOURCE_CONSTANTS_ERR = ::T.let(nil, ::T.untyped)
TMP_PATH = ::T.let(nil, ::T.untyped)
TMP_RBI = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::HiddenMethodFinder
def self.main(); end
def self.output_file(); end
end
module Sorbet::Private::Main
end
module Sorbet::Private::Main
def self.cyan(msg); end
def self.emojify(emoji, msg); end
def self.init(); end
def self.main(argv); end
def self.make_step(step); end
def self.usage(); end
def self.yellow(msg); end
end
module Sorbet::Private::RealStdlib
end
module Sorbet::Private::RealStdlib
def self.real_ancestors(mod); end
def self.real_autoload?(o, klass); end
def self.real_const_get(obj, const, arg); end
def self.real_constants(mod); end
def self.real_eqeq(obj, other); end
def self.real_hash(o); end
def self.real_instance_methods(mod, arg); end
def self.real_is_a?(o, klass); end
def self.real_method(obj, sym); end
def self.real_name(o); end
def self.real_object_id(o); end
def self.real_private_instance_methods(mod, arg); end
def self.real_singleton_class(obj); end
def self.real_singleton_methods(mod, arg); end
def self.real_spaceship(obj, arg); end
def self.real_superclass(o); end
end
class Sorbet::Private::RequireEverything
end
class Sorbet::Private::RequireEverything
def self.excluded_rails_files(); end
def self.load_bundler(); end
def self.load_rails(); end
def self.my_require(abs_path, numerator, denominator); end
def self.patch_kernel(); end
def self.rails?(); end
def self.rails_load_paths(); end
def self.rb_file_paths(); end
def self.require_all_files(); end
def self.require_everything(); end
end
class Sorbet::Private::Serialize
def alias(base, other_name); end
def ancestor_has_method(method, klass); end
def blacklisted_method(method); end
def class_or_module(class_name); end
def comparable?(value); end
def constant(const, value); end
def from_method(method); end
def initialize(constant_cache); end
def serialize_method(method, static=T.unsafe(nil), with_sig: T.unsafe(nil)); end
def serialize_sig(parameters); end
def to_sig(kind, name); end
def valid_class_name(name); end
def valid_method_name(name); end
BLACKLIST_CONSTANTS = ::T.let(nil, ::T.untyped)
KEYWORDS = ::T.let(nil, ::T.untyped)
SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::Serialize
def self.header(typed=T.unsafe(nil), subcommand=T.unsafe(nil)); end
end
module Sorbet::Private::Status
end
module Sorbet::Private::Status
def self.done(); end
def self.say(message, print_without_tty: T.unsafe(nil)); end
end
module Sorbet::Private::StepInterface
end
module Sorbet::Private::StepInterface
def self.main(); end
def self.output_file(); end
end
class Sorbet::Private::SuggestTyped
include ::Sorbet::Private::StepInterface
end
class Sorbet::Private::SuggestTyped
def self.main(); end
def self.output_file(); end
def self.suggest_typed(); end
end
class Sorbet::Private::TodoRBI
include ::Sorbet::Private::StepInterface
HEADER = ::T.let(nil, ::T.untyped)
OUTPUT = ::T.let(nil, ::T.untyped)
end
class Sorbet::Private::TodoRBI
def self.main(); end
def self.output_file(); end
end
class SortedSet
def initialize(*args, &block); end
end
class SortedSet
def self.setup(); end
end
class StopIteration
def result(); end
end
class String
include ::JSON::Ext::Generator::GeneratorMethods::String
def []=(*_); end
def blank?(); end
def casecmp?(_); end
def each_grapheme_cluster(); end
def encode!(*_); end
def ext(newext=T.unsafe(nil)); end
def grapheme_clusters(); end
def pathmap(spec=T.unsafe(nil), &block); end
def pathmap_explode(); end
def pathmap_partial(n); end
def pathmap_replace(patterns, &block); end
def reverse!(); end
def shell_split(); end
def shellescape(); end
def shellsplit(); end
def succ!(); end
def undump(); end
def unicode_normalize(*_); end
def unicode_normalize!(*_); end
def unicode_normalized?(*_); end
def unpack1(_); end
end
class String
extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
end
class StringIO
def length(); end
def truncate(_); end
end
class StringScanner
def <<(_); end
def [](_); end
def beginning_of_line?(); end
def bol?(); end
def captures(); end
def charpos(); end
def check(_); end
def check_until(_); end
def clear(); end
def concat(_); end
def empty?(); end
def exist?(_); end
def get_byte(); end
def getbyte(); end
def initialize(*_); end
def match?(_); end
def matched(); end
def matched?(); end
def matched_size(); end
def peek(_); end
def peep(_); end
def pointer(); end
def pointer=(pointer); end
def pos(); end
def pos=(pos); end
def post_match(); end
def pre_match(); end
def reset(); end
def rest(); end
def rest?(); end
def rest_size(); end
def restsize(); end
def scan_full(_, _1, _2); end
def scan_until(_); end
def search_full(_, _1, _2); end
def size(); end
def skip(_); end
def skip_until(_); end
def string(); end
def string=(string); end
def terminate(); end
def unscan(); end
def values_at(*_); end
Id = ::T.let(nil, ::T.untyped)
Version = ::T.let(nil, ::T.untyped)
end
class StringScanner
def self.must_C_version(); end
end
class Struct
def [](_); end
def []=(_, _1); end
def dig(*_); end
def each_pair(); end
def filter(*_); end
def length(); end
def members(); end
def select(*_); end
def size(); end
def to_a(); end
def to_h(); end
def values(); end
def values_at(*_); end
end
Struct::Group = Etc::Group
class Struct::HTMLElementDescription
def attrs_depr(); end
def attrs_depr=(_); end
def attrs_opt(); end
def attrs_opt=(_); end
def attrs_req(); end
def attrs_req=(_); end
def defaultsubelt(); end
def defaultsubelt=(_); end
def depr(); end
def depr=(_); end
def desc(); end
def desc=(_); end
def dtd(); end
def dtd=(_); end
def empty(); end
def empty=(_); end
def endTag(); end
def endTag=(_); end
def isinline(); end
def isinline=(_); end
def name(); end
def name=(_); end
def saveEndTag(); end
def saveEndTag=(_); end
def startTag(); end
def startTag=(_); end
def subelts(); end
def subelts=(_); end
end
class Struct::HTMLElementDescription
def self.[](*_); end
def self.members(); end
end
Struct::Passwd = Etc::Passwd
Struct::Tms = Process::Tms
class SystemCallError
def errno(); end
end
class SystemExit
def status(); end
def success?(); end
end
class Tempfile
def _close(); end
def inspect(); end
end
class Tempfile::Remover
def call(*args); end
def initialize(tmpfile); end
end
class Tempfile::Remover
end
class Thor
include ::Thor::Base
include ::Thor::Invocation
include ::Thor::Shell
def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end
Correctable = ::T.let(nil, ::T.untyped)
HELP_MAPPINGS = ::T.let(nil, ::T.untyped)
TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped)
THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end
module Thor::Base
def args(); end
def args=(args); end
def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end
def options(); end
def options=(options); end
def parent_options(); end
def parent_options=(parent_options); end
end
module Thor::Base
def self.included(base); end
def self.register_klass_file(klass); end
def self.shell(); end
def self.shell=(shell); end
def self.subclass_files(); end
def self.subclasses(); end
end
module Thor::Invocation
def _parse_initialization_options(args, opts, config); end
def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end
def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end
def _shared_configuration(); end
def current_command_chain(); end
def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end
def invoke(name=T.unsafe(nil), *args); end
def invoke_all(); end
def invoke_command(command, *args); end
def invoke_task(command, *args); end
def invoke_with_padding(*args); end
end
module Thor::Invocation
def self.included(base); end
end
module Thor::Shell
def _shared_configuration(); end
def ask(*args, &block); end
def error(*args, &block); end
def file_collision(*args, &block); end
def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
def no?(*args, &block); end
def print_in_columns(*args, &block); end
def print_table(*args, &block); end
def print_wrapped(*args, &block); end
def say(*args, &block); end
def say_status(*args, &block); end
def set_color(*args, &block); end
def shell(); end
def shell=(shell); end
def terminal_width(*args, &block); end
def with_padding(); end
def yes?(*args, &block); end
SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped)
end
module Thor::Shell
end
class Thor
def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def self.check_unknown_options!(options=T.unsafe(nil)); end
def self.command_help(shell, command_name); end
def self.default_command(meth=T.unsafe(nil)); end
def self.default_task(meth=T.unsafe(nil)); end
def self.desc(usage, description, options=T.unsafe(nil)); end
def self.disable_required_check(); end
def self.disable_required_check!(*command_names); end
def self.disable_required_check?(command); end
def self.dispatch(meth, given_args, given_opts, config); end
def self.dynamic_command_class(); end
def self.find_command_possibilities(meth); end
def self.find_task_possibilities(meth); end
def self.help(shell, subcommand=T.unsafe(nil)); end
def self.long_desc(long_description, options=T.unsafe(nil)); end
def self.map(mappings=T.unsafe(nil)); end
def self.method_option(name, options=T.unsafe(nil)); end
def self.method_options(options=T.unsafe(nil)); end
def self.normalize_command_name(meth); end
def self.normalize_task_name(meth); end
def self.option(name, options=T.unsafe(nil)); end
def self.options(options=T.unsafe(nil)); end
def self.package_name(name, _=T.unsafe(nil)); end
def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end
def self.retrieve_command_name(args); end
def self.retrieve_task_name(args); end
def self.stop_on_unknown_option(); end
def self.stop_on_unknown_option!(*command_names); end
def self.stop_on_unknown_option?(command); end
def self.subcommand(subcommand, subcommand_class); end
def self.subcommand_classes(); end
def self.subcommand_help(cmd); end
def self.subcommands(); end
def self.subtask(subcommand, subcommand_class); end
def self.subtask_help(cmd); end
def self.subtasks(); end
def self.task_help(shell, command_name); end
end
class TracePoint
def __enable(_, _1); end
def eval_script(); end
def event(); end
def instruction_sequence(); end
def parameters(); end
end
class TrueClass
include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
end
module URI
include ::URI::RFC2396_REGEXP
end
module URI::Escape
def decode(*arg); end
def encode(*arg); end
def escape(*arg); end
def unescape(*arg); end
end
class URI::FTP
def set_typecode(v); end
def typecode(); end
def typecode=(typecode); end
end
class URI::FTP
def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
end
class URI::File
def check_password(user); end
def check_user(user); end
def check_userinfo(user); end
def set_userinfo(v); end
COMPONENT = ::T.let(nil, ::T.untyped)
DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end
class URI::File
end
class URI::LDAP
def attributes(); end
def attributes=(val); end
def dn(); end
def dn=(val); end
def extensions(); end
def extensions=(val); end
def filter(); end
def filter=(val); end
def initialize(*arg); end
def scope(); end
def scope=(val); end
def set_attributes(val); end
def set_dn(val); end
def set_extensions(val); end
def set_filter(val); end
def set_scope(val); end
end
class URI::MailTo
def headers(); end
def headers=(v); end
def initialize(*arg); end
def set_headers(v); end
def set_to(v); end
def to(); end
def to=(v); end
def to_mailtext(); end
def to_rfc822text(); end
end
URI::Parser = URI::RFC2396_Parser
URI::REGEXP = URI::RFC2396_REGEXP
class URI::RFC2396_Parser
def escape(str, unsafe=T.unsafe(nil)); end
def extract(str, schemes=T.unsafe(nil)); end
def initialize(opts=T.unsafe(nil)); end
def join(*uris); end
def make_regexp(schemes=T.unsafe(nil)); end
def parse(uri); end
def pattern(); end
def regexp(); end
def split(uri); end
def unescape(str, escaped=T.unsafe(nil)); end
end
class URI::RFC3986_Parser
def join(*uris); end
def parse(uri); end
def regexp(); end
def split(uri); end
RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
end
module URI::Util
def self.make_components_hash(klass, array_hash); end
end
module URI
extend ::URI::Escape
def self.get_encoding(label); end
end
class UnboundMethod
def clone(); end
def original_name(); end
end
class UncaughtThrowError
def tag(); end
def value(); end
end
module Unicode
end
module Unicode::DisplayWidth
DATA_DIRECTORY = ::T.let(nil, ::T.untyped)
DEPTHS = ::T.let(nil, ::T.untyped)
INDEX = ::T.let(nil, ::T.untyped)
INDEX_FILENAME = ::T.let(nil, ::T.untyped)
NO_STRING_EXT = ::T.let(nil, ::T.untyped)
UNICODE_VERSION = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
module Unicode::DisplayWidth
def self.emoji_extra_width_of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), _=T.unsafe(nil)); end
def self.of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), options=T.unsafe(nil)); end
end
module Unicode
end
module UnicodeNormalize
end
module UnicodeNormalize
end
Visitor = Psych::Visitors::Visitor
module Warning
def warn(_); end
end
module Warning
extend ::Warning
end
YAML = Psych
YAMLTree = Psych::Visitors::YAMLTree
module Zlib
ASCII = ::T.let(nil, ::T.untyped)
BEST_COMPRESSION = ::T.let(nil, ::T.untyped)
BEST_SPEED = ::T.let(nil, ::T.untyped)
BINARY = ::T.let(nil, ::T.untyped)
DEFAULT_COMPRESSION = ::T.let(nil, ::T.untyped)
DEFAULT_STRATEGY = ::T.let(nil, ::T.untyped)
DEF_MEM_LEVEL = ::T.let(nil, ::T.untyped)
FILTERED = ::T.let(nil, ::T.untyped)
FINISH = ::T.let(nil, ::T.untyped)
FIXED = ::T.let(nil, ::T.untyped)
FULL_FLUSH = ::T.let(nil, ::T.untyped)
HUFFMAN_ONLY = ::T.let(nil, ::T.untyped)
MAX_MEM_LEVEL = ::T.let(nil, ::T.untyped)
MAX_WBITS = ::T.let(nil, ::T.untyped)
NO_COMPRESSION = ::T.let(nil, ::T.untyped)
NO_FLUSH = ::T.let(nil, ::T.untyped)
OS_AMIGA = ::T.let(nil, ::T.untyped)
OS_ATARI = ::T.let(nil, ::T.untyped)
OS_CODE = ::T.let(nil, ::T.untyped)
OS_CPM = ::T.let(nil, ::T.untyped)
OS_MACOS = ::T.let(nil, ::T.untyped)
OS_MSDOS = ::T.let(nil, ::T.untyped)
OS_OS2 = ::T.let(nil, ::T.untyped)
OS_QDOS = ::T.let(nil, ::T.untyped)
OS_RISCOS = ::T.let(nil, ::T.untyped)
OS_TOPS20 = ::T.let(nil, ::T.untyped)
OS_UNIX = ::T.let(nil, ::T.untyped)
OS_UNKNOWN = ::T.let(nil, ::T.untyped)
OS_VMCMS = ::T.let(nil, ::T.untyped)
OS_VMS = ::T.let(nil, ::T.untyped)
OS_WIN32 = ::T.let(nil, ::T.untyped)
OS_ZSYSTEM = ::T.let(nil, ::T.untyped)
RLE = ::T.let(nil, ::T.untyped)
SYNC_FLUSH = ::T.let(nil, ::T.untyped)
TEXT = ::T.let(nil, ::T.untyped)
UNKNOWN = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
ZLIB_VERSION = ::T.let(nil, ::T.untyped)
end
class Zlib::BufError
end
class Zlib::BufError
end
class Zlib::DataError
end
class Zlib::DataError
end
class Zlib::Deflate
def <<(_); end
def deflate(*_); end
def flush(*_); end
def initialize(*_); end
def params(_, _1); end
def set_dictionary(_); end
end
class Zlib::Deflate
def self.deflate(*_); end
end
class Zlib::Error
end
class Zlib::Error
end
class Zlib::GzipFile
def close(); end
def closed?(); end
def comment(); end
def crc(); end
def finish(); end
def level(); end
def mtime(); end
def orig_name(); end
def os_code(); end
def sync(); end
def sync=(sync); end
def to_io(); end
end
class Zlib::GzipFile::CRCError
end
class Zlib::GzipFile::CRCError
end
class Zlib::GzipFile::Error
def input(); end
end
class Zlib::GzipFile::Error
end
class Zlib::GzipFile::LengthError
end
class Zlib::GzipFile::LengthError
end
class Zlib::GzipFile::NoFooter
end
class Zlib::GzipFile::NoFooter
end
class Zlib::GzipFile
def self.wrap(*_); end
end
class Zlib::GzipReader
include ::Enumerable
def bytes(); end
def each(*_, &blk); end
def each_byte(); end
def each_char(); end
def each_line(*_); end
def eof(); end
def eof?(); end
def external_encoding(); end
def getbyte(); end
def getc(); end
def initialize(*_); end
def lineno(); end
def lineno=(lineno); end
def lines(*_); end
def pos(); end
def read(*_); end
def readbyte(); end
def readchar(); end
def readpartial(*_); end
def rewind(); end
def tell(); end
def ungetbyte(_); end
def ungetc(_); end
def unused(); end
end
class Zlib::GzipReader
end
class Zlib::GzipWriter
def <<(_); end
def comment=(comment); end
def flush(*_); end
def initialize(*_); end
def mtime=(mtime); end
def orig_name=(orig_name); end
def pos(); end
def tell(); end
def write(*_); end
end
class Zlib::GzipWriter
end
class Zlib::Inflate
def <<(_); end
def add_dictionary(_); end
def inflate(_); end
def initialize(*_); end
def set_dictionary(_); end
def sync(_); end
def sync_point?(); end
end
class Zlib::Inflate
def self.inflate(_); end
end
class Zlib::MemError
end
class Zlib::MemError
end
class Zlib::NeedDict
end
class Zlib::NeedDict
end
class Zlib::StreamEnd
end
class Zlib::StreamEnd
end
class Zlib::StreamError
end
class Zlib::StreamError
end
class Zlib::VersionError
end
class Zlib::VersionError
end
class Zlib::ZStream
def adler(); end
def avail_in(); end
def avail_out(); end
def avail_out=(avail_out); end
def close(); end
def closed?(); end
def data_type(); end
def end(); end
def ended?(); end
def finish(); end
def finished?(); end
def flush_next_in(); end
def flush_next_out(); end
def reset(); end
def stream_end?(); end
def total_in(); end
def total_out(); end
end
class Zlib::ZStream
end
module Zlib
def self.adler32(*_); end
def self.adler32_combine(_, _1, _2); end
def self.crc32(*_); end
def self.crc32_combine(_, _1, _2); end
def self.crc_table(); end
def self.deflate(*_); end
def self.gunzip(_); end
def self.gzip(*_); end
def self.inflate(_); end
def self.zlib_version(); end
end