mirror of
https://github.com/cmur2/dyndnsd.git
synced 2024-07-06 00:34:40 +02:00
4223 lines
78 KiB
Ruby
4223 lines
78 KiB
Ruby
# This file is autogenerated. Do not edit it by hand. Regenerate it with:
|
|
# srb rbi sorbet-typed
|
|
#
|
|
# If you would like to make changes to this file, great! Please upstream any changes you make here:
|
|
#
|
|
# https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/gem.rbi
|
|
#
|
|
# 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)
|
|
|
|
def self._deprecated_detect_gemdeps(path = T.unsafe(nil)); end
|
|
|
|
def self._deprecated_gunzip(data); end
|
|
|
|
def self._deprecated_gzip(data); end
|
|
|
|
def self._deprecated_inflate(data); end
|
|
|
|
def self.activate_bin_path(name, *args); end
|
|
|
|
def self.default_ext_dir_for(base_dir); end
|
|
|
|
def self.default_gems_use_full_paths?; end
|
|
|
|
def self.default_spec_cache_dir; end
|
|
|
|
def self.deflate(data); end
|
|
|
|
def self.detect_gemdeps(*args, &block); end
|
|
|
|
def self.dir; end
|
|
|
|
def self.done_installing(&hook); end
|
|
|
|
def self.done_installing_hooks; end
|
|
|
|
def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil); end
|
|
|
|
def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil); end
|
|
|
|
def self.ensure_subdirectories(dir, mode, subdirs); end
|
|
|
|
def self.env_requirement(gem_name); end
|
|
|
|
def self.extension_api_version; end
|
|
|
|
def self.find_files(glob, check_load_path = true); end
|
|
|
|
def self.find_files_from_load_path(glob); end
|
|
|
|
def self.find_latest_files(glob, check_load_path = T.unsafe(nil)); end
|
|
|
|
def self.find_unresolved_default_spec(path); end
|
|
|
|
def self.finish_resolve(*_); end
|
|
|
|
def self.gemdeps; end
|
|
|
|
def self.gunzip(*args, &block); end
|
|
|
|
def self.gzip(*args, &block); end
|
|
|
|
def self.host; end
|
|
|
|
def self.host=(host); end
|
|
|
|
def self.inflate(*args, &block); end
|
|
|
|
def self.install(name, version = T.unsafe(nil), *options); end
|
|
|
|
def self.install_extension_in_lib; end
|
|
|
|
def self.latest_rubygems_version; end
|
|
|
|
def self.latest_spec_for(name); end
|
|
|
|
def self.latest_version_for(name); end
|
|
|
|
def self.load_env_plugins; end
|
|
|
|
def self.load_path_insert_index; end
|
|
|
|
def self.load_plugin_files(plugins); end
|
|
|
|
def self.load_plugins; end
|
|
|
|
def self.load_yaml; end
|
|
|
|
def self.loaded_specs; end
|
|
|
|
def self.location_of_caller(depth = T.unsafe(nil)); end
|
|
|
|
def self.marshal_version; end
|
|
|
|
def self.needs; end
|
|
|
|
def self.operating_system_defaults; end
|
|
|
|
def self.path; end
|
|
|
|
def self.path_separator; end
|
|
|
|
def self.paths; end
|
|
|
|
def self.paths=(env); end
|
|
|
|
def self.platform_defaults; end
|
|
|
|
def self.platforms; end
|
|
|
|
def self.platforms=(platforms); end
|
|
|
|
def self.post_build(&hook); end
|
|
|
|
def self.post_build_hooks; end
|
|
|
|
def self.post_install(&hook); end
|
|
|
|
def self.post_install_hooks; end
|
|
|
|
def self.post_reset(&hook); end
|
|
|
|
def self.post_reset_hooks; end
|
|
|
|
def self.post_uninstall(&hook); end
|
|
|
|
def self.post_uninstall_hooks; end
|
|
|
|
def self.pre_install(&hook); end
|
|
|
|
def self.pre_install_hooks; end
|
|
|
|
def self.pre_reset(&hook); end
|
|
|
|
def self.pre_reset_hooks; end
|
|
|
|
def self.pre_uninstall(&hook); end
|
|
|
|
def self.pre_uninstall_hooks; end
|
|
|
|
def self.prefix; end
|
|
|
|
def self.read_binary(path); end
|
|
|
|
def self.refresh; end
|
|
|
|
def self.register_default_spec(spec); end
|
|
|
|
def self.remove_unresolved_default_spec(spec); end
|
|
|
|
def self.ruby; end
|
|
|
|
def self.ruby_api_version; end
|
|
|
|
def self.ruby_engine; end
|
|
|
|
def self.ruby_version; end
|
|
|
|
def self.rubygems_version; end
|
|
|
|
def self.sources; end
|
|
|
|
def self.sources=(new_sources); end
|
|
|
|
def self.spec_cache_dir; end
|
|
|
|
def self.suffix_pattern; end
|
|
|
|
def self.suffixes; end
|
|
|
|
def self.time(msg, width = T.unsafe(nil), display = T.unsafe(nil)); end
|
|
|
|
def self.try_activate(path); end
|
|
|
|
def self.ui; end
|
|
|
|
def self.use_gemdeps(path = T.unsafe(nil)); end
|
|
|
|
def self.use_paths(home, *paths); end
|
|
|
|
def self.user_dir; end
|
|
|
|
def self.user_home; end
|
|
|
|
def self.vendor_dir; end
|
|
|
|
def self.win_platform?; end
|
|
|
|
def self.write_binary(path, data); end
|
|
|
|
class AvailableSet
|
|
include Enumerable
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def <<(o); end
|
|
|
|
def add(spec, source); end
|
|
|
|
def all_specs; end
|
|
|
|
def each(&blk); end
|
|
|
|
def each_spec; end
|
|
|
|
def empty?; end
|
|
|
|
def find_all(req); end
|
|
|
|
def inject_into_list(dep_list); end
|
|
|
|
def match_platform!; end
|
|
|
|
def pick_best!; end
|
|
|
|
def prefetch(reqs); end
|
|
|
|
def remote; end
|
|
|
|
def remote=(remote); end
|
|
|
|
def remove_installed!(dep); end
|
|
|
|
def set; end
|
|
|
|
def size; end
|
|
|
|
def sorted; end
|
|
|
|
def source_for(spec); end
|
|
|
|
def to_request_set(development = T.unsafe(nil)); end
|
|
|
|
class Tuple
|
|
def source; end
|
|
|
|
def source=(_); end
|
|
|
|
def spec; end
|
|
|
|
def spec=(_); end
|
|
|
|
def self.[](*_); end
|
|
|
|
def self.members; end
|
|
end
|
|
end
|
|
|
|
class BasicSpecification
|
|
def activated?; end
|
|
|
|
def base_dir; end
|
|
|
|
def base_dir=(base_dir); end
|
|
|
|
def contains_requirable_file?(file); end
|
|
|
|
def datadir; end
|
|
|
|
def default_gem?; end
|
|
|
|
def extension_dir; end
|
|
|
|
def extension_dir=(extension_dir); end
|
|
|
|
def extensions_dir; end
|
|
|
|
def full_gem_path; end
|
|
|
|
def full_gem_path=(full_gem_path); end
|
|
|
|
def full_name; end
|
|
|
|
def full_require_paths; end
|
|
|
|
def gem_build_complete_path; end
|
|
|
|
def gem_dir; end
|
|
|
|
def gems_dir; end
|
|
|
|
def ignored=(ignored); end
|
|
|
|
def internal_init; end
|
|
|
|
def lib_dirs_glob; end
|
|
|
|
def loaded_from; end
|
|
|
|
def loaded_from=(loaded_from); end
|
|
|
|
def matches_for_glob(glob); end
|
|
|
|
def name; end
|
|
|
|
def platform; end
|
|
|
|
def raw_require_paths; end
|
|
|
|
def require_paths; end
|
|
|
|
def source_paths; end
|
|
|
|
def stubbed?; end
|
|
|
|
def this; end
|
|
|
|
def to_fullpath(path); end
|
|
|
|
def to_spec; end
|
|
|
|
def version; end
|
|
|
|
def self.default_specifications_dir; end
|
|
end
|
|
|
|
module BundlerVersionFinder
|
|
def self.bundler_version; end
|
|
|
|
def self.bundler_version_with_reason; end
|
|
|
|
def self.compatible?(spec); end
|
|
|
|
def self.filter!(specs); end
|
|
|
|
def self.missing_version_message; end
|
|
end
|
|
|
|
class Command
|
|
include Gem::UserInteraction
|
|
include Gem::DefaultUserInteraction
|
|
include Gem::Text
|
|
HELP = T.let(nil, T.untyped)
|
|
|
|
def add_extra_args(args); end
|
|
|
|
def add_option(*opts, &handler); end
|
|
|
|
def arguments; end
|
|
|
|
def begins?(long, short); end
|
|
|
|
def command; end
|
|
|
|
def defaults; end
|
|
|
|
def defaults=(defaults); end
|
|
|
|
def defaults_str; end
|
|
|
|
def description; end
|
|
|
|
def execute; end
|
|
|
|
def get_all_gem_names; end
|
|
|
|
def get_all_gem_names_and_versions; end
|
|
|
|
def get_one_gem_name; end
|
|
|
|
def get_one_optional_argument; end
|
|
|
|
def handle_options(args); end
|
|
|
|
def handles?(args); end
|
|
|
|
def initialize(command, summary = T.unsafe(nil), defaults = T.unsafe(nil)); end
|
|
|
|
def invoke(*args); end
|
|
|
|
def invoke_with_build_args(args, build_args); end
|
|
|
|
def merge_options(new_options); end
|
|
|
|
def options; end
|
|
|
|
def program_name; end
|
|
|
|
def program_name=(program_name); end
|
|
|
|
def remove_option(name); end
|
|
|
|
def show_help; end
|
|
|
|
def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end
|
|
|
|
def summary; end
|
|
|
|
def summary=(summary); end
|
|
|
|
def usage; end
|
|
|
|
def when_invoked(&block); end
|
|
|
|
def self.add_common_option(*args, &handler); end
|
|
|
|
def self.add_specific_extra_args(cmd, args); end
|
|
|
|
def self.build_args; end
|
|
|
|
def self.build_args=(value); end
|
|
|
|
def self.common_options; end
|
|
|
|
def self.extra_args; end
|
|
|
|
def self.extra_args=(value); end
|
|
|
|
def self.specific_extra_args(cmd); end
|
|
|
|
def self.specific_extra_args_hash; end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
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)
|
|
|
|
def ==(other); end
|
|
|
|
def [](key); end
|
|
|
|
def []=(key, value); end
|
|
|
|
def api_keys; end
|
|
|
|
def args; end
|
|
|
|
def backtrace; end
|
|
|
|
def backtrace=(backtrace); end
|
|
|
|
def bulk_threshold; end
|
|
|
|
def bulk_threshold=(bulk_threshold); end
|
|
|
|
def cert_expiration_length_days; end
|
|
|
|
def cert_expiration_length_days=(cert_expiration_length_days); end
|
|
|
|
def check_credentials_permissions; end
|
|
|
|
def concurrent_downloads; end
|
|
|
|
def concurrent_downloads=(concurrent_downloads); end
|
|
|
|
def config_file_name; end
|
|
|
|
def credentials_path; end
|
|
|
|
def disable_default_gem_server; end
|
|
|
|
def disable_default_gem_server=(disable_default_gem_server); end
|
|
|
|
def each(&block); end
|
|
|
|
def handle_arguments(arg_list); end
|
|
|
|
def home; end
|
|
|
|
def home=(home); end
|
|
|
|
def initialize(args); end
|
|
|
|
def load_api_keys; end
|
|
|
|
def load_file(filename); end
|
|
|
|
def path; end
|
|
|
|
def path=(path); end
|
|
|
|
def really_verbose; end
|
|
|
|
def rubygems_api_key; end
|
|
|
|
def rubygems_api_key=(api_key); end
|
|
|
|
def set_api_key(host, api_key); end
|
|
|
|
def sources; end
|
|
|
|
def sources=(sources); end
|
|
|
|
def ssl_ca_cert; end
|
|
|
|
def ssl_ca_cert=(ssl_ca_cert); end
|
|
|
|
def ssl_client_cert; end
|
|
|
|
def ssl_verify_mode; end
|
|
|
|
def to_yaml; end
|
|
|
|
def unset_api_key!; end
|
|
|
|
def update_sources; end
|
|
|
|
def update_sources=(update_sources); end
|
|
|
|
def verbose; end
|
|
|
|
def verbose=(verbose); end
|
|
|
|
def write; end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
end
|
|
|
|
class ConflictError
|
|
def conflicts; end
|
|
|
|
def initialize(target, conflicts); end
|
|
|
|
def target; end
|
|
end
|
|
|
|
class ConsoleUI
|
|
def initialize; end
|
|
end
|
|
|
|
module DefaultUserInteraction
|
|
include Gem::Text
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def self.ui; end
|
|
|
|
def self.ui=(new_ui); end
|
|
|
|
def self.use_ui(new_ui); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
end
|
|
|
|
class Dependency
|
|
def ==(other); end
|
|
|
|
def ===(other); end
|
|
|
|
def =~(other); end
|
|
|
|
def all_sources; end
|
|
|
|
def all_sources=(all_sources); end
|
|
|
|
def encode_with(coder); end
|
|
|
|
def eql?(other); end
|
|
|
|
def groups; end
|
|
|
|
def groups=(groups); end
|
|
|
|
def initialize(name, *requirements); end
|
|
|
|
def latest_version?; end
|
|
|
|
def match?(obj, version = T.unsafe(nil), allow_prerelease = T.unsafe(nil)); end
|
|
|
|
def matches_spec?(spec); end
|
|
|
|
def matching_specs(platform_only = T.unsafe(nil)); end
|
|
|
|
def merge(other); end
|
|
|
|
def name; end
|
|
|
|
def name=(name); end
|
|
|
|
def prerelease=(prerelease); end
|
|
|
|
def prerelease?; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def requirement; end
|
|
|
|
def requirements_list; end
|
|
|
|
def runtime?; end
|
|
|
|
def source; end
|
|
|
|
def source=(source); end
|
|
|
|
def specific?; end
|
|
|
|
def to_lock; end
|
|
|
|
def to_spec; end
|
|
|
|
def to_specs; end
|
|
|
|
def to_yaml_properties; end
|
|
|
|
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)
|
|
|
|
def _deprecated_add_found_dependencies(to_do, dependency_list); end
|
|
|
|
def _deprecated_gather_dependencies; end
|
|
|
|
def add_found_dependencies(*args, &block); end
|
|
|
|
def available_set_for(dep_or_name, version); end
|
|
|
|
def consider_local?; end
|
|
|
|
def consider_remote?; end
|
|
|
|
def document; end
|
|
|
|
def errors; end
|
|
|
|
def find_gems_with_sources(dep, best_only = T.unsafe(nil)); end
|
|
|
|
def find_spec_by_name_and_version(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end
|
|
|
|
def gather_dependencies(*args, &block); end
|
|
|
|
def in_background(what); end
|
|
|
|
def initialize(options = T.unsafe(nil)); end
|
|
|
|
def install(dep_or_name, version = T.unsafe(nil)); end
|
|
|
|
def install_development_deps; end
|
|
|
|
def installed_gems; end
|
|
|
|
def resolve_dependencies(dep_or_name, version); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
end
|
|
|
|
class DependencyList
|
|
include Enumerable
|
|
include TSort
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def add(*gemspecs); end
|
|
|
|
def clear; end
|
|
|
|
def dependency_order; end
|
|
|
|
def development; end
|
|
|
|
def development=(development); end
|
|
|
|
def each(&block); end
|
|
|
|
def find_name(full_name); end
|
|
|
|
def initialize(development = T.unsafe(nil)); end
|
|
|
|
def ok?; end
|
|
|
|
def ok_to_remove?(full_name, check_dev = T.unsafe(nil)); end
|
|
|
|
def remove_by_name(full_name); end
|
|
|
|
def remove_specs_unsatisfied_by(dependencies); end
|
|
|
|
def spec_predecessors; end
|
|
|
|
def specs; end
|
|
|
|
def tsort_each_node(&block); end
|
|
|
|
def why_not_ok?(quick = T.unsafe(nil)); end
|
|
|
|
def self.from_specs; end
|
|
end
|
|
|
|
class DependencyResolutionError
|
|
def conflict; end
|
|
|
|
def conflicting_dependencies; end
|
|
|
|
def initialize(conflict); end
|
|
end
|
|
|
|
module Deprecate
|
|
def self.deprecate(name, repl, year, month); end
|
|
|
|
def self.skip; end
|
|
|
|
def self.skip=(v); end
|
|
|
|
def self.skip_during; end
|
|
end
|
|
|
|
class Exception
|
|
extend Gem::Deprecate
|
|
|
|
def _deprecated_source_exception; end
|
|
|
|
def source_exception(*args, &block); end
|
|
|
|
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)
|
|
|
|
def build_args; end
|
|
|
|
def build_args=(build_args); end
|
|
|
|
def build_error(build_dir, output, backtrace = T.unsafe(nil)); end
|
|
|
|
def build_extension(extension, dest_path); end
|
|
|
|
def build_extensions; end
|
|
|
|
def builder_for(extension); end
|
|
|
|
def initialize(spec, build_args = T.unsafe(nil)); end
|
|
|
|
def write_gem_make_out(output); end
|
|
|
|
def self.class_name; end
|
|
|
|
def self.make(dest_path, results); end
|
|
|
|
def self.redirector; end
|
|
|
|
def self.run(command, results, command_name = T.unsafe(nil)); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
end
|
|
|
|
class CmakeBuilder
|
|
def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
|
|
end
|
|
|
|
class ConfigureBuilder
|
|
def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
|
|
end
|
|
|
|
class ExtConfBuilder
|
|
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
|
|
def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
|
|
end
|
|
end
|
|
|
|
class FilePermissionError
|
|
def directory; end
|
|
|
|
def initialize(directory); end
|
|
end
|
|
|
|
class FormatException
|
|
def file_path; end
|
|
|
|
def file_path=(file_path); end
|
|
end
|
|
|
|
class GemNotInHomeException
|
|
def spec; end
|
|
|
|
def spec=(spec); end
|
|
end
|
|
|
|
class ImpossibleDependenciesError
|
|
def build_message; end
|
|
|
|
def conflicts; end
|
|
|
|
def dependency; end
|
|
|
|
def initialize(request, conflicts); end
|
|
|
|
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)
|
|
|
|
def _deprecated_extension_build_error(build_dir, output, backtrace = T.unsafe(nil)); end
|
|
|
|
def app_script_text(bin_file_name); end
|
|
|
|
def bin_dir; end
|
|
|
|
def build_extensions; end
|
|
|
|
def build_root; end
|
|
|
|
def check_executable_overwrite(filename); end
|
|
|
|
def check_that_user_bin_dir_is_in_path; end
|
|
|
|
def default_spec_file; end
|
|
|
|
def dir; end
|
|
|
|
def ensure_dependencies_met; end
|
|
|
|
def ensure_dependency(spec, dependency); end
|
|
|
|
def ensure_loadable_spec; end
|
|
|
|
def ensure_required_ruby_version_met; end
|
|
|
|
def ensure_required_rubygems_version_met; end
|
|
|
|
def extension_build_error(*args, &block); end
|
|
|
|
def extract_bin; end
|
|
|
|
def extract_files; end
|
|
|
|
def formatted_program_filename(filename); end
|
|
|
|
def gem; end
|
|
|
|
def gem_dir; end
|
|
|
|
def gem_home; end
|
|
|
|
def generate_bin; end
|
|
|
|
def generate_bin_script(filename, bindir); end
|
|
|
|
def generate_bin_symlink(filename, bindir); end
|
|
|
|
def generate_windows_script(filename, bindir); end
|
|
|
|
def initialize(package, options = T.unsafe(nil)); end
|
|
|
|
def install; end
|
|
|
|
def installation_satisfies_dependency?(dependency); end
|
|
|
|
def installed_specs; end
|
|
|
|
def options; end
|
|
|
|
def pre_install_checks; end
|
|
|
|
def process_options; end
|
|
|
|
def run_post_build_hooks; end
|
|
|
|
def run_post_install_hooks; end
|
|
|
|
def run_pre_install_hooks; end
|
|
|
|
def shebang(bin_file_name); end
|
|
|
|
def spec; end
|
|
|
|
def spec_file; end
|
|
|
|
def unpack(directory); end
|
|
|
|
def verify_gem_home(unpack = T.unsafe(nil)); end
|
|
|
|
def verify_spec; end
|
|
|
|
def windows_stub_script(bindir, bin_file_name); end
|
|
|
|
def write_build_info_file; end
|
|
|
|
def write_cache_file; end
|
|
|
|
def write_default_spec; end
|
|
|
|
def write_spec; end
|
|
|
|
def self.at(path, options = T.unsafe(nil)); end
|
|
|
|
def self.exec_format; end
|
|
|
|
def self.exec_format=(exec_format); end
|
|
|
|
def self.for_spec(spec, options = T.unsafe(nil)); end
|
|
|
|
def self.install_lock; end
|
|
|
|
def self.path_warning; end
|
|
|
|
def self.path_warning=(path_warning); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
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)
|
|
|
|
def self.match?(license); end
|
|
|
|
def self.suggestions(license); end
|
|
|
|
def self.clean_text(text); end
|
|
|
|
def self.format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def self.levenshtein_distance(str1, str2); end
|
|
|
|
def self.min3(a, b, c); end
|
|
|
|
def self.truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
end
|
|
|
|
class List
|
|
def each(&blk); end
|
|
|
|
def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end
|
|
|
|
def prepend(value); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def tail; end
|
|
|
|
def tail=(tail); end
|
|
|
|
def to_a; end
|
|
|
|
def value; end
|
|
|
|
def value=(value); end
|
|
|
|
def self.prepend(list, value); end
|
|
end
|
|
|
|
class LoadError
|
|
def name; end
|
|
|
|
def name=(name); end
|
|
|
|
def requirement; end
|
|
|
|
def requirement=(requirement); end
|
|
end
|
|
|
|
class MissingSpecError
|
|
def initialize(name, requirement); end
|
|
end
|
|
|
|
class MissingSpecVersionError
|
|
def initialize(name, requirement, specs); end
|
|
|
|
def specs; end
|
|
end
|
|
|
|
class NameTuple
|
|
include Comparable
|
|
|
|
def ==(other); end
|
|
|
|
def eql?(other); end
|
|
|
|
def full_name; end
|
|
|
|
def initialize(name, version, platform = T.unsafe(nil)); end
|
|
|
|
def match_platform?; end
|
|
|
|
def name; end
|
|
|
|
def platform; end
|
|
|
|
def prerelease?; end
|
|
|
|
def spec_name; end
|
|
|
|
def to_a; end
|
|
|
|
def version; end
|
|
|
|
def self.from_list(list); end
|
|
|
|
def self.null; end
|
|
|
|
def self.to_basic(list); end
|
|
end
|
|
|
|
class Package
|
|
include Gem::UserInteraction
|
|
include Gem::DefaultUserInteraction
|
|
include Gem::Text
|
|
|
|
def add_checksums(tar); end
|
|
|
|
def add_contents(tar); end
|
|
|
|
def add_files(tar); end
|
|
|
|
def add_metadata(tar); end
|
|
|
|
def build(skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil)); end
|
|
|
|
def build_time; end
|
|
|
|
def build_time=(build_time); end
|
|
|
|
def checksums; end
|
|
|
|
def contents; end
|
|
|
|
def copy_to(path); end
|
|
|
|
def data_mode; end
|
|
|
|
def data_mode=(data_mode); end
|
|
|
|
def digest(entry); end
|
|
|
|
def dir_mode; end
|
|
|
|
def dir_mode=(dir_mode); end
|
|
|
|
def extract_files(destination_dir, pattern = T.unsafe(nil)); end
|
|
|
|
def extract_tar_gz(io, destination_dir, pattern = T.unsafe(nil)); end
|
|
|
|
def file_mode(mode); end
|
|
|
|
def files; end
|
|
|
|
def gzip_to(io); end
|
|
|
|
def initialize(gem, security_policy); end
|
|
|
|
def install_location(filename, destination_dir); end
|
|
|
|
def load_spec(entry); end
|
|
|
|
def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end
|
|
|
|
def normalize_path(pathname); end
|
|
|
|
def open_tar_gz(io); end
|
|
|
|
def prog_mode; end
|
|
|
|
def prog_mode=(prog_mode); end
|
|
|
|
def read_checksums(gem); end
|
|
|
|
def security_policy; end
|
|
|
|
def security_policy=(security_policy); end
|
|
|
|
def setup_signer(signer_options: T.unsafe(nil)); end
|
|
|
|
def spec; end
|
|
|
|
def spec=(spec); end
|
|
|
|
def verify; end
|
|
|
|
def verify_checksums(digests, checksums); end
|
|
|
|
def verify_entry(entry); end
|
|
|
|
def verify_files(gem); end
|
|
|
|
def verify_gz(entry); 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
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
|
|
class DigestIO
|
|
def digests; end
|
|
|
|
def initialize(io, digests); end
|
|
|
|
def write(data); end
|
|
|
|
def self.wrap(io, digests); end
|
|
end
|
|
|
|
class Error
|
|
end
|
|
|
|
class FileSource
|
|
def initialize(path); end
|
|
|
|
def path; end
|
|
|
|
def present?; end
|
|
|
|
def start; end
|
|
|
|
def with_read_io(&block); end
|
|
|
|
def with_write_io(&block); end
|
|
end
|
|
|
|
class FormatError
|
|
def initialize(message, source = T.unsafe(nil)); end
|
|
|
|
def path; end
|
|
end
|
|
|
|
class IOSource
|
|
def initialize(io); end
|
|
|
|
def io; end
|
|
|
|
def path; end
|
|
|
|
def present?; end
|
|
|
|
def start; end
|
|
|
|
def with_read_io; end
|
|
|
|
def with_write_io; end
|
|
end
|
|
|
|
class NonSeekableIO
|
|
end
|
|
|
|
class Old
|
|
def extract_files(destination_dir); end
|
|
|
|
def file_list(io); end
|
|
|
|
def read_until_dashes(io); end
|
|
|
|
def skip_ruby(io); end
|
|
end
|
|
|
|
class 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)
|
|
|
|
def ==(other); end
|
|
|
|
def checksum; end
|
|
|
|
def devmajor; end
|
|
|
|
def devminor; end
|
|
|
|
def empty?; end
|
|
|
|
def gid; end
|
|
|
|
def gname; end
|
|
|
|
def initialize(vals); end
|
|
|
|
def linkname; end
|
|
|
|
def magic; end
|
|
|
|
def mode; end
|
|
|
|
def mtime; end
|
|
|
|
def name; end
|
|
|
|
def prefix; end
|
|
|
|
def size; end
|
|
|
|
def typeflag; end
|
|
|
|
def uid; end
|
|
|
|
def uname; end
|
|
|
|
def update_checksum; end
|
|
|
|
def version; end
|
|
|
|
def self.from(stream); end
|
|
|
|
def self.strict_oct(str); end
|
|
end
|
|
|
|
class TarInvalidError
|
|
end
|
|
|
|
class TarReader
|
|
include Enumerable
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def close; end
|
|
|
|
def each(&blk); end
|
|
|
|
def each_entry; end
|
|
|
|
def initialize(io); end
|
|
|
|
def rewind; end
|
|
|
|
def seek(name); end
|
|
|
|
def self.new(io); end
|
|
|
|
class Entry
|
|
def bytes_read; end
|
|
|
|
def check_closed; end
|
|
|
|
def close; end
|
|
|
|
def closed?; end
|
|
|
|
def directory?; end
|
|
|
|
def eof?; end
|
|
|
|
def file?; end
|
|
|
|
def full_name; end
|
|
|
|
def getc; end
|
|
|
|
def header; end
|
|
|
|
def initialize(header, io); end
|
|
|
|
def length; end
|
|
|
|
def pos; end
|
|
|
|
def read(len = T.unsafe(nil)); end
|
|
|
|
def readpartial(maxlen = T.unsafe(nil), outbuf = T.unsafe(nil)); end
|
|
|
|
def rewind; end
|
|
|
|
def size; end
|
|
|
|
def symlink?; end
|
|
end
|
|
|
|
class UnexpectedEOF
|
|
end
|
|
end
|
|
|
|
class TarWriter
|
|
def add_file(name, mode); end
|
|
|
|
def add_file_digest(name, mode, digest_algorithms); end
|
|
|
|
def add_file_signed(name, mode, signer); end
|
|
|
|
def add_file_simple(name, mode, size); end
|
|
|
|
def add_symlink(name, target, mode); end
|
|
|
|
def check_closed; end
|
|
|
|
def close; end
|
|
|
|
def closed?; end
|
|
|
|
def flush; end
|
|
|
|
def initialize(io); end
|
|
|
|
def mkdir(name, mode); end
|
|
|
|
def split_name(name); end
|
|
|
|
def self.new(io); end
|
|
|
|
class BoundedStream
|
|
def initialize(io, limit); end
|
|
|
|
def limit; end
|
|
|
|
def write(data); end
|
|
|
|
def written; end
|
|
end
|
|
|
|
class FileOverflow
|
|
end
|
|
|
|
class RestrictedStream
|
|
def initialize(io); end
|
|
|
|
def write(data); end
|
|
end
|
|
end
|
|
|
|
class TooLongFileName
|
|
end
|
|
end
|
|
|
|
class PathSupport
|
|
def home; end
|
|
|
|
def initialize(env); end
|
|
|
|
def path; end
|
|
|
|
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)
|
|
|
|
def ==(other); end
|
|
|
|
def ===(other); end
|
|
|
|
def =~(other); end
|
|
|
|
def cpu; end
|
|
|
|
def cpu=(cpu); end
|
|
|
|
def eql?(other); end
|
|
|
|
def initialize(arch); end
|
|
|
|
def os; end
|
|
|
|
def os=(os); end
|
|
|
|
def to_a; end
|
|
|
|
def version; end
|
|
|
|
def version=(version); end
|
|
|
|
def self.installable?(spec); end
|
|
|
|
def self.local; end
|
|
|
|
def self.match(platform); end
|
|
|
|
def self.new(arch); end
|
|
end
|
|
|
|
class PlatformMismatch
|
|
def add_platform(platform); end
|
|
|
|
def initialize(name, version); end
|
|
|
|
def name; end
|
|
|
|
def platforms; end
|
|
|
|
def version; end
|
|
|
|
def wordy; end
|
|
end
|
|
|
|
class RemoteFetcher
|
|
include Gem::UserInteraction
|
|
include Gem::DefaultUserInteraction
|
|
include Gem::Text
|
|
BASE64_URI_TRANSLATE = T.let(nil, T.untyped)
|
|
|
|
def cache_update_path(uri, path = T.unsafe(nil), update = T.unsafe(nil)); end
|
|
|
|
def close_all; end
|
|
|
|
def correct_for_windows_path(path); end
|
|
|
|
def download(spec, source_uri, install_dir = T.unsafe(nil)); end
|
|
|
|
def download_to_cache(dependency); end
|
|
|
|
def fetch_file(uri, *_); end
|
|
|
|
def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); 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
|
|
|
|
def fetch_s3(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end
|
|
|
|
def fetch_size(uri); end
|
|
|
|
def headers; end
|
|
|
|
def headers=(headers); end
|
|
|
|
def https?(uri); end
|
|
|
|
def initialize(proxy = T.unsafe(nil), dns = T.unsafe(nil), headers = T.unsafe(nil)); end
|
|
|
|
def request(uri, request_class, last_modified = T.unsafe(nil)); end
|
|
|
|
def s3_expiration; end
|
|
|
|
def sign_s3_url(uri, expiration = T.unsafe(nil)); end
|
|
|
|
def self.fetcher; end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
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
|
|
|
|
def cert_files; end
|
|
|
|
def connection_for(uri); end
|
|
|
|
def fetch; end
|
|
|
|
def initialize(uri, request_class, last_modified, pool); end
|
|
|
|
def perform_request(request); end
|
|
|
|
def proxy_uri; end
|
|
|
|
def reset(connection); end
|
|
|
|
def user_agent; end
|
|
|
|
def self.configure_connection_for_https(connection, cert_files); end
|
|
|
|
def self.create_with_proxy(uri, request_class, last_modified, proxy); end
|
|
|
|
def self.get_cert_files; end
|
|
|
|
def self.get_proxy_from_env(scheme = T.unsafe(nil)); end
|
|
|
|
def self.proxy_uri(proxy); end
|
|
|
|
def self.verify_certificate(store_context); end
|
|
|
|
def self.verify_certificate_message(error_number, cert); end
|
|
|
|
def self.clean_text(text); end
|
|
|
|
def self.format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def self.levenshtein_distance(str1, str2); end
|
|
|
|
def self.min3(a, b, c); end
|
|
|
|
def self.truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def self.ui; end
|
|
|
|
def self.ui=(new_ui); end
|
|
|
|
def self.use_ui(new_ui, &block); end
|
|
|
|
def self.alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def self.alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def self.alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def self.ask(question); end
|
|
|
|
def self.ask_for_password(prompt); end
|
|
|
|
def self.ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def self.choose_from_list(question, list); end
|
|
|
|
def self.say(statement = T.unsafe(nil)); end
|
|
|
|
def self.terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def self.verbose(msg = T.unsafe(nil)); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
|
|
class ConnectionPools
|
|
def close_all; end
|
|
|
|
def initialize(proxy_uri, cert_files); end
|
|
|
|
def pool_for(uri); end
|
|
|
|
def self.client; end
|
|
|
|
def self.client=(client); end
|
|
end
|
|
|
|
class HTTPPool
|
|
def cert_files; end
|
|
|
|
def checkin(connection); end
|
|
|
|
def checkout; end
|
|
|
|
def close_all; end
|
|
|
|
def initialize(http_args, cert_files, proxy_uri); end
|
|
|
|
def proxy_uri; end
|
|
end
|
|
|
|
class HTTPSPool
|
|
end
|
|
end
|
|
|
|
class RequestSet
|
|
include TSort
|
|
|
|
def always_install; end
|
|
|
|
def always_install=(always_install); end
|
|
|
|
def dependencies; end
|
|
|
|
def development; end
|
|
|
|
def development=(development); end
|
|
|
|
def development_shallow; end
|
|
|
|
def development_shallow=(development_shallow); end
|
|
|
|
def errors; end
|
|
|
|
def gem(name, *reqs); end
|
|
|
|
def git_set; end
|
|
|
|
def ignore_dependencies; end
|
|
|
|
def ignore_dependencies=(ignore_dependencies); end
|
|
|
|
def import(deps); end
|
|
|
|
def initialize(*deps); end
|
|
|
|
def install(options, &block); end
|
|
|
|
def install_dir; end
|
|
|
|
def install_from_gemdeps(options, &block); end
|
|
|
|
def install_hooks(requests, options); end
|
|
|
|
def install_into(dir, force = T.unsafe(nil), options = T.unsafe(nil)); end
|
|
|
|
def load_gemdeps(path, without_groups = T.unsafe(nil), installing = T.unsafe(nil)); end
|
|
|
|
def prerelease; end
|
|
|
|
def prerelease=(prerelease); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def remote; end
|
|
|
|
def remote=(remote); end
|
|
|
|
def resolve(set = T.unsafe(nil)); end
|
|
|
|
def resolve_current; end
|
|
|
|
def resolver; end
|
|
|
|
def sets; end
|
|
|
|
def soft_missing; end
|
|
|
|
def soft_missing=(soft_missing); end
|
|
|
|
def sorted_requests; end
|
|
|
|
def source_set; end
|
|
|
|
def specs; end
|
|
|
|
def specs_in(dir); end
|
|
|
|
def tsort_each_node(&block); end
|
|
|
|
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)
|
|
|
|
def dependencies; end
|
|
|
|
def find_gemspec(name, path); end
|
|
|
|
def gem(name, *requirements); end
|
|
|
|
def gem_deps_file; end
|
|
|
|
def gem_git_reference(options); end
|
|
|
|
def gemspec(options = T.unsafe(nil)); end
|
|
|
|
def git(repository); end
|
|
|
|
def git_set; end
|
|
|
|
def git_source(name, &callback); end
|
|
|
|
def group(*groups); end
|
|
|
|
def initialize(set, path); end
|
|
|
|
def installing=(installing); end
|
|
|
|
def load; end
|
|
|
|
def platform(*platforms); end
|
|
|
|
def platforms(*platforms); end
|
|
|
|
def requires; end
|
|
|
|
def ruby(version, options = T.unsafe(nil)); end
|
|
|
|
def source(url); end
|
|
|
|
def vendor_set; end
|
|
|
|
def without_groups; end
|
|
|
|
def without_groups=(without_groups); end
|
|
end
|
|
|
|
class Lockfile
|
|
def add_DEPENDENCIES(out); end
|
|
|
|
def add_GEM(out, spec_groups); end
|
|
|
|
def add_GIT(out, git_requests); end
|
|
|
|
def add_PATH(out, path_requests); end
|
|
|
|
def add_PLATFORMS(out); end
|
|
|
|
def initialize(request_set, gem_deps_file, dependencies); end
|
|
|
|
def platforms; end
|
|
|
|
def relative_path_from(dest, base); end
|
|
|
|
def spec_groups; end
|
|
|
|
def write; end
|
|
|
|
def self.build(request_set, gem_deps_file, dependencies = T.unsafe(nil)); end
|
|
|
|
def self.requests_to_deps(requests); end
|
|
|
|
class ParseError
|
|
def column; end
|
|
|
|
def initialize(message, column, line, path); end
|
|
|
|
def line; end
|
|
|
|
def path; end
|
|
end
|
|
|
|
class Parser
|
|
def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end
|
|
|
|
def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end
|
|
|
|
def parse; end
|
|
|
|
def parse_DEPENDENCIES; end
|
|
|
|
def parse_GEM; end
|
|
|
|
def parse_GIT; end
|
|
|
|
def parse_PATH; end
|
|
|
|
def parse_PLATFORMS; end
|
|
|
|
def parse_dependency(name, op); end
|
|
end
|
|
|
|
class Tokenizer
|
|
EOF = T.let(nil, T.untyped)
|
|
|
|
def empty?; end
|
|
|
|
def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end
|
|
|
|
def make_parser(set, platforms); end
|
|
|
|
def next_token; end
|
|
|
|
def peek; end
|
|
|
|
def shift; end
|
|
|
|
def skip(type); end
|
|
|
|
def to_a; end
|
|
|
|
def token_pos(byte_offset); end
|
|
|
|
def unshift(token); end
|
|
|
|
def self.from_file(file); end
|
|
|
|
class Token
|
|
def column; end
|
|
|
|
def column=(_); end
|
|
|
|
def line; end
|
|
|
|
def line=(_); end
|
|
|
|
def type; end
|
|
|
|
def type=(_); end
|
|
|
|
def value; end
|
|
|
|
def value=(_); end
|
|
|
|
def self.[](*_); end
|
|
|
|
def self.members; end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
class Requirement
|
|
DefaultRequirement = T.let(nil, T.untyped)
|
|
|
|
def ==(other); end
|
|
|
|
def ===(version); end
|
|
|
|
def =~(version); end
|
|
|
|
def _tilde_requirements; end
|
|
|
|
def as_list; end
|
|
|
|
def concat(new); end
|
|
|
|
def encode_with(coder); end
|
|
|
|
def exact?; end
|
|
|
|
def for_lockfile; end
|
|
|
|
def init_with(coder); end
|
|
|
|
def initialize(*requirements); end
|
|
|
|
def marshal_dump; end
|
|
|
|
def marshal_load(array); end
|
|
|
|
def none?; end
|
|
|
|
def prerelease?; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def requirements; end
|
|
|
|
def satisfied_by?(version); end
|
|
|
|
def specific?; end
|
|
|
|
def to_yaml_properties; end
|
|
|
|
def yaml_initialize(tag, vals); end
|
|
|
|
def self.create(*inputs); end
|
|
|
|
def self.default; end
|
|
|
|
def self.parse(obj); end
|
|
|
|
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)
|
|
|
|
def activation_request(dep, possible); end
|
|
|
|
def development; end
|
|
|
|
def development=(development); end
|
|
|
|
def development_shallow; end
|
|
|
|
def development_shallow=(development_shallow); end
|
|
|
|
def explain(stage, *data); end
|
|
|
|
def explain_list(stage); end
|
|
|
|
def find_possible(dependency); end
|
|
|
|
def ignore_dependencies; end
|
|
|
|
def ignore_dependencies=(ignore_dependencies); end
|
|
|
|
def initialize(needed, set = T.unsafe(nil)); end
|
|
|
|
def missing; end
|
|
|
|
def requests(s, act, reqs = T.unsafe(nil)); end
|
|
|
|
def resolve; end
|
|
|
|
def select_local_platforms(specs); end
|
|
|
|
def skip_gems; end
|
|
|
|
def skip_gems=(skip_gems); end
|
|
|
|
def soft_missing; end
|
|
|
|
def soft_missing=(soft_missing); end
|
|
|
|
def stats; end
|
|
|
|
def self.compose_sets(*sets); end
|
|
|
|
def self.for_current_gems(needed); end
|
|
|
|
def allow_missing?(dependency); end
|
|
|
|
def dependencies_for(specification); end
|
|
|
|
def name_for(dependency); end
|
|
|
|
def name_for_explicit_dependency_source; end
|
|
|
|
def name_for_locking_dependency_source; end
|
|
|
|
def requirement_satisfied_by?(requirement, activated, spec); end
|
|
|
|
def search_for(dependency); end
|
|
|
|
def sort_dependencies(dependencies, activated, conflicts); end
|
|
|
|
def after_resolution; end
|
|
|
|
def before_resolution; end
|
|
|
|
def debug(depth = T.unsafe(nil)); end
|
|
|
|
def debug?; end
|
|
|
|
def indicate_progress; end
|
|
|
|
def output; end
|
|
|
|
def progress_rate; end
|
|
|
|
class APISet
|
|
def dep_uri; end
|
|
|
|
def initialize(dep_uri = T.unsafe(nil)); end
|
|
|
|
def prefetch_now; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def source; end
|
|
|
|
def uri; end
|
|
|
|
def versions(name); end
|
|
end
|
|
|
|
class APISpecification
|
|
def ==(other); end
|
|
|
|
def initialize(set, api_data); end
|
|
|
|
def pretty_print(q); end
|
|
end
|
|
|
|
class ActivationRequest
|
|
def ==(other); end
|
|
|
|
def development?; end
|
|
|
|
def download(path); end
|
|
|
|
def full_name; end
|
|
|
|
def full_spec; end
|
|
|
|
def initialize(spec, request, others_possible = T.unsafe(nil)); end
|
|
|
|
def installed?; end
|
|
|
|
def name; end
|
|
|
|
def others_possible?; end
|
|
|
|
def parent; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def request; end
|
|
|
|
def spec; end
|
|
|
|
def version; end
|
|
end
|
|
|
|
class BestSet
|
|
def initialize(sources = T.unsafe(nil)); end
|
|
|
|
def pick_sets; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def replace_failed_api_set(error); end
|
|
end
|
|
|
|
class ComposedSet
|
|
def initialize(*sets); end
|
|
|
|
def prerelease=(allow_prerelease); end
|
|
|
|
def remote=(remote); end
|
|
|
|
def sets; end
|
|
end
|
|
|
|
class Conflict
|
|
def ==(other); end
|
|
|
|
def activated; end
|
|
|
|
def conflicting_dependencies; end
|
|
|
|
def dependency; end
|
|
|
|
def explain; end
|
|
|
|
def explanation; end
|
|
|
|
def failed_dep; end
|
|
|
|
def for_spec?(spec); end
|
|
|
|
def initialize(dependency, activated, failed_dep = T.unsafe(nil)); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def request_path(current); end
|
|
|
|
def requester; end
|
|
end
|
|
|
|
class CurrentSet
|
|
end
|
|
|
|
class DependencyRequest
|
|
def ==(other); end
|
|
|
|
def dependency; end
|
|
|
|
def development?; end
|
|
|
|
def explicit?; end
|
|
|
|
def implicit?; end
|
|
|
|
def initialize(dependency, requester); end
|
|
|
|
def match?(spec, allow_prerelease = T.unsafe(nil)); end
|
|
|
|
def matches_spec?(spec); end
|
|
|
|
def name; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def request_context; end
|
|
|
|
def requester; end
|
|
|
|
def requirement; end
|
|
|
|
def type; end
|
|
end
|
|
|
|
class GitSet
|
|
def add_git_gem(name, repository, reference, submodules); end
|
|
|
|
def add_git_spec(name, version, repository, reference, submodules); end
|
|
|
|
def need_submodules; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def repositories; end
|
|
|
|
def root_dir; end
|
|
|
|
def root_dir=(root_dir); end
|
|
|
|
def specs; end
|
|
end
|
|
|
|
class GitSpecification
|
|
def ==(other); end
|
|
|
|
def add_dependency(dependency); end
|
|
|
|
def pretty_print(q); end
|
|
end
|
|
|
|
class IndexSet
|
|
def initialize(source = T.unsafe(nil)); end
|
|
|
|
def pretty_print(q); end
|
|
end
|
|
|
|
class IndexSpecification
|
|
def initialize(set, name, version, source, platform); end
|
|
|
|
def pretty_print(q); end
|
|
end
|
|
|
|
class InstalledSpecification
|
|
def ==(other); end
|
|
|
|
def pretty_print(q); end
|
|
end
|
|
|
|
class InstallerSet
|
|
def add_always_install(dependency); end
|
|
|
|
def add_local(dep_name, spec, source); end
|
|
|
|
def always_install; end
|
|
|
|
def consider_local?; end
|
|
|
|
def consider_remote?; end
|
|
|
|
def ignore_dependencies; end
|
|
|
|
def ignore_dependencies=(ignore_dependencies); end
|
|
|
|
def ignore_installed; end
|
|
|
|
def ignore_installed=(ignore_installed); end
|
|
|
|
def initialize(domain); end
|
|
|
|
def load_spec(name, ver, platform, source); end
|
|
|
|
def local?(dep_name); end
|
|
|
|
def prerelease=(allow_prerelease); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def remote=(remote); end
|
|
|
|
def remote_set; end
|
|
end
|
|
|
|
class LocalSpecification
|
|
def pretty_print(q); end
|
|
end
|
|
|
|
class LockSet
|
|
def add(name, version, platform); end
|
|
|
|
def initialize(sources); end
|
|
|
|
def load_spec(name, version, platform, source); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def specs; end
|
|
end
|
|
|
|
class LockSpecification
|
|
def add_dependency(dependency); end
|
|
|
|
def initialize(set, name, version, sources, platform); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def sources; end
|
|
end
|
|
|
|
module Molinillo
|
|
VERSION = T.let(nil, T.untyped)
|
|
|
|
class CircularDependencyError
|
|
def dependencies; end
|
|
|
|
def initialize(nodes); end
|
|
end
|
|
|
|
module Delegates
|
|
module ResolutionState
|
|
def activated; end
|
|
|
|
def conflicts; end
|
|
|
|
def depth; end
|
|
|
|
def name; end
|
|
|
|
def possibilities; end
|
|
|
|
def requirement; end
|
|
|
|
def requirements; end
|
|
end
|
|
|
|
module SpecificationProvider
|
|
def allow_missing?(dependency); end
|
|
|
|
def dependencies_for(specification); end
|
|
|
|
def name_for(dependency); end
|
|
|
|
def name_for_explicit_dependency_source; end
|
|
|
|
def name_for_locking_dependency_source; end
|
|
|
|
def requirement_satisfied_by?(requirement, activated, spec); end
|
|
|
|
def search_for(dependency); end
|
|
|
|
def sort_dependencies(dependencies, activated, conflicts); end
|
|
end
|
|
end
|
|
|
|
class DependencyGraph
|
|
include Enumerable
|
|
include TSort
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def ==(other); end
|
|
|
|
def add_child_vertex(name, payload, parent_names, requirement); end
|
|
|
|
def add_edge(origin, destination, requirement); end
|
|
|
|
def add_vertex(name, payload, root = T.unsafe(nil)); end
|
|
|
|
def delete_edge(edge); end
|
|
|
|
def detach_vertex_named(name); end
|
|
|
|
def each(&blk); end
|
|
|
|
def log; end
|
|
|
|
def rewind_to(tag); end
|
|
|
|
def root_vertex_named(name); end
|
|
|
|
def set_payload(name, payload); end
|
|
|
|
def tag(tag); end
|
|
|
|
def to_dot(options = T.unsafe(nil)); end
|
|
|
|
def tsort_each_child(vertex, &block); end
|
|
|
|
def vertex_named(name); end
|
|
|
|
def vertices; end
|
|
|
|
def self.tsort(vertices); end
|
|
|
|
class Action
|
|
def down(graph); end
|
|
|
|
def next; end
|
|
|
|
def next=(_); end
|
|
|
|
def previous; end
|
|
|
|
def previous=(previous); end
|
|
|
|
def up(graph); end
|
|
|
|
def self.action_name; end
|
|
end
|
|
|
|
class AddEdgeNoCircular
|
|
def destination; end
|
|
|
|
def initialize(origin, destination, requirement); end
|
|
|
|
def make_edge(graph); end
|
|
|
|
def origin; end
|
|
|
|
def requirement; end
|
|
end
|
|
|
|
class AddVertex
|
|
def initialize(name, payload, root); end
|
|
|
|
def name; end
|
|
|
|
def payload; end
|
|
|
|
def root; end
|
|
end
|
|
|
|
class DeleteEdge
|
|
def destination_name; end
|
|
|
|
def initialize(origin_name, destination_name, requirement); end
|
|
|
|
def make_edge(graph); end
|
|
|
|
def origin_name; end
|
|
|
|
def requirement; end
|
|
end
|
|
|
|
class DetachVertexNamed
|
|
def initialize(name); end
|
|
|
|
def name; end
|
|
end
|
|
|
|
class Edge
|
|
def destination; end
|
|
|
|
def destination=(_); end
|
|
|
|
def origin; end
|
|
|
|
def origin=(_); end
|
|
|
|
def requirement; end
|
|
|
|
def requirement=(_); end
|
|
|
|
def self.[](*_); end
|
|
|
|
def self.members; end
|
|
end
|
|
|
|
class Log
|
|
extend T::Enumerable
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def add_edge_no_circular(graph, origin, destination, requirement); end
|
|
|
|
def add_vertex(graph, name, payload, root); end
|
|
|
|
def delete_edge(graph, origin_name, destination_name, requirement); end
|
|
|
|
def detach_vertex_named(graph, name); end
|
|
|
|
def each(&blk); end
|
|
|
|
def pop!(graph); end
|
|
|
|
def reverse_each; end
|
|
|
|
def rewind_to(graph, tag); end
|
|
|
|
def set_payload(graph, name, payload); end
|
|
|
|
def tag(graph, tag); end
|
|
end
|
|
|
|
class SetPayload
|
|
def initialize(name, payload); end
|
|
|
|
def name; end
|
|
|
|
def payload; end
|
|
end
|
|
|
|
class Tag
|
|
def down(_graph); end
|
|
|
|
def initialize(tag); end
|
|
|
|
def tag; end
|
|
|
|
def up(_graph); end
|
|
end
|
|
|
|
class Vertex
|
|
def ==(other); end
|
|
|
|
def ancestor?(other); end
|
|
|
|
def descendent?(other); end
|
|
|
|
def eql?(other); end
|
|
|
|
def explicit_requirements; end
|
|
|
|
def incoming_edges; end
|
|
|
|
def incoming_edges=(incoming_edges); end
|
|
|
|
def initialize(name, payload); end
|
|
|
|
def is_reachable_from?(other); end
|
|
|
|
def name; end
|
|
|
|
def name=(name); end
|
|
|
|
def outgoing_edges; end
|
|
|
|
def outgoing_edges=(outgoing_edges); end
|
|
|
|
def path_to?(other); end
|
|
|
|
def payload; end
|
|
|
|
def payload=(payload); end
|
|
|
|
def predecessors; end
|
|
|
|
def recursive_predecessors; end
|
|
|
|
def recursive_successors; end
|
|
|
|
def requirements; end
|
|
|
|
def root; end
|
|
|
|
def root=(root); end
|
|
|
|
def root?; end
|
|
|
|
def shallow_eql?(other); end
|
|
|
|
def successors; end
|
|
end
|
|
end
|
|
|
|
class DependencyState
|
|
def pop_possibility_state; end
|
|
end
|
|
|
|
class NoSuchDependencyError
|
|
def dependency; end
|
|
|
|
def dependency=(dependency); end
|
|
|
|
def initialize(dependency, required_by = T.unsafe(nil)); end
|
|
|
|
def required_by; end
|
|
|
|
def required_by=(required_by); end
|
|
end
|
|
|
|
class PossibilityState
|
|
end
|
|
|
|
class ResolutionState
|
|
def activated; end
|
|
|
|
def activated=(_); end
|
|
|
|
def conflicts; end
|
|
|
|
def conflicts=(_); end
|
|
|
|
def depth; end
|
|
|
|
def depth=(_); end
|
|
|
|
def name; end
|
|
|
|
def name=(_); end
|
|
|
|
def possibilities; end
|
|
|
|
def possibilities=(_); end
|
|
|
|
def requirement; end
|
|
|
|
def requirement=(_); end
|
|
|
|
def requirements; end
|
|
|
|
def requirements=(_); end
|
|
|
|
def self.[](*_); end
|
|
|
|
def self.empty; end
|
|
|
|
def self.members; end
|
|
end
|
|
|
|
class Resolver
|
|
def initialize(specification_provider, resolver_ui); end
|
|
|
|
def resolve(requested, base = T.unsafe(nil)); end
|
|
|
|
def resolver_ui; end
|
|
|
|
def specification_provider; end
|
|
|
|
class Resolution
|
|
include Gem::Resolver::Molinillo::Delegates::ResolutionState
|
|
include Gem::Resolver::Molinillo::Delegates::SpecificationProvider
|
|
|
|
def base; end
|
|
|
|
def initialize(specification_provider, resolver_ui, requested, base); end
|
|
|
|
def iteration_rate=(iteration_rate); end
|
|
|
|
def original_requested; end
|
|
|
|
def resolve; end
|
|
|
|
def resolver_ui; end
|
|
|
|
def specification_provider; end
|
|
|
|
def started_at=(started_at); end
|
|
|
|
def states=(states); end
|
|
|
|
def allow_missing?(dependency); end
|
|
|
|
def dependencies_for(specification); end
|
|
|
|
def name_for(dependency); end
|
|
|
|
def name_for_explicit_dependency_source; end
|
|
|
|
def name_for_locking_dependency_source; end
|
|
|
|
def requirement_satisfied_by?(requirement, activated, spec); end
|
|
|
|
def search_for(dependency); end
|
|
|
|
def sort_dependencies(dependencies, activated, conflicts); end
|
|
|
|
def activated; end
|
|
|
|
def conflicts; end
|
|
|
|
def depth; end
|
|
|
|
def name; end
|
|
|
|
def possibilities; end
|
|
|
|
def requirement; end
|
|
|
|
def requirements; end
|
|
|
|
class Conflict
|
|
def activated_by_name; end
|
|
|
|
def activated_by_name=(_); end
|
|
|
|
def existing; end
|
|
|
|
def existing=(_); end
|
|
|
|
def locked_requirement; end
|
|
|
|
def locked_requirement=(_); end
|
|
|
|
def possibility; end
|
|
|
|
def possibility=(_); end
|
|
|
|
def requirement; end
|
|
|
|
def requirement=(_); end
|
|
|
|
def requirement_trees; end
|
|
|
|
def requirement_trees=(_); end
|
|
|
|
def requirements; end
|
|
|
|
def requirements=(_); end
|
|
|
|
def self.[](*_); end
|
|
|
|
def self.members; end
|
|
end
|
|
end
|
|
end
|
|
|
|
class ResolverError
|
|
end
|
|
|
|
module SpecificationProvider
|
|
def allow_missing?(dependency); end
|
|
|
|
def dependencies_for(specification); end
|
|
|
|
def name_for(dependency); end
|
|
|
|
def name_for_explicit_dependency_source; end
|
|
|
|
def name_for_locking_dependency_source; end
|
|
|
|
def requirement_satisfied_by?(requirement, activated, spec); end
|
|
|
|
def search_for(dependency); end
|
|
|
|
def sort_dependencies(dependencies, activated, conflicts); end
|
|
end
|
|
|
|
module UI
|
|
def after_resolution; end
|
|
|
|
def before_resolution; end
|
|
|
|
def debug(depth = T.unsafe(nil)); end
|
|
|
|
def debug?; end
|
|
|
|
def indicate_progress; end
|
|
|
|
def output; end
|
|
|
|
def progress_rate; end
|
|
end
|
|
|
|
class VersionConflict
|
|
def conflicts; end
|
|
|
|
def initialize(conflicts); end
|
|
end
|
|
end
|
|
|
|
class RequirementList
|
|
include Enumerable
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def add(req); end
|
|
|
|
def each(&blk); end
|
|
|
|
def empty?; end
|
|
|
|
def next5; end
|
|
|
|
def remove; end
|
|
|
|
def size; end
|
|
end
|
|
|
|
class Set
|
|
def errors; end
|
|
|
|
def errors=(errors); end
|
|
|
|
def find_all(req); end
|
|
|
|
def prefetch(reqs); end
|
|
|
|
def prerelease; end
|
|
|
|
def prerelease=(prerelease); end
|
|
|
|
def remote; end
|
|
|
|
def remote=(remote); end
|
|
|
|
def remote?; end
|
|
end
|
|
|
|
class SourceSet
|
|
def add_source_gem(name, source); end
|
|
end
|
|
|
|
class SpecSpecification
|
|
def initialize(set, spec, source = T.unsafe(nil)); end
|
|
end
|
|
|
|
class Specification
|
|
def dependencies; end
|
|
|
|
def download(options); end
|
|
|
|
def fetch_development_dependencies; end
|
|
|
|
def full_name; end
|
|
|
|
def install(options = T.unsafe(nil)); end
|
|
|
|
def installable_platform?; end
|
|
|
|
def local?; end
|
|
|
|
def name; end
|
|
|
|
def platform; end
|
|
|
|
def set; end
|
|
|
|
def source; end
|
|
|
|
def spec; end
|
|
|
|
def version; end
|
|
end
|
|
|
|
class Stats
|
|
PATTERN = T.let(nil, T.untyped)
|
|
|
|
def backtracking!; end
|
|
|
|
def display; end
|
|
|
|
def iteration!; end
|
|
|
|
def record_depth(stack); end
|
|
|
|
def record_requirements(reqs); end
|
|
|
|
def requirement!; end
|
|
end
|
|
|
|
class VendorSet
|
|
def add_vendor_gem(name, directory); end
|
|
|
|
def load_spec(name, version, platform, source); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def specs; end
|
|
end
|
|
|
|
class VendorSpecification
|
|
def ==(other); end
|
|
end
|
|
end
|
|
|
|
class RuntimeRequirementNotMetError
|
|
def suggestion; end
|
|
|
|
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)
|
|
|
|
def self.alt_name_or_x509_entry(certificate, x509_entry); end
|
|
|
|
def self.create_cert(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
|
|
|
|
def self.create_cert_email(email, key, age = T.unsafe(nil), extensions = T.unsafe(nil)); 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
|
|
|
|
def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end
|
|
|
|
def self.reset; 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
|
|
|
|
def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end
|
|
|
|
class DIGEST_ALGORITHM
|
|
def initialize(data = T.unsafe(nil)); end
|
|
|
|
def self.digest(data); end
|
|
|
|
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)
|
|
|
|
def d; end
|
|
|
|
def d=(d); end
|
|
|
|
def dmp1; end
|
|
|
|
def dmp1=(dmp1); end
|
|
|
|
def dmq1; end
|
|
|
|
def dmq1=(dmq1); end
|
|
|
|
def e; end
|
|
|
|
def e=(e); end
|
|
|
|
def export(*_); end
|
|
|
|
def initialize(*_); end
|
|
|
|
def iqmp; end
|
|
|
|
def iqmp=(iqmp); end
|
|
|
|
def n; end
|
|
|
|
def n=(n); end
|
|
|
|
def p; end
|
|
|
|
def p=(p); end
|
|
|
|
def params; end
|
|
|
|
def private?; end
|
|
|
|
def private_decrypt(*_); end
|
|
|
|
def private_encrypt(*_); end
|
|
|
|
def public?; end
|
|
|
|
def public_decrypt(*_); end
|
|
|
|
def public_encrypt(*_); end
|
|
|
|
def public_key; end
|
|
|
|
def q; end
|
|
|
|
def q=(q); end
|
|
|
|
def set_crt_params(_, _1, _2); end
|
|
|
|
def set_factors(_, _1); end
|
|
|
|
def set_key(_, _1, _2); end
|
|
|
|
def sign_pss(*_); end
|
|
|
|
def to_der; end
|
|
|
|
def to_pem(*_); end
|
|
|
|
def to_s(*_); end
|
|
|
|
def to_text; end
|
|
|
|
def verify_pss(*_); end
|
|
|
|
def self.generate(*_); end
|
|
end
|
|
|
|
class Policy
|
|
include Gem::UserInteraction
|
|
include Gem::DefaultUserInteraction
|
|
include Gem::Text
|
|
|
|
def check_cert(signer, issuer, time); end
|
|
|
|
def check_chain(chain, time); end
|
|
|
|
def check_data(public_key, digest, signature, data); end
|
|
|
|
def check_key(signer, key); end
|
|
|
|
def check_root(chain, time); end
|
|
|
|
def check_trust(chain, digester, trust_dir); end
|
|
|
|
def initialize(name, policy = T.unsafe(nil), opt = T.unsafe(nil)); end
|
|
|
|
def name; end
|
|
|
|
def only_signed; end
|
|
|
|
def only_signed=(only_signed); end
|
|
|
|
def only_trusted; end
|
|
|
|
def only_trusted=(only_trusted); end
|
|
|
|
def subject(certificate); 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
|
|
|
|
def verify_chain=(verify_chain); end
|
|
|
|
def verify_data; end
|
|
|
|
def verify_data=(verify_data); end
|
|
|
|
def verify_root; end
|
|
|
|
def verify_root=(verify_root); end
|
|
|
|
def verify_signatures(spec, digests, signatures); end
|
|
|
|
def verify_signer; end
|
|
|
|
def verify_signer=(verify_signer); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
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)
|
|
|
|
def cert_chain; end
|
|
|
|
def cert_chain=(cert_chain); end
|
|
|
|
def digest_algorithm; end
|
|
|
|
def digest_name; end
|
|
|
|
def extract_name(cert); end
|
|
|
|
def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end
|
|
|
|
def key; end
|
|
|
|
def key=(key); end
|
|
|
|
def load_cert_chain; end
|
|
|
|
def options; end
|
|
|
|
def re_sign_key(expiration_length: T.unsafe(nil)); end
|
|
|
|
def sign(data); end
|
|
|
|
def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
end
|
|
|
|
class TrustDir
|
|
DEFAULT_PERMISSIONS = T.let(nil, T.untyped)
|
|
|
|
def cert_path(certificate); end
|
|
|
|
def dir; end
|
|
|
|
def each_certificate; end
|
|
|
|
def initialize(dir, permissions = T.unsafe(nil)); end
|
|
|
|
def issuer_of(certificate); end
|
|
|
|
def load_certificate(certificate_file); end
|
|
|
|
def name_path(name); end
|
|
|
|
def trust_cert(certificate); end
|
|
|
|
def verify; end
|
|
end
|
|
end
|
|
|
|
class SilentUI
|
|
def initialize; end
|
|
end
|
|
|
|
class Source
|
|
include Comparable
|
|
FILES = T.let(nil, T.untyped)
|
|
|
|
def ==(other); end
|
|
|
|
def cache_dir(uri); end
|
|
|
|
def dependency_resolver_set; end
|
|
|
|
def download(spec, dir = T.unsafe(nil)); end
|
|
|
|
def eql?(other); end
|
|
|
|
def fetch_spec(name_tuple); end
|
|
|
|
def initialize(uri); end
|
|
|
|
def load_specs(type); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def update_cache?; end
|
|
|
|
def uri; end
|
|
|
|
class Git
|
|
def base_dir; end
|
|
|
|
def cache; end
|
|
|
|
def checkout; end
|
|
|
|
def dir_shortref; end
|
|
|
|
def download(full_spec, path); end
|
|
|
|
def initialize(name, repository, reference, submodules = T.unsafe(nil)); end
|
|
|
|
def install_dir; end
|
|
|
|
def name; end
|
|
|
|
def need_submodules; end
|
|
|
|
def reference; end
|
|
|
|
def remote; end
|
|
|
|
def remote=(remote); end
|
|
|
|
def repo_cache_dir; end
|
|
|
|
def repository; end
|
|
|
|
def rev_parse; end
|
|
|
|
def root_dir; end
|
|
|
|
def root_dir=(root_dir); end
|
|
|
|
def specs; end
|
|
|
|
def uri_hash; end
|
|
end
|
|
|
|
class Installed
|
|
def download(spec, path); end
|
|
|
|
def initialize; end
|
|
end
|
|
|
|
class Local
|
|
def download(spec, cache_dir = T.unsafe(nil)); end
|
|
|
|
def fetch_spec(name); end
|
|
|
|
def find_gem(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end
|
|
|
|
def initialize; end
|
|
end
|
|
|
|
class Lock
|
|
def initialize(source); end
|
|
|
|
def wrapped; end
|
|
end
|
|
|
|
class SpecificFile
|
|
def fetch_spec(name); end
|
|
|
|
def initialize(file); end
|
|
|
|
def load_specs(*a); end
|
|
|
|
def path; end
|
|
|
|
def spec; end
|
|
end
|
|
|
|
class Vendor
|
|
def initialize(path); end
|
|
end
|
|
end
|
|
|
|
class SourceFetchProblem
|
|
def error; end
|
|
|
|
def exception; end
|
|
|
|
def initialize(source, error); end
|
|
|
|
def source; end
|
|
|
|
def wordy; end
|
|
end
|
|
|
|
class SourceList
|
|
include Enumerable
|
|
Elem = type_member(fixed: T.untyped)
|
|
|
|
def <<(obj); end
|
|
|
|
def ==(other); end
|
|
|
|
def clear; end
|
|
|
|
def delete(source); end
|
|
|
|
def each(&blk); end
|
|
|
|
def each_source(&b); end
|
|
|
|
def empty?; end
|
|
|
|
def first; end
|
|
|
|
def include?(other); end
|
|
|
|
def replace(other); end
|
|
|
|
def sources; end
|
|
|
|
def to_a; end
|
|
|
|
def to_ary; end
|
|
|
|
def self.from(ary); end
|
|
end
|
|
|
|
class SpecFetcher
|
|
include Gem::UserInteraction
|
|
include Gem::DefaultUserInteraction
|
|
include Gem::Text
|
|
|
|
def available_specs(type); end
|
|
|
|
def detect(type = T.unsafe(nil)); end
|
|
|
|
def initialize(sources = T.unsafe(nil)); end
|
|
|
|
def latest_specs; end
|
|
|
|
def prerelease_specs; end
|
|
|
|
def search_for_dependency(dependency, matching_platform = T.unsafe(nil)); end
|
|
|
|
def sources; end
|
|
|
|
def spec_for_dependency(dependency, matching_platform = T.unsafe(nil)); end
|
|
|
|
def specs; end
|
|
|
|
def suggest_gems_from_name(gem_name, type = T.unsafe(nil)); end
|
|
|
|
def tuples_for(source, type, gracefully_ignore = T.unsafe(nil)); end
|
|
|
|
def self.fetcher; end
|
|
|
|
def self.fetcher=(fetcher); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
end
|
|
|
|
class SpecificGemNotFoundException
|
|
def errors; end
|
|
|
|
def initialize(name, version, errors = T.unsafe(nil)); end
|
|
|
|
def name; end
|
|
|
|
def version; end
|
|
end
|
|
|
|
class Specification
|
|
include Bundler::MatchPlatform
|
|
include Bundler::GemHelpers
|
|
extend Gem::Deprecate
|
|
DateLike = T.let(nil, T.untyped)
|
|
DateTimeFormat = T.let(nil, T.untyped)
|
|
INITIALIZE_CODE_FOR_DEFAULTS = T.let(nil, T.untyped)
|
|
|
|
def ==(other); end
|
|
|
|
def _deprecated_default_executable; end
|
|
|
|
def _deprecated_default_executable=(_deprecated_default_executable); end
|
|
|
|
def _deprecated_has_rdoc; end
|
|
|
|
def _deprecated_has_rdoc=(ignored); end
|
|
|
|
def _deprecated_has_rdoc?(*args, &block); end
|
|
|
|
def _dump(limit); end
|
|
|
|
def abbreviate; end
|
|
|
|
def activate; end
|
|
|
|
def activate_dependencies; end
|
|
|
|
def activated; end
|
|
|
|
def activated=(activated); end
|
|
|
|
def add_bindir(executables); end
|
|
|
|
def add_dependency(gem, *requirements); end
|
|
|
|
def add_development_dependency(gem, *requirements); end
|
|
|
|
def add_runtime_dependency(gem, *requirements); end
|
|
|
|
def add_self_to_load_path; end
|
|
|
|
def author; end
|
|
|
|
def author=(o); end
|
|
|
|
def authors; end
|
|
|
|
def authors=(value); end
|
|
|
|
def autorequire; end
|
|
|
|
def autorequire=(autorequire); end
|
|
|
|
def bin_dir; end
|
|
|
|
def bin_file(name); end
|
|
|
|
def bindir; end
|
|
|
|
def bindir=(bindir); end
|
|
|
|
def build_args; end
|
|
|
|
def build_extensions; end
|
|
|
|
def build_info_dir; end
|
|
|
|
def build_info_file; end
|
|
|
|
def cache_dir; end
|
|
|
|
def cache_file; end
|
|
|
|
def cert_chain; end
|
|
|
|
def cert_chain=(cert_chain); end
|
|
|
|
def conficts_when_loaded_with?(list_of_specs); end
|
|
|
|
def conflicts; end
|
|
|
|
def date; end
|
|
|
|
def date=(date); end
|
|
|
|
def default_executable(*args, &block); end
|
|
|
|
def default_executable=(*args, &block); end
|
|
|
|
def default_value(name); end
|
|
|
|
def dependencies; end
|
|
|
|
def dependent_gems; end
|
|
|
|
def dependent_specs; end
|
|
|
|
def description; end
|
|
|
|
def description=(str); end
|
|
|
|
def development_dependencies; end
|
|
|
|
def doc_dir(type = T.unsafe(nil)); end
|
|
|
|
def email; end
|
|
|
|
def email=(email); end
|
|
|
|
def encode_with(coder); end
|
|
|
|
def eql?(other); end
|
|
|
|
def executable; end
|
|
|
|
def executable=(o); end
|
|
|
|
def executables; end
|
|
|
|
def executables=(value); end
|
|
|
|
def extensions; end
|
|
|
|
def extensions=(extensions); end
|
|
|
|
def extra_rdoc_files; end
|
|
|
|
def extra_rdoc_files=(files); end
|
|
|
|
def file_name; end
|
|
|
|
def files; end
|
|
|
|
def files=(files); end
|
|
|
|
def for_cache; end
|
|
|
|
def git_version; end
|
|
|
|
def groups; end
|
|
|
|
def has_conflicts?; end
|
|
|
|
def has_rdoc(*args, &block); end
|
|
|
|
def has_rdoc=(*args, &block); end
|
|
|
|
def has_rdoc?(*args, &block); end
|
|
|
|
def has_test_suite?; end
|
|
|
|
def has_unit_tests?; end
|
|
|
|
def homepage; end
|
|
|
|
def homepage=(homepage); end
|
|
|
|
def init_with(coder); end
|
|
|
|
def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end
|
|
|
|
def installed_by_version; end
|
|
|
|
def installed_by_version=(version); end
|
|
|
|
def keep_only_files_and_directories; end
|
|
|
|
def lib_files; end
|
|
|
|
def license; end
|
|
|
|
def license=(o); end
|
|
|
|
def licenses; end
|
|
|
|
def licenses=(licenses); end
|
|
|
|
def load_paths; end
|
|
|
|
def location; end
|
|
|
|
def location=(location); end
|
|
|
|
def mark_version; end
|
|
|
|
def metadata; end
|
|
|
|
def metadata=(metadata); end
|
|
|
|
def method_missing(sym, *a, &b); end
|
|
|
|
def missing_extensions?; end
|
|
|
|
def name=(name); end
|
|
|
|
def name_tuple; end
|
|
|
|
def nondevelopment_dependencies; end
|
|
|
|
def normalize; end
|
|
|
|
def original_name; end
|
|
|
|
def original_platform; end
|
|
|
|
def original_platform=(original_platform); end
|
|
|
|
def platform=(platform); end
|
|
|
|
def post_install_message; end
|
|
|
|
def post_install_message=(post_install_message); end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def raise_if_conflicts; end
|
|
|
|
def rdoc_options; end
|
|
|
|
def rdoc_options=(options); end
|
|
|
|
def relative_loaded_from; end
|
|
|
|
def relative_loaded_from=(relative_loaded_from); end
|
|
|
|
def remote; end
|
|
|
|
def remote=(remote); end
|
|
|
|
def require_path; end
|
|
|
|
def require_path=(path); end
|
|
|
|
def require_paths=(val); end
|
|
|
|
def required_ruby_version; end
|
|
|
|
def required_ruby_version=(req); end
|
|
|
|
def required_rubygems_version; end
|
|
|
|
def required_rubygems_version=(req); end
|
|
|
|
def requirements; end
|
|
|
|
def requirements=(req); end
|
|
|
|
def reset_nil_attributes_to_default; end
|
|
|
|
def rg_extension_dir; end
|
|
|
|
def rg_full_gem_path; end
|
|
|
|
def rg_loaded_from; end
|
|
|
|
def ri_dir; end
|
|
|
|
def rubyforge_project=(rubyforge_project); end
|
|
|
|
def rubygems_version; end
|
|
|
|
def rubygems_version=(rubygems_version); end
|
|
|
|
def runtime_dependencies; end
|
|
|
|
def sanitize; end
|
|
|
|
def sanitize_string(string); end
|
|
|
|
def satisfies_requirement?(dependency); end
|
|
|
|
def signing_key; end
|
|
|
|
def signing_key=(signing_key); end
|
|
|
|
def sort_obj; end
|
|
|
|
def source; end
|
|
|
|
def source=(source); end
|
|
|
|
def spec_dir; end
|
|
|
|
def spec_file; end
|
|
|
|
def spec_name; end
|
|
|
|
def specification_version; end
|
|
|
|
def specification_version=(specification_version); end
|
|
|
|
def summary; end
|
|
|
|
def summary=(str); end
|
|
|
|
def test_file; end
|
|
|
|
def test_file=(file); end
|
|
|
|
def test_files; end
|
|
|
|
def test_files=(files); end
|
|
|
|
def to_gemfile(path = T.unsafe(nil)); end
|
|
|
|
def to_ruby; end
|
|
|
|
def to_ruby_for_cache; end
|
|
|
|
def to_yaml(opts = T.unsafe(nil)); end
|
|
|
|
def traverse(trail = T.unsafe(nil), visited = T.unsafe(nil), &block); end
|
|
|
|
def validate(packaging = T.unsafe(nil), strict = T.unsafe(nil)); end
|
|
|
|
def validate_dependencies; end
|
|
|
|
def validate_metadata; end
|
|
|
|
def validate_permissions; end
|
|
|
|
def version=(version); end
|
|
|
|
def yaml_initialize(tag, vals); end
|
|
|
|
def self._all; end
|
|
|
|
def self._clear_load_cache; end
|
|
|
|
def self._latest_specs(specs, prerelease = T.unsafe(nil)); end
|
|
|
|
def self._load(str); end
|
|
|
|
def self._resort!(specs); end
|
|
|
|
def self.add_spec(spec); end
|
|
|
|
def self.add_specs(*specs); end
|
|
|
|
def self.all; end
|
|
|
|
def self.all=(specs); end
|
|
|
|
def self.all_names; end
|
|
|
|
def self.array_attributes; end
|
|
|
|
def self.attribute_names; end
|
|
|
|
def self.dirs; end
|
|
|
|
def self.dirs=(dirs); end
|
|
|
|
def self.each(&blk); end
|
|
|
|
def self.each_gemspec(dirs); end
|
|
|
|
def self.each_spec(dirs); end
|
|
|
|
def self.find_active_stub_by_path(path); end
|
|
|
|
def self.find_all_by_full_name(full_name); end
|
|
|
|
def self.find_all_by_name(name, *requirements); end
|
|
|
|
def self.find_by_name(name, *requirements); end
|
|
|
|
def self.find_by_path(path); end
|
|
|
|
def self.find_in_unresolved(path); end
|
|
|
|
def self.find_in_unresolved_tree(path); end
|
|
|
|
def self.find_inactive_by_path(path); end
|
|
|
|
def self.from_yaml(input); end
|
|
|
|
def self.latest_specs(prerelease = T.unsafe(nil)); end
|
|
|
|
def self.load(file); end
|
|
|
|
def self.load_defaults; end
|
|
|
|
def self.non_nil_attributes; end
|
|
|
|
def self.normalize_yaml_input(input); end
|
|
|
|
def self.outdated; end
|
|
|
|
def self.outdated_and_latest_version; end
|
|
|
|
def self.remove_spec(spec); end
|
|
|
|
def self.required_attribute?(name); end
|
|
|
|
def self.required_attributes; end
|
|
|
|
def self.reset; end
|
|
|
|
def self.stubs; end
|
|
|
|
def self.stubs_for(name); end
|
|
|
|
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)
|
|
|
|
def initialize(specification); end
|
|
|
|
def packaging; end
|
|
|
|
def packaging=(packaging); end
|
|
|
|
def validate(strict = T.unsafe(nil)); end
|
|
|
|
def validate_dependencies; end
|
|
|
|
def validate_metadata; end
|
|
|
|
def validate_permissions; end
|
|
end
|
|
|
|
class StreamUI
|
|
extend Gem::Deprecate
|
|
|
|
def _deprecated_debug(statement); end
|
|
|
|
def _gets_noecho; end
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(question); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def backtrace(exception); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def close; end
|
|
|
|
def debug(*args, &block); end
|
|
|
|
def download_reporter(*args); end
|
|
|
|
def errs; end
|
|
|
|
def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end
|
|
|
|
def ins; end
|
|
|
|
def outs; end
|
|
|
|
def progress_reporter(*args); end
|
|
|
|
def require_io_console; end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(status = T.unsafe(nil)); end
|
|
|
|
def tty?; end
|
|
end
|
|
|
|
class StubSpecification
|
|
def build_extensions; end
|
|
|
|
def extensions; end
|
|
|
|
def initialize(filename, base_dir, gems_dir, default_gem); end
|
|
|
|
def missing_extensions?; end
|
|
|
|
def valid?; end
|
|
|
|
def self.default_gemspec_stub(filename, base_dir, gems_dir); end
|
|
|
|
def self.gemspec_stub(filename, base_dir, gems_dir); end
|
|
|
|
class StubLine
|
|
def extensions; end
|
|
|
|
def full_name; end
|
|
|
|
def initialize(data, extensions); end
|
|
|
|
def name; end
|
|
|
|
def platform; end
|
|
|
|
def require_paths; end
|
|
|
|
def version; end
|
|
end
|
|
end
|
|
|
|
class SystemExitException
|
|
def exit_code; end
|
|
|
|
def exit_code=(exit_code); end
|
|
|
|
def initialize(exit_code); end
|
|
end
|
|
|
|
module Text
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
end
|
|
|
|
class UninstallError
|
|
def spec; end
|
|
|
|
def spec=(spec); end
|
|
end
|
|
|
|
class UnsatisfiableDependencyError
|
|
def dependency; end
|
|
|
|
def errors; end
|
|
|
|
def errors=(errors); end
|
|
|
|
def initialize(dep, platform_mismatch = T.unsafe(nil)); end
|
|
|
|
def name; end
|
|
|
|
def version; end
|
|
end
|
|
|
|
class UriFormatter
|
|
def escape; end
|
|
|
|
def initialize(uri); end
|
|
|
|
def normalize; end
|
|
|
|
def unescape; end
|
|
|
|
def uri; end
|
|
end
|
|
|
|
module UserInteraction
|
|
include Gem::DefaultUserInteraction
|
|
include Gem::Text
|
|
|
|
def alert(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_error(statement, question = T.unsafe(nil)); end
|
|
|
|
def alert_warning(statement, question = T.unsafe(nil)); end
|
|
|
|
def ask(question); end
|
|
|
|
def ask_for_password(prompt); end
|
|
|
|
def ask_yes_no(question, default = T.unsafe(nil)); end
|
|
|
|
def choose_from_list(question, list); end
|
|
|
|
def say(statement = T.unsafe(nil)); end
|
|
|
|
def terminate_interaction(exit_code = T.unsafe(nil)); end
|
|
|
|
def verbose(msg = T.unsafe(nil)); end
|
|
|
|
def clean_text(text); end
|
|
|
|
def format_text(text, wrap, indent = T.unsafe(nil)); end
|
|
|
|
def levenshtein_distance(str1, str2); end
|
|
|
|
def min3(a, b, c); end
|
|
|
|
def truncate_text(text, description, max_length = T.unsafe(nil)); end
|
|
|
|
def ui; end
|
|
|
|
def ui=(new_ui); end
|
|
|
|
def use_ui(new_ui, &block); end
|
|
end
|
|
|
|
module Util
|
|
def self.glob_files_in_dir(glob, base_path); end
|
|
|
|
def self.gunzip(data); end
|
|
|
|
def self.gzip(data); end
|
|
|
|
def self.inflate(data); end
|
|
|
|
def self.popen(*command); end
|
|
|
|
def self.silent_system(*command); end
|
|
|
|
def self.traverse_parents(directory, &block); end
|
|
end
|
|
|
|
class Version
|
|
def _segments; end
|
|
|
|
def _split_segments; end
|
|
|
|
def _version; end
|
|
|
|
def approximate_recommendation; end
|
|
|
|
def bump; end
|
|
|
|
def canonical_segments; end
|
|
|
|
def encode_with(coder); end
|
|
|
|
def eql?(other); end
|
|
|
|
def init_with(coder); end
|
|
|
|
def marshal_dump; end
|
|
|
|
def marshal_load(array); end
|
|
|
|
def prerelease?; end
|
|
|
|
def pretty_print(q); end
|
|
|
|
def release; end
|
|
|
|
def segments; end
|
|
|
|
def to_yaml_properties; end
|
|
|
|
def version; end
|
|
|
|
def yaml_initialize(tag, map); end
|
|
|
|
def self.correct?(version); end
|
|
|
|
def self.create(input); end
|
|
|
|
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
|