From cb1cb432fa51c48bca0849a660cd027049f839f2 Mon Sep 17 00:00:00 2001 From: Andy Waite Date: Tue, 1 Oct 2019 17:21:29 -0400 Subject: [PATCH 1/2] Add Sorbet libraries --- codeclimate_engine.gemspec | 3 +++ 1 file changed, 3 insertions(+) diff --git a/codeclimate_engine.gemspec b/codeclimate_engine.gemspec index f9ccb81..7e61f88 100644 --- a/codeclimate_engine.gemspec +++ b/codeclimate_engine.gemspec @@ -22,6 +22,9 @@ Gem::Specification.new do |spec| spec.add_development_dependency "bundler", ">= 1.9", "< 3.0" spec.add_development_dependency "rake", "~> 10.0" spec.add_development_dependency "rspec", "~> 3.3" + spec.add_development_dependency "sorbet" + + spec.add_dependency "sorbet-runtime" spec.add_dependency "virtus", "~> 1.0" end # rubocop:enable Metrics/LineLength From fb0db430d323397f03c6801191e2dc55cd526a84 Mon Sep 17 00:00:00 2001 From: Andy Waite Date: Tue, 1 Oct 2019 17:21:42 -0400 Subject: [PATCH 2/2] Sorbet init --- lib/cc_engine/category.rb | 1 + lib/cc_engine/config.rb | 1 + lib/cc_engine/issue.rb | 1 + lib/cc_engine/location.rb | 1 + lib/cc_engine/location/line_range.rb | 1 + lib/cc_engine/location/position.rb | 1 + lib/cc_engine/position/grid.rb | 1 + lib/cc_engine/position/offset.rb | 1 + lib/cc_engine/version.rb | 1 + lib/codeclimate_engine.rb | 1 + sorbet/config | 2 + sorbet/rbi/gems/axiom-types.rbi | 159 + sorbet/rbi/gems/coercible.rbi | 156 + sorbet/rbi/gems/descendants_tracker.rbi | 17 + sorbet/rbi/gems/equalizer.rbi | 22 + sorbet/rbi/gems/ice_nine.rbi | 66 + sorbet/rbi/gems/rake.rbi | 634 ++ sorbet/rbi/gems/rspec-core.rbi | 1637 ++++ sorbet/rbi/gems/rspec-expectations.rbi | 388 + sorbet/rbi/gems/rspec-mocks.rbi | 822 ++ sorbet/rbi/gems/rspec-support.rbi | 266 + sorbet/rbi/gems/rspec.rbi | 14 + sorbet/rbi/gems/thread_safe.rbi | 81 + sorbet/rbi/gems/virtus.rbi | 419 + sorbet/rbi/hidden-definitions/errors.txt | 2112 ++++ sorbet/rbi/hidden-definitions/hidden.rbi | 4741 +++++++++ .../sorbet-typed/lib/bundler/all/bundler.rbi | 8682 +++++++++++++++++ sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi | 4222 ++++++++ .../rbi/sorbet-typed/lib/ruby/all/open3.rbi | 111 + .../rbi/sorbet-typed/lib/ruby/all/resolv.rbi | 543 ++ spec/cc_engine/config_spec.rb | 1 + spec/cc_engine/issue_spec.rb | 1 + spec/cc_engine/location/line_range_spec.rb | 1 + spec/cc_engine/location/position_spec.rb | 1 + spec/cc_engine/position/grid_spec.rb | 1 + spec/cc_engine/position/offset_spec.rb | 1 + spec/codeclimate_engine_spec.rb | 1 + spec/spec_helper.rb | 1 + 38 files changed, 25112 insertions(+) create mode 100644 sorbet/config create mode 100644 sorbet/rbi/gems/axiom-types.rbi create mode 100644 sorbet/rbi/gems/coercible.rbi create mode 100644 sorbet/rbi/gems/descendants_tracker.rbi create mode 100644 sorbet/rbi/gems/equalizer.rbi create mode 100644 sorbet/rbi/gems/ice_nine.rbi create mode 100644 sorbet/rbi/gems/rake.rbi create mode 100644 sorbet/rbi/gems/rspec-core.rbi create mode 100644 sorbet/rbi/gems/rspec-expectations.rbi create mode 100644 sorbet/rbi/gems/rspec-mocks.rbi create mode 100644 sorbet/rbi/gems/rspec-support.rbi create mode 100644 sorbet/rbi/gems/rspec.rbi create mode 100644 sorbet/rbi/gems/thread_safe.rbi create mode 100644 sorbet/rbi/gems/virtus.rbi create mode 100644 sorbet/rbi/hidden-definitions/errors.txt create mode 100644 sorbet/rbi/hidden-definitions/hidden.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi diff --git a/lib/cc_engine/category.rb b/lib/cc_engine/category.rb index 7b5fced..755940c 100644 --- a/lib/cc_engine/category.rb +++ b/lib/cc_engine/category.rb @@ -1,3 +1,4 @@ +# typed: true module CCEngine module Category def self.bug_risk diff --git a/lib/cc_engine/config.rb b/lib/cc_engine/config.rb index da15b45..0354ef3 100644 --- a/lib/cc_engine/config.rb +++ b/lib/cc_engine/config.rb @@ -1,3 +1,4 @@ +# typed: true require "json" module CCEngine diff --git a/lib/cc_engine/issue.rb b/lib/cc_engine/issue.rb index 70e9400..2e5b324 100644 --- a/lib/cc_engine/issue.rb +++ b/lib/cc_engine/issue.rb @@ -1,3 +1,4 @@ +# typed: ignore require "virtus" require "json" diff --git a/lib/cc_engine/location.rb b/lib/cc_engine/location.rb index 429a552..428284f 100644 --- a/lib/cc_engine/location.rb +++ b/lib/cc_engine/location.rb @@ -1,2 +1,3 @@ +# typed: strong require "cc_engine/location/line_range" require "cc_engine/location/position" diff --git a/lib/cc_engine/location/line_range.rb b/lib/cc_engine/location/line_range.rb index 9444948..887d676 100644 --- a/lib/cc_engine/location/line_range.rb +++ b/lib/cc_engine/location/line_range.rb @@ -1,3 +1,4 @@ +# typed: ignore require "virtus" module CCEngine diff --git a/lib/cc_engine/location/position.rb b/lib/cc_engine/location/position.rb index 6b3d55d..e0e90fa 100644 --- a/lib/cc_engine/location/position.rb +++ b/lib/cc_engine/location/position.rb @@ -1,3 +1,4 @@ +# typed: ignore require "virtus" module CCEngine diff --git a/lib/cc_engine/position/grid.rb b/lib/cc_engine/position/grid.rb index 73ff79f..e1dd51c 100644 --- a/lib/cc_engine/position/grid.rb +++ b/lib/cc_engine/position/grid.rb @@ -1,3 +1,4 @@ +# typed: ignore require "virtus" module CCEngine diff --git a/lib/cc_engine/position/offset.rb b/lib/cc_engine/position/offset.rb index 2eb5409..e24743f 100644 --- a/lib/cc_engine/position/offset.rb +++ b/lib/cc_engine/position/offset.rb @@ -1,3 +1,4 @@ +# typed: ignore require "virtus" module CCEngine diff --git a/lib/cc_engine/version.rb b/lib/cc_engine/version.rb index 7d9fc08..7ef9a63 100644 --- a/lib/cc_engine/version.rb +++ b/lib/cc_engine/version.rb @@ -1,3 +1,4 @@ +# typed: strong module CCEngine VERSION = "0.4.1" end diff --git a/lib/codeclimate_engine.rb b/lib/codeclimate_engine.rb index 2d35122..1ae61fd 100644 --- a/lib/codeclimate_engine.rb +++ b/lib/codeclimate_engine.rb @@ -1,3 +1,4 @@ +# typed: strong require "cc_engine/version" require "cc_engine/issue" require "cc_engine/location" diff --git a/sorbet/config b/sorbet/config new file mode 100644 index 0000000..7fb7a8e --- /dev/null +++ b/sorbet/config @@ -0,0 +1,2 @@ +--dir +. diff --git a/sorbet/rbi/gems/axiom-types.rbi b/sorbet/rbi/gems/axiom-types.rbi new file mode 100644 index 0000000..1fb729d --- /dev/null +++ b/sorbet/rbi/gems/axiom-types.rbi @@ -0,0 +1,159 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/axiom-types/all/axiom-types.rbi +# +# axiom-types-0.1.1 +module Axiom +end +module Axiom::Types + def self.finalize; end + def self.infer(object); end +end +module Axiom::Types::Options + def accept_options(*new_options); end + def accepted_options; end + def assert_method_available(name); end + def define_option_method(name); end + def inherited(descendant); end + def options; end + def setup_option(new_option); end +end +class Axiom::Types::Options::ReservedMethodError < ArgumentError +end +class Axiom::Types::Infinity + def <=>(other); end + def coerce(other); end + def inverse; end + def self.allocate; end + def self.instance; end + def self.inverse(*args); end + def self.new(*arg0); end + def self.number(*args); end + def succ; end + extend Axiom::Types::Options + extend Singleton::SingletonClassMethods + include Comparable +end +class Axiom::Types::NegativeInfinity < Axiom::Types::Infinity + def <=>(_other); end + def self.instance; end +end +module Axiom::Types::ValueComparable + def finalize; end + def range; end + def self.extended(descendant); end + def use_value_within_range; end +end +module Axiom::Types::LengthComparable + def finalize; end + def range; end + def self.extended(descendant); end + def use_length_within_range; end +end +module Axiom::Types::Encodable + def ascii_compatible?; end + def finalize; end + def self.extended(descendant); end + def use_ascii_compatible_encoding; end + def use_encoding; end +end +class Axiom::Types::Type + def self.add_constraint(constraint); end + def self.anonymous?; end + def self.base; end + def self.base?; end + def self.constraint(constraint = nil, &block); end + def self.finalize; end + def self.include?(object); end + def self.includes(*members); end + def self.infer(object); end + def self.new(*args, &block); end + extend Axiom::Types::Options +end +class Axiom::Types::Object < Axiom::Types::Type + def self.coercion_method(*args); end + def self.finalize; end + def self.infer(object); end + def self.infer_from_primitive_class(object); end + def self.inherits_from_primitive; end + def self.inspect; end + def self.match_primitive?(object); end + def self.primitive(*args); end +end +class Axiom::Types::Collection < Axiom::Types::Object + def self.base?; end + def self.finalize; end + def self.infer(object); end + def self.infer_from(member_type); end + def self.infer_from_primitive_instance(object); end + def self.match_primitive?(*arg0); end + def self.matches_member_type; end + def self.member_type(*args); end + def self.new_from(member_type); end +end +class Axiom::Types::Numeric < Axiom::Types::Object + def self.maximum(*args); end + def self.minimum(*args); end + extend Axiom::Types::ValueComparable +end +class Axiom::Types::Array < Axiom::Types::Collection + def self.base?; end +end +class Axiom::Types::Boolean < Axiom::Types::Object + def self.infer_from_primitive_class(object); end +end +class Axiom::Types::Class < Axiom::Types::Object +end +class Axiom::Types::Date < Axiom::Types::Object + def self.maximum(*args); end + def self.minimum(*args); end + extend Axiom::Types::ValueComparable +end +class Axiom::Types::DateTime < Axiom::Types::Object + def self.maximum(*args); end + def self.minimum(*args); end + extend Axiom::Types::ValueComparable +end +class Axiom::Types::Decimal < Axiom::Types::Numeric +end +class Axiom::Types::Float < Axiom::Types::Numeric +end +class Axiom::Types::Hash < Axiom::Types::Object + def self.base?; end + def self.finalize; end + def self.infer(object); end + def self.infer_from(key_type, value_type); end + def self.infer_from_primitive_instance(object); end + def self.key_type(*args); end + def self.match_primitive?(*arg0); end + def self.matches_key_and_value_types; end + def self.new_from(key_type, value_type); end + def self.value_type(*args); end +end +class Axiom::Types::Integer < Axiom::Types::Numeric +end +class Axiom::Types::Set < Axiom::Types::Collection + def self.base?; end +end +class Axiom::Types::String < Axiom::Types::Object + def self.encoding(*args); end + def self.maximum_length(*args); end + def self.minimum_length(*args); end + extend Axiom::Types::LengthComparable +end +class Axiom::Types::Symbol < Axiom::Types::Object + def self.encoding(*args); end + def self.maximum_length(*args); end + def self.minimum_length(*args); end + extend Axiom::Types::LengthComparable +end +class Axiom::Types::Time < Axiom::Types::Object + def self.maximum(*args); end + def self.minimum(*args); end + extend Axiom::Types::ValueComparable +end diff --git a/sorbet/rbi/gems/coercible.rbi b/sorbet/rbi/gems/coercible.rbi new file mode 100644 index 0000000..82c3e97 --- /dev/null +++ b/sorbet/rbi/gems/coercible.rbi @@ -0,0 +1,156 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/coercible/all/coercible.rbi +# +# coercible-1.0.0 +module Coercible + def self.rbx?; end +end +module Coercible::Options + def accept_options(*new_options); end + def accepted_options; end + def add_accepted_options(new_options); end + def define_option_method(option); end + def inherited(descendant); end + def options; end + def self.extended(descendant); end + def set_options(new_options); end +end +class Coercible::Options::Undefined +end +module Coercible::TypeLookup + def determine_type(class_or_name); end + def determine_type_and_cache(class_or_name); end + def determine_type_from_descendant(descendant); end + def determine_type_from_primitive(primitive); end + def determine_type_from_string(string); end + def primitive; end + def self.extended(model); end +end +class Coercible::Configuration + def self.build(keys, &block); end +end +class Coercible::Coercer + def [](klass); end + def coercers; end + def config; end + def config_for(coercer); end + def initialize(config, coercers = nil); end + def initialize_coercer(klass); end + def self.config_keys; end + def self.configurable_coercers(&block); end + def self.new(&block); end +end +module Coercible::Coercer::Configurable + def config(&block); end + def config_name; end + def configuration_class; end + def self.extended(coercer); end +end +class Coercible::Coercer::Object + def coerce_with_method(value, method, ref_method); end + def coerced?(value); end + def coercers; end + def initialize(coercers = nil); end + def inspect; end + def method_missing(method, *args); end + def raise_unsupported_coercion(value, method); end + def self.primitive(value = nil); end + def to_array(value); end + def to_hash(value); end + def to_integer(value); end + def to_string(value); end + extend Coercible::TypeLookup + extend DescendantsTracker +end +class Coercible::Coercer::Numeric < Coercible::Coercer::Object + def to_decimal(value); end + def to_float(value); end + def to_integer(value); end + def to_string(value); end +end +class Coercible::Coercer::Float < Coercible::Coercer::Numeric + def to_datetime(value); end + def to_float(value); end +end +class Coercible::Coercer::Integer < Coercible::Coercer::Numeric + def boolean_map; end + def datetime_format; end + def datetime_proc; end + def initialize(coercer = nil, config = nil); end + def self.config; end + def self.config_keys(value = nil); end + def to_boolean(value); end + def to_datetime(value); end + def to_integer(value); end + def to_string(value); end + extend Coercible::Coercer::Configurable +end +class Coercible::Coercer::Decimal < Coercible::Coercer::Numeric + def to_decimal(value); end + def to_string(value); end +end +class Coercible::Coercer::String < Coercible::Coercer::Object + def boolean_map; end + def constant_lookup(mod, name); end + def initialize(coercer = nil, config = nil); end + def parse_value(parser, value, method); end + def self.config; end + def self.config_keys(value = nil); end + def to_boolean(value); end + def to_constant(value); end + def to_date(value); end + def to_datetime(value); end + def to_decimal(value); end + def to_float(value); end + def to_integer(value); end + def to_numeric(value, method); end + def to_symbol(value); end + def to_time(value); end + extend Coercible::Coercer::Configurable +end +class Coercible::Coercer::Symbol < Coercible::Coercer::Object + def to_string(value); end +end +module Coercible::Coercer::TimeCoercions + def coerce_with_method(value, method); end + def to_date(value); end + def to_datetime(value); end + def to_string(value); end + def to_time(value); end +end +class Coercible::Coercer::Date < Coercible::Coercer::Object + def to_date(value); end + include Coercible::Coercer::TimeCoercions +end +class Coercible::Coercer::DateTime < Coercible::Coercer::Object + def to_datetime(value); end + include Coercible::Coercer::TimeCoercions +end +class Coercible::Coercer::Time < Coercible::Coercer::Object + def to_integer(value); end + def to_time(value); end + include Coercible::Coercer::TimeCoercions +end +class Coercible::Coercer::FalseClass < Coercible::Coercer::Object + def to_string(value); end +end +class Coercible::Coercer::TrueClass < Coercible::Coercer::Object + def to_string(value); end +end +class Coercible::Coercer::Array < Coercible::Coercer::Object + def to_set(value); end +end +class Coercible::Coercer::Hash < Coercible::Coercer::Object + def extract(value); end + def to_date(value); end + def to_datetime(value); end + def to_time(value); end +end +class Coercible::UnsupportedCoercion < StandardError +end diff --git a/sorbet/rbi/gems/descendants_tracker.rbi b/sorbet/rbi/gems/descendants_tracker.rbi new file mode 100644 index 0000000..0a99016 --- /dev/null +++ b/sorbet/rbi/gems/descendants_tracker.rbi @@ -0,0 +1,17 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/descendants_tracker/all/descendants_tracker.rbi +# +# descendants_tracker-0.0.4 +module DescendantsTracker + def add_descendant(descendant); end + def descendants; end + def inherited(descendant); end + def self.extended(descendant); end + def self.setup(descendant); end +end diff --git a/sorbet/rbi/gems/equalizer.rbi b/sorbet/rbi/gems/equalizer.rbi new file mode 100644 index 0000000..6057b68 --- /dev/null +++ b/sorbet/rbi/gems/equalizer.rbi @@ -0,0 +1,22 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/equalizer/all/equalizer.rbi +# +# equalizer-0.0.11 +class Equalizer < Module + def define_cmp_method; end + def define_hash_method; end + def define_inspect_method; end + def define_methods; end + def included(descendant); end + def initialize(*keys); end +end +module Equalizer::Methods + def ==(other); end + def eql?(other); end +end diff --git a/sorbet/rbi/gems/ice_nine.rbi b/sorbet/rbi/gems/ice_nine.rbi new file mode 100644 index 0000000..275fe1e --- /dev/null +++ b/sorbet/rbi/gems/ice_nine.rbi @@ -0,0 +1,66 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ice_nine/all/ice_nine.rbi +# +# ice_nine-0.11.2 +module IceNine + def self.deep_freeze!(object); end + def self.deep_freeze(object); end +end +class IceNine::RecursionGuard +end +class IceNine::RecursionGuard::ObjectSet < IceNine::RecursionGuard + def guard(object); end + def initialize; end +end +class IceNine::RecursionGuard::Frozen < IceNine::RecursionGuard + def guard(object); end +end +class IceNine::Freezer + def self.[](mod); end + def self.const_lookup(namespace); end + def self.deep_freeze!(object); end + def self.deep_freeze(object); end + def self.find(name); end + def self.guarded_deep_freeze(object, recursion_guard); end +end +class IceNine::Freezer::Object < IceNine::Freezer + def self.freeze_instance_variables(object, recursion_guard); end + def self.guarded_deep_freeze(object, recursion_guard); end +end +class IceNine::Freezer::NoFreeze < IceNine::Freezer + def self.guarded_deep_freeze(object, _recursion_guard); end +end +class IceNine::Freezer::Array < IceNine::Freezer::Object + def self.guarded_deep_freeze(array, recursion_guard); end +end +class IceNine::Freezer::FalseClass < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::Hash < IceNine::Freezer::Object + def self.freeze_key_value_pairs(hash, recursion_guard); end + def self.guarded_deep_freeze(hash, recursion_guard); end +end +class IceNine::Freezer::Hash::State < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::NilClass < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::Module < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::Numeric < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::Range < IceNine::Freezer::Object + def self.guarded_deep_freeze(range, recursion_guard); end +end +class IceNine::Freezer::Rubinius < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::Struct < IceNine::Freezer::Array +end +class IceNine::Freezer::Symbol < IceNine::Freezer::NoFreeze +end +class IceNine::Freezer::TrueClass < IceNine::Freezer::NoFreeze +end diff --git a/sorbet/rbi/gems/rake.rbi b/sorbet/rbi/gems/rake.rbi new file mode 100644 index 0000000..5bad819 --- /dev/null +++ b/sorbet/rbi/gems/rake.rbi @@ -0,0 +1,634 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: true +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi +# +# rake-10.5.0 +module Rake + def self.add_rakelib(*files); end + def self.application; end + def self.application=(app); end + def self.each_dir_parent(dir); end + def self.from_pathname(path); end + def self.load_rakefile(path); end + def self.original_dir; end + def self.suggested_thread_count; end + extend Rake::FileUtilsExt +end +module Rake::Version +end +class Module + def rake_extension(method); end +end +class String + def ext(newext = nil); end + def pathmap(spec = nil, &block); end + def pathmap_explode; end + def pathmap_partial(n); end + def pathmap_replace(patterns, &block); end +end +class Rake::EarlyTime + def <=>(other); end + def self.allocate; end + def self.instance; end + def self.new(*arg0); end + def to_s; end + extend Singleton::SingletonClassMethods + include Comparable + include Singleton +end +class Rake::LateTime + def <=>(other); end + def self.allocate; end + def self.instance; end + def self.new(*arg0); end + def to_s; end + extend Singleton::SingletonClassMethods + include Comparable + include Singleton +end +module Rake::AltSystem + def `(arg0); end + def backticks(arg0); end + def self.`(arg0); end + def self.backticks(arg0); end + def self.define_module_function(name, &block); end + def self.system(*arg0); end + def system(*arg0); end +end +module Rake::Win32 + def self.normalize(path); end + def self.rake_system(*cmd); end + def self.win32_system_dir; end + def self.windows?; end +end +class Rake::Win32::Win32HomeError < RuntimeError +end +class Rake::LinkedList + def ==(other); end + def conj(item); end + def each; end + def empty?; end + def head; end + def initialize(head, tail = nil); end + def inspect; end + def self.cons(head, tail); end + def self.empty; end + def self.make(*args); end + def tail; end + def to_s; end + include Enumerable +end +class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList + def empty?; end + def initialize; end + def self.cons(head, tail); end +end +class Rake::CpuCounter + def count; end + def count_with_default(default = nil); end + def self.count; end +end +class Rake::Scope < Rake::LinkedList + def path; end + def path_with_task_name(task_name); end + def trim(n); end +end +class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList + def path; end + def path_with_task_name(task_name); end +end +class Rake::TaskArgumentError < ArgumentError +end +class Rake::RuleRecursionOverflowError < StandardError + def add_target(target); end + def initialize(*args); end + def message; end +end +module Rake::TaskManager + def [](task_name, scopes = nil); end + def add_location(task); end + def attempt_rule(task_name, args, extensions, block, level); end + def clear; end + def create_rule(*args, &block); end + def current_scope; end + def define_task(task_class, *args, &block); end + def enhance_with_matching_rule(task_name, level = nil); end + def find_location; end + def generate_name; end + def get_description(task); end + def in_namespace(name); end + def initialize; end + def intern(task_class, task_name); end + def last_comment; end + def last_description; end + def last_description=(arg0); end + def lookup(task_name, initial_scope = nil); end + def lookup_in_scope(name, scope); end + def make_sources(task_name, extensions); end + def resolve_args(args); end + def resolve_args_with_dependencies(args, hash); end + def resolve_args_without_dependencies(args); end + def self.record_task_metadata; end + def self.record_task_metadata=(arg0); end + def synthesize_file_task(task_name); end + def tasks; end + def tasks_in_scope(scope); end + def trace_rule(level, message); end +end +module Rake::Cloneable + def initialize_copy(source); end +end +module FileUtils + def create_shell_runner(cmd); end + def rake_system(*cmd); end + def ruby(*args, &block); end + def safe_ln(*args); end + def set_verbose_option(options); end + def sh(*cmd, &block); end + def split_all(path); end +end +module Rake::FileUtilsExt + def cd(*args, &block); end + def chdir(*args, &block); end + def chmod(*args, &block); end + def chmod_R(*args, &block); end + def chown(*args, &block); end + def chown_R(*args, &block); end + def copy(*args, &block); end + def cp(*args, &block); end + def cp_r(*args, &block); end + def install(*args, &block); end + def link(*args, &block); end + def ln(*args, &block); end + def ln_s(*args, &block); end + def ln_sf(*args, &block); end + def makedirs(*args, &block); end + def mkdir(*args, &block); end + def mkdir_p(*args, &block); end + def mkpath(*args, &block); end + def move(*args, &block); end + def mv(*args, &block); end + def nowrite(value = nil); end + def rake_check_options(options, *optdecl); end + def rake_merge_option(args, defaults); end + def rake_output_message(message); end + def remove(*args, &block); end + def rm(*args, &block); end + def rm_f(*args, &block); end + def rm_r(*args, &block); end + def rm_rf(*args, &block); end + def rmdir(*args, &block); end + def rmtree(*args, &block); end + def ruby(*args, &block); end + def safe_unlink(*args, &block); end + def self.nowrite_flag; end + def self.nowrite_flag=(arg0); end + def self.verbose_flag; end + def self.verbose_flag=(arg0); end + def sh(*args, &block); end + def symlink(*args, &block); end + def touch(*args, &block); end + def verbose(value = nil); end + def when_writing(msg = nil); end + extend Rake::FileUtilsExt + include FileUtils +end +class Rake::FileList + def &(*args, &block); end + def *(other); end + def +(*args, &block); end + def -(*args, &block); end + def <<(obj); end + def <=>(*args, &block); end + def ==(array); end + def [](*args, &block); end + def []=(*args, &block); end + def add(*filenames); end + def add_matching(pattern); end + def all?(*args, &block); end + def any?(*args, &block); end + def assoc(*args, &block); end + def at(*args, &block); end + def bsearch(*args, &block); end + def bsearch_index(*args, &block); end + def chunk(*args, &block); end + def chunk_while(*args, &block); end + def clear(*args, &block); end + def clear_exclude; end + def collect!(*args, &block); end + def collect(*args, &block); end + def collect_concat(*args, &block); end + def combination(*args, &block); end + def compact!(*args, &block); end + def compact(*args, &block); end + def concat(*args, &block); end + def count(*args, &block); end + def cycle(*args, &block); end + def delete(*args, &block); end + def delete_at(*args, &block); end + def delete_if(*args, &block); end + def detect(*args, &block); end + def dig(*args, &block); end + def drop(*args, &block); end + def drop_while(*args, &block); end + def each(*args, &block); end + def each_cons(*args, &block); end + def each_entry(*args, &block); end + def each_index(*args, &block); end + def each_slice(*args, &block); end + def each_with_index(*args, &block); end + def each_with_object(*args, &block); end + def egrep(pattern, *options); end + def empty?(*args, &block); end + def entries(*args, &block); end + def exclude(*patterns, &block); end + def excluded_from_list?(fn); end + def existing!; end + def existing; end + def ext(newext = nil); end + def fetch(*args, &block); end + def fill(*args, &block); end + def find(*args, &block); end + def find_all(*args, &block); end + def find_index(*args, &block); end + def first(*args, &block); end + def flat_map(*args, &block); end + def flatten!(*args, &block); end + def flatten(*args, &block); end + def grep(*args, &block); end + def grep_v(*args, &block); end + def group_by(*args, &block); end + def gsub!(pat, rep); end + def gsub(pat, rep); end + def import(array); end + def include(*filenames); end + def include?(*args, &block); end + def index(*args, &block); end + def initialize(*patterns); end + def inject(*args, &block); end + def insert(*args, &block); end + def inspect(*args, &block); end + def is_a?(klass); end + def join(*args, &block); end + def keep_if(*args, &block); end + def kind_of?(klass); end + def last(*args, &block); end + def lazy(*args, &block); end + def length(*args, &block); end + def map!(*args, &block); end + def map(*args, &block); end + def max(*args, &block); end + def max_by(*args, &block); end + def member?(*args, &block); end + def min(*args, &block); end + def min_by(*args, &block); end + def minmax(*args, &block); end + def minmax_by(*args, &block); end + def none?(*args, &block); end + def one?(*args, &block); end + def pack(*args, &block); end + def partition(&block); end + def pathmap(spec = nil); end + def permutation(*args, &block); end + def pop(*args, &block); end + def product(*args, &block); end + def push(*args, &block); end + def rassoc(*args, &block); end + def reduce(*args, &block); end + def reject!(*args, &block); end + def reject(*args, &block); end + def repeated_combination(*args, &block); end + def repeated_permutation(*args, &block); end + def replace(*args, &block); end + def resolve; end + def resolve_add(fn); end + def resolve_exclude; end + def reverse!(*args, &block); end + def reverse(*args, &block); end + def reverse_each(*args, &block); end + def rindex(*args, &block); end + def rotate!(*args, &block); end + def rotate(*args, &block); end + def sample(*args, &block); end + def select!(*args, &block); end + def select(*args, &block); end + def self.[](*args); end + def self.glob(pattern, *args); end + def shelljoin(*args, &block); end + def shift(*args, &block); end + def shuffle!(*args, &block); end + def shuffle(*args, &block); end + def size(*args, &block); end + def slice!(*args, &block); end + def slice(*args, &block); end + def slice_after(*args, &block); end + def slice_before(*args, &block); end + def slice_when(*args, &block); end + def sort!(*args, &block); end + def sort(*args, &block); end + def sort_by!(*args, &block); end + def sort_by(*args, &block); end + def sub!(pat, rep); end + def sub(pat, rep); end + def sum(*args, &block); end + def take(*args, &block); end + def take_while(*args, &block); end + def to_a; end + def to_ary; end + def to_h(*args, &block); end + def to_s; end + def to_set(*args, &block); end + def transpose(*args, &block); end + def uniq!(*args, &block); end + def uniq(*args, &block); end + def unshift(*args, &block); end + def values_at(*args, &block); end + def zip(*args, &block); end + def |(*args, &block); end + include Rake::Cloneable +end +class Rake::Promise + def chore; end + def complete?; end + def discard; end + def error?; end + def initialize(args, &block); end + def recorder; end + def recorder=(arg0); end + def result?; end + def stat(*args); end + def value; end + def work; end +end +class Rake::ThreadPool + def __queue__; end + def future(*args, &block); end + def gather_history; end + def history; end + def initialize(thread_count); end + def join; end + def process_queue_item; end + def safe_thread_count; end + def start_thread; end + def stat(event, data = nil); end + def statistics; end +end +module Rake::PrivateReader + def self.included(base); end +end +module Rake::PrivateReader::ClassMethods + def private_reader(*names); end +end +class Rake::ThreadHistoryDisplay + def initialize(stats); end + def items; end + def rename(hash, key, renames); end + def show; end + def stats; end + def threads; end + extend Rake::PrivateReader::ClassMethods + include Rake::PrivateReader +end +module Rake::TraceOutput + def trace_on(out, *strings); end +end +class Rake::CommandLineOptionError < StandardError +end +class Rake::Application + def add_import(fn); end + def add_loader(ext, loader); end + def collect_command_line_tasks(args); end + def default_task_name; end + def deprecate(old_usage, new_usage, call_site); end + def display_error_message(ex); end + def display_exception_backtrace(ex); end + def display_exception_details(ex); end + def display_exception_message_details(ex); end + def display_prerequisites; end + def display_tasks_and_comments; end + def dynamic_width; end + def dynamic_width_stty; end + def dynamic_width_tput; end + def exit_because_of_exception(ex); end + def find_rakefile_location; end + def glob(path, &block); end + def handle_options; end + def has_cause?(ex); end + def has_chain?(exception); end + def have_rakefile; end + def init(app_name = nil); end + def initialize; end + def invoke_task(task_string); end + def load_imports; end + def load_rakefile; end + def name; end + def options; end + def original_dir; end + def parse_task_string(string); end + def print_rakefile_directory(location); end + def rake_require(file_name, paths = nil, loaded = nil); end + def rakefile; end + def rakefile_location(backtrace = nil); end + def raw_load_rakefile; end + def run; end + def run_with_threads; end + def select_tasks_to_show(options, show_tasks, value); end + def select_trace_output(options, trace_option, value); end + def sort_options(options); end + def standard_exception_handling; end + def standard_rake_options; end + def standard_system_dir; end + def system_dir; end + def terminal_columns; end + def terminal_columns=(arg0); end + def terminal_width; end + def thread_pool; end + def top_level; end + def top_level_tasks; end + def trace(*strings); end + def truncate(string, width); end + def truncate_output?; end + def tty_output=(tty_output_state); end + def tty_output?; end + def unix?; end + def windows?; end + include Rake::TaskManager + include Rake::TraceOutput +end +class Rake::PseudoStatus + def >>(n); end + def exited?; end + def exitstatus; end + def initialize(code = nil); end + def stopped?; end + def to_i; end +end +class Rake::TaskArguments + def [](index); end + def each(&block); end + def extras; end + def has_key?(key); end + def initialize(names, values, parent = nil); end + def inspect; end + def lookup(name); end + def method_missing(sym, *args); end + def names; end + def new_scope(names); end + def to_a; end + def to_hash; end + def to_s; end + def values_at(*keys); end + def with_defaults(defaults); end + include Enumerable +end +class Rake::InvocationChain < Rake::LinkedList + def append(invocation); end + def member?(invocation); end + def prefix; end + def self.append(invocation, chain); end + def to_s; end +end +class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList + def append(invocation); end + def member?(obj); end + def to_s; end +end +module Rake::InvocationExceptionMixin + def chain; end + def chain=(value); end +end +class Rake::Task + def actions; end + def add_chain_to(exception, new_chain); end + def add_comment(comment); end + def add_description(description); end + def all_prerequisite_tasks; end + def application; end + def application=(arg0); end + def arg_description; end + def arg_names; end + def clear; end + def clear_actions; end + def clear_comments; end + def clear_prerequisites; end + def collect_prerequisites(seen); end + def comment; end + def comment=(comment); end + def enhance(deps = nil, &block); end + def execute(args = nil); end + def first_sentence(string); end + def format_trace_flags; end + def full_comment; end + def initialize(task_name, app); end + def inspect; end + def investigation; end + def invoke(*args); end + def invoke_prerequisites(task_args, invocation_chain); end + def invoke_prerequisites_concurrently(task_args, invocation_chain); end + def invoke_with_call_chain(task_args, invocation_chain); end + def locations; end + def lookup_prerequisite(prerequisite_name); end + def name; end + def name_with_args; end + def needed?; end + def prerequisite_tasks; end + def prerequisites; end + def reenable; end + def scope; end + def self.[](task_name); end + def self.clear; end + def self.create_rule(*args, &block); end + def self.define_task(*args, &block); end + def self.scope_name(scope, task_name); end + def self.task_defined?(task_name); end + def self.tasks; end + def set_arg_names(args); end + def source; end + def sources; end + def sources=(arg0); end + def timestamp; end + def to_s; end + def transform_comments(separator, &block); end +end +class Rake::FileTask < Rake::Task + def needed?; end + def out_of_date?(stamp); end + def self.scope_name(scope, task_name); end + def timestamp; end +end +class Rake::FileCreationTask < Rake::FileTask + def needed?; end + def timestamp; end +end +class Rake::MultiTask < Rake::Task + def invoke_prerequisites(task_args, invocation_chain); end +end +module Rake::DSL + def cd(*args, &block); end + def chdir(*args, &block); end + def chmod(*args, &block); end + def chmod_R(*args, &block); end + def chown(*args, &block); end + def chown_R(*args, &block); end + def copy(*args, &block); end + def cp(*args, &block); end + def cp_r(*args, &block); end + def desc(description); end + def directory(*args, &block); end + def file(*args, &block); end + def file_create(*args, &block); end + def import(*fns); end + def install(*args, &block); end + def link(*args, &block); end + def ln(*args, &block); end + def ln_s(*args, &block); end + def ln_sf(*args, &block); end + def makedirs(*args, &block); end + def mkdir(*args, &block); end + def mkdir_p(*args, &block); end + def mkpath(*args, &block); end + def move(*args, &block); end + def multitask(*args, &block); end + def mv(*args, &block); end + def namespace(name = nil, &block); end + def nowrite(value = nil); end + def rake_check_options(options, *optdecl); end + def rake_merge_option(args, defaults); end + def rake_output_message(message); end + def remove(*args, &block); end + def rm(*args, &block); end + def rm_f(*args, &block); end + def rm_r(*args, &block); end + def rm_rf(*args, &block); end + def rmdir(*args, &block); end + def rmtree(*args, &block); end + def ruby(*args, &block); end + def rule(*args, &block); end + def safe_ln(*args); end + def safe_unlink(*args, &block); end + def sh(*args, &block); end + def split_all(path); end + def symlink(*args, &block); end + def task(*args, &block); end + def touch(*args, &block); end + def verbose(value = nil); end + def when_writing(msg = nil); end + include Rake::FileUtilsExt +end +class Rake::DefaultLoader + def load(fn); end +end +class Rake::NameSpace + def [](name); end + def initialize(task_manager, scope_list); end + def scope; end + def tasks; end +end +module Rake::Backtrace + def self.collapse(backtrace); end +end diff --git a/sorbet/rbi/gems/rspec-core.rbi b/sorbet/rbi/gems/rspec-core.rbi new file mode 100644 index 0000000..963fe1c --- /dev/null +++ b/sorbet/rbi/gems/rspec-core.rbi @@ -0,0 +1,1637 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: true +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-core/all/rspec-core.rbi +# +# rspec-core-3.8.2 +module RSpec + def self.clear_examples; end + def self.configuration; end + def self.configuration=(arg0); end + def self.configure; end + def self.const_missing(name); end + def self.context(*args, &example_group_block); end + def self.current_example; end + def self.current_example=(example); end + def self.describe(*args, &example_group_block); end + def self.example_group(*args, &example_group_block); end + def self.fcontext(*args, &example_group_block); end + def self.fdescribe(*args, &example_group_block); end + def self.reset; end + def self.shared_context(name, *args, &block); end + def self.shared_examples(name, *args, &block); end + def self.shared_examples_for(name, *args, &block); end + def self.world; end + def self.world=(arg0); end + def self.xcontext(*args, &example_group_block); end + def self.xdescribe(*args, &example_group_block); end + extend RSpec::Core::Warnings +end +module RSpec::Core + def self.path_to_executable; end +end +module RSpec::Core::Version +end +module RSpec::Core::Warnings + def deprecate(deprecated, data = nil); end + def warn_deprecation(message, opts = nil); end + def warn_with(message, options = nil); end +end +class RSpec::Core::Set + def <<(key); end + def clear; end + def delete(key); end + def each(&block); end + def empty?; end + def include?(key); end + def initialize(array = nil); end + def merge(values); end + include Enumerable +end +module RSpec::Core::FlatMap + def flat_map(array, &block); end + def self.flat_map(array, &block); end +end +class RSpec::Core::FilterManager + def add_ids(rerun_path, scoped_ids); end + def add_location(file_path, line_numbers); end + def add_path_to_arrays_filter(filter_key, path, values); end + def empty?; end + def exclude(*args); end + def exclude_only(*args); end + def exclude_with_low_priority(*args); end + def exclusions; end + def file_scoped_include?(ex_metadata, ids, locations); end + def include(*args); end + def include_only(*args); end + def include_with_low_priority(*args); end + def inclusions; end + def initialize; end + def prune(examples); end + def prune_conditionally_filtered_examples(examples); end +end +class RSpec::Core::FilterRules + def [](key); end + def add(updated); end + def add_with_low_priority(updated); end + def clear; end + def delete(key); end + def description; end + def each_pair(&block); end + def empty?; end + def fetch(*args, &block); end + def include_example?(example); end + def initialize(rules = nil); end + def opposite; end + def opposite=(arg0); end + def rules; end + def self.build; end + def use_only(updated); end +end +class RSpec::Core::InclusionRules < RSpec::Core::FilterRules + def add(*args); end + def add_with_low_priority(*args); end + def apply_standalone_filter(updated); end + def include_example?(example); end + def is_standalone_filter?(rules); end + def replace_filters(new_rules); end + def split_file_scoped_rules; end + def standalone?; end +end +module RSpec::Core::DSL + def self.change_global_dsl(&changes); end + def self.example_group_aliases; end + def self.expose_example_group_alias(name); end + def self.expose_example_group_alias_globally(method_name); end + def self.expose_globally!; end + def self.exposed_globally?; end + def self.remove_globally!; end + def self.top_level; end + def self.top_level=(arg0); end +end +module RSpec::Core::Formatters + def self.register(formatter_class, *notifications); end +end +module RSpec::Core::Formatters::ConsoleCodes + def config_colors_to_methods; end + def console_code_for(code_or_symbol); end + def self.config_colors_to_methods; end + def self.console_code_for(code_or_symbol); end + def self.wrap(text, code_or_symbol); end + def wrap(text, code_or_symbol); end +end +class RSpec::Core::Formatters::SnippetExtractor + def beginning_line_number; end + def expression_lines; end + def expression_node; end + def expression_outmost_node?(node); end + def initialize(source, beginning_line_number, max_line_count = nil); end + def line_range_of_expression; end + def line_range_of_location_nodes_in_expression; end + def location_nodes_at_beginning_line; end + def max_line_count; end + def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count = nil); end + def self.extract_line_at(file_path, line_number); end + def self.least_indentation_from(lines); end + def self.source_from_file(path); end + def source; end + def unclosed_tokens_in_line_range(line_range); end +end +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < StandardError +end +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < StandardError +end +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < StandardError +end +class RSpec::Core::Formatters::SyntaxHighlighter + def color_enabled_implementation; end + def highlight(lines); end + def implementation; end + def initialize(configuration); end + def self.attempt_to_add_rspec_terms_to_coderay_keywords; end +end +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + def self.highlight_syntax(lines); end +end +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + def self.highlight_syntax(lines); end +end +class RSpec::Core::Formatters::ExceptionPresenter + def add_shared_group_lines(lines, colorizer); end + def backtrace_formatter; end + def colorized_formatted_backtrace(colorizer = nil); end + def colorized_message_lines(colorizer = nil); end + def description; end + def detail_formatter; end + def encoded_description(description); end + def encoded_string(string); end + def encoding_of(string); end + def example; end + def exception; end + def exception_backtrace; end + def exception_class_name(exception = nil); end + def exception_lines; end + def extra_detail_formatter; end + def extra_failure_lines; end + def failure_lines; end + def failure_slash_error_lines; end + def final_exception(exception, previous = nil); end + def find_failed_line; end + def formatted_backtrace(exception = nil); end + def formatted_cause(exception); end + def formatted_message_and_backtrace(colorizer); end + def fully_formatted(failure_number, colorizer = nil); end + def fully_formatted_lines(failure_number, colorizer); end + def indent_lines(lines, failure_number); end + def initialize(exception, example, options = nil); end + def message_color; end + def message_lines; end + def read_failed_lines; end +end +class RSpec::Core::Formatters::ExceptionPresenter::Factory + def build; end + def initialize(example); end + def multiple_exception_summarizer(exception, prior_detail_formatter, color); end + def multiple_exceptions_error?(exception); end + def options; end + def pending_options; end + def sub_failure_list_formatter(exception, message_color); end + def with_multiple_error_options_as_needed(exception, options); end +end +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter + def self.format_backtrace(*arg0); end +end +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater + def initialize(parent); end + def with_truncated_backtrace(child); end +end +class RSpec::Core::MultipleExceptionError < StandardError + def aggregation_block_label; end + def aggregation_metadata; end + def all_exceptions; end + def exception_count_description; end + def failures; end + def initialize(*exceptions); end + def message; end + def other_errors; end + def summary; end + include RSpec::Core::MultipleExceptionError::InterfaceTag +end +module RSpec::Core::MultipleExceptionError::InterfaceTag + def add(exception); end + def self.for(ex); end +end +module RSpec::Core::ShellEscape + def conditionally_quote(id); end + def escape(shell_command); end + def quote(argument); end + def self.conditionally_quote(id); end + def self.escape(shell_command); end + def self.quote(argument); end + def self.shell_allows_unquoted_ids?; end + def shell_allows_unquoted_ids?; end +end +module RSpec::Core::Formatters::Helpers + def self.format_duration(duration); end + def self.format_seconds(float, precision = nil); end + def self.organize_ids(ids); end + def self.pluralize(count, string); end + def self.strip_trailing_zeroes(string); end +end +module RSpec::Core::Notifications +end +module RSpec::Core::Notifications::NullColorizer + def self.wrap(line, _code_or_symbol); end + def wrap(line, _code_or_symbol); end +end +class RSpec::Core::Notifications::StartNotification < Struct + def count; end + def count=(_); end + def load_time; end + def load_time=(_); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::ExampleNotification < Struct + def example; end + def example=(_); end + def self.[](*arg0); end + def self.for(example); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::ExamplesNotification + def examples; end + def failed_examples; end + def failure_notifications; end + def format_examples(examples); end + def fully_formatted_failed_examples(colorizer = nil); end + def fully_formatted_pending_examples(colorizer = nil); end + def initialize(reporter); end + def notifications; end + def pending_examples; end + def pending_notifications; end +end +class RSpec::Core::Notifications::FailedExampleNotification < RSpec::Core::Notifications::ExampleNotification + def colorized_formatted_backtrace(colorizer = nil); end + def colorized_message_lines(colorizer = nil); end + def description; end + def exception; end + def formatted_backtrace; end + def fully_formatted(failure_number, colorizer = nil); end + def fully_formatted_lines(failure_number, colorizer = nil); end + def initialize(example, exception_presenter = nil); end + def message_lines; end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::PendingExampleFixedNotification < RSpec::Core::Notifications::FailedExampleNotification +end +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < RSpec::Core::Notifications::FailedExampleNotification +end +class RSpec::Core::Notifications::SkippedExampleNotification < RSpec::Core::Notifications::ExampleNotification + def fully_formatted(pending_number, colorizer = nil); end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::GroupNotification < Struct + def group; end + def group=(_); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::MessageNotification < Struct + def message; end + def message=(_); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::SeedNotification < Struct + def fully_formatted; end + def seed; end + def seed=(_); end + def seed_used?; end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end + def used; end + def used=(_); end +end +class RSpec::Core::Notifications::SummaryNotification < Struct + def colorized_rerun_commands(colorizer = nil); end + def colorized_totals_line(colorizer = nil); end + def duplicate_rerun_locations; end + def duration; end + def duration=(_); end + def errors_outside_of_examples_count; end + def errors_outside_of_examples_count=(_); end + def example_count; end + def examples; end + def examples=(_); end + def failed_examples; end + def failed_examples=(_); end + def failure_count; end + def formatted_duration; end + def formatted_load_time; end + def fully_formatted(colorizer = nil); end + def load_time; end + def load_time=(_); end + def pending_count; end + def pending_examples; end + def pending_examples=(_); end + def rerun_argument_for(example); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end + def totals_line; end + include RSpec::Core::ShellEscape +end +class RSpec::Core::Notifications::ProfileNotification + def calculate_slowest_groups; end + def duration; end + def examples; end + def initialize(duration, examples, number_of_examples, example_groups); end + def number_of_examples; end + def percentage; end + def slow_duration; end + def slowest_examples; end + def slowest_groups; end +end +class RSpec::Core::Notifications::DeprecationNotification < Struct + def call_site; end + def call_site=(_); end + def deprecated; end + def deprecated=(_); end + def message; end + def message=(_); end + def replacement; end + def replacement=(_); end + def self.[](*arg0); end + def self.from_hash(data); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Notifications::NullNotification +end +class RSpec::Core::Notifications::CustomNotification < Struct + def self.for(options = nil); end +end +class RSpec::Core::Reporter + def abort_with(msg, exit_status); end + def close; end + def close_after; end + def deprecation(hash); end + def ensure_listeners_ready; end + def example_failed(example); end + def example_finished(example); end + def example_group_finished(group); end + def example_group_started(group); end + def example_passed(example); end + def example_pending(example); end + def example_started(example); end + def examples; end + def fail_fast_limit_met?; end + def failed_examples; end + def finish; end + def initialize(configuration); end + def message(message); end + def mute_profile_output?; end + def notify(event, notification); end + def notify_non_example_exception(exception, context_description); end + def pending_examples; end + def prepare_default(loader, output_stream, deprecation_stream); end + def publish(event, options = nil); end + def register_listener(listener, *notifications); end + def registered_listeners(notification); end + def report(expected_example_count); end + def seed_used?; end + def start(expected_example_count, time = nil); end + def stop; end +end +class RSpec::Core::NullReporter + def self.method_missing(*arg0); end +end +module RSpec::Core::Hooks + def after(*args, &block); end + def append_after(*args, &block); end + def append_before(*args, &block); end + def around(*args, &block); end + def before(*args, &block); end + def hooks; end + def prepend_after(*args, &block); end + def prepend_before(*args, &block); end +end +class RSpec::Core::Hooks::Hook < Struct + def block; end + def block=(_); end + def options; end + def options=(_); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Hooks::BeforeHook < RSpec::Core::Hooks::Hook + def run(example); end +end +class RSpec::Core::Hooks::AfterHook < RSpec::Core::Hooks::Hook + def run(example); end +end +class RSpec::Core::Hooks::AfterContextHook < RSpec::Core::Hooks::Hook + def run(example); end +end +class RSpec::Core::Hooks::AroundHook < RSpec::Core::Hooks::Hook + def execute_with(example, procsy); end + def hook_description; end +end +class RSpec::Core::Hooks::HookCollections + def all_hooks_for(position, scope); end + def ensure_hooks_initialized_for(position, scope); end + def extract_scope_from(args); end + def hooks_for(position, scope); end + def initialize(owner, filterable_item_repo_class); end + def known_scope?(scope); end + def matching_hooks_for(position, scope, example_or_group); end + def normalized_scope_for(scope); end + def owner_parent_groups; end + def process(host, parent_groups, globals, position, scope); end + def processable_hooks_for(position, scope, host); end + def register(prepend_or_append, position, *args, &block); end + def register_global_singleton_context_hooks(example, globals); end + def register_globals(host, globals); end + def run(position, scope, example_or_group); end + def run_around_example_hooks_for(example); end + def run_example_hooks_for(example, position, each_method); end + def run_owned_hooks_for(position, scope, example_or_group); end + def scope_and_options_from(*args); end +end +module RSpec::Core::MemoizedHelpers + def __init_memoized; end + def __memoized; end + def initialize(*arg0); end + def is_expected; end + def self.define_helpers_on(example_group); end + def self.get_constant_or_yield(example_group, name); end + def self.module_for(example_group); end + def should(matcher = nil, message = nil); end + def should_not(matcher = nil, message = nil); end + def subject; end +end +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized + def fetch_or_store(key); end + def initialize; end +end +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized + def fetch_or_store(key); end + def initialize; end +end +class RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.fetch_or_store(key, &_block); end + def self.isolate_for_context_hook(example_group_instance); end +end +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.article; end + def self.hook_expression; end + def self.hook_intention; end +end +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.article; end + def self.hook_expression; end + def self.hook_intention; end +end +module RSpec::Core::MemoizedHelpers::ClassMethods + def let!(name, &block); end + def let(name, &block); end + def subject!(name = nil, &block); end + def subject(name = nil, &block); end +end +module RSpec::Core::Metadata + def self.ascend(metadata); end + def self.ascending(metadata); end + def self.build_hash_from(args, warn_about_example_group_filtering = nil); end + def self.deep_hash_dup(object); end + def self.id_from(metadata); end + def self.location_tuple_from(metadata); end + def self.relative_path(line); end + def self.relative_path_regex; end +end +class RSpec::Core::Metadata::HashPopulator + def block; end + def build_description_from(parent_description = nil, my_description = nil); end + def build_scoped_id_for(file_path); end + def description_args; end + def description_separator(parent_part, child_part); end + def ensure_valid_user_keys; end + def file_path_and_line_number_from(backtrace); end + def initialize(metadata, user_metadata, index_provider, description_args, block); end + def metadata; end + def populate; end + def populate_location_attributes; end + def user_metadata; end +end +class RSpec::Core::Metadata::ExampleHash < RSpec::Core::Metadata::HashPopulator + def described_class; end + def full_description; end + def self.create(group_metadata, user_metadata, index_provider, description, block); end +end +class RSpec::Core::Metadata::ExampleGroupHash < RSpec::Core::Metadata::HashPopulator + def described_class; end + def full_description; end + def self.backwards_compatibility_default_proc(&example_group_selector); end + def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end + def self.hash_with_backwards_compatibility_default_proc; end +end +module RSpec::Core::HashImitatable + def <(*args, &block); end + def <=(*args, &block); end + def >(*args, &block); end + def >=(*args, &block); end + def [](key); end + def []=(key, value); end + def all?(*args, &block); end + def any?(*args, &block); end + def assoc(*args, &block); end + def chunk(*args, &block); end + def chunk_while(*args, &block); end + def clear(*args, &block); end + def collect(*args, &block); end + def collect_concat(*args, &block); end + def compact!(*args, &block); end + def compact(*args, &block); end + def compare_by_identity(*args, &block); end + def compare_by_identity?(*args, &block); end + def count(*args, &block); end + def cycle(*args, &block); end + def default(*args, &block); end + def default=(*args, &block); end + def default_proc(*args, &block); end + def default_proc=(*args, &block); end + def delete(*args, &block); end + def delete_if(*args, &block); end + def detect(*args, &block); end + def dig(*args, &block); end + def directly_supports_attribute?(name); end + def drop(*args, &block); end + def drop_while(*args, &block); end + def each(*args, &block); end + def each_cons(*args, &block); end + def each_entry(*args, &block); end + def each_key(*args, &block); end + def each_pair(*args, &block); end + def each_slice(*args, &block); end + def each_value(*args, &block); end + def each_with_index(*args, &block); end + def each_with_object(*args, &block); end + def empty?(*args, &block); end + def entries(*args, &block); end + def extra_hash_attributes; end + def fetch(*args, &block); end + def fetch_values(*args, &block); end + def find(*args, &block); end + def find_all(*args, &block); end + def find_index(*args, &block); end + def first(*args, &block); end + def flat_map(*args, &block); end + def flatten(*args, &block); end + def get_value(name); end + def grep(*args, &block); end + def grep_v(*args, &block); end + def group_by(*args, &block); end + def has_key?(*args, &block); end + def has_value?(*args, &block); end + def hash_for_delegation; end + def include?(*args, &block); end + def index(*args, &block); end + def inject(*args, &block); end + def invert(*args, &block); end + def issue_deprecation(_method_name, *_args); end + def keep_if(*args, &block); end + def key(*args, &block); end + def key?(*args, &block); end + def keys(*args, &block); end + def lazy(*args, &block); end + def length(*args, &block); end + def map(*args, &block); end + def max(*args, &block); end + def max_by(*args, &block); end + def member?(*args, &block); end + def merge!(*args, &block); end + def merge(*args, &block); end + def min(*args, &block); end + def min_by(*args, &block); end + def minmax(*args, &block); end + def minmax_by(*args, &block); end + def none?(*args, &block); end + def one?(*args, &block); end + def partition(*args, &block); end + def rassoc(*args, &block); end + def reduce(*args, &block); end + def rehash(*args, &block); end + def reject!(*args, &block); end + def reject(*args, &block); end + def replace(*args, &block); end + def reverse_each(*args, &block); end + def select!(*args, &block); end + def select(*args, &block); end + def self.included(klass); end + def set_value(name, value); end + def shift(*args, &block); end + def size(*args, &block); end + def slice_after(*args, &block); end + def slice_before(*args, &block); end + def slice_when(*args, &block); end + def sort(*args, &block); end + def sort_by(*args, &block); end + def store(*args, &block); end + def sum(*args, &block); end + def take(*args, &block); end + def take_while(*args, &block); end + def to_a(*args, &block); end + def to_h; end + def to_hash(*args, &block); end + def to_proc(*args, &block); end + def to_set(*args, &block); end + def transform_values!(*args, &block); end + def transform_values(*args, &block); end + def uniq(*args, &block); end + def update(*args, &block); end + def value?(*args, &block); end + def values(*args, &block); end + def values_at(*args, &block); end + def zip(*args, &block); end +end +module RSpec::Core::HashImitatable::ClassMethods + def attr_accessor(*names); end + def hash_attribute_names; end +end +class RSpec::Core::LegacyExampleGroupHash + def directly_supports_attribute?(name); end + def get_value(name); end + def initialize(metadata); end + def set_value(name, value); end + def to_h; end + extend RSpec::Core::HashImitatable::ClassMethods + include RSpec::Core::HashImitatable +end +module RSpec::Core::MetadataFilter + def self.apply?(predicate, filters, metadata); end + def self.filter_applies?(key, filter_value, metadata); end + def self.filter_applies_to_any_value?(key, value, metadata); end + def self.filters_apply?(key, value, metadata); end + def self.id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end + def self.location_filter_applies?(locations, metadata); end + def self.proc_filter_applies?(key, proc, metadata); end + def self.silence_metadata_example_group_deprecations; end +end +module RSpec::Core::FilterableItemRepository +end +class RSpec::Core::FilterableItemRepository::UpdateOptimized + def append(item, metadata); end + def delete(item, metadata); end + def initialize(applies_predicate); end + def items_and_filters; end + def items_for(request_meta); end + def prepend(item, metadata); end +end +class RSpec::Core::FilterableItemRepository::QueryOptimized < RSpec::Core::FilterableItemRepository::UpdateOptimized + def append(item, metadata); end + def applicable_metadata_from(metadata); end + def delete(item, metadata); end + def find_items_for(request_meta); end + def handle_mutation(metadata); end + def initialize(applies_predicate); end + def items_for(metadata); end + def prepend(item, metadata); end + def proc_keys_from(metadata); end + def reconstruct_caches; end +end +module RSpec::Core::Pending + def pending(message = nil); end + def self.mark_fixed!(example); end + def self.mark_pending!(example, message_or_bool); end + def self.mark_skipped!(example, message_or_bool); end + def skip(message = nil); end +end +class RSpec::Core::Pending::SkipDeclaredInExample < StandardError + def argument; end + def initialize(argument); end +end +class RSpec::Core::Pending::PendingExampleFixedError < StandardError +end +class RSpec::Core::Formatters::Loader + def add(formatter_to_use, *paths); end + def built_in_formatter(key); end + def custom_formatter(formatter_ref); end + def default_formatter; end + def default_formatter=(arg0); end + def duplicate_formatter_exists?(new_formatter); end + def existing_formatter_implements?(notification); end + def find_formatter(formatter_to_use); end + def formatters; end + def initialize(reporter); end + def notifications_for(formatter_class); end + def open_stream(path_or_wrapper); end + def path_for(const_ref); end + def prepare_default(output_stream, deprecation_stream); end + def register(formatter, notifications); end + def reporter; end + def self.formatters; end + def setup_default(output_stream, deprecation_stream); end + def string_const?(str); end + def underscore(camel_cased_word); end + def underscore_with_fix_for_non_standard_rspec_naming(string); end +end +module RSpec::Core::Ordering +end +class RSpec::Core::Ordering::Identity + def order(items); end +end +class RSpec::Core::Ordering::Random + def initialize(configuration); end + def jenkins_hash_digest(string); end + def order(items); end + def used?; end +end +class RSpec::Core::Ordering::Custom + def initialize(callable); end + def order(list); end +end +class RSpec::Core::Ordering::Registry + def fetch(name, &fallback); end + def initialize(configuration); end + def register(sym, strategy); end + def used_random_seed?; end +end +class RSpec::Core::Ordering::ConfigurationManager + def force(hash); end + def initialize; end + def order=(type); end + def ordering_registry; end + def register_ordering(name, strategy = nil); end + def seed; end + def seed=(seed); end + def seed_used?; end +end +class RSpec::Core::World + def all_example_groups; end + def all_examples; end + def announce_exclusion_filter(announcements); end + def announce_filters; end + def announce_inclusion_filter(announcements); end + def descending_declaration_line_numbers_by_file; end + def everything_filtered_message; end + def example_count(groups = nil); end + def example_groups; end + def exclusion_filter; end + def fail_if_config_and_cli_options_invalid; end + def filter_manager; end + def filtered_examples; end + def inclusion_filter; end + def initialize(configuration = nil); end + def non_example_failure; end + def non_example_failure=(arg0); end + def num_example_groups_defined_in(file); end + def ordered_example_groups; end + def preceding_declaration_line(absolute_file_name, filter_line); end + def prepare_example_filtering; end + def record(example_group); end + def registered_example_group_files; end + def report_filter_message(message); end + def reporter; end + def reset; end + def shared_example_group_registry; end + def source_from_file(path); end + def syntax_highlighter; end + def traverse_example_group_trees_until(&block); end + def wants_to_quit; end + def wants_to_quit=(arg0); end +end +module RSpec::Core::World::Null + def self.all_example_groups; end + def self.example_groups; end + def self.non_example_failure; end + def self.non_example_failure=(_); end + def self.registered_example_group_files; end + def self.traverse_example_group_trees_until; end +end +class RSpec::Core::BacktraceFormatter + def backtrace_line(line); end + def exclude?(line); end + def exclusion_patterns; end + def exclusion_patterns=(arg0); end + def filter_gem(gem_name); end + def format_backtrace(backtrace, options = nil); end + def full_backtrace=(arg0); end + def full_backtrace?; end + def inclusion_patterns; end + def inclusion_patterns=(arg0); end + def initialize; end + def matches?(patterns, line); end +end +module RSpec::Core::RubyProject + def add_dir_to_load_path(dir); end + def add_to_load_path(*dirs); end + def ascend_until; end + def determine_root; end + def find_first_parent_containing(dir); end + def root; end + def self.add_dir_to_load_path(dir); end + def self.add_to_load_path(*dirs); end + def self.ascend_until; end + def self.determine_root; end + def self.find_first_parent_containing(dir); end + def self.root; end +end +class RSpec::Core::Formatters::DeprecationFormatter + def count; end + def deprecation(notification); end + def deprecation_message_for(data); end + def deprecation_stream; end + def deprecation_summary(_notification); end + def initialize(deprecation_stream, summary_stream); end + def output; end + def printer; end + def summary_stream; end +end +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < Struct + def deprecation_type_for(data); end + def initialize(data); end + def output_formatted(str); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end + def to_s; end + def too_many_warnings_message; end + def type; end + def type=(_); end +end +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < Struct + def initialize(data); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end + def to_s; end + def too_many_warnings_message; end + def type; end + def type=(_); end +end +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter + def deprecation_formatter; end + def deprecation_stream; end + def deprecation_summary; end + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + def print_deprecation_message(data); end + def summary_stream; end +end +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter + def deprecation_formatter; end + def deprecation_stream; end + def deprecation_summary; end + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + def print_deferred_deprecation_warnings; end + def print_deprecation_message(data); end + def stash_deprecation_message(deprecation_message); end + def summary_stream; end +end +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream + def puts(message); end + def summarize(summary_stream, deprecation_count); end +end +class RSpec::Core::Formatters::DeprecationFormatter::FileStream + def initialize(file); end + def puts(*args); end + def summarize(summary_stream, deprecation_count); end +end +class RSpec::Core::DeprecationError < StandardError +end +class RSpec::Core::OutputWrapper + def <<(*args, &block); end + def advise(*args, &block); end + def autoclose=(*args, &block); end + def autoclose?(*args, &block); end + def binmode(*args, &block); end + def binmode?(*args, &block); end + def bytes(*args, &block); end + def chars(*args, &block); end + def close(*args, &block); end + def close_on_exec=(*args, &block); end + def close_on_exec?(*args, &block); end + def close_read(*args, &block); end + def close_write(*args, &block); end + def closed?(*args, &block); end + def codepoints(*args, &block); end + def each(*args, &block); end + def each_byte(*args, &block); end + def each_char(*args, &block); end + def each_codepoint(*args, &block); end + def each_line(*args, &block); end + def eof(*args, &block); end + def eof?(*args, &block); end + def external_encoding(*args, &block); end + def fcntl(*args, &block); end + def fdatasync(*args, &block); end + def fileno(*args, &block); end + def flush(*args, &block); end + def fsync(*args, &block); end + def getbyte(*args, &block); end + def getc(*args, &block); end + def gets(*args, &block); end + def initialize(output); end + def inspect(*args, &block); end + def internal_encoding(*args, &block); end + def ioctl(*args, &block); end + def isatty(*args, &block); end + def lineno(*args, &block); end + def lineno=(*args, &block); end + def lines(*args, &block); end + def method_missing(name, *args, &block); end + def output; end + def output=(arg0); end + def pathconf(*args, &block); end + def pid(*args, &block); end + def pos(*args, &block); end + def pos=(*args, &block); end + def print(*args, &block); end + def printf(*args, &block); end + def putc(*args, &block); end + def puts(*args, &block); end + def read(*args, &block); end + def read_nonblock(*args, &block); end + def readbyte(*args, &block); end + def readchar(*args, &block); end + def readline(*args, &block); end + def readlines(*args, &block); end + def readpartial(*args, &block); end + def reopen(*args, &block); end + def respond_to?(name, priv = nil); end + def rewind(*args, &block); end + def seek(*args, &block); end + def set_encoding(*args, &block); end + def stat(*args, &block); end + def sync(*args, &block); end + def sync=(*args, &block); end + def sysread(*args, &block); end + def sysseek(*args, &block); end + def syswrite(*args, &block); end + def tell(*args, &block); end + def to_i(*args, &block); end + def to_io(*args, &block); end + def tty?(*args, &block); end + def ungetbyte(*args, &block); end + def ungetc(*args, &block); end + def write(*args, &block); end + def write_nonblock(*args, &block); end +end +class RSpec::Core::Configuration + def absolute_pattern?(pattern); end + def add_formatter(formatter, output = nil); end + def add_hook_to_existing_matching_groups(meta, scope, &block); end + def add_setting(name, opts = nil); end + def after(scope = nil, *meta, &block); end + def alias_example_group_to(new_name, *args); end + def alias_example_to(name, *args); end + def alias_it_behaves_like_to(new_name, report_label = nil); end + def alias_it_should_behave_like_to(new_name, report_label = nil); end + def append_after(scope = nil, *meta, &block); end + def append_before(scope = nil, *meta, &block); end + def apply_derived_metadata_to(metadata); end + def around(scope = nil, *meta, &block); end + def assert_no_example_groups_defined(config_option); end + def backtrace_exclusion_patterns; end + def backtrace_exclusion_patterns=(patterns); end + def backtrace_formatter; end + def backtrace_inclusion_patterns; end + def backtrace_inclusion_patterns=(patterns); end + def before(scope = nil, *meta, &block); end + def bisect_runner; end + def bisect_runner=(value); end + def bisect_runner_class; end + def clear_values_derived_from_example_status_persistence_file_path; end + def color; end + def color=(arg0); end + def color_enabled?(output = nil); end + def color_mode; end + def color_mode=(arg0); end + def command; end + def conditionally_disable_expectations_monkey_patching; end + def conditionally_disable_mocks_monkey_patching; end + def configure_example(example, example_hooks); end + def configure_expectation_framework; end + def configure_group(group); end + def configure_group_with(group, module_list, application_method); end + def configure_mock_framework; end + def default_color; end + def default_color=(arg0); end + def default_color?; end + def default_formatter; end + def default_formatter=(value); end + def default_path; end + def default_path=(path); end + def default_path?; end + def define_built_in_hooks; end + def define_derived_metadata(*filters, &block); end + def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end + def deprecation_stream; end + def deprecation_stream=(value); end + def detail_color; end + def detail_color=(arg0); end + def detail_color?; end + def disable_monkey_patching!; end + def disable_monkey_patching; end + def disable_monkey_patching=(arg0); end + def drb; end + def drb=(arg0); end + def drb?; end + def drb_port; end + def drb_port=(arg0); end + def drb_port?; end + def dry_run; end + def dry_run=(arg0); end + def dry_run?; end + def error_stream; end + def error_stream=(arg0); end + def error_stream?; end + def example_status_persistence_file_path; end + def example_status_persistence_file_path=(value); end + def exclude_pattern; end + def exclude_pattern=(value); end + def exclusion_filter; end + def exclusion_filter=(filter); end + def expect_with(*frameworks); end + def expectation_framework=(framework); end + def expectation_frameworks; end + def expose_current_running_example_as(method_name); end + def expose_dsl_globally=(value); end + def expose_dsl_globally?; end + def extend(mod, *filters); end + def extract_location(path); end + def fail_fast; end + def fail_fast=(arg0); end + def fail_fast?; end + def fail_if_no_examples; end + def fail_if_no_examples=(arg0); end + def fail_if_no_examples?; end + def failure_color; end + def failure_color=(arg0); end + def failure_color?; end + def failure_exit_code; end + def failure_exit_code=(arg0); end + def failure_exit_code?; end + def file_glob_from(path, pattern); end + def files_or_directories_to_run=(*files); end + def files_to_run; end + def files_to_run=(arg0); end + def filter; end + def filter=(filter); end + def filter_gems_from_backtrace(*gem_names); end + def filter_manager; end + def filter_manager=(arg0); end + def filter_run(*args); end + def filter_run_excluding(*args); end + def filter_run_including(*args); end + def filter_run_when_matching(*args); end + def fixed_color; end + def fixed_color=(arg0); end + def fixed_color?; end + def force(hash); end + def format_docstrings(&block); end + def format_docstrings_block; end + def formatter=(formatter, output = nil); end + def formatter_loader; end + def formatters; end + def full_backtrace=(true_or_false); end + def full_backtrace?; end + def full_description; end + def full_description=(description); end + def gather_directories(path); end + def get_files_to_run(paths); end + def get_matching_files(path, pattern); end + def handle_suite_hook(scope, meta); end + def hooks; end + def in_project_source_dir_regex; end + def include(mod, *filters); end + def include_context(shared_group_name, *filters); end + def inclusion_filter; end + def inclusion_filter=(filter); end + def initialize; end + def last_run_statuses; end + def libs; end + def libs=(libs); end + def load_file_handling_errors(method, file); end + def load_spec_files; end + def loaded_spec_files; end + def max_displayed_failure_line_count; end + def max_displayed_failure_line_count=(arg0); end + def max_displayed_failure_line_count?; end + def metadata_applies_to_group?(meta, group); end + def mock_framework; end + def mock_framework=(framework); end + def mock_with(framework); end + def on_example_group_definition(&block); end + def on_example_group_definition_callbacks; end + def on_existing_matching_groups(meta); end + def only_failures; end + def only_failures?; end + def only_failures_but_not_configured?; end + def order=(*args, &block); end + def ordering_manager; end + def ordering_registry(*args, &block); end + def output_stream; end + def output_stream=(value); end + def output_to_tty?(output = nil); end + def output_wrapper; end + def paths_to_check(paths); end + def pattern; end + def pattern=(value); end + def pattern_might_load_specs_from_vendored_dirs?; end + def pending_color; end + def pending_color=(arg0); end + def pending_color?; end + def prepend(mod, *filters); end + def prepend_after(scope = nil, *meta, &block); end + def prepend_before(scope = nil, *meta, &block); end + def profile_examples; end + def profile_examples=(arg0); end + def profile_examples?; end + def project_source_dirs; end + def project_source_dirs=(arg0); end + def project_source_dirs?; end + def raise_errors_for_deprecations!; end + def raise_on_warning=(value); end + def register_ordering(*args, &block); end + def reporter; end + def requires; end + def requires=(paths); end + def reset; end + def reset_filters; end + def reset_reporter; end + def rspec_expectations_loaded?; end + def rspec_mocks_loaded?; end + def run_all_when_everything_filtered; end + def run_all_when_everything_filtered=(arg0); end + def run_all_when_everything_filtered?; end + def run_suite_hooks(hook_description, hooks); end + def safe_extend(mod, host); end + def safe_include(mod, host); end + def safe_prepend(mod, host); end + def seed(*args, &block); end + def seed=(*args, &block); end + def seed_used?(*args, &block); end + def self.add_read_only_setting(name, opts = nil); end + def self.add_setting(name, opts = nil); end + def self.define_aliases(name, alias_name); end + def self.define_predicate_for(*names); end + def self.define_reader(name); end + def self.delegate_to_ordering_manager(*methods); end + def shared_context_metadata_behavior; end + def shared_context_metadata_behavior=(value); end + def silence_filter_announcements; end + def silence_filter_announcements=(arg0); end + def silence_filter_announcements?; end + def spec_files_with_failures; end + def start_time; end + def start_time=(arg0); end + def start_time?; end + def static_config_filter_manager; end + def static_config_filter_manager=(arg0); end + def success_color; end + def success_color=(arg0); end + def success_color?; end + def threadsafe; end + def threadsafe=(arg0); end + def threadsafe?; end + def treat_symbols_as_metadata_keys_with_true_values=(_value); end + def tty; end + def tty=(arg0); end + def tty?; end + def update_pattern_attr(name, value); end + def value_for(key); end + def warnings=(value); end + def warnings?; end + def when_first_matching_example_defined(*filters); end + def with_suite_hooks; end + def world; end + def world=(arg0); end + include RSpec::Core::Configuration::Readers + include RSpec::Core::Hooks +end +module RSpec::Core::Configuration::Readers + def default_color; end + def default_path; end + def deprecation_stream; end + def detail_color; end + def drb; end + def drb_port; end + def dry_run; end + def error_stream; end + def example_status_persistence_file_path; end + def exclude_pattern; end + def fail_fast; end + def fail_if_no_examples; end + def failure_color; end + def failure_exit_code; end + def fixed_color; end + def libs; end + def max_displayed_failure_line_count; end + def only_failures; end + def output_stream; end + def pattern; end + def pending_color; end + def profile_examples; end + def project_source_dirs; end + def requires; end + def run_all_when_everything_filtered; end + def shared_context_metadata_behavior; end + def silence_filter_announcements; end + def start_time; end + def success_color; end + def threadsafe; end + def tty; end +end +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < StandardError +end +class RSpec::Core::Configuration::DeprecationReporterBuffer + def deprecation(*args); end + def initialize; end + def play_onto(reporter); end +end +module RSpec::Core::Configuration::ExposeCurrentExample +end +class RSpec::Core::Parser + def add_tag_filter(options, filter_type, tag_name, value = nil); end + def configure_only_failures(options); end + def initialize(original_args); end + def original_args; end + def parse(source = nil); end + def parser(options); end + def self.parse(args, source = nil); end + def set_fail_fast(options, value); end +end +class RSpec::Core::ConfigurationOptions + def args; end + def args_from_options_file(path); end + def command_line_options; end + def configure(config); end + def configure_filter_manager(filter_manager); end + def custom_options; end + def custom_options_file; end + def env_options; end + def file_options; end + def force?(key); end + def global_options; end + def global_options_file; end + def home_options_file_path; end + def initialize(args); end + def load_formatters_into(config); end + def local_options; end + def local_options_file; end + def options; end + def options_file_as_erb_string(path); end + def options_from(path); end + def order(keys); end + def organize_options; end + def parse_args_ignoring_files_or_dirs_to_run(args, source); end + def process_options_into(config); end + def project_options; end + def project_options_file; end + def resolve_xdg_config_home; end + def xdg_options_file_if_exists; end + def xdg_options_file_path; end +end +class RSpec::Core::Runner + def configuration; end + def configure(err, out); end + def initialize(options, configuration = nil, world = nil); end + def options; end + def persist_example_statuses; end + def run(err, out); end + def run_specs(example_groups); end + def self.autorun; end + def self.autorun_disabled?; end + def self.disable_autorun!; end + def self.handle_interrupt; end + def self.installed_at_exit?; end + def self.invoke; end + def self.perform_at_exit; end + def self.run(args, err = nil, out = nil); end + def self.running_in_drb?; end + def self.trap_interrupt; end + def setup(err, out); end + def world; end +end +module RSpec::Core::Invocations +end +class RSpec::Core::Invocations::InitializeProject + def call(*_args); end +end +class RSpec::Core::Invocations::DRbWithFallback + def call(options, err, out); end +end +class RSpec::Core::Invocations::Bisect + def bisect_formatter_klass_for(argument); end + def call(options, err, out); end +end +class RSpec::Core::Invocations::PrintVersion + def call(_options, _err, out); end +end +class RSpec::Core::Invocations::PrintHelp < Struct + def call(_options, _err, out); end + def hidden_options; end + def hidden_options=(_); end + def parser; end + def parser=(_); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Core::Example + def assign_generated_description; end + def clock; end + def clock=(arg0); end + def description; end + def display_exception; end + def display_exception=(ex); end + def duplicate_with(metadata_overrides = nil); end + def example_group; end + def example_group_instance; end + def exception; end + def execution_result; end + def fail_with_exception(reporter, exception); end + def file_path; end + def finish(reporter); end + def full_description; end + def generate_description; end + def hooks; end + def id; end + def initialize(example_group_class, description, user_metadata, example_block = nil); end + def inspect; end + def inspect_output; end + def instance_exec(*args, &block); end + def location; end + def location_description; end + def location_rerun_argument; end + def metadata; end + def mocks_need_verification?; end + def pending; end + def pending?; end + def record_finished(status, reporter); end + def reporter; end + def rerun_argument; end + def run(example_group_instance, reporter); end + def run_after_example; end + def run_before_example; end + def self.delegate_to_metadata(key); end + def self.parse_id(id); end + def set_aggregate_failures_exception(exception); end + def set_exception(exception); end + def skip; end + def skip_with_exception(reporter, exception); end + def skipped?; end + def start(reporter); end + def to_s; end + def update_inherited_metadata(updates); end + def verify_mocks; end + def with_around_and_singleton_context_hooks; end + def with_around_example_hooks; end +end +class RSpec::Core::Example::Procsy + def ===(*a, &b); end + def [](*a, &b); end + def arity(*a, &b); end + def binding(*a, &b); end + def call(*args, &block); end + def clock(*a, &b); end + def clock=(*a, &b); end + def clone(*a, &b); end + def curry(*a, &b); end + def description(*a, &b); end + def dup(*a, &b); end + def duplicate_with(*a, &b); end + def example; end + def example_group(*a, &b); end + def example_group_instance(*a, &b); end + def exception(*a, &b); end + def executed?; end + def execution_result(*a, &b); end + def file_path(*a, &b); end + def full_description(*a, &b); end + def hash(*a, &b); end + def id(*a, &b); end + def initialize(example, &block); end + def inspect; end + def inspect_output(*a, &b); end + def lambda?(*a, &b); end + def location(*a, &b); end + def location_rerun_argument(*a, &b); end + def metadata(*a, &b); end + def parameters(*a, &b); end + def pending(*a, &b); end + def pending?(*a, &b); end + def reporter(*a, &b); end + def rerun_argument(*a, &b); end + def run(*args, &block); end + def skip(*a, &b); end + def skipped?(*a, &b); end + def source_location(*a, &b); end + def to_proc; end + def update_inherited_metadata(*a, &b); end + def wrap(&block); end + def yield(*a, &b); end +end +class RSpec::Core::Example::ExecutionResult + def calculate_run_time(finished_at); end + def ensure_timing_set(clock); end + def example_skipped?; end + def exception; end + def exception=(arg0); end + def finished_at; end + def finished_at=(arg0); end + def get_value(name); end + def hash_for_delegation; end + def issue_deprecation(_method_name, *_args); end + def pending_exception; end + def pending_exception=(arg0); end + def pending_fixed; end + def pending_fixed=(arg0); end + def pending_fixed?; end + def pending_message; end + def pending_message=(arg0); end + def record_finished(status, finished_at); end + def run_time; end + def run_time=(arg0); end + def set_value(name, value); end + def started_at; end + def started_at=(arg0); end + def status; end + def status=(arg0); end + extend RSpec::Core::HashImitatable::ClassMethods + include RSpec::Core::HashImitatable +end +class RSpec::Core::SuiteHookContext < RSpec::Core::Example + def initialize(hook_description, reporter); end + def set_exception(exception); end +end +class RSpec::Core::SharedExampleGroupModule < Module + def definition; end + def include_in(klass, inclusion_line, args, customization_block); end + def included(klass); end + def initialize(description, definition, metadata); end + def inspect; end + def to_s; end +end +module RSpec::Core::SharedExampleGroup + def shared_context(name, *args, &block); end + def shared_examples(name, *args, &block); end + def shared_examples_for(name, *args, &block); end +end +module RSpec::Core::SharedExampleGroup::TopLevelDSL + def self.definitions; end + def self.expose_globally!; end + def self.exposed_globally?; end + def self.remove_globally!; end +end +class RSpec::Core::SharedExampleGroup::Registry + def add(context, name, *metadata_args, &block); end + def ensure_block_has_source_location(_block); end + def find(lookup_contexts, name); end + def formatted_location(block); end + def legacy_add(context, name, *metadata_args, &block); end + def shared_example_groups; end + def valid_name?(candidate); end + def warn_if_key_taken(context, key, new_block); end +end +class RSpec::Core::ExampleGroup + def described_class; end + def initialize(inspect_output = nil); end + def inspect; end + def method_missing(name, *args); end + def self.add_example(example); end + def self.before_context_ivars; end + def self.children; end + def self.context(*args, &example_group_block); end + def self.currently_executing_a_context_hook?; end + def self.declaration_locations; end + def self.define_example_group_method(name, metadata = nil); end + def self.define_example_method(name, extra_options = nil); end + def self.define_nested_shared_group_method(new_name, report_label = nil); end + def self.delegate_to_metadata(*names); end + def self.descendant_filtered_examples; end + def self.descendants; end + def self.describe(*args, &example_group_block); end + def self.described_class; end + def self.description; end + def self.each_instance_variable_for_example(group); end + def self.ensure_example_groups_are_configured; end + def self.example(*all_args, &block); end + def self.example_group(*args, &example_group_block); end + def self.examples; end + def self.fcontext(*args, &example_group_block); end + def self.fdescribe(*args, &example_group_block); end + def self.fexample(*all_args, &block); end + def self.file_path; end + def self.filtered_examples; end + def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end + def self.fit(*all_args, &block); end + def self.focus(*all_args, &block); end + def self.for_filtered_examples(reporter, &block); end + def self.fspecify(*all_args, &block); end + def self.id; end + def self.idempotently_define_singleton_method(name, &definition); end + def self.include_context(name, *args, &block); end + def self.include_examples(name, *args, &block); end + def self.it(*all_args, &block); end + def self.it_behaves_like(name, *args, &customization_block); end + def self.it_should_behave_like(name, *args, &customization_block); end + def self.location; end + def self.metadata; end + def self.method_missing(name, *args); end + def self.next_runnable_index_for(file); end + def self.ordering_strategy; end + def self.parent_groups; end + def self.pending(*all_args, &block); end + def self.remove_example(example); end + def self.reset_memoized; end + def self.run(reporter = nil); end + def self.run_after_context_hooks(example_group_instance); end + def self.run_before_context_hooks(example_group_instance); end + def self.run_examples(reporter); end + def self.set_it_up(description, args, registration_collection, &example_group_block); end + def self.set_ivars(instance, ivars); end + def self.skip(*all_args, &block); end + def self.specify(*all_args, &block); end + def self.store_before_context_ivars(example_group_instance); end + def self.subclass(parent, description, args, registration_collection, &example_group_block); end + def self.superclass_before_context_ivars; end + def self.superclass_metadata; end + def self.top_level?; end + def self.top_level_description; end + def self.traverse_tree_until(&block); end + def self.update_inherited_metadata(updates); end + def self.with_replaced_metadata(meta); end + def self.xcontext(*args, &example_group_block); end + def self.xdescribe(*args, &example_group_block); end + def self.xexample(*all_args, &block); end + def self.xit(*all_args, &block); end + def self.xspecify(*all_args, &block); end + extend RSpec::Core::Hooks + extend RSpec::Core::MemoizedHelpers::ClassMethods + extend RSpec::Core::SharedExampleGroup + include RSpec::Core::MemoizedHelpers + include RSpec::Core::Pending +end +class RSpec::Core::ExampleGroup::WrongScopeError < NoMethodError +end +class RSpec::Core::AnonymousExampleGroup < RSpec::Core::ExampleGroup + def self.metadata; end +end +class RSpec::Core::SharedExampleGroupInclusionStackFrame + def description; end + def formatted_inclusion_location; end + def inclusion_location; end + def initialize(shared_group_name, inclusion_location); end + def self.current_backtrace; end + def self.shared_example_group_inclusions; end + def self.with_frame(name, location); end + def shared_group_name; end +end +module RSpec::ExampleGroups + def self.assign_const(group); end + def self.base_name_for(group); end + def self.constant_scope_for(group); end + def self.disambiguate(name, const_scope); end + def self.remove_all_constants; end + extend RSpec::Support::RecursiveConstMethods +end +module RSpec::Support + def self.require_rspec_core(f); end +end +class RSpec::Core::Time + def self.now; end +end +class Module + def context(*a, &b); end + def describe(*a, &b); end + def example_group(*a, &b); end + def fcontext(*a, &b); end + def fdescribe(*a, &b); end + def shared_context(name, *args, &block); end + def shared_examples(name, *args, &block); end + def shared_examples_for(name, *args, &block); end + def xcontext(*a, &b); end + def xdescribe(*a, &b); end +end +module RSpec::Core::MockingAdapters +end +module RSpec::Core::MockingAdapters::RSpec + def self.configuration; end + def self.framework_name; end + def setup_mocks_for_rspec; end + def teardown_mocks_for_rspec; end + def verify_mocks_for_rspec; end + include RSpec::Mocks::ExampleMethods + include RSpec::Mocks::ExampleMethods::ExpectHost +end diff --git a/sorbet/rbi/gems/rspec-expectations.rbi b/sorbet/rbi/gems/rspec-expectations.rbi new file mode 100644 index 0000000..ce059ea --- /dev/null +++ b/sorbet/rbi/gems/rspec-expectations.rbi @@ -0,0 +1,388 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: true +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-expectations/all/rspec-expectations.rbi +# +# rspec-expectations-3.8.4 +module RSpec +end +module RSpec::Matchers + def a_block_changing(*args, &block); end + def a_block_outputting(*args, &block); end + def a_block_raising(*args, &block); end + def a_block_throwing(*args, &block); end + def a_block_yielding_control(*args, &block); end + def a_block_yielding_successive_args(*args, &block); end + def a_block_yielding_with_args(*args, &block); end + def a_block_yielding_with_no_args(*args, &block); end + def a_collection_containing_exactly(*args, &block); end + def a_collection_ending_with(*args, &block); end + def a_collection_including(*args, &block); end + def a_collection_starting_with(*args, &block); end + def a_falsey_value(*args, &block); end + def a_falsy_value(*args, &block); end + def a_hash_including(*args, &block); end + def a_kind_of(*args, &block); end + def a_nil_value(*args, &block); end + def a_range_covering(*args, &block); end + def a_string_ending_with(*args, &block); end + def a_string_including(*args, &block); end + def a_string_matching(*args, &block); end + def a_string_starting_with(*args, &block); end + def a_truthy_value(*args, &block); end + def a_value(*args, &block); end + def a_value_between(*args, &block); end + def a_value_within(*args, &block); end + def aggregate_failures(label = nil, metadata = nil, &block); end + def all(expected); end + def an_instance_of(*args, &block); end + def an_object_eq_to(*args, &block); end + def an_object_eql_to(*args, &block); end + def an_object_equal_to(*args, &block); end + def an_object_existing(*args, &block); end + def an_object_having_attributes(*args, &block); end + def an_object_matching(*args, &block); end + def an_object_responding_to(*args, &block); end + def an_object_satisfying(*args, &block); end + def be(*args); end + def be_a(klass); end + def be_a_kind_of(expected); end + def be_an(klass); end + def be_an_instance_of(expected); end + def be_between(min, max); end + def be_falsey; end + def be_falsy(*args, &block); end + def be_instance_of(expected); end + def be_kind_of(expected); end + def be_nil; end + def be_truthy; end + def be_within(delta); end + def change(receiver = nil, message = nil, &block); end + def changing(*args, &block); end + def contain_exactly(*items); end + def containing_exactly(*args, &block); end + def cover(*values); end + def covering(*args, &block); end + def end_with(*expected); end + def ending_with(*args, &block); end + def eq(expected); end + def eq_to(*args, &block); end + def eql(expected); end + def eql_to(*args, &block); end + def equal(expected); end + def equal_to(*args, &block); end + def exist(*args); end + def existing(*args, &block); end + def expect(value = nil, &block); end + def have_attributes(expected); end + def having_attributes(*args, &block); end + def include(*expected); end + def including(*args, &block); end + def match(expected); end + def match_array(items); end + def match_regex(*args, &block); end + def matching(*args, &block); end + def method_missing(method, *args, &block); end + def output(expected = nil); end + def raise_error(error = nil, message = nil, &block); end + def raise_exception(error = nil, message = nil, &block); end + def raising(*args, &block); end + def respond_to(*names); end + def respond_to_missing?(method, *arg1); end + def responding_to(*args, &block); end + def satisfy(description = nil, &block); end + def satisfying(*args, &block); end + def self.alias_matcher(*args, &block); end + def self.clear_generated_description; end + def self.configuration; end + def self.generated_description; end + def self.is_a_describable_matcher?(obj); end + def self.is_a_matcher?(obj); end + def self.last_description; end + def self.last_expectation_handler; end + def self.last_expectation_handler=(arg0); end + def self.last_matcher; end + def self.last_matcher=(arg0); end + def start_with(*expected); end + def starting_with(*args, &block); end + def throw_symbol(expected_symbol = nil, expected_arg = nil); end + def throwing(*args, &block); end + def within(*args, &block); end + def yield_control; end + def yield_successive_args(*args); end + def yield_with_args(*args); end + def yield_with_no_args; end + def yielding_control(*args, &block); end + def yielding_successive_args(*args, &block); end + def yielding_with_args(*args, &block); end + def yielding_with_no_args(*args, &block); end + extend RSpec::Matchers::DSL +end +module RSpec::Matchers::EnglishPhrasing + def self.list(obj); end + def self.split_words(sym); end +end +module RSpec::Matchers::Composable + def &(matcher); end + def ===(value); end + def and(matcher); end + def description_of(object); end + def or(matcher); end + def self.should_enumerate?(item); end + def self.surface_descriptions_in(item); end + def self.unreadable_io?(object); end + def should_enumerate?(item); end + def surface_descriptions_in(item); end + def unreadable_io?(object); end + def values_match?(expected, actual); end + def with_matchers_cloned(object); end + def |(matcher); end +end +class RSpec::Matchers::Composable::DescribableItem < Struct + def inspect; end + def item; end + def item=(_); end + def pretty_print(pp); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +module RSpec::Matchers::BuiltIn +end +class RSpec::Matchers::BuiltIn::BaseMatcher + def actual; end + def actual_formatted; end + def assert_ivars(*expected_ivars); end + def description; end + def diffable?; end + def expected; end + def expected_formatted; end + def expects_call_stack_jump?; end + def initialize(expected = nil); end + def match_unless_raises(*exceptions); end + def matcher_name; end + def matcher_name=(arg0); end + def matches?(actual); end + def present_ivars; end + def rescued_exception; end + def self.matcher_name; end + def self.underscore(camel_cased_word); end + def supports_block_expectations?; end + include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + include RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + include RSpec::Matchers::Composable +end +module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + def improve_hash_formatting(inspect_string); end + def self.improve_hash_formatting(inspect_string); end +end +module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + def failure_message; end + def failure_message_when_negated; end + def self.has_default_failure_messages?(matcher); end +end +module RSpec::Matchers::DSL + def alias_matcher(new_name, old_name, options = nil, &description_override); end + def define(name, &declarations); end + def define_negated_matcher(negated_name, base_name, &description_override); end + def matcher(name, &declarations); end + def warn_about_block_args(name, declarations); end +end +module RSpec::Matchers::DSL::Macros + def assign_attributes(attr_names); end + def chain(method_name, *attr_names, &definition); end + def define_user_override(method_name, user_def, &our_def); end + def description(&definition); end + def diffable; end + def failure_message(&definition); end + def failure_message_when_negated(&definition); end + def match(options = nil, &match_block); end + def match_unless_raises(expected_exception = nil, &match_block); end + def match_when_negated(&match_block); end + def supports_block_expectations; end +end +module RSpec::Matchers::DSL::Macros::Deprecated + def failure_message_for_should(&definition); end + def failure_message_for_should_not(&definition); end + def match_for_should(&definition); end + def match_for_should_not(&definition); end +end +module RSpec::Matchers::DSL::DefaultImplementations + def chained_method_clause_sentences; end + def description; end + def diffable?; end + def expects_call_stack_jump?; end + def supports_block_expectations?; end + include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages +end +class RSpec::Matchers::DSL::Matcher + def actual; end + def actual_arg_for(block); end + def block_arg; end + def expected; end + def expected_as_array; end + def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end + def inspect; end + def method_missing(method, *args, &block); end + def name; end + def rescued_exception; end + def respond_to_missing?(method, include_private = nil); end + extend RSpec::Matchers::DSL::Macros + extend RSpec::Matchers::DSL::Macros::Deprecated + include RSpec::Matchers + include RSpec::Matchers::Composable + include RSpec::Matchers::DSL::DefaultImplementations +end +class RSpec::Matchers::MatcherDelegator + def base_matcher; end + def initialize(base_matcher); end + def initialize_copy(other); end + def method_missing(*args, &block); end + def respond_to_missing?(name, include_all = nil); end + include RSpec::Matchers::Composable +end +class RSpec::Matchers::AliasedMatcher < RSpec::Matchers::MatcherDelegator + def description; end + def failure_message; end + def failure_message_when_negated; end + def initialize(base_matcher, description_block); end + def method_missing(*arg0); end +end +class RSpec::Matchers::AliasedMatcherWithOperatorSupport < RSpec::Matchers::AliasedMatcher +end +class RSpec::Matchers::AliasedNegatedMatcher < RSpec::Matchers::AliasedMatcher + def does_not_match?(*args, &block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(*args, &block); end + def optimal_failure_message(same, inverted); end +end +class RSpec::Matchers::ExpectedsForMultipleDiffs + def diffs(differ, actual); end + def initialize(expected_list); end + def message_with_diff(message, differ, actual); end + def self.diff_label_for(matcher); end + def self.for_many_matchers(matchers); end + def self.from(expected); end + def self.truncated(description); end +end +module RSpec::Support + def self.require_rspec_expectations(f); end + def self.require_rspec_matchers(f); end +end +module RSpec::Expectations + def self.configuration; end + def self.differ; end + def self.fail_with(message, expected = nil, actual = nil); end +end +class RSpec::Expectations::ExpectationTarget + def initialize(value); end + def self.for(value, block); end + def target; end + include RSpec::Expectations::ExpectationTarget::InstanceMethods +end +module RSpec::Expectations::ExpectationTarget::UndefinedValue +end +module RSpec::Expectations::ExpectationTarget::InstanceMethods + def not_to(matcher = nil, message = nil, &block); end + def prevent_operator_matchers(verb); end + def to(matcher = nil, message = nil, &block); end + def to_not(matcher = nil, message = nil, &block); end +end +class RSpec::Expectations::BlockExpectationTarget < RSpec::Expectations::ExpectationTarget + def enforce_block_expectation(matcher); end + def not_to(matcher, message = nil, &block); end + def supports_block_expectations?(matcher); end + def to(matcher, message = nil, &block); end + def to_not(matcher, message = nil, &block); end +end +module RSpec::Expectations::Syntax + def default_should_host; end + def disable_expect(syntax_host = nil); end + def disable_should(syntax_host = nil); end + def enable_expect(syntax_host = nil); end + def enable_should(syntax_host = nil); end + def expect_enabled?(syntax_host = nil); end + def self.default_should_host; end + def self.disable_expect(syntax_host = nil); end + def self.disable_should(syntax_host = nil); end + def self.enable_expect(syntax_host = nil); end + def self.enable_should(syntax_host = nil); end + def self.expect_enabled?(syntax_host = nil); end + def self.should_enabled?(syntax_host = nil); end + def self.warn_about_should!; end + def self.warn_about_should_unless_configured(method_name); end + def should_enabled?(syntax_host = nil); end + def warn_about_should!; end + def warn_about_should_unless_configured(method_name); end +end +class BasicObject + def should(matcher = nil, message = nil, &block); end + def should_not(matcher = nil, message = nil, &block); end +end +class RSpec::Expectations::Configuration + def add_should_and_should_not_to(*modules); end + def backtrace_formatter; end + def backtrace_formatter=(arg0); end + def color?; end + def false_positives_handler; end + def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end + def include_chain_clauses_in_custom_matcher_descriptions?; end + def initialize; end + def max_formatted_output_length=(length); end + def on_potential_false_positives; end + def on_potential_false_positives=(behavior); end + def reset_syntaxes_to_default; end + def syntax; end + def syntax=(values); end + def warn_about_potential_false_positives=(boolean); end + def warn_about_potential_false_positives?; end +end +module RSpec::Expectations::Configuration::NullBacktraceFormatter + def self.format_backtrace(backtrace); end +end +class InvalidName___Class_0x00___Differ_2 +end +module RSpec::Expectations::ExpectationHelper + def self.check_message(msg); end + def self.handle_failure(matcher, message, failure_message_method); end + def self.modern_matcher_from(matcher); end + def self.with_matcher(handler, matcher, message); end +end +class RSpec::Expectations::PositiveExpectationHandler + def self.handle_matcher(actual, initial_matcher, message = nil, &block); end + def self.opposite_should_method; end + def self.should_method; end + def self.verb; end +end +class RSpec::Expectations::NegativeExpectationHandler + def self.does_not_match?(matcher, actual, &block); end + def self.handle_matcher(actual, initial_matcher, message = nil, &block); end + def self.opposite_should_method; end + def self.should_method; end + def self.verb; end +end +class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator + def initialize(matcher); end + def self.wrap(matcher); end +end +class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter + def failure_message; end + def failure_message_when_negated; end + def self.interface_matches?(matcher); end +end +class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter + def failure_message; end + def failure_message_when_negated; end + def self.interface_matches?(matcher); end +end +module RSpec::Expectations::Version +end +class RSpec::Expectations::ExpectationNotMetError < Exception +end +class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError +end diff --git a/sorbet/rbi/gems/rspec-mocks.rbi b/sorbet/rbi/gems/rspec-mocks.rbi new file mode 100644 index 0000000..e1299c8 --- /dev/null +++ b/sorbet/rbi/gems/rspec-mocks.rbi @@ -0,0 +1,822 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: true +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-mocks/all/rspec-mocks.rbi +# +# rspec-mocks-3.8.1 +module RSpec +end +module RSpec::Mocks + def self.allow_message(subject, message, opts = nil, &block); end + def self.configuration; end + def self.error_generator; end + def self.expect_message(subject, message, opts = nil, &block); end + def self.setup; end + def self.space; end + def self.teardown; end + def self.verify; end + def self.with_temporary_scope; end +end +class RSpec::Mocks::InstanceMethodStasher + def handle_restoration_failures; end + def initialize(object, method); end + def method_defined_directly_on_klass?; end + def method_defined_on_klass?(klass = nil); end + def method_is_stashed?; end + def method_owned_by_klass?; end + def original_method; end + def restore; end + def stash; end +end +class RSpec::Mocks::MethodDouble + def add_default_stub(*args, &implementation); end + def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end + def add_simple_expectation(method_name, response, error_generator, backtrace_line); end + def add_simple_stub(method_name, response); end + def add_stub(error_generator, expectation_ordering, expected_from, opts = nil, &implementation); end + def build_expectation(error_generator, expectation_ordering); end + def clear; end + def configure_method; end + def define_proxy_method; end + def definition_target; end + def expectations; end + def initialize(object, method_name, proxy); end + def message_expectation_class; end + def method_name; end + def method_stasher; end + def new_rspec_prepended_module; end + def object; end + def object_singleton_class; end + def original_implementation_callable; end + def original_method; end + def proxy_method_invoked(_obj, *args, &block); end + def raise_method_not_stubbed_error; end + def remove_method_from_definition_target; end + def remove_stub; end + def remove_stub_if_present; end + def reset; end + def restore_original_method; end + def restore_original_visibility; end + def save_original_implementation_callable!; end + def setup_simple_method_double(method_name, response, collection, error_generator = nil, backtrace_line = nil); end + def show_frozen_warning; end + def stubs; end + def usable_rspec_prepended_module; end + def verify; end + def visibility; end +end +class RSpec::Mocks::MethodDouble::RSpecPrependedModule < Module +end +module RSpec::Mocks::ArgumentMatchers + def a_kind_of(klass); end + def an_instance_of(klass); end + def any_args; end + def anything; end + def array_including(*args); end + def boolean; end + def duck_type(*args); end + def hash_excluding(*args); end + def hash_including(*args); end + def hash_not_including(*args); end + def instance_of(klass); end + def kind_of(klass); end + def no_args; end + def self.anythingize_lonely_keys(*args); end +end +class RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def self.inherited(subklass); end + def self.new(*arg0); end +end +class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def description; end +end +class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def ===(_other); end + def description; end +end +class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def description; end +end +class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def ===(value); end + def description; end +end +class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def ===(predicate, actual); end + def description(name); end + def formatted_expected_hash; end + def initialize(expected); end +end +class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def ===(actual); end + def description; end +end +class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def ===(actual); end + def description; end +end +class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher + def ===(actual); end + def description; end + def formatted_expected_values; end + def initialize(expected); end +end +class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher + def ===(value); end + def description; end + def initialize(*methods_to_respond_to); end +end +class RSpec::Mocks::ArgumentMatchers::InstanceOf + def ===(actual); end + def description; end + def initialize(klass); end +end +class RSpec::Mocks::ArgumentMatchers::KindOf + def ===(actual); end + def description; end + def initialize(klass); end +end +class RSpec::Mocks::ObjectReference + def self.anonymous_module?(mod); end + def self.for(object_module_or_name, allow_direct_object_refs = nil); end + def self.name_of(mod); end +end +class RSpec::Mocks::DirectObjectReference + def const_to_replace; end + def defined?; end + def description; end + def initialize(object); end + def target; end + def when_loaded; end +end +class RSpec::Mocks::NamedObjectReference + def const_to_replace; end + def defined?; end + def description; end + def initialize(const_name); end + def object; end + def target; end + def when_loaded; end +end +module RSpec::Mocks::ExampleMethods + def allow(target); end + def allow_any_instance_of(klass); end + def allow_message_expectations_on_nil; end + def class_double(doubled_class, *args); end + def class_spy(*args); end + def double(*args); end + def expect_any_instance_of(klass); end + def have_received(method_name, &block); end + def hide_const(constant_name); end + def instance_double(doubled_class, *args); end + def instance_spy(*args); end + def object_double(object_or_name, *args); end + def object_spy(*args); end + def receive(method_name, &block); end + def receive_message_chain(*messages, &block); end + def receive_messages(message_return_value_hash); end + def self.declare_double(type, *args); end + def self.declare_verifying_double(type, ref, *args); end + def self.extended(object); end + def self.included(klass); end + def spy(*args); end + def stub_const(constant_name, value, options = nil); end + def without_partial_double_verification; end + include RSpec::Mocks::ArgumentMatchers +end +module RSpec::Mocks::ExampleMethods::ExpectHost + def expect(target); end +end +class RSpec::Mocks::Proxy + def add_message_expectation(method_name, opts = nil, &block); end + def add_simple_expectation(method_name, response, location); end + def add_simple_stub(method_name, response); end + def add_stub(method_name, opts = nil, &implementation); end + def as_null_object; end + def build_expectation(method_name); end + def check_for_unexpected_arguments(expectation); end + def ensure_implemented(*_args); end + def find_almost_matching_expectation(method_name, *args); end + def find_almost_matching_stub(method_name, *args); end + def find_best_matching_expectation_for(method_name); end + def find_matching_expectation(method_name, *args); end + def find_matching_method_stub(method_name, *args); end + def has_negative_expectation?(message); end + def initialize(object, order_group, options = nil); end + def message_received(message, *args, &block); end + def messages_arg_list; end + def method_double_for(message); end + def method_double_if_exists_for_message(message); end + def null_object?; end + def object; end + def original_method_handle_for(_message); end + def prepended_modules_of_singleton_class; end + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + def raise_unexpected_message_error(method_name, args); end + def received_message?(method_name, *args, &block); end + def record_message_received(message, *args, &block); end + def remove_stub(method_name); end + def remove_stub_if_present(method_name); end + def replay_received_message_on(expectation, &block); end + def reset; end + def self.prepended_modules_of(klass); end + def verify; end + def visibility_for(_method_name); end +end +class RSpec::Mocks::Proxy::SpecificMessage < Struct + def ==(expectation); end + def args; end + def args=(_); end + def message; end + def message=(_); end + def object; end + def object=(_); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Mocks::TestDoubleProxy < RSpec::Mocks::Proxy + def reset; end +end +class RSpec::Mocks::PartialDoubleProxy < RSpec::Mocks::Proxy + def add_simple_expectation(method_name, response, location); end + def add_simple_stub(method_name, response); end + def any_instance_class_recorder_observing_method?(klass, method_name); end + def message_received(message, *args, &block); end + def original_method_handle_for(message); end + def reset; end + def visibility_for(method_name); end +end +module RSpec::Mocks::PartialClassDoubleProxyMethods + def initialize(source_space, *args); end + def method_double_from_ancestor_for(message); end + def original_method_handle_for(message); end + def original_unbound_method_handle_from_ancestor_for(message); end + def superclass_proxy; end +end +class RSpec::Mocks::PartialClassDoubleProxy < RSpec::Mocks::PartialDoubleProxy + include RSpec::Mocks::PartialClassDoubleProxyMethods +end +class RSpec::Mocks::ProxyForNil < RSpec::Mocks::PartialDoubleProxy + def add_message_expectation(method_name, opts = nil, &block); end + def add_stub(method_name, opts = nil, &implementation); end + def disallow_expectations; end + def disallow_expectations=(arg0); end + def initialize(order_group); end + def raise_error(method_name); end + def set_expectation_behavior; end + def warn(method_name); end + def warn_about_expectations; end + def warn_about_expectations=(arg0); end + def warn_or_raise!(method_name); end +end +module RSpec::Mocks::TestDouble + def ==(other); end + def __build_mock_proxy(order_group); end + def __build_mock_proxy_unless_expired(order_group); end + def __disallow_further_usage!; end + def __mock_proxy; end + def __raise_expired_error; end + def as_null_object; end + def assign_stubs(stubs); end + def freeze; end + def initialize(name = nil, stubs = nil); end + def initialize_copy(other); end + def inspect; end + def method_missing(message, *args, &block); end + def null_object?; end + def respond_to?(message, incl_private = nil); end + def to_s; end +end +class RSpec::Mocks::Double + include RSpec::Mocks::TestDouble +end +module RSpec::Mocks::TestDoubleFormatter + def self.format(dbl, unwrap = nil); end + def self.name_desc(dbl); end + def self.type_desc(dbl); end + def self.verified_module_desc(dbl); end +end +class RSpec::Mocks::ArgumentListMatcher + def args_match?(*args); end + def ensure_expected_args_valid!; end + def expected_args; end + def initialize(*expected_args); end + def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end + def resolve_expected_args_based_on(actual_args); end +end +class RSpec::Mocks::SimpleMessageExpectation + def called_max_times?; end + def initialize(message, response, error_generator, backtrace_line = nil); end + def invoke(*_); end + def matches?(message, *_); end + def unadvise(_); end + def verify_messages_received; end +end +class RSpec::Mocks::MessageExpectation + def and_call_original; end + def and_raise(*args); end + def and_return(first_value, *values); end + def and_throw(*args); end + def and_wrap_original(&block); end + def and_yield(*args, &block); end + def at_least(n, &block); end + def at_most(n, &block); end + def exactly(n, &block); end + def inspect; end + def never; end + def once(&block); end + def ordered(&block); end + def thrice(&block); end + def times(&block); end + def to_s; end + def twice(&block); end + def with(*args, &block); end + include RSpec::Mocks::MessageExpectation::ImplementationDetails +end +module RSpec::Mocks::MessageExpectation::ImplementationDetails + def actual_received_count_matters?; end + def additional_expected_calls; end + def advise(*args); end + def and_yield_receiver_to_implementation; end + def argument_list_matcher=(arg0); end + def called_max_times?; end + def description_for(verb); end + def ensure_expected_ordering_received!; end + def error_generator; end + def error_generator=(arg0); end + def exception_source_id; end + def expectation_count_type; end + def expected_args; end + def expected_from=(arg0); end + def expected_messages_received?; end + def expected_received_count=(arg0); end + def generate_error; end + def has_been_invoked?; end + def ignoring_args?; end + def implementation; end + def implementation=(arg0); end + def increase_actual_received_count!; end + def initial_implementation_action=(action); end + def initialize(error_generator, expectation_ordering, expected_from, method_double, type = nil, opts = nil, &implementation_block); end + def inner_implementation_action=(action); end + def invoke(parent_stub, *args, &block); end + def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end + def invoke_without_incrementing_received_count(parent_stub, *args, &block); end + def matches?(message, *args); end + def matches_at_least_count?; end + def matches_at_most_count?; end + def matches_exact_count?; end + def matches_name_but_not_args(message, *args); end + def message; end + def negative?; end + def negative_expectation_for?(message); end + def ordered?; end + def orig_object; end + def raise_already_invoked_error_if_necessary(calling_customization); end + def raise_out_of_order_error; end + def raise_unexpected_message_args_error(args_for_multiple_calls); end + def safe_invoke(parent_stub, *args, &block); end + def set_expected_received_count(relativity, n); end + def similar_messages; end + def terminal_implementation_action=(action); end + def type; end + def unadvise(args); end + def verify_messages_received; end + def warn_about_stub_override; end + def wrap_original(method_name, &block); end + def yield_receiver_to_implementation_block?; end +end +class RSpec::Mocks::AndYieldImplementation + def call(*_args_to_ignore, &block); end + def initialize(args_to_yield, eval_context, error_generator); end +end +class RSpec::Mocks::AndReturnImplementation + def call(*_args_to_ignore, &_block); end + def initialize(values_to_return); end +end +class RSpec::Mocks::Implementation + def actions; end + def call(*args, &block); end + def initial_action; end + def initial_action=(arg0); end + def inner_action; end + def inner_action=(arg0); end + def present?; end + def terminal_action; end + def terminal_action=(arg0); end +end +class RSpec::Mocks::AndWrapOriginalImplementation + def call(*args, &block); end + def cannot_modify_further_error; end + def initial_action=(_value); end + def initialize(method, block); end + def inner_action; end + def inner_action=(_value); end + def present?; end + def terminal_action=(_value); end +end +class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < StandardError +end +class RSpec::Mocks::OrderGroup + def clear; end + def consume; end + def empty?; end + def expectation_for(message); end + def expectations_invoked_in_order?; end + def expected_invocations; end + def handle_order_constraint(expectation); end + def initialize; end + def invoked(message); end + def invoked_expectations; end + def ready_for?(expectation); end + def register(expectation); end + def remaining_expectations; end + def verify_invocation_order(expectation); end +end +class RSpec::Mocks::MockExpectationError < Exception +end +class RSpec::Mocks::ExpiredTestDoubleError < RSpec::Mocks::MockExpectationError +end +class RSpec::Mocks::OutsideOfExampleError < StandardError +end +class RSpec::Mocks::MockExpectationAlreadyInvokedError < Exception +end +class RSpec::Mocks::CannotSupportArgMutationsError < StandardError +end +class RSpec::Mocks::UnsupportedMatcherError < StandardError +end +class RSpec::Mocks::NegationUnsupportedError < StandardError +end +class RSpec::Mocks::VerifyingDoubleNotDefinedError < StandardError +end +class RSpec::Mocks::ErrorGenerator + def __raise(message, backtrace_line = nil, source_id = nil); end + def arg_list(args); end + def count_message(count, expectation_count_type = nil); end + def default_error_message(expectation, expected_args, actual_args); end + def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end + def diff_message(expected_args, actual_args); end + def differ; end + def error_message(expectation, args_for_multiple_calls); end + def expectation_on_nil_message(method_name); end + def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end + def format_args(args); end + def format_received_args(args_for_multiple_calls); end + def group_count(index, args); end + def grouped_args(args); end + def initialize(target = nil); end + def intro(unwrapped = nil); end + def list_of_exactly_one_string?(args); end + def method_call_args_description(args, generic_prefix = nil, matcher_prefix = nil); end + def notify(*args); end + def opts; end + def opts=(arg0); end + def prepend_to_backtrace(exception, line); end + def raise_already_invoked_error(message, calling_customization); end + def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end + def raise_double_negation_error(wrapped_expression); end + def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = nil, source_id = nil); end + def raise_expectation_on_mocked_method(method); end + def raise_expectation_on_nil_error(method_name); end + def raise_expectation_on_unstubbed_method(method); end + def raise_expired_test_double_error; end + def raise_have_received_disallowed(type, reason); end + def raise_invalid_arguments_error(verifier); end + def raise_method_not_stubbed_error(method_name); end + def raise_missing_block_error(args_to_yield); end + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + def raise_non_public_error(method_name, visibility); end + def raise_only_valid_on_a_partial_double(method); end + def raise_out_of_order_error(message); end + def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = nil); end + def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = nil); end + def raise_unexpected_message_error(message, args); end + def raise_unimplemented_error(doubled_module, method_name, object); end + def raise_verifying_double_not_defined_error(ref); end + def raise_wrong_arity_error(args_to_yield, signature); end + def received_part_of_expectation_error(actual_received_count, args); end + def times(count); end + def unexpected_arguments_message(expected_args_string, actual_args_string); end + def unpack_string_args(formatted_expected_args, actual_args); end +end +class RSpec::Mocks::RootSpace + def any_instance_proxy_for(*_args); end + def any_instance_recorder_for(*_args); end + def any_instance_recorders_from_ancestry_of(_object); end + def new_scope; end + def proxy_for(*_args); end + def raise_lifecycle_message; end + def register_constant_mutator(_mutator); end + def registered?(_object); end + def reset_all; end + def superclass_proxy_for(*_args); end + def verify_all; end +end +class RSpec::Mocks::Space + def any_instance_mutex; end + def any_instance_proxy_for(klass); end + def any_instance_recorder_for(klass, only_return_existing = nil); end + def any_instance_recorder_not_found_for(id, klass); end + def any_instance_recorders; end + def any_instance_recorders_from_ancestry_of(object); end + def class_proxy_with_callback_verification_strategy(object, strategy); end + def constant_mutator_for(name); end + def ensure_registered(object); end + def id_for(object); end + def initialize; end + def new_mutex; end + def new_scope; end + def proxies; end + def proxies_of(klass); end + def proxy_for(object); end + def proxy_mutex; end + def proxy_not_found_for(id, object); end + def register_constant_mutator(mutator); end + def registered?(object); end + def reset_all; end + def superclass_proxy_for(klass); end + def superclass_proxy_not_found_for(id, object); end + def verify_all; end +end +class RSpec::Mocks::NestedSpace < RSpec::Mocks::Space + def any_instance_recorder_not_found_for(id, klass); end + def constant_mutator_for(name); end + def initialize(parent); end + def proxies_of(klass); end + def proxy_not_found_for(id, object); end + def registered?(object); end +end +class RSpec::Mocks::Constant + def hidden=(arg0); end + def hidden?; end + def initialize(name); end + def inspect; end + def mutated?; end + def name; end + def original_value; end + def original_value=(arg0); end + def previously_defined=(arg0); end + def previously_defined?; end + def self.original(name); end + def self.unmutated(name); end + def stubbed=(arg0); end + def stubbed?; end + def to_s; end + def valid_name=(arg0); end + def valid_name?; end + extend RSpec::Support::RecursiveConstMethods +end +class RSpec::Mocks::ConstantMutator + def self.hide(constant_name); end + def self.mutate(mutator); end + def self.raise_on_invalid_const; end + def self.stub(constant_name, value, options = nil); end + extend RSpec::Support::RecursiveConstMethods +end +class RSpec::Mocks::ConstantMutator::BaseMutator + def full_constant_name; end + def idempotently_reset; end + def initialize(full_constant_name, mutated_value, transfer_nested_constants); end + def original_value; end + def to_constant; end + include RSpec::Support::RecursiveConstMethods +end +class RSpec::Mocks::ConstantMutator::ConstantHider < RSpec::Mocks::ConstantMutator::BaseMutator + def mutate; end + def reset; end + def to_constant; end +end +class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < RSpec::Mocks::ConstantMutator::BaseMutator + def initialize(*args); end + def mutate; end + def reset; end + def should_transfer_nested_constants?; end + def to_constant; end + def transfer_nested_constants; end + def verify_constants_to_transfer!; end +end +class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < RSpec::Mocks::ConstantMutator::BaseMutator + def mutate; end + def name_for(parent, name); end + def reset; end + def to_constant; end +end +module RSpec::Mocks::TargetDelegationClassMethods + def delegate_not_to(matcher_method, options = nil); end + def delegate_to(matcher_method); end + def disallow_negation(method_name); end +end +module RSpec::Mocks::TargetDelegationInstanceMethods + def define_matcher(matcher, name, &block); end + def matcher_allowed?(matcher); end + def raise_negation_unsupported(method_name, matcher); end + def raise_unsupported_matcher(method_name, matcher); end + def target; end +end +class RSpec::Mocks::TargetBase + def initialize(target); end + extend RSpec::Mocks::TargetDelegationClassMethods + include RSpec::Mocks::TargetDelegationInstanceMethods +end +module RSpec::Mocks::ExpectationTargetMethods + def expression; end + def not_to(matcher, &block); end + def to(matcher, &block); end + def to_not(matcher, &block); end + extend RSpec::Mocks::TargetDelegationClassMethods + include RSpec::Mocks::TargetDelegationInstanceMethods +end +class RSpec::Mocks::ExpectationTarget < RSpec::Mocks::TargetBase + include RSpec::Mocks::ExpectationTargetMethods +end +class RSpec::Mocks::AllowanceTarget < RSpec::Mocks::TargetBase + def expression; end + def not_to(matcher, *_args); end + def to(matcher, &block); end + def to_not(matcher, *_args); end +end +class RSpec::Mocks::AnyInstanceAllowanceTarget < RSpec::Mocks::TargetBase + def expression; end + def not_to(matcher, *_args); end + def to(matcher, &block); end + def to_not(matcher, *_args); end +end +class RSpec::Mocks::AnyInstanceExpectationTarget < RSpec::Mocks::TargetBase + def expression; end + def not_to(matcher, &block); end + def to(matcher, &block); end + def to_not(matcher, &block); end +end +module RSpec::Mocks::Syntax + def self.default_should_syntax_host; end + def self.disable_expect(syntax_host = nil); end + def self.disable_should(syntax_host = nil); end + def self.enable_expect(syntax_host = nil); end + def self.enable_should(syntax_host = nil); end + def self.expect_enabled?(syntax_host = nil); end + def self.should_enabled?(syntax_host = nil); end + def self.warn_about_should!; end + def self.warn_unless_should_configured(method_name, replacement = nil); end +end +class BasicObject + def as_null_object; end + def null_object?; end + def received_message?(message, *args, &block); end + def should_not_receive(message, &block); end + def should_receive(message, opts = nil, &block); end + def stub(message_or_hash, opts = nil, &block); end + def stub_chain(*chain, &blk); end + def unstub(message); end +end +class Class < Module + def any_instance; end +end +class RSpec::Mocks::Configuration + def add_stub_and_should_receive_to(*modules); end + def allow_message_expectations_on_nil; end + def allow_message_expectations_on_nil=(arg0); end + def before_verifying_doubles(&block); end + def color?; end + def initialize; end + def patch_marshal_to_support_partial_doubles=(val); end + def reset_syntaxes_to_default; end + def syntax; end + def syntax=(*values); end + def temporarily_suppress_partial_double_verification; end + def temporarily_suppress_partial_double_verification=(arg0); end + def transfer_nested_constants=(arg0); end + def transfer_nested_constants?; end + def verify_doubled_constant_names=(arg0); end + def verify_doubled_constant_names?; end + def verify_partial_doubles=(val); end + def verify_partial_doubles?; end + def verifying_double_callbacks; end + def when_declaring_verifying_double(&block); end + def yield_receiver_to_any_instance_implementation_blocks=(arg0); end + def yield_receiver_to_any_instance_implementation_blocks?; end +end +class RSpec::Mocks::VerifyingMessageExpectation < RSpec::Mocks::MessageExpectation + def initialize(*args); end + def method_reference; end + def method_reference=(arg0); end + def validate_expected_arguments!; end + def with(*args, &block); end +end +class RSpec::Mocks::MethodReference + def defined?; end + def implemented?; end + def initialize(object_reference, method_name); end + def original_method; end + def self.for(object_reference, method_name); end + def self.instance_method_visibility_for(klass, method_name); end + def self.method_defined_at_any_visibility?(klass, method_name); end + def self.method_visibility_for(object, method_name); end + def unimplemented?; end + def visibility; end + def with_signature; end +end +class RSpec::Mocks::InstanceMethodReference < RSpec::Mocks::MethodReference + def find_method(mod); end + def method_defined?(mod); end + def method_implemented?(mod); end + def visibility_from(mod); end +end +class RSpec::Mocks::ObjectMethodReference < RSpec::Mocks::MethodReference + def find_method(object); end + def method_defined?(object); end + def method_implemented?(object); end + def self.for(object_reference, method_name); end + def visibility_from(object); end +end +class RSpec::Mocks::ClassNewMethodReference < RSpec::Mocks::ObjectMethodReference + def self.applies_to?(method_name); end + def with_signature; end +end +class RSpec::Mocks::CallbackInvocationStrategy + def call(doubled_module); end +end +class RSpec::Mocks::NoCallbackInvocationStrategy + def call(_doubled_module); end +end +module RSpec::Mocks::VerifyingProxyMethods + def add_message_expectation(method_name, opts = nil, &block); end + def add_simple_stub(method_name, *args); end + def add_stub(method_name, opts = nil, &implementation); end + def ensure_implemented(method_name); end + def ensure_publicly_implemented(method_name, _object); end +end +class RSpec::Mocks::VerifyingProxy < RSpec::Mocks::TestDoubleProxy + def initialize(object, order_group, doubled_module, method_reference_class); end + def method_reference; end + def validate_arguments!(method_name, args); end + def visibility_for(method_name); end + include RSpec::Mocks::VerifyingProxyMethods +end +class RSpec::Mocks::VerifyingPartialDoubleProxy < RSpec::Mocks::PartialDoubleProxy + def ensure_implemented(_method_name); end + def initialize(object, expectation_ordering, optional_callback_invocation_strategy = nil); end + def method_reference; end + include RSpec::Mocks::VerifyingProxyMethods +end +class RSpec::Mocks::VerifyingPartialClassDoubleProxy < RSpec::Mocks::VerifyingPartialDoubleProxy + include RSpec::Mocks::PartialClassDoubleProxyMethods +end +class RSpec::Mocks::VerifyingMethodDouble < RSpec::Mocks::MethodDouble + def add_expectation(*args, &block); end + def add_stub(*args, &block); end + def initialize(object, method_name, proxy, method_reference); end + def message_expectation_class; end + def proxy_method_invoked(obj, *args, &block); end + def validate_arguments!(actual_args); end +end +class RSpec::Mocks::VerifyingExistingMethodDouble < RSpec::Mocks::VerifyingMethodDouble + def initialize(object, method_name, proxy); end + def self.for(object, method_name, proxy); end + def unimplemented?; end + def with_signature; end +end +class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < RSpec::Mocks::VerifyingExistingMethodDouble + def with_signature; end +end +module RSpec::Mocks::VerifyingDouble + def __send__(name, *args, &block); end + def initialize(doubled_module, *args); end + def method_missing(message, *args, &block); end + def respond_to?(message, include_private = nil); end + def send(name, *args, &block); end +end +module RSpec::Mocks::VerifyingDouble::SilentIO + def self.method_missing(*arg0); end + def self.respond_to?(*arg0); end +end +class RSpec::Mocks::InstanceVerifyingDouble + def __build_mock_proxy(order_group); end + include RSpec::Mocks::TestDouble + include RSpec::Mocks::VerifyingDouble +end +module RSpec::Mocks::ObjectVerifyingDoubleMethods + def __build_mock_proxy(order_group); end + def as_stubbed_const(options = nil); end + include RSpec::Mocks::TestDouble + include RSpec::Mocks::VerifyingDouble +end +class RSpec::Mocks::ObjectVerifyingDouble + include RSpec::Mocks::ObjectVerifyingDoubleMethods +end +class RSpec::Mocks::ClassVerifyingDouble < Module + include RSpec::Mocks::ObjectVerifyingDoubleMethods +end +module RSpec::Mocks::Version +end +module RSpec::Support + def self.require_rspec_mocks(f); end +end +module RSpec::Mocks::Matchers +end +module RSpec::Mocks::Matchers::Matcher +end diff --git a/sorbet/rbi/gems/rspec-support.rbi b/sorbet/rbi/gems/rspec-support.rbi new file mode 100644 index 0000000..9dc6b86 --- /dev/null +++ b/sorbet/rbi/gems/rspec-support.rbi @@ -0,0 +1,266 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: true +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-support/all/rspec-support.rbi +# +# rspec-support-3.8.2 +module RSpec + extend RSpec::Support::Warnings +end +module RSpec::Support + def self.class_of(object); end + def self.define_optimized_require_for_rspec(lib, &require_relative); end + def self.deregister_matcher_definition(&block); end + def self.failure_notifier; end + def self.failure_notifier=(callable); end + def self.is_a_matcher?(object); end + def self.matcher_definitions; end + def self.method_handle_for(object, method_name); end + def self.notify_failure(failure, options = nil); end + def self.register_matcher_definition(&block); end + def self.require_rspec_support(f); end + def self.rspec_description_for_object(object); end + def self.thread_local_data; end + def self.warning_notifier; end + def self.warning_notifier=(arg0); end + def self.with_failure_notifier(callable); end +end +module RSpec::Support::Version +end +class RSpec::Support::ComparableVersion + def <=>(other); end + def initialize(string); end + def segments; end + def string; end + include Comparable +end +module RSpec::Support::OS + def self.windows?; end + def self.windows_file_path?; end + def windows?; end + def windows_file_path?; end +end +module RSpec::Support::Ruby + def jruby?; end + def jruby_9000?; end + def jruby_version; end + def mri?; end + def non_mri?; end + def rbx?; end + def self.jruby?; end + def self.jruby_9000?; end + def self.jruby_version; end + def self.mri?; end + def self.non_mri?; end + def self.rbx?; end +end +module RSpec::Support::RubyFeatures + def caller_locations_supported?; end + def fork_supported?; end + def kw_args_supported?; end + def module_prepends_supported?; end + def module_refinement_supported?; end + def optional_and_splat_args_supported?; end + def required_kw_args_supported?; end + def ripper_supported?; end + def self.caller_locations_supported?; end + def self.fork_supported?; end + def self.kw_args_supported?; end + def self.module_prepends_supported?; end + def self.module_refinement_supported?; end + def self.optional_and_splat_args_supported?; end + def self.required_kw_args_supported?; end + def self.ripper_supported?; end + def self.supports_exception_cause?; end + def self.supports_rebinding_module_methods?; end + def supports_exception_cause?; end + def supports_rebinding_module_methods?; end +end +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + def self.===(exception); end +end +class RSpec::CallerFilter + def self.first_non_rspec_line(skip_frames = nil, increment = nil); end +end +module RSpec::Support::Warnings + def deprecate(deprecated, options = nil); end + def warn_deprecation(message, options = nil); end + def warn_with(message, options = nil); end + def warning(text, options = nil); end +end +class RSpec::Support::EncodedString + def <<(string); end + def ==(*args, &block); end + def detect_source_encoding(string); end + def empty?(*args, &block); end + def encoding(*args, &block); end + def eql?(*args, &block); end + def initialize(string, encoding = nil); end + def lines(*args, &block); end + def matching_encoding(string); end + def remove_invalid_bytes(string); end + def self.pick_encoding(source_a, source_b); end + def source_encoding; end + def split(regex_or_string); end + def to_s; end + def to_str; end +end +class RSpec::Support::ReentrantMutex + def enter; end + def exit; end + def initialize; end + def synchronize; end +end +class RSpec::Support::DirectoryMaker + def self.directory_exists?(dirname); end + def self.generate_path(stack, part); end + def self.generate_stack(path); end + def self.mkdir_p(path); end +end +module RSpec::Support::RecursiveConstMethods + def const_defined_on?(mod, const_name); end + def constants_defined_on(mod); end + def get_const_defined_on(mod, const_name); end + def normalize_const_name(const_name); end + def recursive_const_defined?(const_name); end + def recursive_const_get(const_name); end +end +module RSpec::Support::FuzzyMatcher + def self.arrays_match?(expected_list, actual_list); end + def self.hashes_match?(expected_hash, actual_hash); end + def self.values_match?(expected, actual); end +end +class RSpec::Support::ObjectFormatter + def format(object); end + def initialize(max_formatted_output_length = nil); end + def max_formatted_output_length; end + def max_formatted_output_length=(arg0); end + def prepare_array(array); end + def prepare_element(element); end + def prepare_for_inspection(object); end + def prepare_hash(input_hash); end + def recursive_structure?(object); end + def self.default_instance; end + def self.format(object); end + def self.prepare_for_inspection(object); end + def sort_hash_keys(input_hash); end + def truncate_string(str, start_index, end_index); end + def with_entering_structure(structure); end +end +class RSpec::Support::ObjectFormatter::InspectableItem < Struct + def inspect; end + def pretty_print(pp); end + def self.[](*arg0); end + def self.members; end + def self.new(*arg0); end + def text; end + def text=(_); end +end +class RSpec::Support::ObjectFormatter::BaseInspector < Struct + def formatter; end + def formatter=(_); end + def inspect; end + def object; end + def object=(_); end + def pretty_print(pp); end + def self.[](*arg0); end + def self.can_inspect?(_object); end + def self.members; end + def self.new(*arg0); end +end +class RSpec::Support::ObjectFormatter::TimeInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def self.can_inspect?(object); end +end +class RSpec::Support::ObjectFormatter::DateTimeInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def self.can_inspect?(object); end +end +class RSpec::Support::ObjectFormatter::BigDecimalInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def self.can_inspect?(object); end +end +class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def self.can_inspect?(object); end +end +class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def klass; end + def native_object_id; end + def self.can_inspect?(object); end +end +class RSpec::Support::ObjectFormatter::DelegatorInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def self.can_inspect?(object); end +end +class RSpec::Support::ObjectFormatter::InspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def self.can_inspect?(object); end +end +class RSpec::Support::MethodSignature + def arbitrary_kw_args?; end + def classify_arity(arity = nil); end + def classify_parameters; end + def could_contain_kw_args?(args); end + def description; end + def has_kw_args_in?(args); end + def initialize(method); end + def invalid_kw_args_from(given_kw_args); end + def max_non_kw_args; end + def min_non_kw_args; end + def missing_kw_args_from(given_kw_args); end + def non_kw_args_arity_description; end + def optional_kw_args; end + def required_kw_args; end + def unlimited_args?; end + def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = nil); end +end +class RSpec::Support::MethodSignatureExpectation + def empty?; end + def expect_arbitrary_keywords; end + def expect_arbitrary_keywords=(arg0); end + def expect_unlimited_arguments; end + def expect_unlimited_arguments=(arg0); end + def initialize; end + def keywords; end + def keywords=(values); end + def max_count; end + def max_count=(number); end + def min_count; end + def min_count=(number); end +end +class RSpec::Support::BlockSignature < RSpec::Support::MethodSignature + def classify_parameters; end +end +class RSpec::Support::MethodSignatureVerifier + def arbitrary_kw_args?; end + def error_message; end + def initialize(signature, args = nil); end + def invalid_kw_args; end + def kw_args; end + def max_non_kw_args; end + def min_non_kw_args; end + def missing_kw_args; end + def non_kw_args; end + def split_args(*args); end + def unlimited_args?; end + def valid?; end + def valid_non_kw_args?; end + def with_expectation(expectation); end +end +class RSpec::Support::LooseSignatureVerifier < RSpec::Support::MethodSignatureVerifier + def split_args(*args); end +end +class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher + def has_kw_args_in?(args); end + def initialize(signature); end + def invalid_kw_args_from(_kw_args); end + def missing_kw_args_from(_kw_args); end + def non_kw_args_arity_description; end + def valid_non_kw_args?(*args); end +end diff --git a/sorbet/rbi/gems/rspec.rbi b/sorbet/rbi/gems/rspec.rbi new file mode 100644 index 0000000..89f474c --- /dev/null +++ b/sorbet/rbi/gems/rspec.rbi @@ -0,0 +1,14 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi +# +# rspec-3.8.0 +module RSpec +end +module RSpec::Version +end diff --git a/sorbet/rbi/gems/thread_safe.rbi b/sorbet/rbi/gems/thread_safe.rbi new file mode 100644 index 0000000..3bf3a53 --- /dev/null +++ b/sorbet/rbi/gems/thread_safe.rbi @@ -0,0 +1,81 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: strong +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/thread_safe/all/thread_safe.rbi +# +# thread_safe-0.3.6 +module ThreadSafe +end +module Threadsafe + def self.const_missing(name); end +end +class SynchronizedDelegator < SimpleDelegator + def initialize(obj); end + def method_missing(method, *args, &block); end + def setup; end + def teardown; end +end +class ThreadSafe::NonConcurrentCacheBackend + def [](key); end + def []=(key, value); end + def _get(key); end + def _set(key, value); end + def clear; end + def compute(key); end + def compute_if_absent(key); end + def compute_if_present(key); end + def delete(key); end + def delete_pair(key, value); end + def dupped_backend; end + def each_pair; end + def get_and_set(key, value); end + def get_or_default(key, default_value); end + def initialize(options = nil); end + def initialize_copy(other); end + def key?(key); end + def merge_pair(key, value); end + def pair?(key, expected_value); end + def replace_if_exists(key, new_value); end + def replace_pair(key, old_value, new_value); end + def size; end + def store_computed_value(key, new_value); end + def value?(value); end +end +class ThreadSafe::MriCacheBackend < ThreadSafe::NonConcurrentCacheBackend + def []=(key, value); end + def clear; end + def compute(key); end + def compute_if_absent(key); end + def compute_if_present(key); end + def delete(key); end + def delete_pair(key, value); end + def get_and_set(key, value); end + def merge_pair(key, value); end + def replace_if_exists(key, new_value); end + def replace_pair(key, old_value, new_value); end +end +class ThreadSafe::Cache < ThreadSafe::MriCacheBackend + def [](key); end + def each_key; end + def each_value; end + def empty?; end + def fetch(key, default_value = nil); end + def fetch_or_store(key, default_value = nil); end + def get(key); end + def initialize(options = nil, &block); end + def initialize_copy(other); end + def key(value); end + def keys; end + def marshal_dump; end + def marshal_load(hash); end + def populate_from(hash); end + def put(key, value); end + def put_if_absent(key, value); end + def raise_fetch_no_key; end + def validate_options_hash!(options); end + def values; end +end diff --git a/sorbet/rbi/gems/virtus.rbi b/sorbet/rbi/gems/virtus.rbi new file mode 100644 index 0000000..73c4be9 --- /dev/null +++ b/sorbet/rbi/gems/virtus.rbi @@ -0,0 +1,419 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: true +# +# If you would like to make changes to this file, great! Please create the gem's shim here: +# +# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/virtus/all/virtus.rbi +# +# virtus-1.0.5 +module Virtus + def self.coerce; end + def self.coerce=(value); end + def self.coercer(&block); end + def self.config(&block); end + def self.configuration; end + def self.extended(object); end + def self.finalize; end + def self.included(object); end + def self.model(options = nil, &block); end + def self.module(options = nil, &block); end + def self.value_object(options = nil, &block); end + def self.warn(msg); end +end +class Virtus::Equalizer < Module + def <<(key); end + def define_cmp_method; end + def define_hash_method; end + def define_inspect_method; end + def define_methods; end + def include_comparison_methods; end + def initialize(name, keys = nil); end +end +module Virtus::Equalizer::Methods + def ==(other); end + def eql?(other); end +end +module Virtus::Options + def accept_options(*new_options); end + def accepted_options; end + def add_accepted_options(new_options); end + def define_option_method(option); end + def inherited(descendant); end + def options; end + def set_options(new_options); end +end +module Virtus::TypeLookup + def determine_type(class_or_name); end + def determine_type_and_cache(class_or_name); end + def determine_type_from_descendant(descendant); end + def determine_type_from_primitive(primitive); end + def determine_type_from_string(string); end + def primitive; end + def self.extended(model); end +end +module Virtus::Model + def self.extended(descendant); end + def self.included(descendant); end +end +module Virtus::Model::Core + def self.extended(descendant); end + def self.included(descendant); end +end +module Virtus::Model::Constructor + def self.included(descendant); end +end +module Virtus::Model::MassAssignment + def self.extended(descendant); end + def self.included(descendant); end +end +module Virtus::Extensions + def self.extended(object); end +end +module Virtus::Extensions::Methods + def attribute(name, type = nil, options = nil); end + def attribute_set; end + def self.extended(descendant); end + def values(&block); end +end +module Virtus::Extensions::AllowedWriterMethods + def allowed_writer_methods; end +end +module Virtus::ConstMissingExtensions + def const_missing(name); end +end +module Virtus::ClassInclusions + def self.included(descendant); end +end +module Virtus::ClassInclusions::Methods + def allowed_writer_methods; end + def attribute_set; end +end +module Virtus::ModuleExtensions + def attribute(name, type = nil, options = nil); end + def define_attributes(object); end + def extended(object); end + def included(object); end + def self.extended(mod); end + def self.setup(mod, inclusions = nil, attribute_definitions = nil); end + include Virtus::ConstMissingExtensions +end +class Virtus::Configuration + def coerce; end + def coerce=(arg0); end + def coercer(&block); end + def constructor; end + def constructor=(arg0); end + def finalize; end + def finalize=(arg0); end + def initialize(options = nil); end + def mass_assignment; end + def mass_assignment=(arg0); end + def nullify_blank; end + def nullify_blank=(arg0); end + def required; end + def required=(arg0); end + def strict; end + def strict=(arg0); end + def to_h; end +end +class Virtus::Builder + def add_extended_hook; end + def add_included_hook; end + def config; end + def extensions; end + def initialize(conf, mod = nil); end + def mod; end + def options; end + def self.call(options, &block); end + def self.pending; end + def with_hook_context; end +end +class Virtus::ModelBuilder < Virtus::Builder +end +class Virtus::ModuleBuilder < Virtus::Builder + def add_included_hook; end +end +class Virtus::ValueObjectBuilder < Virtus::Builder + def extensions; end + def options; end +end +class Virtus::Builder::HookContext + def attribute_method; end + def builder; end + def config; end + def constructor?; end + def finalize?; end + def initialize(builder, config); end + def initialize_attribute_method; end + def mass_assignment?; end + def modules; end +end +module Virtus::ClassMethods + def allowed_methods; end + def assert_valid_name(name); end + def attribute_set; end + def attributes; end + def inherited(descendant); end + def self.extended(descendant); end + include Virtus::ConstMissingExtensions + include Virtus::Extensions::Methods +end +module Virtus::InstanceMethods + def [](name); end + def []=(name, value); end + def allowed_methods; end + def assert_valid_name(name); end + def freeze; end + def reset_attribute(attribute_name); end + def set_default_attributes!; end + def set_default_attributes; end +end +module Virtus::InstanceMethods::Constructor + def initialize(attributes = nil); end +end +module Virtus::InstanceMethods::MassAssignment + def attributes; end + def attributes=(attributes); end + def to_h; end + def to_hash; end +end +module Virtus::ValueObject + def self.included(base); end +end +module Virtus::ValueObject::InstanceMethods + def clone; end + def dup; end + def with(attribute_updates); end +end +module Virtus::ValueObject::AllowedWriterMethods + def allowed_writer_methods; end +end +module Virtus::ValueObject::ClassMethods + def attribute(name, type, options = nil); end + def equalizer; end +end +class Virtus::Coercer + def call(input); end + def initialize(type); end + def primitive; end + def success?(primitive, input); end + def type; end +end +class Virtus::AttributeSet < Module + def <<(attribute); end + def [](name); end + def []=(name, attribute); end + def coerce(attributes); end + def define_reader_method(attribute, method_name, visibility); end + def define_writer_method(attribute, method_name, visibility); end + def each; end + def finalize; end + def get(object); end + def initialize(parent = nil, attributes = nil); end + def merge(attributes); end + def merge_attributes(attributes); end + def reset; end + def self.create(descendant); end + def set(object, attributes); end + def set_defaults(object, filter = nil); end + def skip_default?(object, attribute); end + def update_index(name, attribute); end + include Enumerable +end +class Virtus::Attribute + def coerce(input); end + def coercer; end + def coercible?; end + def default_value; end + def define_accessor_methods(attribute_set); end + def finalize; end + def finalized?; end + def initialize(type, options); end + def lazy?; end + def nullify_blank?; end + def options; end + def primitive; end + def rename(name); end + def required?; end + def self.accessor(value = nil); end + def self.build(type, options = nil); end + def self.build_coercer(type, options = nil); end + def self.build_type(definition); end + def self.coerce(value = nil); end + def self.default(value = nil); end + def self.finalize(value = nil); end + def self.lazy(value = nil); end + def self.merge_options!(*arg0); end + def self.nullify_blank(value = nil); end + def self.primitive(value = nil); end + def self.required(value = nil); end + def self.strict(value = nil); end + def strict?; end + def type; end + def value_coerced?(value); end + extend DescendantsTracker + include Anonymous_Equalizer_1 + include Equalizer::Methods +end +class Virtus::Attribute::DefaultValue + def call(*arg0); end + def initialize(value); end + def self.build(*args); end + def value; end + extend DescendantsTracker +end +class Virtus::Attribute::DefaultValue::FromClonable < Virtus::Attribute::DefaultValue + def call(*arg0); end + def self.handle?(value); end +end +class Virtus::Attribute::DefaultValue::FromCallable < Virtus::Attribute::DefaultValue + def call(*args); end + def self.handle?(value); end +end +class Virtus::Attribute::DefaultValue::FromSymbol < Virtus::Attribute::DefaultValue + def call(instance, _); end + def self.handle?(value); end +end +module Anonymous_Equalizer_1 + def cmp?(comparator, other); end + def hash; end + def inspect; end +end +class Virtus::PendingAttribute + def determine_type; end + def finalize; end + def finalized?; end + def initialize(type, options); end + def name; end + def options; end + def type; end +end +class Virtus::TypeDefinition + def initialize(type); end + def initialize_primitive; end + def pending?; end + def primitive; end + def type; end +end +class Virtus::Attribute::Builder + def attribute; end + def determine_coercer; end + def determine_visibility; end + def initialize(type_definition, options); end + def initialize_attribute; end + def initialize_class; end + def initialize_coercer; end + def initialize_default_value; end + def initialize_options(options); end + def initialize_type; end + def klass; end + def options; end + def self.call(type, options = nil); end + def self.determine_type(klass, default = nil); end + def type; end + def type_definition; end +end +class Virtus::Attribute::Coercer < Virtus::Coercer + def call(value); end + def coercers; end + def initialize(type, coercers); end + def method; end + def success?(primitive, value); end +end +module Virtus::Attribute::Accessor + def defined?(instance); end + def get(instance); end + def instance_variable_name; end + def name; end + def public_reader?; end + def public_writer?; end + def self.extended(descendant); end + def set(instance, value); end + def set_default_value(instance); end +end +module Virtus::Attribute::Coercible + def set(instance, value); end +end +module Virtus::Attribute::Strict + def coerce(*arg0); end +end +module Virtus::Attribute::LazyDefault + def get(instance); end +end +module Virtus::Attribute::NullifyBlank + def coerce(input); end +end +class Virtus::Attribute::Boolean < Virtus::Attribute + def define_accessor_methods(attribute_set); end + def self.build_type(*arg0); end + def value_coerced?(value); end +end +class Virtus::Attribute::Collection < Virtus::Attribute + def coerce(value); end + def finalize; end + def finalized?; end + def member_type; end + def self.build_type(definition); end + def self.merge_options!(type, options); end +end +class Virtus::Attribute::Collection::Type < Struct + def coercion_method; end + def member_type; end + def member_type=(_); end + def primitive; end + def primitive=(_); end + def self.[](*arg0); end + def self.axiom_type?(type); end + def self.infer(type, primitive); end + def self.infer_member_type(type); end + def self.members; end + def self.new(*arg0); end + def self.pending?(primitive); end +end +class Virtus::Attribute::Hash < Virtus::Attribute + def coerce(*arg0); end + def finalize; end + def finalized?; end + def key_type; end + def self.build_type(definition); end + def self.merge_options!(type, options); end + def value_type; end +end +class Virtus::Attribute::Hash::Type < Struct + def coercion_method; end + def key_type; end + def key_type=(_); end + def primitive; end + def self.[](*arg0); end + def self.axiom_type?(type); end + def self.determine_type(type); end + def self.infer(type); end + def self.infer_key_and_value_types(type); end + def self.members; end + def self.new(*arg0); end + def self.pending?(primitive); end + def value_type; end + def value_type=(_); end +end +class Virtus::Attribute::EmbeddedValue < Virtus::Attribute + def self.build_coercer(type, _options); end + def self.build_type(definition); end + def self.handles?(klass); end +end +class Virtus::Attribute::EmbeddedValue::FromStruct < Virtus::Coercer + def call(input); end +end +class Virtus::Attribute::EmbeddedValue::FromOpenStruct < Virtus::Coercer + def call(input); end +end +class Virtus::CoercionError < StandardError + def attribute; end + def attribute_name; end + def attribute_name?; end + def build_message; end + def initialize(output, attribute); end + def output; end + def target_type; end +end diff --git a/sorbet/rbi/hidden-definitions/errors.txt b/sorbet/rbi/hidden-definitions/errors.txt new file mode 100644 index 0000000..0290c80 --- /dev/null +++ b/sorbet/rbi/hidden-definitions/errors.txt @@ -0,0 +1,2112 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi hidden-definitions + +# typed: autogenerated + +# wrong constant name +# wrong constant name +# wrong constant name > +# wrong constant name +# wrong constant name +# wrong constant name > +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name > +# wrong constant name +# wrong constant name +# uninitialized constant Abbrev +# uninitialized constant Abbrev +# wrong constant name bsearch +# wrong constant name bsearch_index +# wrong constant name collect! +# wrong constant name dig +# wrong constant name flatten! +# wrong constant name pack +# wrong constant name replace +# wrong constant name shelljoin +# wrong constant name to_h +# wrong constant name try_convert +# wrong constant name +# uninitialized constant Benchmark +# uninitialized constant Benchmark +# wrong constant name to_d +# wrong constant name to_digits +# wrong constant name ver +# wrong constant name clone +# wrong constant name +# wrong constant name environment +# wrong constant name report +# wrong constant name write +# wrong constant name github_https? +# wrong constant name lockfile_upgrade_warning? +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name fetch_spec +# wrong constant name fetchers +# wrong constant name http_proxy +# wrong constant name initialize +# wrong constant name specs +# wrong constant name specs_with_retry +# wrong constant name uri +# wrong constant name use_api +# wrong constant name user_agent +# wrong constant name initialize +# wrong constant name initialize +# wrong constant name api_fetcher? +# wrong constant name available? +# wrong constant name display_uri +# wrong constant name downloader +# wrong constant name fetch_uri +# wrong constant name initialize +# wrong constant name remote +# wrong constant name remote_uri +# wrong constant name +# wrong constant name initialize +# wrong constant name +# wrong constant name available? +# wrong constant name fetch_spec +# wrong constant name specs +# wrong constant name specs_for_names +# uninitialized constant Bundler::Fetcher::CompactIndex::ClientFetcher::Elem +# wrong constant name call +# wrong constant name fetcher +# wrong constant name fetcher= +# wrong constant name ui +# wrong constant name ui= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name compact_index_request +# wrong constant name dependency_api_uri +# wrong constant name dependency_specs +# wrong constant name get_formatted_specs_and_deps +# wrong constant name specs +# wrong constant name unmarshalled_dep_gems +# wrong constant name +# wrong constant name connection +# wrong constant name fetch +# wrong constant name initialize +# wrong constant name redirect_limit +# wrong constant name request +# wrong constant name +# wrong constant name fetch_spec +# wrong constant name specs +# wrong constant name +# wrong constant name initialize +# wrong constant name +# wrong constant name api_timeout +# wrong constant name api_timeout= +# wrong constant name disable_endpoint +# wrong constant name disable_endpoint= +# wrong constant name max_retries +# wrong constant name max_retries= +# wrong constant name redirect_limit +# wrong constant name redirect_limit= +# wrong constant name link +# wrong constant name cp_lr +# wrong constant name link_entry +# uninitialized constant Bundler::GemHelper::DEFAULT +# Did you mean? Bundler::GemHelper::DEFAULT +# uninitialized constant Bundler::GemHelper::LN_SUPPORTED +# Did you mean? Bundler::GemHelper::LN_SUPPORTED +# uninitialized constant Bundler::GemHelper::LOW_METHODS +# Did you mean? Bundler::GemHelper::LowMethods +# Bundler::GemHelper::LOW_METHODS +# uninitialized constant Bundler::GemHelper::METHODS +# Did you mean? Method +# Bundler::GemHelper::METHODS +# uninitialized constant Bundler::GemHelper::OPT_TABLE +# Did you mean? Bundler::GemHelper::OPT_TABLE +# uninitialized constant Bundler::GemHelper::RUBY +# Did you mean? Bundler::GemHelper::RUBY +# wrong constant name allowed_push_host +# wrong constant name already_tagged? +# wrong constant name base +# wrong constant name build_gem +# wrong constant name built_gem_path +# wrong constant name clean? +# wrong constant name committed? +# wrong constant name gem_key +# wrong constant name gem_push? +# wrong constant name gem_push_host +# wrong constant name gemspec +# wrong constant name git_push +# wrong constant name guard_clean +# wrong constant name initialize +# wrong constant name install +# wrong constant name install_gem +# wrong constant name name +# wrong constant name perform_git_push +# wrong constant name rubygem_push +# wrong constant name sh +# wrong constant name sh_with_input +# wrong constant name sh_with_status +# wrong constant name spec_path +# wrong constant name tag_version +# wrong constant name version +# wrong constant name version_tag +# wrong constant name +# wrong constant name gemspec +# wrong constant name install_tasks +# wrong constant name instance +# wrong constant name instance= +# wrong constant name +# wrong constant name initialize +# wrong constant name level +# wrong constant name level= +# wrong constant name locked_specs +# wrong constant name major? +# wrong constant name minor? +# wrong constant name prerelease_specified +# wrong constant name prerelease_specified= +# wrong constant name sort_versions +# wrong constant name strict +# wrong constant name strict= +# wrong constant name unlock_gems +# wrong constant name +# wrong constant name +# wrong constant name edge_options +# wrong constant name groups +# wrong constant name initialize +# wrong constant name node_options +# wrong constant name output_file +# wrong constant name output_format +# wrong constant name relations +# wrong constant name viz +# wrong constant name g +# wrong constant name initialize +# wrong constant name run +# wrong constant name +# wrong constant name +# uninitialized constant Bundler::Index::Elem +# wrong constant name initialize +# wrong constant name inject +# wrong constant name remove +# wrong constant name +# wrong constant name inject +# wrong constant name remove +# wrong constant name generate_bundler_executable_stubs +# wrong constant name generate_standalone_bundler_executable_stubs +# wrong constant name initialize +# wrong constant name post_install_messages +# wrong constant name run +# wrong constant name +# wrong constant name ambiguous_gems +# wrong constant name ambiguous_gems= +# wrong constant name install +# uninitialized constant Bundler::Molinillo::DependencyGraph::Elem +# uninitialized constant Bundler::Molinillo::DependencyGraph::Log::Elem +# wrong constant name == +# wrong constant name app_cache_dirname +# wrong constant name app_cache_path +# wrong constant name bundler_plugin_api_source? +# wrong constant name cache +# wrong constant name cached! +# wrong constant name can_lock? +# wrong constant name dependency_names +# wrong constant name dependency_names= +# wrong constant name double_check_for +# wrong constant name eql? +# wrong constant name fetch_gemspec_files +# wrong constant name gem_install_dir +# wrong constant name hash +# wrong constant name include? +# wrong constant name initialize +# wrong constant name install +# wrong constant name install_path +# wrong constant name installed? +# wrong constant name name +# wrong constant name options +# wrong constant name options_to_lock +# wrong constant name post_install +# wrong constant name remote! +# wrong constant name root +# wrong constant name specs +# wrong constant name to_lock +# wrong constant name to_s +# wrong constant name unlock! +# wrong constant name unmet_deps +# wrong constant name uri +# wrong constant name uri_hash +# wrong constant name +# wrong constant name initialize +# wrong constant name +# wrong constant name initialize +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name install +# wrong constant name install_definition +# uninitialized constant Bundler::Plugin::Installer::Git::DEFAULT_GLOB +# Did you mean? Bundler::Plugin::Installer::Git::DEFAULT_GLOB +# wrong constant name generate_bin +# wrong constant name +# uninitialized constant Bundler::Plugin::Installer::Rubygems::API_REQUEST_LIMIT +# Did you mean? Bundler::Plugin::Installer::Rubygems::API_REQUEST_SIZE +# Bundler::Plugin::Installer::Rubygems::API_REQUEST_LIMIT +# uninitialized constant Bundler::Plugin::Installer::Rubygems::API_REQUEST_SIZE +# Did you mean? Bundler::Plugin::Installer::Rubygems::API_REQUEST_SIZE +# Bundler::Plugin::Installer::Rubygems::API_REQUEST_LIMIT +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name lock +# wrong constant name attempt +# wrong constant name attempts +# wrong constant name current_run +# wrong constant name current_run= +# wrong constant name initialize +# wrong constant name name +# wrong constant name name= +# wrong constant name total_runs +# wrong constant name total_runs= +# wrong constant name +# wrong constant name attempts +# wrong constant name default_attempts +# wrong constant name default_retries +# uninitialized constant Bundler::RubyGemsGemInstaller::ENV_PATHS +# Did you mean? Bundler::RubyGemsGemInstaller::ENV_PATHS +# wrong constant name +# uninitialized constant Bundler::RubygemsIntegration::MoreFuture::EXT_LOCK +# Did you mean? Bundler::RubygemsIntegration::MoreFuture::EXT_LOCK +# Bundler::RubygemsIntegration::EXT_LOCK +# wrong constant name default_stubs +# wrong constant name == +# wrong constant name fallback_timeout +# wrong constant name fallback_timeout= +# wrong constant name initialize +# wrong constant name uri +# wrong constant name uri= +# wrong constant name valid? +# wrong constant name validate! +# wrong constant name +# wrong constant name each +# wrong constant name for +# wrong constant name initialize +# wrong constant name parse +# wrong constant name +# wrong constant name +# wrong constant name description +# wrong constant name fail! +# wrong constant name initialize +# wrong constant name k +# wrong constant name set +# wrong constant name validate! +# wrong constant name +# wrong constant name +# wrong constant name validate! +# uninitialized constant Bundler::SpecSet::Elem +# wrong constant name add_color +# wrong constant name ask +# wrong constant name confirm +# wrong constant name debug +# wrong constant name debug? +# wrong constant name error +# wrong constant name info +# wrong constant name initialize +# wrong constant name level +# wrong constant name level= +# wrong constant name no? +# wrong constant name quiet? +# wrong constant name shell= +# wrong constant name silence +# wrong constant name trace +# wrong constant name unprinted_warnings +# wrong constant name warn +# wrong constant name yes? +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant Bundler::VersionRanges::NEq::Elem +# wrong constant name version +# wrong constant name version= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# uninitialized constant Bundler::VersionRanges::ReqR::Elem +# wrong constant name +# wrong constant name cover? +# wrong constant name empty? +# wrong constant name left +# wrong constant name left= +# wrong constant name right +# wrong constant name right= +# wrong constant name single? +# uninitialized constant Bundler::VersionRanges::ReqR::Endpoint::Elem +# wrong constant name inclusive +# wrong constant name inclusive= +# wrong constant name version +# wrong constant name version= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name empty? +# wrong constant name for +# wrong constant name for_many +# wrong constant name a +# wrong constant name base +# wrong constant name blockquote +# wrong constant name caption +# wrong constant name checkbox +# wrong constant name checkbox_group +# wrong constant name file_field +# wrong constant name form +# wrong constant name hidden +# wrong constant name html +# wrong constant name image_button +# wrong constant name img +# wrong constant name multipart_form +# wrong constant name password_field +# wrong constant name popup_menu +# wrong constant name radio_button +# wrong constant name radio_group +# wrong constant name reset +# wrong constant name scrolling_list +# wrong constant name submit +# wrong constant name text_field +# wrong constant name textarea +# wrong constant name +# uninitialized constant CSV +# uninitialized constant CSV +# uninitialized constant Chalk +# uninitialized constant Chalk +# wrong constant name json_creatable? +# uninitialized constant Coercible::Coercer::Array::COERCION_METHOD_REGEXP +# Did you mean? Coercible::Coercer::Array::COERCION_METHOD_REGEXP +# uninitialized constant Coercible::Coercer::Decimal::COERCION_METHOD_REGEXP +# Did you mean? Coercible::Coercer::Decimal::COERCION_METHOD_REGEXP +# uninitialized constant Coercible::Coercer::Hash::COERCION_METHOD_REGEXP +# Did you mean? Coercible::Coercer::Hash::COERCION_METHOD_REGEXP +# uninitialized constant Coercible::Coercer::String::COERCION_METHOD_REGEXP +# Did you mean? Coercible::Coercer::String::COERCION_METHOD_REGEXP +# wrong constant name polar +# wrong constant name rect +# wrong constant name rectangular +# uninitialized constant Configatron +# uninitialized constant Configatron +# uninitialized constant Coverage +# uninitialized constant Coverage +# wrong constant name initialize +# wrong constant name != +# wrong constant name == +# wrong constant name __getobj__ +# wrong constant name __setobj__ +# wrong constant name initialize +# wrong constant name marshal_dump +# wrong constant name marshal_load +# wrong constant name method_missing +# wrong constant name methods +# wrong constant name protected_methods +# wrong constant name public_methods +# wrong constant name const_missing +# wrong constant name delegating_block +# wrong constant name public_api +# wrong constant name class_name +# wrong constant name class_names +# wrong constant name corrections +# wrong constant name initialize +# wrong constant name scopes +# wrong constant name corrections +# wrong constant name original_message +# wrong constant name spell_checker +# wrong constant name to_s +# wrong constant name initialize +# wrong constant name distance +# wrong constant name distance +# wrong constant name distance +# wrong constant name min3 +# wrong constant name corrections +# wrong constant name initialize +# wrong constant name method_name +# wrong constant name method_names +# wrong constant name receiver +# wrong constant name included +# wrong constant name new +# wrong constant name corrections +# wrong constant name initialize +# wrong constant name correct +# wrong constant name initialize +# wrong constant name corrections +# wrong constant name cvar_names +# wrong constant name initialize +# wrong constant name ivar_names +# wrong constant name lvar_names +# wrong constant name method_names +# wrong constant name name +# wrong constant name empty? +# wrong constant name exists? +# wrong constant name tmpdir +# wrong constant name def_method +# wrong constant name def_module +# wrong constant name _dump +# wrong constant name convert +# wrong constant name convpath +# wrong constant name destination_encoding +# wrong constant name finish +# wrong constant name initialize +# wrong constant name insert_output +# wrong constant name last_error +# wrong constant name primitive_convert +# wrong constant name primitive_errinfo +# wrong constant name putback +# wrong constant name replacement +# wrong constant name replacement= +# wrong constant name source_encoding +# wrong constant name asciicompat_encoding +# wrong constant name search_convpath +# wrong constant name destination_encoding +# wrong constant name destination_encoding_name +# wrong constant name error_bytes +# wrong constant name incomplete_input? +# wrong constant name readagain_bytes +# wrong constant name source_encoding +# wrong constant name source_encoding_name +# wrong constant name destination_encoding +# wrong constant name destination_encoding_name +# wrong constant name error_char +# wrong constant name source_encoding +# wrong constant name source_encoding_name +# wrong constant name _load +# wrong constant name locale_charmap +# wrong constant name chunk +# wrong constant name chunk_while +# wrong constant name each_entry +# wrong constant name grep_v +# wrong constant name slice_after +# wrong constant name slice_before +# wrong constant name slice_when +# wrong constant name sum +# wrong constant name to_set +# wrong constant name uniq +# wrong constant name zip +# wrong constant name each_with_index +# wrong constant name each +# wrong constant name initialize +# wrong constant name chunk +# wrong constant name chunk_while +# wrong constant name force +# wrong constant name slice_when +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name gid +# wrong constant name gid= +# wrong constant name mem +# wrong constant name mem= +# wrong constant name name +# wrong constant name name= +# wrong constant name passwd +# wrong constant name passwd= +# uninitialized constant Etc::Group::Elem +# wrong constant name [] +# wrong constant name each +# wrong constant name members +# wrong constant name change +# wrong constant name change= +# wrong constant name dir +# wrong constant name dir= +# wrong constant name expire +# wrong constant name expire= +# wrong constant name gecos +# wrong constant name gecos= +# wrong constant name gid +# wrong constant name gid= +# wrong constant name name +# wrong constant name name= +# wrong constant name passwd +# wrong constant name passwd= +# wrong constant name shell +# wrong constant name shell= +# wrong constant name uclass +# wrong constant name uclass= +# wrong constant name uid +# wrong constant name uid= +# uninitialized constant Etc::Passwd::Elem +# wrong constant name [] +# wrong constant name each +# wrong constant name members +# wrong constant name confstr +# wrong constant name endgrent +# wrong constant name endpwent +# wrong constant name getgrent +# wrong constant name getgrgid +# wrong constant name getgrnam +# wrong constant name getlogin +# wrong constant name getpwent +# wrong constant name getpwnam +# wrong constant name getpwuid +# wrong constant name group +# wrong constant name nprocessors +# wrong constant name passwd +# wrong constant name setgrent +# wrong constant name setpwent +# wrong constant name sysconf +# wrong constant name sysconfdir +# wrong constant name systmpdir +# wrong constant name uname +# wrong constant name exception +# uninitialized constant Exception2MessageMapper +# uninitialized constant Exception2MessageMapper +# wrong constant name +# wrong constant name resume +# wrong constant name yield +# wrong constant name size? +# wrong constant name empty? +# wrong constant name exists? +# wrong constant name mkfifo +# uninitialized constant FileUtils::DryRun::LN_SUPPORTED +# Did you mean? FileUtils::DryRun::LN_SUPPORTED +# FileUtils::LN_SUPPORTED +# uninitialized constant FileUtils::DryRun::RUBY +# Did you mean? FileUtils::RUBY +# FileUtils::DryRun::RUBY +# uninitialized constant FileUtils::NoWrite::LN_SUPPORTED +# Did you mean? FileUtils::NoWrite::LN_SUPPORTED +# FileUtils::LN_SUPPORTED +# uninitialized constant FileUtils::NoWrite::RUBY +# Did you mean? FileUtils::RUBY +# FileUtils::NoWrite::RUBY +# uninitialized constant FileUtils::Verbose::LN_SUPPORTED +# Did you mean? FileUtils::Verbose::LN_SUPPORTED +# FileUtils::LN_SUPPORTED +# uninitialized constant FileUtils::Verbose::RUBY +# Did you mean? FileUtils::RUBY +# FileUtils::Verbose::RUBY +# wrong constant name to_d +# uninitialized constant Forwardable +# uninitialized constant Forwardable +# wrong constant name garbage_collect +# wrong constant name latest_gc_info +# wrong constant name stress= +# wrong constant name verify_internal_consistency +# wrong constant name oct_or_256based +# wrong constant name s3_uri_signer +# uninitialized constant Gem::Resolver::Molinillo::DependencyGraph::Log::Elem +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name initialize +# wrong constant name sign +# wrong constant name uri +# wrong constant name uri= +# wrong constant name initialize +# wrong constant name +# wrong constant name initialize +# wrong constant name +# uninitialized constant Gem::S3URISigner::S3Config::Elem +# wrong constant name access_key_id +# wrong constant name access_key_id= +# wrong constant name region +# wrong constant name region= +# wrong constant name secret_access_key +# wrong constant name secret_access_key= +# wrong constant name security_token +# wrong constant name security_token= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# uninitialized constant Gem::Specification::Elem +# wrong constant name correct_for_windows_path +# wrong constant name < +# wrong constant name <= +# wrong constant name > +# wrong constant name >= +# wrong constant name compact +# wrong constant name compact! +# wrong constant name default_proc +# wrong constant name default_proc= +# wrong constant name dig +# wrong constant name fetch_values +# wrong constant name flatten +# wrong constant name index +# wrong constant name merge! +# wrong constant name replace +# wrong constant name to_h +# wrong constant name to_proc +# wrong constant name transform_values +# wrong constant name transform_values! +# wrong constant name update +# wrong constant name try_convert +# wrong constant name external_encoding +# wrong constant name nonblock +# wrong constant name nonblock= +# wrong constant name nonblock? +# wrong constant name nread +# wrong constant name pathconf +# wrong constant name ready? +# wrong constant name wait +# wrong constant name wait_readable +# wrong constant name wait_writable +# wrong constant name write_nonblock +# wrong constant name foreach +# wrong constant name pipe +# wrong constant name digits +# wrong constant name to_bn +# wrong constant name to_d +# wrong constant name from_state +# wrong constant name initialize +# wrong constant name gem +# wrong constant name itself +# wrong constant name object_id +# wrong constant name pretty_inspect +# wrong constant name respond_to? +# wrong constant name at_exit +# wrong constant name path +# wrong constant name exit_value +# wrong constant name reason +# uninitialized constant Logger +# uninitialized constant Logger +# wrong constant name restore +# uninitialized constant MessagePack +# uninitialized constant MessagePack +# wrong constant name deprecate_constant +# wrong constant name used_modules +# wrong constant name enter +# wrong constant name exit +# wrong constant name try_enter +# wrong constant name initialize +# wrong constant name mon_enter +# wrong constant name mon_exit +# wrong constant name mon_synchronize +# wrong constant name mon_try_enter +# wrong constant name new_cond +# wrong constant name synchronize +# wrong constant name try_mon_enter +# wrong constant name broadcast +# wrong constant name initialize +# wrong constant name signal +# wrong constant name wait +# wrong constant name wait_until +# wrong constant name wait_while +# wrong constant name extend_object +# wrong constant name name +# wrong constant name receiver +# uninitialized constant Net::FTP +# uninitialized constant Net::FTP +# uninitialized constant Net::FTPConnectionError +# uninitialized constant Net::FTPConnectionError +# uninitialized constant Net::FTPError +# Did you mean? Net::HTTPError +# uninitialized constant Net::FTPError +# Did you mean? Net::HTTPError +# uninitialized constant Net::FTPPermError +# Did you mean? FiberError +# uninitialized constant Net::FTPPermError +# Did you mean? FiberError +# uninitialized constant Net::FTPProtoError +# uninitialized constant Net::FTPProtoError +# uninitialized constant Net::FTPReplyError +# uninitialized constant Net::FTPReplyError +# uninitialized constant Net::FTPTempError +# Did you mean? TypeError +# uninitialized constant Net::FTPTempError +# Did you mean? TypeError +# uninitialized constant Net::HTTP::DigestAuth +# Did you mean? Digest +# uninitialized constant Net::HTTP::DigestAuth +# Did you mean? Digest +# uninitialized constant Net::HTTP::Persistent +# uninitialized constant Net::HTTP::Persistent +# uninitialized constant Net::IMAP +# uninitialized constant Net::IMAP +# uninitialized constant Net::SMTP +# uninitialized constant Net::SMTP +# uninitialized constant Net::SMTPAuthenticationError +# uninitialized constant Net::SMTPAuthenticationError +# uninitialized constant Net::SMTPError +# Did you mean? Net::HTTPError +# uninitialized constant Net::SMTPError +# Did you mean? Net::HTTPError +# uninitialized constant Net::SMTPFatalError +# Did you mean? Net::ProtoFatalError +# Net::HTTPFatalError +# uninitialized constant Net::SMTPFatalError +# Did you mean? Net::ProtoFatalError +# Net::HTTPFatalError +# uninitialized constant Net::SMTPServerBusy +# uninitialized constant Net::SMTPServerBusy +# uninitialized constant Net::SMTPSyntaxError +# Did you mean? SyntaxError +# Net::ProtoSyntaxError +# uninitialized constant Net::SMTPSyntaxError +# Did you mean? SyntaxError +# Net::ProtoSyntaxError +# uninitialized constant Net::SMTPUnknownError +# uninitialized constant Net::SMTPUnknownError +# uninitialized constant Net::SMTPUnsupportedCommand +# uninitialized constant Net::SMTPUnsupportedCommand +# wrong constant name to_i +# wrong constant name args +# wrong constant name private_call? +# uninitialized constant RUBYGEMS_ACTIVATION_MONITOR +# Did you mean? RUBYGEMS_ACTIVATION_MONITOR +# wrong constant name +# wrong constant name [] +# wrong constant name []= +# wrong constant name each +# wrong constant name each_key +# wrong constant name each_pair +# wrong constant name each_value +# wrong constant name key? +# wrong constant name keys +# wrong constant name length +# wrong constant name size +# wrong constant name values +# wrong constant name count_objects +# wrong constant name define_finalizer +# wrong constant name garbage_collect +# wrong constant name undefine_finalizer +# uninitialized constant OpenSSL::Digest::DSS +# uninitialized constant OpenSSL::Digest::DSS +# uninitialized constant OpenSSL::Digest::DSS1 +# uninitialized constant OpenSSL::Digest::DSS1 +# uninitialized constant OpenSSL::Digest::SHA +# Did you mean? OpenSSL::Digest::SHA1 +# uninitialized constant OpenSSL::Digest::SHA +# Did you mean? OpenSSL::Digest::SHA1 +# uninitialized constant Opus +# uninitialized constant Opus +# wrong constant name empty? +# wrong constant name fnmatch? +# wrong constant name make_symlink +# wrong constant name === +# wrong constant name clone +# wrong constant name yield +# uninitialized constant Proc0 +# Did you mean? Proc +# uninitialized constant Proc0 +# Did you mean? Proc +# uninitialized constant Proc1 +# Did you mean? Proc +# uninitialized constant Proc1 +# Did you mean? Proc +# uninitialized constant Proc10 +# Did you mean? Proc +# uninitialized constant Proc10 +# Did you mean? Proc +# uninitialized constant Proc2 +# Did you mean? Proc +# uninitialized constant Proc2 +# Did you mean? Proc +# uninitialized constant Proc3 +# Did you mean? Proc +# uninitialized constant Proc3 +# Did you mean? Proc +# uninitialized constant Proc4 +# Did you mean? Proc +# uninitialized constant Proc4 +# Did you mean? Proc +# uninitialized constant Proc5 +# Did you mean? Proc +# uninitialized constant Proc5 +# Did you mean? Proc +# uninitialized constant Proc6 +# Did you mean? Proc +# uninitialized constant Proc6 +# Did you mean? Proc +# uninitialized constant Proc7 +# Did you mean? Proc +# uninitialized constant Proc7 +# Did you mean? Proc +# uninitialized constant Proc8 +# Did you mean? Proc +# uninitialized constant Proc8 +# Did you mean? Proc +# uninitialized constant Proc9 +# Did you mean? Proc +# uninitialized constant Proc9 +# Did you mean? Proc +# wrong constant name getegid +# wrong constant name cstime +# wrong constant name cstime= +# wrong constant name cutime +# wrong constant name cutime= +# wrong constant name stime +# wrong constant name stime= +# wrong constant name utime +# wrong constant name utime= +# wrong constant name [] +# wrong constant name members +# wrong constant name setpgrp +# uninitialized constant RSpec::Core::ExampleGroup::BE_PREDICATE_REGEX +# Did you mean? RSpec::Core::ExampleGroup::BE_PREDICATE_REGEX +# uninitialized constant RSpec::Core::ExampleGroup::DYNAMIC_MATCHER_REGEX +# Did you mean? RSpec::Core::ExampleGroup::DYNAMIC_MATCHER_REGEX +# uninitialized constant RSpec::Core::ExampleGroup::HAS_REGEX +# Did you mean? RSpec::Core::ExampleGroup::HAS_REGEX +# uninitialized constant RSpec::Core::ExampleGroup::NOT_YET_IMPLEMENTED +# Did you mean? RSpec::Core::ExampleGroup::NOT_YET_IMPLEMENTED +# uninitialized constant RSpec::Core::ExampleGroup::NO_REASON_GIVEN +# Did you mean? RSpec::Core::ExampleGroup::NO_REASON_GIVEN +# wrong constant name initialize +# wrong constant name persist +# wrong constant name +# wrong constant name load_from +# wrong constant name persist +# wrong constant name example_failed +# wrong constant name example_finished +# wrong constant name initialize +# wrong constant name start_dump +# wrong constant name +# wrong constant name inherited +# wrong constant name close +# wrong constant name example_group +# wrong constant name example_group= +# wrong constant name example_group_started +# wrong constant name initialize +# wrong constant name output +# wrong constant name start +# wrong constant name +# wrong constant name dump_failures +# wrong constant name dump_pending +# wrong constant name dump_summary +# wrong constant name message +# wrong constant name seed +# wrong constant name +# wrong constant name initialize +# wrong constant name notify_results +# wrong constant name +# wrong constant name example_failed +# wrong constant name example_group_finished +# wrong constant name example_passed +# wrong constant name example_pending +# wrong constant name +# wrong constant name initialize +# wrong constant name message +# wrong constant name output +# wrong constant name +# wrong constant name dump_summary +# wrong constant name example_failed +# wrong constant name example_passed +# wrong constant name example_pending +# wrong constant name example_started +# wrong constant name start_dump +# wrong constant name +# wrong constant name dump_profile +# wrong constant name dump_profile_slowest_example_groups +# wrong constant name dump_profile_slowest_examples +# wrong constant name dump_summary +# wrong constant name message +# wrong constant name output_hash +# wrong constant name seed +# wrong constant name stop +# wrong constant name +# wrong constant name dump_profile +# wrong constant name initialize +# wrong constant name output +# wrong constant name +# wrong constant name example_failed +# wrong constant name example_passed +# wrong constant name example_pending +# wrong constant name start_dump +# wrong constant name +# wrong constant name example_group_finished +# wrong constant name example_group_started +# wrong constant name example_groups +# wrong constant name example_started +# wrong constant name +# wrong constant name +# wrong constant name __shared_context_recordings +# wrong constant name after +# wrong constant name append_after +# wrong constant name append_before +# wrong constant name around +# wrong constant name before +# wrong constant name context +# wrong constant name describe +# wrong constant name hooks +# wrong constant name included +# wrong constant name let +# wrong constant name let! +# wrong constant name prepend_after +# wrong constant name prepend_before +# wrong constant name subject +# wrong constant name subject! +# uninitialized constant RSpec::Core::SharedContext::Recording::Elem +# wrong constant name args +# wrong constant name args= +# wrong constant name block +# wrong constant name block= +# wrong constant name method_name +# wrong constant name method_name= +# wrong constant name playback_onto +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name record +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name body_content_lines +# wrong constant name initialize +# wrong constant name method_name +# wrong constant name +# uninitialized constant RSpec::Expectations::BlockSnippetExtractor::BlockLocator::Elem +# wrong constant name beginning_line_number +# wrong constant name beginning_line_number= +# wrong constant name body_content_locations +# wrong constant name method_call_location +# wrong constant name method_name +# wrong constant name method_name= +# wrong constant name source +# wrong constant name source= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# uninitialized constant RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor::Elem +# wrong constant name beginning_line_number +# wrong constant name beginning_line_number= +# wrong constant name body_tokens +# wrong constant name method_name +# wrong constant name method_name= +# wrong constant name source +# wrong constant name source= +# wrong constant name state +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name try_extracting_single_line_body_of +# wrong constant name aggregate +# wrong constant name block_label +# wrong constant name call +# wrong constant name failures +# wrong constant name initialize +# wrong constant name metadata +# wrong constant name other_errors +# wrong constant name +# wrong constant name aggregation_block_label +# wrong constant name aggregation_metadata +# wrong constant name all_exceptions +# wrong constant name exception_count_description +# wrong constant name failures +# wrong constant name initialize +# wrong constant name other_errors +# wrong constant name summary +# uninitialized constant RSpec::Matchers::BuiltIn::All::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::All::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name failed_objects +# wrong constant name initialize +# wrong constant name matcher +# wrong constant name +# wrong constant name < +# wrong constant name <= +# wrong constant name == +# wrong constant name === +# wrong constant name =~ +# wrong constant name > +# wrong constant name >= +# uninitialized constant RSpec::Matchers::BuiltIn::Be::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Be::UNDEFINED +# wrong constant name initialize +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeAKindOf::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeAKindOf::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeAnInstanceOf::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeAnInstanceOf::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeBetween::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeBetween::UNDEFINED +# wrong constant name exclusive +# wrong constant name inclusive +# wrong constant name initialize +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeComparedTo::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeComparedTo::UNDEFINED +# wrong constant name initialize +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeFalsey::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeFalsey::UNDEFINED +# wrong constant name +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeNil::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeNil::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BePredicate::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BePredicate::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeTruthy::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeTruthy::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::BeWithin::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::BeWithin::UNDEFINED +# wrong constant name initialize +# wrong constant name of +# wrong constant name percent_of +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Change::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Change::UNDEFINED +# wrong constant name by +# wrong constant name by_at_least +# wrong constant name by_at_most +# wrong constant name does_not_match? +# wrong constant name from +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name to +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Compound::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Compound::UNDEFINED +# wrong constant name diffable_matcher_list +# wrong constant name does_not_match? +# wrong constant name evaluator +# wrong constant name initialize +# wrong constant name matcher_1 +# wrong constant name matcher_2 +# uninitialized constant RSpec::Matchers::BuiltIn::Compound::And::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Compound::And::UNDEFINED +# RSpec::Matchers::BuiltIn::Compound::UNDEFINED +# wrong constant name +# wrong constant name initialize +# wrong constant name matcher_matches? +# wrong constant name +# wrong constant name matcher_expects_call_stack_jump? +# uninitialized constant RSpec::Matchers::BuiltIn::Compound::Or::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Compound::Or::UNDEFINED +# RSpec::Matchers::BuiltIn::Compound::UNDEFINED +# wrong constant name +# wrong constant name initialize +# wrong constant name matcher_matches? +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::ContainExactly::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::ContainExactly::UNDEFINED +# wrong constant name +# wrong constant name +# wrong constant name actual_to_expected_matched_indexes +# wrong constant name expected_to_actual_matched_indexes +# wrong constant name find_best_solution +# wrong constant name initialize +# wrong constant name solution +# wrong constant name +# wrong constant name worse_than? +# wrong constant name + +# uninitialized constant #::Elem +# wrong constant name candidate? +# wrong constant name ideal? +# wrong constant name indeterminate_actual_indexes +# wrong constant name indeterminate_actual_indexes= +# wrong constant name indeterminate_expected_indexes +# wrong constant name indeterminate_expected_indexes= +# wrong constant name unmatched_actual_indexes +# wrong constant name unmatched_actual_indexes= +# wrong constant name unmatched_expected_indexes +# wrong constant name unmatched_expected_indexes= +# wrong constant name unmatched_item_count +# wrong constant name worse_than? +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Cover::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Cover::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::EndWith::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::EndWith::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Eq::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Eq::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Eql::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Eql::UNDEFINED +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Equal::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Equal::UNDEFINED +# wrong constant name +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Exist::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Exist::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name actual_exists? +# wrong constant name valid_test? +# wrong constant name validity_message +# wrong constant name +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Has::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Has::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::HaveAttributes::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::HaveAttributes::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name respond_to_failed +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Include::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Include::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name expecteds +# wrong constant name initialize +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Match::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Match::UNDEFINED +# wrong constant name initialize +# wrong constant name with_captures +# wrong constant name +# wrong constant name __delegate_operator +# wrong constant name +# wrong constant name != +# wrong constant name !~ +# wrong constant name < +# wrong constant name <= +# wrong constant name == +# wrong constant name === +# wrong constant name =~ +# wrong constant name > +# wrong constant name >= +# wrong constant name description +# wrong constant name fail_with_message +# wrong constant name initialize +# wrong constant name +# wrong constant name get +# wrong constant name register +# wrong constant name registry +# wrong constant name unregister +# wrong constant name use_custom_matcher_or_delegate +# uninitialized constant RSpec::Matchers::BuiltIn::Output::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Output::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name to_stderr +# wrong constant name to_stderr_from_any_process +# wrong constant name to_stdout +# wrong constant name to_stdout_from_any_process +# wrong constant name +# wrong constant name __delegate_operator +# wrong constant name +# wrong constant name description +# wrong constant name does_not_match? +# wrong constant name expects_call_stack_jump? +# wrong constant name failure_message +# wrong constant name failure_message_when_negated +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name supports_block_expectations? +# wrong constant name with_message +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::RespondTo::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::RespondTo::UNDEFINED +# wrong constant name and_any_keywords +# wrong constant name and_keywords +# wrong constant name and_unlimited_arguments +# wrong constant name argument +# wrong constant name arguments +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name with +# wrong constant name with_any_keywords +# wrong constant name with_keywords +# wrong constant name with_unlimited_arguments +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::Satisfy::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::Satisfy::UNDEFINED +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::StartOrEndWith::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::StartOrEndWith::UNDEFINED +# wrong constant name initialize +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::StartWith::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::StartWith::UNDEFINED +# wrong constant name +# wrong constant name description +# wrong constant name does_not_match? +# wrong constant name expects_call_stack_jump? +# wrong constant name failure_message +# wrong constant name failure_message_when_negated +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name supports_block_expectations? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::YieldControl::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::YieldControl::UNDEFINED +# wrong constant name at_least +# wrong constant name at_most +# wrong constant name does_not_match? +# wrong constant name exactly +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name once +# wrong constant name thrice +# wrong constant name times +# wrong constant name twice +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::YieldSuccessiveArgs::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::YieldSuccessiveArgs::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::YieldWithArgs::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::YieldWithArgs::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name +# uninitialized constant RSpec::Matchers::BuiltIn::YieldWithNoArgs::UNDEFINED +# Did you mean? RSpec::Matchers::BuiltIn::YieldWithNoArgs::UNDEFINED +# wrong constant name does_not_match? +# wrong constant name matches? +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name constrained_to_any_of? +# wrong constant name expectation_fulfilled! +# wrong constant name initialize +# wrong constant name matches_args? +# wrong constant name never +# wrong constant name playback! +# wrong constant name and_call_original +# wrong constant name and_raise +# wrong constant name and_return +# wrong constant name and_throw +# wrong constant name and_wrap_original +# wrong constant name and_yield +# wrong constant name at_least +# wrong constant name at_most +# wrong constant name exactly +# wrong constant name never +# wrong constant name once +# wrong constant name thrice +# wrong constant name times +# wrong constant name twice +# wrong constant name with +# wrong constant name +# wrong constant name record +# wrong constant name +# wrong constant name raise_does_not_implement_error +# wrong constant name raise_message_already_received_by_other_instance_error +# wrong constant name raise_not_supported_with_prepend_error +# wrong constant name raise_second_instance_received_message_error +# wrong constant name +# uninitialized constant RSpec::Mocks::AnyInstance::ExpectChainChain::EmptyInvocationOrder +# Did you mean? RSpec::Mocks::AnyInstance::ExpectChainChain::EmptyInvocationOrder +# RSpec::Mocks::AnyInstance::ExpectChainChain::InvocationOrder +# uninitialized constant RSpec::Mocks::AnyInstance::ExpectChainChain::InvocationOrder +# Did you mean? RSpec::Mocks::AnyInstance::ExpectChainChain::InvocationOrder +# wrong constant name initialize +# wrong constant name +# wrong constant name expectation_fulfilled? +# wrong constant name initialize +# wrong constant name +# wrong constant name initialize +# wrong constant name method_missing +# wrong constant name +# wrong constant name [] +# wrong constant name add +# wrong constant name all_expectations_fulfilled? +# wrong constant name each_unfulfilled_expectation_matching +# wrong constant name has_expectation? +# wrong constant name playback! +# wrong constant name received_expected_message! +# wrong constant name remove_stub_chains_for! +# wrong constant name unfulfilled_expectations +# wrong constant name +# wrong constant name +# wrong constant name expect_chain +# wrong constant name initialize +# wrong constant name klass +# wrong constant name should_not_receive +# wrong constant name should_receive +# wrong constant name stub +# wrong constant name stub_chain +# wrong constant name unstub +# wrong constant name +# wrong constant name already_observing? +# wrong constant name build_alias_method_name +# wrong constant name expect_chain +# wrong constant name initialize +# wrong constant name instance_that_received +# wrong constant name klass +# wrong constant name message_chains +# wrong constant name notify_received_message +# wrong constant name playback! +# wrong constant name should_not_receive +# wrong constant name should_receive +# wrong constant name stop_all_observation! +# wrong constant name stop_observing! +# wrong constant name stub +# wrong constant name stub_chain +# wrong constant name stubs +# wrong constant name unstub +# wrong constant name verify +# wrong constant name +# wrong constant name expectation_fulfilled? +# wrong constant name +# uninitialized constant RSpec::Mocks::AnyInstance::StubChainChain::EmptyInvocationOrder +# Did you mean? RSpec::Mocks::AnyInstance::StubChainChain::EmptyInvocationOrder +# RSpec::Mocks::AnyInstance::StubChainChain::InvocationOrder +# uninitialized constant RSpec::Mocks::AnyInstance::StubChainChain::InvocationOrder +# Did you mean? RSpec::Mocks::AnyInstance::StubChainChain::InvocationOrder +# wrong constant name initialize +# wrong constant name +# wrong constant name +# wrong constant name error_generator +# wrong constant name +# wrong constant name expect_chain_on +# wrong constant name +# wrong constant name patch! +# wrong constant name unpatch! +# wrong constant name at_least +# wrong constant name at_most +# wrong constant name description +# wrong constant name does_not_match? +# wrong constant name exactly +# wrong constant name failure_message +# wrong constant name failure_message_when_negated +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name name +# wrong constant name once +# wrong constant name ordered +# wrong constant name setup_allowance +# wrong constant name setup_any_instance_allowance +# wrong constant name setup_any_instance_expectation +# wrong constant name setup_any_instance_negative_expectation +# wrong constant name setup_expectation +# wrong constant name setup_negative_expectation +# wrong constant name thrice +# wrong constant name times +# wrong constant name twice +# wrong constant name with +# wrong constant name +# wrong constant name +# wrong constant name and_call_original +# wrong constant name and_raise +# wrong constant name and_return +# wrong constant name and_throw +# wrong constant name and_wrap_original +# wrong constant name and_yield +# wrong constant name at_least +# wrong constant name at_most +# wrong constant name description +# wrong constant name does_not_match? +# wrong constant name exactly +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name name +# wrong constant name never +# wrong constant name once +# wrong constant name ordered +# wrong constant name setup_allowance +# wrong constant name setup_any_instance_allowance +# wrong constant name setup_any_instance_expectation +# wrong constant name setup_any_instance_negative_expectation +# wrong constant name setup_expectation +# wrong constant name setup_negative_expectation +# wrong constant name thrice +# wrong constant name times +# wrong constant name twice +# wrong constant name with +# wrong constant name description_for +# wrong constant name initialize +# wrong constant name +# wrong constant name +# wrong constant name and_call_original +# wrong constant name and_raise +# wrong constant name and_return +# wrong constant name and_throw +# wrong constant name and_yield +# wrong constant name description +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name name +# wrong constant name setup_allowance +# wrong constant name setup_any_instance_allowance +# wrong constant name setup_any_instance_expectation +# wrong constant name setup_expectation +# wrong constant name setup_negative_expectation +# wrong constant name with +# wrong constant name +# wrong constant name description +# wrong constant name does_not_match? +# wrong constant name initialize +# wrong constant name matches? +# wrong constant name name +# wrong constant name setup_allowance +# wrong constant name setup_any_instance_allowance +# wrong constant name setup_any_instance_expectation +# wrong constant name setup_expectation +# wrong constant name setup_negative_expectation +# wrong constant name warn_about_block +# wrong constant name +# wrong constant name block +# wrong constant name chain +# wrong constant name initialize +# wrong constant name object +# wrong constant name setup_chain +# wrong constant name +# wrong constant name +# wrong constant name stub_chain_on +# wrong constant name +# wrong constant name color? +# wrong constant name diff +# wrong constant name diff_as_object +# wrong constant name diff_as_string +# wrong constant name initialize +# wrong constant name +# uninitialized constant Racc +# uninitialized constant Racc +# uninitialized constant Rake::DSL::DEFAULT +# Did you mean? Rake::DSL::DEFAULT +# uninitialized constant Rake::DSL::LN_SUPPORTED +# Did you mean? Rake::DSL::LN_SUPPORTED +# uninitialized constant Rake::DSL::LOW_METHODS +# Did you mean? Rake::DSL::LowMethods +# Rake::DSL::LOW_METHODS +# uninitialized constant Rake::DSL::METHODS +# Did you mean? Method +# Rake::DSL::METHODS +# uninitialized constant Rake::DSL::OPT_TABLE +# Did you mean? Rake::DSL::OPT_TABLE +# uninitialized constant Rake::DSL::RUBY +# Did you mean? Rake::DSL::RUBY +# uninitialized constant Rake::FileUtilsExt::LN_SUPPORTED +# Did you mean? Rake::FileUtilsExt::LN_SUPPORTED +# uninitialized constant Rake::FileUtilsExt::LOW_METHODS +# Did you mean? Rake::FileUtilsExt::LowMethods +# Rake::FileUtilsExt::LOW_METHODS +# uninitialized constant Rake::FileUtilsExt::METHODS +# Did you mean? Method +# Rake::FileUtilsExt::METHODS +# uninitialized constant Rake::FileUtilsExt::OPT_TABLE +# Did you mean? Rake::FileUtilsExt::OPT_TABLE +# uninitialized constant Rake::FileUtilsExt::RUBY +# Did you mean? Rake::FileUtilsExt::RUBY +# wrong constant name raw_seed +# wrong constant name to_d +# wrong constant name expand +# wrong constant name ruby +# wrong constant name match? +# wrong constant name union +# uninitialized constant Ripper +# uninitialized constant Ripper +# wrong constant name absolute_path +# wrong constant name base_label +# wrong constant name disasm +# wrong constant name disassemble +# wrong constant name eval +# wrong constant name first_lineno +# wrong constant name label +# wrong constant name path +# wrong constant name to_a +# wrong constant name to_binary +# wrong constant name compile +# wrong constant name compile_file +# wrong constant name compile_option +# wrong constant name compile_option= +# wrong constant name disasm +# wrong constant name disassemble +# wrong constant name load_from_binary +# wrong constant name load_from_binary_extra_data +# wrong constant name of +# wrong constant name stat +# wrong constant name == +# wrong constant name compare_by_identity +# wrong constant name compare_by_identity? +# wrong constant name divide +# wrong constant name eql? +# wrong constant name flatten_merge +# wrong constant name pretty_print +# wrong constant name pretty_print_cycle +# wrong constant name +# wrong constant name escape +# wrong constant name join +# wrong constant name shellescape +# wrong constant name shelljoin +# wrong constant name shellsplit +# wrong constant name shellwords +# wrong constant name split +# wrong constant name signm +# wrong constant name signo +# uninitialized constant SingleForwardable +# uninitialized constant SingleForwardable +# wrong constant name _dump +# wrong constant name clone +# wrong constant name dup +# wrong constant name _load +# wrong constant name clone +# wrong constant name __init__ +# wrong constant name +# wrong constant name all_module_aliases +# wrong constant name all_module_names +# wrong constant name all_named_modules +# wrong constant name class_by_name +# wrong constant name name_by_class +# uninitialized constant Sorbet::Private::ConstantLookupCache::ConstantEntry::Elem +# wrong constant name aliases +# wrong constant name aliases= +# wrong constant name const +# wrong constant name const= +# wrong constant name const_name +# wrong constant name const_name= +# wrong constant name found_name +# wrong constant name found_name= +# wrong constant name owner +# wrong constant name owner= +# wrong constant name primary_name +# wrong constant name primary_name= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# wrong constant name +# wrong constant name fetch_sorbet_typed +# wrong constant name main +# wrong constant name matching_version_directories +# wrong constant name output_file +# wrong constant name paths_for_gem_version +# wrong constant name paths_for_ruby_version +# wrong constant name vendor_rbis_within_paths +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# wrong constant name paths_within_gem_sources +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant Sorbet::Private::GemGeneratorTracepoint::ClassDefinition::Elem +# wrong constant name defs +# wrong constant name defs= +# wrong constant name id +# wrong constant name id= +# wrong constant name klass +# wrong constant name klass= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name initialize +# wrong constant name serialize +# wrong constant name +# wrong constant name +# wrong constant name add_to_context +# wrong constant name disable_tracepoints +# wrong constant name finish +# wrong constant name install_tracepoints +# wrong constant name on_method_added +# wrong constant name on_module_created +# wrong constant name on_module_extended +# wrong constant name on_module_included +# wrong constant name pre_cache_module_methods +# wrong constant name register_delegate_class +# wrong constant name start +# wrong constant name trace +# wrong constant name trace_results +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# wrong constant name +# wrong constant name my_require +# wrong constant name require_all_gems +# wrong constant name require_gem +# wrong constant name all_modules_and_aliases +# wrong constant name capture_stderr +# wrong constant name constant_cache +# wrong constant name gen_source_rbi +# wrong constant name looks_like_stub_name +# wrong constant name main +# wrong constant name mk_dir +# wrong constant name read_constants +# wrong constant name real_name +# wrong constant name require_everything +# wrong constant name rm_dir +# wrong constant name serialize_alias +# wrong constant name serialize_class +# wrong constant name serialize_constants +# wrong constant name symbols_id_to_name +# wrong constant name write_constants +# wrong constant name write_diff +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# wrong constant name +# wrong constant name cyan +# wrong constant name emojify +# wrong constant name init +# wrong constant name main +# wrong constant name make_step +# wrong constant name usage +# wrong constant name yellow +# wrong constant name +# wrong constant name real_ancestors +# wrong constant name real_autoload? +# wrong constant name real_const_get +# wrong constant name real_constants +# wrong constant name real_eqeq +# wrong constant name real_hash +# wrong constant name real_instance_methods +# wrong constant name real_is_a? +# wrong constant name real_name +# wrong constant name real_object_id +# wrong constant name real_private_instance_methods +# wrong constant name real_singleton_class +# wrong constant name real_singleton_methods +# wrong constant name real_spaceship +# wrong constant name real_superclass +# wrong constant name +# wrong constant name excluded_rails_files +# wrong constant name load_bundler +# wrong constant name load_rails +# wrong constant name my_require +# wrong constant name patch_kernel +# wrong constant name rails? +# wrong constant name rails_load_paths +# wrong constant name rb_file_paths +# wrong constant name require_all_files +# wrong constant name require_everything +# wrong constant name alias +# wrong constant name ancestor_has_method +# wrong constant name blacklisted_method +# wrong constant name class_or_module +# wrong constant name comparable? +# wrong constant name constant +# wrong constant name from_method +# wrong constant name initialize +# wrong constant name serialize_method +# wrong constant name serialize_sig +# wrong constant name to_sig +# wrong constant name valid_class_name +# wrong constant name valid_method_name +# wrong constant name +# wrong constant name header +# uninitialized constant Sorbet::Private::Static +# Did you mean? Sorbet::Private::Status +# uninitialized constant Sorbet::Private::Static +# Did you mean? Sorbet::Private::Status +# wrong constant name +# wrong constant name done +# wrong constant name say +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# wrong constant name suggest_typed +# wrong constant name +# wrong constant name main +# wrong constant name output_file +# uninitialized constant SortedSet::InspectKey +# Did you mean? SortedSet::InspectKey +# wrong constant name initialize +# wrong constant name setup +# wrong constant name result +# wrong constant name +@ +# wrong constant name -@ +# wrong constant name []= +# wrong constant name casecmp? +# wrong constant name encode +# wrong constant name encode! +# wrong constant name reverse! +# wrong constant name shellescape +# wrong constant name shellsplit +# wrong constant name succ! +# wrong constant name to_d +# wrong constant name unicode_normalize +# wrong constant name unicode_normalize! +# wrong constant name unicode_normalized? +# wrong constant name unpack1 +# wrong constant name length +# wrong constant name truncate +# wrong constant name << +# wrong constant name [] +# wrong constant name beginning_of_line? +# wrong constant name bol? +# wrong constant name charpos +# wrong constant name check +# wrong constant name check_until +# wrong constant name clear +# wrong constant name concat +# wrong constant name empty? +# wrong constant name exist? +# wrong constant name get_byte +# wrong constant name getbyte +# wrong constant name initialize +# wrong constant name match? +# wrong constant name matched +# wrong constant name matched? +# wrong constant name matched_size +# wrong constant name peek +# wrong constant name peep +# wrong constant name pointer +# wrong constant name pointer= +# wrong constant name pos +# wrong constant name pos= +# wrong constant name post_match +# wrong constant name pre_match +# wrong constant name reset +# wrong constant name rest +# wrong constant name rest? +# wrong constant name rest_size +# wrong constant name restsize +# wrong constant name scan_full +# wrong constant name scan_until +# wrong constant name search_full +# wrong constant name skip +# wrong constant name skip_until +# wrong constant name string +# wrong constant name string= +# wrong constant name terminate +# wrong constant name unscan +# wrong constant name must_C_version +# wrong constant name [] +# wrong constant name []= +# wrong constant name dig +# wrong constant name each_pair +# wrong constant name length +# wrong constant name members +# wrong constant name select +# wrong constant name size +# wrong constant name to_a +# wrong constant name to_h +# wrong constant name values +# wrong constant name values_at +# wrong constant name errno +# wrong constant name status +# wrong constant name success? +# wrong constant name T.noreturn +# wrong constant name T.noreturn +# wrong constant name T.untyped +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name [] +# wrong constant name []= +# wrong constant name clear +# wrong constant name compute +# wrong constant name compute_if_absent +# wrong constant name compute_if_present +# wrong constant name delete +# wrong constant name delete_pair +# wrong constant name each_pair +# wrong constant name empty? +# wrong constant name get_and_set +# wrong constant name get_or_default +# wrong constant name initialize +# wrong constant name key? +# wrong constant name merge_pair +# wrong constant name replace_if_exists +# wrong constant name replace_pair +# wrong constant name size +# wrong constant name initialize +# wrong constant name key +# wrong constant name key? +# wrong constant name locked? +# wrong constant name matches? +# wrong constant name pure_hash +# wrong constant name try_await_lock +# wrong constant name try_lock_via_hash +# wrong constant name unlock_via_hash +# wrong constant name +# wrong constant name locked_hash? +# uninitialized constant ThreadSafe::AtomicReferenceCacheBackend::Table::Elem +# wrong constant name cas_new_node +# wrong constant name delete_node_at +# wrong constant name try_lock_via_hash +# wrong constant name try_to_cas_in_computed +# wrong constant name +# wrong constant name +# wrong constant name lock +# wrong constant name locked? +# wrong constant name synchronize +# wrong constant name try_lock +# wrong constant name unlock +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant ThreadSafe::Util::Adder::THREAD_LOCAL_KEY +# Did you mean? ThreadSafe::Util::Adder::THREAD_LOCAL_KEY +# wrong constant name add +# wrong constant name decrement +# wrong constant name increment +# wrong constant name reset +# wrong constant name sum +# wrong constant name +# wrong constant name compare_and_set +# wrong constant name get +# wrong constant name initialize +# wrong constant name set +# wrong constant name value +# wrong constant name value= +# wrong constant name +# wrong constant name cas_mutex +# wrong constant name compare_and_set_mutex +# wrong constant name lazy_set_mutex +# wrong constant name mutex +# wrong constant name mutex= +# wrong constant name +# uninitialized constant ThreadSafe::Util::PowerOfTwoTuple::Elem +# wrong constant name hash_to_index +# wrong constant name next_in_size_table +# wrong constant name volatile_get_by_hash +# wrong constant name volatile_set_by_hash +# wrong constant name +# wrong constant name +# wrong constant name busy? +# wrong constant name initialize +# wrong constant name retry_update +# wrong constant name cas +# wrong constant name cas_computed +# wrong constant name padding_ +# wrong constant name +# wrong constant name +# wrong constant name attr_volatile +# wrong constant name +# uninitialized constant ThreadSafe::Util::VolatileTuple::Elem +# wrong constant name cas +# wrong constant name compare_and_set +# wrong constant name each +# wrong constant name initialize +# wrong constant name size +# wrong constant name volatile_get +# wrong constant name volatile_set +# wrong constant name +# wrong constant name get +# wrong constant name xorshift +# wrong constant name +# wrong constant name +# wrong constant name event +# wrong constant name decode +# wrong constant name encode +# wrong constant name escape +# wrong constant name unescape +# wrong constant name set_typecode +# wrong constant name typecode +# wrong constant name typecode= +# wrong constant name new2 +# wrong constant name request_uri +# wrong constant name attributes +# wrong constant name attributes= +# wrong constant name dn +# wrong constant name dn= +# wrong constant name extensions +# wrong constant name extensions= +# wrong constant name filter +# wrong constant name filter= +# wrong constant name initialize +# wrong constant name scope +# wrong constant name scope= +# wrong constant name set_attributes +# wrong constant name set_dn +# wrong constant name set_extensions +# wrong constant name set_filter +# wrong constant name set_scope +# wrong constant name headers +# wrong constant name headers= +# wrong constant name initialize +# wrong constant name set_headers +# wrong constant name set_to +# wrong constant name to +# wrong constant name to= +# wrong constant name to_mailtext +# wrong constant name to_rfc822text +# wrong constant name escape +# wrong constant name extract +# wrong constant name initialize +# wrong constant name join +# wrong constant name make_regexp +# wrong constant name parse +# wrong constant name pattern +# wrong constant name regexp +# wrong constant name split +# wrong constant name unescape +# wrong constant name join +# wrong constant name parse +# wrong constant name regexp +# wrong constant name split +# wrong constant name make_components_hash +# wrong constant name decode_www_form +# wrong constant name encode_www_form +# wrong constant name encode_www_form_component +# wrong constant name get_encoding +# wrong constant name clone +# wrong constant name original_name +# wrong constant name tag +# wrong constant name value +# uninitialized constant WEBrick +# uninitialized constant WEBrick +# wrong constant name warn diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi new file mode 100644 index 0000000..a49e5ce --- /dev/null +++ b/sorbet/rbi/hidden-definitions/hidden.rbi @@ -0,0 +1,4741 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi hidden-definitions + +# typed: autogenerated + +class Array + include ::JSON::Ext::Generator::GeneratorMethods::Array + def bsearch(); end + + def bsearch_index(); end + + def collect!(); end + + def dig(*_); end + + def flatten!(*_); end + + def pack(*_); end + + def replace(_); end + + def shelljoin(); end + + def to_h(); end +end + +class Array + def self.try_convert(_); end +end + +module Axiom::Types + Contradiction = ::T.let(nil, ::T.untyped) + Tautology = ::T.let(nil, ::T.untyped) + Undefined = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Axiom::Types::DateTime + MAXIMUM_SECONDS = ::T.let(nil, ::T.untyped) +end + +class Axiom::Types::Infinity + include ::Singleton +end + +class Axiom::Types::Infinity + extend ::DescendantsTracker +end + +class Axiom::Types::String + extend ::Axiom::Types::Encodable +end + +class Axiom::Types::Symbol + extend ::Axiom::Types::Encodable +end + +class Axiom::Types::Time + MAXIMUM_SECONDS = ::T.let(nil, ::T.untyped) + MINIMUM_SECONDS = ::T.let(nil, ::T.untyped) +end + +class Axiom::Types::Type + extend ::DescendantsTracker +end + +BasicObject::BasicObject = BasicObject + +class BigDecimal + def to_d(); end + + def to_digits(); end + EXCEPTION_NaN = ::T.let(nil, ::T.untyped) + SIGN_NaN = ::T.let(nil, ::T.untyped) +end + +class BigDecimal + def self.ver(); end +end + +class Binding + def clone(); end +end + +Bundler::Deprecate = Gem::Deprecate + +class Bundler::Env +end + +class Bundler::Env + def self.environment(); end + + def self.report(options=T.unsafe(nil)); end + + def self.write(io); end +end + +class Bundler::FeatureFlag + def github_https?(); end + + def lockfile_upgrade_warning?(); end +end + +class Bundler::Fetcher + def fetch_spec(spec); end + + def fetchers(); end + + def http_proxy(); end + + def initialize(remote); end + + def specs(gem_names, source); end + + def specs_with_retry(gem_names, source); end + + def uri(); end + + def use_api(); end + + def user_agent(); end + FAIL_ERRORS = ::T.let(nil, ::T.untyped) + FETCHERS = ::T.let(nil, ::T.untyped) + HTTP_ERRORS = ::T.let(nil, ::T.untyped) + NET_ERRORS = ::T.let(nil, ::T.untyped) +end + +class Bundler::Fetcher::AuthenticationRequiredError + def initialize(remote_uri); end +end + +class Bundler::Fetcher::BadAuthenticationError + def initialize(remote_uri); end +end + +class Bundler::Fetcher::Base + def api_fetcher?(); end + + def available?(); end + + def display_uri(); end + + def downloader(); end + + def fetch_uri(); end + + def initialize(downloader, remote, display_uri); end + + def remote(); end + + def remote_uri(); end +end + +class Bundler::Fetcher::Base +end + +class Bundler::Fetcher::CertificateFailureError + def initialize(remote_uri); end +end + +class Bundler::Fetcher::CompactIndex + def available?(*args, &blk); end + + def fetch_spec(*args, &blk); end + + def specs(*args, &blk); end + + def specs_for_names(gem_names); end +end + +class Bundler::Fetcher::CompactIndex::ClientFetcher + def call(path, headers); end + + def fetcher(); end + + def fetcher=(_); end + + def ui(); end + + def ui=(_); end +end + +class Bundler::Fetcher::CompactIndex::ClientFetcher + def self.[](*_); end + + def self.members(); end +end + +class Bundler::Fetcher::CompactIndex + def self.compact_index_request(method_name); end +end + +class Bundler::Fetcher::Dependency + def dependency_api_uri(gem_names=T.unsafe(nil)); end + + def dependency_specs(gem_names); end + + def get_formatted_specs_and_deps(gem_list); end + + def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end + + def unmarshalled_dep_gems(gem_names); end +end + +class Bundler::Fetcher::Dependency +end + +class Bundler::Fetcher::Downloader + def connection(); end + + def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end + + def initialize(connection, redirect_limit); end + + def redirect_limit(); end + + def request(uri, headers); end +end + +class Bundler::Fetcher::Downloader +end + +class Bundler::Fetcher::Index + def fetch_spec(spec); end + + def specs(_gem_names); end +end + +class Bundler::Fetcher::Index +end + +class Bundler::Fetcher::SSLError + def initialize(msg=T.unsafe(nil)); end +end + +class Bundler::Fetcher + def self.api_timeout(); end + + def self.api_timeout=(api_timeout); end + + def self.disable_endpoint(); end + + def self.disable_endpoint=(disable_endpoint); end + + def self.max_retries(); end + + def self.max_retries=(max_retries); end + + def self.redirect_limit(); end + + def self.redirect_limit=(redirect_limit); end +end + +module Bundler::FileUtils + VERSION = ::T.let(nil, ::T.untyped) +end + +class Bundler::FileUtils::Entry_ + def link(dest); end +end + +module Bundler::FileUtils + def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end + + def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end +end + +class Bundler::GemHelper + include ::Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ + def allowed_push_host(); end + + def already_tagged?(); end + + def base(); end + + def build_gem(); end + + def built_gem_path(); end + + def clean?(); end + + def committed?(); end + + def gem_key(); end + + def gem_push?(); end + + def gem_push_host(); end + + def gemspec(); end + + def git_push(remote=T.unsafe(nil)); end + + def guard_clean(); end + + def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end + + def install(); end + + def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end + + def name(); end + + def perform_git_push(options=T.unsafe(nil)); end + + def rubygem_push(path); end + + def sh(cmd, &block); end + + def sh_with_input(cmd); end + + def sh_with_status(cmd, &block); end + + def spec_path(); end + + def tag_version(); end + + def version(); end + + def version_tag(); end +end + +class Bundler::GemHelper + def self.gemspec(&block); end + + def self.install_tasks(opts=T.unsafe(nil)); end + + def self.instance(); end + + def self.instance=(instance); end +end + +class Bundler::GemRemoteFetcher +end + +class Bundler::GemRemoteFetcher +end + +class Bundler::GemVersionPromoter + def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end + + def level(); end + + def level=(value); end + + def locked_specs(); end + + def major?(); end + + def minor?(); end + + def prerelease_specified(); end + + def prerelease_specified=(prerelease_specified); end + + def sort_versions(dep, spec_groups); end + + def strict(); end + + def strict=(strict); end + + def unlock_gems(); end + DEBUG = ::T.let(nil, ::T.untyped) +end + +class Bundler::GemVersionPromoter +end + +class Bundler::Graph + def edge_options(); end + + def groups(); end + + def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end + + def node_options(); end + + def output_file(); end + + def output_format(); end + + def relations(); end + + def viz(); end + GRAPH_NAME = ::T.let(nil, ::T.untyped) +end + +class Bundler::Graph::GraphVizClient + def g(); end + + def initialize(graph_instance); end + + def run(); end +end + +class Bundler::Graph::GraphVizClient +end + +class Bundler::Graph +end + +class Bundler::Index + include ::Enumerable +end + +class Bundler::Injector + def initialize(deps, options=T.unsafe(nil)); end + + def inject(gemfile_path, lockfile_path); end + + def remove(gemfile_path, lockfile_path); end + INJECTED_GEMS = ::T.let(nil, ::T.untyped) +end + +class Bundler::Injector + def self.inject(new_deps, options=T.unsafe(nil)); end + + def self.remove(gems, options=T.unsafe(nil)); end +end + +class Bundler::Installer + def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end + + def generate_standalone_bundler_executable_stubs(spec); end + + def initialize(root, definition); end + + def post_install_messages(); end + + def run(options); end +end + +class Bundler::Installer + def self.ambiguous_gems(); end + + def self.ambiguous_gems=(ambiguous_gems); end + + def self.install(root, definition, options=T.unsafe(nil)); end +end + +class Bundler::Molinillo::DependencyGraph + include ::Enumerable +end + +class Bundler::Molinillo::DependencyGraph::Log + extend ::Enumerable +end + +module Bundler::Plugin::API::Source + def ==(other); end + + def app_cache_dirname(); end + + def app_cache_path(custom_path=T.unsafe(nil)); end + + def bundler_plugin_api_source?(); end + + def cache(spec, custom_path=T.unsafe(nil)); end + + def cached!(); end + + def can_lock?(spec); end + + def dependency_names(); end + + def dependency_names=(dependency_names); end + + def double_check_for(*_); end + + def eql?(other); end + + def fetch_gemspec_files(); end + + def gem_install_dir(); end + + def hash(); end + + def include?(other); end + + def initialize(opts); end + + def install(spec, opts); end + + def install_path(); end + + def installed?(); end + + def name(); end + + def options(); end + + def options_to_lock(); end + + def post_install(spec, disable_exts=T.unsafe(nil)); end + + def remote!(); end + + def root(); end + + def specs(); end + + def to_lock(); end + + def to_s(); end + + def unlock!(); end + + def unmet_deps(); end + + def uri(); end + + def uri_hash(); end +end + +module Bundler::Plugin::API::Source +end + +module Bundler::Plugin::Events + GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped) + GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped) + GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped) + GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped) +end + +class Bundler::Plugin::Index::CommandConflict + def initialize(plugin, commands); end +end + +class Bundler::Plugin::Index::CommandConflict +end + +class Bundler::Plugin::Index::SourceConflict + def initialize(plugin, sources); end +end + +class Bundler::Plugin::Index::SourceConflict +end + +class Bundler::Plugin::Installer + def install(names, options); end + + def install_definition(definition); end +end + +class Bundler::Plugin::Installer::Git + def generate_bin(spec, disable_extensions=T.unsafe(nil)); end +end + +class Bundler::Plugin::Installer::Git +end + +class Bundler::Plugin::Installer::Rubygems +end + +class Bundler::Plugin::Installer::Rubygems +end + +class Bundler::Plugin::Installer +end + +class Bundler::Plugin::SourceList +end + +class Bundler::Plugin::SourceList +end + +class Bundler::ProcessLock +end + +class Bundler::ProcessLock + def self.lock(bundle_path=T.unsafe(nil)); end +end + +class Bundler::Retry + def attempt(&block); end + + def attempts(&block); end + + def current_run(); end + + def current_run=(current_run); end + + def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end + + def name(); end + + def name=(name); end + + def total_runs(); end + + def total_runs=(total_runs); end +end + +class Bundler::Retry + def self.attempts(); end + + def self.default_attempts(); end + + def self.default_retries(); end +end + +class Bundler::RubyGemsGemInstaller +end + +class Bundler::RubyGemsGemInstaller +end + +class Bundler::RubygemsIntegration::MoreFuture + def default_stubs(); end +end + +class Bundler::Settings::Mirror + def ==(other); end + + def fallback_timeout(); end + + def fallback_timeout=(timeout); end + + def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end + + def uri(); end + + def uri=(uri); end + + def valid?(); end + + def validate!(probe=T.unsafe(nil)); end + DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped) +end + +class Bundler::Settings::Mirror +end + +class Bundler::Settings::Mirrors + def each(&blk); end + + def for(uri); end + + def initialize(prober=T.unsafe(nil)); end + + def parse(key, value); end +end + +class Bundler::Settings::Mirrors +end + +class Bundler::Settings::Validator +end + +class Bundler::Settings::Validator::Rule + def description(); end + + def fail!(key, value, *reasons); end + + def initialize(keys, description, &validate); end + + def k(key); end + + def set(settings, key, value, *reasons); end + + def validate!(key, value, settings); end +end + +class Bundler::Settings::Validator::Rule +end + +class Bundler::Settings::Validator + def self.validate!(key, value, settings); end +end + +class Bundler::SpecSet + include ::Enumerable +end + +class Bundler::UI::Shell + def add_color(string, *color); end + + def ask(msg); end + + def confirm(msg, newline=T.unsafe(nil)); end + + def debug(msg, newline=T.unsafe(nil)); end + + def debug?(); end + + def error(msg, newline=T.unsafe(nil)); end + + def info(msg, newline=T.unsafe(nil)); end + + def initialize(options=T.unsafe(nil)); end + + def level(name=T.unsafe(nil)); end + + def level=(level); end + + def no?(); end + + def quiet?(); end + + def shell=(shell); end + + def silence(&blk); end + + def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end + + def unprinted_warnings(); end + + def warn(msg, newline=T.unsafe(nil)); end + + def yes?(msg); end + LEVELS = ::T.let(nil, ::T.untyped) +end + +class Bundler::UI::Shell +end + +module Bundler::VersionRanges +end + +class Bundler::VersionRanges::NEq + def version(); end + + def version=(_); end +end + +class Bundler::VersionRanges::NEq + def self.[](*_); end + + def self.members(); end +end + +class Bundler::VersionRanges::ReqR + def cover?(v); end + + def empty?(); end + + def left(); end + + def left=(_); end + + def right(); end + + def right=(_); end + + def single?(); end + INFINITY = ::T.let(nil, ::T.untyped) + UNIVERSAL = ::T.let(nil, ::T.untyped) + ZERO = ::T.let(nil, ::T.untyped) +end + +class Bundler::VersionRanges::ReqR::Endpoint + def inclusive(); end + + def inclusive=(_); end + + def version(); end + + def version=(_); end +end + +class Bundler::VersionRanges::ReqR::Endpoint + def self.[](*_); end + + def self.members(); end +end + +class Bundler::VersionRanges::ReqR + def self.[](*_); end + + def self.members(); end +end + +module Bundler::VersionRanges + def self.empty?(ranges, neqs); end + + def self.for(requirement); end + + def self.for_many(requirements); end +end + +class CCEngine::Issue + include ::Virtus::Model::Core + include ::Virtus::ClassInclusions::Methods + include ::Virtus::InstanceMethods + include ::Virtus::Model::Constructor + include ::Virtus::InstanceMethods::Constructor + include ::Virtus::Model::MassAssignment + include ::Virtus::InstanceMethods::MassAssignment +end + +class CCEngine::Issue + extend ::Virtus::ClassMethods + extend ::Virtus::Extensions::Methods + extend ::Virtus::ConstMissingExtensions + extend ::Virtus::Extensions::AllowedWriterMethods +end + +class CCEngine::Location::LineRange + include ::Virtus::Model::Core + include ::Virtus::ClassInclusions::Methods + include ::Virtus::InstanceMethods + include ::Virtus::Model::Constructor + include ::Virtus::InstanceMethods::Constructor + include ::Virtus::Model::MassAssignment + include ::Virtus::InstanceMethods::MassAssignment +end + +class CCEngine::Location::LineRange + extend ::Virtus::ClassMethods + extend ::Virtus::Extensions::Methods + extend ::Virtus::ConstMissingExtensions + extend ::Virtus::Extensions::AllowedWriterMethods +end + +class CCEngine::Location::Position + include ::Virtus::Model::Core + include ::Virtus::ClassInclusions::Methods + include ::Virtus::InstanceMethods + include ::Virtus::Model::Constructor + include ::Virtus::InstanceMethods::Constructor + include ::Virtus::Model::MassAssignment + include ::Virtus::InstanceMethods::MassAssignment +end + +class CCEngine::Location::Position + extend ::Virtus::ClassMethods + extend ::Virtus::Extensions::Methods + extend ::Virtus::ConstMissingExtensions + extend ::Virtus::Extensions::AllowedWriterMethods +end + +class CCEngine::Position::Grid + include ::Virtus::Model::Core + include ::Virtus::ClassInclusions::Methods + include ::Virtus::InstanceMethods + include ::Virtus::Model::Constructor + include ::Virtus::InstanceMethods::Constructor + include ::Virtus::Model::MassAssignment + include ::Virtus::InstanceMethods::MassAssignment +end + +class CCEngine::Position::Grid + extend ::Virtus::ClassMethods + extend ::Virtus::Extensions::Methods + extend ::Virtus::ConstMissingExtensions + extend ::Virtus::Extensions::AllowedWriterMethods +end + +class CCEngine::Position::Offset + include ::Virtus::Model::Core + include ::Virtus::ClassInclusions::Methods + include ::Virtus::InstanceMethods + include ::Virtus::Model::Constructor + include ::Virtus::InstanceMethods::Constructor + include ::Virtus::Model::MassAssignment + include ::Virtus::InstanceMethods::MassAssignment +end + +class CCEngine::Position::Offset + extend ::Virtus::ClassMethods + extend ::Virtus::Extensions::Methods + extend ::Virtus::ConstMissingExtensions + extend ::Virtus::Extensions::AllowedWriterMethods +end + +module CGI::HtmlExtension + def a(href=T.unsafe(nil)); end + + def base(href=T.unsafe(nil)); end + + def blockquote(cite=T.unsafe(nil)); end + + def caption(align=T.unsafe(nil)); end + + def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end + + def checkbox_group(name=T.unsafe(nil), *values); end + + def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end + + def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end + + def html(attributes=T.unsafe(nil)); end + + def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end + + def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end + + def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end + + def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def popup_menu(name=T.unsafe(nil), *values); end + + def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end + + def radio_group(name=T.unsafe(nil), *values); end + + def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end + + def scrolling_list(name=T.unsafe(nil), *values); end + + def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end + + def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end +end + +module CGI::HtmlExtension +end + +class Class + def json_creatable?(); end +end + +module Coercible + EXTRA_CONST_ARGS = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Coercible::Coercer::Array + TIME_SEGMENTS = ::T.let(nil, ::T.untyped) +end + +class Coercible::Coercer::Decimal + FLOAT_FORMAT = ::T.let(nil, ::T.untyped) +end + +class Coercible::Coercer::Hash + TIME_SEGMENTS = ::T.let(nil, ::T.untyped) +end + +class Coercible::Coercer::Object + COERCION_METHOD_REGEXP = ::T.let(nil, ::T.untyped) +end + +class Coercible::Coercer::Object + extend ::Coercible::Options +end + +class Coercible::Coercer::String + BOOLEAN_MAP = ::T.let(nil, ::T.untyped) + EXPONENT_REGEXP = ::T.let(nil, ::T.untyped) + FALSE_VALUES = ::T.let(nil, ::T.untyped) + FRACTIONAL_REGEXP = ::T.let(nil, ::T.untyped) + INTEGER_REGEXP = ::T.let(nil, ::T.untyped) + NUMERIC_REGEXP = ::T.let(nil, ::T.untyped) + TRUE_VALUES = ::T.let(nil, ::T.untyped) +end + +module Coercible::TypeLookup + TYPE_FORMAT = ::T.let(nil, ::T.untyped) +end + +class Complex + def self.polar(*_); end + + def self.rect(*_); end + + def self.rectangular(*_); end +end + +class Date::Infinity + def initialize(d=T.unsafe(nil)); end +end + +class Delegator + def !=(obj); end + + def ==(obj); end + + def __getobj__(); end + + def __setobj__(obj); end + + def initialize(obj); end + + def marshal_dump(); end + + def marshal_load(data); end + + def method_missing(m, *args, &block); end + + def methods(all=T.unsafe(nil)); end + + def protected_methods(all=T.unsafe(nil)); end + + def public_methods(all=T.unsafe(nil)); end +end + +class Delegator + def self.const_missing(n); end + + def self.delegating_block(mid); end + + def self.public_api(); end +end + +class DidYouMean::ClassNameChecker + def class_name(); end + + def class_names(); end + + def corrections(); end + + def initialize(exception); end + + def scopes(); end +end + +module DidYouMean::Correctable + def corrections(); end + + def original_message(); end + + def spell_checker(); end + + def to_s(); end +end + +class DidYouMean::Formatter + def initialize(corrections=T.unsafe(nil)); end +end + +module DidYouMean::Jaro + def self.distance(str1, str2); end +end + +module DidYouMean::JaroWinkler + def self.distance(str1, str2); end +end + +module DidYouMean::Levenshtein + def self.distance(str1, str2); end + + def self.min3(a, b, c); end +end + +class DidYouMean::MethodNameChecker + def corrections(); end + + def initialize(exception); end + + def method_name(); end + + def method_names(); end + + def receiver(); end +end + +module DidYouMean::NameErrorCheckers + def self.included(*_); end + + def self.new(exception); end +end + +class DidYouMean::NullChecker + def corrections(); end + + def initialize(*_); end +end + +class DidYouMean::SpellChecker + def correct(input); end + + def initialize(dictionary:); end +end + +class DidYouMean::VariableNameChecker + def corrections(); end + + def cvar_names(); end + + def initialize(exception); end + + def ivar_names(); end + + def lvar_names(); end + + def method_names(); end + + def name(); end +end + +class Dir + def self.empty?(_); end + + def self.exists?(_); end + + def self.tmpdir(); end +end + +class ERB + def def_method(mod, methodname, fname=T.unsafe(nil)); end + + def def_module(methodname=T.unsafe(nil)); end +end + +class Encoding + def _dump(*_); end +end + +class Encoding::Converter + def convert(_); end + + def convpath(); end + + def destination_encoding(); end + + def finish(); end + + def initialize(*_); end + + def insert_output(_); end + + def last_error(); end + + def primitive_convert(*_); end + + def primitive_errinfo(); end + + def putback(*_); end + + def replacement(); end + + def replacement=(replacement); end + + def source_encoding(); end +end + +class Encoding::Converter + def self.asciicompat_encoding(_); end + + def self.search_convpath(*_); end +end + +class Encoding::InvalidByteSequenceError + def destination_encoding(); end + + def destination_encoding_name(); end + + def error_bytes(); end + + def incomplete_input?(); end + + def readagain_bytes(); end + + def source_encoding(); end + + def source_encoding_name(); end +end + +class Encoding::UndefinedConversionError + def destination_encoding(); end + + def destination_encoding_name(); end + + def error_char(); end + + def source_encoding(); end + + def source_encoding_name(); end +end + +class Encoding + def self._load(_); end + + def self.locale_charmap(); end +end + +module Enumerable + def chunk(); end + + def chunk_while(); end + + def each_entry(*_); end + + def grep_v(_); end + + def slice_after(*_); end + + def slice_before(*_); end + + def slice_when(); end + + def sum(*_); end + + def to_set(klass=T.unsafe(nil), *args, &block); end + + def uniq(); end + + def zip(*_); end +end + +class Enumerator + def each_with_index(); end +end + +class Enumerator::Generator + def each(*_, &blk); end + + def initialize(*_); end +end + +class Enumerator::Lazy + def chunk(*_); end + + def chunk_while(*_); end + + def force(*_); end + + def slice_when(*_); end +end + +class Errno::EAUTH + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EAUTH +end + +class Errno::EBADRPC + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EBADRPC +end + +Errno::ECAPMODE = Errno::NOERROR + +Errno::EDEADLOCK = Errno::NOERROR + +Errno::EDOOFUS = Errno::NOERROR + +class Errno::EFTYPE + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EFTYPE +end + +Errno::EIPSEC = Errno::NOERROR + +class Errno::ENEEDAUTH + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::ENEEDAUTH +end + +class Errno::ENOATTR + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::ENOATTR +end + +Errno::ENOTCAPABLE = Errno::NOERROR + +class Errno::ENOTSUP + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::ENOTSUP +end + +class Errno::EPROCLIM + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EPROCLIM +end + +class Errno::EPROCUNAVAIL + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EPROCUNAVAIL +end + +class Errno::EPROGMISMATCH + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EPROGMISMATCH +end + +class Errno::EPROGUNAVAIL + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::EPROGUNAVAIL +end + +class Errno::ERPCMISMATCH + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::ERPCMISMATCH +end + +class Etc::Group + def gid(); end + + def gid=(_); end + + def mem(); end + + def mem=(_); end + + def name(); end + + def name=(_); end + + def passwd(); end + + def passwd=(_); end +end + +class Etc::Group + extend ::Enumerable + def self.[](*_); end + + def self.each(&blk); end + + def self.members(); end +end + +class Etc::Passwd + def change(); end + + def change=(_); end + + def dir(); end + + def dir=(_); end + + def expire(); end + + def expire=(_); end + + def gecos(); end + + def gecos=(_); end + + def gid(); end + + def gid=(_); end + + def name(); end + + def name=(_); end + + def passwd(); end + + def passwd=(_); end + + def shell(); end + + def shell=(_); end + + def uclass(); end + + def uclass=(_); end + + def uid(); end + + def uid=(_); end +end + +class Etc::Passwd + extend ::Enumerable + def self.[](*_); end + + def self.each(&blk); end + + def self.members(); end +end + +module Etc + def self.confstr(_); end + + def self.endgrent(); end + + def self.endpwent(); end + + def self.getgrent(); end + + def self.getgrgid(*_); end + + def self.getgrnam(_); end + + def self.getlogin(); end + + def self.getpwent(); end + + def self.getpwnam(_); end + + def self.getpwuid(*_); end + + def self.group(); end + + def self.nprocessors(); end + + def self.passwd(); end + + def self.setgrent(); end + + def self.setpwent(); end + + def self.sysconf(_); end + + def self.sysconfdir(); end + + def self.systmpdir(); end + + def self.uname(); end +end + +class Exception + def self.exception(*_); end +end + +class ExitCalledError +end + +class ExitCalledError +end + +class FalseClass + include ::JSON::Ext::Generator::GeneratorMethods::FalseClass +end + +class Fiber + def resume(*_); end +end + +class Fiber + def self.yield(*_); end +end + +class File + Separator = ::T.let(nil, ::T.untyped) +end + +class File::Stat + def size?(); end +end + +class File + def self.empty?(_); end + + def self.exists?(_); end + + def self.mkfifo(*_); end +end + +FileList = Rake::FileList + +module FileUtils + include ::FileUtils::StreamUtils_ + LN_SUPPORTED = ::T.let(nil, ::T.untyped) + RUBY = ::T.let(nil, ::T.untyped) +end + +module FileUtils::DryRun + include ::FileUtils + include ::FileUtils::StreamUtils_ + include ::FileUtils::LowMethods +end + +module FileUtils::DryRun + extend ::FileUtils::DryRun + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils::LowMethods +end + +module FileUtils::NoWrite + include ::FileUtils + include ::FileUtils::StreamUtils_ + include ::FileUtils::LowMethods +end + +module FileUtils::NoWrite + extend ::FileUtils::NoWrite + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils::LowMethods +end + +module FileUtils::Verbose + include ::FileUtils + include ::FileUtils::StreamUtils_ +end + +module FileUtils::Verbose + extend ::FileUtils::Verbose + extend ::FileUtils + extend ::FileUtils::StreamUtils_ +end + +module FileUtils + extend ::FileUtils::StreamUtils_ +end + +class Float + include ::JSON::Ext::Generator::GeneratorMethods::Float + def to_d(precision=T.unsafe(nil)); end +end + +module GC + def garbage_collect(*_); end +end + +module GC + def self.latest_gc_info(*_); end + + def self.stress=(stress); end + + def self.verify_internal_consistency(); end +end + +class Gem::Package::TarHeader + def self.oct_or_256based(str); end +end + +class Gem::RemoteFetcher + def s3_uri_signer(uri); end +end + +class Gem::Resolver::Molinillo::DependencyGraph::Log + extend ::Enumerable +end + +class Gem::S3URISigner + def initialize(uri); end + + def sign(expiration=T.unsafe(nil)); end + + def uri(); end + + def uri=(uri); end + BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped) + EC2_METADATA_CREDENTIALS = ::T.let(nil, ::T.untyped) +end + +class Gem::S3URISigner::ConfigurationError + def initialize(message); end +end + +class Gem::S3URISigner::ConfigurationError +end + +class Gem::S3URISigner::InstanceProfileError + def initialize(message); end +end + +class Gem::S3URISigner::InstanceProfileError +end + +class Gem::S3URISigner::S3Config + def access_key_id(); end + + def access_key_id=(_); end + + def region(); end + + def region=(_); end + + def secret_access_key(); end + + def secret_access_key=(_); end + + def security_token(); end + + def security_token=(_); end +end + +class Gem::S3URISigner::S3Config + def self.[](*_); end + + def self.members(); end +end + +class Gem::S3URISigner +end + +class Gem::Specification + extend ::Enumerable +end + +module Gem::Util + def self.correct_for_windows_path(path); end +end + +class Hash + include ::JSON::Ext::Generator::GeneratorMethods::Hash + def <(_); end + + def <=(_); end + + def >(_); end + + def >=(_); end + + def compact(); end + + def compact!(); end + + def default_proc(); end + + def default_proc=(default_proc); end + + def dig(*_); end + + def fetch_values(*_); end + + def flatten(*_); end + + def index(_); end + + def merge!(_); end + + def replace(_); end + + def to_h(); end + + def to_proc(); end + + def transform_values(); end + + def transform_values!(); end + + def update(_); end +end + +class Hash + def self.try_convert(_); end +end + +class IO + def external_encoding(); end + + def nonblock(*_); end + + def nonblock=(nonblock); end + + def nonblock?(); end + + def nread(); end + + def pathconf(_); end + + def ready?(); end + + def wait(*_); end + + def wait_readable(*_); end + + def wait_writable(*_); end + + def write_nonblock(buf, exception: T.unsafe(nil)); end +end + +IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable + +IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable + +class IO + def self.foreach(*_); end + + def self.pipe(*_); end +end + +module IceNine + VERSION = ::T.let(nil, ::T.untyped) +end + +IceNine::Freezer::BasicObject = IceNine::Freezer::Object + +class Integer + include ::JSON::Ext::Generator::GeneratorMethods::Integer + def digits(*_); end + + def to_bn(); end + + def to_d(); end +end + +class JSON::Ext::Generator::State + def self.from_state(_); end +end + +class JSON::Ext::Parser + def initialize(*_); end +end + +JSON::Parser = JSON::Ext::Parser + +JSON::State = JSON::Ext::Generator::State + +JSON::UnparserError = JSON::GeneratorError + +module Kernel + def gem(dep, *reqs); end + + def itself(); end + + def object_id(); end + + def pretty_inspect(); end + + def respond_to?(*_); end +end + +module Kernel + def self.at_exit(); end +end + +class LoadError + def path(); end +end + +class LocalJumpError + def exit_value(); end + + def reason(); end +end + +module Marshal + def self.restore(*_); end +end + +class Module + def deprecate_constant(*_); end +end + +class Module + def self.used_modules(); end +end + +class Monitor + def enter(); end + + def exit(); end + + def try_enter(); end +end + +module MonitorMixin + def initialize(*args); end + + def mon_enter(); end + + def mon_exit(); end + + def mon_synchronize(); end + + def mon_try_enter(); end + + def new_cond(); end + + def synchronize(); end + + def try_mon_enter(); end +end + +class MonitorMixin::ConditionVariable + def broadcast(); end + + def initialize(monitor); end + + def signal(); end + + def wait(timeout=T.unsafe(nil)); end + + def wait_until(); end + + def wait_while(); end +end + +module MonitorMixin + def self.extend_object(obj); end +end + +class NameError + include ::DidYouMean::Correctable + def name(); end + + def receiver(); end +end + +class NilClass + include ::JSON::Ext::Generator::GeneratorMethods::NilClass + def to_i(); end +end + +class NoMethodError + def args(); end + + def private_call?(); end +end + +class Object + include ::JSON::Ext::Generator::GeneratorMethods::Object + include ::PP::ObjectMixin + ARGF = ::T.let(nil, ::T.untyped) + ARGV = ::T.let(nil, ::T.untyped) + CROSS_COMPILING = ::T.let(nil, ::T.untyped) + ENV = ::T.let(nil, ::T.untyped) + RAKEVERSION = ::T.let(nil, ::T.untyped) + RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped) + RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped) + RUBY_ENGINE = ::T.let(nil, ::T.untyped) + RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped) + RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped) + RUBY_PLATFORM = ::T.let(nil, ::T.untyped) + RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped) + RUBY_REVISION = ::T.let(nil, ::T.untyped) + RUBY_VERSION = ::T.let(nil, ::T.untyped) + STDERR = ::T.let(nil, ::T.untyped) + STDIN = ::T.let(nil, ::T.untyped) + STDOUT = ::T.let(nil, ::T.untyped) + TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) +end + +class ObjectSpace::WeakMap + def [](_); end + + def []=(_, _1); end + + def each(&blk); end + + def each_key(); end + + def each_pair(); end + + def each_value(); end + + def key?(_); end + + def keys(); end + + def length(); end + + def size(); end + + def values(); end +end + +module ObjectSpace + def self.count_objects(*_); end + + def self.define_finalizer(*_); end + + def self.garbage_collect(*_); end + + def self.undefine_finalizer(_); end +end + +class Pathname + def empty?(); end + + def fnmatch?(*_); end + + def make_symlink(_); end +end + +class Proc + def ===(*_); end + + def clone(); end + + def yield(*_); end +end + +module Process + CLOCK_MONOTONIC_RAW_APPROX = ::T.let(nil, ::T.untyped) + CLOCK_UPTIME_RAW = ::T.let(nil, ::T.untyped) + CLOCK_UPTIME_RAW_APPROX = ::T.let(nil, ::T.untyped) +end + +module Process::Sys + def self.getegid(); end +end + +class Process::Tms + def cstime(); end + + def cstime=(_); end + + def cutime(); end + + def cutime=(_); end + + def stime(); end + + def stime=(_); end + + def utime(); end + + def utime=(_); end +end + +class Process::Tms + def self.[](*_); end + + def self.members(); end +end + +module Process + def self.setpgrp(); end +end + +module RSpec + MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped) +end + +class RSpec::CallerFilter + ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped) + IGNORE_REGEX = ::T.let(nil, ::T.untyped) + LIB_REGEX = ::T.let(nil, ::T.untyped) + RSPEC_LIBS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Configuration + DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped) + FAILED_STATUS = ::T.let(nil, ::T.untyped) + MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped) + PASSED_STATUS = ::T.let(nil, ::T.untyped) + PENDING_STATUS = ::T.let(nil, ::T.untyped) + RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) + UNKNOWN_STATUS = ::T.let(nil, ::T.untyped) + VALID_STATUSES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::ConfigurationOptions + OPTIONS_ORDER = ::T.let(nil, ::T.untyped) + UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped) + UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped) +end + +RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + +class RSpec::Core::ExampleGroup + include ::RSpec::Core::MockingAdapters::RSpec + include ::RSpec::Mocks::ExampleMethods + include ::RSpec::Mocks::ArgumentMatchers + include ::RSpec::Mocks::ExampleMethods::ExpectHost + include ::RSpec::Matchers + INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::ExampleStatusPersister + def initialize(examples, file_name); end + + def persist(); end +end + +class RSpec::Core::ExampleStatusPersister + def self.load_from(file_name); end + + def self.persist(examples, file_name); end +end + +RSpec::Core::ExclusionRules = RSpec::Core::FilterRules + +class RSpec::Core::FilterRules + PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped) + PROJECT_DIR = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def example_failed(notification); end + + def example_finished(notification); end + + def initialize(expected_failures); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def self.inherited(formatter); end +end + +class RSpec::Core::Formatters::BaseFormatter + def close(_notification); end + + def example_group(); end + + def example_group=(example_group); end + + def example_group_started(notification); end + + def initialize(output); end + + def output(); end + + def start(notification); end +end + +class RSpec::Core::Formatters::BaseFormatter +end + +class RSpec::Core::Formatters::BaseTextFormatter + def dump_failures(notification); end + + def dump_pending(notification); end + + def dump_summary(summary); end + + def message(notification); end + + def seed(notification); end +end + +class RSpec::Core::Formatters::BaseTextFormatter +end + +class RSpec::Core::Formatters::BisectDRbFormatter + def initialize(_output); end + + def notify_results(results); end +end + +class RSpec::Core::Formatters::BisectDRbFormatter +end + +module RSpec::Core::Formatters::ConsoleCodes + VT100_CODES = ::T.let(nil, ::T.untyped) + VT100_CODE_VALUES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DeprecationFormatter + DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped) + RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped) + TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter + TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DocumentationFormatter + def example_failed(failure); end + + def example_group_finished(_notification); end + + def example_passed(passed); end + + def example_pending(pending); end +end + +class RSpec::Core::Formatters::DocumentationFormatter +end + +class RSpec::Core::Formatters::ExceptionPresenter + PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::FallbackMessageFormatter + def initialize(output); end + + def message(notification); end + + def output(); end +end + +class RSpec::Core::Formatters::FallbackMessageFormatter +end + +module RSpec::Core::Formatters::Helpers + DEFAULT_PRECISION = ::T.let(nil, ::T.untyped) + SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::HtmlFormatter + def dump_summary(summary); end + + def example_failed(failure); end + + def example_passed(passed); end + + def example_pending(pending); end + + def example_started(_notification); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::HtmlFormatter +end + +class RSpec::Core::Formatters::JsonFormatter + def dump_profile(profile); end + + def dump_profile_slowest_example_groups(profile); end + + def dump_profile_slowest_examples(profile); end + + def dump_summary(summary); end + + def message(notification); end + + def output_hash(); end + + def seed(notification); end + + def stop(notification); end +end + +class RSpec::Core::Formatters::JsonFormatter +end + +class RSpec::Core::Formatters::ProfileFormatter + def dump_profile(profile); end + + def initialize(output); end + + def output(); end +end + +class RSpec::Core::Formatters::ProfileFormatter +end + +class RSpec::Core::Formatters::ProgressFormatter + def example_failed(_notification); end + + def example_passed(_notification); end + + def example_pending(_notification); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::ProgressFormatter +end + +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + RESET_CODE = ::T.let(nil, ::T.untyped) +end + +RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + +class RSpec::Core::Hooks::HookCollections + EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped) + HOOK_TYPES = ::T.let(nil, ::T.untyped) + SCOPES = ::T.let(nil, ::T.untyped) + SCOPE_ALIASES = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Metadata + RESERVED_KEYS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Ordering::Random + MAX_32_BIT = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Pending + NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped) + NO_REASON_GIVEN = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Profiler + def example_group_finished(notification); end + + def example_group_started(notification); end + + def example_groups(); end + + def example_started(notification); end + NOTIFICATIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Profiler +end + +class RSpec::Core::Reporter + RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::SharedContext + def __shared_context_recordings(); end + + def after(*args, &block); end + + def append_after(*args, &block); end + + def append_before(*args, &block); end + + def around(*args, &block); end + + def before(*args, &block); end + + def context(*args, &block); end + + def describe(*args, &block); end + + def hooks(*args, &block); end + + def included(group); end + + def let(*args, &block); end + + def let!(*args, &block); end + + def prepend_after(*args, &block); end + + def prepend_before(*args, &block); end + + def subject(*args, &block); end + + def subject!(*args, &block); end +end + +class RSpec::Core::SharedContext::Recording + def args(); end + + def args=(_); end + + def block(); end + + def block=(_); end + + def method_name(); end + + def method_name=(_); end + + def playback_onto(group); end +end + +class RSpec::Core::SharedContext::Recording + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::SharedContext + def self.record(methods); end +end + +module RSpec::Core::ShellEscape + SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Version + STRING = ::T.let(nil, ::T.untyped) +end + +class RSpec::Expectations::BlockSnippetExtractor + def body_content_lines(); end + + def initialize(proc, method_name); end + + def method_name(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError +end + +class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockLocator + def beginning_line_number(); end + + def beginning_line_number=(_); end + + def body_content_locations(); end + + def method_call_location(); end + + def method_name(); end + + def method_name=(_); end + + def source(); end + + def source=(_); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockLocator + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor + def beginning_line_number(); end + + def beginning_line_number=(_); end + + def body_tokens(); end + + def method_name(); end + + def method_name=(_); end + + def source(); end + + def source=(_); end + + def state(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::Error +end + +class RSpec::Expectations::BlockSnippetExtractor::Error +end + +class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError +end + +class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError +end + +class RSpec::Expectations::BlockSnippetExtractor + def self.try_extracting_single_line_body_of(proc, method_name); end +end + +class RSpec::Expectations::Configuration + FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Expectations::FailureAggregator + def aggregate(); end + + def block_label(); end + + def call(failure, options); end + + def failures(); end + + def initialize(block_label, metadata); end + + def metadata(); end + + def other_errors(); end +end + +class RSpec::Expectations::FailureAggregator +end + +RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter + +class RSpec::Expectations::MultipleExpectationsNotMetError + include ::RSpec::Core::MultipleExceptionError::InterfaceTag + def aggregation_block_label(); end + + def aggregation_metadata(); end + + def all_exceptions(); end + + def exception_count_description(); end + + def failures(); end + + def initialize(failure_aggregator); end + + def other_errors(); end + + def summary(); end +end + +module RSpec::Expectations::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Matchers + BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped) + DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped) + HAS_REGEX = ::T.let(nil, ::T.untyped) +end + +RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + +class RSpec::Matchers::BuiltIn::All + def does_not_match?(_actual); end + + def failed_objects(); end + + def initialize(matcher); end + + def matcher(); end +end + +class RSpec::Matchers::BuiltIn::All +end + +class RSpec::Matchers::BuiltIn::BaseMatcher + UNDEFINED = ::T.let(nil, ::T.untyped) +end + +class RSpec::Matchers::BuiltIn::Be + include ::RSpec::Matchers::BuiltIn::BeHelpers + def <(operand); end + + def <=(operand); end + + def ==(operand); end + + def ===(operand); end + + def =~(operand); end + + def >(operand); end + + def >=(operand); end + + def initialize(*args); end +end + +class RSpec::Matchers::BuiltIn::Be +end + +class RSpec::Matchers::BuiltIn::BeAKindOf +end + +class RSpec::Matchers::BuiltIn::BeAKindOf +end + +class RSpec::Matchers::BuiltIn::BeAnInstanceOf +end + +class RSpec::Matchers::BuiltIn::BeAnInstanceOf +end + +class RSpec::Matchers::BuiltIn::BeBetween + def exclusive(); end + + def inclusive(); end + + def initialize(min, max); end +end + +class RSpec::Matchers::BuiltIn::BeBetween +end + +class RSpec::Matchers::BuiltIn::BeComparedTo + include ::RSpec::Matchers::BuiltIn::BeHelpers + def initialize(operand, operator); end +end + +class RSpec::Matchers::BuiltIn::BeComparedTo +end + +class RSpec::Matchers::BuiltIn::BeFalsey +end + +class RSpec::Matchers::BuiltIn::BeFalsey +end + +module RSpec::Matchers::BuiltIn::BeHelpers +end + +module RSpec::Matchers::BuiltIn::BeHelpers +end + +class RSpec::Matchers::BuiltIn::BeNil +end + +class RSpec::Matchers::BuiltIn::BeNil +end + +class RSpec::Matchers::BuiltIn::BePredicate + include ::RSpec::Matchers::BuiltIn::BeHelpers + def does_not_match?(actual, &block); end + + def initialize(*args, &block); end + + def matches?(actual, &block); end +end + +class RSpec::Matchers::BuiltIn::BePredicate +end + +class RSpec::Matchers::BuiltIn::BeTruthy +end + +class RSpec::Matchers::BuiltIn::BeTruthy +end + +class RSpec::Matchers::BuiltIn::BeWithin + def initialize(delta); end + + def of(expected); end + + def percent_of(expected); end +end + +class RSpec::Matchers::BuiltIn::BeWithin +end + +class RSpec::Matchers::BuiltIn::Change + def by(expected_delta); end + + def by_at_least(minimum); end + + def by_at_most(maximum); end + + def does_not_match?(event_proc); end + + def from(value); end + + def initialize(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def matches?(event_proc); end + + def to(value); end +end + +class RSpec::Matchers::BuiltIn::Change +end + +class RSpec::Matchers::BuiltIn::Compound + def diffable_matcher_list(); end + + def does_not_match?(_actual); end + + def evaluator(); end + + def initialize(matcher_1, matcher_2); end + + def matcher_1(); end + + def matcher_2(); end +end + +class RSpec::Matchers::BuiltIn::Compound::And +end + +class RSpec::Matchers::BuiltIn::Compound::And +end + +class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator + def initialize(actual, matcher_1, matcher_2); end + + def matcher_matches?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator + def self.matcher_expects_call_stack_jump?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::Or +end + +class RSpec::Matchers::BuiltIn::Compound::Or +end + +class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator + def initialize(actual, *_); end + + def matcher_matches?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator +end + +class RSpec::Matchers::BuiltIn::Compound +end + +class RSpec::Matchers::BuiltIn::ContainExactly +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer + def actual_to_expected_matched_indexes(); end + + def expected_to_actual_matched_indexes(); end + + def find_best_solution(); end + + def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end + + def solution(); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution + def self.worse_than?(_other); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution + def +(derived_candidate_solution); end + + def candidate?(); end + + def ideal?(); end + + def indeterminate_actual_indexes(); end + + def indeterminate_actual_indexes=(_); end + + def indeterminate_expected_indexes(); end + + def indeterminate_expected_indexes=(_); end + + def unmatched_actual_indexes(); end + + def unmatched_actual_indexes=(_); end + + def unmatched_expected_indexes(); end + + def unmatched_expected_indexes=(_); end + + def unmatched_item_count(); end + + def worse_than?(other); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer +end + +class RSpec::Matchers::BuiltIn::ContainExactly +end + +class RSpec::Matchers::BuiltIn::Cover + def does_not_match?(range); end + + def initialize(*expected); end + + def matches?(range); end +end + +class RSpec::Matchers::BuiltIn::Cover +end + +class RSpec::Matchers::BuiltIn::EndWith +end + +class RSpec::Matchers::BuiltIn::EndWith +end + +class RSpec::Matchers::BuiltIn::Eq +end + +class RSpec::Matchers::BuiltIn::Eq +end + +class RSpec::Matchers::BuiltIn::Eql +end + +class RSpec::Matchers::BuiltIn::Eql +end + +class RSpec::Matchers::BuiltIn::Equal + LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Matchers::BuiltIn::Equal +end + +class RSpec::Matchers::BuiltIn::Exist + def does_not_match?(actual); end + + def initialize(*expected); end +end + +class RSpec::Matchers::BuiltIn::Exist::ExistenceTest + def actual_exists?(); end + + def valid_test?(); end + + def validity_message(); end +end + +class RSpec::Matchers::BuiltIn::Exist::ExistenceTest +end + +class RSpec::Matchers::BuiltIn::Exist +end + +class RSpec::Matchers::BuiltIn::Has + def does_not_match?(actual, &block); end + + def initialize(method_name, *args, &block); end + + def matches?(actual, &block); end +end + +class RSpec::Matchers::BuiltIn::Has +end + +class RSpec::Matchers::BuiltIn::HaveAttributes + def does_not_match?(actual); end + + def initialize(expected); end + + def respond_to_failed(); end +end + +class RSpec::Matchers::BuiltIn::HaveAttributes +end + +class RSpec::Matchers::BuiltIn::Include + def does_not_match?(actual); end + + def expecteds(); end + + def initialize(*expecteds); end +end + +class RSpec::Matchers::BuiltIn::Include +end + +class RSpec::Matchers::BuiltIn::Match + def initialize(expected); end + + def with_captures(*captures); end +end + +class RSpec::Matchers::BuiltIn::Match +end + +class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher + def __delegate_operator(actual, operator, expected); end +end + +class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher +end + +class RSpec::Matchers::BuiltIn::OperatorMatcher + def !=(_expected); end + + def !~(_expected); end + + def <(expected); end + + def <=(expected); end + + def ==(expected); end + + def ===(expected); end + + def =~(expected); end + + def >(expected); end + + def >=(expected); end + + def description(); end + + def fail_with_message(message); end + + def initialize(actual); end +end + +class RSpec::Matchers::BuiltIn::OperatorMatcher + def self.get(klass, operator); end + + def self.register(klass, operator, matcher); end + + def self.registry(); end + + def self.unregister(klass, operator); end + + def self.use_custom_matcher_or_delegate(operator); end +end + +class RSpec::Matchers::BuiltIn::Output + def does_not_match?(block); end + + def initialize(expected); end + + def matches?(block); end + + def to_stderr(); end + + def to_stderr_from_any_process(); end + + def to_stdout(); end + + def to_stdout_from_any_process(); end +end + +class RSpec::Matchers::BuiltIn::Output +end + +class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher + def __delegate_operator(actual, operator, expected); end +end + +class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher +end + +class RSpec::Matchers::BuiltIn::RaiseError + include ::RSpec::Matchers::Composable + def description(); end + + def does_not_match?(given_proc); end + + def expects_call_stack_jump?(); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(expected_error_or_message=T.unsafe(nil), expected_message=T.unsafe(nil), &block); end + + def matches?(given_proc, negative_expectation=T.unsafe(nil), &block); end + + def supports_block_expectations?(); end + + def with_message(expected_message); end +end + +class RSpec::Matchers::BuiltIn::RaiseError +end + +class RSpec::Matchers::BuiltIn::RespondTo + def and_any_keywords(); end + + def and_keywords(*keywords); end + + def and_unlimited_arguments(); end + + def argument(); end + + def arguments(); end + + def does_not_match?(actual); end + + def initialize(*names); end + + def with(n); end + + def with_any_keywords(); end + + def with_keywords(*keywords); end + + def with_unlimited_arguments(); end +end + +class RSpec::Matchers::BuiltIn::RespondTo +end + +class RSpec::Matchers::BuiltIn::Satisfy + def initialize(description=T.unsafe(nil), &block); end + + def matches?(actual, &block); end +end + +class RSpec::Matchers::BuiltIn::Satisfy +end + +class RSpec::Matchers::BuiltIn::StartOrEndWith + def initialize(*expected); end +end + +class RSpec::Matchers::BuiltIn::StartOrEndWith +end + +class RSpec::Matchers::BuiltIn::StartWith +end + +class RSpec::Matchers::BuiltIn::StartWith +end + +class RSpec::Matchers::BuiltIn::ThrowSymbol + include ::RSpec::Matchers::Composable + def description(); end + + def does_not_match?(given_proc); end + + def expects_call_stack_jump?(); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end + + def matches?(given_proc); end + + def supports_block_expectations?(); end +end + +class RSpec::Matchers::BuiltIn::ThrowSymbol +end + +class RSpec::Matchers::BuiltIn::YieldControl + def at_least(number); end + + def at_most(number); end + + def does_not_match?(block); end + + def exactly(number); end + + def initialize(); end + + def matches?(block); end + + def once(); end + + def thrice(); end + + def times(); end + + def twice(); end +end + +class RSpec::Matchers::BuiltIn::YieldControl +end + +class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs + def does_not_match?(block); end + + def initialize(*args); end + + def matches?(block); end +end + +class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs +end + +class RSpec::Matchers::BuiltIn::YieldWithArgs + def does_not_match?(block); end + + def initialize(*args); end + + def matches?(block); end +end + +class RSpec::Matchers::BuiltIn::YieldWithArgs +end + +class RSpec::Matchers::BuiltIn::YieldWithNoArgs + def does_not_match?(block); end + + def matches?(block); end +end + +class RSpec::Matchers::BuiltIn::YieldWithNoArgs +end + +module RSpec::Matchers::DSL::Macros + RAISE_NOTIFIER = ::T.let(nil, ::T.untyped) +end + +class RSpec::Matchers::ExpectedsForMultipleDiffs + DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped) + DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped) +end + +module RSpec::Mocks + DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped) + IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped) +end + +module RSpec::Mocks::AnyInstance +end + +class RSpec::Mocks::AnyInstance::Chain + include ::RSpec::Mocks::AnyInstance::Chain::Customizations + def constrained_to_any_of?(*constraints); end + + def expectation_fulfilled!(); end + + def initialize(recorder, *args, &block); end + + def matches_args?(*args); end + + def never(); end + + def playback!(instance); end +end + +module RSpec::Mocks::AnyInstance::Chain::Customizations + def and_call_original(*args, &block); end + + def and_raise(*args, &block); end + + def and_return(*args, &block); end + + def and_throw(*args, &block); end + + def and_wrap_original(*args, &block); end + + def and_yield(*args, &block); end + + def at_least(*args, &block); end + + def at_most(*args, &block); end + + def exactly(*args, &block); end + + def never(*args, &block); end + + def once(*args, &block); end + + def thrice(*args, &block); end + + def times(*args, &block); end + + def twice(*args, &block); end + + def with(*args, &block); end +end + +module RSpec::Mocks::AnyInstance::Chain::Customizations + def self.record(method_name); end +end + +class RSpec::Mocks::AnyInstance::Chain +end + +class RSpec::Mocks::AnyInstance::ErrorGenerator + def raise_does_not_implement_error(klass, method_name); end + + def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end + + def raise_not_supported_with_prepend_error(method_name, problem_mod); end + + def raise_second_instance_received_message_error(unfulfilled_expectations); end +end + +class RSpec::Mocks::AnyInstance::ErrorGenerator +end + +class RSpec::Mocks::AnyInstance::ExpectChainChain + def initialize(*args); end +end + +class RSpec::Mocks::AnyInstance::ExpectChainChain +end + +class RSpec::Mocks::AnyInstance::ExpectationChain + def expectation_fulfilled?(); end + + def initialize(*args, &block); end +end + +class RSpec::Mocks::AnyInstance::ExpectationChain +end + +class RSpec::Mocks::AnyInstance::FluentInterfaceProxy + def initialize(targets); end + + def method_missing(*args, &block); end +end + +class RSpec::Mocks::AnyInstance::FluentInterfaceProxy +end + +class RSpec::Mocks::AnyInstance::MessageChains + def [](method_name); end + + def add(method_name, chain); end + + def all_expectations_fulfilled?(); end + + def each_unfulfilled_expectation_matching(method_name, *args); end + + def has_expectation?(method_name); end + + def playback!(instance, method_name); end + + def received_expected_message!(method_name); end + + def remove_stub_chains_for!(method_name); end + + def unfulfilled_expectations(); end +end + +class RSpec::Mocks::AnyInstance::MessageChains +end + +class RSpec::Mocks::AnyInstance::PositiveExpectationChain + ExpectationInvocationOrder = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::AnyInstance::PositiveExpectationChain +end + +class RSpec::Mocks::AnyInstance::Proxy + def expect_chain(*chain, &block); end + + def initialize(recorder, target_proxies); end + + def klass(); end + + def should_not_receive(method_name, &block); end + + def should_receive(method_name, &block); end + + def stub(method_name_or_method_map, &block); end + + def stub_chain(*chain, &block); end + + def unstub(method_name); end +end + +class RSpec::Mocks::AnyInstance::Proxy +end + +class RSpec::Mocks::AnyInstance::Recorder + def already_observing?(method_name); end + + def build_alias_method_name(method_name); end + + def expect_chain(*method_names_and_optional_return_values, &block); end + + def initialize(klass); end + + def instance_that_received(method_name); end + + def klass(); end + + def message_chains(); end + + def notify_received_message(_object, message, args, _blk); end + + def playback!(instance, method_name); end + + def should_not_receive(method_name, &block); end + + def should_receive(method_name, &block); end + + def stop_all_observation!(); end + + def stop_observing!(method_name); end + + def stub(method_name, &block); end + + def stub_chain(*method_names_and_optional_return_values, &block); end + + def stubs(); end + + def unstub(method_name); end + + def verify(); end +end + +class RSpec::Mocks::AnyInstance::Recorder +end + +class RSpec::Mocks::AnyInstance::StubChain + def expectation_fulfilled?(); end + EmptyInvocationOrder = ::T.let(nil, ::T.untyped) + InvocationOrder = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::AnyInstance::StubChain +end + +class RSpec::Mocks::AnyInstance::StubChainChain + def initialize(*args); end +end + +class RSpec::Mocks::AnyInstance::StubChainChain +end + +module RSpec::Mocks::AnyInstance + def self.error_generator(); end +end + +class RSpec::Mocks::ArgumentListMatcher + MATCH_ALL = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ExpectChain +end + +class RSpec::Mocks::ExpectChain + def self.expect_chain_on(object, *chain, &blk); end +end + +class RSpec::Mocks::MarshalExtension +end + +class RSpec::Mocks::MarshalExtension + def self.patch!(); end + + def self.unpatch!(); end +end + +class RSpec::Mocks::Matchers::HaveReceived + include ::RSpec::Mocks::Matchers::Matcher + def at_least(*args); end + + def at_most(*args); end + + def description(); end + + def does_not_match?(subject); end + + def exactly(*args); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(method_name, &block); end + + def matches?(subject, &block); end + + def name(); end + + def once(*args); end + + def ordered(*args); end + + def setup_allowance(_subject, &_block); end + + def setup_any_instance_allowance(_subject, &_block); end + + def setup_any_instance_expectation(_subject, &_block); end + + def setup_any_instance_negative_expectation(_subject, &_block); end + + def setup_expectation(subject, &block); end + + def setup_negative_expectation(subject, &block); end + + def thrice(*args); end + + def times(*args); end + + def twice(*args); end + + def with(*args); end + ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped) + CONSTRAINTS = ::T.let(nil, ::T.untyped) + COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::Matchers::HaveReceived +end + +class RSpec::Mocks::Matchers::Receive + include ::RSpec::Mocks::Matchers::Matcher + def and_call_original(*args, &block); end + + def and_raise(*args, &block); end + + def and_return(*args, &block); end + + def and_throw(*args, &block); end + + def and_wrap_original(*args, &block); end + + def and_yield(*args, &block); end + + def at_least(*args, &block); end + + def at_most(*args, &block); end + + def description(); end + + def does_not_match?(subject, &block); end + + def exactly(*args, &block); end + + def initialize(message, block); end + + def matches?(subject, &block); end + + def name(); end + + def never(*args, &block); end + + def once(*args, &block); end + + def ordered(*args, &block); end + + def setup_allowance(subject, &block); end + + def setup_any_instance_allowance(subject, &block); end + + def setup_any_instance_expectation(subject, &block); end + + def setup_any_instance_negative_expectation(subject, &block); end + + def setup_expectation(subject, &block); end + + def setup_negative_expectation(subject, &block); end + + def thrice(*args, &block); end + + def times(*args, &block); end + + def twice(*args, &block); end + + def with(*args, &block); end +end + +class RSpec::Mocks::Matchers::Receive::DefaultDescribable + def description_for(verb); end + + def initialize(message); end +end + +class RSpec::Mocks::Matchers::Receive::DefaultDescribable +end + +class RSpec::Mocks::Matchers::Receive +end + +class RSpec::Mocks::Matchers::ReceiveMessageChain + include ::RSpec::Mocks::Matchers::Matcher + def and_call_original(*args, &block); end + + def and_raise(*args, &block); end + + def and_return(*args, &block); end + + def and_throw(*args, &block); end + + def and_yield(*args, &block); end + + def description(); end + + def does_not_match?(*_args); end + + def initialize(chain, &block); end + + def matches?(subject, &block); end + + def name(); end + + def setup_allowance(subject, &block); end + + def setup_any_instance_allowance(subject, &block); end + + def setup_any_instance_expectation(subject, &block); end + + def setup_expectation(subject, &block); end + + def setup_negative_expectation(*_args); end + + def with(*args, &block); end +end + +class RSpec::Mocks::Matchers::ReceiveMessageChain +end + +class RSpec::Mocks::Matchers::ReceiveMessages + include ::RSpec::Mocks::Matchers::Matcher + def description(); end + + def does_not_match?(_subject); end + + def initialize(message_return_value_hash); end + + def matches?(subject); end + + def name(); end + + def setup_allowance(subject); end + + def setup_any_instance_allowance(subject); end + + def setup_any_instance_expectation(subject); end + + def setup_expectation(subject); end + + def setup_negative_expectation(_subject); end + + def warn_about_block(); end +end + +class RSpec::Mocks::Matchers::ReceiveMessages +end + +class RSpec::Mocks::MessageChain + def block(); end + + def chain(); end + + def initialize(object, *chain, &blk); end + + def object(); end + + def setup_chain(); end +end + +class RSpec::Mocks::MessageChain +end + +class RSpec::Mocks::ObjectReference + MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::Proxy + DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::StubChain +end + +class RSpec::Mocks::StubChain + def self.stub_chain_on(object, *chain, &blk); end +end + +module RSpec::Mocks::Version + STRING = ::T.let(nil, ::T.untyped) +end + +RSpec::SharedContext = RSpec::Core::SharedContext + +module RSpec::Support + DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped) + DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) + KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + AVOID_RESCUING = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::Differ + def color?(); end + + def diff(actual, expected); end + + def diff_as_object(actual, expected); end + + def diff_as_string(actual, expected); end + + def initialize(opts=T.unsafe(nil)); end +end + +class RSpec::Support::Differ +end + +class RSpec::Support::EncodedString + ENCODE_NO_CONVERTER = ::T.let(nil, ::T.untyped) + ENCODE_UNCONVERTABLE_BYTES = ::T.let(nil, ::T.untyped) + REPLACE = ::T.let(nil, ::T.untyped) + US_ASCII = ::T.let(nil, ::T.untyped) + UTF_8 = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::MethodSignature + INFINITY = ::T.let(nil, ::T.untyped) +end + +RSpec::Support::Mutex = Thread::Mutex + +class RSpec::Support::ObjectFormatter + ELLIPSIS = ::T.let(nil, ::T.untyped) + INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::DateTimeInspector + FORMAT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::TimeInspector + FORMAT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::UninspectableObjectInspector + OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped) +end + +RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier + +module RSpec::Support::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module Rake + EARLY = ::T.let(nil, ::T.untyped) + EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped) + LATE = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +module Rake::AltSystem + WINDOWS = ::T.let(nil, ::T.untyped) +end + +class Rake::Application + DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped) + FIXNUM_MAX = ::T.let(nil, ::T.untyped) +end + +module Rake::Backtrace + SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped) + SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped) + SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped) + SYS_KEYS = ::T.let(nil, ::T.untyped) + SYS_PATHS = ::T.let(nil, ::T.untyped) +end + +module Rake::DSL + include ::FileUtils::StreamUtils_ +end + +class Rake::FileList + ARRAY_METHODS = ::T.let(nil, ::T.untyped) + DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped) + DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped) + DELEGATING_METHODS = ::T.let(nil, ::T.untyped) + MUST_DEFINE = ::T.let(nil, ::T.untyped) + MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped) + SPECIAL_RETURN = ::T.let(nil, ::T.untyped) +end + +module Rake::FileUtilsExt + include ::FileUtils::StreamUtils_ + DEFAULT = ::T.let(nil, ::T.untyped) +end + +module Rake::FileUtilsExt + extend ::FileUtils::StreamUtils_ +end + +class Rake::InvocationChain + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::LinkedList + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::Promise + NOT_SET = ::T.let(nil, ::T.untyped) +end + +class Rake::Scope + EMPTY = ::T.let(nil, ::T.untyped) +end + +module Rake::Version + BUILD = ::T.let(nil, ::T.untyped) + MAJOR = ::T.let(nil, ::T.untyped) + MINOR = ::T.let(nil, ::T.untyped) + NUMBERS = ::T.let(nil, ::T.untyped) + OTHER = ::T.let(nil, ::T.untyped) +end + +module Rake + extend ::FileUtils::StreamUtils_ +end + +RakeFileUtils = Rake::FileUtilsExt + +class Random + def self.raw_seed(_); end +end + +class Rational + def to_d(precision); end +end + +module RbConfig + def self.expand(val, config=T.unsafe(nil)); end + + def self.ruby(); end +end + +class Regexp + def match?(*_); end +end + +class Regexp + def self.union(*_); end +end + +class RubyVM::InstructionSequence + def absolute_path(); end + + def base_label(); end + + def disasm(); end + + def disassemble(); end + + def eval(); end + + def first_lineno(); end + + def label(); end + + def path(); end + + def to_a(); end + + def to_binary(*_); end +end + +class RubyVM::InstructionSequence + def self.compile(*_); end + + def self.compile_file(*_); end + + def self.compile_option(); end + + def self.compile_option=(compile_option); end + + def self.disasm(_); end + + def self.disassemble(_); end + + def self.load_from_binary(_); end + + def self.load_from_binary_extra_data(_); end + + def self.of(_); end +end + +class RubyVM + def self.stat(*_); end +end + +ScanError = StringScanner::Error + +class Set + def ==(other); end + + def compare_by_identity(); end + + def compare_by_identity?(); end + + def divide(&func); end + + def eql?(o); end + + def flatten_merge(set, seen=T.unsafe(nil)); end + + def pretty_print(pp); end + + def pretty_print_cycle(pp); end + InspectKey = ::T.let(nil, ::T.untyped) +end + +module Shellwords +end + +module Shellwords + def self.escape(str); end + + def self.join(array); end + + def self.shellescape(str); end + + def self.shelljoin(array); end + + def self.shellsplit(line); end + + def self.shellwords(line); end + + def self.split(line); end +end + +class SignalException + def signm(); end + + def signo(); end +end + +module Singleton + def _dump(depth=T.unsafe(nil)); end + + def clone(); end + + def dup(); end +end + +module Singleton::SingletonClassMethods + def _load(str); end + + def clone(); end +end + +module Singleton + def self.__init__(klass); end +end + +class Sorbet::Private::ConstantLookupCache + def all_module_aliases(); end + + def all_module_names(); end + + def all_named_modules(); end + + def class_by_name(name); end + + def name_by_class(klass); end + DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::ConstantLookupCache::ConstantEntry + def aliases(); end + + def aliases=(_); end + + def const(); end + + def const=(_); end + + def const_name(); end + + def const_name=(_); end + + def found_name(); end + + def found_name=(_); end + + def owner(); end + + def owner=(_); end + + def primary_name(); end + + def primary_name=(_); end +end + +class Sorbet::Private::ConstantLookupCache::ConstantEntry + def self.[](*_); end + + def self.members(); end +end + +class Sorbet::Private::ConstantLookupCache +end + +class Sorbet::Private::CreateConfig + include ::Sorbet::Private::StepInterface + SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped) + SORBET_DIR = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::CreateConfig + def self.main(); end + + def self.output_file(); end +end + +class Sorbet::Private::FetchRBIs + include ::Sorbet::Private::StepInterface + HEADER = ::T.let(nil, ::T.untyped) + RBI_CACHE_DIR = ::T.let(nil, ::T.untyped) + SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped) + SORBET_DIR = ::T.let(nil, ::T.untyped) + SORBET_RBI_LIST = ::T.let(nil, ::T.untyped) + SORBET_RBI_SORBET_TYPED = ::T.let(nil, ::T.untyped) + SORBET_TYPED_REPO = ::T.let(nil, ::T.untyped) + SORBET_TYPED_REVISION = ::T.let(nil, ::T.untyped) + XDG_CACHE_HOME = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::FetchRBIs + def self.fetch_sorbet_typed(); end + + def self.main(); end + + def self.matching_version_directories(root, version); end + + def self.output_file(); end + + def self.paths_for_gem_version(gemspec); end + + def self.paths_for_ruby_version(ruby_version); end + + def self.vendor_rbis_within_paths(vendor_paths); end +end + +class Sorbet::Private::FindGemRBIs + include ::Sorbet::Private::StepInterface + GEM_DIR = ::T.let(nil, ::T.untyped) + HEADER = ::T.let(nil, ::T.untyped) + RBI_CACHE_DIR = ::T.let(nil, ::T.untyped) + XDG_CACHE_HOME = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::FindGemRBIs + def self.main(); end + + def self.output_file(); end + + def self.paths_within_gem_sources(gemspec); end +end + +module Sorbet::Private::GemGeneratorTracepoint + include ::Sorbet::Private::StepInterface + OUTPUT = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition + def defs(); end + + def defs=(_); end + + def id(); end + + def id=(_); end + + def klass(); end + + def klass=(_); end +end + +class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition + def self.[](*_); end + + def self.members(); end +end + +class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer + def initialize(files:, delegate_classes:); end + + def serialize(output_dir); end + BAD_METHODS = ::T.let(nil, ::T.untyped) + HEADER = ::T.let(nil, ::T.untyped) + SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer +end + +class Sorbet::Private::GemGeneratorTracepoint::Tracer +end + +class Sorbet::Private::GemGeneratorTracepoint::Tracer + def self.add_to_context(item); end + + def self.disable_tracepoints(); end + + def self.finish(); end + + def self.install_tracepoints(); end + + def self.on_method_added(mod, method, singleton); end + + def self.on_module_created(mod); end + + def self.on_module_extended(extended, extender); end + + def self.on_module_included(included, includer); end + + def self.pre_cache_module_methods(); end + + def self.register_delegate_class(klass, delegate); end + + def self.start(); end + + def self.trace(); end + + def self.trace_results(); end +end + +module Sorbet::Private::GemGeneratorTracepoint + def self.main(output_dir=T.unsafe(nil)); end + + def self.output_file(); end +end + +class Sorbet::Private::GemLoader + GEM_LOADER = ::T.let(nil, ::T.untyped) + NO_GEM = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::GemLoader + def self.my_require(gem); end + + def self.require_all_gems(); end + + def self.require_gem(gem); end +end + +class Sorbet::Private::HiddenMethodFinder + include ::Sorbet::Private::StepInterface + def all_modules_and_aliases(); end + + def capture_stderr(); end + + def constant_cache(); end + + def gen_source_rbi(classes, aliases); end + + def looks_like_stub_name(name); end + + def main(); end + + def mk_dir(); end + + def read_constants(); end + + def real_name(mod); end + + def require_everything(); end + + def rm_dir(); end + + def serialize_alias(source_entry, rbi_entry, my_klass, source_symbols, rbi_symbols); end + + def serialize_class(source_entry, rbi_entry, klass, source_symbols, rbi_symbols, source_by_name); end + + def serialize_constants(source, rbi, klass, is_singleton, source_symbols, rbi_symbols); end + + def symbols_id_to_name(entry, prefix); end + + def write_constants(); end + + def write_diff(source, rbi); end + BLACKLIST = ::T.let(nil, ::T.untyped) + DIFF_RBI = ::T.let(nil, ::T.untyped) + ERRORS_RBI = ::T.let(nil, ::T.untyped) + HEADER = ::T.let(nil, ::T.untyped) + HIDDEN_RBI = ::T.let(nil, ::T.untyped) + PATH = ::T.let(nil, ::T.untyped) + RBI_CONSTANTS = ::T.let(nil, ::T.untyped) + RBI_CONSTANTS_ERR = ::T.let(nil, ::T.untyped) + SOURCE_CONSTANTS = ::T.let(nil, ::T.untyped) + SOURCE_CONSTANTS_ERR = ::T.let(nil, ::T.untyped) + TMP_PATH = ::T.let(nil, ::T.untyped) + TMP_RBI = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::HiddenMethodFinder + def self.main(); end + + def self.output_file(); end +end + +module Sorbet::Private::Main +end + +module Sorbet::Private::Main + def self.cyan(msg); end + + def self.emojify(emoji, msg); end + + def self.init(); end + + def self.main(argv); end + + def self.make_step(step); end + + def self.usage(); end + + def self.yellow(msg); end +end + +module Sorbet::Private::RealStdlib +end + +module Sorbet::Private::RealStdlib + def self.real_ancestors(mod); end + + def self.real_autoload?(o, klass); end + + def self.real_const_get(obj, const, arg); end + + def self.real_constants(mod); end + + def self.real_eqeq(obj, other); end + + def self.real_hash(o); end + + def self.real_instance_methods(mod, arg); end + + def self.real_is_a?(o, klass); end + + def self.real_name(o); end + + def self.real_object_id(o); end + + def self.real_private_instance_methods(mod, arg); end + + def self.real_singleton_class(obj); end + + def self.real_singleton_methods(mod, arg); end + + def self.real_spaceship(obj, arg); end + + def self.real_superclass(o); end +end + +class Sorbet::Private::RequireEverything +end + +class Sorbet::Private::RequireEverything + def self.excluded_rails_files(); end + + def self.load_bundler(); end + + def self.load_rails(); end + + def self.my_require(abs_path, numerator, denominator); end + + def self.patch_kernel(); end + + def self.rails?(); end + + def self.rails_load_paths(); end + + def self.rb_file_paths(); end + + def self.require_all_files(); end + + def self.require_everything(); end +end + +class Sorbet::Private::Serialize + def alias(base, other_name); end + + def ancestor_has_method(method, klass); end + + def blacklisted_method(method); end + + def class_or_module(class_name); end + + def comparable?(value); end + + def constant(const, value); end + + def from_method(method); end + + def initialize(constant_cache); end + + def serialize_method(method, static=T.unsafe(nil), with_sig: T.unsafe(nil)); end + + def serialize_sig(parameters); end + + def to_sig(kind, name); end + + def valid_class_name(name); end + + def valid_method_name(name); end + BLACKLIST_CONSTANTS = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::Serialize + def self.header(typed=T.unsafe(nil), subcommand=T.unsafe(nil)); end +end + +module Sorbet::Private::Status +end + +module Sorbet::Private::Status + def self.done(); end + + def self.say(message, print_without_tty: T.unsafe(nil)); end +end + +module Sorbet::Private::StepInterface +end + +module Sorbet::Private::StepInterface + def self.main(); end + + def self.output_file(); end +end + +class Sorbet::Private::SuggestTyped + include ::Sorbet::Private::StepInterface +end + +class Sorbet::Private::SuggestTyped + def self.main(); end + + def self.output_file(); end + + def self.suggest_typed(); end +end + +class Sorbet::Private::TodoRBI + include ::Sorbet::Private::StepInterface + HEADER = ::T.let(nil, ::T.untyped) + OUTPUT = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::TodoRBI + def self.main(); end + + def self.output_file(); end +end + +class SortedSet + def initialize(*args, &block); end +end + +class SortedSet + def self.setup(); end +end + +class StopIteration + def result(); end +end + +class String + include ::JSON::Ext::Generator::GeneratorMethods::String + def +@(); end + + def -@(); end + + def []=(*_); end + + def casecmp?(_); end + + def encode(*_); end + + def encode!(*_); end + + def reverse!(); end + + def shellescape(); end + + def shellsplit(); end + + def succ!(); end + + def to_d(); end + + def unicode_normalize(form=T.unsafe(nil)); end + + def unicode_normalize!(form=T.unsafe(nil)); end + + def unicode_normalized?(form=T.unsafe(nil)); end + + def unpack1(_); end +end + +class String + extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend +end + +class StringIO + def length(); end + + def truncate(_); end +end + +class StringScanner + def <<(_); end + + def [](_); end + + def beginning_of_line?(); end + + def bol?(); end + + def charpos(); end + + def check(_); end + + def check_until(_); end + + def clear(); end + + def concat(_); end + + def empty?(); end + + def exist?(_); end + + def get_byte(); end + + def getbyte(); end + + def initialize(*_); end + + def match?(_); end + + def matched(); end + + def matched?(); end + + def matched_size(); end + + def peek(_); end + + def peep(_); end + + def pointer(); end + + def pointer=(pointer); end + + def pos(); end + + def pos=(pos); end + + def post_match(); end + + def pre_match(); end + + def reset(); end + + def rest(); end + + def rest?(); end + + def rest_size(); end + + def restsize(); end + + def scan_full(_, _1, _2); end + + def scan_until(_); end + + def search_full(_, _1, _2); end + + def skip(_); end + + def skip_until(_); end + + def string(); end + + def string=(string); end + + def terminate(); end + + def unscan(); end + Id = ::T.let(nil, ::T.untyped) + Version = ::T.let(nil, ::T.untyped) +end + +class StringScanner + def self.must_C_version(); end +end + +class Struct + def [](_); end + + def []=(_, _1); end + + def dig(*_); end + + def each_pair(); end + + def length(); end + + def members(); end + + def select(*_); end + + def size(); end + + def to_a(); end + + def to_h(); end + + def values(); end + + def values_at(*_); end +end + +Struct::Group = Etc::Group + +Struct::Passwd = Etc::Passwd + +Struct::Tms = Process::Tms + +class SystemCallError + def errno(); end +end + +class SystemExit + def status(); end + + def success?(); end +end + +module ThreadSafe + NULL = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +ThreadSafe::Array = Array + +class ThreadSafe::AtomicReferenceCacheBackend + def [](key); end + + def []=(key, value); end + + def clear(); end + + def compute(key); end + + def compute_if_absent(key); end + + def compute_if_present(key); end + + def delete(key); end + + def delete_pair(key, value); end + + def each_pair(); end + + def empty?(); end + + def get_and_set(key, value); end + + def get_or_default(key, else_value=T.unsafe(nil)); end + + def initialize(options=T.unsafe(nil)); end + + def key?(key); end + + def merge_pair(key, value); end + + def replace_if_exists(key, new_value); end + + def replace_pair(key, old_value, new_value); end + + def size(); end + DEFAULT_CAPACITY = ::T.let(nil, ::T.untyped) + HASH_BITS = ::T.let(nil, ::T.untyped) + LOCKED = ::T.let(nil, ::T.untyped) + MAX_CAPACITY = ::T.let(nil, ::T.untyped) + MOVED = ::T.let(nil, ::T.untyped) + NOW_RESIZING = ::T.let(nil, ::T.untyped) + TRANSFER_BUFFER_SIZE = ::T.let(nil, ::T.untyped) + WAITING = ::T.let(nil, ::T.untyped) +end + +class ThreadSafe::AtomicReferenceCacheBackend::Node + include ::ThreadSafe::Util::CheapLockable + def initialize(hash, key, value, next_node=T.unsafe(nil)); end + + def key(); end + + def key?(key); end + + def locked?(); end + + def matches?(key, hash); end + + def pure_hash(); end + + def try_await_lock(table, i); end + + def try_lock_via_hash(node_hash=T.unsafe(nil)); end + + def unlock_via_hash(locked_hash, node_hash); end + HASH_BITS = ::T.let(nil, ::T.untyped) + LOCKED = ::T.let(nil, ::T.untyped) + MOVED = ::T.let(nil, ::T.untyped) + SPIN_LOCK_ATTEMPTS = ::T.let(nil, ::T.untyped) + WAITING = ::T.let(nil, ::T.untyped) +end + +class ThreadSafe::AtomicReferenceCacheBackend::Node + extend ::ThreadSafe::Util::Volatile + def self.locked_hash?(hash); end +end + +class ThreadSafe::AtomicReferenceCacheBackend::Table + def cas_new_node(i, hash, key, value); end + + def delete_node_at(i, node, predecessor_node); end + + def try_lock_via_hash(i, node, node_hash); end + + def try_to_cas_in_computed(i, hash, key); end +end + +class ThreadSafe::AtomicReferenceCacheBackend::Table +end + +class ThreadSafe::AtomicReferenceCacheBackend + extend ::ThreadSafe::Util::Volatile +end + +ThreadSafe::ConcurrentCacheBackend = ThreadSafe::MriCacheBackend + +ThreadSafe::Hash = Hash + +class ThreadSafe::MriCacheBackend + WRITE_LOCK = ::T.let(nil, ::T.untyped) +end + +class ThreadSafe::SynchronizedCacheBackend + include ::Mutex_m + def lock(); end + + def locked?(); end + + def synchronize(&block); end + + def try_lock(); end + + def unlock(); end +end + +class ThreadSafe::SynchronizedCacheBackend +end + +module ThreadSafe::Util + CPU_COUNT = ::T.let(nil, ::T.untyped) + FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped) + MAX_INT = ::T.let(nil, ::T.untyped) +end + +class ThreadSafe::Util::Adder + def add(x); end + + def decrement(); end + + def increment(); end + + def reset(); end + + def sum(); end +end + +class ThreadSafe::Util::Adder +end + +class ThreadSafe::Util::AtomicReference + def compare_and_set(old_value, new_value); end + + def get(); end + + def initialize(value=T.unsafe(nil)); end + + def set(new_value); end + + def value(); end + + def value=(new_value); end +end + +class ThreadSafe::Util::AtomicReference +end + +module ThreadSafe::Util::CheapLockable + def cas_mutex(old_value, new_value); end + + def compare_and_set_mutex(old_value, new_value); end + + def lazy_set_mutex(value); end + + def mutex(); end + + def mutex=(value); end +end + +module ThreadSafe::Util::CheapLockable + extend ::ThreadSafe::Util::Volatile +end + +class ThreadSafe::Util::PowerOfTwoTuple + def hash_to_index(hash); end + + def next_in_size_table(); end + + def volatile_get_by_hash(hash); end + + def volatile_set_by_hash(hash, value); end +end + +class ThreadSafe::Util::PowerOfTwoTuple +end + +class ThreadSafe::Util::Striped64 + def busy?(); end + + def initialize(); end + + def retry_update(x, hash_code, was_uncontended); end + THREAD_LOCAL_KEY = ::T.let(nil, ::T.untyped) +end + +class ThreadSafe::Util::Striped64::Cell + def cas(old_value, new_value); end + + def cas_computed(); end + + def padding_(); end +end + +class ThreadSafe::Util::Striped64::Cell +end + +class ThreadSafe::Util::Striped64 + extend ::ThreadSafe::Util::Volatile +end + +module ThreadSafe::Util::Volatile + def attr_volatile(*attr_names); end +end + +module ThreadSafe::Util::Volatile +end + +class ThreadSafe::Util::VolatileTuple + include ::Enumerable + def cas(i, old_value, new_value); end + + def compare_and_set(i, old_value, new_value); end + + def each(&blk); end + + def initialize(size); end + + def size(); end + + def volatile_get(i); end + + def volatile_set(i, value); end +end + +class ThreadSafe::Util::VolatileTuple +end + +module ThreadSafe::Util::XorShiftRandom + def get(); end + + def xorshift(x); end + MAX_XOR_SHIFTABLE_INT = ::T.let(nil, ::T.untyped) +end + +module ThreadSafe::Util::XorShiftRandom + extend ::ThreadSafe::Util::XorShiftRandom +end + +module ThreadSafe::Util +end + +class TracePoint + def event(); end +end + +class TrueClass + include ::JSON::Ext::Generator::GeneratorMethods::TrueClass +end + +module URI + include ::URI::RFC2396_REGEXP +end + +module URI::Escape + def decode(*arg); end + + def encode(*arg); end + + def escape(*arg); end + + def unescape(*arg); end +end + +class URI::FTP + def set_typecode(v); end + + def typecode(); end + + def typecode=(typecode); end +end + +class URI::FTP + def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end +end + +class URI::HTTP + def request_uri(); end +end + +class URI::LDAP + def attributes(); end + + def attributes=(val); end + + def dn(); end + + def dn=(val); end + + def extensions(); end + + def extensions=(val); end + + def filter(); end + + def filter=(val); end + + def initialize(*arg); end + + def scope(); end + + def scope=(val); end + + def set_attributes(val); end + + def set_dn(val); end + + def set_extensions(val); end + + def set_filter(val); end + + def set_scope(val); end +end + +class URI::MailTo + def headers(); end + + def headers=(v); end + + def initialize(*arg); end + + def set_headers(v); end + + def set_to(v); end + + def to(); end + + def to=(v); end + + def to_mailtext(); end + + def to_rfc822text(); end +end + +URI::Parser = URI::RFC2396_Parser + +URI::REGEXP = URI::RFC2396_REGEXP + +class URI::RFC2396_Parser + def escape(str, unsafe=T.unsafe(nil)); end + + def extract(str, schemes=T.unsafe(nil)); end + + def initialize(opts=T.unsafe(nil)); end + + def join(*uris); end + + def make_regexp(schemes=T.unsafe(nil)); end + + def parse(uri); end + + def pattern(); end + + def regexp(); end + + def split(uri); end + + def unescape(str, escaped=T.unsafe(nil)); end +end + +class URI::RFC3986_Parser + def join(*uris); end + + def parse(uri); end + + def regexp(); end + + def split(uri); end + RFC3986_relative_ref = ::T.let(nil, ::T.untyped) +end + +module URI::Util + def self.make_components_hash(klass, array_hash); end +end + +module URI + extend ::URI::Escape + def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end + + def self.encode_www_form(enum, enc=T.unsafe(nil)); end + + def self.encode_www_form_component(str, enc=T.unsafe(nil)); end + + def self.get_encoding(label); end +end + +class UnboundMethod + def clone(); end + + def original_name(); end +end + +class UncaughtThrowError + def tag(); end + + def value(); end +end + +module Virtus + EXTRA_CONST_ARGS = ::T.let(nil, ::T.untyped) + Undefined = ::T.let(nil, ::T.untyped) +end + +class Virtus::Attribute::DefaultValue::FromClonable + SINGLETON_CLASSES = ::T.let(nil, ::T.untyped) +end + +class Virtus::Attribute::EmbeddedValue + TYPES = ::T.let(nil, ::T.untyped) +end + +class Virtus::Attribute + extend ::Virtus::TypeLookup + extend ::Virtus::Options +end + +module Virtus::Extensions + INVALID_WRITER_METHODS = ::T.let(nil, ::T.untyped) + RESERVED_NAMES = ::T.let(nil, ::T.untyped) + WRITER_METHOD_REGEXP = ::T.let(nil, ::T.untyped) +end + +module Virtus::Extensions::AllowedWriterMethods + INVALID_WRITER_METHODS = ::T.let(nil, ::T.untyped) + WRITER_METHOD_REGEXP = ::T.let(nil, ::T.untyped) +end + +module Virtus::TypeLookup + TYPE_FORMAT = ::T.let(nil, ::T.untyped) +end + +module Warning + def warn(_); end +end + +module Warning + extend ::Warning +end diff --git a/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi b/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi new file mode 100644 index 0000000..40c57a7 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi @@ -0,0 +1,8682 @@ +# 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/bundler/all/bundler.rbi +# +# typed: true + +module Bundler + FREEBSD = ::T.let(nil, T.untyped) + NULL = ::T.let(nil, T.untyped) + ORIGINAL_ENV = ::T.let(nil, T.untyped) + SUDO_MUTEX = ::T.let(nil, T.untyped) + VERSION = ::T.let(nil, T.untyped) + WINDOWS = ::T.let(nil, T.untyped) + + sig do + params( + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def self.app_cache(custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.app_config_path(); end + + sig {returns(T.untyped)} + def self.bin_path(); end + + sig {returns(T.untyped)} + def self.bundle_path(); end + + sig {returns(T.untyped)} + def self.bundler_major_version(); end + + sig {returns(T.untyped)} + def self.clean_env(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def self.clean_exec(*args); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def self.clean_system(*args); end + + sig {returns(T.untyped)} + def self.clear_gemspec_cache(); end + + sig {returns(T.untyped)} + def self.configure(); end + + sig {returns(T.untyped)} + def self.configured_bundle_path(); end + + sig {returns(T.untyped)} + def self.current_ruby(); end + + sig {returns(T.untyped)} + def self.default_bundle_dir(); end + + sig {returns(T.untyped)} + def self.default_gemfile(); end + + sig {returns(T.untyped)} + def self.default_lockfile(); end + + sig do + params( + unlock: T.untyped, + ) + .returns(T.untyped) + end + def self.definition(unlock=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.environment(); end + + sig {returns(T.untyped)} + def self.feature_flag(); end + + sig {returns(T.untyped)} + def self.frozen_bundle?(); end + + sig {returns(T.untyped)} + def self.git_present?(); end + + sig {returns(T.untyped)} + def self.home(); end + + sig {returns(T.untyped)} + def self.install_path(); end + + sig {returns(T.untyped)} + def self.load(); end + + sig do + params( + file: T.untyped, + validate: T.untyped, + ) + .returns(T.untyped) + end + def self.load_gemspec(file, validate=T.unsafe(nil)); end + + sig do + params( + file: T.untyped, + validate: T.untyped, + ) + .returns(T.untyped) + end + def self.load_gemspec_uncached(file, validate=T.unsafe(nil)); end + + sig do + params( + data: T.untyped, + ) + .returns(T.untyped) + end + def self.load_marshal(data); end + + sig {returns(T.untyped)} + def self.local_platform(); end + + sig {returns(T.untyped)} + def self.locked_gems(); end + + sig do + params( + path: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(path, options=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.original_env(); end + + sig do + params( + file: T.untyped, + ) + .returns(T.untyped) + end + def self.read_file(file); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def self.require(*groups); end + + sig {returns(T.untyped)} + def self.require_thor_actions(); end + + sig {returns(T.untyped)} + def self.requires_sudo?(); end + + sig {returns(T.untyped)} + def self.reset!(); end + + sig {returns(T.untyped)} + def self.reset_paths!(); end + + sig {returns(T.untyped)} + def self.reset_rubygems!(); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(path); end + + sig {returns(T.untyped)} + def self.root(); end + + sig {returns(T.untyped)} + def self.ruby_scope(); end + + sig {returns(T.untyped)} + def self.rubygems(); end + + sig {returns(T.untyped)} + def self.settings(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def self.setup(*groups); end + + sig {returns(T.untyped)} + def self.specs_path(); end + + sig do + params( + str: T.untyped, + ) + .returns(T.untyped) + end + def self.sudo(str); end + + sig {returns(T.untyped)} + def self.system_bindir(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.tmp(name=T.unsafe(nil)); end + + sig do + params( + login: T.untyped, + warning: T.untyped, + ) + .returns(T.untyped) + end + def self.tmp_home_path(login, warning); end + + sig {returns(T.untyped)} + def self.ui(); end + + sig do + params( + ui: T.untyped, + ) + .returns(T.untyped) + end + def self.ui=(ui); end + + sig {returns(T.untyped)} + def self.use_system_gems?(); end + + sig do + params( + dir: T.untyped, + ) + .returns(T.untyped) + end + def self.user_bundle_path(dir=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.user_cache(); end + + sig {returns(T.untyped)} + def self.user_home(); end + + sig do + params( + executable: T.untyped, + ) + .returns(T.untyped) + end + def self.which(executable); end + + sig {returns(T.untyped)} + def self.with_clean_env(); end + + sig {returns(T.untyped)} + def self.with_original_env(); end +end + +class Bundler::APIResponseMismatchError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::BuildMetadata + sig {returns(T.untyped)} + def self.built_at(); end + + sig {returns(T.untyped)} + def self.git_commit_sha(); end + + sig {returns(T.untyped)} + def self.release?(); end + + sig {returns(T.untyped)} + def self.to_h(); end +end + +class Bundler::BundlerError < StandardError + sig {returns(T.untyped)} + def self.all_errors(); end + + sig do + params( + code: T.untyped, + ) + .returns(T.untyped) + end + def self.status_code(code); end +end + +class Bundler::CurrentRuby + KNOWN_MAJOR_VERSIONS = ::T.let(nil, T.untyped) + KNOWN_MINOR_VERSIONS = ::T.let(nil, T.untyped) + KNOWN_PLATFORMS = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def jruby?(); end + + sig {returns(T.untyped)} + def jruby_18?(); end + + sig {returns(T.untyped)} + def jruby_19?(); end + + sig {returns(T.untyped)} + def jruby_1?(); end + + sig {returns(T.untyped)} + def jruby_20?(); end + + sig {returns(T.untyped)} + def jruby_21?(); end + + sig {returns(T.untyped)} + def jruby_22?(); end + + sig {returns(T.untyped)} + def jruby_23?(); end + + sig {returns(T.untyped)} + def jruby_24?(); end + + sig {returns(T.untyped)} + def jruby_25?(); end + + sig {returns(T.untyped)} + def jruby_26?(); end + + sig {returns(T.untyped)} + def jruby_27?(); end + + sig {returns(T.untyped)} + def jruby_2?(); end + + sig {returns(T.untyped)} + def maglev?(); end + + sig {returns(T.untyped)} + def maglev_18?(); end + + sig {returns(T.untyped)} + def maglev_19?(); end + + sig {returns(T.untyped)} + def maglev_1?(); end + + sig {returns(T.untyped)} + def maglev_20?(); end + + sig {returns(T.untyped)} + def maglev_21?(); end + + sig {returns(T.untyped)} + def maglev_22?(); end + + sig {returns(T.untyped)} + def maglev_23?(); end + + sig {returns(T.untyped)} + def maglev_24?(); end + + sig {returns(T.untyped)} + def maglev_25?(); end + + sig {returns(T.untyped)} + def maglev_26?(); end + + sig {returns(T.untyped)} + def maglev_27?(); end + + sig {returns(T.untyped)} + def maglev_2?(); end + + sig {returns(T.untyped)} + def mingw?(); end + + sig {returns(T.untyped)} + def mingw_18?(); end + + sig {returns(T.untyped)} + def mingw_19?(); end + + sig {returns(T.untyped)} + def mingw_1?(); end + + sig {returns(T.untyped)} + def mingw_20?(); end + + sig {returns(T.untyped)} + def mingw_21?(); end + + sig {returns(T.untyped)} + def mingw_22?(); end + + sig {returns(T.untyped)} + def mingw_23?(); end + + sig {returns(T.untyped)} + def mingw_24?(); end + + sig {returns(T.untyped)} + def mingw_25?(); end + + sig {returns(T.untyped)} + def mingw_26?(); end + + sig {returns(T.untyped)} + def mingw_27?(); end + + sig {returns(T.untyped)} + def mingw_2?(); end + + sig {returns(T.untyped)} + def mri?(); end + + sig {returns(T.untyped)} + def mri_18?(); end + + sig {returns(T.untyped)} + def mri_19?(); end + + sig {returns(T.untyped)} + def mri_1?(); end + + sig {returns(T.untyped)} + def mri_20?(); end + + sig {returns(T.untyped)} + def mri_21?(); end + + sig {returns(T.untyped)} + def mri_22?(); end + + sig {returns(T.untyped)} + def mri_23?(); end + + sig {returns(T.untyped)} + def mri_24?(); end + + sig {returns(T.untyped)} + def mri_25?(); end + + sig {returns(T.untyped)} + def mri_26?(); end + + sig {returns(T.untyped)} + def mri_27?(); end + + sig {returns(T.untyped)} + def mri_2?(); end + + sig {returns(T.untyped)} + def mswin64?(); end + + sig {returns(T.untyped)} + def mswin64_18?(); end + + sig {returns(T.untyped)} + def mswin64_19?(); end + + sig {returns(T.untyped)} + def mswin64_1?(); end + + sig {returns(T.untyped)} + def mswin64_20?(); end + + sig {returns(T.untyped)} + def mswin64_21?(); end + + sig {returns(T.untyped)} + def mswin64_22?(); end + + sig {returns(T.untyped)} + def mswin64_23?(); end + + sig {returns(T.untyped)} + def mswin64_24?(); end + + sig {returns(T.untyped)} + def mswin64_25?(); end + + sig {returns(T.untyped)} + def mswin64_26?(); end + + sig {returns(T.untyped)} + def mswin64_27?(); end + + sig {returns(T.untyped)} + def mswin64_2?(); end + + sig {returns(T.untyped)} + def mswin?(); end + + sig {returns(T.untyped)} + def mswin_18?(); end + + sig {returns(T.untyped)} + def mswin_19?(); end + + sig {returns(T.untyped)} + def mswin_1?(); end + + sig {returns(T.untyped)} + def mswin_20?(); end + + sig {returns(T.untyped)} + def mswin_21?(); end + + sig {returns(T.untyped)} + def mswin_22?(); end + + sig {returns(T.untyped)} + def mswin_23?(); end + + sig {returns(T.untyped)} + def mswin_24?(); end + + sig {returns(T.untyped)} + def mswin_25?(); end + + sig {returns(T.untyped)} + def mswin_26?(); end + + sig {returns(T.untyped)} + def mswin_27?(); end + + sig {returns(T.untyped)} + def mswin_2?(); end + + sig {returns(T.untyped)} + def on_18?(); end + + sig {returns(T.untyped)} + def on_19?(); end + + sig {returns(T.untyped)} + def on_1?(); end + + sig {returns(T.untyped)} + def on_20?(); end + + sig {returns(T.untyped)} + def on_21?(); end + + sig {returns(T.untyped)} + def on_22?(); end + + sig {returns(T.untyped)} + def on_23?(); end + + sig {returns(T.untyped)} + def on_24?(); end + + sig {returns(T.untyped)} + def on_25?(); end + + sig {returns(T.untyped)} + def on_26?(); end + + sig {returns(T.untyped)} + def on_27?(); end + + sig {returns(T.untyped)} + def on_2?(); end + + sig {returns(T.untyped)} + def rbx?(); end + + sig {returns(T.untyped)} + def rbx_18?(); end + + sig {returns(T.untyped)} + def rbx_19?(); end + + sig {returns(T.untyped)} + def rbx_1?(); end + + sig {returns(T.untyped)} + def rbx_20?(); end + + sig {returns(T.untyped)} + def rbx_21?(); end + + sig {returns(T.untyped)} + def rbx_22?(); end + + sig {returns(T.untyped)} + def rbx_23?(); end + + sig {returns(T.untyped)} + def rbx_24?(); end + + sig {returns(T.untyped)} + def rbx_25?(); end + + sig {returns(T.untyped)} + def rbx_26?(); end + + sig {returns(T.untyped)} + def rbx_27?(); end + + sig {returns(T.untyped)} + def rbx_2?(); end + + sig {returns(T.untyped)} + def ruby?(); end + + sig {returns(T.untyped)} + def ruby_18?(); end + + sig {returns(T.untyped)} + def ruby_19?(); end + + sig {returns(T.untyped)} + def ruby_1?(); end + + sig {returns(T.untyped)} + def ruby_20?(); end + + sig {returns(T.untyped)} + def ruby_21?(); end + + sig {returns(T.untyped)} + def ruby_22?(); end + + sig {returns(T.untyped)} + def ruby_23?(); end + + sig {returns(T.untyped)} + def ruby_24?(); end + + sig {returns(T.untyped)} + def ruby_25?(); end + + sig {returns(T.untyped)} + def ruby_26?(); end + + sig {returns(T.untyped)} + def ruby_27?(); end + + sig {returns(T.untyped)} + def ruby_2?(); end + + sig {returns(T.untyped)} + def truffleruby?(); end + + sig {returns(T.untyped)} + def truffleruby_18?(); end + + sig {returns(T.untyped)} + def truffleruby_19?(); end + + sig {returns(T.untyped)} + def truffleruby_1?(); end + + sig {returns(T.untyped)} + def truffleruby_20?(); end + + sig {returns(T.untyped)} + def truffleruby_21?(); end + + sig {returns(T.untyped)} + def truffleruby_22?(); end + + sig {returns(T.untyped)} + def truffleruby_23?(); end + + sig {returns(T.untyped)} + def truffleruby_24?(); end + + sig {returns(T.untyped)} + def truffleruby_25?(); end + + sig {returns(T.untyped)} + def truffleruby_26?(); end + + sig {returns(T.untyped)} + def truffleruby_27?(); end + + sig {returns(T.untyped)} + def truffleruby_2?(); end + + sig {returns(T.untyped)} + def x64_mingw?(); end + + sig {returns(T.untyped)} + def x64_mingw_18?(); end + + sig {returns(T.untyped)} + def x64_mingw_19?(); end + + sig {returns(T.untyped)} + def x64_mingw_1?(); end + + sig {returns(T.untyped)} + def x64_mingw_20?(); end + + sig {returns(T.untyped)} + def x64_mingw_21?(); end + + sig {returns(T.untyped)} + def x64_mingw_22?(); end + + sig {returns(T.untyped)} + def x64_mingw_23?(); end + + sig {returns(T.untyped)} + def x64_mingw_24?(); end + + sig {returns(T.untyped)} + def x64_mingw_25?(); end + + sig {returns(T.untyped)} + def x64_mingw_26?(); end + + sig {returns(T.untyped)} + def x64_mingw_27?(); end + + sig {returns(T.untyped)} + def x64_mingw_2?(); end +end + +class Bundler::CyclicDependencyError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Definition + include ::Bundler::GemHelpers + sig {returns(T.untyped)} + def add_current_platform(); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def add_platform(platform); end + + sig {returns(T.untyped)} + def current_dependencies(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + explicit_flag: T.untyped, + ) + .returns(T.untyped) + end + def ensure_equivalent_gemfile_and_lockfile(explicit_flag=T.unsafe(nil)); end + + sig do + params( + current_spec: T.untyped, + ) + .returns(T.untyped) + end + def find_indexed_specs(current_spec); end + + sig do + params( + current_spec: T.untyped, + ) + .returns(T.untyped) + end + def find_resolved_spec(current_spec); end + + sig {returns(T.untyped)} + def gem_version_promoter(); end + + sig {returns(T.untyped)} + def gemfiles(); end + + sig {returns(T.untyped)} + def groups(); end + + sig {returns(T.untyped)} + def has_local_dependencies?(); end + + sig {returns(T.untyped)} + def has_rubygems_remotes?(); end + + sig {returns(T.untyped)} + def index(); end + + sig do + params( + lockfile: T.untyped, + dependencies: T.untyped, + sources: T.untyped, + unlock: T.untyped, + ruby_version: T.untyped, + optional_groups: T.untyped, + gemfiles: T.untyped, + ) + .returns(T.untyped) + end + def initialize(lockfile, dependencies, sources, unlock, ruby_version=T.unsafe(nil), optional_groups=T.unsafe(nil), gemfiles=T.unsafe(nil)); end + + sig do + params( + file: T.untyped, + preserve_unknown_sections: T.untyped, + ) + .returns(T.untyped) + end + def lock(file, preserve_unknown_sections=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def locked_bundler_version(); end + + sig {returns(T.untyped)} + def locked_deps(); end + + sig {returns(T.untyped)} + def locked_gems(); end + + sig {returns(T.untyped)} + def locked_ruby_version(); end + + sig {returns(T.untyped)} + def locked_ruby_version_object(); end + + sig {returns(T.untyped)} + def lockfile(); end + + sig {returns(T.untyped)} + def missing_specs(); end + + sig {returns(T.untyped)} + def missing_specs?(); end + + sig {returns(T.untyped)} + def new_platform?(); end + + sig {returns(T.untyped)} + def new_specs(); end + + sig {returns(T.untyped)} + def nothing_changed?(); end + + sig {returns(T.untyped)} + def platforms(); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def remove_platform(platform); end + + sig {returns(T.untyped)} + def removed_specs(); end + + sig {returns(T.untyped)} + def requested_specs(); end + + sig {returns(T.untyped)} + def requires(); end + + sig {returns(T.untyped)} + def resolve(); end + + sig {returns(T.untyped)} + def resolve_remotely!(); end + + sig {returns(T.untyped)} + def resolve_with_cache!(); end + + sig {returns(T.untyped)} + def ruby_version(); end + + sig {returns(T.untyped)} + def spec_git_paths(); end + + sig {returns(T.untyped)} + def specs(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def specs_for(groups); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def unlocking?(); end + + sig {returns(T.untyped)} + def validate_platforms!(); end + + sig {returns(T.untyped)} + def validate_ruby!(); end + + sig {returns(T.untyped)} + def validate_runtime!(); end + + sig do + params( + gemfile: T.untyped, + lockfile: T.untyped, + unlock: T.untyped, + ) + .returns(T.untyped) + end + def self.build(gemfile, lockfile, unlock); end +end + +class Bundler::DepProxy + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def __platform(); end + + sig {returns(T.untyped)} + def dep(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + dep: T.untyped, + platform: T.untyped, + ) + .returns(T.untyped) + end + def initialize(dep, platform); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def type(); end +end + +class Bundler::Dependency < Gem::Dependency + PLATFORM_MAP = ::T.let(nil, T.untyped) + REVERSE_PLATFORM_MAP = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def autorequire(); end + + sig {returns(T.untyped)} + def current_env?(); end + + sig {returns(T.untyped)} + def current_platform?(); end + + sig do + params( + valid_platforms: T.untyped, + ) + .returns(T.untyped) + end + def gem_platforms(valid_platforms); end + + sig {returns(T.untyped)} + def gemfile(); end + + sig {returns(T.untyped)} + def groups(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + options: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, options=T.unsafe(nil), &blk); end + + sig {returns(T.untyped)} + def platforms(); end + + sig {returns(T.untyped)} + def should_include?(); end + + sig {returns(T.untyped)} + def specific?(); end + + sig {returns(T.untyped)} + def to_lock(); end +end + +class Bundler::DeprecatedError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Dsl + include ::Bundler::RubyDsl + VALID_KEYS = ::T.let(nil, T.untyped) + VALID_PLATFORMS = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + dependencies: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(dependencies); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def env(name); end + + sig do + params( + gemfile: T.untyped, + contents: T.untyped, + ) + .returns(T.untyped) + end + def eval_gemfile(gemfile, contents=T.unsafe(nil)); end + + sig do + params( + name: T.untyped, + args: T.untyped, + ) + .returns(T.untyped) + end + def gem(name, *args); end + + sig do + params( + opts: T.untyped, + ) + .returns(T.untyped) + end + def gemspec(opts=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def gemspecs(); end + + sig do + params( + uri: T.untyped, + options: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def git(uri, options=T.unsafe(nil), &blk); end + + sig do + params( + name: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def git_source(name, &block); end + + sig do + params( + repo: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def github(repo, options=T.unsafe(nil)); end + + sig do + params( + args: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def group(*args, &blk); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def install_if(*args); end + + sig do + params( + name: T.untyped, + args: T.untyped, + ) + .returns(T.untyped) + end + def method_missing(name, *args); end + + sig do + params( + path: T.untyped, + options: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def path(path, options=T.unsafe(nil), &blk); end + + sig do + params( + platforms: T.untyped, + ) + .returns(T.untyped) + end + def platform(*platforms); end + + sig do + params( + platforms: T.untyped, + ) + .returns(T.untyped) + end + def platforms(*platforms); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def plugin(*args); end + + sig do + params( + source: T.untyped, + args: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def source(source, *args, &blk); end + + sig do + params( + lockfile: T.untyped, + unlock: T.untyped, + ) + .returns(T.untyped) + end + def to_definition(lockfile, unlock); end + + sig do + params( + gemfile: T.untyped, + lockfile: T.untyped, + unlock: T.untyped, + ) + .returns(T.untyped) + end + def self.evaluate(gemfile, lockfile, unlock); end +end + +class Bundler::Dsl::DSLError < Bundler::GemfileError + sig {returns(T.untyped)} + def backtrace(); end + + sig {returns(T.untyped)} + def contents(); end + + sig {returns(T.untyped)} + def description(); end + + sig {returns(T.untyped)} + def dsl_path(); end + + sig do + params( + description: T.untyped, + dsl_path: T.untyped, + backtrace: T.untyped, + contents: T.untyped, + ) + .returns(T.untyped) + end + def initialize(description, dsl_path, backtrace, contents=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def status_code(); end + + sig {returns(T.untyped)} + def to_s(); end +end + +class Bundler::EndpointSpecification < Gem::Specification + ILLFORMED_MESSAGE = ::T.let(nil, T.untyped) + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def __swap__(spec); end + + sig {returns(T.untyped)} + def _local_specification(); end + + sig {returns(T.untyped)} + def bindir(); end + + sig {returns(T.untyped)} + def checksum(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + dependencies: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(dependencies); end + + sig {returns(T.untyped)} + def executables(); end + + sig {returns(T.untyped)} + def extensions(); end + + sig {returns(T.untyped)} + def fetch_platform(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + dependencies: T.untyped, + metadata: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, platform, dependencies, metadata=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def load_paths(); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def platform(); end + + sig {returns(T.untyped)} + def post_install_message(); end + + sig {returns(T.untyped)} + def remote(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remote=(remote); end + + sig {returns(T.untyped)} + def require_paths(); end + + sig {returns(T.untyped)} + def required_ruby_version(); end + + sig {returns(T.untyped)} + def required_rubygems_version(); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::EnvironmentPreserver + BUNDLER_KEYS = ::T.let(nil, T.untyped) + BUNDLER_PREFIX = ::T.let(nil, T.untyped) + INTENTIONALLY_NIL = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def backup(); end + + sig do + params( + env: T.untyped, + keys: T.untyped, + ) + .returns(T.untyped) + end + def initialize(env, keys); end + + sig {returns(T.untyped)} + def restore(); end +end + +class Bundler::FeatureFlag + sig {returns(T.untyped)} + def allow_bundler_dependency_conflicts?(); end + + sig {returns(T.untyped)} + def allow_offline_install?(); end + + sig {returns(T.untyped)} + def auto_clean_without_path?(); end + + sig {returns(T.untyped)} + def auto_config_jobs?(); end + + sig {returns(T.untyped)} + def bundler_10_mode?(); end + + sig {returns(T.untyped)} + def bundler_1_mode?(); end + + sig {returns(T.untyped)} + def bundler_2_mode?(); end + + sig {returns(T.untyped)} + def bundler_3_mode?(); end + + sig {returns(T.untyped)} + def bundler_4_mode?(); end + + sig {returns(T.untyped)} + def bundler_5_mode?(); end + + sig {returns(T.untyped)} + def bundler_6_mode?(); end + + sig {returns(T.untyped)} + def bundler_7_mode?(); end + + sig {returns(T.untyped)} + def bundler_8_mode?(); end + + sig {returns(T.untyped)} + def bundler_9_mode?(); end + + sig {returns(T.untyped)} + def cache_all?(); end + + sig {returns(T.untyped)} + def cache_command_is_package?(); end + + sig {returns(T.untyped)} + def console_command?(); end + + sig {returns(T.untyped)} + def default_cli_command(); end + + sig {returns(T.untyped)} + def default_install_uses_path?(); end + + sig {returns(T.untyped)} + def deployment_means_frozen?(); end + + sig {returns(T.untyped)} + def disable_multisource?(); end + + sig {returns(T.untyped)} + def error_on_stderr?(); end + + sig {returns(T.untyped)} + def forget_cli_options?(); end + + sig {returns(T.untyped)} + def global_gem_cache?(); end + + sig {returns(T.untyped)} + def global_path_appends_ruby_scope?(); end + + sig {returns(T.untyped)} + def init_gems_rb?(); end + + sig do + params( + bundler_version: T.untyped, + ) + .returns(T.untyped) + end + def initialize(bundler_version); end + + sig {returns(T.untyped)} + def list_command?(); end + + sig {returns(T.untyped)} + def lockfile_uses_separate_rubygems_sources?(); end + + sig {returns(T.untyped)} + def only_update_to_newer_versions?(); end + + sig {returns(T.untyped)} + def path_relative_to_cwd?(); end + + sig {returns(T.untyped)} + def plugins?(); end + + sig {returns(T.untyped)} + def prefer_gems_rb?(); end + + sig {returns(T.untyped)} + def print_only_version_number?(); end + + sig {returns(T.untyped)} + def setup_makes_kernel_gem_public?(); end + + sig {returns(T.untyped)} + def skip_default_git_sources?(); end + + sig {returns(T.untyped)} + def specific_platform?(); end + + sig {returns(T.untyped)} + def suppress_install_using_messages?(); end + + sig {returns(T.untyped)} + def unlock_source_unlocks_spec?(); end + + sig {returns(T.untyped)} + def update_requires_all_flag?(); end + + sig {returns(T.untyped)} + def use_gem_version_promoter_for_major_updates?(); end + + sig {returns(T.untyped)} + def viz_command?(); end +end + +module Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::StreamUtils_ + LOW_METHODS = ::T.let(nil, T.untyped) + METHODS = ::T.let(nil, T.untyped) + OPT_TABLE = ::T.let(nil, T.untyped) + + sig do + params( + dir: T.untyped, + verbose: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(dir, verbose: T.unsafe(nil), &block); end + + sig do + params( + dir: T.untyped, + verbose: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(dir, verbose: T.unsafe(nil), &block); end + + sig do + params( + mode: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + mode: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end + + sig do + params( + user: T.untyped, + group: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + user: T.untyped, + group: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(a, b); end + + sig do + params( + opt: T.untyped, + ) + .returns(T.untyped) + end + def self.collect_method(opt); end + + sig {returns(T.untyped)} + def self.commands(); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(a, b); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(a, b); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference_root: T.untyped, + remove_destination: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(src, dest); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + dereference_root: T.untyped, + remove_destination: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.getwd(); end + + sig do + params( + mid: T.untyped, + opt: T.untyped, + ) + .returns(T.untyped) + end + def self.have_option?(mid, opt); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(a, b); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + mode: T.untyped, + owner: T.untyped, + group: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.install(src, dest, mode: T.unsafe(nil), owner: T.unsafe(nil), group: T.unsafe(nil), preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.link(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.move(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.options(); end + + sig do + params( + mid: T.untyped, + ) + .returns(T.untyped) + end + def self.options_of(mid); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.private_module_function(name); end + + sig {returns(T.untyped)} + def self.pwd(); end + + sig do + params( + list: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(path, force=T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + parents: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(list, parents: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + mtime: T.untyped, + nocreate: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), mtime: T.unsafe(nil), nocreate: T.unsafe(nil)); end + + sig do + params( + new: T.untyped, + old_list: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(new, old_list); end +end + +module Bundler::FileUtils::DryRun + include ::Bundler::FileUtils::LowMethods + include ::Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::DryRun + extend ::Bundler::FileUtils::LowMethods + extend ::Bundler::FileUtils + extend ::Bundler::FileUtils::StreamUtils_ + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.getwd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.link(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.move(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.pwd(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(*_); end +end + +class Bundler::FileUtils::Entry_ + include ::Bundler::FileUtils::StreamUtils_ + DIRECTORY_TERM = ::T.let(nil, T.untyped) + SYSCASE = ::T.let(nil, T.untyped) + S_IF_DOOR = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def blockdev?(); end + + sig {returns(T.untyped)} + def chardev?(); end + + sig do + params( + mode: T.untyped, + ) + .returns(T.untyped) + end + def chmod(mode); end + + sig do + params( + uid: T.untyped, + gid: T.untyped, + ) + .returns(T.untyped) + end + def chown(uid, gid); end + + sig do + params( + dest: T.untyped, + ) + .returns(T.untyped) + end + def copy(dest); end + + sig do + params( + dest: T.untyped, + ) + .returns(T.untyped) + end + def copy_file(dest); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def copy_metadata(path); end + + sig {returns(T.untyped)} + def dereference?(); end + + sig {returns(T.untyped)} + def directory?(); end + + sig {returns(T.untyped)} + def door?(); end + + sig {returns(T.untyped)} + def entries(); end + + sig {returns(T.untyped)} + def exist?(); end + + sig {returns(T.untyped)} + def file?(); end + + sig do + params( + a: T.untyped, + b: T.untyped, + deref: T.untyped, + ) + .returns(T.untyped) + end + def initialize(a, b=T.unsafe(nil), deref=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def inspect(); end + + sig {returns(T.untyped)} + def lstat(); end + + sig {returns(T.untyped)} + def lstat!(); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def pipe?(); end + + sig {returns(T.untyped)} + def platform_support(); end + + sig {returns(T.untyped)} + def postorder_traverse(); end + + sig {returns(T.untyped)} + def prefix(); end + + sig {returns(T.untyped)} + def preorder_traverse(); end + + sig {returns(T.untyped)} + def rel(); end + + sig {returns(T.untyped)} + def remove(); end + + sig {returns(T.untyped)} + def remove_dir1(); end + + sig {returns(T.untyped)} + def remove_file(); end + + sig {returns(T.untyped)} + def socket?(); end + + sig {returns(T.untyped)} + def stat(); end + + sig {returns(T.untyped)} + def stat!(); end + + sig {returns(T.untyped)} + def symlink?(); end + + sig {returns(T.untyped)} + def traverse(); end + + sig do + params( + pre: T.untyped, + post: T.untyped, + ) + .returns(T.untyped) + end + def wrap_traverse(pre, post); end +end + +module Bundler::FileUtils::LowMethods +end + +module Bundler::FileUtils::NoWrite + include ::Bundler::FileUtils::LowMethods + include ::Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::NoWrite + extend ::Bundler::FileUtils::LowMethods + extend ::Bundler::FileUtils + extend ::Bundler::FileUtils::StreamUtils_ + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.getwd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.link(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.move(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.pwd(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(*_); end +end + +module Bundler::FileUtils::StreamUtils_ +end + +module Bundler::FileUtils::Verbose + include ::Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::Verbose + extend ::Bundler::FileUtils + extend ::Bundler::FileUtils::StreamUtils_ + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(*args, **options); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(a, b); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(a, b); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(a, b); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(*args, **options); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference_root: T.untyped, + remove_destination: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(src, dest); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(*args, **options); end + + sig {returns(T.untyped)} + def self.getwd(); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(a, b); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.link(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.move(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(*args, **options); end + + sig {returns(T.untyped)} + def self.pwd(); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(*args, **options); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(path, force=T.unsafe(nil)); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(*args, **options); end + + sig do + params( + new: T.untyped, + old_list: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(new, old_list); end +end + +module Bundler::GemHelpers + GENERICS = ::T.let(nil, T.untyped) + GENERIC_CACHE = ::T.let(nil, T.untyped) + + sig do + params( + p: T.untyped, + ) + .returns(T.untyped) + end + def self.generic(p); end + + sig {returns(T.untyped)} + def self.generic_local_platform(); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platform_specificity_match(spec_platform, user_platform); end + + sig do + params( + specs: T.untyped, + platform: T.untyped, + ) + .returns(T.untyped) + end + def self.select_best_platform_match(specs, platform); end +end + +class Bundler::GemHelpers::PlatformMatch < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + EXACT_MATCH = ::T.let(nil, T.untyped) + WORST_MATCH = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig {returns(T.untyped)} + def cpu_match(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def cpu_match=(_); end + + sig {returns(T.untyped)} + def os_match(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def os_match=(_); end + + sig {returns(T.untyped)} + def platform_version_match(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def platform_version_match=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.cpu_match(spec_platform, user_platform); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.os_match(spec_platform, user_platform); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platform_version_match(spec_platform, user_platform); end +end + +class Bundler::GemNotFound < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemRequireError < Bundler::BundlerError + sig do + params( + orig_exception: T.untyped, + msg: T.untyped, + ) + .returns(T.untyped) + end + def initialize(orig_exception, msg); end + + sig {returns(T.untyped)} + def orig_exception(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemfileError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemfileEvalError < Bundler::GemfileError +end + +class Bundler::GemfileLockNotFound < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemfileNotFound < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemspecError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GenericSystemCallError < Bundler::BundlerError + sig do + params( + underlying_error: T.untyped, + message: T.untyped, + ) + .returns(T.untyped) + end + def initialize(underlying_error, message); end + + sig {returns(T.untyped)} + def status_code(); end + + sig {returns(T.untyped)} + def underlying_error(); end +end + +class Bundler::GitError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::HTTPError < Bundler::BundlerError + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def filter_uri(uri); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Fetcher::AuthenticationRequiredError < Bundler::HTTPError +end + +class Bundler::Fetcher::BadAuthenticationError < Bundler::HTTPError +end + +class Bundler::Fetcher::CertificateFailureError < Bundler::HTTPError +end + +class Bundler::Fetcher::FallbackError < Bundler::HTTPError +end + +class Bundler::Fetcher::NetworkDownError < Bundler::HTTPError +end + +class Bundler::Fetcher::SSLError < Bundler::HTTPError +end + +class Bundler::Index + include T::Enumerable + EMPTY_SEARCH = ::T.let(nil, T.untyped) + NULL = ::T.let(nil, T.untyped) + RUBY = ::T.let(nil, T.untyped) + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def <<(spec); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def [](query, base=T.unsafe(nil)); end + + sig do + params( + index: T.untyped, + ) + .returns(T.untyped) + end + def add_source(index); end + + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + spec: T.untyped, + other_spec: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_eql?(spec, other_spec); end + + sig {returns(T.untyped)} + def dependency_names(); end + + sig do + params( + blk: T.untyped, + ) + .returns(T.untyped) + end + def each(&blk); end + + sig {returns(T.untyped)} + def empty?(); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def inspect(); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def local_search(query, base=T.unsafe(nil)); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def search(query, base=T.unsafe(nil)); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def search_all(name); end + + sig {returns(T.untyped)} + def size(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def sort_specs(specs); end + + sig {returns(T.untyped)} + def sources(); end + + sig {returns(T.untyped)} + def spec_names(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def unmet_dependency_names(); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def unsorted_search(query, base); end + + sig do + params( + other: T.untyped, + override_dupes: T.untyped, + ) + .returns(T.untyped) + end + def use(other, override_dupes=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.build(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def self.sort_specs(specs); end +end + +class Bundler::InstallError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::InstallHookError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::InvalidOption < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::LazySpecification + include ::Bundler::MatchPlatform + include ::Bundler::GemHelpers + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def __materialize__(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig {returns(T.untyped)} + def full_name(); end + + sig {returns(T.untyped)} + def git_version(); end + + sig {returns(T.untyped)} + def identifier(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + source: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, platform, source=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def platform(); end + + sig {returns(T.untyped)} + def remote(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remote=(remote); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def respond_to?(*args); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def satisfies?(dependency); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::LazySpecification::Identifier < Struct + include ::Comparable + extend ::T::Generic + + Elem = type_member(fixed: T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(_); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def name=(_); end + + sig {returns(T.untyped)} + def platform(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def platform=(_); end + + sig {returns(T.untyped)} + def platform_string(); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def source=(_); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def version=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::LockfileError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::LockfileParser + BUNDLED = ::T.let(nil, T.untyped) + DEPENDENCIES = ::T.let(nil, T.untyped) + ENVIRONMENT_VERSION_SECTIONS = ::T.let(nil, T.untyped) + GEM = ::T.let(nil, T.untyped) + GIT = ::T.let(nil, T.untyped) + KNOWN_SECTIONS = ::T.let(nil, T.untyped) + NAME_VERSION = ::T.let(nil, T.untyped) + OPTIONS = ::T.let(nil, T.untyped) + PATH = ::T.let(nil, T.untyped) + PLATFORMS = ::T.let(nil, T.untyped) + PLUGIN = ::T.let(nil, T.untyped) + RUBY = ::T.let(nil, T.untyped) + SECTIONS_BY_VERSION_INTRODUCED = ::T.let(nil, T.untyped) + SOURCE = ::T.let(nil, T.untyped) + SPECS = ::T.let(nil, T.untyped) + TYPES = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def bundler_version(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + lockfile: T.untyped, + ) + .returns(T.untyped) + end + def initialize(lockfile); end + + sig {returns(T.untyped)} + def platforms(); end + + sig {returns(T.untyped)} + def ruby_version(); end + + sig {returns(T.untyped)} + def sources(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def warn_for_outdated_bundler_version(); end + + sig do + params( + lockfile_contents: T.untyped, + ) + .returns(T.untyped) + end + def self.sections_in_lockfile(lockfile_contents); end + + sig do + params( + base_version: T.untyped, + ) + .returns(T.untyped) + end + def self.sections_to_ignore(base_version=T.unsafe(nil)); end + + sig do + params( + lockfile_contents: T.untyped, + ) + .returns(T.untyped) + end + def self.unknown_sections_in_lockfile(lockfile_contents); end +end + +class Bundler::MarshalError < StandardError +end + +module Bundler::MatchPlatform + include ::Bundler::GemHelpers + sig do + params( + p: T.untyped, + ) + .returns(T.untyped) + end + def match_platform(p); end + + sig do + params( + gemspec_platform: T.untyped, + local_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platforms_match?(gemspec_platform, local_platform); end +end + +module Bundler::Molinillo + VERSION = ::T.let(nil, T.untyped) + +end + +class Bundler::Molinillo::CircularDependencyError < Bundler::Molinillo::ResolverError + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + vertices: T.untyped, + ) + .returns(T.untyped) + end + def initialize(vertices); end +end + +module Bundler::Molinillo::Compatibility + sig do + params( + enum: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def self.flat_map(enum, &blk); end +end + +module Bundler::Molinillo::Delegates +end + +module Bundler::Molinillo::Delegates::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 + + sig {returns(T.untyped)} + def unused_unwind_options(); end +end + +module Bundler::Molinillo::Delegates::SpecificationProvider + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def allow_missing?(dependency); end + + sig do + params( + specification: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_for(specification); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + 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 do + params( + requirement: T.untyped, + activated: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def requirement_satisfied_by?(requirement, activated, spec); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def search_for(dependency); end + + sig do + params( + dependencies: T.untyped, + activated: T.untyped, + conflicts: T.untyped, + ) + .returns(T.untyped) + end + def sort_dependencies(dependencies, activated, conflicts); end +end + +class Bundler::Molinillo::DependencyGraph + include ::TSort + include T::Enumerable + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + 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 do + params( + origin: T.untyped, + destination: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def add_edge(origin, destination, requirement); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + root: T.untyped, + ) + .returns(T.untyped) + end + def add_vertex(name, payload, root=T.unsafe(nil)); end + + sig do + params( + edge: T.untyped, + ) + .returns(T.untyped) + end + def delete_edge(edge); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def detach_vertex_named(name); end + + sig do + params( + blk: T.untyped, + ) + .returns(T.untyped) + end + def each(&blk); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def inspect(); end + + sig {returns(T.untyped)} + def log(); end + + sig do + params( + tag: T.untyped, + ) + .returns(T.untyped) + end + def rewind_to(tag); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def root_vertex_named(name); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def set_payload(name, payload); end + + sig do + params( + tag: T.untyped, + ) + .returns(T.untyped) + end + def tag(tag); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def to_dot(options=T.unsafe(nil)); end + + sig do + params( + vertex: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def tsort_each_child(vertex, &block); end + + sig {returns(T.untyped)} + def tsort_each_node(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def vertex_named(name); end + + sig {returns(T.untyped)} + def vertices(); end + + sig do + params( + vertices: T.untyped, + ) + .returns(T.untyped) + end + def self.tsort(vertices); end +end + +class Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig {returns(T.untyped)} + def next(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def next=(_); end + + sig {returns(T.untyped)} + def previous(); end + + sig do + params( + previous: T.untyped, + ) + .returns(T.untyped) + end + def previous=(previous); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular < Bundler::Molinillo::DependencyGraph::Action + sig {returns(T.untyped)} + def destination(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + origin: T.untyped, + destination: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def initialize(origin, destination, requirement); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def make_edge(graph); end + + sig {returns(T.untyped)} + def origin(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::AddVertex < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + root: T.untyped, + ) + .returns(T.untyped) + end + 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 + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::DeleteEdge < Bundler::Molinillo::DependencyGraph::Action + sig {returns(T.untyped)} + def destination_name(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + origin_name: T.untyped, + destination_name: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def initialize(origin_name, destination_name, requirement); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def make_edge(graph); end + + sig {returns(T.untyped)} + def origin_name(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::DetachVertexNamed < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::Edge < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def destination(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def destination=(_); end + + sig {returns(T.untyped)} + def origin(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def origin=(_); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::DependencyGraph::Log + extend T::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 do + params( + graph: T.untyped, + name: T.untyped, + ) + .returns(T.untyped) + end + def detach_vertex_named(graph, name); end + + sig do + params( + blk: T.untyped, + ) + .returns(T.untyped) + end + def each(&blk); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def pop!(graph); end + + sig {returns(T.untyped)} + def reverse_each(); end + + sig do + params( + graph: T.untyped, + tag: T.untyped, + ) + .returns(T.untyped) + end + def rewind_to(graph, tag); end + + sig do + params( + graph: T.untyped, + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def set_payload(graph, name, payload); end + + sig do + params( + graph: T.untyped, + tag: T.untyped, + ) + .returns(T.untyped) + end + def tag(graph, tag); end +end + +class Bundler::Molinillo::DependencyGraph::SetPayload < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, payload); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def payload(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::Tag < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + _graph: T.untyped, + ) + .returns(T.untyped) + end + def down(_graph); end + + sig do + params( + tag: T.untyped, + ) + .returns(T.untyped) + end + def initialize(tag); end + + sig {returns(T.untyped)} + def tag(); end + + sig do + params( + _graph: T.untyped, + ) + .returns(T.untyped) + end + def up(_graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::Vertex + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + other: T.untyped, + visited: T.untyped, + ) + .returns(T.untyped) + end + def _path_to?(other, visited=T.unsafe(nil)); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ancestor?(other); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def descendent?(other); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def explicit_requirements(); end + + sig {returns(T.untyped)} + def hash(); end + + sig {returns(T.untyped)} + def incoming_edges(); end + + sig do + params( + incoming_edges: T.untyped, + ) + .returns(T.untyped) + end + def incoming_edges=(incoming_edges); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, payload); end + + sig {returns(T.untyped)} + def inspect(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def is_reachable_from?(other); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def name=(name); end + + sig {returns(T.untyped)} + def outgoing_edges(); end + + sig do + params( + outgoing_edges: T.untyped, + ) + .returns(T.untyped) + end + def outgoing_edges=(outgoing_edges); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def path_to?(other); end + + sig {returns(T.untyped)} + def payload(); end + + sig do + params( + payload: T.untyped, + ) + .returns(T.untyped) + end + 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 do + params( + root: T.untyped, + ) + .returns(T.untyped) + end + def root=(root); end + + sig {returns(T.untyped)} + def root?(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def shallow_eql?(other); end + + sig {returns(T.untyped)} + def successors(); end +end + +class Bundler::Molinillo::DependencyState < Bundler::Molinillo::ResolutionState + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def pop_possibility_state(); end +end + +class Bundler::Molinillo::NoSuchDependencyError < Bundler::Molinillo::ResolverError + sig {returns(T.untyped)} + def dependency(); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def dependency=(dependency); end + + sig do + params( + dependency: T.untyped, + required_by: T.untyped, + ) + .returns(T.untyped) + end + def initialize(dependency, required_by=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def required_by(); end + + sig do + params( + required_by: T.untyped, + ) + .returns(T.untyped) + end + def required_by=(required_by); end +end + +class Bundler::Molinillo::PossibilityState < Bundler::Molinillo::ResolutionState + extend T::Generic + Elem = type_member(fixed: T.untyped) +end + +class Bundler::Molinillo::ResolutionState < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def activated(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def activated=(_); end + + sig {returns(T.untyped)} + def conflicts(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def conflicts=(_); end + + sig {returns(T.untyped)} + def depth(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def depth=(_); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def name=(_); end + + sig {returns(T.untyped)} + def possibilities(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def possibilities=(_); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement=(_); end + + sig {returns(T.untyped)} + def requirements(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirements=(_); end + + sig {returns(T.untyped)} + def unused_unwind_options(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def unused_unwind_options=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.empty(); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::Resolver + sig do + params( + specification_provider: T.untyped, + resolver_ui: T.untyped, + ) + .returns(T.untyped) + end + def initialize(specification_provider, resolver_ui); end + + sig do + params( + requested: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def resolve(requested, base=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def resolver_ui(); end + + sig {returns(T.untyped)} + def specification_provider(); end +end + +class Bundler::Molinillo::Resolver::Resolution + include ::Bundler::Molinillo::Delegates::SpecificationProvider + include ::Bundler::Molinillo::Delegates::ResolutionState + 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(T.untyped) + end + def initialize(specification_provider, resolver_ui, requested, base); end + + sig do + params( + iteration_rate: T.untyped, + ) + .returns(T.untyped) + end + 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 do + params( + started_at: T.untyped, + ) + .returns(T.untyped) + end + def started_at=(started_at); end + + sig do + params( + states: T.untyped, + ) + .returns(T.untyped) + end + def states=(states); end +end + +class Bundler::Molinillo::Resolver::Resolution::Conflict < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def activated_by_name(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def activated_by_name=(_); end + + sig {returns(T.untyped)} + def existing(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def existing=(_); end + + sig {returns(T.untyped)} + def locked_requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def locked_requirement=(_); end + + sig {returns(T.untyped)} + def possibility(); end + + sig {returns(T.untyped)} + def possibility_set(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def possibility_set=(_); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement=(_); end + + sig {returns(T.untyped)} + def requirement_trees(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement_trees=(_); end + + sig {returns(T.untyped)} + def requirements(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirements=(_); end + + sig {returns(T.untyped)} + def underlying_error(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def underlying_error=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::Resolver::Resolution::PossibilitySet < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(_); end + + sig {returns(T.untyped)} + def latest_version(); end + + sig {returns(T.untyped)} + def possibilities(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def possibilities=(_); end + + sig {returns(T.untyped)} + def to_s(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::Resolver::Resolution::UnwindDetails < Struct + include ::Comparable + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig {returns(T.untyped)} + def all_requirements(); end + + sig {returns(T.untyped)} + def conflicting_requirements(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def conflicting_requirements=(_); end + + sig {returns(T.untyped)} + def requirement_tree(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement_tree=(_); end + + sig {returns(T.untyped)} + def requirement_trees(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement_trees=(_); end + + sig {returns(T.untyped)} + def requirements_unwound_to_instead(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirements_unwound_to_instead=(_); end + + sig {returns(T.untyped)} + def reversed_requirement_tree_index(); end + + sig {returns(T.untyped)} + def state_index(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def state_index=(_); end + + sig {returns(T.untyped)} + def state_requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def state_requirement=(_); end + + sig {returns(T.untyped)} + def sub_dependencies_to_avoid(); end + + sig {returns(T.untyped)} + def unwinding_to_primary_requirement?(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::ResolverError < StandardError +end + +module Bundler::Molinillo::SpecificationProvider + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def allow_missing?(dependency); end + + sig do + params( + specification: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_for(specification); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + 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 do + params( + requirement: T.untyped, + activated: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def requirement_satisfied_by?(requirement, activated, spec); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def search_for(dependency); end + + sig do + params( + dependencies: T.untyped, + activated: T.untyped, + conflicts: T.untyped, + ) + .returns(T.untyped) + end + def sort_dependencies(dependencies, activated, conflicts); end +end + +module Bundler::Molinillo::UI + sig {returns(T.untyped)} + def after_resolution(); end + + sig {returns(T.untyped)} + def before_resolution(); end + + sig do + params( + depth: T.untyped, + ) + .returns(T.untyped) + end + def debug(depth=T.unsafe(nil)); end + + sig {returns(T.untyped)} + 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 Bundler::Molinillo::VersionConflict < Bundler::Molinillo::ResolverError + include ::Bundler::Molinillo::Delegates::SpecificationProvider + sig {returns(T.untyped)} + def conflicts(); end + + sig do + params( + conflicts: T.untyped, + specification_provider: T.untyped, + ) + .returns(T.untyped) + end + def initialize(conflicts, specification_provider); end + + sig do + params( + opts: T.untyped, + ) + .returns(T.untyped) + end + def message_with_trees(opts=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def specification_provider(); end +end + +class Bundler::NoSpaceOnDeviceError < Bundler::PermissionError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::OperationNotSupportedError < Bundler::PermissionError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::PathError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::PermissionError < Bundler::BundlerError + sig {returns(T.untyped)} + def action(); end + + sig do + params( + path: T.untyped, + permission_type: T.untyped, + ) + .returns(T.untyped) + end + def initialize(path, permission_type=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::Plugin + PLUGIN_FILE_NAME = ::T.let(nil, T.untyped) + + sig do + params( + command: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.add_command(command, cls); end + + sig do + params( + event: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.add_hook(event, &block); end + + sig do + params( + source: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.add_source(source, cls); end + + sig {returns(T.untyped)} + def self.cache(); end + + sig do + params( + command: T.untyped, + ) + .returns(T.untyped) + end + def self.command?(command); end + + sig do + params( + command: T.untyped, + args: T.untyped, + ) + .returns(T.untyped) + end + def self.exec_command(command, args); end + + sig do + params( + gemfile: T.untyped, + inline: T.untyped, + ) + .returns(T.untyped) + end + def self.gemfile_install(gemfile=T.unsafe(nil), &inline); end + + sig {returns(T.untyped)} + def self.global_root(); end + + sig do + params( + event: T.untyped, + args: T.untyped, + arg_blk: T.untyped, + ) + .returns(T.untyped) + end + def self.hook(event, *args, &arg_blk); end + + sig {returns(T.untyped)} + def self.index(); end + + sig do + params( + names: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(names, options); end + + sig do + params( + plugin: T.untyped, + ) + .returns(T.untyped) + end + def self.installed?(plugin); end + + sig {returns(T.untyped)} + def self.local_root(); end + + sig {returns(T.untyped)} + def self.reset!(); end + + sig {returns(T.untyped)} + def self.root(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.source(name); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.source?(name); end + + sig do + params( + locked_opts: T.untyped, + ) + .returns(T.untyped) + end + def self.source_from_lock(locked_opts); end +end + +class Bundler::Plugin::API + sig {returns(T.untyped)} + def cache_dir(); end + + sig do + params( + name: T.untyped, + args: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def method_missing(name, *args, &blk); end + + sig do + params( + names: T.untyped, + ) + .returns(T.untyped) + end + def tmp(*names); end + + sig do + params( + command: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.command(command, cls=T.unsafe(nil)); end + + sig do + params( + event: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.hook(event, &block); end + + sig do + params( + source: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.source(source, cls=T.unsafe(nil)); end +end + +class Bundler::Plugin::DSL + sig do + params( + name: T.untyped, + args: T.untyped + ) + .returns(T.untyped) + end + def _gem(name, *args); end + + sig { returns(T.untyped) } + def inferred_plugins(); end + + sig do + params( + name: T.untyped, + args: T.untyped + ) + .returns(T.untyped) + end + def plugin(name, *args); end +end + +module Bundler::Plugin::Events + def self.defined_event?(event); end +end + +class Bundler::Plugin::Index + def command_plugin(command); end + + def commands(); end + + def global_index_file(); end + + def hook_plugins(event); end + + def index_file(); end + + def installed?(name); end + + def load_paths(name); end + + def local_index_file(); end + + def plugin_path(name); end + + def register_plugin(name, path, load_paths, commands, sources, hooks); end + + def source?(source); end + + def source_plugin(name); end +end + +class Bundler::Plugin::MalformattedPlugin < Bundler::PluginError +end + +class Bundler::Plugin::UndefinedCommandError < Bundler::PluginError +end + +class Bundler::Plugin::UnknownSourceError < Bundler::PluginError +end + +class Bundler::Plugin::DSL::PluginGemfileError < Bundler::PluginError +end + +class Bundler::PluginError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::ProductionError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::RemoteSpecification + include ::Comparable + include ::Bundler::MatchPlatform + include ::Bundler::GemHelpers + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def __swap__(spec); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + dependencies: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(dependencies); end + + sig {returns(T.untyped)} + def fetch_platform(); end + + sig {returns(T.untyped)} + def full_name(); end + + sig {returns(T.untyped)} + def git_version(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + spec_fetcher: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, platform, spec_fetcher); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def platform(); end + + sig {returns(T.untyped)} + def remote(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remote=(remote); end + + sig do + params( + method: T.untyped, + include_all: T.untyped, + ) + .returns(T.untyped) + end + def respond_to?(method, include_all=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def sort_obj(); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::Resolver + include ::Bundler::Molinillo::SpecificationProvider + include ::Bundler::Molinillo::UI + sig {returns(T.untyped)} + def after_resolution(); end + + sig {returns(T.untyped)} + def before_resolution(); end + + sig do + params( + depth: T.untyped, + ) + .returns(T.untyped) + end + def debug(depth=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def debug?(); end + + sig do + params( + specification: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_for(specification); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def index_for(dependency); end + + sig {returns(T.untyped)} + def indicate_progress(); end + + sig do + params( + index: T.untyped, + source_requirements: T.untyped, + base: T.untyped, + gem_version_promoter: T.untyped, + additional_base_requirements: T.untyped, + platforms: T.untyped, + ) + .returns(T.untyped) + end + def initialize(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + 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 do + params( + vertex: T.untyped, + ) + .returns(T.untyped) + end + def relevant_sources_for_vertex(vertex); end + + sig do + params( + requirement: T.untyped, + activated: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def requirement_satisfied_by?(requirement, activated, spec); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def search_for(dependency); end + + sig do + params( + dependencies: T.untyped, + activated: T.untyped, + conflicts: T.untyped, + ) + .returns(T.untyped) + end + def sort_dependencies(dependencies, activated, conflicts); end + + sig do + params( + requirements: T.untyped, + ) + .returns(T.untyped) + end + def start(requirements); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platform_sort_key(platform); end + + sig do + params( + requirements: T.untyped, + index: T.untyped, + source_requirements: T.untyped, + base: T.untyped, + gem_version_promoter: T.untyped, + additional_base_requirements: T.untyped, + platforms: T.untyped, + ) + .returns(T.untyped) + end + def self.resolve(requirements, index, source_requirements=T.unsafe(nil), base=T.unsafe(nil), gem_version_promoter=T.unsafe(nil), additional_base_requirements=T.unsafe(nil), platforms=T.unsafe(nil)); end + + sig do + params( + platforms: T.untyped, + ) + .returns(T.untyped) + end + def self.sort_platforms(platforms); end +end + +class Bundler::Resolver::SpecGroup + include ::Bundler::GemHelpers + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def activate_platform!(platform); end + + sig {returns(T.untyped)} + def dependencies_for_activated_platforms(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def for?(platform); end + + sig {returns(T.untyped)} + def hash(); end + + sig {returns(T.untyped)} + def ignores_bundler_dependencies(); end + + sig do + params( + ignores_bundler_dependencies: T.untyped, + ) + .returns(T.untyped) + end + def ignores_bundler_dependencies=(ignores_bundler_dependencies); end + + sig do + params( + all_specs: T.untyped, + ) + .returns(T.untyped) + end + def initialize(all_specs); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def name=(name); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def to_specs(); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + version: T.untyped, + ) + .returns(T.untyped) + end + def version=(version); end +end + +module Bundler::RubyDsl + sig do + params( + ruby_version: T.untyped, + ) + .returns(T.untyped) + end + def ruby(*ruby_version); end +end + +class Bundler::RubyVersion + PATTERN = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def diff(other); end + + sig {returns(T.untyped)} + def engine(); end + + sig {returns(T.untyped)} + def engine_gem_version(); end + + sig {returns(T.untyped)} + def engine_versions(); end + + sig {returns(T.untyped)} + def exact?(); end + + sig {returns(T.untyped)} + def gem_version(); end + + sig {returns(T.untyped)} + def host(); end + + sig do + params( + versions: T.untyped, + patchlevel: T.untyped, + engine: T.untyped, + engine_version: T.untyped, + ) + .returns(T.untyped) + end + def initialize(versions, patchlevel, engine, engine_version); end + + sig {returns(T.untyped)} + def patchlevel(); end + + sig {returns(T.untyped)} + def single_version_string(); end + + sig {returns(T.untyped)} + def to_gem_version_with_patchlevel(); end + + sig do + params( + versions: T.untyped, + ) + .returns(T.untyped) + end + def to_s(versions=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def versions(); end + + sig do + params( + versions: T.untyped, + ) + .returns(T.untyped) + end + def versions_string(versions); end + + sig do + params( + string: T.untyped, + ) + .returns(T.untyped) + end + def self.from_string(string); end + + sig {returns(T.untyped)} + def self.system(); end +end + +class Bundler::RubyVersionMismatch < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::RubygemsIntegration + EXT_LOCK = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def backport_base_dir(); end + + sig {returns(T.untyped)} + def backport_cache_file(); end + + sig {returns(T.untyped)} + def backport_segment_generation(); end + + sig {returns(T.untyped)} + def backport_spec_file(); end + + sig {returns(T.untyped)} + def backport_yaml_initialize(); end + + sig do + params( + gem: T.untyped, + bin: T.untyped, + ver: T.untyped, + ) + .returns(T.untyped) + end + def bin_path(gem, bin, ver); end + + sig {returns(T.untyped)} + def binstubs_call_gem?(); end + + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + ) + .returns(T.untyped) + end + def build(spec, skip_validation=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def build_args(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def build_args=(args); end + + sig do + params( + gem_dir: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def build_gem(gem_dir, spec); end + + sig {returns(T.untyped)} + def clear_paths(); end + + sig {returns(T.untyped)} + def config_map(); end + + sig {returns(T.untyped)} + def configuration(); end + + sig do + params( + spec: T.untyped, + uri: T.untyped, + path: T.untyped, + ) + .returns(T.untyped) + end + def download_gem(spec, uri, path); end + + sig {returns(T.untyped)} + def ext_lock(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def fetch_all_remote_specs(remote); end + + sig {returns(T.untyped)} + def fetch_prerelease_specs(); end + + sig do + params( + all: T.untyped, + pre: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def fetch_specs(all, pre, &blk); end + + sig {returns(T.untyped)} + def gem_bindir(); end + + sig {returns(T.untyped)} + def gem_cache(); end + + sig {returns(T.untyped)} + def gem_dir(); end + + sig do + params( + path: T.untyped, + policy: T.untyped, + ) + .returns(T.untyped) + end + def gem_from_path(path, policy=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def gem_path(); end + + sig do + params( + obj: T.untyped, + ) + .returns(T.untyped) + end + def inflate(obj); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def install_with_build_args(args); end + + sig {returns(T.untyped)} + def load_path_insert_index(); end + + sig do + params( + files: T.untyped, + ) + .returns(T.untyped) + end + def load_plugin_files(files); end + + sig {returns(T.untyped)} + def load_plugins(); end + + sig {returns(T.untyped)} + def loaded_gem_paths(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def loaded_specs(name); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def mark_loaded(spec); end + + sig {returns(T.untyped)} + def marshal_spec_dir(); end + + sig do + params( + klass: T.untyped, + method: T.untyped, + ) + .returns(T.untyped) + end + def method_visibility(klass, method); end + + sig do + params( + obj: T.untyped, + ) + .returns(T.untyped) + end + def path(obj); end + + sig {returns(T.untyped)} + def path_separator(); end + + sig {returns(T.untyped)} + def platforms(); end + + sig {returns(T.untyped)} + def post_reset_hooks(); end + + sig {returns(T.untyped)} + def preserve_paths(); end + + sig do + params( + req_str: T.untyped, + ) + .returns(T.untyped) + end + def provides?(req_str); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def read_binary(path); end + + sig do + params( + klass: T.untyped, + method: T.untyped, + unbound_method: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def redefine_method(klass, method, unbound_method=T.unsafe(nil), &block); end + + sig do + params( + specs: T.untyped, + specs_by_name: T.untyped, + ) + .returns(T.untyped) + end + def replace_bin_path(specs, specs_by_name); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def replace_entrypoints(specs); end + + sig do + params( + specs: T.untyped, + specs_by_name: T.untyped, + ) + .returns(T.untyped) + end + def replace_gem(specs, specs_by_name); end + + sig {returns(T.untyped)} + def replace_refresh(); end + + sig {returns(T.untyped)} + def repository_subdirectories(); end + + sig {returns(T.untyped)} + def reset(); end + + sig {returns(T.untyped)} + def reverse_rubygems_kernel_mixin(); end + + sig {returns(T.untyped)} + def ruby_engine(); end + + sig {returns(T.untyped)} + def security_policies(); end + + sig {returns(T.untyped)} + def security_policy_keys(); end + + sig do + params( + spec: T.untyped, + installed_by_version: T.untyped, + ) + .returns(T.untyped) + end + def set_installed_by_version(spec, installed_by_version=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def sources(); end + + sig do + params( + val: T.untyped, + ) + .returns(T.untyped) + end + def sources=(val); end + + sig {returns(T.untyped)} + def spec_cache_dirs(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def spec_default_gem?(spec); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def spec_extension_dir(spec); end + + sig do + params( + path: T.untyped, + policy: T.untyped, + ) + .returns(T.untyped) + end + def spec_from_gem(path, policy=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + glob: T.untyped, + ) + .returns(T.untyped) + end + def spec_matches_for_glob(spec, glob); end + + sig do + params( + spec: T.untyped, + default: T.untyped, + ) + .returns(T.untyped) + end + def spec_missing_extensions?(spec, default=T.unsafe(nil)); end + + sig do + params( + stub: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def stub_set_spec(stub, spec); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_source_index(specs); end + + sig {returns(T.untyped)} + def stubs_provide_full_functionality?(); end + + sig {returns(T.untyped)} + def suffix_pattern(); end + + sig do + params( + obj: T.untyped, + ) + .returns(T.untyped) + end + def ui=(obj); end + + sig {returns(T.untyped)} + def undo_replacements(); end + + sig {returns(T.untyped)} + def user_home(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def validate(spec); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def with_build_args(args); end + + sig do + params( + req_str: T.untyped, + ) + .returns(T.untyped) + end + def self.provides?(req_str); end + + sig {returns(T.untyped)} + def self.version(); end +end + +class Bundler::RubygemsIntegration::AlmostModern < Bundler::RubygemsIntegration::Modern + sig {returns(T.untyped)} + def preserve_paths(); end +end + +class Bundler::RubygemsIntegration::Ancient < Bundler::RubygemsIntegration::Legacy + sig {returns(T.untyped)} + def initialize(); end +end + +class Bundler::RubygemsIntegration::Future < Bundler::RubygemsIntegration + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + ) + .returns(T.untyped) + end + def build(spec, skip_validation=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + uri: T.untyped, + path: T.untyped, + ) + .returns(T.untyped) + end + def download_gem(spec, uri, path); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def fetch_all_remote_specs(remote); end + + sig do + params( + source: T.untyped, + remote: T.untyped, + name: T.untyped, + ) + .returns(T.untyped) + end + def fetch_specs(source, remote, name); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig do + params( + path: T.untyped, + policy: T.untyped, + ) + .returns(T.untyped) + end + def gem_from_path(path, policy=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def gem_remote_fetcher(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def install_with_build_args(args); end + + sig {returns(T.untyped)} + def path_separator(); end + + sig {returns(T.untyped)} + def repository_subdirectories(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end +end + +class Bundler::RubygemsIntegration::Legacy < Bundler::RubygemsIntegration + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def post_reset_hooks(); end + + sig {returns(T.untyped)} + def reset(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def validate(spec); end +end + +class Bundler::RubygemsIntegration::Modern < Bundler::RubygemsIntegration + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end +end + +class Bundler::RubygemsIntegration::MoreFuture < Bundler::RubygemsIntegration::Future + sig {returns(T.untyped)} + def all_specs(); end + + sig {returns(T.untyped)} + def backport_ext_builder_monitor(); end + + sig {returns(T.untyped)} + def binstubs_call_gem?(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def stubs_provide_full_functionality?(); end + + sig do + params( + gemfile: T.untyped, + ) + .returns(T.untyped) + end + def use_gemdeps(gemfile); end +end + +class Bundler::RubygemsIntegration::MoreModern < Bundler::RubygemsIntegration::Modern + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + ) + .returns(T.untyped) + end + def build(spec, skip_validation=T.unsafe(nil)); end +end + +class Bundler::RubygemsIntegration::Transitional < Bundler::RubygemsIntegration::Legacy + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def validate(spec); end +end + +class Bundler::Runtime + include ::Bundler::SharedHelpers + REQUIRE_ERRORS = ::T.let(nil, T.untyped) + + sig do + params( + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(custom_path=T.unsafe(nil)); end + + sig do + params( + dry_run: T.untyped, + ) + .returns(T.untyped) + end + def clean(dry_run=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def current_dependencies(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig {returns(T.untyped)} + def gems(); end + + sig do + params( + root: T.untyped, + definition: T.untyped, + ) + .returns(T.untyped) + end + def initialize(root, definition); end + + sig do + params( + opts: T.untyped, + ) + .returns(T.untyped) + end + def lock(opts=T.unsafe(nil)); end + + sig do + params( + cache_path: T.untyped, + ) + .returns(T.untyped) + end + def prune_cache(cache_path); end + + sig {returns(T.untyped)} + def requested_specs(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def require(*groups); end + + sig {returns(T.untyped)} + def requires(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def setup(*groups); end + + sig {returns(T.untyped)} + def specs(); end +end + +class Bundler::SecurityError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Settings + ARRAY_KEYS = ::T.let(nil, T.untyped) + BOOL_KEYS = ::T.let(nil, T.untyped) + CONFIG_REGEX = ::T.let(nil, T.untyped) + DEFAULT_CONFIG = ::T.let(nil, T.untyped) + NORMALIZE_URI_OPTIONS_PATTERN = ::T.let(nil, T.untyped) + NUMBER_KEYS = ::T.let(nil, T.untyped) + PER_URI_OPTIONS = ::T.let(nil, T.untyped) + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def [](name); end + + sig {returns(T.untyped)} + def all(); end + + sig {returns(T.untyped)} + def allow_sudo?(); end + + sig {returns(T.untyped)} + def app_cache_path(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def credentials_for(uri); end + + sig {returns(T.untyped)} + def gem_mirrors(); end + + sig {returns(T.untyped)} + def ignore_config?(); end + + sig do + params( + root: T.untyped, + ) + .returns(T.untyped) + end + def initialize(root=T.unsafe(nil)); end + + sig do + params( + key: T.untyped, + ) + .returns(T.untyped) + end + def key_for(key); end + + sig {returns(T.untyped)} + def local_overrides(); end + + sig do + params( + key: T.untyped, + ) + .returns(T.untyped) + end + def locations(key); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def mirror_for(uri); end + + sig {returns(T.untyped)} + def path(); end + + sig do + params( + exposed_key: T.untyped, + ) + .returns(T.untyped) + end + def pretty_values_for(exposed_key); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_command_option(key, value); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_command_option_if_given(key, value); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_global(key, value); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_local(key, value); end + + sig do + params( + update: T.untyped, + ) + .returns(T.untyped) + end + def temporary(update); end + + sig {returns(T.untyped)} + def validate!(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def self.normalize_uri(uri); end +end + +class Bundler::Settings::Path < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def append_ruby_scope(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def append_ruby_scope=(_); end + + sig {returns(T.untyped)} + def base_path(); end + + sig {returns(T.untyped)} + def base_path_relative_to_pwd(); end + + sig {returns(T.untyped)} + def default_install_uses_path(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def default_install_uses_path=(_); end + + sig {returns(T.untyped)} + def explicit_path(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def explicit_path=(_); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def system_path(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def system_path=(_); end + + sig {returns(T.untyped)} + def use_system_gems?(); end + + sig {returns(T.untyped)} + def validate!(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +module Bundler::SharedHelpers + extend ::Bundler::SharedHelpers + sig do + params( + dir: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def chdir(dir, &blk); end + + sig do + params( + constant_name: T.untyped, + namespace: T.untyped, + ) + .returns(T.untyped) + end + def const_get_safely(constant_name, namespace); end + + sig {returns(T.untyped)} + def default_bundle_dir(); end + + sig {returns(T.untyped)} + def default_gemfile(); end + + sig {returns(T.untyped)} + def default_lockfile(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def digest(name); end + + sig do + params( + spec: T.untyped, + old_deps: T.untyped, + new_deps: T.untyped, + ) + .returns(T.untyped) + end + def ensure_same_dependencies(spec, old_deps, new_deps); end + + sig do + params( + path: T.untyped, + action: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def filesystem_access(path, action=T.unsafe(nil), &block); end + + sig {returns(T.untyped)} + def in_bundle?(); end + + sig do + params( + major_version: T.untyped, + message: T.untyped, + ) + .returns(T.untyped) + end + def major_deprecation(major_version, message); end + + sig {returns(T.untyped)} + def md5_available?(); end + + sig do + params( + dep: T.untyped, + print_source: T.untyped, + ) + .returns(T.untyped) + end + def pretty_dependency(dep, print_source=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def print_major_deprecations!(); end + + sig {returns(T.untyped)} + def pwd(); end + + sig {returns(T.untyped)} + def root(); end + + sig {returns(T.untyped)} + def set_bundle_environment(); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_env(key, value); end + + sig do + params( + signal: T.untyped, + override: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def trap(signal, override=T.unsafe(nil), &block); end + + sig do + params( + block: T.untyped, + ) + .returns(T.untyped) + end + def with_clean_git_env(&block); end + + sig do + params( + gemfile_path: T.untyped, + contents: T.untyped, + ) + .returns(T.untyped) + end + def write_to_gemfile(gemfile_path, contents); end +end + +class Bundler::Source + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def can_lock?(spec); end + + sig {returns(T.untyped)} + def dependency_names(); end + + sig do + params( + dependency_names: T.untyped, + ) + .returns(T.untyped) + end + def dependency_names=(dependency_names); end + + sig {returns(T.untyped)} + def dependency_names_to_double_check(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def double_check_for(*_); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def extension_cache_path(spec); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def include?(other); end + + sig {returns(T.untyped)} + def inspect(); end + + sig {returns(T.untyped)} + def path?(); end + + sig {returns(T.untyped)} + def unmet_deps(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def version_message(spec); end +end + +class Bundler::Source::Gemspec < Bundler::Source::Path + sig {returns(T.untyped)} + def as_path_source(); end + + sig {returns(T.untyped)} + def gemspec(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options); end +end + +class Bundler::Source::Git < Bundler::Source::Path + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def allow_git_ops?(); end + + sig {returns(T.untyped)} + def app_cache_dirname(); end + + sig {returns(T.untyped)} + def branch(); end + + sig do + params( + spec: T.untyped, + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(spec, custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def cache_path(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def extension_dir_name(); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options); end + + sig do + params( + spec: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, options=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def install_path(); end + + sig {returns(T.untyped)} + def load_spec_files(); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def local_override!(path); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def ref(); end + + sig {returns(T.untyped)} + def revision(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def specs(*_); end + + sig {returns(T.untyped)} + def submodules(); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def unlock!(); end + + sig {returns(T.untyped)} + def uri(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def self.from_lock(options); end +end + +class Bundler::Source::Git::GitCommandError < Bundler::GitError + sig do + params( + command: T.untyped, + path: T.untyped, + extra_info: T.untyped, + ) + .returns(T.untyped) + end + def initialize(command, path=T.unsafe(nil), extra_info=T.unsafe(nil)); end +end + +class Bundler::Source::Git::GitNotAllowedError < Bundler::GitError + sig do + params( + command: T.untyped, + ) + .returns(T.untyped) + end + def initialize(command); end +end + +class Bundler::Source::Git::GitNotInstalledError < Bundler::GitError + sig {returns(T.untyped)} + def initialize(); end +end + +class Bundler::Source::Git::GitProxy + sig {returns(T.untyped)} + def branch(); end + + sig {returns(T.untyped)} + def checkout(); end + + sig do + params( + commit: T.untyped, + ) + .returns(T.untyped) + end + def contains?(commit); end + + sig do + params( + destination: T.untyped, + submodules: T.untyped, + ) + .returns(T.untyped) + end + def copy_to(destination, submodules=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def full_version(); end + + sig do + params( + path: T.untyped, + uri: T.untyped, + ref: T.untyped, + revision: T.untyped, + git: T.untyped, + ) + .returns(T.untyped) + end + def initialize(path, uri, ref, revision=T.unsafe(nil), git=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def path(); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def path=(path); end + + sig {returns(T.untyped)} + def ref(); end + + sig do + params( + ref: T.untyped, + ) + .returns(T.untyped) + end + def ref=(ref); end + + sig {returns(T.untyped)} + def revision(); end + + sig do + params( + revision: T.untyped, + ) + .returns(T.untyped) + end + def revision=(revision); end + + sig {returns(T.untyped)} + def uri(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def uri=(uri); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::Source::Git::MissingGitRevisionError < Bundler::GitError + sig do + params( + ref: T.untyped, + repo: T.untyped, + ) + .returns(T.untyped) + end + def initialize(ref, repo); end +end + +class Bundler::Source::Metadata < Bundler::Source + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def cached!(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + spec: T.untyped, + _opts: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, _opts=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def version_message(spec); end +end + +class Bundler::Source::Path < Bundler::Source + DEFAULT_GLOB = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def app_cache_dirname(); end + + sig do + params( + spec: T.untyped, + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(spec, custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def cached!(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def expanded_original_path(); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options); end + + sig do + params( + spec: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, options=T.unsafe(nil)); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def local_specs(*_); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def name=(name); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def original_path(); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig {returns(T.untyped)} + def root(); end + + sig {returns(T.untyped)} + def root_path(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + version: T.untyped, + ) + .returns(T.untyped) + end + def version=(version); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def self.from_lock(options); end +end + +class Bundler::Source::Rubygems < Bundler::Source + API_REQUEST_LIMIT = ::T.let(nil, T.untyped) + API_REQUEST_SIZE = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def add_remote(source); end + + sig {returns(T.untyped)} + def api_fetchers(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def builtin_gem?(spec); end + + sig do + params( + spec: T.untyped, + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(spec, custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def cache_path(); end + + sig {returns(T.untyped)} + def cached!(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def cached_built_in_gem(spec); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def cached_gem(spec); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def cached_path(spec); end + + sig {returns(T.untyped)} + def cached_specs(); end + + sig {returns(T.untyped)} + def caches(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def can_lock?(spec); end + + sig {returns(T.untyped)} + def credless_remotes(); end + + sig {returns(T.untyped)} + def dependency_names_to_double_check(); end + + sig do + params( + unmet_dependency_names: T.untyped, + ) + .returns(T.untyped) + end + def double_check_for(unmet_dependency_names); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig do + params( + other_remotes: T.untyped, + ) + .returns(T.untyped) + end + def equivalent_remotes?(other_remotes); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def fetch_gem(spec); end + + sig do + params( + fetchers: T.untyped, + dependency_names: T.untyped, + index: T.untyped, + override_dupes: T.untyped, + ) + .returns(T.untyped) + end + def fetch_names(fetchers, dependency_names, index, override_dupes); end + + sig {returns(T.untyped)} + def fetchers(); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + o: T.untyped, + ) + .returns(T.untyped) + end + def include?(o); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + opts: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, opts=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def installed?(spec); end + + sig {returns(T.untyped)} + def installed_specs(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def loaded_from(spec); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def normalize_uri(uri); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig {returns(T.untyped)} + def remote_specs(); end + + sig {returns(T.untyped)} + def remotes(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def remotes_for_spec(spec); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remove_auth(remote); end + + sig do + params( + other_remotes: T.untyped, + allow_equivalent: T.untyped, + ) + .returns(T.untyped) + end + def replace_remotes(other_remotes, allow_equivalent=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def requires_sudo?(); end + + sig {returns(T.untyped)} + def rubygems_dir(); end + + sig {returns(T.untyped)} + def specs(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def suppress_configured_credentials(remote); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def unmet_deps(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def self.from_lock(options); end +end + +class Bundler::SourceList + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def add_git_source(options=T.unsafe(nil)); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def add_path_source(options=T.unsafe(nil)); end + + sig do + params( + source: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def add_plugin_source(source, options=T.unsafe(nil)); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def add_rubygems_remote(uri); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def add_rubygems_source(options=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def all_sources(); end + + sig {returns(T.untyped)} + def cached!(); end + + sig {returns(T.untyped)} + def default_source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def get(source); end + + sig {returns(T.untyped)} + def git_sources(); end + + sig {returns(T.untyped)} + def global_rubygems_source(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def global_rubygems_source=(uri); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def lock_sources(); end + + sig {returns(T.untyped)} + def metadata_source(); end + + sig {returns(T.untyped)} + def path_sources(); end + + sig {returns(T.untyped)} + def plugin_sources(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig do + params( + replacement_sources: T.untyped, + ) + .returns(T.untyped) + end + def replace_sources!(replacement_sources); end + + sig {returns(T.untyped)} + def rubygems_primary_remotes(); end + + sig {returns(T.untyped)} + def rubygems_remotes(); end + + sig {returns(T.untyped)} + def rubygems_sources(); end +end + +class Bundler::SpecSet + include ::TSort + include T::Enumerable + extend ::Forwardable + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def <<(*args, &block); end + + sig do + params( + key: T.untyped, + ) + .returns(T.untyped) + end + def [](key); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def []=(key, value); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def add(*args, &block); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def each(*args, &block); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def empty?(*args, &block); end + + sig do + params( + name: T.untyped, + platform: T.untyped, + ) + .returns(T.untyped) + end + def find_by_name_and_platform(name, platform); end + + sig do + params( + dependencies: T.untyped, + skip: T.untyped, + check: T.untyped, + match_current_platform: T.untyped, + raise_on_missing: T.untyped, + ) + .returns(T.untyped) + end + def for(dependencies, skip=T.unsafe(nil), check=T.unsafe(nil), match_current_platform=T.unsafe(nil), raise_on_missing=T.unsafe(nil)); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def initialize(specs); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def length(*args, &block); end + + sig do + params( + deps: T.untyped, + missing_specs: T.untyped, + ) + .returns(T.untyped) + end + def materialize(deps, missing_specs=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def materialized_for_all_platforms(); end + + sig do + params( + set: T.untyped, + ) + .returns(T.untyped) + end + def merge(set); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def remove(*args, &block); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def size(*args, &block); end + + sig {returns(T.untyped)} + def sort!(); end + + sig {returns(T.untyped)} + def to_a(); end + + sig {returns(T.untyped)} + def to_hash(); end + + sig do + params( + deps: T.untyped, + ) + .returns(T.untyped) + end + def valid_for?(deps); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def what_required(spec); end +end + +class Bundler::StubSpecification < Bundler::RemoteSpecification + sig {returns(T.untyped)} + def activated(); end + + sig do + params( + activated: T.untyped, + ) + .returns(T.untyped) + end + def activated=(activated); end + + sig {returns(T.untyped)} + def default_gem(); end + + sig {returns(T.untyped)} + def full_gem_path(); end + + sig {returns(T.untyped)} + def full_require_paths(); end + + sig {returns(T.untyped)} + def ignored(); end + + sig do + params( + ignored: T.untyped, + ) + .returns(T.untyped) + end + def ignored=(ignored); end + + sig {returns(T.untyped)} + def load_paths(); end + + sig {returns(T.untyped)} + def loaded_from(); end + + sig do + params( + glob: T.untyped, + ) + .returns(T.untyped) + end + def matches_for_glob(glob); end + + sig {returns(T.untyped)} + def missing_extensions?(); end + + sig {returns(T.untyped)} + def raw_require_paths(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def stub(); end + + sig do + params( + stub: T.untyped, + ) + .returns(T.untyped) + end + def stub=(stub); end + + sig {returns(T.untyped)} + def to_yaml(); end + + sig do + params( + stub: T.untyped, + ) + .returns(T.untyped) + end + def self.from_stub(stub); end +end + +class Bundler::SudoNotPermittedError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::TemporaryResourceError < Bundler::PermissionError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::ThreadCreationError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::UI +end + +class Bundler::UI::RGProxy < Gem::SilentUI + sig do + params( + ui: T.untyped, + ) + .returns(T.untyped) + end + def initialize(ui); end + + sig do + params( + message: T.untyped, + ) + .returns(T.untyped) + end + def say(message); end +end + +class Bundler::UI::Silent + sig do + params( + string: T.untyped, + color: T.untyped, + ) + .returns(T.untyped) + end + def add_color(string, color); end + + sig do + params( + message: T.untyped, + ) + .returns(T.untyped) + end + def ask(message); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def confirm(message, newline=T.unsafe(nil)); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def debug(message, newline=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def debug?(); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def error(message, newline=T.unsafe(nil)); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def info(message, newline=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def level(name=T.unsafe(nil)); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def level=(name); end + + sig {returns(T.untyped)} + def no?(); end + + sig {returns(T.untyped)} + def quiet?(); end + + sig do + params( + shell: T.untyped, + ) + .returns(T.untyped) + end + def shell=(shell); end + + sig {returns(T.untyped)} + def silence(); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def trace(message, newline=T.unsafe(nil), force=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def unprinted_warnings(); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def warn(message, newline=T.unsafe(nil)); end + + sig do + params( + msg: T.untyped, + ) + .returns(T.untyped) + end + def yes?(msg); end +end + +module Bundler::URICredentialsFilter + sig do + params( + str_to_filter: T.untyped, + uri: T.untyped, + ) + .returns(T.untyped) + end + def self.credential_filtered_string(str_to_filter, uri); end + + sig do + params( + uri_to_anonymize: T.untyped, + ) + .returns(T.untyped) + end + def self.credential_filtered_uri(uri_to_anonymize); end +end + +class Bundler::VersionConflict < Bundler::BundlerError + sig {returns(T.untyped)} + def conflicts(); end + + sig do + params( + conflicts: T.untyped, + msg: T.untyped, + ) + .returns(T.untyped) + end + def initialize(conflicts, msg=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::VirtualProtocolError < Bundler::BundlerError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::YAMLSerializer + ARRAY_REGEX = ::T.let(nil, T.untyped) + HASH_REGEX = ::T.let(nil, T.untyped) + + sig do + params( + hash: T.untyped, + ) + .returns(T.untyped) + end + def self.dump(hash); end + + sig do + params( + str: T.untyped, + ) + .returns(T.untyped) + end + def self.load(str); end +end + +class Bundler::YamlSyntaxError < Bundler::BundlerError + sig do + params( + orig_exception: T.untyped, + msg: T.untyped, + ) + .returns(T.untyped) + end + def initialize(orig_exception, msg); end + + sig {returns(T.untyped)} + def orig_exception(); end + + sig {returns(T.untyped)} + def status_code(); end +end diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi new file mode 100644 index 0000000..2f8d981 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi @@ -0,0 +1,4222 @@ +# 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 diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi new file mode 100644 index 0000000..4b1fed1 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi @@ -0,0 +1,111 @@ +# 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/open3.rbi +# +# typed: strong + +module Open3 + sig do + params( + cmd: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter).void) + ).returns([IO, IO, IO, Process::Waiter]) + end + def self.popen3(*cmd, **opts, &block); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter).void) + ).returns([IO, IO, Process::Waiter]) + end + def self.popen2(*cmd, **opts, &block); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(stdin: IO, stdout_and_stderr: IO, wait_thr: Process::Waiter).void) + ).returns([IO, IO, Process::Waiter]) + end + def self.popen2e(*cmd, **opts, &block); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + stdin_data: T.nilable(String), + binmode: T.any(FalseClass, TrueClass), + opts: T::Hash[Symbol, T.untyped] + ).returns([String, String, Process::Status]) + end + def self.capture3(*cmd, stdin_data: '', binmode: false, **opts); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + stdin_data: T.nilable(String), + binmode: T.any(FalseClass, TrueClass), + opts: T::Hash[Symbol, T.untyped] + ).returns([String, Process::Status]) + end + def self.capture2(*cmd, stdin_data: nil, binmode: false, **opts); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + stdin_data: T.nilable(String), + binmode: T.any(FalseClass, TrueClass), + opts: T::Hash[Symbol, T.untyped] + ).returns([String, Process::Status]) + end + def self.capture2e(*cmd, stdin_data: nil, binmode: false, **opts); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(first_stdin: IO, last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void) + ).returns([IO, IO, T::Array[Process::Waiter]]) + end + def self.pipeline_rw(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void) + ).returns([IO, T::Array[Process::Waiter]]) + end + def self.pipeline_r(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(first_stdin: IO, wait_threads: T::Array[Process::Waiter]).void) + ).returns([IO, T::Array[Process::Waiter]]) + end + def self.pipeline_w(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped], + block: T.nilable(T.proc.params(wait_threads: T::Array[Process::Waiter]).void) + ).returns(T::Array[Process::Waiter]) + end + def self.pipeline_start(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T::Hash[Symbol, T.untyped] + ).returns(T::Array[Process::Status]) + end + def self.pipeline(*cmds, **opts); end +end diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi new file mode 100644 index 0000000..487e803 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi @@ -0,0 +1,543 @@ +# 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/resolv.rbi +# +# typed: strong + +class Resolv + sig { params(name: String).returns(String) } + def self.getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def self.getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def self.each_address(name, &block); end + + sig { params(address: String).returns(String) } + def self.getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def self.getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def self.each_name(address, &proc); end + + sig { params(resolvers: [Hosts, DNS]).void } + def initialize(resolvers=[Hosts.new, DNS.new]); end + + sig { params(name: String).returns(String) } + def getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def each_address(name, &block); end + + sig { params(address: String).returns(String) } + def getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def each_name(address, &proc); end + + class ResolvError < StandardError; end + class ResolvTimeout < Timeout::Error; end + + class Hosts + DefaultFileName = T.let(T.unsafe(nil), String) + + sig { params(filename: String).void } + def initialize(filename = DefaultFileName); end + + sig { params(name: String).returns(String) } + def getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def each_address(name, &block); end + + sig { params(address: String).returns(String) } + def getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def each_name(address, &proc); end + end + + class DNS + Port = T.let(T.unsafe(nil), Integer) + + UDPSize = T.let(T.unsafe(nil), Integer) + + sig do + params( + config_info: T.any( + NilClass, + String, + { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, + { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } + ) + ).returns(Resolv::DNS) + end + def self.open(config_info = nil); end + + sig do + params( + config_info: T.any( + NilClass, + String, + { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, + { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } + ) + ).void + end + def initialize(config_info = nil); end + + sig { params(values: T.any(NilClass, Integer, T::Array[Integer])).void } + def timeouts=(values); end + + sig { void } + def close; end + + sig { params(name: String).returns(String) } + def getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def each_address(name, &block); end + + sig { params(address: String).returns(String) } + def getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def each_name(address, &proc); end + + sig do + params( + name: T.any(String, Resolv::DNS::Name), + typeclass: T.class_of(Resolv::DNS::Resource) + ).returns(Resolv::DNS::Resource) + end + def getresource(name, typeclass); end + + sig do + params( + name: T.any(String, Resolv::DNS::Name), + typeclass: T.class_of(Resolv::DNS::Resource) + ).returns(T::Array[Resolv::DNS::Resource]) + end + def getresources(name, typeclass); end + + sig do + params( + name: T.any(String, Resolv::DNS::Name), + typeclass: T.class_of(Resolv::DNS::Resource), + proc: T.proc.params(resource: Resolv::DNS::Resource).void + ).void + end + def each_resource(name, typeclass, &proc); end + + class DecodeError < StandardError; end + class EncodeError < StandardError; end + + class Name + sig { params(arg: T.any(String, Resolv::DNS::Name)).returns(Resolv::DNS::Name) } + def self.create(arg); end + + sig { params(labels: T::Array[String], absolute: T.any(FalseClass, TrueClass)).void } + def initialize(labels, absolute=true); end + + sig { returns(T.any(FalseClass, TrueClass)) } + def absolute?; end + + sig { params(other: Resolv::DNS::Name).returns(T.any(FalseClass, TrueClass)) } + def subdomain_of?(other); end + end + + class Query; end + + class Resource < Query + sig { returns(T.nilable(Integer)) } + attr_reader :ttl + + sig { void } + def initialize + @ttl = T.let(T.unsafe(nil), T.nilable(Integer)) + end + + class Generic < Resource + sig { params(data: T.untyped).void } + def initialize(data) + @data = T.let(T.unsafe(nil), T.untyped) + end + + sig { returns(T.untyped) } + attr_reader :data + end + + class DomainName < Resource + sig { params(name: String).void } + def initialize(name) + @name = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :name + end + + class NS < DomainName; end + + class CNAME < DomainName; end + + class SOA < Resource + sig do + params( + mname: String, + rname: String, + serial: Integer, + refresh: Integer, + retry_: Integer, + expire: Integer, + minimum: Integer + ).void + end + def initialize(mname, rname, serial, refresh, retry_, expire, minimum) + @mname = T.let(T.unsafe(nil), String) + @rname = T.let(T.unsafe(nil), String) + @serial = T.let(T.unsafe(nil), Integer) + @refresh = T.let(T.unsafe(nil), Integer) + @retry = T.let(T.unsafe(nil), Integer) + @expire = T.let(T.unsafe(nil), Integer) + @minimum = T.let(T.unsafe(nil), Integer) + end + + sig { returns(String) } + attr_reader :mname + + sig { returns(String) } + attr_reader :rname + + sig { returns(Integer) } + attr_reader :serial + + sig { returns(Integer) } + attr_reader :refresh + + sig { returns(Integer) } + attr_reader :retry + + sig { returns(Integer) } + attr_reader :expire + + sig { returns(Integer) } + attr_reader :minimum + end + + class PTR < DomainName; end + + class HINFO < Resource + sig { params(cpu: String, os: String).void } + def initialize(cpu, os) + @cpu = T.let(T.unsafe(nil), String) + @os = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :cpu + + sig { returns(String) } + attr_reader :os + end + + class MINFO < Resource + sig { params(rmailbx: String, emailbx: String).void } + def initialize(rmailbx, emailbx) + @rmailbx = T.let(T.unsafe(nil), String) + @emailbx = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :rmailbx + + sig { returns(String) } + attr_reader :emailbx + end + + class MX < Resource + sig { params(preference: Integer, exchange: String).void } + def initialize(preference, exchange) + @preference = T.let(T.unsafe(nil), Integer) + @exchange = T.let(T.unsafe(nil), String) + end + + sig { returns(Integer) } + attr_reader :preference + + sig { returns(String) } + attr_reader :exchange + end + + class TXT < Resource + sig { params(first_string: String, rest_strings: String).void } + def initialize(first_string, *rest_strings) + @strings = T.let(T.unsafe(nil), T::Array[String]) + end + + sig { returns(T::Array[String]) } + attr_reader :strings + + sig { returns(String) } + def data; end + end + + class LOC < Resource + sig do + params( + version: String, + ssize: T.any(String, Resolv::LOC::Size), + hprecision: T.any(String, Resolv::LOC::Size), + vprecision: T.any(String, Resolv::LOC::Size), + latitude: T.any(String, Resolv::LOC::Coord), + longitude: T.any(String, Resolv::LOC::Coord), + altitude: T.any(String, Resolv::LOC::Alt) + ).void + end + def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude) + @version = T.let(T.unsafe(nil), String) + @ssize = T.let(T.unsafe(nil), Resolv::LOC::Size) + @hprecision = T.let(T.unsafe(nil), Resolv::LOC::Size) + @vprecision = T.let(T.unsafe(nil), Resolv::LOC::Size) + @latitude = T.let(T.unsafe(nil), Resolv::LOC::Coord) + @longitude = T.let(T.unsafe(nil), Resolv::LOC::Coord) + @altitude = T.let(T.unsafe(nil), Resolv::LOC::Alt) + end + + sig { returns(String) } + attr_reader :version + + sig { returns(Resolv::LOC::Size) } + attr_reader :ssize + + sig { returns(Resolv::LOC::Size) } + attr_reader :hprecision + + sig { returns(Resolv::LOC::Size) } + attr_reader :vprecision + + sig { returns(Resolv::LOC::Coord) } + attr_reader :latitude + + sig { returns(Resolv::LOC::Coord) } + attr_reader :longitude + + sig { returns(Resolv::LOC::Alt) } + attr_reader :altitude + end + + class ANY < Query; end + + module IN + class A < Resource + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), Resolv::IPv4) + end + + sig { returns(Resolv::IPv4) } + attr_reader :address + end + + class WKS < Resource + sig { params(address: String, protocol: Integer, bitmap: String).void } + def initialize(address, protocol, bitmap) + @address = T.let(T.unsafe(nil), Resolv::IPv4) + @protocol = T.let(T.unsafe(nil), Integer) + @bitmap = T.let(T.unsafe(nil), String) + end + + sig { returns(Resolv::IPv4) } + attr_reader :address + + sig { returns(Integer) } + attr_reader :protocol + + sig { returns(String) } + attr_reader :bitmap + end + + class AAAA < Resource + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), Resolv::IPv6) + end + + sig { returns(Resolv::IPv6) } + attr_reader :address + end + + class SRV < Resource + # Create a SRV resource record. + # + # See the documentation for #priority, #weight, #port and #target + # for +priority+, +weight+, +port and +target+ respectively. + + sig do + params( + priority: T.any(Integer, String), + weight: T.any(Integer, String), + port: T.any(Integer, String), + target: T.any(String, Resolv::DNS::Name) + ).void + end + def initialize(priority, weight, port, target) + @priority = T.let(T.unsafe(nil), Integer) + @weight = T.let(T.unsafe(nil), Integer) + @port = T.let(T.unsafe(nil), Integer) + @target = T.let(T.unsafe(nil), Resolv::DNS::Name) + end + + sig { returns(Integer) } + attr_reader :priority + + sig { returns(Integer) } + attr_reader :weight + + sig { returns(Integer) } + attr_reader :port + + sig { returns(Resolv::DNS::Name) } + attr_reader :target + end + end + end + end + + class IPv4 + Regex256 = T.let(T.unsafe(nil), Regexp) + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::IPv4)).returns(Resolv::IPv4) } + def self.create(arg); end + + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :address + + sig { returns(DNS::Name) } + def to_name; end + end + + class IPv6 + Regex_8Hex = T.let(T.unsafe(nil), Regexp) + Regex_CompressedHex = T.let(T.unsafe(nil), Regexp) + Regex_6Hex4Dec = T.let(T.unsafe(nil), Regexp) + Regex_CompressedHex4Dec = T.let(T.unsafe(nil), Regexp) + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::IPv6)).returns(Resolv::IPv6) } + def self.create(arg); end + + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :address + + sig { returns(DNS::Name) } + def to_name; end + end + + class MDNS < DNS + Port = T.let(T.unsafe(nil), Integer) + AddressV4 = T.let(T.unsafe(nil), String) + AddressV6 = T.let(T.unsafe(nil), String) + Addresses = T.let(T.unsafe(nil), [[String, Integer], [String, Integer]]) + + sig do + params( + config_info: T.any( + NilClass, + { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, + { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } + ) + ).void + end + def initialize(config_info = nil); end + end + + module LOC + class Size + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::LOC::Size)).returns(Resolv::LOC::Size) } + def self.create(arg); end + + sig { params(scalar: String).void } + def initialize(scalar) + @scalar = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :scalar + end + + class Coord + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::LOC::Coord)).returns(Resolv::LOC::Coord) } + def self.create(arg); end + + sig { params(coordinates: String, orientation: T.enum(%w[lat lon])).void } + def initialize(coordinates, orientation) + @coordinates = T.let(T.unsafe(nil), String) + @orientation = T.let(T.unsafe(nil), T.enum(%w[lat lon])) + end + + sig { returns(String) } + attr_reader :coordinates + + sig { returns(T.enum(%w[lat lon])) } + attr_reader :orientation + end + + class Alt + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::LOC::Alt)).returns(Resolv::LOC::Alt) } + def self.create(arg); end + + sig { params(altitude: String).void } + def initialize(altitude) + @altitude = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :altitude + end + end + + DefaultResolver = T.let(T.unsafe(nil), Resolv) + AddressRegex = T.let(T.unsafe(nil), Regexp) +end diff --git a/spec/cc_engine/config_spec.rb b/spec/cc_engine/config_spec.rb index 98bea58..bbc7007 100644 --- a/spec/cc_engine/config_spec.rb +++ b/spec/cc_engine/config_spec.rb @@ -1,3 +1,4 @@ +# typed: false require "cc_engine/config" RSpec.describe CCEngine::Config do diff --git a/spec/cc_engine/issue_spec.rb b/spec/cc_engine/issue_spec.rb index 105c222..3b363e4 100644 --- a/spec/cc_engine/issue_spec.rb +++ b/spec/cc_engine/issue_spec.rb @@ -1,3 +1,4 @@ +# typed: false require "cc_engine/issue" require "cc_engine/category" diff --git a/spec/cc_engine/location/line_range_spec.rb b/spec/cc_engine/location/line_range_spec.rb index 91a3ede..b6af82f 100644 --- a/spec/cc_engine/location/line_range_spec.rb +++ b/spec/cc_engine/location/line_range_spec.rb @@ -1,3 +1,4 @@ +# typed: false require "cc_engine/location/line_range" module CCEngine diff --git a/spec/cc_engine/location/position_spec.rb b/spec/cc_engine/location/position_spec.rb index a13fdb9..693a7c0 100644 --- a/spec/cc_engine/location/position_spec.rb +++ b/spec/cc_engine/location/position_spec.rb @@ -1,3 +1,4 @@ +# typed: ignore require "cc_engine/location/position" require "cc_engine/position/grid" require "cc_engine/position/offset" diff --git a/spec/cc_engine/position/grid_spec.rb b/spec/cc_engine/position/grid_spec.rb index 579a672..27e0767 100644 --- a/spec/cc_engine/position/grid_spec.rb +++ b/spec/cc_engine/position/grid_spec.rb @@ -1,3 +1,4 @@ +# typed: false require "cc_engine/position/grid" module CCEngine diff --git a/spec/cc_engine/position/offset_spec.rb b/spec/cc_engine/position/offset_spec.rb index 5160a63..81e3a55 100644 --- a/spec/cc_engine/position/offset_spec.rb +++ b/spec/cc_engine/position/offset_spec.rb @@ -1,3 +1,4 @@ +# typed: ignore require "cc_engine/position/offset" module CCEngine diff --git a/spec/codeclimate_engine_spec.rb b/spec/codeclimate_engine_spec.rb index 15dfb29..c33eca1 100644 --- a/spec/codeclimate_engine_spec.rb +++ b/spec/codeclimate_engine_spec.rb @@ -1,3 +1,4 @@ +# typed: false require 'spec_helper' describe CCEngine do diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index e47c2d3..04d829b 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -1,2 +1,3 @@ +# typed: strict $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__) require 'codeclimate_engine'