From 466c2dc34d461b10fa2763087e9e47faaa924383 Mon Sep 17 00:00:00 2001 From: Connor Shea <connor.james.shea@gmail.com> Date: Thu, 1 Aug 2019 21:30:03 -0600 Subject: [PATCH 1/6] Add a basic gem.rbi to lib/ruby. --- lib/ruby/all/gem.rbi | 6345 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6345 insertions(+) create mode 100644 lib/ruby/all/gem.rbi diff --git a/lib/ruby/all/gem.rbi b/lib/ruby/all/gem.rbi new file mode 100644 index 00000000..3803c6d7 --- /dev/null +++ b/lib/ruby/all/gem.rbi @@ -0,0 +1,6345 @@ +# typed: strong +module Gem + ConfigMap = T.let(nil, T.untyped) + RbConfigPriorities = T.let(nil, T.untyped) + RubyGemsPackageVersion = T.let(nil, T.untyped) + RubyGemsVersion = T.let(nil, T.untyped) + USE_BUNDLER_FOR_GEMDEPS = T.let(nil, T.untyped) + + sig { params(path: T.untyped).returns(T.untyped) } + def self._deprecated_detect_gemdeps(path = T.unsafe(nil)); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self._deprecated_gunzip(data); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self._deprecated_gzip(data); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self._deprecated_inflate(data); end + + sig { params(name: T.untyped, args: T.untyped).returns(T.untyped) } + def self.activate_bin_path(name, *args); end + + sig { params(base_dir: T.untyped).returns(T.untyped) } + def self.default_ext_dir_for(base_dir); end + + sig { returns(T::Boolean) } + def self.default_gems_use_full_paths?; end + + sig { returns(T.untyped) } + def self.default_spec_cache_dir; end + + sig { params(data: T.untyped).returns(T.untyped) } + def self.deflate(data); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def self.detect_gemdeps(*args, &block); end + + sig { returns(T.untyped) } + def self.dir; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.done_installing(&hook); end + + sig { returns(T.untyped) } + def self.done_installing_hooks; end + + sig { params(dir: T.untyped, mode: T.untyped).returns(T.untyped) } + def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil); end + + sig { params(dir: T.untyped, mode: T.untyped).returns(T.untyped) } + def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil); end + + sig { params(dir: T.untyped, mode: T.untyped, subdirs: T.untyped).returns(T.untyped) } + def self.ensure_subdirectories(dir, mode, subdirs); end + + sig { params(gem_name: T.untyped).returns(T.untyped) } + def self.env_requirement(gem_name); end + + sig { returns(T.untyped) } + def self.extension_api_version; end + + sig { params(glob: T.untyped, check_load_path: T.untyped).returns(T.untyped) } + def self.find_files(glob, check_load_path = true); end + + sig { params(glob: T.untyped).returns(T.untyped) } + def self.find_files_from_load_path(glob); end + + sig { params(glob: T.untyped, check_load_path: T.untyped).returns(T.untyped) } + def self.find_latest_files(glob, check_load_path = T.unsafe(nil)); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.find_unresolved_default_spec(path); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.finish_resolve(*_); end + + sig { returns(T.untyped) } + def self.gemdeps; end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def self.gunzip(*args, &block); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def self.gzip(*args, &block); end + + sig { returns(T.untyped) } + def self.host; end + + sig { params(host: T.untyped).returns(T.untyped) } + def self.host=(host); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def self.inflate(*args, &block); end + + sig { params(name: T.untyped, version: T.untyped, options: T.untyped).returns(T.untyped) } + def self.install(name, version = T.unsafe(nil), *options); end + + sig { returns(T.untyped) } + def self.install_extension_in_lib; end + + sig { returns(T.untyped) } + def self.latest_rubygems_version; end + + sig { params(name: T.untyped).returns(T.untyped) } + def self.latest_spec_for(name); end + + sig { params(name: T.untyped).returns(T.untyped) } + def self.latest_version_for(name); end + + sig { returns(T.untyped) } + def self.load_env_plugins; end + + sig { returns(T.untyped) } + def self.load_path_insert_index; end + + sig { params(plugins: T.untyped).returns(T.untyped) } + def self.load_plugin_files(plugins); end + + sig { returns(T.untyped) } + def self.load_plugins; end + + sig { returns(T.untyped) } + def self.load_yaml; end + + sig { returns(T.untyped) } + def self.loaded_specs; end + + sig { params(depth: T.untyped).returns(T.untyped) } + def self.location_of_caller(depth = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.marshal_version; end + + sig { returns(T.untyped) } + def self.needs; end + + sig { returns(T.untyped) } + def self.operating_system_defaults; end + + sig { returns(T.untyped) } + def self.path; end + + sig { returns(T.untyped) } + def self.path_separator; end + + sig { returns(T.untyped) } + def self.paths; end + + sig { params(env: T.untyped).returns(T.untyped) } + def self.paths=(env); end + + sig { returns(T.untyped) } + def self.platform_defaults; end + + sig { returns(T.untyped) } + def self.platforms; end + + sig { params(platforms: T.untyped).returns(T.untyped) } + def self.platforms=(platforms); end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.post_build(&hook); end + + sig { returns(T.untyped) } + def self.post_build_hooks; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.post_install(&hook); end + + sig { returns(T.untyped) } + def self.post_install_hooks; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.post_reset(&hook); end + + sig { returns(T.untyped) } + def self.post_reset_hooks; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.post_uninstall(&hook); end + + sig { returns(T.untyped) } + def self.post_uninstall_hooks; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.pre_install(&hook); end + + sig { returns(T.untyped) } + def self.pre_install_hooks; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.pre_reset(&hook); end + + sig { returns(T.untyped) } + def self.pre_reset_hooks; end + + sig { params(hook: T.untyped).returns(T.untyped) } + def self.pre_uninstall(&hook); end + + sig { returns(T.untyped) } + def self.pre_uninstall_hooks; end + + sig { returns(T.untyped) } + def self.prefix; end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.read_binary(path); end + + sig { returns(T.untyped) } + def self.refresh; end + + sig { params(spec: T.untyped).returns(T.untyped) } + def self.register_default_spec(spec); end + + sig { params(spec: T.untyped).returns(T.untyped) } + def self.remove_unresolved_default_spec(spec); end + + sig { returns(T.untyped) } + def self.ruby; end + + sig { returns(T.untyped) } + def self.ruby_api_version; end + + sig { returns(T.untyped) } + def self.ruby_engine; end + + sig { returns(T.untyped) } + def self.ruby_version; end + + sig { returns(T.untyped) } + def self.rubygems_version; end + + sig { returns(T.untyped) } + def self.sources; end + + sig { params(new_sources: T.untyped).returns(T.untyped) } + def self.sources=(new_sources); end + + sig { returns(T.untyped) } + def self.spec_cache_dir; end + + sig { returns(T.untyped) } + def self.suffix_pattern; end + + sig { returns(T.untyped) } + def self.suffixes; end + + sig { params(msg: T.untyped, width: T.untyped, display: T.untyped).returns(T.untyped) } + def self.time(msg, width = T.unsafe(nil), display = T.unsafe(nil)); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.try_activate(path); end + + sig { returns(T.untyped) } + def self.ui; end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.use_gemdeps(path = T.unsafe(nil)); end + + sig { params(home: T.untyped, paths: T.untyped).returns(T.untyped) } + def self.use_paths(home, *paths); end + + sig { returns(T.untyped) } + def self.user_dir; end + + sig { returns(T.untyped) } + def self.user_home; end + + sig { returns(T.untyped) } + def self.vendor_dir; end + + sig { returns(T::Boolean) } + def self.win_platform?; end + + sig { params(path: T.untyped, data: T.untyped).returns(T.untyped) } + def self.write_binary(path, data); end + + class AvailableSet + include Enumerable + + sig { params(o: T.untyped).returns(T.untyped) } + def <<(o); end + + sig { params(spec: T.untyped, source: T.untyped).returns(T.untyped) } + def add(spec, source); end + + sig { returns(T.untyped) } + def all_specs; end + + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { returns(T.untyped) } + def each_spec; end + + sig { returns(T::Boolean) } + def empty?; end + + sig { params(req: T.untyped).returns(T.untyped) } + def find_all(req); end + + sig { params(dep_list: T.untyped).returns(T.untyped) } + def inject_into_list(dep_list); end + + sig { returns(T.untyped) } + def match_platform!; end + + sig { returns(T.untyped) } + def pick_best!; end + + sig { params(reqs: T.untyped).returns(T.untyped) } + def prefetch(reqs); end + + sig { returns(T.untyped) } + def remote; end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { params(dep: T.untyped).returns(T.untyped) } + def remove_installed!(dep); end + + sig { returns(T.untyped) } + def set; end + + sig { returns(T.untyped) } + def size; end + + sig { returns(T.untyped) } + def sorted; end + + sig { params(spec: T.untyped).returns(T.untyped) } + def source_for(spec); end + + sig { params(development: T.untyped).returns(T.untyped) } + def to_request_set(development = T.unsafe(nil)); end + + class Tuple + sig { returns(T.untyped) } + def source; end + + sig { params(_: T.untyped).returns(T.untyped) } + def source=(_); end + + sig { returns(T.untyped) } + def spec; end + + sig { params(_: T.untyped).returns(T.untyped) } + def spec=(_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.[](*_); end + + sig { returns(T.untyped) } + def self.members; end + end + end + + class BasicSpecification + sig { returns(T::Boolean) } + def activated?; end + + sig { returns(T.untyped) } + def base_dir; end + + sig { params(base_dir: T.untyped).returns(T.untyped) } + def base_dir=(base_dir); end + + sig { params(file: T.untyped).returns(T::Boolean) } + def contains_requirable_file?(file); end + + sig { returns(T.untyped) } + def datadir; end + + sig { returns(T::Boolean) } + def default_gem?; end + + sig { returns(T.untyped) } + def extension_dir; end + + sig { params(extension_dir: T.untyped).returns(T.untyped) } + def extension_dir=(extension_dir); end + + sig { returns(T.untyped) } + def extensions_dir; end + + sig { returns(T.untyped) } + def full_gem_path; end + + sig { params(full_gem_path: T.untyped).returns(T.untyped) } + def full_gem_path=(full_gem_path); end + + sig { returns(T.untyped) } + def full_name; end + + sig { returns(T.untyped) } + def full_require_paths; end + + sig { returns(T.untyped) } + def gem_build_complete_path; end + + sig { returns(T.untyped) } + def gem_dir; end + + sig { returns(T.untyped) } + def gems_dir; end + + sig { params(ignored: T.untyped).returns(T.untyped) } + def ignored=(ignored); end + + sig { returns(T.untyped) } + def internal_init; end + + sig { returns(T.untyped) } + def lib_dirs_glob; end + + sig { returns(T.untyped) } + def loaded_from; end + + sig { params(loaded_from: T.untyped).returns(T.untyped) } + def loaded_from=(loaded_from); end + + sig { params(glob: T.untyped).returns(T.untyped) } + def matches_for_glob(glob); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def platform; end + + sig { returns(T.untyped) } + def raw_require_paths; end + + sig { returns(T.untyped) } + def require_paths; end + + sig { returns(T.untyped) } + def source_paths; end + + sig { returns(T::Boolean) } + def stubbed?; end + + sig { returns(T.untyped) } + def this; end + + sig { params(path: T.untyped).returns(T.untyped) } + def to_fullpath(path); end + + sig { returns(T.untyped) } + def to_spec; end + + sig { returns(T.untyped) } + def version; end + + sig { returns(T.untyped) } + def self.default_specifications_dir; end + end + + module BundlerVersionFinder + sig { returns(T.untyped) } + def self.bundler_version; end + + sig { returns(T.untyped) } + def self.bundler_version_with_reason; end + + sig { params(spec: T.untyped).returns(T::Boolean) } + def self.compatible?(spec); end + + sig { params(specs: T.untyped).returns(T.untyped) } + def self.filter!(specs); end + + sig { returns(T.untyped) } + def self.missing_version_message; end + end + + class Command + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + HELP = T.let(nil, T.untyped) + + sig { params(args: T.untyped).returns(T.untyped) } + def add_extra_args(args); end + + sig { params(opts: T.untyped, handler: T.untyped).returns(T.untyped) } + def add_option(*opts, &handler); end + + sig { returns(T.untyped) } + def arguments; end + + sig { params(long: T.untyped, short: T.untyped).returns(T::Boolean) } + def begins?(long, short); end + + sig { returns(T.untyped) } + def command; end + + sig { returns(T.untyped) } + def defaults; end + + sig { params(defaults: T.untyped).returns(T.untyped) } + def defaults=(defaults); end + + sig { returns(T.untyped) } + def defaults_str; end + + sig { returns(T.untyped) } + def description; end + + sig { returns(T.untyped) } + def execute; end + + sig { returns(T.untyped) } + def get_all_gem_names; end + + sig { returns(T.untyped) } + def get_all_gem_names_and_versions; end + + sig { returns(T.untyped) } + def get_one_gem_name; end + + sig { returns(T.untyped) } + def get_one_optional_argument; end + + sig { params(args: T.untyped).returns(T.untyped) } + def handle_options(args); end + + sig { params(args: T.untyped).returns(T::Boolean) } + def handles?(args); end + + sig { params(command: T.untyped, summary: T.untyped, defaults: T.untyped).returns(Command) } + def initialize(command, summary = T.unsafe(nil), defaults = T.unsafe(nil)); end + + sig { params(args: T.untyped).returns(T.untyped) } + def invoke(*args); end + + sig { params(args: T.untyped, build_args: T.untyped).returns(T.untyped) } + def invoke_with_build_args(args, build_args); end + + sig { params(new_options: T.untyped).returns(T.untyped) } + def merge_options(new_options); end + + sig { returns(T.untyped) } + def options; end + + sig { returns(T.untyped) } + def program_name; end + + sig { params(program_name: T.untyped).returns(T.untyped) } + def program_name=(program_name); end + + sig { params(name: T.untyped).returns(T.untyped) } + def remove_option(name); end + + sig { returns(T.untyped) } + def show_help; end + + sig do + params( + gem_name: T.untyped, + version: T.untyped, + errors: T.untyped, + domain: T.untyped, + required_by: T.untyped + ).returns(T.untyped) + end + def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def summary; end + + sig { params(summary: T.untyped).returns(T.untyped) } + def summary=(summary); end + + sig { returns(T.untyped) } + def usage; end + + sig { params(block: T.untyped).returns(T.untyped) } + def when_invoked(&block); end + + sig { params(args: T.untyped, handler: T.untyped).returns(T.untyped) } + def self.add_common_option(*args, &handler); end + + sig { params(cmd: T.untyped, args: T.untyped).returns(T.untyped) } + def self.add_specific_extra_args(cmd, args); end + + sig { returns(T.untyped) } + def self.build_args; end + + sig { params(value: T.untyped).returns(T.untyped) } + def self.build_args=(value); end + + sig { returns(T.untyped) } + def self.common_options; end + + sig { returns(T.untyped) } + def self.extra_args; end + + sig { params(value: T.untyped).returns(T.untyped) } + def self.extra_args=(value); end + + sig { params(cmd: T.untyped).returns(T.untyped) } + def self.specific_extra_args(cmd); end + + sig { returns(T.untyped) } + def self.specific_extra_args_hash; end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + module Commands + end + + class ConfigFile + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + DEFAULT_BACKTRACE = T.let(nil, T.untyped) + DEFAULT_BULK_THRESHOLD = T.let(nil, T.untyped) + DEFAULT_CERT_EXPIRATION_LENGTH_DAYS = T.let(nil, T.untyped) + DEFAULT_CONCURRENT_DOWNLOADS = T.let(nil, T.untyped) + DEFAULT_UPDATE_SOURCES = T.let(nil, T.untyped) + DEFAULT_VERBOSITY = T.let(nil, T.untyped) + OPERATING_SYSTEM_DEFAULTS = T.let(nil, T.untyped) + PLATFORM_DEFAULTS = T.let(nil, T.untyped) + SYSTEM_CONFIG_PATH = T.let(nil, T.untyped) + SYSTEM_WIDE_CONFIG_FILE = T.let(nil, T.untyped) + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(key: T.untyped).returns(T.untyped) } + def [](key); end + + sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) } + def []=(key, value); end + + sig { returns(T.untyped) } + def api_keys; end + + sig { returns(T.untyped) } + def args; end + + sig { returns(T.untyped) } + def backtrace; end + + sig { params(backtrace: T.untyped).returns(T.untyped) } + def backtrace=(backtrace); end + + sig { returns(T.untyped) } + def bulk_threshold; end + + sig { params(bulk_threshold: T.untyped).returns(T.untyped) } + def bulk_threshold=(bulk_threshold); end + + sig { returns(T.untyped) } + def cert_expiration_length_days; end + + sig { params(cert_expiration_length_days: T.untyped).returns(T.untyped) } + def cert_expiration_length_days=(cert_expiration_length_days); end + + sig { returns(T.untyped) } + def check_credentials_permissions; end + + sig { returns(T.untyped) } + def concurrent_downloads; end + + sig { params(concurrent_downloads: T.untyped).returns(T.untyped) } + def concurrent_downloads=(concurrent_downloads); end + + sig { returns(T.untyped) } + def config_file_name; end + + sig { returns(T.untyped) } + def credentials_path; end + + sig { returns(T.untyped) } + def disable_default_gem_server; end + + sig { params(disable_default_gem_server: T.untyped).returns(T.untyped) } + def disable_default_gem_server=(disable_default_gem_server); end + + sig { params(block: T.untyped).returns(T.untyped) } + def each(&block); end + + sig { params(arg_list: T.untyped).returns(T.untyped) } + def handle_arguments(arg_list); end + + sig { returns(T.untyped) } + def home; end + + sig { params(home: T.untyped).returns(T.untyped) } + def home=(home); end + + sig { params(args: T.untyped).returns(ConfigFile) } + def initialize(args); end + + sig { returns(T.untyped) } + def load_api_keys; end + + sig { params(filename: T.untyped).returns(T.untyped) } + def load_file(filename); end + + sig { returns(T.untyped) } + def path; end + + sig { params(path: T.untyped).returns(T.untyped) } + def path=(path); end + + sig { returns(T.untyped) } + def really_verbose; end + + sig { returns(T.untyped) } + def rubygems_api_key; end + + sig { params(api_key: T.untyped).returns(T.untyped) } + def rubygems_api_key=(api_key); end + + sig { params(host: T.untyped, api_key: T.untyped).returns(T.untyped) } + def set_api_key(host, api_key); end + + sig { returns(T.untyped) } + def sources; end + + sig { params(sources: T.untyped).returns(T.untyped) } + def sources=(sources); end + + sig { returns(T.untyped) } + def ssl_ca_cert; end + + sig { params(ssl_ca_cert: T.untyped).returns(T.untyped) } + def ssl_ca_cert=(ssl_ca_cert); end + + sig { returns(T.untyped) } + def ssl_client_cert; end + + sig { returns(T.untyped) } + def ssl_verify_mode; end + + sig { returns(T.untyped) } + def to_yaml; end + + sig { returns(T.untyped) } + def unset_api_key!; end + + sig { returns(T.untyped) } + def update_sources; end + + sig { params(update_sources: T.untyped).returns(T.untyped) } + def update_sources=(update_sources); end + + sig { returns(T.untyped) } + def verbose; end + + sig { params(verbose: T.untyped).returns(T.untyped) } + def verbose=(verbose); end + + sig { returns(T.untyped) } + def write; end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + end + + class ConflictError + sig { returns(T.untyped) } + def conflicts; end + + sig { params(target: T.untyped, conflicts: T.untyped).returns(ConflictError) } + def initialize(target, conflicts); end + + sig { returns(T.untyped) } + def target; end + end + + class ConsoleUI + sig { returns(ConsoleUI) } + def initialize; end + end + + module DefaultUserInteraction + include Gem::Text + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { returns(T.untyped) } + def self.ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def self.ui=(new_ui); end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def self.use_ui(new_ui); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + end + + class Dependency + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(other: T.untyped).returns(T.untyped) } + def ===(other); end + + sig { params(other: T.untyped).returns(T.untyped) } + def =~(other); end + + sig { returns(T.untyped) } + def all_sources; end + + sig { params(all_sources: T.untyped).returns(T.untyped) } + def all_sources=(all_sources); end + + sig { params(coder: T.untyped).returns(T.untyped) } + def encode_with(coder); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { returns(T.untyped) } + def groups; end + + sig { params(groups: T.untyped).returns(T.untyped) } + def groups=(groups); end + + sig { params(name: T.untyped, requirements: T.untyped).returns(Dependency) } + def initialize(name, *requirements); end + + sig { returns(T::Boolean) } + def latest_version?; end + + sig { params(obj: T.untyped, version: T.untyped, allow_prerelease: T.untyped).returns(T::Boolean) } + def match?(obj, version = T.unsafe(nil), allow_prerelease = T.unsafe(nil)); end + + sig { params(spec: T.untyped).returns(T::Boolean) } + def matches_spec?(spec); end + + sig { params(platform_only: T.untyped).returns(T.untyped) } + def matching_specs(platform_only = T.unsafe(nil)); end + + sig { params(other: T.untyped).returns(T.untyped) } + def merge(other); end + + sig { returns(T.untyped) } + def name; end + + sig { params(name: T.untyped).returns(T.untyped) } + def name=(name); end + + sig { params(prerelease: T.untyped).returns(T.untyped) } + def prerelease=(prerelease); end + + sig { returns(T::Boolean) } + def prerelease?; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def requirement; end + + sig { returns(T.untyped) } + def requirements_list; end + + sig { returns(T::Boolean) } + def runtime?; end + + sig { returns(T.untyped) } + def source; end + + sig { params(source: T.untyped).returns(T.untyped) } + def source=(source); end + + sig { returns(T::Boolean) } + def specific?; end + + sig { returns(T.untyped) } + def to_lock; end + + sig { returns(T.untyped) } + def to_spec; end + + sig { returns(T.untyped) } + def to_specs; end + + sig { returns(T.untyped) } + def to_yaml_properties; end + + sig { returns(T.untyped) } + def type; end + end + + class DependencyInstaller + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + extend Gem::Deprecate + DEFAULT_OPTIONS = T.let(nil, T.untyped) + + sig { params(to_do: T.untyped, dependency_list: T.untyped).returns(T.untyped) } + def _deprecated_add_found_dependencies(to_do, dependency_list); end + + sig { returns(T.untyped) } + def _deprecated_gather_dependencies; end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def add_found_dependencies(*args, &block); end + + sig { params(dep_or_name: T.untyped, version: T.untyped).returns(T.untyped) } + def available_set_for(dep_or_name, version); end + + sig { returns(T::Boolean) } + def consider_local?; end + + sig { returns(T::Boolean) } + def consider_remote?; end + + sig { returns(T.untyped) } + def document; end + + sig { returns(T.untyped) } + def errors; end + + sig { params(dep: T.untyped, best_only: T.untyped).returns(T.untyped) } + def find_gems_with_sources(dep, best_only = T.unsafe(nil)); end + + sig { params(gem_name: T.untyped, version: T.untyped, prerelease: T.untyped).returns(T.untyped) } + def find_spec_by_name_and_version(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def gather_dependencies(*args, &block); end + + sig { params(what: T.untyped).returns(T.untyped) } + def in_background(what); end + + sig { params(options: T.untyped).returns(DependencyInstaller) } + def initialize(options = T.unsafe(nil)); end + + sig { params(dep_or_name: T.untyped, version: T.untyped).returns(T.untyped) } + def install(dep_or_name, version = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def install_development_deps; end + + sig { returns(T.untyped) } + def installed_gems; end + + sig { params(dep_or_name: T.untyped, version: T.untyped).returns(T.untyped) } + def resolve_dependencies(dep_or_name, version); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class DependencyList + include Enumerable + include TSort + + sig { params(gemspecs: T.untyped).returns(T.untyped) } + def add(*gemspecs); end + + sig { returns(T.untyped) } + def clear; end + + sig { returns(T.untyped) } + def dependency_order; end + + sig { returns(T.untyped) } + def development; end + + sig { params(development: T.untyped).returns(T.untyped) } + def development=(development); end + + sig { params(block: T.untyped).returns(T.untyped) } + def each(&block); end + + sig { params(full_name: T.untyped).returns(T.untyped) } + def find_name(full_name); end + + sig { params(development: T.untyped).returns(DependencyList) } + def initialize(development = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def ok?; end + + sig { params(full_name: T.untyped, check_dev: T.untyped).returns(T::Boolean) } + def ok_to_remove?(full_name, check_dev = T.unsafe(nil)); end + + sig { params(full_name: T.untyped).returns(T.untyped) } + def remove_by_name(full_name); end + + sig { params(dependencies: T.untyped).returns(T.untyped) } + def remove_specs_unsatisfied_by(dependencies); end + + sig { returns(T.untyped) } + def spec_predecessors; end + + sig { returns(T.untyped) } + def specs; end + + sig { params(block: T.untyped).returns(T.untyped) } + def tsort_each_node(&block); end + + sig { params(quick: T.untyped).returns(T::Boolean) } + def why_not_ok?(quick = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.from_specs; end + end + + class DependencyResolutionError + sig { returns(T.untyped) } + def conflict; end + + sig { returns(T.untyped) } + def conflicting_dependencies; end + + sig { params(conflict: T.untyped).returns(DependencyResolutionError) } + def initialize(conflict); end + end + + module Deprecate + sig do + params( + name: T.untyped, + repl: T.untyped, + year: T.untyped, + month: T.untyped + ).returns(T.untyped) + end + def self.deprecate(name, repl, year, month); end + + sig { returns(T.untyped) } + def self.skip; end + + sig { params(v: T.untyped).returns(T.untyped) } + def self.skip=(v); end + + sig { returns(T.untyped) } + def self.skip_during; end + end + + class Exception + extend Gem::Deprecate + + sig { returns(T.untyped) } + def _deprecated_source_exception; end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def source_exception(*args, &block); end + + sig { params(source_exception: T.untyped).returns(T.untyped) } + def source_exception=(source_exception); end + end + + module Ext + class BuildError + end + + class Builder + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + CHDIR_MONITOR = T.let(nil, T.untyped) + CHDIR_MUTEX = T.let(nil, T.untyped) + + sig { returns(T.untyped) } + def build_args; end + + sig { params(build_args: T.untyped).returns(T.untyped) } + def build_args=(build_args); end + + sig { params(build_dir: T.untyped, output: T.untyped, backtrace: T.untyped).returns(T.untyped) } + def build_error(build_dir, output, backtrace = T.unsafe(nil)); end + + sig { params(extension: T.untyped, dest_path: T.untyped).returns(T.untyped) } + def build_extension(extension, dest_path); end + + sig { returns(T.untyped) } + def build_extensions; end + + sig { params(extension: T.untyped).returns(T.untyped) } + def builder_for(extension); end + + sig { params(spec: T.untyped, build_args: T.untyped).returns(Builder) } + def initialize(spec, build_args = T.unsafe(nil)); end + + sig { params(output: T.untyped).returns(T.untyped) } + def write_gem_make_out(output); end + + sig { returns(T.untyped) } + def self.class_name; end + + sig { params(dest_path: T.untyped, results: T.untyped).returns(T.untyped) } + def self.make(dest_path, results); end + + sig { returns(T.untyped) } + def self.redirector; end + + sig { params(command: T.untyped, results: T.untyped, command_name: T.untyped).returns(T.untyped) } + def self.run(command, results, command_name = T.unsafe(nil)); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class CmakeBuilder + sig do + params( + extension: T.untyped, + dest_path: T.untyped, + results: T.untyped, + args: T.untyped, + lib_dir: T.untyped + ).returns(T.untyped) + end + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + end + + class ConfigureBuilder + sig do + params( + extension: T.untyped, + dest_path: T.untyped, + results: T.untyped, + args: T.untyped, + lib_dir: T.untyped + ).returns(T.untyped) + end + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + end + + class ExtConfBuilder + sig do + params( + extension: T.untyped, + dest_path: T.untyped, + results: T.untyped, + args: T.untyped, + lib_dir: T.untyped + ).returns(T.untyped) + end + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.get_relative_path(path); end + end + + class RakeBuilder + sig do + params( + extension: T.untyped, + dest_path: T.untyped, + results: T.untyped, + args: T.untyped, + lib_dir: T.untyped + ).returns(T.untyped) + end + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + end + end + + class FilePermissionError + sig { returns(T.untyped) } + def directory; end + + sig { params(directory: T.untyped).returns(FilePermissionError) } + def initialize(directory); end + end + + class FormatException + sig { returns(T.untyped) } + def file_path; end + + sig { params(file_path: T.untyped).returns(T.untyped) } + def file_path=(file_path); end + end + + class GemNotInHomeException + sig { returns(T.untyped) } + def spec; end + + sig { params(spec: T.untyped).returns(T.untyped) } + def spec=(spec); end + end + + class ImpossibleDependenciesError + sig { returns(T.untyped) } + def build_message; end + + sig { returns(T.untyped) } + def conflicts; end + + sig { returns(T.untyped) } + def dependency; end + + sig { params(request: T.untyped, conflicts: T.untyped).returns(ImpossibleDependenciesError) } + def initialize(request, conflicts); end + + sig { returns(T.untyped) } + def request; end + end + + class Installer + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + extend Gem::Deprecate + ENV_PATHS = T.let(nil, T.untyped) + + sig { params(build_dir: T.untyped, output: T.untyped, backtrace: T.untyped).returns(T.untyped) } + def _deprecated_extension_build_error(build_dir, output, backtrace = T.unsafe(nil)); end + + sig { params(bin_file_name: T.untyped).returns(T.untyped) } + def app_script_text(bin_file_name); end + + sig { returns(T.untyped) } + def bin_dir; end + + sig { returns(T.untyped) } + def build_extensions; end + + sig { returns(T.untyped) } + def build_root; end + + sig { params(filename: T.untyped).returns(T.untyped) } + def check_executable_overwrite(filename); end + + sig { returns(T.untyped) } + def check_that_user_bin_dir_is_in_path; end + + sig { returns(T.untyped) } + def default_spec_file; end + + sig { returns(T.untyped) } + def dir; end + + sig { returns(T.untyped) } + def ensure_dependencies_met; end + + sig { params(spec: T.untyped, dependency: T.untyped).returns(T.untyped) } + def ensure_dependency(spec, dependency); end + + sig { returns(T.untyped) } + def ensure_loadable_spec; end + + sig { returns(T.untyped) } + def ensure_required_ruby_version_met; end + + sig { returns(T.untyped) } + def ensure_required_rubygems_version_met; end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def extension_build_error(*args, &block); end + + sig { returns(T.untyped) } + def extract_bin; end + + sig { returns(T.untyped) } + def extract_files; end + + sig { params(filename: T.untyped).returns(T.untyped) } + def formatted_program_filename(filename); end + + sig { returns(T.untyped) } + def gem; end + + sig { returns(T.untyped) } + def gem_dir; end + + sig { returns(T.untyped) } + def gem_home; end + + sig { returns(T.untyped) } + def generate_bin; end + + sig { params(filename: T.untyped, bindir: T.untyped).returns(T.untyped) } + def generate_bin_script(filename, bindir); end + + sig { params(filename: T.untyped, bindir: T.untyped).returns(T.untyped) } + def generate_bin_symlink(filename, bindir); end + + sig { params(filename: T.untyped, bindir: T.untyped).returns(T.untyped) } + def generate_windows_script(filename, bindir); end + + sig { params(package: T.untyped, options: T.untyped).returns(Installer) } + def initialize(package, options = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def install; end + + sig { params(dependency: T.untyped).returns(T::Boolean) } + def installation_satisfies_dependency?(dependency); end + + sig { returns(T.untyped) } + def installed_specs; end + + sig { returns(T.untyped) } + def options; end + + sig { returns(T.untyped) } + def pre_install_checks; end + + sig { returns(T.untyped) } + def process_options; end + + sig { returns(T.untyped) } + def run_post_build_hooks; end + + sig { returns(T.untyped) } + def run_post_install_hooks; end + + sig { returns(T.untyped) } + def run_pre_install_hooks; end + + sig { params(bin_file_name: T.untyped).returns(T.untyped) } + def shebang(bin_file_name); end + + sig { returns(T.untyped) } + def spec; end + + sig { returns(T.untyped) } + def spec_file; end + + sig { params(directory: T.untyped).returns(T.untyped) } + def unpack(directory); end + + sig { params(unpack: T.untyped).returns(T.untyped) } + def verify_gem_home(unpack = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def verify_spec; end + + sig { params(bindir: T.untyped, bin_file_name: T.untyped).returns(T.untyped) } + def windows_stub_script(bindir, bin_file_name); end + + sig { returns(T.untyped) } + def write_build_info_file; end + + sig { returns(T.untyped) } + def write_cache_file; end + + sig { returns(T.untyped) } + def write_default_spec; end + + sig { returns(T.untyped) } + def write_spec; end + + sig { params(path: T.untyped, options: T.untyped).returns(T.untyped) } + def self.at(path, options = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.exec_format; end + + sig { params(exec_format: T.untyped).returns(T.untyped) } + def self.exec_format=(exec_format); end + + sig { params(spec: T.untyped, options: T.untyped).returns(T.untyped) } + def self.for_spec(spec, options = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.install_lock; end + + sig { returns(T.untyped) } + def self.path_warning; end + + sig { params(path_warning: T.untyped).returns(T.untyped) } + def self.path_warning=(path_warning); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class Licenses + extend Gem::Text + EXCEPTION_IDENTIFIERS = T.let(nil, T.untyped) + LICENSE_IDENTIFIERS = T.let(nil, T.untyped) + NONSTANDARD = T.let(nil, T.untyped) + REGEXP = T.let(nil, T.untyped) + + sig { params(license: T.untyped).returns(T::Boolean) } + def self.match?(license); end + + sig { params(license: T.untyped).returns(T.untyped) } + def self.suggestions(license); end + + sig { params(text: T.untyped).returns(T.untyped) } + def self.clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def self.format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def self.levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def self.min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def self.truncate_text(text, description, max_length = T.unsafe(nil)); end + end + + class List + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { params(value: T.untyped, tail: T.untyped).returns(List) } + def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end + + sig { params(value: T.untyped).returns(T.untyped) } + def prepend(value); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def tail; end + + sig { params(tail: T.untyped).returns(T.untyped) } + def tail=(tail); end + + sig { returns(T.untyped) } + def to_a; end + + sig { returns(T.untyped) } + def value; end + + sig { params(value: T.untyped).returns(T.untyped) } + def value=(value); end + + sig { params(list: T.untyped, value: T.untyped).returns(T.untyped) } + def self.prepend(list, value); end + end + + class LoadError + sig { returns(T.untyped) } + def name; end + + sig { params(name: T.untyped).returns(T.untyped) } + def name=(name); end + + sig { returns(T.untyped) } + def requirement; end + + sig { params(requirement: T.untyped).returns(T.untyped) } + def requirement=(requirement); end + end + + class MissingSpecError + sig { params(name: T.untyped, requirement: T.untyped).returns(MissingSpecError) } + def initialize(name, requirement); end + end + + class MissingSpecVersionError + sig { params(name: T.untyped, requirement: T.untyped, specs: T.untyped).returns(MissingSpecVersionError) } + def initialize(name, requirement, specs); end + + sig { returns(T.untyped) } + def specs; end + end + + class NameTuple + include Comparable + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { returns(T.untyped) } + def full_name; end + + sig { params(name: T.untyped, version: T.untyped, platform: T.untyped).returns(NameTuple) } + def initialize(name, version, platform = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def match_platform?; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def platform; end + + sig { returns(T::Boolean) } + def prerelease?; end + + sig { returns(T.untyped) } + def spec_name; end + + sig { returns(T.untyped) } + def to_a; end + + sig { returns(T.untyped) } + def version; end + + sig { params(list: T.untyped).returns(T.untyped) } + def self.from_list(list); end + + sig { returns(T.untyped) } + def self.null; end + + sig { params(list: T.untyped).returns(T.untyped) } + def self.to_basic(list); end + end + + class Package + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + sig { params(tar: T.untyped).returns(T.untyped) } + def add_checksums(tar); end + + sig { params(tar: T.untyped).returns(T.untyped) } + def add_contents(tar); end + + sig { params(tar: T.untyped).returns(T.untyped) } + def add_files(tar); end + + sig { params(tar: T.untyped).returns(T.untyped) } + def add_metadata(tar); end + + sig { params(skip_validation: T.untyped, strict_validation: T.untyped).returns(T.untyped) } + def build(skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def build_time; end + + sig { params(build_time: T.untyped).returns(T.untyped) } + def build_time=(build_time); end + + sig { returns(T.untyped) } + def checksums; end + + sig { returns(T.untyped) } + def contents; end + + sig { params(path: T.untyped).returns(T.untyped) } + def copy_to(path); end + + sig { returns(T.untyped) } + def data_mode; end + + sig { params(data_mode: T.untyped).returns(T.untyped) } + def data_mode=(data_mode); end + + sig { params(entry: T.untyped).returns(T.untyped) } + def digest(entry); end + + sig { returns(T.untyped) } + def dir_mode; end + + sig { params(dir_mode: T.untyped).returns(T.untyped) } + def dir_mode=(dir_mode); end + + sig { params(destination_dir: T.untyped, pattern: T.untyped).returns(T.untyped) } + def extract_files(destination_dir, pattern = T.unsafe(nil)); end + + sig { params(io: T.untyped, destination_dir: T.untyped, pattern: T.untyped).returns(T.untyped) } + def extract_tar_gz(io, destination_dir, pattern = T.unsafe(nil)); end + + sig { params(mode: T.untyped).returns(T.untyped) } + def file_mode(mode); end + + sig { returns(T.untyped) } + def files; end + + sig { params(io: T.untyped).returns(T.untyped) } + def gzip_to(io); end + + sig { params(gem: T.untyped, security_policy: T.untyped).returns(Package) } + def initialize(gem, security_policy); end + + sig { params(filename: T.untyped, destination_dir: T.untyped).returns(T.untyped) } + def install_location(filename, destination_dir); end + + sig { params(entry: T.untyped).returns(T.untyped) } + def load_spec(entry); end + + sig do + params( + mkdir: T.untyped, + mkdir_options: T.untyped, + destination_dir: T.untyped, + file_name: T.untyped + ).returns(T.untyped) + end + def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end + + sig { params(pathname: T.untyped).returns(T.untyped) } + def normalize_path(pathname); end + + sig { params(io: T.untyped).returns(T.untyped) } + def open_tar_gz(io); end + + sig { returns(T.untyped) } + def prog_mode; end + + sig { params(prog_mode: T.untyped).returns(T.untyped) } + def prog_mode=(prog_mode); end + + sig { params(gem: T.untyped).returns(T.untyped) } + def read_checksums(gem); end + + sig { returns(T.untyped) } + def security_policy; end + + sig { params(security_policy: T.untyped).returns(T.untyped) } + def security_policy=(security_policy); end + + sig { params(signer_options: T.untyped).returns(T.untyped) } + def setup_signer(signer_options: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def spec; end + + sig { params(spec: T.untyped).returns(T.untyped) } + def spec=(spec); end + + sig { returns(T.untyped) } + def verify; end + + sig { params(digests: T.untyped, checksums: T.untyped).returns(T.untyped) } + def verify_checksums(digests, checksums); end + + sig { params(entry: T.untyped).returns(T.untyped) } + def verify_entry(entry); end + + sig { params(gem: T.untyped).returns(T.untyped) } + def verify_files(gem); end + + sig { params(entry: T.untyped).returns(T.untyped) } + def verify_gz(entry); end + + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + strict_validation: T.untyped, + file_name: T.untyped + ).returns(T.untyped) + end + def self.build(spec, skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil), file_name = T.unsafe(nil)); end + + sig { params(gem: T.untyped, security_policy: T.untyped).returns(T.untyped) } + def self.new(gem, security_policy = T.unsafe(nil)); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + + class DigestIO + sig { returns(T.untyped) } + def digests; end + + sig { params(io: T.untyped, digests: T.untyped).returns(DigestIO) } + def initialize(io, digests); end + + sig { params(data: T.untyped).returns(T.untyped) } + def write(data); end + + sig { params(io: T.untyped, digests: T.untyped).returns(T.untyped) } + def self.wrap(io, digests); end + end + + class Error + end + + class FileSource + sig { params(path: T.untyped).returns(FileSource) } + def initialize(path); end + + sig { returns(T.untyped) } + def path; end + + sig { returns(T::Boolean) } + def present?; end + + sig { returns(T.untyped) } + def start; end + + sig { params(block: T.untyped).returns(T.untyped) } + def with_read_io(&block); end + + sig { params(block: T.untyped).returns(T.untyped) } + def with_write_io(&block); end + end + + class FormatError + sig { params(message: T.untyped, source: T.untyped).returns(FormatError) } + def initialize(message, source = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def path; end + end + + class IOSource + sig { params(io: T.untyped).returns(IOSource) } + def initialize(io); end + + sig { returns(T.untyped) } + def io; end + + sig { returns(T.untyped) } + def path; end + + sig { returns(T::Boolean) } + def present?; end + + sig { returns(T.untyped) } + def start; end + + sig { returns(T.untyped) } + def with_read_io; end + + sig { returns(T.untyped) } + def with_write_io; end + end + + class NonSeekableIO + end + + class Old + sig { params(destination_dir: T.untyped).returns(T.untyped) } + def extract_files(destination_dir); end + + sig { params(io: T.untyped).returns(T.untyped) } + def file_list(io); end + + sig { params(io: T.untyped).returns(T.untyped) } + def read_until_dashes(io); end + + sig { params(io: T.untyped).returns(T.untyped) } + def skip_ruby(io); end + end + + class PathError + sig { params(destination: T.untyped, destination_dir: T.untyped).returns(PathError) } + def initialize(destination, destination_dir); end + end + + class Source + end + + class TarHeader + EMPTY_HEADER = T.let(nil, T.untyped) + FIELDS = T.let(nil, T.untyped) + PACK_FORMAT = T.let(nil, T.untyped) + UNPACK_FORMAT = T.let(nil, T.untyped) + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { returns(T.untyped) } + def checksum; end + + sig { returns(T.untyped) } + def devmajor; end + + sig { returns(T.untyped) } + def devminor; end + + sig { returns(T::Boolean) } + def empty?; end + + sig { returns(T.untyped) } + def gid; end + + sig { returns(T.untyped) } + def gname; end + + sig { params(vals: T.untyped).returns(TarHeader) } + def initialize(vals); end + + sig { returns(T.untyped) } + def linkname; end + + sig { returns(T.untyped) } + def magic; end + + sig { returns(T.untyped) } + def mode; end + + sig { returns(T.untyped) } + def mtime; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def prefix; end + + sig { returns(T.untyped) } + def size; end + + sig { returns(T.untyped) } + def typeflag; end + + sig { returns(T.untyped) } + def uid; end + + sig { returns(T.untyped) } + def uname; end + + sig { returns(T.untyped) } + def update_checksum; end + + sig { returns(T.untyped) } + def version; end + + sig { params(stream: T.untyped).returns(T.untyped) } + def self.from(stream); end + + sig { params(str: T.untyped).returns(T.untyped) } + def self.strict_oct(str); end + end + + class TarInvalidError + end + + class TarReader + include Enumerable + + sig { returns(T.untyped) } + def close; end + + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { returns(T.untyped) } + def each_entry; end + + sig { params(io: T.untyped).returns(TarReader) } + def initialize(io); end + + sig { returns(T.untyped) } + def rewind; end + + sig { params(name: T.untyped).returns(T.untyped) } + def seek(name); end + + sig { params(io: T.untyped).returns(T.untyped) } + def self.new(io); end + + class Entry + sig { returns(T.untyped) } + def bytes_read; end + + sig { returns(T.untyped) } + def check_closed; end + + sig { returns(T.untyped) } + def close; end + + sig { returns(T::Boolean) } + def closed?; end + + sig { returns(T::Boolean) } + def directory?; end + + sig { returns(T::Boolean) } + def eof?; end + + sig { returns(T::Boolean) } + def file?; end + + sig { returns(T.untyped) } + def full_name; end + + sig { returns(T.untyped) } + def getc; end + + sig { returns(T.untyped) } + def header; end + + sig { params(header: T.untyped, io: T.untyped).returns(Entry) } + def initialize(header, io); end + + sig { returns(T.untyped) } + def length; end + + sig { returns(T.untyped) } + def pos; end + + sig { params(len: T.untyped).returns(T.untyped) } + def read(len = T.unsafe(nil)); end + + sig { params(maxlen: T.untyped, outbuf: T.untyped).returns(T.untyped) } + def readpartial(maxlen = T.unsafe(nil), outbuf = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def rewind; end + + sig { returns(T.untyped) } + def size; end + + sig { returns(T::Boolean) } + def symlink?; end + end + + class UnexpectedEOF + end + end + + class TarWriter + sig { params(name: T.untyped, mode: T.untyped).returns(T.untyped) } + def add_file(name, mode); end + + sig { params(name: T.untyped, mode: T.untyped, digest_algorithms: T.untyped).returns(T.untyped) } + def add_file_digest(name, mode, digest_algorithms); end + + sig { params(name: T.untyped, mode: T.untyped, signer: T.untyped).returns(T.untyped) } + def add_file_signed(name, mode, signer); end + + sig { params(name: T.untyped, mode: T.untyped, size: T.untyped).returns(T.untyped) } + def add_file_simple(name, mode, size); end + + sig { params(name: T.untyped, target: T.untyped, mode: T.untyped).returns(T.untyped) } + def add_symlink(name, target, mode); end + + sig { returns(T.untyped) } + def check_closed; end + + sig { returns(T.untyped) } + def close; end + + sig { returns(T::Boolean) } + def closed?; end + + sig { returns(T.untyped) } + def flush; end + + sig { params(io: T.untyped).returns(TarWriter) } + def initialize(io); end + + sig { params(name: T.untyped, mode: T.untyped).returns(T.untyped) } + def mkdir(name, mode); end + + sig { params(name: T.untyped).returns(T.untyped) } + def split_name(name); end + + sig { params(io: T.untyped).returns(T.untyped) } + def self.new(io); end + + class BoundedStream + sig { params(io: T.untyped, limit: T.untyped).returns(BoundedStream) } + def initialize(io, limit); end + + sig { returns(T.untyped) } + def limit; end + + sig { params(data: T.untyped).returns(T.untyped) } + def write(data); end + + sig { returns(T.untyped) } + def written; end + end + + class FileOverflow + end + + class RestrictedStream + sig { params(io: T.untyped).returns(RestrictedStream) } + def initialize(io); end + + sig { params(data: T.untyped).returns(T.untyped) } + def write(data); end + end + end + + class TooLongFileName + end + end + + class PathSupport + sig { returns(T.untyped) } + def home; end + + sig { params(env: T.untyped).returns(PathSupport) } + def initialize(env); end + + sig { returns(T.untyped) } + def path; end + + sig { returns(T.untyped) } + def spec_cache_dir; end + end + + class Platform + JAVA = T.let(nil, T.untyped) + MINGW = T.let(nil, T.untyped) + MSWIN = T.let(nil, T.untyped) + MSWIN64 = T.let(nil, T.untyped) + X64_MINGW = T.let(nil, T.untyped) + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(other: T.untyped).returns(T.untyped) } + def ===(other); end + + sig { params(other: T.untyped).returns(T.untyped) } + def =~(other); end + + sig { returns(T.untyped) } + def cpu; end + + sig { params(cpu: T.untyped).returns(T.untyped) } + def cpu=(cpu); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { params(arch: T.untyped).returns(Platform) } + def initialize(arch); end + + sig { returns(T.untyped) } + def os; end + + sig { params(os: T.untyped).returns(T.untyped) } + def os=(os); end + + sig { returns(T.untyped) } + def to_a; end + + sig { returns(T.untyped) } + def version; end + + sig { params(version: T.untyped).returns(T.untyped) } + def version=(version); end + + sig { params(spec: T.untyped).returns(T::Boolean) } + def self.installable?(spec); end + + sig { returns(T.untyped) } + def self.local; end + + sig { params(platform: T.untyped).returns(T.untyped) } + def self.match(platform); end + + sig { params(arch: T.untyped).returns(T.untyped) } + def self.new(arch); end + end + + class PlatformMismatch + sig { params(platform: T.untyped).returns(T.untyped) } + def add_platform(platform); end + + sig { params(name: T.untyped, version: T.untyped).returns(PlatformMismatch) } + def initialize(name, version); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def platforms; end + + sig { returns(T.untyped) } + def version; end + + sig { returns(T.untyped) } + def wordy; end + end + + class RemoteFetcher + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + BASE64_URI_TRANSLATE = T.let(nil, T.untyped) + + sig { params(uri: T.untyped, path: T.untyped, update: T.untyped).returns(T.untyped) } + def cache_update_path(uri, path = T.unsafe(nil), update = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def close_all; end + + sig { params(path: T.untyped).returns(T.untyped) } + def correct_for_windows_path(path); end + + sig { params(spec: T.untyped, source_uri: T.untyped, install_dir: T.untyped).returns(T.untyped) } + def download(spec, source_uri, install_dir = T.unsafe(nil)); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def download_to_cache(dependency); end + + sig { params(uri: T.untyped, _: T.untyped).returns(T.untyped) } + def fetch_file(uri, *_); end + + sig do + params( + uri: T.untyped, + last_modified: T.untyped, + head: T.untyped, + depth: T.untyped + ).returns(T.untyped) + end + def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end + + sig do + params( + uri: T.untyped, + last_modified: T.untyped, + head: T.untyped, + depth: T.untyped + ).returns(T.untyped) + end + def fetch_https(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end + + sig { params(uri: T.untyped, mtime: T.untyped, head: T.untyped).returns(T.untyped) } + def fetch_path(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end + + sig { params(uri: T.untyped, mtime: T.untyped, head: T.untyped).returns(T.untyped) } + def fetch_s3(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end + + sig { params(uri: T.untyped).returns(T.untyped) } + def fetch_size(uri); end + + sig { returns(T.untyped) } + def headers; end + + sig { params(headers: T.untyped).returns(T.untyped) } + def headers=(headers); end + + sig { params(uri: T.untyped).returns(T::Boolean) } + def https?(uri); end + + sig { params(proxy: T.untyped, dns: T.untyped, headers: T.untyped).returns(RemoteFetcher) } + def initialize(proxy = T.unsafe(nil), dns = T.unsafe(nil), headers = T.unsafe(nil)); end + + sig { params(uri: T.untyped, request_class: T.untyped, last_modified: T.untyped).returns(T.untyped) } + def request(uri, request_class, last_modified = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def s3_expiration; end + + sig { params(uri: T.untyped, expiration: T.untyped).returns(T.untyped) } + def sign_s3_url(uri, expiration = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.fetcher; end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class Request + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + extend Gem::UserInteraction + extend Gem::DefaultUserInteraction + extend Gem::Text + + sig { returns(T.untyped) } + def cert_files; end + + sig { params(uri: T.untyped).returns(T.untyped) } + def connection_for(uri); end + + sig { returns(T.untyped) } + def fetch; end + + sig do + params( + uri: T.untyped, + request_class: T.untyped, + last_modified: T.untyped, + pool: T.untyped + ).returns(Request) + end + def initialize(uri, request_class, last_modified, pool); end + + sig { params(request: T.untyped).returns(T.untyped) } + def perform_request(request); end + + sig { returns(T.untyped) } + def proxy_uri; end + + sig { params(connection: T.untyped).returns(T.untyped) } + def reset(connection); end + + sig { returns(T.untyped) } + def user_agent; end + + sig { params(connection: T.untyped, cert_files: T.untyped).returns(T.untyped) } + def self.configure_connection_for_https(connection, cert_files); end + + sig do + params( + uri: T.untyped, + request_class: T.untyped, + last_modified: T.untyped, + proxy: T.untyped + ).returns(T.untyped) + end + def self.create_with_proxy(uri, request_class, last_modified, proxy); end + + sig { returns(T.untyped) } + def self.get_cert_files; end + + sig { params(scheme: T.untyped).returns(T.untyped) } + def self.get_proxy_from_env(scheme = T.unsafe(nil)); end + + sig { params(proxy: T.untyped).returns(T.untyped) } + def self.proxy_uri(proxy); end + + sig { params(store_context: T.untyped).returns(T.untyped) } + def self.verify_certificate(store_context); end + + sig { params(error_number: T.untyped, cert: T.untyped).returns(T.untyped) } + def self.verify_certificate_message(error_number, cert); end + + sig { params(text: T.untyped).returns(T.untyped) } + def self.clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def self.format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def self.levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def self.min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def self.truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def self.ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def self.use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def self.alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def self.alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def self.alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def self.ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def self.ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def self.ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def self.choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def self.say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def self.terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def self.verbose(msg = T.unsafe(nil)); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + + class ConnectionPools + sig { returns(T.untyped) } + def close_all; end + + sig { params(proxy_uri: T.untyped, cert_files: T.untyped).returns(ConnectionPools) } + def initialize(proxy_uri, cert_files); end + + sig { params(uri: T.untyped).returns(T.untyped) } + def pool_for(uri); end + + sig { returns(T.untyped) } + def self.client; end + + sig { params(client: T.untyped).returns(T.untyped) } + def self.client=(client); end + end + + class HTTPPool + sig { returns(T.untyped) } + def cert_files; end + + sig { params(connection: T.untyped).returns(T.untyped) } + def checkin(connection); end + + sig { returns(T.untyped) } + def checkout; end + + sig { returns(T.untyped) } + def close_all; end + + sig { params(http_args: T.untyped, cert_files: T.untyped, proxy_uri: T.untyped).returns(HTTPPool) } + def initialize(http_args, cert_files, proxy_uri); end + + sig { returns(T.untyped) } + def proxy_uri; end + end + + class HTTPSPool + end + end + + class RequestSet + include TSort + + sig { returns(T.untyped) } + def always_install; end + + sig { params(always_install: T.untyped).returns(T.untyped) } + def always_install=(always_install); end + + sig { returns(T.untyped) } + def dependencies; end + + sig { returns(T.untyped) } + def development; end + + sig { params(development: T.untyped).returns(T.untyped) } + def development=(development); end + + sig { returns(T.untyped) } + def development_shallow; end + + sig { params(development_shallow: T.untyped).returns(T.untyped) } + def development_shallow=(development_shallow); end + + sig { returns(T.untyped) } + def errors; end + + sig { params(name: T.untyped, reqs: T.untyped).returns(T.untyped) } + def gem(name, *reqs); end + + sig { returns(T.untyped) } + def git_set; end + + sig { returns(T.untyped) } + def ignore_dependencies; end + + sig { params(ignore_dependencies: T.untyped).returns(T.untyped) } + def ignore_dependencies=(ignore_dependencies); end + + sig { params(deps: T.untyped).returns(T.untyped) } + def import(deps); end + + sig { params(deps: T.untyped).returns(RequestSet) } + def initialize(*deps); end + + sig { params(options: T.untyped, block: T.untyped).returns(T.untyped) } + def install(options, &block); end + + sig { returns(T.untyped) } + def install_dir; end + + sig { params(options: T.untyped, block: T.untyped).returns(T.untyped) } + def install_from_gemdeps(options, &block); end + + sig { params(requests: T.untyped, options: T.untyped).returns(T.untyped) } + def install_hooks(requests, options); end + + sig { params(dir: T.untyped, force: T.untyped, options: T.untyped).returns(T.untyped) } + def install_into(dir, force = T.unsafe(nil), options = T.unsafe(nil)); end + + sig { params(path: T.untyped, without_groups: T.untyped, installing: T.untyped).returns(T.untyped) } + def load_gemdeps(path, without_groups = T.unsafe(nil), installing = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def prerelease; end + + sig { params(prerelease: T.untyped).returns(T.untyped) } + def prerelease=(prerelease); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def remote; end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { params(set: T.untyped).returns(T.untyped) } + def resolve(set = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def resolve_current; end + + sig { returns(T.untyped) } + def resolver; end + + sig { returns(T.untyped) } + def sets; end + + sig { returns(T.untyped) } + def soft_missing; end + + sig { params(soft_missing: T.untyped).returns(T.untyped) } + def soft_missing=(soft_missing); end + + sig { returns(T.untyped) } + def sorted_requests; end + + sig { returns(T.untyped) } + def source_set; end + + sig { returns(T.untyped) } + def specs; end + + sig { params(dir: T.untyped).returns(T.untyped) } + def specs_in(dir); end + + sig { params(block: T.untyped).returns(T.untyped) } + def tsort_each_node(&block); end + + sig { returns(T.untyped) } + def vendor_set; end + + class GemDependencyAPI + ENGINE_MAP = T.let(nil, T.untyped) + PLATFORM_MAP = T.let(nil, T.untyped) + VERSION_MAP = T.let(nil, T.untyped) + WINDOWS = T.let(nil, T.untyped) + + sig { returns(T.untyped) } + def dependencies; end + + sig { params(name: T.untyped, path: T.untyped).returns(T.untyped) } + def find_gemspec(name, path); end + + sig { params(name: T.untyped, requirements: T.untyped).returns(T.untyped) } + def gem(name, *requirements); end + + sig { returns(T.untyped) } + def gem_deps_file; end + + sig { params(options: T.untyped).returns(T.untyped) } + def gem_git_reference(options); end + + sig { params(options: T.untyped).returns(T.untyped) } + def gemspec(options = T.unsafe(nil)); end + + sig { params(repository: T.untyped).returns(T.untyped) } + def git(repository); end + + sig { returns(T.untyped) } + def git_set; end + + sig { params(name: T.untyped, callback: T.untyped).returns(T.untyped) } + def git_source(name, &callback); end + + sig { params(groups: T.untyped).returns(T.untyped) } + def group(*groups); end + + sig { params(set: T.untyped, path: T.untyped).returns(GemDependencyAPI) } + def initialize(set, path); end + + sig { params(installing: T.untyped).returns(T.untyped) } + def installing=(installing); end + + sig { returns(T.untyped) } + def load; end + + sig { params(platforms: T.untyped).returns(T.untyped) } + def platform(*platforms); end + + sig { params(platforms: T.untyped).returns(T.untyped) } + def platforms(*platforms); end + + sig { returns(T.untyped) } + def requires; end + + sig { params(version: T.untyped, options: T.untyped).returns(T.untyped) } + def ruby(version, options = T.unsafe(nil)); end + + sig { params(url: T.untyped).returns(T.untyped) } + def source(url); end + + sig { returns(T.untyped) } + def vendor_set; end + + sig { returns(T.untyped) } + def without_groups; end + + sig { params(without_groups: T.untyped).returns(T.untyped) } + def without_groups=(without_groups); end + end + + class Lockfile + sig { params(out: T.untyped).returns(T.untyped) } + def add_DEPENDENCIES(out); end + + sig { params(out: T.untyped, spec_groups: T.untyped).returns(T.untyped) } + def add_GEM(out, spec_groups); end + + sig { params(out: T.untyped, git_requests: T.untyped).returns(T.untyped) } + def add_GIT(out, git_requests); end + + sig { params(out: T.untyped, path_requests: T.untyped).returns(T.untyped) } + def add_PATH(out, path_requests); end + + sig { params(out: T.untyped).returns(T.untyped) } + def add_PLATFORMS(out); end + + sig { params(request_set: T.untyped, gem_deps_file: T.untyped, dependencies: T.untyped).returns(Lockfile) } + def initialize(request_set, gem_deps_file, dependencies); end + + sig { returns(T.untyped) } + def platforms; end + + sig { params(dest: T.untyped, base: T.untyped).returns(T.untyped) } + def relative_path_from(dest, base); end + + sig { returns(T.untyped) } + def spec_groups; end + + sig { returns(T.untyped) } + def write; end + + sig { params(request_set: T.untyped, gem_deps_file: T.untyped, dependencies: T.untyped).returns(T.untyped) } + def self.build(request_set, gem_deps_file, dependencies = T.unsafe(nil)); end + + sig { params(requests: T.untyped).returns(T.untyped) } + def self.requests_to_deps(requests); end + + class ParseError + sig { returns(T.untyped) } + def column; end + + sig do + params( + message: T.untyped, + column: T.untyped, + line: T.untyped, + path: T.untyped + ).returns(ParseError) + end + def initialize(message, column, line, path); end + + sig { returns(T.untyped) } + def line; end + + sig { returns(T.untyped) } + def path; end + end + + class Parser + sig { params(expected_types: T.untyped, expected_value: T.untyped).returns(T.untyped) } + def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end + + sig do + params( + tokenizer: T.untyped, + set: T.untyped, + platforms: T.untyped, + filename: T.untyped + ).returns(Parser) + end + def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def parse; end + + sig { returns(T.untyped) } + def parse_DEPENDENCIES; end + + sig { returns(T.untyped) } + def parse_GEM; end + + sig { returns(T.untyped) } + def parse_GIT; end + + sig { returns(T.untyped) } + def parse_PATH; end + + sig { returns(T.untyped) } + def parse_PLATFORMS; end + + sig { params(name: T.untyped, op: T.untyped).returns(T.untyped) } + def parse_dependency(name, op); end + end + + class Tokenizer + EOF = T.let(nil, T.untyped) + + sig { returns(T::Boolean) } + def empty?; end + + sig do + params( + input: T.untyped, + filename: T.untyped, + line: T.untyped, + pos: T.untyped + ).returns(Tokenizer) + end + def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end + + sig { params(set: T.untyped, platforms: T.untyped).returns(T.untyped) } + def make_parser(set, platforms); end + + sig { returns(T.untyped) } + def next_token; end + + sig { returns(T.untyped) } + def peek; end + + sig { returns(T.untyped) } + def shift; end + + sig { params(type: T.untyped).returns(T.untyped) } + def skip(type); end + + sig { returns(T.untyped) } + def to_a; end + + sig { params(byte_offset: T.untyped).returns(T.untyped) } + def token_pos(byte_offset); end + + sig { params(token: T.untyped).returns(T.untyped) } + def unshift(token); end + + sig { params(file: T.untyped).returns(T.untyped) } + def self.from_file(file); end + + class Token + sig { returns(T.untyped) } + def column; end + + sig { params(_: T.untyped).returns(T.untyped) } + def column=(_); end + + sig { returns(T.untyped) } + def line; end + + sig { params(_: T.untyped).returns(T.untyped) } + def line=(_); end + + sig { returns(T.untyped) } + def type; end + + sig { params(_: T.untyped).returns(T.untyped) } + def type=(_); end + + sig { returns(T.untyped) } + def value; end + + sig { params(_: T.untyped).returns(T.untyped) } + def value=(_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.[](*_); end + + sig { returns(T.untyped) } + def self.members; end + end + end + end + end + + class Requirement + DefaultRequirement = T.let(nil, T.untyped) + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(version: T.untyped).returns(T.untyped) } + def ===(version); end + + sig { params(version: T.untyped).returns(T.untyped) } + def =~(version); end + + sig { returns(T.untyped) } + def _tilde_requirements; end + + sig { returns(T.untyped) } + def as_list; end + + sig { params(new: T.untyped).returns(T.untyped) } + def concat(new); end + + sig { params(coder: T.untyped).returns(T.untyped) } + def encode_with(coder); end + + sig { returns(T::Boolean) } + def exact?; end + + sig { returns(T.untyped) } + def for_lockfile; end + + sig { params(coder: T.untyped).returns(T.untyped) } + def init_with(coder); end + + sig { params(requirements: T.untyped).returns(Requirement) } + def initialize(*requirements); end + + sig { returns(T.untyped) } + def marshal_dump; end + + sig { params(array: T.untyped).returns(T.untyped) } + def marshal_load(array); end + + sig { returns(T::Boolean) } + def none?; end + + sig { returns(T::Boolean) } + def prerelease?; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def requirements; end + + sig { params(version: T.untyped).returns(T::Boolean) } + def satisfied_by?(version); end + + sig { returns(T::Boolean) } + def specific?; end + + sig { returns(T.untyped) } + def to_yaml_properties; end + + sig { params(tag: T.untyped, vals: T.untyped).returns(T.untyped) } + def yaml_initialize(tag, vals); end + + sig { params(inputs: T.untyped).returns(T.untyped) } + def self.create(*inputs); end + + sig { returns(T.untyped) } + def self.default; end + + sig { params(obj: T.untyped).returns(T.untyped) } + def self.parse(obj); end + + sig { returns(T.untyped) } + def self.source_set; end + end + + class Resolver + include Gem::Resolver::Molinillo::UI + include Gem::Resolver::Molinillo::SpecificationProvider + DEBUG_RESOLVER = T.let(nil, T.untyped) + + sig { params(dep: T.untyped, possible: T.untyped).returns(T.untyped) } + def activation_request(dep, possible); end + + sig { returns(T.untyped) } + def development; end + + sig { params(development: T.untyped).returns(T.untyped) } + def development=(development); end + + sig { returns(T.untyped) } + def development_shallow; end + + sig { params(development_shallow: T.untyped).returns(T.untyped) } + def development_shallow=(development_shallow); end + + sig { params(stage: T.untyped, data: T.untyped).returns(T.untyped) } + def explain(stage, *data); end + + sig { params(stage: T.untyped).returns(T.untyped) } + def explain_list(stage); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def find_possible(dependency); end + + sig { returns(T.untyped) } + def ignore_dependencies; end + + sig { params(ignore_dependencies: T.untyped).returns(T.untyped) } + def ignore_dependencies=(ignore_dependencies); end + + sig { params(needed: T.untyped, set: T.untyped).returns(Resolver) } + def initialize(needed, set = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def missing; end + + sig { params(s: T.untyped, act: T.untyped, reqs: T.untyped).returns(T.untyped) } + def requests(s, act, reqs = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def resolve; end + + sig { params(specs: T.untyped).returns(T.untyped) } + def select_local_platforms(specs); end + + sig { returns(T.untyped) } + def skip_gems; end + + sig { params(skip_gems: T.untyped).returns(T.untyped) } + def skip_gems=(skip_gems); end + + sig { returns(T.untyped) } + def soft_missing; end + + sig { params(soft_missing: T.untyped).returns(T.untyped) } + def soft_missing=(soft_missing); end + + sig { returns(T.untyped) } + def stats; end + + sig { params(sets: T.untyped).returns(T.untyped) } + def self.compose_sets(*sets); end + + sig { params(needed: T.untyped).returns(T.untyped) } + def self.for_current_gems(needed); end + + sig { params(dependency: T.untyped).returns(T::Boolean) } + def allow_missing?(dependency); end + + sig { params(specification: T.untyped).returns(T.untyped) } + def dependencies_for(specification); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def name_for(dependency); end + + sig { returns(T.untyped) } + def name_for_explicit_dependency_source; end + + sig { returns(T.untyped) } + def name_for_locking_dependency_source; end + + sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } + def requirement_satisfied_by?(requirement, activated, spec); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def search_for(dependency); end + + sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } + def sort_dependencies(dependencies, activated, conflicts); end + + sig { returns(T.untyped) } + def after_resolution; end + + sig { returns(T.untyped) } + def before_resolution; end + + sig { params(depth: T.untyped).returns(T.untyped) } + def debug(depth = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def debug?; end + + sig { returns(T.untyped) } + def indicate_progress; end + + sig { returns(T.untyped) } + def output; end + + sig { returns(T.untyped) } + def progress_rate; end + + class APISet + sig { returns(T.untyped) } + def dep_uri; end + + sig { params(dep_uri: T.untyped).returns(APISet) } + def initialize(dep_uri = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def prefetch_now; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def source; end + + sig { returns(T.untyped) } + def uri; end + + sig { params(name: T.untyped).returns(T.untyped) } + def versions(name); end + end + + class APISpecification + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(set: T.untyped, api_data: T.untyped).returns(APISpecification) } + def initialize(set, api_data); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + end + + class ActivationRequest + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { returns(T::Boolean) } + def development?; end + + sig { params(path: T.untyped).returns(T.untyped) } + def download(path); end + + sig { returns(T.untyped) } + def full_name; end + + sig { returns(T.untyped) } + def full_spec; end + + sig { params(spec: T.untyped, request: T.untyped, others_possible: T.untyped).returns(ActivationRequest) } + def initialize(spec, request, others_possible = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def installed?; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T::Boolean) } + def others_possible?; end + + sig { returns(T.untyped) } + def parent; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def request; end + + sig { returns(T.untyped) } + def spec; end + + sig { returns(T.untyped) } + def version; end + end + + class BestSet + sig { params(sources: T.untyped).returns(BestSet) } + def initialize(sources = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def pick_sets; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { params(error: T.untyped).returns(T.untyped) } + def replace_failed_api_set(error); end + end + + class ComposedSet + sig { params(sets: T.untyped).returns(ComposedSet) } + def initialize(*sets); end + + sig { params(allow_prerelease: T.untyped).returns(T.untyped) } + def prerelease=(allow_prerelease); end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { returns(T.untyped) } + def sets; end + end + + class Conflict + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { returns(T.untyped) } + def activated; end + + sig { returns(T.untyped) } + def conflicting_dependencies; end + + sig { returns(T.untyped) } + def dependency; end + + sig { returns(T.untyped) } + def explain; end + + sig { returns(T.untyped) } + def explanation; end + + sig { returns(T.untyped) } + def failed_dep; end + + sig { params(spec: T.untyped).returns(T::Boolean) } + def for_spec?(spec); end + + sig { params(dependency: T.untyped, activated: T.untyped, failed_dep: T.untyped).returns(Conflict) } + def initialize(dependency, activated, failed_dep = T.unsafe(nil)); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { params(current: T.untyped).returns(T.untyped) } + def request_path(current); end + + sig { returns(T.untyped) } + def requester; end + end + + class CurrentSet + end + + class DependencyRequest + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { returns(T.untyped) } + def dependency; end + + sig { returns(T::Boolean) } + def development?; end + + sig { returns(T::Boolean) } + def explicit?; end + + sig { returns(T::Boolean) } + def implicit?; end + + sig { params(dependency: T.untyped, requester: T.untyped).returns(DependencyRequest) } + def initialize(dependency, requester); end + + sig { params(spec: T.untyped, allow_prerelease: T.untyped).returns(T::Boolean) } + def match?(spec, allow_prerelease = T.unsafe(nil)); end + + sig { params(spec: T.untyped).returns(T::Boolean) } + def matches_spec?(spec); end + + sig { returns(T.untyped) } + def name; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def request_context; end + + sig { returns(T.untyped) } + def requester; end + + sig { returns(T.untyped) } + def requirement; end + + sig { returns(T.untyped) } + def type; end + end + + class GitSet + sig do + params( + name: T.untyped, + repository: T.untyped, + reference: T.untyped, + submodules: T.untyped + ).returns(T.untyped) + end + def add_git_gem(name, repository, reference, submodules); end + + sig do + params( + name: T.untyped, + version: T.untyped, + repository: T.untyped, + reference: T.untyped, + submodules: T.untyped + ).returns(T.untyped) + end + def add_git_spec(name, version, repository, reference, submodules); end + + sig { returns(T.untyped) } + def need_submodules; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def repositories; end + + sig { returns(T.untyped) } + def root_dir; end + + sig { params(root_dir: T.untyped).returns(T.untyped) } + def root_dir=(root_dir); end + + sig { returns(T.untyped) } + def specs; end + end + + class GitSpecification + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def add_dependency(dependency); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + end + + class IndexSet + sig { params(source: T.untyped).returns(IndexSet) } + def initialize(source = T.unsafe(nil)); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + end + + class IndexSpecification + sig do + params( + set: T.untyped, + name: T.untyped, + version: T.untyped, + source: T.untyped, + platform: T.untyped + ).returns(IndexSpecification) + end + def initialize(set, name, version, source, platform); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + end + + class InstalledSpecification + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + end + + class InstallerSet + sig { params(dependency: T.untyped).returns(T.untyped) } + def add_always_install(dependency); end + + sig { params(dep_name: T.untyped, spec: T.untyped, source: T.untyped).returns(T.untyped) } + def add_local(dep_name, spec, source); end + + sig { returns(T.untyped) } + def always_install; end + + sig { returns(T::Boolean) } + def consider_local?; end + + sig { returns(T::Boolean) } + def consider_remote?; end + + sig { returns(T.untyped) } + def ignore_dependencies; end + + sig { params(ignore_dependencies: T.untyped).returns(T.untyped) } + def ignore_dependencies=(ignore_dependencies); end + + sig { returns(T.untyped) } + def ignore_installed; end + + sig { params(ignore_installed: T.untyped).returns(T.untyped) } + def ignore_installed=(ignore_installed); end + + sig { params(domain: T.untyped).returns(InstallerSet) } + def initialize(domain); end + + sig do + params( + name: T.untyped, + ver: T.untyped, + platform: T.untyped, + source: T.untyped + ).returns(T.untyped) + end + def load_spec(name, ver, platform, source); end + + sig { params(dep_name: T.untyped).returns(T::Boolean) } + def local?(dep_name); end + + sig { params(allow_prerelease: T.untyped).returns(T.untyped) } + def prerelease=(allow_prerelease); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { returns(T.untyped) } + def remote_set; end + end + + class LocalSpecification + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + end + + class LockSet + sig { params(name: T.untyped, version: T.untyped, platform: T.untyped).returns(T.untyped) } + def add(name, version, platform); end + + sig { params(sources: T.untyped).returns(LockSet) } + def initialize(sources); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + source: T.untyped + ).returns(T.untyped) + end + def load_spec(name, version, platform, source); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def specs; end + end + + class LockSpecification + sig { params(dependency: T.untyped).returns(T.untyped) } + def add_dependency(dependency); end + + sig do + params( + set: T.untyped, + name: T.untyped, + version: T.untyped, + sources: T.untyped, + platform: T.untyped + ).returns(LockSpecification) + end + def initialize(set, name, version, sources, platform); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def sources; end + end + + module Molinillo + VERSION = T.let(nil, T.untyped) + + class CircularDependencyError + sig { returns(T.untyped) } + def dependencies; end + + sig { params(nodes: T.untyped).returns(CircularDependencyError) } + def initialize(nodes); end + end + + module Delegates + module ResolutionState + sig { returns(T.untyped) } + def activated; end + + sig { returns(T.untyped) } + def conflicts; end + + sig { returns(T.untyped) } + def depth; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def possibilities; end + + sig { returns(T.untyped) } + def requirement; end + + sig { returns(T.untyped) } + def requirements; end + end + + module SpecificationProvider + sig { params(dependency: T.untyped).returns(T::Boolean) } + def allow_missing?(dependency); end + + sig { params(specification: T.untyped).returns(T.untyped) } + def dependencies_for(specification); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def name_for(dependency); end + + sig { returns(T.untyped) } + def name_for_explicit_dependency_source; end + + sig { returns(T.untyped) } + def name_for_locking_dependency_source; end + + sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } + def requirement_satisfied_by?(requirement, activated, spec); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def search_for(dependency); end + + sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } + def sort_dependencies(dependencies, activated, conflicts); end + end + end + + class DependencyGraph + include Enumerable + include TSort + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + parent_names: T.untyped, + requirement: T.untyped + ).returns(T.untyped) + end + def add_child_vertex(name, payload, parent_names, requirement); end + + sig { params(origin: T.untyped, destination: T.untyped, requirement: T.untyped).returns(T.untyped) } + def add_edge(origin, destination, requirement); end + + sig { params(name: T.untyped, payload: T.untyped, root: T.untyped).returns(T.untyped) } + def add_vertex(name, payload, root = T.unsafe(nil)); end + + sig { params(edge: T.untyped).returns(T.untyped) } + def delete_edge(edge); end + + sig { params(name: T.untyped).returns(T.untyped) } + def detach_vertex_named(name); end + + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { returns(T.untyped) } + def log; end + + sig { params(tag: T.untyped).returns(T.untyped) } + def rewind_to(tag); end + + sig { params(name: T.untyped).returns(T.untyped) } + def root_vertex_named(name); end + + sig { params(name: T.untyped, payload: T.untyped).returns(T.untyped) } + def set_payload(name, payload); end + + sig { params(tag: T.untyped).returns(T.untyped) } + def tag(tag); end + + sig { params(options: T.untyped).returns(T.untyped) } + def to_dot(options = T.unsafe(nil)); end + + sig { params(vertex: T.untyped, block: T.untyped).returns(T.untyped) } + def tsort_each_child(vertex, &block); end + + sig { params(name: T.untyped).returns(T.untyped) } + def vertex_named(name); end + + sig { returns(T.untyped) } + def vertices; end + + sig { params(vertices: T.untyped).returns(T.untyped) } + def self.tsort(vertices); end + + class Action + sig { params(graph: T.untyped).returns(T.untyped) } + def down(graph); end + + sig { returns(T.untyped) } + def next; end + + sig { params(_: T.untyped).returns(T.untyped) } + def next=(_); end + + sig { returns(T.untyped) } + def previous; end + + sig { params(previous: T.untyped).returns(T.untyped) } + def previous=(previous); end + + sig { params(graph: T.untyped).returns(T.untyped) } + def up(graph); end + + sig { returns(T.untyped) } + def self.action_name; end + end + + class AddEdgeNoCircular + sig { returns(T.untyped) } + def destination; end + + sig { params(origin: T.untyped, destination: T.untyped, requirement: T.untyped).returns(AddEdgeNoCircular) } + def initialize(origin, destination, requirement); end + + sig { params(graph: T.untyped).returns(T.untyped) } + def make_edge(graph); end + + sig { returns(T.untyped) } + def origin; end + + sig { returns(T.untyped) } + def requirement; end + end + + class AddVertex + sig { params(name: T.untyped, payload: T.untyped, root: T.untyped).returns(AddVertex) } + def initialize(name, payload, root); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def payload; end + + sig { returns(T.untyped) } + def root; end + end + + class DeleteEdge + sig { returns(T.untyped) } + def destination_name; end + + sig { params(origin_name: T.untyped, destination_name: T.untyped, requirement: T.untyped).returns(DeleteEdge) } + def initialize(origin_name, destination_name, requirement); end + + sig { params(graph: T.untyped).returns(T.untyped) } + def make_edge(graph); end + + sig { returns(T.untyped) } + def origin_name; end + + sig { returns(T.untyped) } + def requirement; end + end + + class DetachVertexNamed + sig { params(name: T.untyped).returns(DetachVertexNamed) } + def initialize(name); end + + sig { returns(T.untyped) } + def name; end + end + + class Edge + sig { returns(T.untyped) } + def destination; end + + sig { params(_: T.untyped).returns(T.untyped) } + def destination=(_); end + + sig { returns(T.untyped) } + def origin; end + + sig { params(_: T.untyped).returns(T.untyped) } + def origin=(_); end + + sig { returns(T.untyped) } + def requirement; end + + sig { params(_: T.untyped).returns(T.untyped) } + def requirement=(_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.[](*_); end + + sig { returns(T.untyped) } + def self.members; end + end + + class Log + extend Enumerable + + sig do + params( + graph: T.untyped, + origin: T.untyped, + destination: T.untyped, + requirement: T.untyped + ).returns(T.untyped) + end + def add_edge_no_circular(graph, origin, destination, requirement); end + + sig do + params( + graph: T.untyped, + name: T.untyped, + payload: T.untyped, + root: T.untyped + ).returns(T.untyped) + end + def add_vertex(graph, name, payload, root); end + + sig do + params( + graph: T.untyped, + origin_name: T.untyped, + destination_name: T.untyped, + requirement: T.untyped + ).returns(T.untyped) + end + def delete_edge(graph, origin_name, destination_name, requirement); end + + sig { params(graph: T.untyped, name: T.untyped).returns(T.untyped) } + def detach_vertex_named(graph, name); end + + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { params(graph: T.untyped).returns(T.untyped) } + def pop!(graph); end + + sig { returns(T.untyped) } + def reverse_each; end + + sig { params(graph: T.untyped, tag: T.untyped).returns(T.untyped) } + def rewind_to(graph, tag); end + + sig { params(graph: T.untyped, name: T.untyped, payload: T.untyped).returns(T.untyped) } + def set_payload(graph, name, payload); end + + sig { params(graph: T.untyped, tag: T.untyped).returns(T.untyped) } + def tag(graph, tag); end + end + + class SetPayload + sig { params(name: T.untyped, payload: T.untyped).returns(SetPayload) } + def initialize(name, payload); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def payload; end + end + + class Tag + sig { params(_graph: T.untyped).returns(T.untyped) } + def down(_graph); end + + sig { params(tag: T.untyped).returns(Tag) } + def initialize(tag); end + + sig { returns(T.untyped) } + def tag; end + + sig { params(_graph: T.untyped).returns(T.untyped) } + def up(_graph); end + end + + class Vertex + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def ancestor?(other); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def descendent?(other); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { returns(T.untyped) } + def explicit_requirements; end + + sig { returns(T.untyped) } + def incoming_edges; end + + sig { params(incoming_edges: T.untyped).returns(T.untyped) } + def incoming_edges=(incoming_edges); end + + sig { params(name: T.untyped, payload: T.untyped).returns(Vertex) } + def initialize(name, payload); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def is_reachable_from?(other); end + + sig { returns(T.untyped) } + def name; end + + sig { params(name: T.untyped).returns(T.untyped) } + def name=(name); end + + sig { returns(T.untyped) } + def outgoing_edges; end + + sig { params(outgoing_edges: T.untyped).returns(T.untyped) } + def outgoing_edges=(outgoing_edges); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def path_to?(other); end + + sig { returns(T.untyped) } + def payload; end + + sig { params(payload: T.untyped).returns(T.untyped) } + def payload=(payload); end + + sig { returns(T.untyped) } + def predecessors; end + + sig { returns(T.untyped) } + def recursive_predecessors; end + + sig { returns(T.untyped) } + def recursive_successors; end + + sig { returns(T.untyped) } + def requirements; end + + sig { returns(T.untyped) } + def root; end + + sig { params(root: T.untyped).returns(T.untyped) } + def root=(root); end + + sig { returns(T::Boolean) } + def root?; end + + sig { params(other: T.untyped).returns(T::Boolean) } + def shallow_eql?(other); end + + sig { returns(T.untyped) } + def successors; end + end + end + + class DependencyState + sig { returns(T.untyped) } + def pop_possibility_state; end + end + + class NoSuchDependencyError + sig { returns(T.untyped) } + def dependency; end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def dependency=(dependency); end + + sig { params(dependency: T.untyped, required_by: T.untyped).returns(NoSuchDependencyError) } + def initialize(dependency, required_by = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def required_by; end + + sig { params(required_by: T.untyped).returns(T.untyped) } + def required_by=(required_by); end + end + + class PossibilityState + end + + class ResolutionState + sig { returns(T.untyped) } + def activated; end + + sig { params(_: T.untyped).returns(T.untyped) } + def activated=(_); end + + sig { returns(T.untyped) } + def conflicts; end + + sig { params(_: T.untyped).returns(T.untyped) } + def conflicts=(_); end + + sig { returns(T.untyped) } + def depth; end + + sig { params(_: T.untyped).returns(T.untyped) } + def depth=(_); end + + sig { returns(T.untyped) } + def name; end + + sig { params(_: T.untyped).returns(T.untyped) } + def name=(_); end + + sig { returns(T.untyped) } + def possibilities; end + + sig { params(_: T.untyped).returns(T.untyped) } + def possibilities=(_); end + + sig { returns(T.untyped) } + def requirement; end + + sig { params(_: T.untyped).returns(T.untyped) } + def requirement=(_); end + + sig { returns(T.untyped) } + def requirements; end + + sig { params(_: T.untyped).returns(T.untyped) } + def requirements=(_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.[](*_); end + + sig { returns(T.untyped) } + def self.empty; end + + sig { returns(T.untyped) } + def self.members; end + end + + class Resolver + sig { params(specification_provider: T.untyped, resolver_ui: T.untyped).returns(Resolver) } + def initialize(specification_provider, resolver_ui); end + + sig { params(requested: T.untyped, base: T.untyped).returns(T.untyped) } + def resolve(requested, base = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def resolver_ui; end + + sig { returns(T.untyped) } + def specification_provider; end + + class Resolution + include Gem::Resolver::Molinillo::Delegates::ResolutionState + include Gem::Resolver::Molinillo::Delegates::SpecificationProvider + + sig { returns(T.untyped) } + def base; end + + sig do + params( + specification_provider: T.untyped, + resolver_ui: T.untyped, + requested: T.untyped, + base: T.untyped + ).returns(Resolution) + end + def initialize(specification_provider, resolver_ui, requested, base); end + + sig { params(iteration_rate: T.untyped).returns(T.untyped) } + def iteration_rate=(iteration_rate); end + + sig { returns(T.untyped) } + def original_requested; end + + sig { returns(T.untyped) } + def resolve; end + + sig { returns(T.untyped) } + def resolver_ui; end + + sig { returns(T.untyped) } + def specification_provider; end + + sig { params(started_at: T.untyped).returns(T.untyped) } + def started_at=(started_at); end + + sig { params(states: T.untyped).returns(T.untyped) } + def states=(states); end + + sig { params(dependency: T.untyped).returns(T::Boolean) } + def allow_missing?(dependency); end + + sig { params(specification: T.untyped).returns(T.untyped) } + def dependencies_for(specification); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def name_for(dependency); end + + sig { returns(T.untyped) } + def name_for_explicit_dependency_source; end + + sig { returns(T.untyped) } + def name_for_locking_dependency_source; end + + sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } + def requirement_satisfied_by?(requirement, activated, spec); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def search_for(dependency); end + + sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } + def sort_dependencies(dependencies, activated, conflicts); end + + sig { returns(T.untyped) } + def activated; end + + sig { returns(T.untyped) } + def conflicts; end + + sig { returns(T.untyped) } + def depth; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def possibilities; end + + sig { returns(T.untyped) } + def requirement; end + + sig { returns(T.untyped) } + def requirements; end + + class Conflict + sig { returns(T.untyped) } + def activated_by_name; end + + sig { params(_: T.untyped).returns(T.untyped) } + def activated_by_name=(_); end + + sig { returns(T.untyped) } + def existing; end + + sig { params(_: T.untyped).returns(T.untyped) } + def existing=(_); end + + sig { returns(T.untyped) } + def locked_requirement; end + + sig { params(_: T.untyped).returns(T.untyped) } + def locked_requirement=(_); end + + sig { returns(T.untyped) } + def possibility; end + + sig { params(_: T.untyped).returns(T.untyped) } + def possibility=(_); end + + sig { returns(T.untyped) } + def requirement; end + + sig { params(_: T.untyped).returns(T.untyped) } + def requirement=(_); end + + sig { returns(T.untyped) } + def requirement_trees; end + + sig { params(_: T.untyped).returns(T.untyped) } + def requirement_trees=(_); end + + sig { returns(T.untyped) } + def requirements; end + + sig { params(_: T.untyped).returns(T.untyped) } + def requirements=(_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.[](*_); end + + sig { returns(T.untyped) } + def self.members; end + end + end + end + + class ResolverError + end + + module SpecificationProvider + sig { params(dependency: T.untyped).returns(T::Boolean) } + def allow_missing?(dependency); end + + sig { params(specification: T.untyped).returns(T.untyped) } + def dependencies_for(specification); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def name_for(dependency); end + + sig { returns(T.untyped) } + def name_for_explicit_dependency_source; end + + sig { returns(T.untyped) } + def name_for_locking_dependency_source; end + + sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } + def requirement_satisfied_by?(requirement, activated, spec); end + + sig { params(dependency: T.untyped).returns(T.untyped) } + def search_for(dependency); end + + sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } + def sort_dependencies(dependencies, activated, conflicts); end + end + + module UI + sig { returns(T.untyped) } + def after_resolution; end + + sig { returns(T.untyped) } + def before_resolution; end + + sig { params(depth: T.untyped).returns(T.untyped) } + def debug(depth = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def debug?; end + + sig { returns(T.untyped) } + def indicate_progress; end + + sig { returns(T.untyped) } + def output; end + + sig { returns(T.untyped) } + def progress_rate; end + end + + class VersionConflict + sig { returns(T.untyped) } + def conflicts; end + + sig { params(conflicts: T.untyped).returns(VersionConflict) } + def initialize(conflicts); end + end + end + + class RequirementList + include Enumerable + + sig { params(req: T.untyped).returns(T.untyped) } + def add(req); end + + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { returns(T::Boolean) } + def empty?; end + + sig { returns(T.untyped) } + def next5; end + + sig { returns(T.untyped) } + def remove; end + + sig { returns(T.untyped) } + def size; end + end + + class Set + sig { returns(T.untyped) } + def errors; end + + sig { params(errors: T.untyped).returns(T.untyped) } + def errors=(errors); end + + sig { params(req: T.untyped).returns(T.untyped) } + def find_all(req); end + + sig { params(reqs: T.untyped).returns(T.untyped) } + def prefetch(reqs); end + + sig { returns(T.untyped) } + def prerelease; end + + sig { params(prerelease: T.untyped).returns(T.untyped) } + def prerelease=(prerelease); end + + sig { returns(T.untyped) } + def remote; end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { returns(T::Boolean) } + def remote?; end + end + + class SourceSet + sig { params(name: T.untyped, source: T.untyped).returns(T.untyped) } + def add_source_gem(name, source); end + end + + class SpecSpecification + sig { params(set: T.untyped, spec: T.untyped, source: T.untyped).returns(SpecSpecification) } + def initialize(set, spec, source = T.unsafe(nil)); end + end + + class Specification + sig { returns(T.untyped) } + def dependencies; end + + sig { params(options: T.untyped).returns(T.untyped) } + def download(options); end + + sig { returns(T.untyped) } + def fetch_development_dependencies; end + + sig { returns(T.untyped) } + def full_name; end + + sig { params(options: T.untyped).returns(T.untyped) } + def install(options = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def installable_platform?; end + + sig { returns(T::Boolean) } + def local?; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def platform; end + + sig { returns(T.untyped) } + def set; end + + sig { returns(T.untyped) } + def source; end + + sig { returns(T.untyped) } + def spec; end + + sig { returns(T.untyped) } + def version; end + end + + class Stats + PATTERN = T.let(nil, T.untyped) + + sig { returns(T.untyped) } + def backtracking!; end + + sig { returns(T.untyped) } + def display; end + + sig { returns(T.untyped) } + def iteration!; end + + sig { params(stack: T.untyped).returns(T.untyped) } + def record_depth(stack); end + + sig { params(reqs: T.untyped).returns(T.untyped) } + def record_requirements(reqs); end + + sig { returns(T.untyped) } + def requirement!; end + end + + class VendorSet + sig { params(name: T.untyped, directory: T.untyped).returns(T.untyped) } + def add_vendor_gem(name, directory); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + source: T.untyped + ).returns(T.untyped) + end + def load_spec(name, version, platform, source); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def specs; end + end + + class VendorSpecification + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + end + end + + class RuntimeRequirementNotMetError + sig { returns(T.untyped) } + def suggestion; end + + sig { params(suggestion: T.untyped).returns(T.untyped) } + def suggestion=(suggestion); end + end + + module Security + AlmostNoSecurity = T.let(nil, T.untyped) + DIGEST_NAME = T.let(nil, T.untyped) + EXTENSIONS = T.let(nil, T.untyped) + HighSecurity = T.let(nil, T.untyped) + KEY_CIPHER = T.let(nil, T.untyped) + KEY_LENGTH = T.let(nil, T.untyped) + LowSecurity = T.let(nil, T.untyped) + MediumSecurity = T.let(nil, T.untyped) + NoSecurity = T.let(nil, T.untyped) + ONE_DAY = T.let(nil, T.untyped) + ONE_YEAR = T.let(nil, T.untyped) + Policies = T.let(nil, T.untyped) + SigningPolicy = T.let(nil, T.untyped) + + sig { params(certificate: T.untyped, x509_entry: T.untyped).returns(T.untyped) } + def self.alt_name_or_x509_entry(certificate, x509_entry); end + + sig do + params( + subject: T.untyped, + key: T.untyped, + age: T.untyped, + extensions: T.untyped, + serial: T.untyped + ).returns(T.untyped) + end + def self.create_cert(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end + + sig do + params( + email: T.untyped, + key: T.untyped, + age: T.untyped, + extensions: T.untyped + ).returns(T.untyped) + end + def self.create_cert_email(email, key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end + + sig do + params( + subject: T.untyped, + key: T.untyped, + age: T.untyped, + extensions: T.untyped, + serial: T.untyped + ).returns(T.untyped) + end + def self.create_cert_self_signed(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end + + sig { params(length: T.untyped, algorithm: T.untyped).returns(T.untyped) } + def self.create_key(length = T.unsafe(nil), algorithm = T.unsafe(nil)); end + + sig { params(email_address: T.untyped).returns(T.untyped) } + def self.email_to_name(email_address); end + + sig do + params( + expired_certificate: T.untyped, + private_key: T.untyped, + age: T.untyped, + extensions: T.untyped + ).returns(T.untyped) + end + def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.reset; end + + sig do + params( + certificate: T.untyped, + signing_key: T.untyped, + signing_cert: T.untyped, + age: T.untyped, + extensions: T.untyped, + serial: T.untyped + ).returns(T.untyped) + end + def self.sign(certificate, signing_key, signing_cert, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.trust_dir; end + + sig { params(block: T.untyped).returns(T.untyped) } + def self.trusted_certificates(&block); end + + sig do + params( + pemmable: T.untyped, + path: T.untyped, + permissions: T.untyped, + passphrase: T.untyped, + cipher: T.untyped + ).returns(T.untyped) + end + def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end + + class DIGEST_ALGORITHM + sig { params(data: T.untyped).returns(DIGEST_ALGORITHM) } + def initialize(data = T.unsafe(nil)); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self.digest(data); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self.hexdigest(data); end + end + + class Exception + end + + class KEY_ALGORITHM + NO_PADDING = T.let(nil, T.untyped) + PKCS1_OAEP_PADDING = T.let(nil, T.untyped) + PKCS1_PADDING = T.let(nil, T.untyped) + SSLV23_PADDING = T.let(nil, T.untyped) + + sig { returns(T.untyped) } + def d; end + + sig { params(d: T.untyped).returns(T.untyped) } + def d=(d); end + + sig { returns(T.untyped) } + def dmp1; end + + sig { params(dmp1: T.untyped).returns(T.untyped) } + def dmp1=(dmp1); end + + sig { returns(T.untyped) } + def dmq1; end + + sig { params(dmq1: T.untyped).returns(T.untyped) } + def dmq1=(dmq1); end + + sig { returns(T.untyped) } + def e; end + + sig { params(e: T.untyped).returns(T.untyped) } + def e=(e); end + + sig { params(_: T.untyped).returns(T.untyped) } + def export(*_); end + + sig { params(_: T.untyped).returns(KEY_ALGORITHM) } + def initialize(*_); end + + sig { returns(T.untyped) } + def iqmp; end + + sig { params(iqmp: T.untyped).returns(T.untyped) } + def iqmp=(iqmp); end + + sig { returns(T.untyped) } + def n; end + + sig { params(n: T.untyped).returns(T.untyped) } + def n=(n); end + + sig { returns(T.untyped) } + def p; end + + sig { params(p: T.untyped).returns(T.untyped) } + def p=(p); end + + sig { returns(T.untyped) } + def params; end + + sig { returns(T::Boolean) } + def private?; end + + sig { params(_: T.untyped).returns(T.untyped) } + def private_decrypt(*_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def private_encrypt(*_); end + + sig { returns(T::Boolean) } + def public?; end + + sig { params(_: T.untyped).returns(T.untyped) } + def public_decrypt(*_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def public_encrypt(*_); end + + sig { returns(T.untyped) } + def public_key; end + + sig { returns(T.untyped) } + def q; end + + sig { params(q: T.untyped).returns(T.untyped) } + def q=(q); end + + sig { params(_: T.untyped, _1: T.untyped, _2: T.untyped).returns(T.untyped) } + def set_crt_params(_, _1, _2); end + + sig { params(_: T.untyped, _1: T.untyped).returns(T.untyped) } + def set_factors(_, _1); end + + sig { params(_: T.untyped, _1: T.untyped, _2: T.untyped).returns(T.untyped) } + def set_key(_, _1, _2); end + + sig { params(_: T.untyped).returns(T.untyped) } + def sign_pss(*_); end + + sig { returns(T.untyped) } + def to_der; end + + sig { params(_: T.untyped).returns(T.untyped) } + def to_pem(*_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def to_s(*_); end + + sig { returns(T.untyped) } + def to_text; end + + sig { params(_: T.untyped).returns(T.untyped) } + def verify_pss(*_); end + + sig { params(_: T.untyped).returns(T.untyped) } + def self.generate(*_); end + end + + class Policy + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + sig { params(signer: T.untyped, issuer: T.untyped, time: T.untyped).returns(T.untyped) } + def check_cert(signer, issuer, time); end + + sig { params(chain: T.untyped, time: T.untyped).returns(T.untyped) } + def check_chain(chain, time); end + + sig do + params( + public_key: T.untyped, + digest: T.untyped, + signature: T.untyped, + data: T.untyped + ).returns(T.untyped) + end + def check_data(public_key, digest, signature, data); end + + sig { params(signer: T.untyped, key: T.untyped).returns(T.untyped) } + def check_key(signer, key); end + + sig { params(chain: T.untyped, time: T.untyped).returns(T.untyped) } + def check_root(chain, time); end + + sig { params(chain: T.untyped, digester: T.untyped, trust_dir: T.untyped).returns(T.untyped) } + def check_trust(chain, digester, trust_dir); end + + sig { params(name: T.untyped, policy: T.untyped, opt: T.untyped).returns(Policy) } + def initialize(name, policy = T.unsafe(nil), opt = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def only_signed; end + + sig { params(only_signed: T.untyped).returns(T.untyped) } + def only_signed=(only_signed); end + + sig { returns(T.untyped) } + def only_trusted; end + + sig { params(only_trusted: T.untyped).returns(T.untyped) } + def only_trusted=(only_trusted); end + + sig { params(certificate: T.untyped).returns(T.untyped) } + def subject(certificate); end + + sig do + params( + chain: T.untyped, + key: T.untyped, + digests: T.untyped, + signatures: T.untyped, + full_name: T.untyped + ).returns(T.untyped) + end + def verify(chain, key = T.unsafe(nil), digests = T.unsafe(nil), signatures = T.unsafe(nil), full_name = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def verify_chain; end + + sig { params(verify_chain: T.untyped).returns(T.untyped) } + def verify_chain=(verify_chain); end + + sig { returns(T.untyped) } + def verify_data; end + + sig { params(verify_data: T.untyped).returns(T.untyped) } + def verify_data=(verify_data); end + + sig { returns(T.untyped) } + def verify_root; end + + sig { params(verify_root: T.untyped).returns(T.untyped) } + def verify_root=(verify_root); end + + sig { params(spec: T.untyped, digests: T.untyped, signatures: T.untyped).returns(T.untyped) } + def verify_signatures(spec, digests, signatures); end + + sig { returns(T.untyped) } + def verify_signer; end + + sig { params(verify_signer: T.untyped).returns(T.untyped) } + def verify_signer=(verify_signer); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class Signer + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + DEFAULT_OPTIONS = T.let(nil, T.untyped) + + sig { returns(T.untyped) } + def cert_chain; end + + sig { params(cert_chain: T.untyped).returns(T.untyped) } + def cert_chain=(cert_chain); end + + sig { returns(T.untyped) } + def digest_algorithm; end + + sig { returns(T.untyped) } + def digest_name; end + + sig { params(cert: T.untyped).returns(T.untyped) } + def extract_name(cert); end + + sig do + params( + key: T.untyped, + cert_chain: T.untyped, + passphrase: T.untyped, + options: T.untyped + ).returns(Signer) + end + def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def key; end + + sig { params(key: T.untyped).returns(T.untyped) } + def key=(key); end + + sig { returns(T.untyped) } + def load_cert_chain; end + + sig { returns(T.untyped) } + def options; end + + sig { params(expiration_length: T.untyped).returns(T.untyped) } + def re_sign_key(expiration_length: T.unsafe(nil)); end + + sig { params(data: T.untyped).returns(T.untyped) } + def sign(data); end + + sig { params(expired_cert: T.untyped, expired_cert_path: T.untyped, private_key: T.untyped).returns(T.untyped) } + def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class TrustDir + DEFAULT_PERMISSIONS = T.let(nil, T.untyped) + + sig { params(certificate: T.untyped).returns(T.untyped) } + def cert_path(certificate); end + + sig { returns(T.untyped) } + def dir; end + + sig { returns(T.untyped) } + def each_certificate; end + + sig { params(dir: T.untyped, permissions: T.untyped).returns(TrustDir) } + def initialize(dir, permissions = T.unsafe(nil)); end + + sig { params(certificate: T.untyped).returns(T.untyped) } + def issuer_of(certificate); end + + sig { params(certificate_file: T.untyped).returns(T.untyped) } + def load_certificate(certificate_file); end + + sig { params(name: T.untyped).returns(T.untyped) } + def name_path(name); end + + sig { params(certificate: T.untyped).returns(T.untyped) } + def trust_cert(certificate); end + + sig { returns(T.untyped) } + def verify; end + end + end + + class SilentUI + sig { returns(SilentUI) } + def initialize; end + end + + class Source + include Comparable + FILES = T.let(nil, T.untyped) + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { params(uri: T.untyped).returns(T.untyped) } + def cache_dir(uri); end + + sig { returns(T.untyped) } + def dependency_resolver_set; end + + sig { params(spec: T.untyped, dir: T.untyped).returns(T.untyped) } + def download(spec, dir = T.unsafe(nil)); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { params(name_tuple: T.untyped).returns(T.untyped) } + def fetch_spec(name_tuple); end + + sig { params(uri: T.untyped).returns(Source) } + def initialize(uri); end + + sig { params(type: T.untyped).returns(T.untyped) } + def load_specs(type); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T::Boolean) } + def update_cache?; end + + sig { returns(T.untyped) } + def uri; end + + class Git + sig { returns(T.untyped) } + def base_dir; end + + sig { returns(T.untyped) } + def cache; end + + sig { returns(T.untyped) } + def checkout; end + + sig { returns(T.untyped) } + def dir_shortref; end + + sig { params(full_spec: T.untyped, path: T.untyped).returns(T.untyped) } + def download(full_spec, path); end + + sig do + params( + name: T.untyped, + repository: T.untyped, + reference: T.untyped, + submodules: T.untyped + ).returns(Git) + end + def initialize(name, repository, reference, submodules = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def install_dir; end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def need_submodules; end + + sig { returns(T.untyped) } + def reference; end + + sig { returns(T.untyped) } + def remote; end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { returns(T.untyped) } + def repo_cache_dir; end + + sig { returns(T.untyped) } + def repository; end + + sig { returns(T.untyped) } + def rev_parse; end + + sig { returns(T.untyped) } + def root_dir; end + + sig { params(root_dir: T.untyped).returns(T.untyped) } + def root_dir=(root_dir); end + + sig { returns(T.untyped) } + def specs; end + + sig { returns(T.untyped) } + def uri_hash; end + end + + class Installed + sig { params(spec: T.untyped, path: T.untyped).returns(T.untyped) } + def download(spec, path); end + + sig { returns(Installed) } + def initialize; end + end + + class Local + sig { params(spec: T.untyped, cache_dir: T.untyped).returns(T.untyped) } + def download(spec, cache_dir = T.unsafe(nil)); end + + sig { params(name: T.untyped).returns(T.untyped) } + def fetch_spec(name); end + + sig { params(gem_name: T.untyped, version: T.untyped, prerelease: T.untyped).returns(T.untyped) } + def find_gem(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end + + sig { returns(Local) } + def initialize; end + end + + class Lock + sig { params(source: T.untyped).returns(Lock) } + def initialize(source); end + + sig { returns(T.untyped) } + def wrapped; end + end + + class SpecificFile + sig { params(name: T.untyped).returns(T.untyped) } + def fetch_spec(name); end + + sig { params(file: T.untyped).returns(SpecificFile) } + def initialize(file); end + + sig { params(a: T.untyped).returns(T.untyped) } + def load_specs(*a); end + + sig { returns(T.untyped) } + def path; end + + sig { returns(T.untyped) } + def spec; end + end + + class Vendor + sig { params(path: T.untyped).returns(Vendor) } + def initialize(path); end + end + end + + class SourceFetchProblem + sig { returns(T.untyped) } + def error; end + + sig { returns(T.untyped) } + def exception; end + + sig { params(source: T.untyped, error: T.untyped).returns(SourceFetchProblem) } + def initialize(source, error); end + + sig { returns(T.untyped) } + def source; end + + sig { returns(T.untyped) } + def wordy; end + end + + class SourceList + include Enumerable + + sig { params(obj: T.untyped).returns(T.untyped) } + def <<(obj); end + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { returns(T.untyped) } + def clear; end + + sig { params(source: T.untyped).returns(T.untyped) } + def delete(source); end + + sig { params(blk: T.untyped).returns(T.untyped) } + def each(&blk); end + + sig { params(b: T.untyped).returns(T.untyped) } + def each_source(&b); end + + sig { returns(T::Boolean) } + def empty?; end + + sig { returns(T.untyped) } + def first; end + + sig { params(other: T.untyped).returns(T::Boolean) } + def include?(other); end + + sig { params(other: T.untyped).returns(T.untyped) } + def replace(other); end + + sig { returns(T.untyped) } + def sources; end + + sig { returns(T.untyped) } + def to_a; end + + sig { returns(T.untyped) } + def to_ary; end + + sig { params(ary: T.untyped).returns(T.untyped) } + def self.from(ary); end + end + + class SpecFetcher + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + sig { params(type: T.untyped).returns(T.untyped) } + def available_specs(type); end + + sig { params(type: T.untyped).returns(T.untyped) } + def detect(type = T.unsafe(nil)); end + + sig { params(sources: T.untyped).returns(SpecFetcher) } + def initialize(sources = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def latest_specs; end + + sig { returns(T.untyped) } + def prerelease_specs; end + + sig { params(dependency: T.untyped, matching_platform: T.untyped).returns(T.untyped) } + def search_for_dependency(dependency, matching_platform = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def sources; end + + sig { params(dependency: T.untyped, matching_platform: T.untyped).returns(T.untyped) } + def spec_for_dependency(dependency, matching_platform = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def specs; end + + sig { params(gem_name: T.untyped, type: T.untyped).returns(T.untyped) } + def suggest_gems_from_name(gem_name, type = T.unsafe(nil)); end + + sig { params(source: T.untyped, type: T.untyped, gracefully_ignore: T.untyped).returns(T.untyped) } + def tuples_for(source, type, gracefully_ignore = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def self.fetcher; end + + sig { params(fetcher: T.untyped).returns(T.untyped) } + def self.fetcher=(fetcher); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + end + + class SpecificGemNotFoundException + sig { returns(T.untyped) } + def errors; end + + sig { params(name: T.untyped, version: T.untyped, errors: T.untyped).returns(SpecificGemNotFoundException) } + def initialize(name, version, errors = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def version; end + end + + class Specification + include Bundler::MatchPlatform + include Bundler::GemHelpers + extend Enumerable + extend Gem::Deprecate + DateLike = T.let(nil, T.untyped) + DateTimeFormat = T.let(nil, T.untyped) + INITIALIZE_CODE_FOR_DEFAULTS = T.let(nil, T.untyped) + + sig { params(other: T.untyped).returns(T.untyped) } + def ==(other); end + + sig { returns(T.untyped) } + def _deprecated_default_executable; end + + sig { params(_deprecated_default_executable: T.untyped).returns(T.untyped) } + def _deprecated_default_executable=(_deprecated_default_executable); end + + sig { returns(T.untyped) } + def _deprecated_has_rdoc; end + + sig { params(ignored: T.untyped).returns(T.untyped) } + def _deprecated_has_rdoc=(ignored); end + + sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) } + def _deprecated_has_rdoc?(*args, &block); end + + sig { params(limit: T.untyped).returns(T.untyped) } + def _dump(limit); end + + sig { returns(T.untyped) } + def abbreviate; end + + sig { returns(T.untyped) } + def activate; end + + sig { returns(T.untyped) } + def activate_dependencies; end + + sig { returns(T.untyped) } + def activated; end + + sig { params(activated: T.untyped).returns(T.untyped) } + def activated=(activated); end + + sig { params(executables: T.untyped).returns(T.untyped) } + def add_bindir(executables); end + + sig { params(gem: T.untyped, requirements: T.untyped).returns(T.untyped) } + def add_dependency(gem, *requirements); end + + sig { params(gem: T.untyped, requirements: T.untyped).returns(T.untyped) } + def add_development_dependency(gem, *requirements); end + + sig { params(gem: T.untyped, requirements: T.untyped).returns(T.untyped) } + def add_runtime_dependency(gem, *requirements); end + + sig { returns(T.untyped) } + def add_self_to_load_path; end + + sig { returns(T.untyped) } + def author; end + + sig { params(o: T.untyped).returns(T.untyped) } + def author=(o); end + + sig { returns(T.untyped) } + def authors; end + + sig { params(value: T.untyped).returns(T.untyped) } + def authors=(value); end + + sig { returns(T.untyped) } + def autorequire; end + + sig { params(autorequire: T.untyped).returns(T.untyped) } + def autorequire=(autorequire); end + + sig { returns(T.untyped) } + def bin_dir; end + + sig { params(name: T.untyped).returns(T.untyped) } + def bin_file(name); end + + sig { returns(T.untyped) } + def bindir; end + + sig { params(bindir: T.untyped).returns(T.untyped) } + def bindir=(bindir); end + + sig { returns(T.untyped) } + def build_args; end + + sig { returns(T.untyped) } + def build_extensions; end + + sig { returns(T.untyped) } + def build_info_dir; end + + sig { returns(T.untyped) } + def build_info_file; end + + sig { returns(T.untyped) } + def cache_dir; end + + sig { returns(T.untyped) } + def cache_file; end + + sig { returns(T.untyped) } + def cert_chain; end + + sig { params(cert_chain: T.untyped).returns(T.untyped) } + def cert_chain=(cert_chain); end + + sig { params(list_of_specs: T.untyped).returns(T::Boolean) } + def conficts_when_loaded_with?(list_of_specs); end + + sig { returns(T.untyped) } + def conflicts; end + + sig { returns(T.untyped) } + def date; end + + sig { params(date: T.untyped).returns(T.untyped) } + def date=(date); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def default_executable(*args, &block); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def default_executable=(*args, &block); end + + sig { params(name: T.untyped).returns(T.untyped) } + def default_value(name); end + + sig { returns(T.untyped) } + def dependencies; end + + sig { returns(T.untyped) } + def dependent_gems; end + + sig { returns(T.untyped) } + def dependent_specs; end + + sig { returns(T.untyped) } + def description; end + + sig { params(str: T.untyped).returns(T.untyped) } + def description=(str); end + + sig { returns(T.untyped) } + def development_dependencies; end + + sig { params(type: T.untyped).returns(T.untyped) } + def doc_dir(type = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def email; end + + sig { params(email: T.untyped).returns(T.untyped) } + def email=(email); end + + sig { params(coder: T.untyped).returns(T.untyped) } + def encode_with(coder); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { returns(T.untyped) } + def executable; end + + sig { params(o: T.untyped).returns(T.untyped) } + def executable=(o); end + + sig { returns(T.untyped) } + def executables; end + + sig { params(value: T.untyped).returns(T.untyped) } + def executables=(value); end + + sig { returns(T.untyped) } + def extensions; end + + sig { params(extensions: T.untyped).returns(T.untyped) } + def extensions=(extensions); end + + sig { returns(T.untyped) } + def extra_rdoc_files; end + + sig { params(files: T.untyped).returns(T.untyped) } + def extra_rdoc_files=(files); end + + sig { returns(T.untyped) } + def file_name; end + + sig { returns(T.untyped) } + def files; end + + sig { params(files: T.untyped).returns(T.untyped) } + def files=(files); end + + sig { returns(T.untyped) } + def for_cache; end + + sig { returns(T.untyped) } + def git_version; end + + sig { returns(T.untyped) } + def groups; end + + sig { returns(T::Boolean) } + def has_conflicts?; end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def has_rdoc(*args, &block); end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def has_rdoc=(*args, &block); end + + sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) } + def has_rdoc?(*args, &block); end + + sig { returns(T::Boolean) } + def has_test_suite?; end + + sig { returns(T::Boolean) } + def has_unit_tests?; end + + sig { returns(T.untyped) } + def homepage; end + + sig { params(homepage: T.untyped).returns(T.untyped) } + def homepage=(homepage); end + + sig { params(coder: T.untyped).returns(T.untyped) } + def init_with(coder); end + + sig { params(name: T.untyped, version: T.untyped).returns(Specification) } + def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def installed_by_version; end + + sig { params(version: T.untyped).returns(T.untyped) } + def installed_by_version=(version); end + + sig { returns(T.untyped) } + def keep_only_files_and_directories; end + + sig { returns(T.untyped) } + def lib_files; end + + sig { returns(T.untyped) } + def license; end + + sig { params(o: T.untyped).returns(T.untyped) } + def license=(o); end + + sig { returns(T.untyped) } + def licenses; end + + sig { params(licenses: T.untyped).returns(T.untyped) } + def licenses=(licenses); end + + sig { returns(T.untyped) } + def load_paths; end + + sig { returns(T.untyped) } + def location; end + + sig { params(location: T.untyped).returns(T.untyped) } + def location=(location); end + + sig { returns(T.untyped) } + def mark_version; end + + sig { returns(T.untyped) } + def metadata; end + + sig { params(metadata: T.untyped).returns(T.untyped) } + def metadata=(metadata); end + + sig { params(sym: T.untyped, a: T.untyped, b: T.untyped).returns(T.untyped) } + def method_missing(sym, *a, &b); end + + sig { returns(T::Boolean) } + def missing_extensions?; end + + sig { params(name: T.untyped).returns(T.untyped) } + def name=(name); end + + sig { returns(T.untyped) } + def name_tuple; end + + sig { returns(T.untyped) } + def nondevelopment_dependencies; end + + sig { returns(T.untyped) } + def normalize; end + + sig { returns(T.untyped) } + def original_name; end + + sig { returns(T.untyped) } + def original_platform; end + + sig { params(original_platform: T.untyped).returns(T.untyped) } + def original_platform=(original_platform); end + + sig { params(platform: T.untyped).returns(T.untyped) } + def platform=(platform); end + + sig { returns(T.untyped) } + def post_install_message; end + + sig { params(post_install_message: T.untyped).returns(T.untyped) } + def post_install_message=(post_install_message); end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def raise_if_conflicts; end + + sig { returns(T.untyped) } + def rdoc_options; end + + sig { params(options: T.untyped).returns(T.untyped) } + def rdoc_options=(options); end + + sig { returns(T.untyped) } + def relative_loaded_from; end + + sig { params(relative_loaded_from: T.untyped).returns(T.untyped) } + def relative_loaded_from=(relative_loaded_from); end + + sig { returns(T.untyped) } + def remote; end + + sig { params(remote: T.untyped).returns(T.untyped) } + def remote=(remote); end + + sig { returns(T.untyped) } + def require_path; end + + sig { params(path: T.untyped).returns(T.untyped) } + def require_path=(path); end + + sig { params(val: T.untyped).returns(T.untyped) } + def require_paths=(val); end + + sig { returns(T.untyped) } + def required_ruby_version; end + + sig { params(req: T.untyped).returns(T.untyped) } + def required_ruby_version=(req); end + + sig { returns(T.untyped) } + def required_rubygems_version; end + + sig { params(req: T.untyped).returns(T.untyped) } + def required_rubygems_version=(req); end + + sig { returns(T.untyped) } + def requirements; end + + sig { params(req: T.untyped).returns(T.untyped) } + def requirements=(req); end + + sig { returns(T.untyped) } + def reset_nil_attributes_to_default; end + + sig { returns(T.untyped) } + def rg_extension_dir; end + + sig { returns(T.untyped) } + def rg_full_gem_path; end + + sig { returns(T.untyped) } + def rg_loaded_from; end + + sig { returns(T.untyped) } + def ri_dir; end + + sig { params(rubyforge_project: T.untyped).returns(T.untyped) } + def rubyforge_project=(rubyforge_project); end + + sig { returns(T.untyped) } + def rubygems_version; end + + sig { params(rubygems_version: T.untyped).returns(T.untyped) } + def rubygems_version=(rubygems_version); end + + sig { returns(T.untyped) } + def runtime_dependencies; end + + sig { returns(T.untyped) } + def sanitize; end + + sig { params(string: T.untyped).returns(T.untyped) } + def sanitize_string(string); end + + sig { params(dependency: T.untyped).returns(T::Boolean) } + def satisfies_requirement?(dependency); end + + sig { returns(T.untyped) } + def signing_key; end + + sig { params(signing_key: T.untyped).returns(T.untyped) } + def signing_key=(signing_key); end + + sig { returns(T.untyped) } + def sort_obj; end + + sig { returns(T.untyped) } + def source; end + + sig { params(source: T.untyped).returns(T.untyped) } + def source=(source); end + + sig { returns(T.untyped) } + def spec_dir; end + + sig { returns(T.untyped) } + def spec_file; end + + sig { returns(T.untyped) } + def spec_name; end + + sig { returns(T.untyped) } + def specification_version; end + + sig { params(specification_version: T.untyped).returns(T.untyped) } + def specification_version=(specification_version); end + + sig { returns(T.untyped) } + def summary; end + + sig { params(str: T.untyped).returns(T.untyped) } + def summary=(str); end + + sig { returns(T.untyped) } + def test_file; end + + sig { params(file: T.untyped).returns(T.untyped) } + def test_file=(file); end + + sig { returns(T.untyped) } + def test_files; end + + sig { params(files: T.untyped).returns(T.untyped) } + def test_files=(files); end + + sig { params(path: T.untyped).returns(T.untyped) } + def to_gemfile(path = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def to_ruby; end + + sig { returns(T.untyped) } + def to_ruby_for_cache; end + + sig { params(opts: T.untyped).returns(T.untyped) } + def to_yaml(opts = T.unsafe(nil)); end + + sig { params(trail: T.untyped, visited: T.untyped, block: T.untyped).returns(T.untyped) } + def traverse(trail = T.unsafe(nil), visited = T.unsafe(nil), &block); end + + sig { params(packaging: T.untyped, strict: T.untyped).returns(T.untyped) } + def validate(packaging = T.unsafe(nil), strict = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def validate_dependencies; end + + sig { returns(T.untyped) } + def validate_metadata; end + + sig { returns(T.untyped) } + def validate_permissions; end + + sig { params(version: T.untyped).returns(T.untyped) } + def version=(version); end + + sig { params(tag: T.untyped, vals: T.untyped).returns(T.untyped) } + def yaml_initialize(tag, vals); end + + sig { returns(T.untyped) } + def self._all; end + + sig { returns(T.untyped) } + def self._clear_load_cache; end + + sig { params(specs: T.untyped, prerelease: T.untyped).returns(T.untyped) } + def self._latest_specs(specs, prerelease = T.unsafe(nil)); end + + sig { params(str: T.untyped).returns(T.untyped) } + def self._load(str); end + + sig { params(specs: T.untyped).returns(T.untyped) } + def self._resort!(specs); end + + sig { params(spec: T.untyped).returns(T.untyped) } + def self.add_spec(spec); end + + sig { params(specs: T.untyped).returns(T.untyped) } + def self.add_specs(*specs); end + + sig { returns(T.untyped) } + def self.all; end + + sig { params(specs: T.untyped).returns(T.untyped) } + def self.all=(specs); end + + sig { returns(T.untyped) } + def self.all_names; end + + sig { returns(T.untyped) } + def self.array_attributes; end + + sig { returns(T.untyped) } + def self.attribute_names; end + + sig { returns(T.untyped) } + def self.dirs; end + + sig { params(dirs: T.untyped).returns(T.untyped) } + def self.dirs=(dirs); end + + sig { params(blk: T.untyped).returns(T.untyped) } + def self.each(&blk); end + + sig { params(dirs: T.untyped).returns(T.untyped) } + def self.each_gemspec(dirs); end + + sig { params(dirs: T.untyped).returns(T.untyped) } + def self.each_spec(dirs); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.find_active_stub_by_path(path); end + + sig { params(full_name: T.untyped).returns(T.untyped) } + def self.find_all_by_full_name(full_name); end + + sig { params(name: T.untyped, requirements: T.untyped).returns(T.untyped) } + def self.find_all_by_name(name, *requirements); end + + sig { params(name: T.untyped, requirements: T.untyped).returns(T.untyped) } + def self.find_by_name(name, *requirements); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.find_by_path(path); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.find_in_unresolved(path); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.find_in_unresolved_tree(path); end + + sig { params(path: T.untyped).returns(T.untyped) } + def self.find_inactive_by_path(path); end + + sig { params(input: T.untyped).returns(T.untyped) } + def self.from_yaml(input); end + + sig { params(prerelease: T.untyped).returns(T.untyped) } + def self.latest_specs(prerelease = T.unsafe(nil)); end + + sig { params(file: T.untyped).returns(T.untyped) } + def self.load(file); end + + sig { returns(T.untyped) } + def self.load_defaults; end + + sig { returns(T.untyped) } + def self.non_nil_attributes; end + + sig { params(input: T.untyped).returns(T.untyped) } + def self.normalize_yaml_input(input); end + + sig { returns(T.untyped) } + def self.outdated; end + + sig { returns(T.untyped) } + def self.outdated_and_latest_version; end + + sig { params(spec: T.untyped).returns(T.untyped) } + def self.remove_spec(spec); end + + sig { params(name: T.untyped).returns(T::Boolean) } + def self.required_attribute?(name); end + + sig { returns(T.untyped) } + def self.required_attributes; end + + sig { returns(T.untyped) } + def self.reset; end + + sig { returns(T.untyped) } + def self.stubs; end + + sig { params(name: T.untyped).returns(T.untyped) } + def self.stubs_for(name); end + + sig { returns(T.untyped) } + def self.unresolved_deps; end + end + + class SpecificationPolicy + HOMEPAGE_URI_PATTERN = T.let(nil, T.untyped) + LAZY = T.let(nil, T.untyped) + LAZY_PATTERN = T.let(nil, T.untyped) + METADATA_LINK_KEYS = T.let(nil, T.untyped) + SPECIAL_CHARACTERS = T.let(nil, T.untyped) + VALID_NAME_PATTERN = T.let(nil, T.untyped) + VALID_URI_PATTERN = T.let(nil, T.untyped) + + sig { params(specification: T.untyped).returns(SpecificationPolicy) } + def initialize(specification); end + + sig { returns(T.untyped) } + def packaging; end + + sig { params(packaging: T.untyped).returns(T.untyped) } + def packaging=(packaging); end + + sig { params(strict: T.untyped).returns(T.untyped) } + def validate(strict = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def validate_dependencies; end + + sig { returns(T.untyped) } + def validate_metadata; end + + sig { returns(T.untyped) } + def validate_permissions; end + end + + class StreamUI + extend Gem::Deprecate + + sig { params(statement: T.untyped).returns(T.untyped) } + def _deprecated_debug(statement); end + + sig { returns(T.untyped) } + def _gets_noecho; end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask_for_password(question); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(exception: T.untyped).returns(T.untyped) } + def backtrace(exception); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { returns(T.untyped) } + def close; end + + sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } + def debug(*args, &block); end + + sig { params(args: T.untyped).returns(T.untyped) } + def download_reporter(*args); end + + sig { returns(T.untyped) } + def errs; end + + sig do + params( + in_stream: T.untyped, + out_stream: T.untyped, + err_stream: T.untyped, + usetty: T.untyped + ).returns(StreamUI) + end + def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ins; end + + sig { returns(T.untyped) } + def outs; end + + sig { params(args: T.untyped).returns(T.untyped) } + def progress_reporter(*args); end + + sig { returns(T.untyped) } + def require_io_console; end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(status: T.untyped).returns(T.untyped) } + def terminate_interaction(status = T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def tty?; end + end + + class StubSpecification + sig { returns(T.untyped) } + def build_extensions; end + + sig { returns(T.untyped) } + def extensions; end + + sig do + params( + filename: T.untyped, + base_dir: T.untyped, + gems_dir: T.untyped, + default_gem: T.untyped + ).returns(StubSpecification) + end + def initialize(filename, base_dir, gems_dir, default_gem); end + + sig { returns(T::Boolean) } + def missing_extensions?; end + + sig { returns(T::Boolean) } + def valid?; end + + sig { params(filename: T.untyped, base_dir: T.untyped, gems_dir: T.untyped).returns(T.untyped) } + def self.default_gemspec_stub(filename, base_dir, gems_dir); end + + sig { params(filename: T.untyped, base_dir: T.untyped, gems_dir: T.untyped).returns(T.untyped) } + def self.gemspec_stub(filename, base_dir, gems_dir); end + + class StubLine + sig { returns(T.untyped) } + def extensions; end + + sig { returns(T.untyped) } + def full_name; end + + sig { params(data: T.untyped, extensions: T.untyped).returns(StubLine) } + def initialize(data, extensions); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def platform; end + + sig { returns(T.untyped) } + def require_paths; end + + sig { returns(T.untyped) } + def version; end + end + end + + class SystemExitException + sig { returns(T.untyped) } + def exit_code; end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def exit_code=(exit_code); end + + sig { params(exit_code: T.untyped).returns(SystemExitException) } + def initialize(exit_code); end + end + + module Text + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + end + + class UninstallError + sig { returns(T.untyped) } + def spec; end + + sig { params(spec: T.untyped).returns(T.untyped) } + def spec=(spec); end + end + + class UnsatisfiableDependencyError + sig { returns(T.untyped) } + def dependency; end + + sig { returns(T.untyped) } + def errors; end + + sig { params(errors: T.untyped).returns(T.untyped) } + def errors=(errors); end + + sig { params(dep: T.untyped, platform_mismatch: T.untyped).returns(UnsatisfiableDependencyError) } + def initialize(dep, platform_mismatch = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def name; end + + sig { returns(T.untyped) } + def version; end + end + + class UriFormatter + sig { returns(T.untyped) } + def escape; end + + sig { params(uri: T.untyped).returns(UriFormatter) } + def initialize(uri); end + + sig { returns(T.untyped) } + def normalize; end + + sig { returns(T.untyped) } + def unescape; end + + sig { returns(T.untyped) } + def uri; end + end + + module UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_error(statement, question = T.unsafe(nil)); end + + sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } + def alert_warning(statement, question = T.unsafe(nil)); end + + sig { params(question: T.untyped).returns(T.untyped) } + def ask(question); end + + sig { params(prompt: T.untyped).returns(T.untyped) } + def ask_for_password(prompt); end + + sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } + def ask_yes_no(question, default = T.unsafe(nil)); end + + sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } + def choose_from_list(question, list); end + + sig { params(statement: T.untyped).returns(T.untyped) } + def say(statement = T.unsafe(nil)); end + + sig { params(exit_code: T.untyped).returns(T.untyped) } + def terminate_interaction(exit_code = T.unsafe(nil)); end + + sig { params(msg: T.untyped).returns(T.untyped) } + def verbose(msg = T.unsafe(nil)); end + + sig { params(text: T.untyped).returns(T.untyped) } + def clean_text(text); end + + sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } + def format_text(text, wrap, indent = T.unsafe(nil)); end + + sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } + def levenshtein_distance(str1, str2); end + + sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } + def min3(a, b, c); end + + sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + sig { returns(T.untyped) } + def ui; end + + sig { params(new_ui: T.untyped).returns(T.untyped) } + def ui=(new_ui); end + + sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } + def use_ui(new_ui, &block); end + end + + module Util + sig { params(glob: T.untyped, base_path: T.untyped).returns(T.untyped) } + def self.glob_files_in_dir(glob, base_path); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self.gunzip(data); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self.gzip(data); end + + sig { params(data: T.untyped).returns(T.untyped) } + def self.inflate(data); end + + sig { params(command: T.untyped).returns(T.untyped) } + def self.popen(*command); end + + sig { params(command: T.untyped).returns(T.untyped) } + def self.silent_system(*command); end + + sig { params(directory: T.untyped, block: T.untyped).returns(T.untyped) } + def self.traverse_parents(directory, &block); end + end + + class Version + sig { returns(T.untyped) } + def _segments; end + + sig { returns(T.untyped) } + def _split_segments; end + + sig { returns(T.untyped) } + def _version; end + + sig { returns(T.untyped) } + def approximate_recommendation; end + + sig { returns(T.untyped) } + def bump; end + + sig { returns(T.untyped) } + def canonical_segments; end + + sig { params(coder: T.untyped).returns(T.untyped) } + def encode_with(coder); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def eql?(other); end + + sig { params(coder: T.untyped).returns(T.untyped) } + def init_with(coder); end + + sig { returns(T.untyped) } + def marshal_dump; end + + sig { params(array: T.untyped).returns(T.untyped) } + def marshal_load(array); end + + sig { returns(T::Boolean) } + def prerelease?; end + + sig { params(q: T.untyped).returns(T.untyped) } + def pretty_print(q); end + + sig { returns(T.untyped) } + def release; end + + sig { returns(T.untyped) } + def segments; end + + sig { returns(T.untyped) } + def to_yaml_properties; end + + sig { returns(T.untyped) } + def version; end + + sig { params(tag: T.untyped, map: T.untyped).returns(T.untyped) } + def yaml_initialize(tag, map); end + + sig { params(version: T.untyped).returns(T::Boolean) } + def self.correct?(version); end + + sig { params(input: T.untyped).returns(T.untyped) } + def self.create(input); end + + sig { params(version: T.untyped).returns(T.untyped) } + def self.new(version); end + end +end + +Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError +Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_ +Gem::Version::Requirement = Gem::Requirement +Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict From 736f773c698641a4a45c2de70ebfc82740d9f1e9 Mon Sep 17 00:00:00 2001 From: Connor Shea <connor.james.shea@gmail.com> Date: Thu, 1 Aug 2019 21:54:44 -0600 Subject: [PATCH 2/6] Fix a few type errors. I'm stumped as to how the last one is supposed to be fixed. --- lib/bundler/all/bundler.rbi | 1 + lib/ruby/all/gem.rbi | 17 ++++++++++++----- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/lib/bundler/all/bundler.rbi b/lib/bundler/all/bundler.rbi index e7a1011f..ac69245c 100644 --- a/lib/bundler/all/bundler.rbi +++ b/lib/bundler/all/bundler.rbi @@ -1210,6 +1210,7 @@ end class Bundler::EndpointSpecification < Gem::Specification ILLFORMED_MESSAGE = ::T.let(nil, ::T.untyped) + Elem = type_member(fixed: T.untyped) sig do params( diff --git a/lib/ruby/all/gem.rbi b/lib/ruby/all/gem.rbi index 3803c6d7..33c953db 100644 --- a/lib/ruby/all/gem.rbi +++ b/lib/ruby/all/gem.rbi @@ -278,6 +278,7 @@ module Gem class AvailableSet include Enumerable + Elem = type_member(fixed: T.untyped) sig { params(o: T.untyped).returns(T.untyped) } def <<(o); end @@ -1127,6 +1128,7 @@ module Gem class DependencyList include Enumerable include TSort + Elem = type_member(fixed: T.untyped) sig { params(gemspecs: T.untyped).returns(T.untyped) } def add(*gemspecs); end @@ -1149,7 +1151,7 @@ module Gem sig { params(full_name: T.untyped).returns(T.untyped) } def find_name(full_name); end - sig { params(development: T.untyped).returns(DependencyList) } + sig { params(development: T.untyped).returns(T.untyped) } def initialize(development = T.unsafe(nil)); end sig { returns(T::Boolean) } @@ -1678,7 +1680,7 @@ module Gem sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { params(value: T.untyped, tail: T.untyped).returns(List) } + sig { params(value: T.untyped, tail: T.untyped).returns(T.untyped) } def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end sig { params(value: T.untyped).returns(T.untyped) } @@ -2146,6 +2148,7 @@ module Gem class TarReader include Enumerable + Elem = type_member(fixed: T.untyped) sig { returns(T.untyped) } def close; end @@ -2156,7 +2159,7 @@ module Gem sig { returns(T.untyped) } def each_entry; end - sig { params(io: T.untyped).returns(TarReader) } + sig { params(io: T.untyped).returns(T.untyped) } def initialize(io); end sig { returns(T.untyped) } @@ -3314,7 +3317,7 @@ module Gem sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(set: T.untyped, api_data: T.untyped).returns(APISpecification) } + sig { params(set: T.untyped, api_data: T.untyped).returns(T.untyped) } def initialize(set, api_data); end sig { params(q: T.untyped).returns(T.untyped) } @@ -3735,6 +3738,7 @@ module Gem class DependencyGraph include Enumerable include TSort + Elem = type_member(fixed: T.untyped) sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end @@ -3900,7 +3904,8 @@ module Gem end class Log - extend Enumerable + extend T::Enumerable + Elem = type_member(fixed: T.untyped) sig do params( @@ -4346,6 +4351,7 @@ module Gem class RequirementList include Enumerable + Elem = type_member(fixed: T.untyped) sig { params(req: T.untyped).returns(T.untyped) } def add(req); end @@ -5193,6 +5199,7 @@ module Gem class SourceList include Enumerable + Elem = type_member(fixed: T.untyped) sig { params(obj: T.untyped).returns(T.untyped) } def <<(obj); end From 17c5b16926bf78da50e702238e243dae59571885 Mon Sep 17 00:00:00 2001 From: Connor Shea <connor.james.shea@gmail.com> Date: Fri, 2 Aug 2019 18:13:48 -0600 Subject: [PATCH 3/6] Remove untyped signatures from gem.rbi. --- lib/ruby/all/gem.rbi | 1836 +----------------------------------------- 1 file changed, 26 insertions(+), 1810 deletions(-) diff --git a/lib/ruby/all/gem.rbi b/lib/ruby/all/gem.rbi index 33c953db..fc2d4fc8 100644 --- a/lib/ruby/all/gem.rbi +++ b/lib/ruby/all/gem.rbi @@ -6,473 +6,320 @@ module Gem RubyGemsVersion = T.let(nil, T.untyped) USE_BUNDLER_FOR_GEMDEPS = T.let(nil, T.untyped) - sig { params(path: T.untyped).returns(T.untyped) } def self._deprecated_detect_gemdeps(path = T.unsafe(nil)); end - sig { params(data: T.untyped).returns(T.untyped) } def self._deprecated_gunzip(data); end - sig { params(data: T.untyped).returns(T.untyped) } def self._deprecated_gzip(data); end - sig { params(data: T.untyped).returns(T.untyped) } def self._deprecated_inflate(data); end - sig { params(name: T.untyped, args: T.untyped).returns(T.untyped) } def self.activate_bin_path(name, *args); end - sig { params(base_dir: T.untyped).returns(T.untyped) } def self.default_ext_dir_for(base_dir); end - sig { returns(T::Boolean) } def self.default_gems_use_full_paths?; end - sig { returns(T.untyped) } def self.default_spec_cache_dir; end - sig { params(data: T.untyped).returns(T.untyped) } def self.deflate(data); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def self.detect_gemdeps(*args, &block); end - sig { returns(T.untyped) } def self.dir; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.done_installing(&hook); end - sig { returns(T.untyped) } def self.done_installing_hooks; end - sig { params(dir: T.untyped, mode: T.untyped).returns(T.untyped) } def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil); end - sig { params(dir: T.untyped, mode: T.untyped).returns(T.untyped) } def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil); end - sig { params(dir: T.untyped, mode: T.untyped, subdirs: T.untyped).returns(T.untyped) } def self.ensure_subdirectories(dir, mode, subdirs); end - sig { params(gem_name: T.untyped).returns(T.untyped) } def self.env_requirement(gem_name); end - sig { returns(T.untyped) } def self.extension_api_version; end - sig { params(glob: T.untyped, check_load_path: T.untyped).returns(T.untyped) } def self.find_files(glob, check_load_path = true); end - sig { params(glob: T.untyped).returns(T.untyped) } def self.find_files_from_load_path(glob); end - sig { params(glob: T.untyped, check_load_path: T.untyped).returns(T.untyped) } def self.find_latest_files(glob, check_load_path = T.unsafe(nil)); end - sig { params(path: T.untyped).returns(T.untyped) } def self.find_unresolved_default_spec(path); end - sig { params(_: T.untyped).returns(T.untyped) } def self.finish_resolve(*_); end - sig { returns(T.untyped) } def self.gemdeps; end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def self.gunzip(*args, &block); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def self.gzip(*args, &block); end - sig { returns(T.untyped) } def self.host; end - sig { params(host: T.untyped).returns(T.untyped) } def self.host=(host); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def self.inflate(*args, &block); end - sig { params(name: T.untyped, version: T.untyped, options: T.untyped).returns(T.untyped) } def self.install(name, version = T.unsafe(nil), *options); end - sig { returns(T.untyped) } def self.install_extension_in_lib; end - sig { returns(T.untyped) } def self.latest_rubygems_version; end - sig { params(name: T.untyped).returns(T.untyped) } def self.latest_spec_for(name); end - sig { params(name: T.untyped).returns(T.untyped) } def self.latest_version_for(name); end - sig { returns(T.untyped) } def self.load_env_plugins; end - sig { returns(T.untyped) } def self.load_path_insert_index; end - sig { params(plugins: T.untyped).returns(T.untyped) } def self.load_plugin_files(plugins); end - sig { returns(T.untyped) } def self.load_plugins; end - sig { returns(T.untyped) } def self.load_yaml; end - sig { returns(T.untyped) } def self.loaded_specs; end - sig { params(depth: T.untyped).returns(T.untyped) } def self.location_of_caller(depth = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.marshal_version; end - sig { returns(T.untyped) } def self.needs; end - sig { returns(T.untyped) } def self.operating_system_defaults; end - sig { returns(T.untyped) } def self.path; end - sig { returns(T.untyped) } def self.path_separator; end - sig { returns(T.untyped) } def self.paths; end - sig { params(env: T.untyped).returns(T.untyped) } def self.paths=(env); end - sig { returns(T.untyped) } def self.platform_defaults; end - sig { returns(T.untyped) } def self.platforms; end - sig { params(platforms: T.untyped).returns(T.untyped) } def self.platforms=(platforms); end - sig { params(hook: T.untyped).returns(T.untyped) } def self.post_build(&hook); end - sig { returns(T.untyped) } def self.post_build_hooks; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.post_install(&hook); end - sig { returns(T.untyped) } def self.post_install_hooks; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.post_reset(&hook); end - sig { returns(T.untyped) } def self.post_reset_hooks; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.post_uninstall(&hook); end - sig { returns(T.untyped) } def self.post_uninstall_hooks; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.pre_install(&hook); end - sig { returns(T.untyped) } def self.pre_install_hooks; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.pre_reset(&hook); end - sig { returns(T.untyped) } def self.pre_reset_hooks; end - sig { params(hook: T.untyped).returns(T.untyped) } def self.pre_uninstall(&hook); end - sig { returns(T.untyped) } def self.pre_uninstall_hooks; end - sig { returns(T.untyped) } def self.prefix; end - sig { params(path: T.untyped).returns(T.untyped) } def self.read_binary(path); end - sig { returns(T.untyped) } def self.refresh; end - sig { params(spec: T.untyped).returns(T.untyped) } def self.register_default_spec(spec); end - sig { params(spec: T.untyped).returns(T.untyped) } def self.remove_unresolved_default_spec(spec); end - sig { returns(T.untyped) } def self.ruby; end - sig { returns(T.untyped) } def self.ruby_api_version; end - sig { returns(T.untyped) } def self.ruby_engine; end - sig { returns(T.untyped) } def self.ruby_version; end - sig { returns(T.untyped) } def self.rubygems_version; end - sig { returns(T.untyped) } def self.sources; end - sig { params(new_sources: T.untyped).returns(T.untyped) } def self.sources=(new_sources); end - sig { returns(T.untyped) } def self.spec_cache_dir; end - sig { returns(T.untyped) } def self.suffix_pattern; end - sig { returns(T.untyped) } def self.suffixes; end - sig { params(msg: T.untyped, width: T.untyped, display: T.untyped).returns(T.untyped) } def self.time(msg, width = T.unsafe(nil), display = T.unsafe(nil)); end - sig { params(path: T.untyped).returns(T.untyped) } def self.try_activate(path); end - sig { returns(T.untyped) } def self.ui; end - sig { params(path: T.untyped).returns(T.untyped) } def self.use_gemdeps(path = T.unsafe(nil)); end - sig { params(home: T.untyped, paths: T.untyped).returns(T.untyped) } def self.use_paths(home, *paths); end - sig { returns(T.untyped) } def self.user_dir; end - sig { returns(T.untyped) } def self.user_home; end - sig { returns(T.untyped) } def self.vendor_dir; end - sig { returns(T::Boolean) } def self.win_platform?; end - sig { params(path: T.untyped, data: T.untyped).returns(T.untyped) } def self.write_binary(path, data); end class AvailableSet include Enumerable Elem = type_member(fixed: T.untyped) - sig { params(o: T.untyped).returns(T.untyped) } def <<(o); end - sig { params(spec: T.untyped, source: T.untyped).returns(T.untyped) } def add(spec, source); end - sig { returns(T.untyped) } def all_specs; end - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { returns(T.untyped) } def each_spec; end - sig { returns(T::Boolean) } def empty?; end - sig { params(req: T.untyped).returns(T.untyped) } def find_all(req); end - sig { params(dep_list: T.untyped).returns(T.untyped) } def inject_into_list(dep_list); end - sig { returns(T.untyped) } def match_platform!; end - sig { returns(T.untyped) } def pick_best!; end - sig { params(reqs: T.untyped).returns(T.untyped) } def prefetch(reqs); end - sig { returns(T.untyped) } def remote; end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { params(dep: T.untyped).returns(T.untyped) } def remove_installed!(dep); end - sig { returns(T.untyped) } def set; end - sig { returns(T.untyped) } def size; end - sig { returns(T.untyped) } def sorted; end - sig { params(spec: T.untyped).returns(T.untyped) } def source_for(spec); end - sig { params(development: T.untyped).returns(T.untyped) } def to_request_set(development = T.unsafe(nil)); end class Tuple - sig { returns(T.untyped) } def source; end - sig { params(_: T.untyped).returns(T.untyped) } def source=(_); end - sig { returns(T.untyped) } def spec; end - sig { params(_: T.untyped).returns(T.untyped) } def spec=(_); end - sig { params(_: T.untyped).returns(T.untyped) } def self.[](*_); end - sig { returns(T.untyped) } def self.members; end end end class BasicSpecification - sig { returns(T::Boolean) } def activated?; end - sig { returns(T.untyped) } def base_dir; end - sig { params(base_dir: T.untyped).returns(T.untyped) } def base_dir=(base_dir); end - sig { params(file: T.untyped).returns(T::Boolean) } def contains_requirable_file?(file); end - sig { returns(T.untyped) } def datadir; end - sig { returns(T::Boolean) } def default_gem?; end - sig { returns(T.untyped) } def extension_dir; end - sig { params(extension_dir: T.untyped).returns(T.untyped) } def extension_dir=(extension_dir); end - sig { returns(T.untyped) } def extensions_dir; end - sig { returns(T.untyped) } def full_gem_path; end - sig { params(full_gem_path: T.untyped).returns(T.untyped) } def full_gem_path=(full_gem_path); end - sig { returns(T.untyped) } def full_name; end - sig { returns(T.untyped) } def full_require_paths; end - sig { returns(T.untyped) } def gem_build_complete_path; end - sig { returns(T.untyped) } def gem_dir; end - sig { returns(T.untyped) } def gems_dir; end - sig { params(ignored: T.untyped).returns(T.untyped) } def ignored=(ignored); end - sig { returns(T.untyped) } def internal_init; end - sig { returns(T.untyped) } def lib_dirs_glob; end - sig { returns(T.untyped) } def loaded_from; end - sig { params(loaded_from: T.untyped).returns(T.untyped) } def loaded_from=(loaded_from); end - sig { params(glob: T.untyped).returns(T.untyped) } def matches_for_glob(glob); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def platform; end - sig { returns(T.untyped) } def raw_require_paths; end - sig { returns(T.untyped) } def require_paths; end - sig { returns(T.untyped) } def source_paths; end - sig { returns(T::Boolean) } def stubbed?; end - sig { returns(T.untyped) } def this; end - sig { params(path: T.untyped).returns(T.untyped) } def to_fullpath(path); end - sig { returns(T.untyped) } def to_spec; end - sig { returns(T.untyped) } def version; end - sig { returns(T.untyped) } def self.default_specifications_dir; end end module BundlerVersionFinder - sig { returns(T.untyped) } def self.bundler_version; end - sig { returns(T.untyped) } def self.bundler_version_with_reason; end - sig { params(spec: T.untyped).returns(T::Boolean) } def self.compatible?(spec); end - sig { params(specs: T.untyped).returns(T.untyped) } def self.filter!(specs); end - sig { returns(T.untyped) } def self.missing_version_message; end end @@ -482,79 +329,54 @@ module Gem include Gem::Text HELP = T.let(nil, T.untyped) - sig { params(args: T.untyped).returns(T.untyped) } def add_extra_args(args); end - sig { params(opts: T.untyped, handler: T.untyped).returns(T.untyped) } def add_option(*opts, &handler); end - sig { returns(T.untyped) } def arguments; end - sig { params(long: T.untyped, short: T.untyped).returns(T::Boolean) } def begins?(long, short); end - sig { returns(T.untyped) } def command; end - sig { returns(T.untyped) } def defaults; end - sig { params(defaults: T.untyped).returns(T.untyped) } def defaults=(defaults); end - sig { returns(T.untyped) } def defaults_str; end - sig { returns(T.untyped) } def description; end - sig { returns(T.untyped) } def execute; end - sig { returns(T.untyped) } def get_all_gem_names; end - sig { returns(T.untyped) } def get_all_gem_names_and_versions; end - sig { returns(T.untyped) } def get_one_gem_name; end - sig { returns(T.untyped) } def get_one_optional_argument; end - sig { params(args: T.untyped).returns(T.untyped) } def handle_options(args); end - sig { params(args: T.untyped).returns(T::Boolean) } def handles?(args); end - sig { params(command: T.untyped, summary: T.untyped, defaults: T.untyped).returns(Command) } def initialize(command, summary = T.unsafe(nil), defaults = T.unsafe(nil)); end - sig { params(args: T.untyped).returns(T.untyped) } def invoke(*args); end - sig { params(args: T.untyped, build_args: T.untyped).returns(T.untyped) } def invoke_with_build_args(args, build_args); end - sig { params(new_options: T.untyped).returns(T.untyped) } def merge_options(new_options); end - sig { returns(T.untyped) } def options; end - sig { returns(T.untyped) } def program_name; end - sig { params(program_name: T.untyped).returns(T.untyped) } def program_name=(program_name); end - sig { params(name: T.untyped).returns(T.untyped) } def remove_option(name); end - sig { returns(T.untyped) } def show_help; end sig do @@ -566,99 +388,69 @@ module Gem required_by: T.untyped ).returns(T.untyped) end + def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end - sig { returns(T.untyped) } def summary; end - sig { params(summary: T.untyped).returns(T.untyped) } def summary=(summary); end - sig { returns(T.untyped) } def usage; end - sig { params(block: T.untyped).returns(T.untyped) } def when_invoked(&block); end - sig { params(args: T.untyped, handler: T.untyped).returns(T.untyped) } def self.add_common_option(*args, &handler); end - sig { params(cmd: T.untyped, args: T.untyped).returns(T.untyped) } def self.add_specific_extra_args(cmd, args); end - sig { returns(T.untyped) } def self.build_args; end - sig { params(value: T.untyped).returns(T.untyped) } def self.build_args=(value); end - sig { returns(T.untyped) } def self.common_options; end - sig { returns(T.untyped) } def self.extra_args; end - sig { params(value: T.untyped).returns(T.untyped) } def self.extra_args=(value); end - sig { params(cmd: T.untyped).returns(T.untyped) } def self.specific_extra_args(cmd); end - sig { returns(T.untyped) } def self.specific_extra_args_hash; end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end @@ -680,335 +472,228 @@ module Gem SYSTEM_CONFIG_PATH = T.let(nil, T.untyped) SYSTEM_WIDE_CONFIG_FILE = T.let(nil, T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(key: T.untyped).returns(T.untyped) } def [](key); end - sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) } def []=(key, value); end - sig { returns(T.untyped) } def api_keys; end - sig { returns(T.untyped) } def args; end - sig { returns(T.untyped) } def backtrace; end - sig { params(backtrace: T.untyped).returns(T.untyped) } def backtrace=(backtrace); end - sig { returns(T.untyped) } def bulk_threshold; end - sig { params(bulk_threshold: T.untyped).returns(T.untyped) } def bulk_threshold=(bulk_threshold); end - sig { returns(T.untyped) } def cert_expiration_length_days; end - sig { params(cert_expiration_length_days: T.untyped).returns(T.untyped) } def cert_expiration_length_days=(cert_expiration_length_days); end - sig { returns(T.untyped) } def check_credentials_permissions; end - sig { returns(T.untyped) } def concurrent_downloads; end - sig { params(concurrent_downloads: T.untyped).returns(T.untyped) } def concurrent_downloads=(concurrent_downloads); end - sig { returns(T.untyped) } def config_file_name; end - sig { returns(T.untyped) } def credentials_path; end - sig { returns(T.untyped) } def disable_default_gem_server; end - sig { params(disable_default_gem_server: T.untyped).returns(T.untyped) } def disable_default_gem_server=(disable_default_gem_server); end - sig { params(block: T.untyped).returns(T.untyped) } def each(&block); end - sig { params(arg_list: T.untyped).returns(T.untyped) } def handle_arguments(arg_list); end - sig { returns(T.untyped) } def home; end - sig { params(home: T.untyped).returns(T.untyped) } def home=(home); end - sig { params(args: T.untyped).returns(ConfigFile) } def initialize(args); end - sig { returns(T.untyped) } def load_api_keys; end - sig { params(filename: T.untyped).returns(T.untyped) } def load_file(filename); end - sig { returns(T.untyped) } def path; end - sig { params(path: T.untyped).returns(T.untyped) } def path=(path); end - sig { returns(T.untyped) } def really_verbose; end - sig { returns(T.untyped) } def rubygems_api_key; end - sig { params(api_key: T.untyped).returns(T.untyped) } def rubygems_api_key=(api_key); end - sig { params(host: T.untyped, api_key: T.untyped).returns(T.untyped) } def set_api_key(host, api_key); end - sig { returns(T.untyped) } def sources; end - sig { params(sources: T.untyped).returns(T.untyped) } def sources=(sources); end - sig { returns(T.untyped) } def ssl_ca_cert; end - sig { params(ssl_ca_cert: T.untyped).returns(T.untyped) } def ssl_ca_cert=(ssl_ca_cert); end - sig { returns(T.untyped) } def ssl_client_cert; end - sig { returns(T.untyped) } def ssl_verify_mode; end - sig { returns(T.untyped) } def to_yaml; end - sig { returns(T.untyped) } def unset_api_key!; end - sig { returns(T.untyped) } def update_sources; end - sig { params(update_sources: T.untyped).returns(T.untyped) } def update_sources=(update_sources); end - sig { returns(T.untyped) } def verbose; end - sig { params(verbose: T.untyped).returns(T.untyped) } def verbose=(verbose); end - sig { returns(T.untyped) } def write; end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end end class ConflictError - sig { returns(T.untyped) } def conflicts; end - sig { params(target: T.untyped, conflicts: T.untyped).returns(ConflictError) } def initialize(target, conflicts); end - sig { returns(T.untyped) } def target; end end class ConsoleUI - sig { returns(ConsoleUI) } def initialize; end end module DefaultUserInteraction include Gem::Text - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { returns(T.untyped) } def self.ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def self.ui=(new_ui); end - sig { params(new_ui: T.untyped).returns(T.untyped) } def self.use_ui(new_ui); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end end class Dependency - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(other: T.untyped).returns(T.untyped) } def ===(other); end - sig { params(other: T.untyped).returns(T.untyped) } def =~(other); end - sig { returns(T.untyped) } def all_sources; end - sig { params(all_sources: T.untyped).returns(T.untyped) } def all_sources=(all_sources); end - sig { params(coder: T.untyped).returns(T.untyped) } def encode_with(coder); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { returns(T.untyped) } def groups; end - sig { params(groups: T.untyped).returns(T.untyped) } def groups=(groups); end - sig { params(name: T.untyped, requirements: T.untyped).returns(Dependency) } def initialize(name, *requirements); end - sig { returns(T::Boolean) } def latest_version?; end - sig { params(obj: T.untyped, version: T.untyped, allow_prerelease: T.untyped).returns(T::Boolean) } def match?(obj, version = T.unsafe(nil), allow_prerelease = T.unsafe(nil)); end - sig { params(spec: T.untyped).returns(T::Boolean) } def matches_spec?(spec); end - sig { params(platform_only: T.untyped).returns(T.untyped) } def matching_specs(platform_only = T.unsafe(nil)); end - sig { params(other: T.untyped).returns(T.untyped) } def merge(other); end - sig { returns(T.untyped) } def name; end - sig { params(name: T.untyped).returns(T.untyped) } def name=(name); end - sig { params(prerelease: T.untyped).returns(T.untyped) } def prerelease=(prerelease); end - sig { returns(T::Boolean) } def prerelease?; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def requirement; end - sig { returns(T.untyped) } def requirements_list; end - sig { returns(T::Boolean) } def runtime?; end - sig { returns(T.untyped) } def source; end - sig { params(source: T.untyped).returns(T.untyped) } def source=(source); end - sig { returns(T::Boolean) } def specific?; end - sig { returns(T.untyped) } def to_lock; end - sig { returns(T.untyped) } def to_spec; end - sig { returns(T.untyped) } def to_specs; end - sig { returns(T.untyped) } def to_yaml_properties; end - sig { returns(T.untyped) } def type; end end @@ -1019,109 +704,74 @@ module Gem extend Gem::Deprecate DEFAULT_OPTIONS = T.let(nil, T.untyped) - sig { params(to_do: T.untyped, dependency_list: T.untyped).returns(T.untyped) } def _deprecated_add_found_dependencies(to_do, dependency_list); end - sig { returns(T.untyped) } def _deprecated_gather_dependencies; end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def add_found_dependencies(*args, &block); end - sig { params(dep_or_name: T.untyped, version: T.untyped).returns(T.untyped) } def available_set_for(dep_or_name, version); end - sig { returns(T::Boolean) } def consider_local?; end - sig { returns(T::Boolean) } def consider_remote?; end - sig { returns(T.untyped) } def document; end - sig { returns(T.untyped) } def errors; end - sig { params(dep: T.untyped, best_only: T.untyped).returns(T.untyped) } def find_gems_with_sources(dep, best_only = T.unsafe(nil)); end - sig { params(gem_name: T.untyped, version: T.untyped, prerelease: T.untyped).returns(T.untyped) } def find_spec_by_name_and_version(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def gather_dependencies(*args, &block); end - sig { params(what: T.untyped).returns(T.untyped) } def in_background(what); end - sig { params(options: T.untyped).returns(DependencyInstaller) } def initialize(options = T.unsafe(nil)); end - sig { params(dep_or_name: T.untyped, version: T.untyped).returns(T.untyped) } def install(dep_or_name, version = T.unsafe(nil)); end - sig { returns(T.untyped) } def install_development_deps; end - sig { returns(T.untyped) } def installed_gems; end - sig { params(dep_or_name: T.untyped, version: T.untyped).returns(T.untyped) } def resolve_dependencies(dep_or_name, version); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end @@ -1130,66 +780,46 @@ module Gem include TSort Elem = type_member(fixed: T.untyped) - sig { params(gemspecs: T.untyped).returns(T.untyped) } def add(*gemspecs); end - sig { returns(T.untyped) } def clear; end - sig { returns(T.untyped) } def dependency_order; end - sig { returns(T.untyped) } def development; end - sig { params(development: T.untyped).returns(T.untyped) } def development=(development); end - sig { params(block: T.untyped).returns(T.untyped) } def each(&block); end - sig { params(full_name: T.untyped).returns(T.untyped) } def find_name(full_name); end - sig { params(development: T.untyped).returns(T.untyped) } def initialize(development = T.unsafe(nil)); end - sig { returns(T::Boolean) } def ok?; end - sig { params(full_name: T.untyped, check_dev: T.untyped).returns(T::Boolean) } def ok_to_remove?(full_name, check_dev = T.unsafe(nil)); end - sig { params(full_name: T.untyped).returns(T.untyped) } def remove_by_name(full_name); end - sig { params(dependencies: T.untyped).returns(T.untyped) } def remove_specs_unsatisfied_by(dependencies); end - sig { returns(T.untyped) } def spec_predecessors; end - sig { returns(T.untyped) } def specs; end - sig { params(block: T.untyped).returns(T.untyped) } def tsort_each_node(&block); end - sig { params(quick: T.untyped).returns(T::Boolean) } def why_not_ok?(quick = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.from_specs; end end class DependencyResolutionError - sig { returns(T.untyped) } def conflict; end - sig { returns(T.untyped) } def conflicting_dependencies; end - sig { params(conflict: T.untyped).returns(DependencyResolutionError) } def initialize(conflict); end end @@ -1204,26 +834,20 @@ module Gem end def self.deprecate(name, repl, year, month); end - sig { returns(T.untyped) } def self.skip; end - sig { params(v: T.untyped).returns(T.untyped) } def self.skip=(v); end - sig { returns(T.untyped) } def self.skip_during; end end class Exception extend Gem::Deprecate - sig { returns(T.untyped) } def _deprecated_source_exception; end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def source_exception(*args, &block); end - sig { params(source_exception: T.untyped).returns(T.untyped) } def source_exception=(source_exception); end end @@ -1238,94 +862,64 @@ module Gem CHDIR_MONITOR = T.let(nil, T.untyped) CHDIR_MUTEX = T.let(nil, T.untyped) - sig { returns(T.untyped) } def build_args; end - sig { params(build_args: T.untyped).returns(T.untyped) } def build_args=(build_args); end - sig { params(build_dir: T.untyped, output: T.untyped, backtrace: T.untyped).returns(T.untyped) } def build_error(build_dir, output, backtrace = T.unsafe(nil)); end - sig { params(extension: T.untyped, dest_path: T.untyped).returns(T.untyped) } def build_extension(extension, dest_path); end - sig { returns(T.untyped) } def build_extensions; end - sig { params(extension: T.untyped).returns(T.untyped) } def builder_for(extension); end - sig { params(spec: T.untyped, build_args: T.untyped).returns(Builder) } def initialize(spec, build_args = T.unsafe(nil)); end - sig { params(output: T.untyped).returns(T.untyped) } def write_gem_make_out(output); end - sig { returns(T.untyped) } def self.class_name; end - sig { params(dest_path: T.untyped, results: T.untyped).returns(T.untyped) } def self.make(dest_path, results); end - sig { returns(T.untyped) } def self.redirector; end - sig { params(command: T.untyped, results: T.untyped, command_name: T.untyped).returns(T.untyped) } def self.run(command, results, command_name = T.unsafe(nil)); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end @@ -1367,7 +961,6 @@ module Gem end def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end - sig { params(path: T.untyped).returns(T.untyped) } def self.get_relative_path(path); end end @@ -1386,43 +979,32 @@ module Gem end class FilePermissionError - sig { returns(T.untyped) } def directory; end - sig { params(directory: T.untyped).returns(FilePermissionError) } def initialize(directory); end end class FormatException - sig { returns(T.untyped) } def file_path; end - sig { params(file_path: T.untyped).returns(T.untyped) } def file_path=(file_path); end end class GemNotInHomeException - sig { returns(T.untyped) } def spec; end - sig { params(spec: T.untyped).returns(T.untyped) } def spec=(spec); end end class ImpossibleDependenciesError - sig { returns(T.untyped) } def build_message; end - sig { returns(T.untyped) } def conflicts; end - sig { returns(T.untyped) } def dependency; end - sig { params(request: T.untyped, conflicts: T.untyped).returns(ImpossibleDependenciesError) } def initialize(request, conflicts); end - sig { returns(T.untyped) } def request; end end @@ -1433,217 +1015,146 @@ module Gem extend Gem::Deprecate ENV_PATHS = T.let(nil, T.untyped) - sig { params(build_dir: T.untyped, output: T.untyped, backtrace: T.untyped).returns(T.untyped) } def _deprecated_extension_build_error(build_dir, output, backtrace = T.unsafe(nil)); end - sig { params(bin_file_name: T.untyped).returns(T.untyped) } def app_script_text(bin_file_name); end - sig { returns(T.untyped) } def bin_dir; end - sig { returns(T.untyped) } def build_extensions; end - sig { returns(T.untyped) } def build_root; end - sig { params(filename: T.untyped).returns(T.untyped) } def check_executable_overwrite(filename); end - sig { returns(T.untyped) } def check_that_user_bin_dir_is_in_path; end - sig { returns(T.untyped) } def default_spec_file; end - sig { returns(T.untyped) } def dir; end - sig { returns(T.untyped) } def ensure_dependencies_met; end - sig { params(spec: T.untyped, dependency: T.untyped).returns(T.untyped) } def ensure_dependency(spec, dependency); end - sig { returns(T.untyped) } def ensure_loadable_spec; end - sig { returns(T.untyped) } def ensure_required_ruby_version_met; end - sig { returns(T.untyped) } def ensure_required_rubygems_version_met; end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def extension_build_error(*args, &block); end - sig { returns(T.untyped) } def extract_bin; end - sig { returns(T.untyped) } def extract_files; end - sig { params(filename: T.untyped).returns(T.untyped) } def formatted_program_filename(filename); end - sig { returns(T.untyped) } def gem; end - sig { returns(T.untyped) } def gem_dir; end - sig { returns(T.untyped) } def gem_home; end - sig { returns(T.untyped) } def generate_bin; end - sig { params(filename: T.untyped, bindir: T.untyped).returns(T.untyped) } def generate_bin_script(filename, bindir); end - sig { params(filename: T.untyped, bindir: T.untyped).returns(T.untyped) } def generate_bin_symlink(filename, bindir); end - sig { params(filename: T.untyped, bindir: T.untyped).returns(T.untyped) } def generate_windows_script(filename, bindir); end - sig { params(package: T.untyped, options: T.untyped).returns(Installer) } def initialize(package, options = T.unsafe(nil)); end - sig { returns(T.untyped) } def install; end - sig { params(dependency: T.untyped).returns(T::Boolean) } def installation_satisfies_dependency?(dependency); end - sig { returns(T.untyped) } def installed_specs; end - sig { returns(T.untyped) } def options; end - sig { returns(T.untyped) } def pre_install_checks; end - sig { returns(T.untyped) } def process_options; end - sig { returns(T.untyped) } def run_post_build_hooks; end - sig { returns(T.untyped) } def run_post_install_hooks; end - sig { returns(T.untyped) } def run_pre_install_hooks; end - sig { params(bin_file_name: T.untyped).returns(T.untyped) } def shebang(bin_file_name); end - sig { returns(T.untyped) } def spec; end - sig { returns(T.untyped) } def spec_file; end - sig { params(directory: T.untyped).returns(T.untyped) } def unpack(directory); end - sig { params(unpack: T.untyped).returns(T.untyped) } def verify_gem_home(unpack = T.unsafe(nil)); end - sig { returns(T.untyped) } def verify_spec; end - sig { params(bindir: T.untyped, bin_file_name: T.untyped).returns(T.untyped) } def windows_stub_script(bindir, bin_file_name); end - sig { returns(T.untyped) } def write_build_info_file; end - sig { returns(T.untyped) } def write_cache_file; end - sig { returns(T.untyped) } def write_default_spec; end - sig { returns(T.untyped) } def write_spec; end - sig { params(path: T.untyped, options: T.untyped).returns(T.untyped) } def self.at(path, options = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.exec_format; end - sig { params(exec_format: T.untyped).returns(T.untyped) } def self.exec_format=(exec_format); end - sig { params(spec: T.untyped, options: T.untyped).returns(T.untyped) } def self.for_spec(spec, options = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.install_lock; end - sig { returns(T.untyped) } def self.path_warning; end - sig { params(path_warning: T.untyped).returns(T.untyped) } def self.path_warning=(path_warning); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end @@ -1654,130 +1165,92 @@ module Gem NONSTANDARD = T.let(nil, T.untyped) REGEXP = T.let(nil, T.untyped) - sig { params(license: T.untyped).returns(T::Boolean) } def self.match?(license); end - sig { params(license: T.untyped).returns(T.untyped) } def self.suggestions(license); end - sig { params(text: T.untyped).returns(T.untyped) } def self.clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def self.format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def self.levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def self.min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def self.truncate_text(text, description, max_length = T.unsafe(nil)); end end class List - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { params(value: T.untyped, tail: T.untyped).returns(T.untyped) } def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end - sig { params(value: T.untyped).returns(T.untyped) } def prepend(value); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def tail; end - sig { params(tail: T.untyped).returns(T.untyped) } def tail=(tail); end - sig { returns(T.untyped) } def to_a; end - sig { returns(T.untyped) } def value; end - sig { params(value: T.untyped).returns(T.untyped) } def value=(value); end - sig { params(list: T.untyped, value: T.untyped).returns(T.untyped) } def self.prepend(list, value); end end class LoadError - sig { returns(T.untyped) } def name; end - sig { params(name: T.untyped).returns(T.untyped) } def name=(name); end - sig { returns(T.untyped) } def requirement; end - sig { params(requirement: T.untyped).returns(T.untyped) } def requirement=(requirement); end end class MissingSpecError - sig { params(name: T.untyped, requirement: T.untyped).returns(MissingSpecError) } def initialize(name, requirement); end end class MissingSpecVersionError - sig { params(name: T.untyped, requirement: T.untyped, specs: T.untyped).returns(MissingSpecVersionError) } def initialize(name, requirement, specs); end - sig { returns(T.untyped) } def specs; end end class NameTuple include Comparable - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { returns(T.untyped) } def full_name; end - sig { params(name: T.untyped, version: T.untyped, platform: T.untyped).returns(NameTuple) } def initialize(name, version, platform = T.unsafe(nil)); end - sig { returns(T::Boolean) } def match_platform?; end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def platform; end - sig { returns(T::Boolean) } def prerelease?; end - sig { returns(T.untyped) } def spec_name; end - sig { returns(T.untyped) } def to_a; end - sig { returns(T.untyped) } def version; end - sig { params(list: T.untyped).returns(T.untyped) } def self.from_list(list); end - sig { returns(T.untyped) } def self.null; end - sig { params(list: T.untyped).returns(T.untyped) } def self.to_basic(list); end end @@ -1786,73 +1259,50 @@ module Gem include Gem::DefaultUserInteraction include Gem::Text - sig { params(tar: T.untyped).returns(T.untyped) } def add_checksums(tar); end - sig { params(tar: T.untyped).returns(T.untyped) } def add_contents(tar); end - sig { params(tar: T.untyped).returns(T.untyped) } def add_files(tar); end - sig { params(tar: T.untyped).returns(T.untyped) } def add_metadata(tar); end - sig { params(skip_validation: T.untyped, strict_validation: T.untyped).returns(T.untyped) } def build(skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil)); end - sig { returns(T.untyped) } def build_time; end - sig { params(build_time: T.untyped).returns(T.untyped) } def build_time=(build_time); end - sig { returns(T.untyped) } def checksums; end - sig { returns(T.untyped) } def contents; end - sig { params(path: T.untyped).returns(T.untyped) } def copy_to(path); end - sig { returns(T.untyped) } def data_mode; end - sig { params(data_mode: T.untyped).returns(T.untyped) } def data_mode=(data_mode); end - sig { params(entry: T.untyped).returns(T.untyped) } def digest(entry); end - sig { returns(T.untyped) } def dir_mode; end - sig { params(dir_mode: T.untyped).returns(T.untyped) } def dir_mode=(dir_mode); end - sig { params(destination_dir: T.untyped, pattern: T.untyped).returns(T.untyped) } def extract_files(destination_dir, pattern = T.unsafe(nil)); end - sig { params(io: T.untyped, destination_dir: T.untyped, pattern: T.untyped).returns(T.untyped) } def extract_tar_gz(io, destination_dir, pattern = T.unsafe(nil)); end - sig { params(mode: T.untyped).returns(T.untyped) } def file_mode(mode); end - sig { returns(T.untyped) } def files; end - sig { params(io: T.untyped).returns(T.untyped) } def gzip_to(io); end - sig { params(gem: T.untyped, security_policy: T.untyped).returns(Package) } def initialize(gem, security_policy); end - sig { params(filename: T.untyped, destination_dir: T.untyped).returns(T.untyped) } def install_location(filename, destination_dir); end - sig { params(entry: T.untyped).returns(T.untyped) } def load_spec(entry); end sig do @@ -1863,51 +1313,37 @@ module Gem file_name: T.untyped ).returns(T.untyped) end + def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end - sig { params(pathname: T.untyped).returns(T.untyped) } def normalize_path(pathname); end - sig { params(io: T.untyped).returns(T.untyped) } def open_tar_gz(io); end - sig { returns(T.untyped) } def prog_mode; end - sig { params(prog_mode: T.untyped).returns(T.untyped) } def prog_mode=(prog_mode); end - sig { params(gem: T.untyped).returns(T.untyped) } def read_checksums(gem); end - sig { returns(T.untyped) } def security_policy; end - sig { params(security_policy: T.untyped).returns(T.untyped) } def security_policy=(security_policy); end - sig { params(signer_options: T.untyped).returns(T.untyped) } def setup_signer(signer_options: T.unsafe(nil)); end - sig { returns(T.untyped) } def spec; end - sig { params(spec: T.untyped).returns(T.untyped) } def spec=(spec); end - sig { returns(T.untyped) } def verify; end - sig { params(digests: T.untyped, checksums: T.untyped).returns(T.untyped) } def verify_checksums(digests, checksums); end - sig { params(entry: T.untyped).returns(T.untyped) } def verify_entry(entry); end - sig { params(gem: T.untyped).returns(T.untyped) } def verify_files(gem); end - sig { params(entry: T.untyped).returns(T.untyped) } def verify_gz(entry); end sig do @@ -1920,74 +1356,51 @@ module Gem end def self.build(spec, skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil), file_name = T.unsafe(nil)); end - sig { params(gem: T.untyped, security_policy: T.untyped).returns(T.untyped) } def self.new(gem, security_policy = T.unsafe(nil)); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end class DigestIO - sig { returns(T.untyped) } def digests; end - sig { params(io: T.untyped, digests: T.untyped).returns(DigestIO) } def initialize(io, digests); end - sig { params(data: T.untyped).returns(T.untyped) } def write(data); end - sig { params(io: T.untyped, digests: T.untyped).returns(T.untyped) } def self.wrap(io, digests); end end @@ -1995,53 +1408,38 @@ module Gem end class FileSource - sig { params(path: T.untyped).returns(FileSource) } def initialize(path); end - sig { returns(T.untyped) } def path; end - sig { returns(T::Boolean) } def present?; end - sig { returns(T.untyped) } def start; end - sig { params(block: T.untyped).returns(T.untyped) } def with_read_io(&block); end - sig { params(block: T.untyped).returns(T.untyped) } def with_write_io(&block); end end class FormatError - sig { params(message: T.untyped, source: T.untyped).returns(FormatError) } def initialize(message, source = T.unsafe(nil)); end - sig { returns(T.untyped) } def path; end end class IOSource - sig { params(io: T.untyped).returns(IOSource) } def initialize(io); end - sig { returns(T.untyped) } def io; end - sig { returns(T.untyped) } def path; end - sig { returns(T::Boolean) } def present?; end - sig { returns(T.untyped) } def start; end - sig { returns(T.untyped) } def with_read_io; end - sig { returns(T.untyped) } def with_write_io; end end @@ -2049,21 +1447,16 @@ module Gem end class Old - sig { params(destination_dir: T.untyped).returns(T.untyped) } def extract_files(destination_dir); end - sig { params(io: T.untyped).returns(T.untyped) } def file_list(io); end - sig { params(io: T.untyped).returns(T.untyped) } def read_until_dashes(io); end - sig { params(io: T.untyped).returns(T.untyped) } def skip_ruby(io); end end class PathError - sig { params(destination: T.untyped, destination_dir: T.untyped).returns(PathError) } def initialize(destination, destination_dir); end end @@ -2076,70 +1469,48 @@ module Gem PACK_FORMAT = T.let(nil, T.untyped) UNPACK_FORMAT = T.let(nil, T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { returns(T.untyped) } def checksum; end - sig { returns(T.untyped) } def devmajor; end - sig { returns(T.untyped) } def devminor; end - sig { returns(T::Boolean) } def empty?; end - sig { returns(T.untyped) } def gid; end - sig { returns(T.untyped) } def gname; end - sig { params(vals: T.untyped).returns(TarHeader) } def initialize(vals); end - sig { returns(T.untyped) } def linkname; end - sig { returns(T.untyped) } def magic; end - sig { returns(T.untyped) } def mode; end - sig { returns(T.untyped) } def mtime; end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def prefix; end - sig { returns(T.untyped) } def size; end - sig { returns(T.untyped) } def typeflag; end - sig { returns(T.untyped) } def uid; end - sig { returns(T.untyped) } def uname; end - sig { returns(T.untyped) } def update_checksum; end - sig { returns(T.untyped) } def version; end - sig { params(stream: T.untyped).returns(T.untyped) } def self.from(stream); end - sig { params(str: T.untyped).returns(T.untyped) } def self.strict_oct(str); end end @@ -2150,80 +1521,55 @@ module Gem include Enumerable Elem = type_member(fixed: T.untyped) - sig { returns(T.untyped) } def close; end - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { returns(T.untyped) } def each_entry; end - sig { params(io: T.untyped).returns(T.untyped) } def initialize(io); end - sig { returns(T.untyped) } def rewind; end - sig { params(name: T.untyped).returns(T.untyped) } def seek(name); end - sig { params(io: T.untyped).returns(T.untyped) } def self.new(io); end class Entry - sig { returns(T.untyped) } def bytes_read; end - sig { returns(T.untyped) } def check_closed; end - sig { returns(T.untyped) } def close; end - sig { returns(T::Boolean) } def closed?; end - sig { returns(T::Boolean) } def directory?; end - sig { returns(T::Boolean) } def eof?; end - sig { returns(T::Boolean) } def file?; end - sig { returns(T.untyped) } def full_name; end - sig { returns(T.untyped) } def getc; end - sig { returns(T.untyped) } def header; end - sig { params(header: T.untyped, io: T.untyped).returns(Entry) } def initialize(header, io); end - sig { returns(T.untyped) } def length; end - sig { returns(T.untyped) } def pos; end - sig { params(len: T.untyped).returns(T.untyped) } def read(len = T.unsafe(nil)); end - sig { params(maxlen: T.untyped, outbuf: T.untyped).returns(T.untyped) } def readpartial(maxlen = T.unsafe(nil), outbuf = T.unsafe(nil)); end - sig { returns(T.untyped) } def rewind; end - sig { returns(T.untyped) } def size; end - sig { returns(T::Boolean) } def symlink?; end end @@ -2232,56 +1578,39 @@ module Gem end class TarWriter - sig { params(name: T.untyped, mode: T.untyped).returns(T.untyped) } def add_file(name, mode); end - sig { params(name: T.untyped, mode: T.untyped, digest_algorithms: T.untyped).returns(T.untyped) } def add_file_digest(name, mode, digest_algorithms); end - sig { params(name: T.untyped, mode: T.untyped, signer: T.untyped).returns(T.untyped) } def add_file_signed(name, mode, signer); end - sig { params(name: T.untyped, mode: T.untyped, size: T.untyped).returns(T.untyped) } def add_file_simple(name, mode, size); end - sig { params(name: T.untyped, target: T.untyped, mode: T.untyped).returns(T.untyped) } def add_symlink(name, target, mode); end - sig { returns(T.untyped) } def check_closed; end - sig { returns(T.untyped) } def close; end - sig { returns(T::Boolean) } def closed?; end - sig { returns(T.untyped) } def flush; end - sig { params(io: T.untyped).returns(TarWriter) } def initialize(io); end - sig { params(name: T.untyped, mode: T.untyped).returns(T.untyped) } def mkdir(name, mode); end - sig { params(name: T.untyped).returns(T.untyped) } def split_name(name); end - sig { params(io: T.untyped).returns(T.untyped) } def self.new(io); end class BoundedStream - sig { params(io: T.untyped, limit: T.untyped).returns(BoundedStream) } def initialize(io, limit); end - sig { returns(T.untyped) } def limit; end - sig { params(data: T.untyped).returns(T.untyped) } def write(data); end - sig { returns(T.untyped) } def written; end end @@ -2289,10 +1618,8 @@ module Gem end class RestrictedStream - sig { params(io: T.untyped).returns(RestrictedStream) } def initialize(io); end - sig { params(data: T.untyped).returns(T.untyped) } def write(data); end end end @@ -2302,16 +1629,12 @@ module Gem end class PathSupport - sig { returns(T.untyped) } def home; end - sig { params(env: T.untyped).returns(PathSupport) } def initialize(env); end - sig { returns(T.untyped) } def path; end - sig { returns(T.untyped) } def spec_cache_dir; end end @@ -2322,72 +1645,50 @@ module Gem MSWIN64 = T.let(nil, T.untyped) X64_MINGW = T.let(nil, T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(other: T.untyped).returns(T.untyped) } def ===(other); end - sig { params(other: T.untyped).returns(T.untyped) } def =~(other); end - sig { returns(T.untyped) } def cpu; end - sig { params(cpu: T.untyped).returns(T.untyped) } def cpu=(cpu); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { params(arch: T.untyped).returns(Platform) } def initialize(arch); end - sig { returns(T.untyped) } def os; end - sig { params(os: T.untyped).returns(T.untyped) } def os=(os); end - sig { returns(T.untyped) } def to_a; end - sig { returns(T.untyped) } def version; end - sig { params(version: T.untyped).returns(T.untyped) } def version=(version); end - sig { params(spec: T.untyped).returns(T::Boolean) } def self.installable?(spec); end - sig { returns(T.untyped) } def self.local; end - sig { params(platform: T.untyped).returns(T.untyped) } def self.match(platform); end - sig { params(arch: T.untyped).returns(T.untyped) } def self.new(arch); end end class PlatformMismatch - sig { params(platform: T.untyped).returns(T.untyped) } def add_platform(platform); end - sig { params(name: T.untyped, version: T.untyped).returns(PlatformMismatch) } def initialize(name, version); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def platforms; end - sig { returns(T.untyped) } def version; end - sig { returns(T.untyped) } def wordy; end end @@ -2397,22 +1698,16 @@ module Gem include Gem::Text BASE64_URI_TRANSLATE = T.let(nil, T.untyped) - sig { params(uri: T.untyped, path: T.untyped, update: T.untyped).returns(T.untyped) } def cache_update_path(uri, path = T.unsafe(nil), update = T.unsafe(nil)); end - sig { returns(T.untyped) } def close_all; end - sig { params(path: T.untyped).returns(T.untyped) } def correct_for_windows_path(path); end - sig { params(spec: T.untyped, source_uri: T.untyped, install_dir: T.untyped).returns(T.untyped) } def download(spec, source_uri, install_dir = T.unsafe(nil)); end - sig { params(dependency: T.untyped).returns(T.untyped) } def download_to_cache(dependency); end - sig { params(uri: T.untyped, _: T.untyped).returns(T.untyped) } def fetch_file(uri, *_); end sig do @@ -2423,6 +1718,7 @@ module Gem depth: T.untyped ).returns(T.untyped) end + def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end sig do @@ -2433,93 +1729,65 @@ module Gem depth: T.untyped ).returns(T.untyped) end + def fetch_https(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end - sig { params(uri: T.untyped, mtime: T.untyped, head: T.untyped).returns(T.untyped) } def fetch_path(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end - sig { params(uri: T.untyped, mtime: T.untyped, head: T.untyped).returns(T.untyped) } def fetch_s3(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end - sig { params(uri: T.untyped).returns(T.untyped) } def fetch_size(uri); end - sig { returns(T.untyped) } def headers; end - sig { params(headers: T.untyped).returns(T.untyped) } def headers=(headers); end - sig { params(uri: T.untyped).returns(T::Boolean) } def https?(uri); end - sig { params(proxy: T.untyped, dns: T.untyped, headers: T.untyped).returns(RemoteFetcher) } def initialize(proxy = T.unsafe(nil), dns = T.unsafe(nil), headers = T.unsafe(nil)); end - sig { params(uri: T.untyped, request_class: T.untyped, last_modified: T.untyped).returns(T.untyped) } def request(uri, request_class, last_modified = T.unsafe(nil)); end - sig { returns(T.untyped) } def s3_expiration; end - sig { params(uri: T.untyped, expiration: T.untyped).returns(T.untyped) } def sign_s3_url(uri, expiration = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.fetcher; end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end @@ -2531,13 +1799,10 @@ module Gem extend Gem::DefaultUserInteraction extend Gem::Text - sig { returns(T.untyped) } def cert_files; end - sig { params(uri: T.untyped).returns(T.untyped) } def connection_for(uri); end - sig { returns(T.untyped) } def fetch; end sig do @@ -2548,21 +1813,17 @@ module Gem pool: T.untyped ).returns(Request) end + def initialize(uri, request_class, last_modified, pool); end - sig { params(request: T.untyped).returns(T.untyped) } def perform_request(request); end - sig { returns(T.untyped) } def proxy_uri; end - sig { params(connection: T.untyped).returns(T.untyped) } def reset(connection); end - sig { returns(T.untyped) } def user_agent; end - sig { params(connection: T.untyped, cert_files: T.untyped).returns(T.untyped) } def self.configure_connection_for_https(connection, cert_files); end sig do @@ -2575,163 +1836,111 @@ module Gem end def self.create_with_proxy(uri, request_class, last_modified, proxy); end - sig { returns(T.untyped) } def self.get_cert_files; end - sig { params(scheme: T.untyped).returns(T.untyped) } def self.get_proxy_from_env(scheme = T.unsafe(nil)); end - sig { params(proxy: T.untyped).returns(T.untyped) } def self.proxy_uri(proxy); end - sig { params(store_context: T.untyped).returns(T.untyped) } def self.verify_certificate(store_context); end - sig { params(error_number: T.untyped, cert: T.untyped).returns(T.untyped) } def self.verify_certificate_message(error_number, cert); end - sig { params(text: T.untyped).returns(T.untyped) } def self.clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def self.format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def self.levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def self.min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def self.truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def self.ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def self.use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def self.alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def self.alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def self.alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def self.ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def self.ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def self.ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def self.choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def self.say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def self.terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def self.verbose(msg = T.unsafe(nil)); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end class ConnectionPools - sig { returns(T.untyped) } def close_all; end - sig { params(proxy_uri: T.untyped, cert_files: T.untyped).returns(ConnectionPools) } def initialize(proxy_uri, cert_files); end - sig { params(uri: T.untyped).returns(T.untyped) } def pool_for(uri); end - sig { returns(T.untyped) } def self.client; end - sig { params(client: T.untyped).returns(T.untyped) } def self.client=(client); end end class HTTPPool - sig { returns(T.untyped) } def cert_files; end - sig { params(connection: T.untyped).returns(T.untyped) } def checkin(connection); end - sig { returns(T.untyped) } def checkout; end - sig { returns(T.untyped) } def close_all; end - sig { params(http_args: T.untyped, cert_files: T.untyped, proxy_uri: T.untyped).returns(HTTPPool) } def initialize(http_args, cert_files, proxy_uri); end - sig { returns(T.untyped) } def proxy_uri; end end @@ -2742,115 +1951,78 @@ module Gem class RequestSet include TSort - sig { returns(T.untyped) } def always_install; end - sig { params(always_install: T.untyped).returns(T.untyped) } def always_install=(always_install); end - sig { returns(T.untyped) } def dependencies; end - sig { returns(T.untyped) } def development; end - sig { params(development: T.untyped).returns(T.untyped) } def development=(development); end - sig { returns(T.untyped) } def development_shallow; end - sig { params(development_shallow: T.untyped).returns(T.untyped) } def development_shallow=(development_shallow); end - sig { returns(T.untyped) } def errors; end - sig { params(name: T.untyped, reqs: T.untyped).returns(T.untyped) } def gem(name, *reqs); end - sig { returns(T.untyped) } def git_set; end - sig { returns(T.untyped) } def ignore_dependencies; end - sig { params(ignore_dependencies: T.untyped).returns(T.untyped) } def ignore_dependencies=(ignore_dependencies); end - sig { params(deps: T.untyped).returns(T.untyped) } def import(deps); end - sig { params(deps: T.untyped).returns(RequestSet) } def initialize(*deps); end - sig { params(options: T.untyped, block: T.untyped).returns(T.untyped) } def install(options, &block); end - sig { returns(T.untyped) } def install_dir; end - sig { params(options: T.untyped, block: T.untyped).returns(T.untyped) } def install_from_gemdeps(options, &block); end - sig { params(requests: T.untyped, options: T.untyped).returns(T.untyped) } def install_hooks(requests, options); end - sig { params(dir: T.untyped, force: T.untyped, options: T.untyped).returns(T.untyped) } def install_into(dir, force = T.unsafe(nil), options = T.unsafe(nil)); end - sig { params(path: T.untyped, without_groups: T.untyped, installing: T.untyped).returns(T.untyped) } def load_gemdeps(path, without_groups = T.unsafe(nil), installing = T.unsafe(nil)); end - sig { returns(T.untyped) } def prerelease; end - sig { params(prerelease: T.untyped).returns(T.untyped) } def prerelease=(prerelease); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def remote; end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { params(set: T.untyped).returns(T.untyped) } def resolve(set = T.unsafe(nil)); end - sig { returns(T.untyped) } def resolve_current; end - sig { returns(T.untyped) } def resolver; end - sig { returns(T.untyped) } def sets; end - sig { returns(T.untyped) } def soft_missing; end - sig { params(soft_missing: T.untyped).returns(T.untyped) } def soft_missing=(soft_missing); end - sig { returns(T.untyped) } def sorted_requests; end - sig { returns(T.untyped) } def source_set; end - sig { returns(T.untyped) } def specs; end - sig { params(dir: T.untyped).returns(T.untyped) } def specs_in(dir); end - sig { params(block: T.untyped).returns(T.untyped) } def tsort_each_node(&block); end - sig { returns(T.untyped) } def vendor_set; end class GemDependencyAPI @@ -2859,109 +2031,75 @@ module Gem VERSION_MAP = T.let(nil, T.untyped) WINDOWS = T.let(nil, T.untyped) - sig { returns(T.untyped) } def dependencies; end - sig { params(name: T.untyped, path: T.untyped).returns(T.untyped) } def find_gemspec(name, path); end - sig { params(name: T.untyped, requirements: T.untyped).returns(T.untyped) } def gem(name, *requirements); end - sig { returns(T.untyped) } def gem_deps_file; end - sig { params(options: T.untyped).returns(T.untyped) } def gem_git_reference(options); end - sig { params(options: T.untyped).returns(T.untyped) } def gemspec(options = T.unsafe(nil)); end - sig { params(repository: T.untyped).returns(T.untyped) } def git(repository); end - sig { returns(T.untyped) } def git_set; end - sig { params(name: T.untyped, callback: T.untyped).returns(T.untyped) } def git_source(name, &callback); end - sig { params(groups: T.untyped).returns(T.untyped) } def group(*groups); end - sig { params(set: T.untyped, path: T.untyped).returns(GemDependencyAPI) } def initialize(set, path); end - sig { params(installing: T.untyped).returns(T.untyped) } def installing=(installing); end - sig { returns(T.untyped) } def load; end - sig { params(platforms: T.untyped).returns(T.untyped) } def platform(*platforms); end - sig { params(platforms: T.untyped).returns(T.untyped) } def platforms(*platforms); end - sig { returns(T.untyped) } def requires; end - sig { params(version: T.untyped, options: T.untyped).returns(T.untyped) } def ruby(version, options = T.unsafe(nil)); end - sig { params(url: T.untyped).returns(T.untyped) } def source(url); end - sig { returns(T.untyped) } def vendor_set; end - sig { returns(T.untyped) } def without_groups; end - sig { params(without_groups: T.untyped).returns(T.untyped) } def without_groups=(without_groups); end end class Lockfile - sig { params(out: T.untyped).returns(T.untyped) } def add_DEPENDENCIES(out); end - sig { params(out: T.untyped, spec_groups: T.untyped).returns(T.untyped) } def add_GEM(out, spec_groups); end - sig { params(out: T.untyped, git_requests: T.untyped).returns(T.untyped) } def add_GIT(out, git_requests); end - sig { params(out: T.untyped, path_requests: T.untyped).returns(T.untyped) } def add_PATH(out, path_requests); end - sig { params(out: T.untyped).returns(T.untyped) } def add_PLATFORMS(out); end - sig { params(request_set: T.untyped, gem_deps_file: T.untyped, dependencies: T.untyped).returns(Lockfile) } def initialize(request_set, gem_deps_file, dependencies); end - sig { returns(T.untyped) } def platforms; end - sig { params(dest: T.untyped, base: T.untyped).returns(T.untyped) } def relative_path_from(dest, base); end - sig { returns(T.untyped) } def spec_groups; end - sig { returns(T.untyped) } def write; end - sig { params(request_set: T.untyped, gem_deps_file: T.untyped, dependencies: T.untyped).returns(T.untyped) } def self.build(request_set, gem_deps_file, dependencies = T.unsafe(nil)); end - sig { params(requests: T.untyped).returns(T.untyped) } def self.requests_to_deps(requests); end class ParseError - sig { returns(T.untyped) } def column; end sig do @@ -2972,17 +2110,15 @@ module Gem path: T.untyped ).returns(ParseError) end + def initialize(message, column, line, path); end - sig { returns(T.untyped) } def line; end - sig { returns(T.untyped) } def path; end end class Parser - sig { params(expected_types: T.untyped, expected_value: T.untyped).returns(T.untyped) } def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end sig do @@ -2993,34 +2129,27 @@ module Gem filename: T.untyped ).returns(Parser) end + def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end - sig { returns(T.untyped) } def parse; end - sig { returns(T.untyped) } def parse_DEPENDENCIES; end - sig { returns(T.untyped) } def parse_GEM; end - sig { returns(T.untyped) } def parse_GIT; end - sig { returns(T.untyped) } def parse_PATH; end - sig { returns(T.untyped) } def parse_PLATFORMS; end - sig { params(name: T.untyped, op: T.untyped).returns(T.untyped) } def parse_dependency(name, op); end end class Tokenizer EOF = T.let(nil, T.untyped) - sig { returns(T::Boolean) } def empty?; end sig do @@ -3031,64 +2160,46 @@ module Gem pos: T.untyped ).returns(Tokenizer) end + def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end - sig { params(set: T.untyped, platforms: T.untyped).returns(T.untyped) } def make_parser(set, platforms); end - sig { returns(T.untyped) } def next_token; end - sig { returns(T.untyped) } def peek; end - sig { returns(T.untyped) } def shift; end - sig { params(type: T.untyped).returns(T.untyped) } def skip(type); end - sig { returns(T.untyped) } def to_a; end - sig { params(byte_offset: T.untyped).returns(T.untyped) } def token_pos(byte_offset); end - sig { params(token: T.untyped).returns(T.untyped) } def unshift(token); end - sig { params(file: T.untyped).returns(T.untyped) } def self.from_file(file); end class Token - sig { returns(T.untyped) } def column; end - sig { params(_: T.untyped).returns(T.untyped) } def column=(_); end - sig { returns(T.untyped) } def line; end - sig { params(_: T.untyped).returns(T.untyped) } def line=(_); end - sig { returns(T.untyped) } def type; end - sig { params(_: T.untyped).returns(T.untyped) } def type=(_); end - sig { returns(T.untyped) } def value; end - sig { params(_: T.untyped).returns(T.untyped) } def value=(_); end - sig { params(_: T.untyped).returns(T.untyped) } def self.[](*_); end - sig { returns(T.untyped) } def self.members; end end end @@ -3098,79 +2209,54 @@ module Gem class Requirement DefaultRequirement = T.let(nil, T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(version: T.untyped).returns(T.untyped) } def ===(version); end - sig { params(version: T.untyped).returns(T.untyped) } def =~(version); end - sig { returns(T.untyped) } def _tilde_requirements; end - sig { returns(T.untyped) } def as_list; end - sig { params(new: T.untyped).returns(T.untyped) } def concat(new); end - sig { params(coder: T.untyped).returns(T.untyped) } def encode_with(coder); end - sig { returns(T::Boolean) } def exact?; end - sig { returns(T.untyped) } def for_lockfile; end - sig { params(coder: T.untyped).returns(T.untyped) } def init_with(coder); end - sig { params(requirements: T.untyped).returns(Requirement) } def initialize(*requirements); end - sig { returns(T.untyped) } def marshal_dump; end - sig { params(array: T.untyped).returns(T.untyped) } def marshal_load(array); end - sig { returns(T::Boolean) } def none?; end - sig { returns(T::Boolean) } def prerelease?; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def requirements; end - sig { params(version: T.untyped).returns(T::Boolean) } def satisfied_by?(version); end - sig { returns(T::Boolean) } def specific?; end - sig { returns(T.untyped) } def to_yaml_properties; end - sig { params(tag: T.untyped, vals: T.untyped).returns(T.untyped) } def yaml_initialize(tag, vals); end - sig { params(inputs: T.untyped).returns(T.untyped) } def self.create(*inputs); end - sig { returns(T.untyped) } def self.default; end - sig { params(obj: T.untyped).returns(T.untyped) } def self.parse(obj); end - sig { returns(T.untyped) } def self.source_set; end end @@ -3179,258 +2265,177 @@ module Gem include Gem::Resolver::Molinillo::SpecificationProvider DEBUG_RESOLVER = T.let(nil, T.untyped) - sig { params(dep: T.untyped, possible: T.untyped).returns(T.untyped) } def activation_request(dep, possible); end - sig { returns(T.untyped) } def development; end - sig { params(development: T.untyped).returns(T.untyped) } def development=(development); end - sig { returns(T.untyped) } def development_shallow; end - sig { params(development_shallow: T.untyped).returns(T.untyped) } def development_shallow=(development_shallow); end - sig { params(stage: T.untyped, data: T.untyped).returns(T.untyped) } def explain(stage, *data); end - sig { params(stage: T.untyped).returns(T.untyped) } def explain_list(stage); end - sig { params(dependency: T.untyped).returns(T.untyped) } def find_possible(dependency); end - sig { returns(T.untyped) } def ignore_dependencies; end - sig { params(ignore_dependencies: T.untyped).returns(T.untyped) } def ignore_dependencies=(ignore_dependencies); end - sig { params(needed: T.untyped, set: T.untyped).returns(Resolver) } def initialize(needed, set = T.unsafe(nil)); end - sig { returns(T.untyped) } def missing; end - sig { params(s: T.untyped, act: T.untyped, reqs: T.untyped).returns(T.untyped) } def requests(s, act, reqs = T.unsafe(nil)); end - sig { returns(T.untyped) } def resolve; end - sig { params(specs: T.untyped).returns(T.untyped) } def select_local_platforms(specs); end - sig { returns(T.untyped) } def skip_gems; end - sig { params(skip_gems: T.untyped).returns(T.untyped) } def skip_gems=(skip_gems); end - sig { returns(T.untyped) } def soft_missing; end - sig { params(soft_missing: T.untyped).returns(T.untyped) } def soft_missing=(soft_missing); end - sig { returns(T.untyped) } def stats; end - sig { params(sets: T.untyped).returns(T.untyped) } def self.compose_sets(*sets); end - sig { params(needed: T.untyped).returns(T.untyped) } def self.for_current_gems(needed); end - sig { params(dependency: T.untyped).returns(T::Boolean) } def allow_missing?(dependency); end - sig { params(specification: T.untyped).returns(T.untyped) } def dependencies_for(specification); end - sig { params(dependency: T.untyped).returns(T.untyped) } def name_for(dependency); end - sig { returns(T.untyped) } def name_for_explicit_dependency_source; end - sig { returns(T.untyped) } def name_for_locking_dependency_source; end - sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } def requirement_satisfied_by?(requirement, activated, spec); end - sig { params(dependency: T.untyped).returns(T.untyped) } def search_for(dependency); end - sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } def sort_dependencies(dependencies, activated, conflicts); end - sig { returns(T.untyped) } def after_resolution; end - sig { returns(T.untyped) } def before_resolution; end - sig { params(depth: T.untyped).returns(T.untyped) } def debug(depth = T.unsafe(nil)); end - sig { returns(T::Boolean) } def debug?; end - sig { returns(T.untyped) } def indicate_progress; end - sig { returns(T.untyped) } def output; end - sig { returns(T.untyped) } def progress_rate; end class APISet - sig { returns(T.untyped) } def dep_uri; end - sig { params(dep_uri: T.untyped).returns(APISet) } def initialize(dep_uri = T.unsafe(nil)); end - sig { returns(T.untyped) } def prefetch_now; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def source; end - sig { returns(T.untyped) } def uri; end - sig { params(name: T.untyped).returns(T.untyped) } def versions(name); end end class APISpecification - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(set: T.untyped, api_data: T.untyped).returns(T.untyped) } def initialize(set, api_data); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end end class ActivationRequest - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { returns(T::Boolean) } def development?; end - sig { params(path: T.untyped).returns(T.untyped) } def download(path); end - sig { returns(T.untyped) } def full_name; end - sig { returns(T.untyped) } def full_spec; end - sig { params(spec: T.untyped, request: T.untyped, others_possible: T.untyped).returns(ActivationRequest) } def initialize(spec, request, others_possible = T.unsafe(nil)); end - sig { returns(T::Boolean) } def installed?; end - sig { returns(T.untyped) } def name; end - sig { returns(T::Boolean) } def others_possible?; end - sig { returns(T.untyped) } def parent; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def request; end - sig { returns(T.untyped) } def spec; end - sig { returns(T.untyped) } def version; end end class BestSet - sig { params(sources: T.untyped).returns(BestSet) } def initialize(sources = T.unsafe(nil)); end - sig { returns(T.untyped) } def pick_sets; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { params(error: T.untyped).returns(T.untyped) } def replace_failed_api_set(error); end end class ComposedSet - sig { params(sets: T.untyped).returns(ComposedSet) } def initialize(*sets); end - sig { params(allow_prerelease: T.untyped).returns(T.untyped) } def prerelease=(allow_prerelease); end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { returns(T.untyped) } def sets; end end class Conflict - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { returns(T.untyped) } def activated; end - sig { returns(T.untyped) } def conflicting_dependencies; end - sig { returns(T.untyped) } def dependency; end - sig { returns(T.untyped) } def explain; end - sig { returns(T.untyped) } def explanation; end - sig { returns(T.untyped) } def failed_dep; end - sig { params(spec: T.untyped).returns(T::Boolean) } def for_spec?(spec); end - sig { params(dependency: T.untyped, activated: T.untyped, failed_dep: T.untyped).returns(Conflict) } def initialize(dependency, activated, failed_dep = T.unsafe(nil)); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { params(current: T.untyped).returns(T.untyped) } def request_path(current); end - sig { returns(T.untyped) } def requester; end end @@ -3438,46 +2443,32 @@ module Gem end class DependencyRequest - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { returns(T.untyped) } def dependency; end - sig { returns(T::Boolean) } def development?; end - sig { returns(T::Boolean) } def explicit?; end - sig { returns(T::Boolean) } def implicit?; end - sig { params(dependency: T.untyped, requester: T.untyped).returns(DependencyRequest) } def initialize(dependency, requester); end - sig { params(spec: T.untyped, allow_prerelease: T.untyped).returns(T::Boolean) } def match?(spec, allow_prerelease = T.unsafe(nil)); end - sig { params(spec: T.untyped).returns(T::Boolean) } def matches_spec?(spec); end - sig { returns(T.untyped) } def name; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def request_context; end - sig { returns(T.untyped) } def requester; end - sig { returns(T.untyped) } def requirement; end - sig { returns(T.untyped) } def type; end end @@ -3490,6 +2481,7 @@ module Gem submodules: T.untyped ).returns(T.untyped) end + def add_git_gem(name, repository, reference, submodules); end sig do @@ -3501,43 +2493,33 @@ module Gem submodules: T.untyped ).returns(T.untyped) end + def add_git_spec(name, version, repository, reference, submodules); end - sig { returns(T.untyped) } def need_submodules; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def repositories; end - sig { returns(T.untyped) } def root_dir; end - sig { params(root_dir: T.untyped).returns(T.untyped) } def root_dir=(root_dir); end - sig { returns(T.untyped) } def specs; end end class GitSpecification - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(dependency: T.untyped).returns(T.untyped) } def add_dependency(dependency); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end end class IndexSet - sig { params(source: T.untyped).returns(IndexSet) } def initialize(source = T.unsafe(nil)); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end end @@ -3551,49 +2533,37 @@ module Gem platform: T.untyped ).returns(IndexSpecification) end + def initialize(set, name, version, source, platform); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end end class InstalledSpecification - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end end class InstallerSet - sig { params(dependency: T.untyped).returns(T.untyped) } def add_always_install(dependency); end - sig { params(dep_name: T.untyped, spec: T.untyped, source: T.untyped).returns(T.untyped) } def add_local(dep_name, spec, source); end - sig { returns(T.untyped) } def always_install; end - sig { returns(T::Boolean) } def consider_local?; end - sig { returns(T::Boolean) } def consider_remote?; end - sig { returns(T.untyped) } def ignore_dependencies; end - sig { params(ignore_dependencies: T.untyped).returns(T.untyped) } def ignore_dependencies=(ignore_dependencies); end - sig { returns(T.untyped) } def ignore_installed; end - sig { params(ignore_installed: T.untyped).returns(T.untyped) } def ignore_installed=(ignore_installed); end - sig { params(domain: T.untyped).returns(InstallerSet) } def initialize(domain); end sig do @@ -3604,34 +2574,27 @@ module Gem source: T.untyped ).returns(T.untyped) end + def load_spec(name, ver, platform, source); end - sig { params(dep_name: T.untyped).returns(T::Boolean) } def local?(dep_name); end - sig { params(allow_prerelease: T.untyped).returns(T.untyped) } def prerelease=(allow_prerelease); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { returns(T.untyped) } def remote_set; end end class LocalSpecification - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end end class LockSet - sig { params(name: T.untyped, version: T.untyped, platform: T.untyped).returns(T.untyped) } def add(name, version, platform); end - sig { params(sources: T.untyped).returns(LockSet) } def initialize(sources); end sig do @@ -3642,17 +2605,15 @@ module Gem source: T.untyped ).returns(T.untyped) end + def load_spec(name, version, platform, source); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def specs; end end class LockSpecification - sig { params(dependency: T.untyped).returns(T.untyped) } def add_dependency(dependency); end sig do @@ -3664,12 +2625,11 @@ module Gem platform: T.untyped ).returns(LockSpecification) end + def initialize(set, name, version, sources, platform); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def sources; end end @@ -3677,60 +2637,43 @@ module Gem VERSION = T.let(nil, T.untyped) class CircularDependencyError - sig { returns(T.untyped) } def dependencies; end - sig { params(nodes: T.untyped).returns(CircularDependencyError) } def initialize(nodes); end end module Delegates module ResolutionState - sig { returns(T.untyped) } def activated; end - sig { returns(T.untyped) } def conflicts; end - sig { returns(T.untyped) } def depth; end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def possibilities; end - sig { returns(T.untyped) } def requirement; end - sig { returns(T.untyped) } def requirements; end end module SpecificationProvider - sig { params(dependency: T.untyped).returns(T::Boolean) } def allow_missing?(dependency); end - sig { params(specification: T.untyped).returns(T.untyped) } def dependencies_for(specification); end - sig { params(dependency: T.untyped).returns(T.untyped) } def name_for(dependency); end - sig { returns(T.untyped) } def name_for_explicit_dependency_source; end - sig { returns(T.untyped) } def name_for_locking_dependency_source; end - sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } def requirement_satisfied_by?(requirement, activated, spec); end - sig { params(dependency: T.untyped).returns(T.untyped) } def search_for(dependency); end - sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } def sort_dependencies(dependencies, activated, conflicts); end end end @@ -3740,7 +2683,6 @@ module Gem include TSort Elem = type_member(fixed: T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end sig do @@ -3751,155 +2693,110 @@ module Gem requirement: T.untyped ).returns(T.untyped) end + def add_child_vertex(name, payload, parent_names, requirement); end - sig { params(origin: T.untyped, destination: T.untyped, requirement: T.untyped).returns(T.untyped) } def add_edge(origin, destination, requirement); end - sig { params(name: T.untyped, payload: T.untyped, root: T.untyped).returns(T.untyped) } def add_vertex(name, payload, root = T.unsafe(nil)); end - sig { params(edge: T.untyped).returns(T.untyped) } def delete_edge(edge); end - sig { params(name: T.untyped).returns(T.untyped) } def detach_vertex_named(name); end - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { returns(T.untyped) } def log; end - sig { params(tag: T.untyped).returns(T.untyped) } def rewind_to(tag); end - sig { params(name: T.untyped).returns(T.untyped) } def root_vertex_named(name); end - sig { params(name: T.untyped, payload: T.untyped).returns(T.untyped) } def set_payload(name, payload); end - sig { params(tag: T.untyped).returns(T.untyped) } def tag(tag); end - sig { params(options: T.untyped).returns(T.untyped) } def to_dot(options = T.unsafe(nil)); end - sig { params(vertex: T.untyped, block: T.untyped).returns(T.untyped) } def tsort_each_child(vertex, &block); end - sig { params(name: T.untyped).returns(T.untyped) } def vertex_named(name); end - sig { returns(T.untyped) } def vertices; end - sig { params(vertices: T.untyped).returns(T.untyped) } def self.tsort(vertices); end class Action - sig { params(graph: T.untyped).returns(T.untyped) } def down(graph); end - sig { returns(T.untyped) } def next; end - sig { params(_: T.untyped).returns(T.untyped) } def next=(_); end - sig { returns(T.untyped) } def previous; end - sig { params(previous: T.untyped).returns(T.untyped) } def previous=(previous); end - sig { params(graph: T.untyped).returns(T.untyped) } def up(graph); end - sig { returns(T.untyped) } def self.action_name; end end class AddEdgeNoCircular - sig { returns(T.untyped) } def destination; end - sig { params(origin: T.untyped, destination: T.untyped, requirement: T.untyped).returns(AddEdgeNoCircular) } def initialize(origin, destination, requirement); end - sig { params(graph: T.untyped).returns(T.untyped) } def make_edge(graph); end - sig { returns(T.untyped) } def origin; end - sig { returns(T.untyped) } def requirement; end end class AddVertex - sig { params(name: T.untyped, payload: T.untyped, root: T.untyped).returns(AddVertex) } def initialize(name, payload, root); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def payload; end - sig { returns(T.untyped) } def root; end end class DeleteEdge - sig { returns(T.untyped) } def destination_name; end - sig { params(origin_name: T.untyped, destination_name: T.untyped, requirement: T.untyped).returns(DeleteEdge) } def initialize(origin_name, destination_name, requirement); end - sig { params(graph: T.untyped).returns(T.untyped) } def make_edge(graph); end - sig { returns(T.untyped) } def origin_name; end - sig { returns(T.untyped) } def requirement; end end class DetachVertexNamed - sig { params(name: T.untyped).returns(DetachVertexNamed) } def initialize(name); end - sig { returns(T.untyped) } def name; end end class Edge - sig { returns(T.untyped) } def destination; end - sig { params(_: T.untyped).returns(T.untyped) } def destination=(_); end - sig { returns(T.untyped) } def origin; end - sig { params(_: T.untyped).returns(T.untyped) } def origin=(_); end - sig { returns(T.untyped) } def requirement; end - sig { params(_: T.untyped).returns(T.untyped) } def requirement=(_); end - sig { params(_: T.untyped).returns(T.untyped) } def self.[](*_); end - sig { returns(T.untyped) } def self.members; end end @@ -3915,6 +2812,7 @@ module Gem requirement: T.untyped ).returns(T.untyped) end + def add_edge_no_circular(graph, origin, destination, requirement); end sig do @@ -3925,6 +2823,7 @@ module Gem root: T.untyped ).returns(T.untyped) end + def add_vertex(graph, name, payload, root); end sig do @@ -3935,152 +2834,108 @@ module Gem requirement: T.untyped ).returns(T.untyped) end + def delete_edge(graph, origin_name, destination_name, requirement); end - sig { params(graph: T.untyped, name: T.untyped).returns(T.untyped) } def detach_vertex_named(graph, name); end - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { params(graph: T.untyped).returns(T.untyped) } def pop!(graph); end - sig { returns(T.untyped) } def reverse_each; end - sig { params(graph: T.untyped, tag: T.untyped).returns(T.untyped) } def rewind_to(graph, tag); end - sig { params(graph: T.untyped, name: T.untyped, payload: T.untyped).returns(T.untyped) } def set_payload(graph, name, payload); end - sig { params(graph: T.untyped, tag: T.untyped).returns(T.untyped) } def tag(graph, tag); end end class SetPayload - sig { params(name: T.untyped, payload: T.untyped).returns(SetPayload) } def initialize(name, payload); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def payload; end end class Tag - sig { params(_graph: T.untyped).returns(T.untyped) } def down(_graph); end - sig { params(tag: T.untyped).returns(Tag) } def initialize(tag); end - sig { returns(T.untyped) } def tag; end - sig { params(_graph: T.untyped).returns(T.untyped) } def up(_graph); end end class Vertex - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(other: T.untyped).returns(T::Boolean) } def ancestor?(other); end - sig { params(other: T.untyped).returns(T::Boolean) } def descendent?(other); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { returns(T.untyped) } def explicit_requirements; end - sig { returns(T.untyped) } def incoming_edges; end - sig { params(incoming_edges: T.untyped).returns(T.untyped) } def incoming_edges=(incoming_edges); end - sig { params(name: T.untyped, payload: T.untyped).returns(Vertex) } def initialize(name, payload); end - sig { params(other: T.untyped).returns(T::Boolean) } def is_reachable_from?(other); end - sig { returns(T.untyped) } def name; end - sig { params(name: T.untyped).returns(T.untyped) } def name=(name); end - sig { returns(T.untyped) } def outgoing_edges; end - sig { params(outgoing_edges: T.untyped).returns(T.untyped) } def outgoing_edges=(outgoing_edges); end - sig { params(other: T.untyped).returns(T::Boolean) } def path_to?(other); end - sig { returns(T.untyped) } def payload; end - sig { params(payload: T.untyped).returns(T.untyped) } def payload=(payload); end - sig { returns(T.untyped) } def predecessors; end - sig { returns(T.untyped) } def recursive_predecessors; end - sig { returns(T.untyped) } def recursive_successors; end - sig { returns(T.untyped) } def requirements; end - sig { returns(T.untyped) } def root; end - sig { params(root: T.untyped).returns(T.untyped) } def root=(root); end - sig { returns(T::Boolean) } def root?; end - sig { params(other: T.untyped).returns(T::Boolean) } def shallow_eql?(other); end - sig { returns(T.untyped) } def successors; end end end class DependencyState - sig { returns(T.untyped) } def pop_possibility_state; end end class NoSuchDependencyError - sig { returns(T.untyped) } def dependency; end - sig { params(dependency: T.untyped).returns(T.untyped) } def dependency=(dependency); end - sig { params(dependency: T.untyped, required_by: T.untyped).returns(NoSuchDependencyError) } def initialize(dependency, required_by = T.unsafe(nil)); end - sig { returns(T.untyped) } def required_by; end - sig { params(required_by: T.untyped).returns(T.untyped) } def required_by=(required_by); end end @@ -4088,76 +2943,54 @@ module Gem end class ResolutionState - sig { returns(T.untyped) } def activated; end - sig { params(_: T.untyped).returns(T.untyped) } def activated=(_); end - sig { returns(T.untyped) } def conflicts; end - sig { params(_: T.untyped).returns(T.untyped) } def conflicts=(_); end - sig { returns(T.untyped) } def depth; end - sig { params(_: T.untyped).returns(T.untyped) } def depth=(_); end - sig { returns(T.untyped) } def name; end - sig { params(_: T.untyped).returns(T.untyped) } def name=(_); end - sig { returns(T.untyped) } def possibilities; end - sig { params(_: T.untyped).returns(T.untyped) } def possibilities=(_); end - sig { returns(T.untyped) } def requirement; end - sig { params(_: T.untyped).returns(T.untyped) } def requirement=(_); end - sig { returns(T.untyped) } def requirements; end - sig { params(_: T.untyped).returns(T.untyped) } def requirements=(_); end - sig { params(_: T.untyped).returns(T.untyped) } def self.[](*_); end - sig { returns(T.untyped) } def self.empty; end - sig { returns(T.untyped) } def self.members; end end class Resolver - sig { params(specification_provider: T.untyped, resolver_ui: T.untyped).returns(Resolver) } def initialize(specification_provider, resolver_ui); end - sig { params(requested: T.untyped, base: T.untyped).returns(T.untyped) } def resolve(requested, base = T.unsafe(nil)); end - sig { returns(T.untyped) } def resolver_ui; end - sig { returns(T.untyped) } def specification_provider; end class Resolution include Gem::Resolver::Molinillo::Delegates::ResolutionState include Gem::Resolver::Molinillo::Delegates::SpecificationProvider - sig { returns(T.untyped) } def base; end sig do @@ -4168,121 +3001,84 @@ module Gem base: T.untyped ).returns(Resolution) end + def initialize(specification_provider, resolver_ui, requested, base); end - sig { params(iteration_rate: T.untyped).returns(T.untyped) } def iteration_rate=(iteration_rate); end - sig { returns(T.untyped) } def original_requested; end - sig { returns(T.untyped) } def resolve; end - sig { returns(T.untyped) } def resolver_ui; end - sig { returns(T.untyped) } def specification_provider; end - sig { params(started_at: T.untyped).returns(T.untyped) } def started_at=(started_at); end - sig { params(states: T.untyped).returns(T.untyped) } def states=(states); end - sig { params(dependency: T.untyped).returns(T::Boolean) } def allow_missing?(dependency); end - sig { params(specification: T.untyped).returns(T.untyped) } def dependencies_for(specification); end - sig { params(dependency: T.untyped).returns(T.untyped) } def name_for(dependency); end - sig { returns(T.untyped) } def name_for_explicit_dependency_source; end - sig { returns(T.untyped) } def name_for_locking_dependency_source; end - sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } def requirement_satisfied_by?(requirement, activated, spec); end - sig { params(dependency: T.untyped).returns(T.untyped) } def search_for(dependency); end - sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } def sort_dependencies(dependencies, activated, conflicts); end - sig { returns(T.untyped) } def activated; end - sig { returns(T.untyped) } def conflicts; end - sig { returns(T.untyped) } def depth; end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def possibilities; end - sig { returns(T.untyped) } def requirement; end - sig { returns(T.untyped) } def requirements; end class Conflict - sig { returns(T.untyped) } def activated_by_name; end - sig { params(_: T.untyped).returns(T.untyped) } def activated_by_name=(_); end - sig { returns(T.untyped) } def existing; end - sig { params(_: T.untyped).returns(T.untyped) } def existing=(_); end - sig { returns(T.untyped) } def locked_requirement; end - sig { params(_: T.untyped).returns(T.untyped) } def locked_requirement=(_); end - sig { returns(T.untyped) } def possibility; end - sig { params(_: T.untyped).returns(T.untyped) } def possibility=(_); end - sig { returns(T.untyped) } def requirement; end - sig { params(_: T.untyped).returns(T.untyped) } def requirement=(_); end - sig { returns(T.untyped) } def requirement_trees; end - sig { params(_: T.untyped).returns(T.untyped) } def requirement_trees=(_); end - sig { returns(T.untyped) } def requirements; end - sig { params(_: T.untyped).returns(T.untyped) } def requirements=(_); end - sig { params(_: T.untyped).returns(T.untyped) } def self.[](*_); end - sig { returns(T.untyped) } def self.members; end end end @@ -4292,59 +3088,42 @@ module Gem end module SpecificationProvider - sig { params(dependency: T.untyped).returns(T::Boolean) } def allow_missing?(dependency); end - sig { params(specification: T.untyped).returns(T.untyped) } def dependencies_for(specification); end - sig { params(dependency: T.untyped).returns(T.untyped) } def name_for(dependency); end - sig { returns(T.untyped) } def name_for_explicit_dependency_source; end - sig { returns(T.untyped) } def name_for_locking_dependency_source; end - sig { params(requirement: T.untyped, activated: T.untyped, spec: T.untyped).returns(T::Boolean) } def requirement_satisfied_by?(requirement, activated, spec); end - sig { params(dependency: T.untyped).returns(T.untyped) } def search_for(dependency); end - sig { params(dependencies: T.untyped, activated: T.untyped, conflicts: T.untyped).returns(T.untyped) } def sort_dependencies(dependencies, activated, conflicts); end end module UI - sig { returns(T.untyped) } def after_resolution; end - sig { returns(T.untyped) } def before_resolution; end - sig { params(depth: T.untyped).returns(T.untyped) } def debug(depth = T.unsafe(nil)); end - sig { returns(T::Boolean) } def debug?; end - sig { returns(T.untyped) } def indicate_progress; end - sig { returns(T.untyped) } def output; end - sig { returns(T.untyped) } def progress_rate; end end class VersionConflict - sig { returns(T.untyped) } def conflicts; end - sig { params(conflicts: T.untyped).returns(VersionConflict) } def initialize(conflicts); end end end @@ -4353,129 +3132,92 @@ module Gem include Enumerable Elem = type_member(fixed: T.untyped) - sig { params(req: T.untyped).returns(T.untyped) } def add(req); end - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { returns(T::Boolean) } def empty?; end - sig { returns(T.untyped) } def next5; end - sig { returns(T.untyped) } def remove; end - sig { returns(T.untyped) } def size; end end class Set - sig { returns(T.untyped) } def errors; end - sig { params(errors: T.untyped).returns(T.untyped) } def errors=(errors); end - sig { params(req: T.untyped).returns(T.untyped) } def find_all(req); end - sig { params(reqs: T.untyped).returns(T.untyped) } def prefetch(reqs); end - sig { returns(T.untyped) } def prerelease; end - sig { params(prerelease: T.untyped).returns(T.untyped) } def prerelease=(prerelease); end - sig { returns(T.untyped) } def remote; end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { returns(T::Boolean) } def remote?; end end class SourceSet - sig { params(name: T.untyped, source: T.untyped).returns(T.untyped) } def add_source_gem(name, source); end end class SpecSpecification - sig { params(set: T.untyped, spec: T.untyped, source: T.untyped).returns(SpecSpecification) } def initialize(set, spec, source = T.unsafe(nil)); end end class Specification - sig { returns(T.untyped) } def dependencies; end - sig { params(options: T.untyped).returns(T.untyped) } def download(options); end - sig { returns(T.untyped) } def fetch_development_dependencies; end - sig { returns(T.untyped) } def full_name; end - sig { params(options: T.untyped).returns(T.untyped) } def install(options = T.unsafe(nil)); end - sig { returns(T::Boolean) } def installable_platform?; end - sig { returns(T::Boolean) } def local?; end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def platform; end - sig { returns(T.untyped) } def set; end - sig { returns(T.untyped) } def source; end - sig { returns(T.untyped) } def spec; end - sig { returns(T.untyped) } def version; end end class Stats PATTERN = T.let(nil, T.untyped) - sig { returns(T.untyped) } def backtracking!; end - sig { returns(T.untyped) } def display; end - sig { returns(T.untyped) } def iteration!; end - sig { params(stack: T.untyped).returns(T.untyped) } def record_depth(stack); end - sig { params(reqs: T.untyped).returns(T.untyped) } def record_requirements(reqs); end - sig { returns(T.untyped) } def requirement!; end end class VendorSet - sig { params(name: T.untyped, directory: T.untyped).returns(T.untyped) } def add_vendor_gem(name, directory); end sig do @@ -4486,26 +3228,22 @@ module Gem source: T.untyped ).returns(T.untyped) end + def load_spec(name, version, platform, source); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def specs; end end class VendorSpecification - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end end end class RuntimeRequirementNotMetError - sig { returns(T.untyped) } def suggestion; end - sig { params(suggestion: T.untyped).returns(T.untyped) } def suggestion=(suggestion); end end @@ -4524,7 +3262,6 @@ module Gem Policies = T.let(nil, T.untyped) SigningPolicy = T.let(nil, T.untyped) - sig { params(certificate: T.untyped, x509_entry: T.untyped).returns(T.untyped) } def self.alt_name_or_x509_entry(certificate, x509_entry); end sig do @@ -4559,10 +3296,8 @@ module Gem end def self.create_cert_self_signed(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end - sig { params(length: T.untyped, algorithm: T.untyped).returns(T.untyped) } def self.create_key(length = T.unsafe(nil), algorithm = T.unsafe(nil)); end - sig { params(email_address: T.untyped).returns(T.untyped) } def self.email_to_name(email_address); end sig do @@ -4575,7 +3310,6 @@ module Gem end def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.reset; end sig do @@ -4590,10 +3324,8 @@ module Gem end def self.sign(certificate, signing_key, signing_cert, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.trust_dir; end - sig { params(block: T.untyped).returns(T.untyped) } def self.trusted_certificates(&block); end sig do @@ -4608,13 +3340,10 @@ module Gem def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end class DIGEST_ALGORITHM - sig { params(data: T.untyped).returns(DIGEST_ALGORITHM) } def initialize(data = T.unsafe(nil)); end - sig { params(data: T.untyped).returns(T.untyped) } def self.digest(data); end - sig { params(data: T.untyped).returns(T.untyped) } def self.hexdigest(data); end end @@ -4627,112 +3356,76 @@ module Gem PKCS1_PADDING = T.let(nil, T.untyped) SSLV23_PADDING = T.let(nil, T.untyped) - sig { returns(T.untyped) } def d; end - sig { params(d: T.untyped).returns(T.untyped) } def d=(d); end - sig { returns(T.untyped) } def dmp1; end - sig { params(dmp1: T.untyped).returns(T.untyped) } def dmp1=(dmp1); end - sig { returns(T.untyped) } def dmq1; end - sig { params(dmq1: T.untyped).returns(T.untyped) } def dmq1=(dmq1); end - sig { returns(T.untyped) } def e; end - sig { params(e: T.untyped).returns(T.untyped) } def e=(e); end - sig { params(_: T.untyped).returns(T.untyped) } def export(*_); end - sig { params(_: T.untyped).returns(KEY_ALGORITHM) } def initialize(*_); end - sig { returns(T.untyped) } def iqmp; end - sig { params(iqmp: T.untyped).returns(T.untyped) } def iqmp=(iqmp); end - sig { returns(T.untyped) } def n; end - sig { params(n: T.untyped).returns(T.untyped) } def n=(n); end - sig { returns(T.untyped) } def p; end - sig { params(p: T.untyped).returns(T.untyped) } def p=(p); end - sig { returns(T.untyped) } def params; end - sig { returns(T::Boolean) } def private?; end - sig { params(_: T.untyped).returns(T.untyped) } def private_decrypt(*_); end - sig { params(_: T.untyped).returns(T.untyped) } def private_encrypt(*_); end - sig { returns(T::Boolean) } def public?; end - sig { params(_: T.untyped).returns(T.untyped) } def public_decrypt(*_); end - sig { params(_: T.untyped).returns(T.untyped) } def public_encrypt(*_); end - sig { returns(T.untyped) } def public_key; end - sig { returns(T.untyped) } def q; end - sig { params(q: T.untyped).returns(T.untyped) } def q=(q); end - sig { params(_: T.untyped, _1: T.untyped, _2: T.untyped).returns(T.untyped) } def set_crt_params(_, _1, _2); end - sig { params(_: T.untyped, _1: T.untyped).returns(T.untyped) } def set_factors(_, _1); end - sig { params(_: T.untyped, _1: T.untyped, _2: T.untyped).returns(T.untyped) } def set_key(_, _1, _2); end - sig { params(_: T.untyped).returns(T.untyped) } def sign_pss(*_); end - sig { returns(T.untyped) } def to_der; end - sig { params(_: T.untyped).returns(T.untyped) } def to_pem(*_); end - sig { params(_: T.untyped).returns(T.untyped) } def to_s(*_); end - sig { returns(T.untyped) } def to_text; end - sig { params(_: T.untyped).returns(T.untyped) } def verify_pss(*_); end - sig { params(_: T.untyped).returns(T.untyped) } def self.generate(*_); end end @@ -4741,10 +3434,8 @@ module Gem include Gem::DefaultUserInteraction include Gem::Text - sig { params(signer: T.untyped, issuer: T.untyped, time: T.untyped).returns(T.untyped) } def check_cert(signer, issuer, time); end - sig { params(chain: T.untyped, time: T.untyped).returns(T.untyped) } def check_chain(chain, time); end sig do @@ -4755,36 +3446,27 @@ module Gem data: T.untyped ).returns(T.untyped) end + def check_data(public_key, digest, signature, data); end - sig { params(signer: T.untyped, key: T.untyped).returns(T.untyped) } def check_key(signer, key); end - sig { params(chain: T.untyped, time: T.untyped).returns(T.untyped) } def check_root(chain, time); end - sig { params(chain: T.untyped, digester: T.untyped, trust_dir: T.untyped).returns(T.untyped) } def check_trust(chain, digester, trust_dir); end - sig { params(name: T.untyped, policy: T.untyped, opt: T.untyped).returns(Policy) } def initialize(name, policy = T.unsafe(nil), opt = T.unsafe(nil)); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def only_signed; end - sig { params(only_signed: T.untyped).returns(T.untyped) } def only_signed=(only_signed); end - sig { returns(T.untyped) } def only_trusted; end - sig { params(only_trusted: T.untyped).returns(T.untyped) } def only_trusted=(only_trusted); end - sig { params(certificate: T.untyped).returns(T.untyped) } def subject(certificate); end sig do @@ -4796,87 +3478,61 @@ module Gem full_name: T.untyped ).returns(T.untyped) end + def verify(chain, key = T.unsafe(nil), digests = T.unsafe(nil), signatures = T.unsafe(nil), full_name = T.unsafe(nil)); end - sig { returns(T.untyped) } def verify_chain; end - sig { params(verify_chain: T.untyped).returns(T.untyped) } def verify_chain=(verify_chain); end - sig { returns(T.untyped) } def verify_data; end - sig { params(verify_data: T.untyped).returns(T.untyped) } def verify_data=(verify_data); end - sig { returns(T.untyped) } def verify_root; end - sig { params(verify_root: T.untyped).returns(T.untyped) } def verify_root=(verify_root); end - sig { params(spec: T.untyped, digests: T.untyped, signatures: T.untyped).returns(T.untyped) } def verify_signatures(spec, digests, signatures); end - sig { returns(T.untyped) } def verify_signer; end - sig { params(verify_signer: T.untyped).returns(T.untyped) } def verify_signer=(verify_signer); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end @@ -4886,19 +3542,14 @@ module Gem include Gem::Text DEFAULT_OPTIONS = T.let(nil, T.untyped) - sig { returns(T.untyped) } def cert_chain; end - sig { params(cert_chain: T.untyped).returns(T.untyped) } def cert_chain=(cert_chain); end - sig { returns(T.untyped) } def digest_algorithm; end - sig { returns(T.untyped) } def digest_name; end - sig { params(cert: T.untyped).returns(T.untyped) } def extract_name(cert); end sig do @@ -4909,118 +3560,84 @@ module Gem options: T.untyped ).returns(Signer) end + def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end - sig { returns(T.untyped) } def key; end - sig { params(key: T.untyped).returns(T.untyped) } def key=(key); end - sig { returns(T.untyped) } def load_cert_chain; end - sig { returns(T.untyped) } def options; end - sig { params(expiration_length: T.untyped).returns(T.untyped) } def re_sign_key(expiration_length: T.unsafe(nil)); end - sig { params(data: T.untyped).returns(T.untyped) } def sign(data); end - sig { params(expired_cert: T.untyped, expired_cert_path: T.untyped, private_key: T.untyped).returns(T.untyped) } def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end class TrustDir DEFAULT_PERMISSIONS = T.let(nil, T.untyped) - sig { params(certificate: T.untyped).returns(T.untyped) } def cert_path(certificate); end - sig { returns(T.untyped) } def dir; end - sig { returns(T.untyped) } def each_certificate; end - sig { params(dir: T.untyped, permissions: T.untyped).returns(TrustDir) } def initialize(dir, permissions = T.unsafe(nil)); end - sig { params(certificate: T.untyped).returns(T.untyped) } def issuer_of(certificate); end - sig { params(certificate_file: T.untyped).returns(T.untyped) } def load_certificate(certificate_file); end - sig { params(name: T.untyped).returns(T.untyped) } def name_path(name); end - sig { params(certificate: T.untyped).returns(T.untyped) } def trust_cert(certificate); end - sig { returns(T.untyped) } def verify; end end end class SilentUI - sig { returns(SilentUI) } def initialize; end end @@ -5028,53 +3645,37 @@ module Gem include Comparable FILES = T.let(nil, T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { params(uri: T.untyped).returns(T.untyped) } def cache_dir(uri); end - sig { returns(T.untyped) } def dependency_resolver_set; end - sig { params(spec: T.untyped, dir: T.untyped).returns(T.untyped) } def download(spec, dir = T.unsafe(nil)); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { params(name_tuple: T.untyped).returns(T.untyped) } def fetch_spec(name_tuple); end - sig { params(uri: T.untyped).returns(Source) } def initialize(uri); end - sig { params(type: T.untyped).returns(T.untyped) } def load_specs(type); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T::Boolean) } def update_cache?; end - sig { returns(T.untyped) } def uri; end class Git - sig { returns(T.untyped) } def base_dir; end - sig { returns(T.untyped) } def cache; end - sig { returns(T.untyped) } def checkout; end - sig { returns(T.untyped) } def dir_shortref; end - sig { params(full_spec: T.untyped, path: T.untyped).returns(T.untyped) } def download(full_spec, path); end sig do @@ -5085,115 +3686,84 @@ module Gem submodules: T.untyped ).returns(Git) end + def initialize(name, repository, reference, submodules = T.unsafe(nil)); end - sig { returns(T.untyped) } def install_dir; end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def need_submodules; end - sig { returns(T.untyped) } def reference; end - sig { returns(T.untyped) } def remote; end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { returns(T.untyped) } def repo_cache_dir; end - sig { returns(T.untyped) } def repository; end - sig { returns(T.untyped) } def rev_parse; end - sig { returns(T.untyped) } def root_dir; end - sig { params(root_dir: T.untyped).returns(T.untyped) } def root_dir=(root_dir); end - sig { returns(T.untyped) } def specs; end - sig { returns(T.untyped) } def uri_hash; end end class Installed - sig { params(spec: T.untyped, path: T.untyped).returns(T.untyped) } def download(spec, path); end - sig { returns(Installed) } def initialize; end end class Local - sig { params(spec: T.untyped, cache_dir: T.untyped).returns(T.untyped) } def download(spec, cache_dir = T.unsafe(nil)); end - sig { params(name: T.untyped).returns(T.untyped) } def fetch_spec(name); end - sig { params(gem_name: T.untyped, version: T.untyped, prerelease: T.untyped).returns(T.untyped) } def find_gem(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end - sig { returns(Local) } def initialize; end end class Lock - sig { params(source: T.untyped).returns(Lock) } def initialize(source); end - sig { returns(T.untyped) } def wrapped; end end class SpecificFile - sig { params(name: T.untyped).returns(T.untyped) } def fetch_spec(name); end - sig { params(file: T.untyped).returns(SpecificFile) } def initialize(file); end - sig { params(a: T.untyped).returns(T.untyped) } def load_specs(*a); end - sig { returns(T.untyped) } def path; end - sig { returns(T.untyped) } def spec; end end class Vendor - sig { params(path: T.untyped).returns(Vendor) } def initialize(path); end end end class SourceFetchProblem - sig { returns(T.untyped) } def error; end - sig { returns(T.untyped) } def exception; end - sig { params(source: T.untyped, error: T.untyped).returns(SourceFetchProblem) } def initialize(source, error); end - sig { returns(T.untyped) } def source; end - sig { returns(T.untyped) } def wordy; end end @@ -5201,46 +3771,32 @@ module Gem include Enumerable Elem = type_member(fixed: T.untyped) - sig { params(obj: T.untyped).returns(T.untyped) } def <<(obj); end - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { returns(T.untyped) } def clear; end - sig { params(source: T.untyped).returns(T.untyped) } def delete(source); end - sig { params(blk: T.untyped).returns(T.untyped) } def each(&blk); end - sig { params(b: T.untyped).returns(T.untyped) } def each_source(&b); end - sig { returns(T::Boolean) } def empty?; end - sig { returns(T.untyped) } def first; end - sig { params(other: T.untyped).returns(T::Boolean) } def include?(other); end - sig { params(other: T.untyped).returns(T.untyped) } def replace(other); end - sig { returns(T.untyped) } def sources; end - sig { returns(T.untyped) } def to_a; end - sig { returns(T.untyped) } def to_ary; end - sig { params(ary: T.untyped).returns(T.untyped) } def self.from(ary); end end @@ -5249,111 +3805,76 @@ module Gem include Gem::DefaultUserInteraction include Gem::Text - sig { params(type: T.untyped).returns(T.untyped) } def available_specs(type); end - sig { params(type: T.untyped).returns(T.untyped) } def detect(type = T.unsafe(nil)); end - sig { params(sources: T.untyped).returns(SpecFetcher) } def initialize(sources = T.unsafe(nil)); end - sig { returns(T.untyped) } def latest_specs; end - sig { returns(T.untyped) } def prerelease_specs; end - sig { params(dependency: T.untyped, matching_platform: T.untyped).returns(T.untyped) } def search_for_dependency(dependency, matching_platform = T.unsafe(nil)); end - sig { returns(T.untyped) } def sources; end - sig { params(dependency: T.untyped, matching_platform: T.untyped).returns(T.untyped) } def spec_for_dependency(dependency, matching_platform = T.unsafe(nil)); end - sig { returns(T.untyped) } def specs; end - sig { params(gem_name: T.untyped, type: T.untyped).returns(T.untyped) } def suggest_gems_from_name(gem_name, type = T.unsafe(nil)); end - sig { params(source: T.untyped, type: T.untyped, gracefully_ignore: T.untyped).returns(T.untyped) } def tuples_for(source, type, gracefully_ignore = T.unsafe(nil)); end - sig { returns(T.untyped) } def self.fetcher; end - sig { params(fetcher: T.untyped).returns(T.untyped) } def self.fetcher=(fetcher); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end end class SpecificGemNotFoundException - sig { returns(T.untyped) } def errors; end - sig { params(name: T.untyped, version: T.untyped, errors: T.untyped).returns(SpecificGemNotFoundException) } def initialize(name, version, errors = T.unsafe(nil)); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def version; end end @@ -5366,601 +3887,402 @@ module Gem DateTimeFormat = T.let(nil, T.untyped) INITIALIZE_CODE_FOR_DEFAULTS = T.let(nil, T.untyped) - sig { params(other: T.untyped).returns(T.untyped) } def ==(other); end - sig { returns(T.untyped) } def _deprecated_default_executable; end - sig { params(_deprecated_default_executable: T.untyped).returns(T.untyped) } def _deprecated_default_executable=(_deprecated_default_executable); end - sig { returns(T.untyped) } def _deprecated_has_rdoc; end - sig { params(ignored: T.untyped).returns(T.untyped) } def _deprecated_has_rdoc=(ignored); end - sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) } def _deprecated_has_rdoc?(*args, &block); end - sig { params(limit: T.untyped).returns(T.untyped) } def _dump(limit); end - sig { returns(T.untyped) } def abbreviate; end - sig { returns(T.untyped) } def activate; end - sig { returns(T.untyped) } def activate_dependencies; end - sig { returns(T.untyped) } def activated; end - sig { params(activated: T.untyped).returns(T.untyped) } def activated=(activated); end - sig { params(executables: T.untyped).returns(T.untyped) } def add_bindir(executables); end - sig { params(gem: T.untyped, requirements: T.untyped).returns(T.untyped) } def add_dependency(gem, *requirements); end - sig { params(gem: T.untyped, requirements: T.untyped).returns(T.untyped) } def add_development_dependency(gem, *requirements); end - sig { params(gem: T.untyped, requirements: T.untyped).returns(T.untyped) } def add_runtime_dependency(gem, *requirements); end - sig { returns(T.untyped) } def add_self_to_load_path; end - sig { returns(T.untyped) } def author; end - sig { params(o: T.untyped).returns(T.untyped) } def author=(o); end - sig { returns(T.untyped) } def authors; end - sig { params(value: T.untyped).returns(T.untyped) } def authors=(value); end - sig { returns(T.untyped) } def autorequire; end - sig { params(autorequire: T.untyped).returns(T.untyped) } def autorequire=(autorequire); end - sig { returns(T.untyped) } def bin_dir; end - sig { params(name: T.untyped).returns(T.untyped) } def bin_file(name); end - sig { returns(T.untyped) } def bindir; end - sig { params(bindir: T.untyped).returns(T.untyped) } def bindir=(bindir); end - sig { returns(T.untyped) } def build_args; end - sig { returns(T.untyped) } def build_extensions; end - sig { returns(T.untyped) } def build_info_dir; end - sig { returns(T.untyped) } def build_info_file; end - sig { returns(T.untyped) } def cache_dir; end - sig { returns(T.untyped) } def cache_file; end - sig { returns(T.untyped) } def cert_chain; end - sig { params(cert_chain: T.untyped).returns(T.untyped) } def cert_chain=(cert_chain); end - sig { params(list_of_specs: T.untyped).returns(T::Boolean) } def conficts_when_loaded_with?(list_of_specs); end - sig { returns(T.untyped) } def conflicts; end - sig { returns(T.untyped) } def date; end - sig { params(date: T.untyped).returns(T.untyped) } def date=(date); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def default_executable(*args, &block); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def default_executable=(*args, &block); end - sig { params(name: T.untyped).returns(T.untyped) } def default_value(name); end - sig { returns(T.untyped) } def dependencies; end - sig { returns(T.untyped) } def dependent_gems; end - sig { returns(T.untyped) } def dependent_specs; end - sig { returns(T.untyped) } def description; end - sig { params(str: T.untyped).returns(T.untyped) } def description=(str); end - sig { returns(T.untyped) } def development_dependencies; end - sig { params(type: T.untyped).returns(T.untyped) } def doc_dir(type = T.unsafe(nil)); end - sig { returns(T.untyped) } def email; end - sig { params(email: T.untyped).returns(T.untyped) } def email=(email); end - sig { params(coder: T.untyped).returns(T.untyped) } def encode_with(coder); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { returns(T.untyped) } def executable; end - sig { params(o: T.untyped).returns(T.untyped) } def executable=(o); end - sig { returns(T.untyped) } def executables; end - sig { params(value: T.untyped).returns(T.untyped) } def executables=(value); end - sig { returns(T.untyped) } def extensions; end - sig { params(extensions: T.untyped).returns(T.untyped) } def extensions=(extensions); end - sig { returns(T.untyped) } def extra_rdoc_files; end - sig { params(files: T.untyped).returns(T.untyped) } def extra_rdoc_files=(files); end - sig { returns(T.untyped) } def file_name; end - sig { returns(T.untyped) } def files; end - sig { params(files: T.untyped).returns(T.untyped) } def files=(files); end - sig { returns(T.untyped) } def for_cache; end - sig { returns(T.untyped) } def git_version; end - sig { returns(T.untyped) } def groups; end - sig { returns(T::Boolean) } def has_conflicts?; end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def has_rdoc(*args, &block); end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def has_rdoc=(*args, &block); end - sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) } def has_rdoc?(*args, &block); end - sig { returns(T::Boolean) } def has_test_suite?; end - sig { returns(T::Boolean) } def has_unit_tests?; end - sig { returns(T.untyped) } def homepage; end - sig { params(homepage: T.untyped).returns(T.untyped) } def homepage=(homepage); end - sig { params(coder: T.untyped).returns(T.untyped) } def init_with(coder); end - sig { params(name: T.untyped, version: T.untyped).returns(Specification) } def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end - sig { returns(T.untyped) } def installed_by_version; end - sig { params(version: T.untyped).returns(T.untyped) } def installed_by_version=(version); end - sig { returns(T.untyped) } def keep_only_files_and_directories; end - sig { returns(T.untyped) } def lib_files; end - sig { returns(T.untyped) } def license; end - sig { params(o: T.untyped).returns(T.untyped) } def license=(o); end - sig { returns(T.untyped) } def licenses; end - sig { params(licenses: T.untyped).returns(T.untyped) } def licenses=(licenses); end - sig { returns(T.untyped) } def load_paths; end - sig { returns(T.untyped) } def location; end - sig { params(location: T.untyped).returns(T.untyped) } def location=(location); end - sig { returns(T.untyped) } def mark_version; end - sig { returns(T.untyped) } def metadata; end - sig { params(metadata: T.untyped).returns(T.untyped) } def metadata=(metadata); end - sig { params(sym: T.untyped, a: T.untyped, b: T.untyped).returns(T.untyped) } def method_missing(sym, *a, &b); end - sig { returns(T::Boolean) } def missing_extensions?; end - sig { params(name: T.untyped).returns(T.untyped) } def name=(name); end - sig { returns(T.untyped) } def name_tuple; end - sig { returns(T.untyped) } def nondevelopment_dependencies; end - sig { returns(T.untyped) } def normalize; end - sig { returns(T.untyped) } def original_name; end - sig { returns(T.untyped) } def original_platform; end - sig { params(original_platform: T.untyped).returns(T.untyped) } def original_platform=(original_platform); end - sig { params(platform: T.untyped).returns(T.untyped) } def platform=(platform); end - sig { returns(T.untyped) } def post_install_message; end - sig { params(post_install_message: T.untyped).returns(T.untyped) } def post_install_message=(post_install_message); end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def raise_if_conflicts; end - sig { returns(T.untyped) } def rdoc_options; end - sig { params(options: T.untyped).returns(T.untyped) } def rdoc_options=(options); end - sig { returns(T.untyped) } def relative_loaded_from; end - sig { params(relative_loaded_from: T.untyped).returns(T.untyped) } def relative_loaded_from=(relative_loaded_from); end - sig { returns(T.untyped) } def remote; end - sig { params(remote: T.untyped).returns(T.untyped) } def remote=(remote); end - sig { returns(T.untyped) } def require_path; end - sig { params(path: T.untyped).returns(T.untyped) } def require_path=(path); end - sig { params(val: T.untyped).returns(T.untyped) } def require_paths=(val); end - sig { returns(T.untyped) } def required_ruby_version; end - sig { params(req: T.untyped).returns(T.untyped) } def required_ruby_version=(req); end - sig { returns(T.untyped) } def required_rubygems_version; end - sig { params(req: T.untyped).returns(T.untyped) } def required_rubygems_version=(req); end - sig { returns(T.untyped) } def requirements; end - sig { params(req: T.untyped).returns(T.untyped) } def requirements=(req); end - sig { returns(T.untyped) } def reset_nil_attributes_to_default; end - sig { returns(T.untyped) } def rg_extension_dir; end - sig { returns(T.untyped) } def rg_full_gem_path; end - sig { returns(T.untyped) } def rg_loaded_from; end - sig { returns(T.untyped) } def ri_dir; end - sig { params(rubyforge_project: T.untyped).returns(T.untyped) } def rubyforge_project=(rubyforge_project); end - sig { returns(T.untyped) } def rubygems_version; end - sig { params(rubygems_version: T.untyped).returns(T.untyped) } def rubygems_version=(rubygems_version); end - sig { returns(T.untyped) } def runtime_dependencies; end - sig { returns(T.untyped) } def sanitize; end - sig { params(string: T.untyped).returns(T.untyped) } def sanitize_string(string); end - sig { params(dependency: T.untyped).returns(T::Boolean) } def satisfies_requirement?(dependency); end - sig { returns(T.untyped) } def signing_key; end - sig { params(signing_key: T.untyped).returns(T.untyped) } def signing_key=(signing_key); end - sig { returns(T.untyped) } def sort_obj; end - sig { returns(T.untyped) } def source; end - sig { params(source: T.untyped).returns(T.untyped) } def source=(source); end - sig { returns(T.untyped) } def spec_dir; end - sig { returns(T.untyped) } def spec_file; end - sig { returns(T.untyped) } def spec_name; end - sig { returns(T.untyped) } def specification_version; end - sig { params(specification_version: T.untyped).returns(T.untyped) } def specification_version=(specification_version); end - sig { returns(T.untyped) } def summary; end - sig { params(str: T.untyped).returns(T.untyped) } def summary=(str); end - sig { returns(T.untyped) } def test_file; end - sig { params(file: T.untyped).returns(T.untyped) } def test_file=(file); end - sig { returns(T.untyped) } def test_files; end - sig { params(files: T.untyped).returns(T.untyped) } def test_files=(files); end - sig { params(path: T.untyped).returns(T.untyped) } def to_gemfile(path = T.unsafe(nil)); end - sig { returns(T.untyped) } def to_ruby; end - sig { returns(T.untyped) } def to_ruby_for_cache; end - sig { params(opts: T.untyped).returns(T.untyped) } def to_yaml(opts = T.unsafe(nil)); end - sig { params(trail: T.untyped, visited: T.untyped, block: T.untyped).returns(T.untyped) } def traverse(trail = T.unsafe(nil), visited = T.unsafe(nil), &block); end - sig { params(packaging: T.untyped, strict: T.untyped).returns(T.untyped) } def validate(packaging = T.unsafe(nil), strict = T.unsafe(nil)); end - sig { returns(T.untyped) } def validate_dependencies; end - sig { returns(T.untyped) } def validate_metadata; end - sig { returns(T.untyped) } def validate_permissions; end - sig { params(version: T.untyped).returns(T.untyped) } def version=(version); end - sig { params(tag: T.untyped, vals: T.untyped).returns(T.untyped) } def yaml_initialize(tag, vals); end - sig { returns(T.untyped) } def self._all; end - sig { returns(T.untyped) } def self._clear_load_cache; end - sig { params(specs: T.untyped, prerelease: T.untyped).returns(T.untyped) } def self._latest_specs(specs, prerelease = T.unsafe(nil)); end - sig { params(str: T.untyped).returns(T.untyped) } def self._load(str); end - sig { params(specs: T.untyped).returns(T.untyped) } def self._resort!(specs); end - sig { params(spec: T.untyped).returns(T.untyped) } def self.add_spec(spec); end - sig { params(specs: T.untyped).returns(T.untyped) } def self.add_specs(*specs); end - sig { returns(T.untyped) } def self.all; end - sig { params(specs: T.untyped).returns(T.untyped) } def self.all=(specs); end - sig { returns(T.untyped) } def self.all_names; end - sig { returns(T.untyped) } def self.array_attributes; end - sig { returns(T.untyped) } def self.attribute_names; end - sig { returns(T.untyped) } def self.dirs; end - sig { params(dirs: T.untyped).returns(T.untyped) } def self.dirs=(dirs); end - sig { params(blk: T.untyped).returns(T.untyped) } def self.each(&blk); end - sig { params(dirs: T.untyped).returns(T.untyped) } def self.each_gemspec(dirs); end - sig { params(dirs: T.untyped).returns(T.untyped) } def self.each_spec(dirs); end - sig { params(path: T.untyped).returns(T.untyped) } def self.find_active_stub_by_path(path); end - sig { params(full_name: T.untyped).returns(T.untyped) } def self.find_all_by_full_name(full_name); end - sig { params(name: T.untyped, requirements: T.untyped).returns(T.untyped) } def self.find_all_by_name(name, *requirements); end - sig { params(name: T.untyped, requirements: T.untyped).returns(T.untyped) } def self.find_by_name(name, *requirements); end - sig { params(path: T.untyped).returns(T.untyped) } def self.find_by_path(path); end - sig { params(path: T.untyped).returns(T.untyped) } def self.find_in_unresolved(path); end - sig { params(path: T.untyped).returns(T.untyped) } def self.find_in_unresolved_tree(path); end - sig { params(path: T.untyped).returns(T.untyped) } def self.find_inactive_by_path(path); end - sig { params(input: T.untyped).returns(T.untyped) } def self.from_yaml(input); end - sig { params(prerelease: T.untyped).returns(T.untyped) } def self.latest_specs(prerelease = T.unsafe(nil)); end - sig { params(file: T.untyped).returns(T.untyped) } def self.load(file); end - sig { returns(T.untyped) } def self.load_defaults; end - sig { returns(T.untyped) } def self.non_nil_attributes; end - sig { params(input: T.untyped).returns(T.untyped) } def self.normalize_yaml_input(input); end - sig { returns(T.untyped) } def self.outdated; end - sig { returns(T.untyped) } def self.outdated_and_latest_version; end - sig { params(spec: T.untyped).returns(T.untyped) } def self.remove_spec(spec); end - sig { params(name: T.untyped).returns(T::Boolean) } def self.required_attribute?(name); end - sig { returns(T.untyped) } def self.required_attributes; end - sig { returns(T.untyped) } def self.reset; end - sig { returns(T.untyped) } def self.stubs; end - sig { params(name: T.untyped).returns(T.untyped) } def self.stubs_for(name); end - sig { returns(T.untyped) } def self.unresolved_deps; end end @@ -5973,71 +4295,50 @@ module Gem VALID_NAME_PATTERN = T.let(nil, T.untyped) VALID_URI_PATTERN = T.let(nil, T.untyped) - sig { params(specification: T.untyped).returns(SpecificationPolicy) } def initialize(specification); end - sig { returns(T.untyped) } def packaging; end - sig { params(packaging: T.untyped).returns(T.untyped) } def packaging=(packaging); end - sig { params(strict: T.untyped).returns(T.untyped) } def validate(strict = T.unsafe(nil)); end - sig { returns(T.untyped) } def validate_dependencies; end - sig { returns(T.untyped) } def validate_metadata; end - sig { returns(T.untyped) } def validate_permissions; end end class StreamUI extend Gem::Deprecate - sig { params(statement: T.untyped).returns(T.untyped) } def _deprecated_debug(statement); end - sig { returns(T.untyped) } def _gets_noecho; end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(question: T.untyped).returns(T.untyped) } def ask_for_password(question); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(exception: T.untyped).returns(T.untyped) } def backtrace(exception); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { returns(T.untyped) } def close; end - sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) } def debug(*args, &block); end - sig { params(args: T.untyped).returns(T.untyped) } def download_reporter(*args); end - sig { returns(T.untyped) } def errs; end sig do @@ -6048,35 +4349,27 @@ module Gem usetty: T.untyped ).returns(StreamUI) end + def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end - sig { returns(T.untyped) } def ins; end - sig { returns(T.untyped) } def outs; end - sig { params(args: T.untyped).returns(T.untyped) } def progress_reporter(*args); end - sig { returns(T.untyped) } def require_io_console; end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(status: T.untyped).returns(T.untyped) } def terminate_interaction(status = T.unsafe(nil)); end - sig { returns(T::Boolean) } def tty?; end end class StubSpecification - sig { returns(T.untyped) } def build_extensions; end - sig { returns(T.untyped) } def extensions; end sig do @@ -6087,114 +4380,83 @@ module Gem default_gem: T.untyped ).returns(StubSpecification) end + def initialize(filename, base_dir, gems_dir, default_gem); end - sig { returns(T::Boolean) } def missing_extensions?; end - sig { returns(T::Boolean) } def valid?; end - sig { params(filename: T.untyped, base_dir: T.untyped, gems_dir: T.untyped).returns(T.untyped) } def self.default_gemspec_stub(filename, base_dir, gems_dir); end - sig { params(filename: T.untyped, base_dir: T.untyped, gems_dir: T.untyped).returns(T.untyped) } def self.gemspec_stub(filename, base_dir, gems_dir); end class StubLine - sig { returns(T.untyped) } def extensions; end - sig { returns(T.untyped) } def full_name; end - sig { params(data: T.untyped, extensions: T.untyped).returns(StubLine) } def initialize(data, extensions); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def platform; end - sig { returns(T.untyped) } def require_paths; end - sig { returns(T.untyped) } def version; end end end class SystemExitException - sig { returns(T.untyped) } def exit_code; end - sig { params(exit_code: T.untyped).returns(T.untyped) } def exit_code=(exit_code); end - sig { params(exit_code: T.untyped).returns(SystemExitException) } def initialize(exit_code); end end module Text - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end end class UninstallError - sig { returns(T.untyped) } def spec; end - sig { params(spec: T.untyped).returns(T.untyped) } def spec=(spec); end end class UnsatisfiableDependencyError - sig { returns(T.untyped) } def dependency; end - sig { returns(T.untyped) } def errors; end - sig { params(errors: T.untyped).returns(T.untyped) } def errors=(errors); end - sig { params(dep: T.untyped, platform_mismatch: T.untyped).returns(UnsatisfiableDependencyError) } def initialize(dep, platform_mismatch = T.unsafe(nil)); end - sig { returns(T.untyped) } def name; end - sig { returns(T.untyped) } def version; end end class UriFormatter - sig { returns(T.untyped) } def escape; end - sig { params(uri: T.untyped).returns(UriFormatter) } def initialize(uri); end - sig { returns(T.untyped) } def normalize; end - sig { returns(T.untyped) } def unescape; end - sig { returns(T.untyped) } def uri; end end @@ -6202,146 +4464,100 @@ module Gem include Gem::DefaultUserInteraction include Gem::Text - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_error(statement, question = T.unsafe(nil)); end - sig { params(statement: T.untyped, question: T.untyped).returns(T.untyped) } def alert_warning(statement, question = T.unsafe(nil)); end - sig { params(question: T.untyped).returns(T.untyped) } def ask(question); end - sig { params(prompt: T.untyped).returns(T.untyped) } def ask_for_password(prompt); end - sig { params(question: T.untyped, default: T.untyped).returns(T.untyped) } def ask_yes_no(question, default = T.unsafe(nil)); end - sig { params(question: T.untyped, list: T.untyped).returns(T.untyped) } def choose_from_list(question, list); end - sig { params(statement: T.untyped).returns(T.untyped) } def say(statement = T.unsafe(nil)); end - sig { params(exit_code: T.untyped).returns(T.untyped) } def terminate_interaction(exit_code = T.unsafe(nil)); end - sig { params(msg: T.untyped).returns(T.untyped) } def verbose(msg = T.unsafe(nil)); end - sig { params(text: T.untyped).returns(T.untyped) } def clean_text(text); end - sig { params(text: T.untyped, wrap: T.untyped, indent: T.untyped).returns(T.untyped) } def format_text(text, wrap, indent = T.unsafe(nil)); end - sig { params(str1: T.untyped, str2: T.untyped).returns(T.untyped) } def levenshtein_distance(str1, str2); end - sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) } def min3(a, b, c); end - sig { params(text: T.untyped, description: T.untyped, max_length: T.untyped).returns(T.untyped) } def truncate_text(text, description, max_length = T.unsafe(nil)); end - sig { returns(T.untyped) } def ui; end - sig { params(new_ui: T.untyped).returns(T.untyped) } def ui=(new_ui); end - sig { params(new_ui: T.untyped, block: T.untyped).returns(T.untyped) } def use_ui(new_ui, &block); end end module Util - sig { params(glob: T.untyped, base_path: T.untyped).returns(T.untyped) } def self.glob_files_in_dir(glob, base_path); end - sig { params(data: T.untyped).returns(T.untyped) } def self.gunzip(data); end - sig { params(data: T.untyped).returns(T.untyped) } def self.gzip(data); end - sig { params(data: T.untyped).returns(T.untyped) } def self.inflate(data); end - sig { params(command: T.untyped).returns(T.untyped) } def self.popen(*command); end - sig { params(command: T.untyped).returns(T.untyped) } def self.silent_system(*command); end - sig { params(directory: T.untyped, block: T.untyped).returns(T.untyped) } def self.traverse_parents(directory, &block); end end class Version - sig { returns(T.untyped) } def _segments; end - sig { returns(T.untyped) } def _split_segments; end - sig { returns(T.untyped) } def _version; end - sig { returns(T.untyped) } def approximate_recommendation; end - sig { returns(T.untyped) } def bump; end - sig { returns(T.untyped) } def canonical_segments; end - sig { params(coder: T.untyped).returns(T.untyped) } def encode_with(coder); end - sig { params(other: T.untyped).returns(T::Boolean) } def eql?(other); end - sig { params(coder: T.untyped).returns(T.untyped) } def init_with(coder); end - sig { returns(T.untyped) } def marshal_dump; end - sig { params(array: T.untyped).returns(T.untyped) } def marshal_load(array); end - sig { returns(T::Boolean) } def prerelease?; end - sig { params(q: T.untyped).returns(T.untyped) } def pretty_print(q); end - sig { returns(T.untyped) } def release; end - sig { returns(T.untyped) } def segments; end - sig { returns(T.untyped) } def to_yaml_properties; end - sig { returns(T.untyped) } def version; end - sig { params(tag: T.untyped, map: T.untyped).returns(T.untyped) } def yaml_initialize(tag, map); end - sig { params(version: T.untyped).returns(T::Boolean) } def self.correct?(version); end - sig { params(input: T.untyped).returns(T.untyped) } def self.create(input); end - sig { params(version: T.untyped).returns(T.untyped) } def self.new(version); end end end From 3984407787554f25915c9f4eb68cb0df122e800c Mon Sep 17 00:00:00 2001 From: Connor Shea <connor.james.shea@gmail.com> Date: Tue, 6 Aug 2019 17:15:37 -0600 Subject: [PATCH 4/6] Remove incorrect 'extend Enumerable' from gem.rbi. --- lib/ruby/all/gem.rbi | 1 - 1 file changed, 1 deletion(-) diff --git a/lib/ruby/all/gem.rbi b/lib/ruby/all/gem.rbi index fc2d4fc8..6282a2fc 100644 --- a/lib/ruby/all/gem.rbi +++ b/lib/ruby/all/gem.rbi @@ -3881,7 +3881,6 @@ module Gem class Specification include Bundler::MatchPlatform include Bundler::GemHelpers - extend Enumerable extend Gem::Deprecate DateLike = T.let(nil, T.untyped) DateTimeFormat = T.let(nil, T.untyped) From b7487cf006615578e898e8f01d8bdc8590c53388 Mon Sep 17 00:00:00 2001 From: Connor Shea <connor.james.shea@gmail.com> Date: Tue, 6 Aug 2019 17:36:34 -0600 Subject: [PATCH 5/6] Revert the change in bundler.rbi --- lib/bundler/all/bundler.rbi | 1 - 1 file changed, 1 deletion(-) diff --git a/lib/bundler/all/bundler.rbi b/lib/bundler/all/bundler.rbi index ac69245c..e7a1011f 100644 --- a/lib/bundler/all/bundler.rbi +++ b/lib/bundler/all/bundler.rbi @@ -1210,7 +1210,6 @@ end class Bundler::EndpointSpecification < Gem::Specification ILLFORMED_MESSAGE = ::T.let(nil, ::T.untyped) - Elem = type_member(fixed: T.untyped) sig do params( From e00095f7e45342116354037d41ec41776e2455a4 Mon Sep 17 00:00:00 2001 From: Connor Shea <connor.james.shea@gmail.com> Date: Sat, 10 Aug 2019 10:33:54 -0600 Subject: [PATCH 6/6] Remove sigs I missed before. --- lib/ruby/all/gem.rbi | 352 ------------------------------------------- 1 file changed, 352 deletions(-) diff --git a/lib/ruby/all/gem.rbi b/lib/ruby/all/gem.rbi index 6282a2fc..823107fe 100644 --- a/lib/ruby/all/gem.rbi +++ b/lib/ruby/all/gem.rbi @@ -379,16 +379,6 @@ module Gem def show_help; end - sig do - params( - gem_name: T.untyped, - version: T.untyped, - errors: T.untyped, - domain: T.untyped, - required_by: T.untyped - ).returns(T.untyped) - end - def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end def summary; end @@ -824,14 +814,6 @@ module Gem end module Deprecate - sig do - params( - name: T.untyped, - repl: T.untyped, - year: T.untyped, - month: T.untyped - ).returns(T.untyped) - end def self.deprecate(name, repl, year, month); end def self.skip; end @@ -924,56 +906,20 @@ module Gem end class CmakeBuilder - sig do - params( - extension: T.untyped, - dest_path: T.untyped, - results: T.untyped, - args: T.untyped, - lib_dir: T.untyped - ).returns(T.untyped) - end def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end end class ConfigureBuilder - sig do - params( - extension: T.untyped, - dest_path: T.untyped, - results: T.untyped, - args: T.untyped, - lib_dir: T.untyped - ).returns(T.untyped) - end def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end end class ExtConfBuilder - sig do - params( - extension: T.untyped, - dest_path: T.untyped, - results: T.untyped, - args: T.untyped, - lib_dir: T.untyped - ).returns(T.untyped) - end def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end def self.get_relative_path(path); end end class RakeBuilder - sig do - params( - extension: T.untyped, - dest_path: T.untyped, - results: T.untyped, - args: T.untyped, - lib_dir: T.untyped - ).returns(T.untyped) - end def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end end end @@ -1305,15 +1251,6 @@ module Gem def load_spec(entry); end - sig do - params( - mkdir: T.untyped, - mkdir_options: T.untyped, - destination_dir: T.untyped, - file_name: T.untyped - ).returns(T.untyped) - end - def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end def normalize_path(pathname); end @@ -1346,14 +1283,6 @@ module Gem def verify_gz(entry); end - sig do - params( - spec: T.untyped, - skip_validation: T.untyped, - strict_validation: T.untyped, - file_name: T.untyped - ).returns(T.untyped) - end def self.build(spec, skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil), file_name = T.unsafe(nil)); end def self.new(gem, security_policy = T.unsafe(nil)); end @@ -1710,26 +1639,8 @@ module Gem def fetch_file(uri, *_); end - sig do - params( - uri: T.untyped, - last_modified: T.untyped, - head: T.untyped, - depth: T.untyped - ).returns(T.untyped) - end - def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end - sig do - params( - uri: T.untyped, - last_modified: T.untyped, - head: T.untyped, - depth: T.untyped - ).returns(T.untyped) - end - def fetch_https(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end def fetch_path(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end @@ -1805,15 +1716,6 @@ module Gem def fetch; end - sig do - params( - uri: T.untyped, - request_class: T.untyped, - last_modified: T.untyped, - pool: T.untyped - ).returns(Request) - end - def initialize(uri, request_class, last_modified, pool); end def perform_request(request); end @@ -1826,14 +1728,6 @@ module Gem def self.configure_connection_for_https(connection, cert_files); end - sig do - params( - uri: T.untyped, - request_class: T.untyped, - last_modified: T.untyped, - proxy: T.untyped - ).returns(T.untyped) - end def self.create_with_proxy(uri, request_class, last_modified, proxy); end def self.get_cert_files; end @@ -2102,15 +1996,6 @@ module Gem class ParseError def column; end - sig do - params( - message: T.untyped, - column: T.untyped, - line: T.untyped, - path: T.untyped - ).returns(ParseError) - end - def initialize(message, column, line, path); end def line; end @@ -2121,15 +2006,6 @@ module Gem class Parser def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end - sig do - params( - tokenizer: T.untyped, - set: T.untyped, - platforms: T.untyped, - filename: T.untyped - ).returns(Parser) - end - def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end def parse; end @@ -2152,15 +2028,6 @@ module Gem def empty?; end - sig do - params( - input: T.untyped, - filename: T.untyped, - line: T.untyped, - pos: T.untyped - ).returns(Tokenizer) - end - def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end def make_parser(set, platforms); end @@ -2473,27 +2340,8 @@ module Gem end class GitSet - sig do - params( - name: T.untyped, - repository: T.untyped, - reference: T.untyped, - submodules: T.untyped - ).returns(T.untyped) - end - def add_git_gem(name, repository, reference, submodules); end - sig do - params( - name: T.untyped, - version: T.untyped, - repository: T.untyped, - reference: T.untyped, - submodules: T.untyped - ).returns(T.untyped) - end - def add_git_spec(name, version, repository, reference, submodules); end def need_submodules; end @@ -2524,16 +2372,6 @@ module Gem end class IndexSpecification - sig do - params( - set: T.untyped, - name: T.untyped, - version: T.untyped, - source: T.untyped, - platform: T.untyped - ).returns(IndexSpecification) - end - def initialize(set, name, version, source, platform); end def pretty_print(q); end @@ -2566,15 +2404,6 @@ module Gem def initialize(domain); end - sig do - params( - name: T.untyped, - ver: T.untyped, - platform: T.untyped, - source: T.untyped - ).returns(T.untyped) - end - def load_spec(name, ver, platform, source); end def local?(dep_name); end @@ -2597,15 +2426,6 @@ module Gem def initialize(sources); end - sig do - params( - name: T.untyped, - version: T.untyped, - platform: T.untyped, - source: T.untyped - ).returns(T.untyped) - end - def load_spec(name, version, platform, source); end def pretty_print(q); end @@ -2616,16 +2436,6 @@ module Gem class LockSpecification def add_dependency(dependency); end - sig do - params( - set: T.untyped, - name: T.untyped, - version: T.untyped, - sources: T.untyped, - platform: T.untyped - ).returns(LockSpecification) - end - def initialize(set, name, version, sources, platform); end def pretty_print(q); end @@ -2685,15 +2495,6 @@ module Gem def ==(other); end - sig do - params( - name: T.untyped, - payload: T.untyped, - parent_names: T.untyped, - requirement: T.untyped - ).returns(T.untyped) - end - def add_child_vertex(name, payload, parent_names, requirement); end def add_edge(origin, destination, requirement); end @@ -2804,37 +2605,10 @@ module Gem extend T::Enumerable Elem = type_member(fixed: T.untyped) - sig do - params( - graph: T.untyped, - origin: T.untyped, - destination: T.untyped, - requirement: T.untyped - ).returns(T.untyped) - end - def add_edge_no_circular(graph, origin, destination, requirement); end - sig do - params( - graph: T.untyped, - name: T.untyped, - payload: T.untyped, - root: T.untyped - ).returns(T.untyped) - end - def add_vertex(graph, name, payload, root); end - sig do - params( - graph: T.untyped, - origin_name: T.untyped, - destination_name: T.untyped, - requirement: T.untyped - ).returns(T.untyped) - end - def delete_edge(graph, origin_name, destination_name, requirement); end def detach_vertex_named(graph, name); end @@ -2993,15 +2767,6 @@ module Gem def base; end - sig do - params( - specification_provider: T.untyped, - resolver_ui: T.untyped, - requested: T.untyped, - base: T.untyped - ).returns(Resolution) - end - def initialize(specification_provider, resolver_ui, requested, base); end def iteration_rate=(iteration_rate); end @@ -3220,15 +2985,6 @@ module Gem class VendorSet def add_vendor_gem(name, directory); end - sig do - params( - name: T.untyped, - version: T.untyped, - platform: T.untyped, - source: T.untyped - ).returns(T.untyped) - end - def load_spec(name, version, platform, source); end def pretty_print(q); end @@ -3264,79 +3020,26 @@ module Gem def self.alt_name_or_x509_entry(certificate, x509_entry); end - sig do - params( - subject: T.untyped, - key: T.untyped, - age: T.untyped, - extensions: T.untyped, - serial: T.untyped - ).returns(T.untyped) - end def self.create_cert(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end - sig do - params( - email: T.untyped, - key: T.untyped, - age: T.untyped, - extensions: T.untyped - ).returns(T.untyped) - end def self.create_cert_email(email, key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end - sig do - params( - subject: T.untyped, - key: T.untyped, - age: T.untyped, - extensions: T.untyped, - serial: T.untyped - ).returns(T.untyped) - end def self.create_cert_self_signed(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end def self.create_key(length = T.unsafe(nil), algorithm = T.unsafe(nil)); end def self.email_to_name(email_address); end - sig do - params( - expired_certificate: T.untyped, - private_key: T.untyped, - age: T.untyped, - extensions: T.untyped - ).returns(T.untyped) - end def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end def self.reset; end - sig do - params( - certificate: T.untyped, - signing_key: T.untyped, - signing_cert: T.untyped, - age: T.untyped, - extensions: T.untyped, - serial: T.untyped - ).returns(T.untyped) - end def self.sign(certificate, signing_key, signing_cert, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end def self.trust_dir; end def self.trusted_certificates(&block); end - sig do - params( - pemmable: T.untyped, - path: T.untyped, - permissions: T.untyped, - passphrase: T.untyped, - cipher: T.untyped - ).returns(T.untyped) - end def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end class DIGEST_ALGORITHM @@ -3438,15 +3141,6 @@ module Gem def check_chain(chain, time); end - sig do - params( - public_key: T.untyped, - digest: T.untyped, - signature: T.untyped, - data: T.untyped - ).returns(T.untyped) - end - def check_data(public_key, digest, signature, data); end def check_key(signer, key); end @@ -3469,16 +3163,6 @@ module Gem def subject(certificate); end - sig do - params( - chain: T.untyped, - key: T.untyped, - digests: T.untyped, - signatures: T.untyped, - full_name: T.untyped - ).returns(T.untyped) - end - def verify(chain, key = T.unsafe(nil), digests = T.unsafe(nil), signatures = T.unsafe(nil), full_name = T.unsafe(nil)); end def verify_chain; end @@ -3552,15 +3236,6 @@ module Gem def extract_name(cert); end - sig do - params( - key: T.untyped, - cert_chain: T.untyped, - passphrase: T.untyped, - options: T.untyped - ).returns(Signer) - end - def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end def key; end @@ -3678,15 +3353,6 @@ module Gem def download(full_spec, path); end - sig do - params( - name: T.untyped, - repository: T.untyped, - reference: T.untyped, - submodules: T.untyped - ).returns(Git) - end - def initialize(name, repository, reference, submodules = T.unsafe(nil)); end def install_dir; end @@ -4340,15 +4006,6 @@ module Gem def errs; end - sig do - params( - in_stream: T.untyped, - out_stream: T.untyped, - err_stream: T.untyped, - usetty: T.untyped - ).returns(StreamUI) - end - def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end def ins; end @@ -4371,15 +4028,6 @@ module Gem def extensions; end - sig do - params( - filename: T.untyped, - base_dir: T.untyped, - gems_dir: T.untyped, - default_gem: T.untyped - ).returns(StubSpecification) - end - def initialize(filename, base_dir, gems_dir, default_gem); end def missing_extensions?; end