sorbet/rbi/hidden-definitions/hidden.rbi in clean-architecture-3.0.0 vs sorbet/rbi/hidden-definitions/hidden.rbi in clean-architecture-3.0.1
- old
+ new
@@ -532,16 +532,10 @@
end
module ActiveModel::Type::Helpers
end
-class ActiveModel::Type::ImmutableString
-end
-
-class ActiveModel::Type::ImmutableString
-end
-
class ActiveModel::Type::Integer
include ::ActiveModel::Type::Helpers::Numeric
def initialize(*_); end
DEFAULT_LIMIT = ::T.let(nil, ::T.untyped)
end
@@ -567,16 +561,10 @@
end
class ActiveModel::Type::Registry
end
-class ActiveModel::Type::String
-end
-
-class ActiveModel::Type::String
-end
-
class ActiveModel::Type::Time
include ::ActiveModel::Type::Helpers::Timezone
include ::ActiveModel::Type::Helpers::TimeValue
end
@@ -588,24 +576,20 @@
def assert_valid_value(*_); end
def binary?(); end
- def cast(value); end
-
def changed?(old_value, new_value, _new_value_before_type_cast); end
def changed_in_place?(raw_old_value, new_value); end
def deserialize(value); end
def eql?(other); end
def force_equality?(_value); end
- def initialize(precision: T.unsafe(nil), limit: T.unsafe(nil), scale: T.unsafe(nil)); end
-
def limit(); end
def map(value); end
def precision(); end
@@ -619,13 +603,10 @@
def type_cast_for_schema(value); end
def value_constructed_by_mass_assignment?(_value); end
end
-class ActiveModel::Type::Value
-end
-
module ActiveModel::Type
def self.default_value(); end
def self.lookup(*args, **kwargs); end
@@ -679,28 +660,27 @@
end
class ActiveModel::Validations::AcceptanceValidator
end
-class ActiveModel::Validations::AcceptanceValidator::AttributeDefinition
+class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes
+ def ==(other); end
+
+ def attributes(); end
+
def define_on(klass); end
+ def included(klass); end
+
def initialize(attributes); end
def matches?(method_name); end
end
-class ActiveModel::Validations::AcceptanceValidator::AttributeDefinition
-end
-
class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes
- def initialize(attribute_definition); end
end
-class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes
-end
-
class ActiveModel::Validations::AcceptanceValidator
end
module ActiveModel::Validations::Callbacks
end
@@ -762,10 +742,32 @@
end
class ActiveModel::Validations::FormatValidator
end
+module ActiveModel::Validations::HelperMethods
+ def validates_absence_of(*attr_names); end
+
+ def validates_acceptance_of(*attr_names); end
+
+ def validates_confirmation_of(*attr_names); end
+
+ def validates_exclusion_of(*attr_names); end
+
+ def validates_format_of(*attr_names); end
+
+ def validates_inclusion_of(*attr_names); end
+
+ def validates_length_of(*attr_names); end
+
+ def validates_numericality_of(*attr_names); end
+
+ def validates_presence_of(*attr_names); end
+
+ def validates_size_of(*attr_names); end
+end
+
class ActiveModel::Validations::InclusionValidator
include ::ActiveModel::Validations::Clusivity
end
class ActiveModel::Validations::InclusionValidator
@@ -1592,58 +1594,40 @@
def self.hexdigest(arg); end
end
class ActiveSupport::Duration
- def %(other); end
-
- def *(other); end
-
- def +(other); end
-
- def -(other); end
-
def -@(); end
- def /(other); end
-
- def ==(other); end
-
def after(time=T.unsafe(nil)); end
def ago(time=T.unsafe(nil)); end
def before(time=T.unsafe(nil)); end
def coerce(other); end
def encode_with(coder); end
- def eql?(other); end
-
def from_now(time=T.unsafe(nil)); end
def init_with(coder); end
def initialize(value, parts); end
def instance_of?(klass); end
def is_a?(klass); end
- def iso8601(precision: T.unsafe(nil)); end
-
def kind_of?(klass); end
def parts(); end
def parts=(parts); end
def since(time=T.unsafe(nil)); end
- def to_i(); end
-
def until(time=T.unsafe(nil)); end
def value(); end
def value=(value); end
@@ -1733,22 +1717,18 @@
end
class ActiveSupport::Duration
def self.===(other); end
- def self.build(value); end
-
def self.days(value); end
def self.hours(value); end
def self.minutes(value); end
def self.months(value); end
- def self.parse(iso8601duration); end
-
def self.seconds(value); end
def self.weeks(value); end
def self.years(value); end
@@ -1940,11 +1920,11 @@
def merge(hash, &block); end
def merge!(other_hash); end
- def regular_update(_); end
+ def regular_update(*_); end
def regular_writer(_, _1); end
def reject(*args, &block); end
@@ -2113,16 +2093,12 @@
def self.generate(value); end
def self.verify(value); end
end
-class ActiveSupport::MessageEncryptor::OpenSSLCipherError
-end
+ActiveSupport::MessageEncryptor::OpenSSLCipherError = OpenSSL::Cipher::CipherError
-class ActiveSupport::MessageEncryptor::OpenSSLCipherError
-end
-
class ActiveSupport::MessageEncryptor
def self.default_cipher(); end
def self.key_len(cipher=T.unsafe(nil)); end
@@ -3173,10 +3149,14 @@
def self.use_standard_json_time_format(*args, &block); end
def self.use_standard_json_time_format=(arg); end
end
+class Addrinfo
+ def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end
+end
+
class Array
include ::JSON::Ext::Generator::GeneratorMethods::Array
def bsearch(); end
def bsearch_index(); end
@@ -3194,54 +3174,19 @@
def shelljoin(); end
def to_default_s(); end
def to_h(); end
+
end
class Array
def self.try_convert(_); end
def self.wrap(object); 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
include ::ActiveSupport::BigDecimalWithDefaultFormat
def clone(); end
@@ -3253,23 +3198,19 @@
SIGN_NaN = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
class BigDecimal
- def self.ver(); end
+ def self.new(*args, **kwargs); end
end
class Binding
def clone(); end
def irb(); end
end
-class Bundler::Definition
- def create_gem_version_promoter(); end
-end
-
Bundler::Deprecate = Gem::Deprecate
class Bundler::Env
end
@@ -3279,10 +3220,14 @@
def self.report(options=T.unsafe(nil)); end
def self.write(io); end
end
+class Bundler::FeatureFlag
+ def github_https?(); end
+end
+
class Bundler::Fetcher
def fetch_spec(spec); end
def fetchers(); end
@@ -3386,17 +3331,17 @@
end
class Bundler::Fetcher::Downloader
def connection(); end
- def fetch(uri, options=T.unsafe(nil), counter=T.unsafe(nil)); 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, options); end
+ def request(uri, headers); end
end
class Bundler::Fetcher::Downloader
end
@@ -3514,17 +3459,22 @@
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
@@ -3564,17 +3514,22 @@
class Bundler::Index
include ::Enumerable
end
class Bundler::Injector
- def initialize(new_deps, options=T.unsafe(nil)); end
+ 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
@@ -3670,10 +3625,17 @@
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
@@ -3719,14 +3681,10 @@
class Bundler::ProcessLock
def self.lock(bundle_path=T.unsafe(nil)); end
end
-class Bundler::Resolver::SpecGroup
- def platforms_for_dependency_named(dependency); end
-end
-
class Bundler::Retry
def attempt(&block); end
def attempts(&block); end
@@ -4000,14 +3958,10 @@
class Byebug::WidthSetting
DEFAULT = ::T.let(nil, ::T.untyped)
end
-module CCEngine
- VERSION = ::T.let(nil, ::T.untyped)
-end
-
module CGI::HtmlExtension
def a(href=T.unsafe(nil)); end
def base(href=T.unsafe(nil)); end
@@ -4095,10 +4049,110 @@
end
class CleanArchitecture::Adapters::ExampleAdapter
end
+class CleanArchitecture::Builders::ExampleBuilder
+end
+
+class CleanArchitecture::Builders::ExampleBuilder
+ def self.belongs_to_builders(); end
+
+ def self.has_many_builders(); end
+end
+
+class CleanArchitecture::Builders::ExampleEntity
+ def forename(); end
+
+ def main_interest(); end
+
+ def not_interested_in(); end
+
+ def other_interests(); end
+
+ def surname(); end
+
+ def years_on_planet_earth(); end
+end
+
+class CleanArchitecture::Builders::ExampleEntity
+ extend ::Dry::Core::DescendantsTracker
+end
+
+class CleanArchitecture::Builders::ExampleInterest
+ def label(); end
+end
+
+class CleanArchitecture::Builders::ExampleInterest
+ extend ::Dry::Core::DescendantsTracker
+end
+
+class CleanArchitecture::Builders::ExampleInterestBuilder
+end
+
+class CleanArchitecture::Builders::ExampleInterestBuilder
+ def self.belongs_to_builders(); end
+
+ def self.has_many_builders(); end
+end
+
+class CleanArchitecture::Builders::ExampleInterestModel
+ def attributes(); end
+
+ def initialize(label); end
+
+ def label(); end
+end
+
+class CleanArchitecture::Builders::ExampleInterestModel
+end
+
+class CleanArchitecture::Builders::ExampleModel
+ def age(); end
+
+ def attributes(); end
+
+ def main_interest(); end
+
+ def not_interested_in(); end
+
+ def other_interests(); end
+end
+
+class CleanArchitecture::Builders::ExampleModel
+end
+
+class CleanArchitecture::Builders::TStructExampleBuilder
+end
+
+class CleanArchitecture::Builders::TStructExampleBuilder
+ def self.belongs_to_builders(); end
+
+ def self.has_many_builders(); end
+end
+
+class CleanArchitecture::Builders::TStructExampleEntity
+ def forename(); end
+
+ def initialize(*args, &blk); end
+
+ def main_interest(); end
+
+ def not_interested_in(); end
+
+ def other_interests(); end
+
+ def surname(); end
+
+ def years_on_planet_earth(); end
+end
+
+class CleanArchitecture::Builders::TStructExampleEntity
+ extend ::T::Sig
+ def self.inherited(s); end
+end
+
class CleanArchitecture::Entities::FailureDetails
def message(); end
def other_properties(); end
@@ -4181,23 +4235,10 @@
end
class CleanArchitecture::UseCases::ExampleGateway
end
-class CleanArchitecture::UseCases::ExampleSharedContract
-end
-
-class CleanArchitecture::UseCases::ExampleSharedContract
-end
-
-class CleanArchitecture::UseCases::ExampleUseCase
- EMAILS_OF_TROLLS = ::T.let(nil, ::T.untyped)
-end
-
-class CleanArchitecture::UseCases::ExampleUseCase
-end
-
class CleanArchitecture::UseCases::Form
def model_name(*args, &block); end
end
class CleanArchitecture::UseCases::Form
@@ -4213,16 +4254,10 @@
class CleanArchitecture::UseCases::Parameters
def [](*args, &block); end
end
-class CleanArchitecture::UseCases::UnrelatedUseCase
-end
-
-class CleanArchitecture::UseCases::UnrelatedUseCase
-end
-
module CodeRay
CODERAY_PATH = ::T.let(nil, ::T.untyped)
TokenKinds = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
@@ -4456,59 +4491,19 @@
end
class CodeRay::TokensProxy
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
module Concurrent
- AtExit = ::T.let(nil, ::T.untyped)
NULL = ::T.let(nil, ::T.untyped)
NULL_LOGGER = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
@@ -4565,20 +4560,12 @@
DEFAULT_MAX_QUEUE_SIZE = ::T.let(nil, ::T.untyped)
DEFAULT_MIN_POOL_SIZE = ::T.let(nil, ::T.untyped)
DEFAULT_THREAD_IDLETIMEOUT = ::T.let(nil, ::T.untyped)
end
-class Concurrent::SerializedExecutionDelegator
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-
Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
-class Concurrent::SynchronizedDelegator
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-
module Concurrent::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
@@ -4595,23 +4582,15 @@
module Concurrent::Utility::NativeInteger
MAX_VALUE = ::T.let(nil, ::T.untyped)
MIN_VALUE = ::T.let(nil, ::T.untyped)
end
-module Coverage
- def self.peek_result(); end
-
- def self.running?(); end
-end
-
class Date
include ::DateAndTime::Zones
include ::DateAndTime::Calculations
def acts_like_date?(); end
- def advance(options); end
-
def ago(seconds); end
def at_beginning_of_day(); end
def at_end_of_day(); end
@@ -4659,10 +4638,11 @@
def since(seconds); end
def to_default_s(); end
def to_formatted_s(format=T.unsafe(nil)); end
+
DATE_FORMATS = ::T.let(nil, ::T.untyped)
end
class Date::Infinity
def initialize(d=T.unsafe(nil)); end
@@ -4885,11 +4865,10 @@
def methods(all=T.unsafe(nil)); end
def protected_methods(all=T.unsafe(nil)); end
def public_methods(all=T.unsafe(nil)); end
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end
class Delegator
def self.const_missing(n); end
@@ -4897,10 +4876,16 @@
def self.public_api(); end
end
class Dir
+ def children(); end
+
+ def each_child(); end
+end
+
+class Dir
def self.children(*_); end
def self.each_child(*_); end
def self.empty?(_); end
@@ -4926,32 +4911,33 @@
EMPTY_OPTS = ::T.let(nil, ::T.untyped)
EMPTY_SET = ::T.let(nil, ::T.untyped)
EMPTY_STRING = ::T.let(nil, ::T.untyped)
Self = ::T.let(nil, ::T.untyped)
Undefined = ::T.let(nil, ::T.untyped)
- VERSION = ::T.let(nil, ::T.untyped)
end
-class Dry::Configurable::Settings
- Parser = ::T.let(nil, ::T.untyped)
+class Dry::Configurable::DSL
+ VALID_NAME = ::T.let(nil, ::T.untyped)
end
-class Dry::Configurable::Settings::ArgumentParser
- DEFAULT_PROCESSOR = ::T.let(nil, ::T.untyped)
+class Dry::Configurable::Setting
+ CLONABLE_VALUE_TYPES = ::T.let(nil, ::T.untyped)
+ DEFAULT_CONSTRUCTOR = ::T.let(nil, ::T.untyped)
+ OPTIONS = ::T.let(nil, ::T.untyped)
end
+class Dry::Configurable::Setting::Nested
+ CONSTRUCTOR = ::T.let(nil, ::T.untyped)
+end
+
class Dry::Container
include ::Dry::Container::Mixin::Initializer
EMPTY_HASH = ::T.let(nil, ::T.untyped)
PREFIX_NAMESPACE = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
-class Dry::Container::NamespaceDSL
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-
module Dry::Core::ClassAttributes
EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
EMPTY_HASH = ::T.let(nil, ::T.untyped)
EMPTY_OPTS = ::T.let(nil, ::T.untyped)
EMPTY_SET = ::T.let(nil, ::T.untyped)
@@ -5039,25 +5025,36 @@
EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
EMPTY_HASH = ::T.let(nil, ::T.untyped)
EMPTY_OPTS = ::T.let(nil, ::T.untyped)
EMPTY_SET = ::T.let(nil, ::T.untyped)
EMPTY_STRING = ::T.let(nil, ::T.untyped)
+ RUBY2_KEYWORDS = ::T.let(nil, ::T.untyped)
ResultMatcher = ::T.let(nil, ::T.untyped)
Self = ::T.let(nil, ::T.untyped)
Undefined = ::T.let(nil, ::T.untyped)
end
class Dry::Matcher::Case
DEFAULT_RESOLVE = ::T.let(nil, ::T.untyped)
end
module Dry::Monads
+ EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
+ EMPTY_HASH = ::T.let(nil, ::T.untyped)
+ EMPTY_OPTS = ::T.let(nil, ::T.untyped)
+ EMPTY_SET = ::T.let(nil, ::T.untyped)
+ EMPTY_STRING = ::T.let(nil, ::T.untyped)
+ Self = ::T.let(nil, ::T.untyped)
Traverse = ::T.let(nil, ::T.untyped)
Undefined = ::T.let(nil, ::T.untyped)
Unit = ::T.let(nil, ::T.untyped)
end
+module Dry::Monads::Do
+ DELEGATE = ::T.let(nil, ::T.untyped)
+end
+
Dry::Monads::Failure = Dry::Monads::Result::Failure
Dry::Monads::Invalid = Dry::Monads::Validated::Invalid
module Dry::Monads::Lazy::Mixin
@@ -5081,32 +5078,12 @@
Dry::Monads::Maybe::Mixin::None = Dry::Monads::Maybe::None
Dry::Monads::Maybe::Mixin::Some = Dry::Monads::Maybe::Some
-class Dry::Monads::Maybe::None
- EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
- EMPTY_HASH = ::T.let(nil, ::T.untyped)
- EMPTY_OPTS = ::T.let(nil, ::T.untyped)
- EMPTY_SET = ::T.let(nil, ::T.untyped)
- EMPTY_STRING = ::T.let(nil, ::T.untyped)
- Self = ::T.let(nil, ::T.untyped)
- Undefined = ::T.let(nil, ::T.untyped)
-end
-
Dry::Monads::None = Dry::Monads::Maybe::None
-module Dry::Monads::RightBiased::Right
- EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
- EMPTY_HASH = ::T.let(nil, ::T.untyped)
- EMPTY_OPTS = ::T.let(nil, ::T.untyped)
- EMPTY_SET = ::T.let(nil, ::T.untyped)
- EMPTY_STRING = ::T.let(nil, ::T.untyped)
- Self = ::T.let(nil, ::T.untyped)
- Undefined = ::T.let(nil, ::T.untyped)
-end
-
Dry::Monads::Some = Dry::Monads::Maybe::Some
Dry::Monads::Success = Dry::Monads::Result::Success
module Dry::Monads::Task::Mixin
@@ -5332,12 +5309,10 @@
def self.json_escape(s); end
def self.unwrapped_html_escape(s); end
end
-Emitter = Psych::Stream::Emitter
-
class Encoding
def _dump(*_); end
end
class Encoding::Converter
@@ -5410,10 +5385,12 @@
module Enumerable
include ::ActiveSupport::ToJsonWithActiveSupportEncoder
def as_json(options=T.unsafe(nil)); end
+ def chain(*_); end
+
def chunk(); end
def chunk_while(); end
def each_entry(*_); end
@@ -5429,18 +5406,41 @@
def sum(*_); end
def to_set(klass=T.unsafe(nil), *args, &block); end
def uniq(); end
-
- def zip(*_); end
end
class Enumerator
+ def +(_); end
+
def each_with_index(); end
end
+class Enumerator::ArithmeticSequence
+ def begin(); end
+
+ def each(&blk); end
+
+ def end(); end
+
+ def exclude_end?(); end
+
+ def last(*_); end
+
+ def step(); end
+end
+
+class Enumerator::ArithmeticSequence
+end
+
+class Enumerator::Chain
+end
+
+class Enumerator::Chain
+end
+
class Enumerator::Generator
def each(*_, &blk); end
def initialize(*_); end
end
@@ -5460,10 +5460,31 @@
end
class Errno::EAUTH
end
+class Errno::EBADARCH
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADARCH
+end
+
+class Errno::EBADEXEC
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADEXEC
+end
+
+class Errno::EBADMACHO
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADMACHO
+end
+
class Errno::EBADRPC
Errno = ::T.let(nil, ::T.untyped)
end
class Errno::EBADRPC
@@ -5471,10 +5492,17 @@
Errno::ECAPMODE = Errno::NOERROR
Errno::EDEADLOCK = Errno::NOERROR
+class Errno::EDEVERR
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EDEVERR
+end
+
Errno::EDOOFUS = Errno::NOERROR
class Errno::EFTYPE
Errno = ::T.let(nil, ::T.untyped)
end
@@ -5482,10 +5510,17 @@
class Errno::EFTYPE
end
Errno::EIPSEC = Errno::NOERROR
+class Errno::ELAST
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ELAST
+end
+
class Errno::ENEEDAUTH
Errno = ::T.let(nil, ::T.untyped)
end
class Errno::ENEEDAUTH
@@ -5496,10 +5531,17 @@
end
class Errno::ENOATTR
end
+class Errno::ENOPOLICY
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ENOPOLICY
+end
+
Errno::ENOTCAPABLE = Errno::NOERROR
class Errno::ENOTSUP
Errno = ::T.let(nil, ::T.untyped)
end
@@ -5533,17 +5575,33 @@
end
class Errno::EPROGUNAVAIL
end
+class Errno::EPWROFF
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EPWROFF
+end
+
+Errno::EQFULL = Errno::ELAST
+
class Errno::ERPCMISMATCH
Errno = ::T.let(nil, ::T.untyped)
end
class Errno::ERPCMISMATCH
end
+class Errno::ESHLIBVERS
+ Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ESHLIBVERS
+end
+
class Etc::Group
def gid(); end
def gid=(_); end
@@ -5572,44 +5630,32 @@
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
@@ -5631,10 +5677,11 @@
def self.to_tty?(); end
end
module Exception2MessageMapper
def bind(cl); end
+
end
Exception2MessageMapper::E2MM = Exception2MessageMapper
class Exception2MessageMapper::ErrNotRegisteredException
@@ -5776,10 +5823,11 @@
def def_instance_delegators(accessor, *methods); end
def delegate(hash); end
def instance_delegate(hash); end
+ VERSION = ::T.let(nil, ::T.untyped)
end
module Forwardable
def self._compile_method(src, file, line); end
@@ -5790,104 +5838,32 @@
def self.debug(); end
def self.debug=(debug); end
end
-class FrozenError
-end
-
-class FrozenError
-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
-module Gem::BundlerVersionFinder
- def self.without_filtering(); end
+ def self.verify_transient_heap_internal_consistency(); end
end
-class Gem::DependencyInstaller
- def _deprecated_gems_to_install(); end
-
- def gems_to_install(*args, &block); end
-end
-
-class Gem::Resolver
-end
-
-Gem::DependencyResolver::Conflict = Gem::Resolver::Conflict
-
-Gem::DependencyResolver::DependencyConflict = Gem::Resolver::Conflict
-
-module Gem::Resolver::Molinillo
-end
-
-Gem::DependencyResolver::Molinillo::SpecificationProvider = Gem::Resolver::Molinillo::SpecificationProvider
-
-Gem::DependencyResolver::Molinillo::UI = Gem::Resolver::Molinillo::UI
-
-module Gem::Resolver::Molinillo
-end
-
-class Gem::Resolver
-end
-
-class Gem::Installer
- def verify_spec_name(); end
-end
-
-class Gem::Licenses
- IDENTIFIERS = ::T.let(nil, ::T.untyped)
-end
-
-class Gem::Package
- def realpath(file); end
-end
-
-class Gem::RemoteFetcher
- def api_endpoint(uri); end
-end
-
-Gem::RequestSet::GemDepedencyAPI = Gem::RequestSet::GemDependencyAPI
-
class Gem::Resolver::Molinillo::DependencyGraph::Log
extend ::Enumerable
end
-class Gem::Source
- def api_uri(); end
-end
-
class Gem::Specification
- def bundled_gem_in_old_ruby?(); end
-
- def rubyforge_project(); end
-
- def warning(statement); end
-end
-
-class Gem::Specification
extend ::Enumerable
end
-module Gem::Util
- NULL_DEVICE = ::T.let(nil, ::T.untyped)
-end
-
-module Gem
- def self._deprecated_datadir(gem_name); end
-end
-
class Hash
include ::JSON::Ext::Generator::GeneratorMethods::Hash
def <(_); end
def <=(_); end
@@ -5904,20 +5880,16 @@
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 nested_under_indifferent_access(); end
def replace(_); end
def reverse_merge(other_hash); end
@@ -5944,11 +5916,11 @@
def transform_values(); end
def transform_values!(); end
- def update(_); end
+ def update(*_); end
def with_defaults(other_hash); end
def with_defaults!(other_hash); end
@@ -6609,12 +6581,10 @@
class IO
def self.console(*_); end
def self.foreach(*_); end
-
- def self.pipe(*_); end
end
class IPAddr
include ::Comparable
def &(other); end
@@ -6724,10 +6694,11 @@
module IRB
IRBRC_EXT = ::T.let(nil, ::T.untyped)
MagicFile = ::T.let(nil, ::T.untyped)
STDIN_FILE_NAME = ::T.let(nil, ::T.untyped)
+ VERSION = ::T.let(nil, ::T.untyped)
end
class IRB::Abort
end
@@ -6765,11 +6736,11 @@
def echo?(); end
def eval_history=(*opts, &b); end
- def evaluate(line, line_no); end
+ def evaluate(line, line_no, exception: T.unsafe(nil)); end
def exit(ret=T.unsafe(nil)); end
def file_input?(); end
@@ -7008,10 +6979,12 @@
class IRB::Irb
def context(); end
def eval_input(); end
+ def handle_exception(exc); end
+
def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end
def output_value(); end
def prompt(prompt, ltype, indent, line_no); end
@@ -7305,10 +7278,14 @@
def filter_backtrace(bt); end
def initialize(*main); end
+ def local_variable_get(name); end
+
+ def local_variable_set(name, value); end
+
def main(); end
end
class IRB::WorkSpace
end
@@ -7349,16 +7326,10 @@
def self.start(ap_path=T.unsafe(nil)); end
def self.version(); 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 allbits?(_); end
def anybits?(_); end
@@ -7391,12 +7362,10 @@
JSON::State = JSON::Ext::Generator::State
JSON::UnparserError = JSON::GeneratorError
-JSONTree = Psych::Visitors::JSONTree
-
module JaroWinkler
VERSION = ::T.let(nil, ::T.untyped)
end
class JaroWinkler::Error
@@ -7420,10 +7389,12 @@
def pretty_inspect(); end
def respond_to?(*_); end
+ def then(); end
+
def yield_self(); end
end
module Kernel
def self.at_exit(); end
@@ -7437,45 +7408,10 @@
def key(); end
def receiver(); end
end
-module Kwalify
- META_VALIDATOR = ::T.let(nil, ::T.untyped)
- RELEASE = ::T.let(nil, ::T.untyped)
-end
-
-class Kwalify::BaseParser
- CHAR_TABLE = ::T.let(nil, ::T.untyped)
-end
-
-class Kwalify::MetaValidator
- META_SCHEMA = ::T.let(nil, ::T.untyped)
-end
-
-module Kwalify::Types
- DEFAULT_TYPE = ::T.let(nil, ::T.untyped)
-end
-
-module Kwalify::Util::HashLike
- def [](key); end
-
- def []=(key, val); end
-
- def each(&blk); end
-
- def key?(key); end
-end
-
-module Kwalify::Util::HashLike
-end
-
-class Kwalify::Yaml::Parser
- MAPKEY_PATTERN = ::T.let(nil, ::T.untyped)
- PRECEDING_ALIAS_PLACEHOLDER = ::T.let(nil, ::T.untyped)
-end
-
class LoadError
def is_missing?(location); end
def path(); end
end
@@ -7500,19 +7436,25 @@
module Logger::Period
SiD = ::T.let(nil, ::T.untyped)
end
+module Marshal
+ def self.restore(*_); end
+end
+
module MethodSource
VERSION = ::T.let(nil, ::T.untyped)
end
module MethodSource::CodeHelpers::IncompleteExpression
GENERIC_REGEXPS = ::T.let(nil, ::T.untyped)
RBX_ONLY_REGEXPS = ::T.let(nil, ::T.untyped)
end
+Methods = T::Private::Methods
+
module Minitest::Assertions
def _synchronize(); end
def assert_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
@@ -7526,10 +7468,12 @@
def assert_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
def assert_output(stdout=T.unsafe(nil), stderr=T.unsafe(nil)); end
+ def assert_path_exists(path, msg=T.unsafe(nil)); end
+
def assert_predicate(o1, op, msg=T.unsafe(nil)); end
def assert_respond_to(obj, meth, msg=T.unsafe(nil)); end
def assert_same(exp, act, msg=T.unsafe(nil)); end
@@ -7546,10 +7490,12 @@
def diff(exp, act); end
def exception_details(e, msg); end
+ def fail_after(y, m, d, msg); end
+
def flunk(msg=T.unsafe(nil)); end
def message(msg=T.unsafe(nil), ending=T.unsafe(nil), &default); end
def mu_pp(obj); end
@@ -7568,19 +7514,25 @@
def refute_match(matcher, obj, msg=T.unsafe(nil)); end
def refute_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
+ def refute_path_exists(path, msg=T.unsafe(nil)); end
+
def refute_predicate(o1, op, msg=T.unsafe(nil)); end
def refute_respond_to(obj, meth, msg=T.unsafe(nil)); end
def refute_same(exp, act, msg=T.unsafe(nil)); end
def skip(msg=T.unsafe(nil), bt=T.unsafe(nil)); end
+ def skip_until(y, m, d, msg); end
+
def skipped?(); end
+
+ def things_to_diff(exp, act); end
E = ::T.let(nil, ::T.untyped)
UNDEFINED = ::T.let(nil, ::T.untyped)
end
module Minitest::Assertions
@@ -7594,10 +7546,12 @@
def maglev?(platform=T.unsafe(nil)); end
def mri?(platform=T.unsafe(nil)); end
+ def osx?(platform=T.unsafe(nil)); end
+
def rubinius?(platform=T.unsafe(nil)); end
def windows?(platform=T.unsafe(nil)); end
end
@@ -7773,10 +7727,12 @@
def new_cond(); end
def synchronize(); end
def try_mon_enter(); end
+ EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
+ EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
end
class MonitorMixin::ConditionVariable
def broadcast(); end
@@ -7793,20 +7749,30 @@
module MonitorMixin
def self.extend_object(obj); end
end
+module Mutex_m
+ VERSION = ::T.let(nil, ::T.untyped)
+end
+
class NameError
def missing_name(); end
def missing_name?(name); end
def name(); end
def receiver(); end
end
+class Net::BufferedIO
+ def write_timeout(); end
+
+ def write_timeout=(write_timeout); end
+end
+
class Net::HTTP
def max_retries(); end
def max_retries=(retries); end
@@ -7815,15 +7781,17 @@
def max_version=(max_version); end
def min_version(); end
def min_version=(min_version); end
+
+ def write_timeout(); end
+
+ def write_timeout=(sec); end
ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped)
end
-Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta
-
class Net::HTTPAlreadyReported
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPAlreadyReported
@@ -7831,12 +7799,30 @@
Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPServerException
Net::HTTPClientErrorCode = Net::HTTPClientError
+Net::HTTPClientException = Net::HTTPServerException
+
+class Net::HTTPEarlyHints
+ HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPEarlyHints
+end
+
Net::HTTPFatalErrorCode = Net::HTTPClientError
+class Net::HTTPGatewayTimeout
+ HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPGatewayTimeout
+end
+
+Net::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError
+
Net::HTTPInformationCode = Net::HTTPInformation
class Net::HTTPLoopDetected
HAS_BODY = ::T.let(nil, ::T.untyped)
end
@@ -7860,37 +7846,73 @@
end
class Net::HTTPNotExtended
end
+class Net::HTTPPayloadTooLarge
+ HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPPayloadTooLarge
+end
+
class Net::HTTPProcessing
HAS_BODY = ::T.let(nil, ::T.untyped)
end
class Net::HTTPProcessing
end
+class Net::HTTPRangeNotSatisfiable
+ HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPRangeNotSatisfiable
+end
+
Net::HTTPRedirection::EXCEPTION_TYPE = Net::HTTPRetriableError
Net::HTTPRedirectionCode = Net::HTTPRedirection
-Net::HTTPRequestURITooLarge = Net::HTTPRequestURITooLong
+class Net::HTTPRequestTimeout
+ HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+class Net::HTTPRequestTimeout
+end
+
+Net::HTTPRequestURITooLarge = Net::HTTPURITooLong
+
Net::HTTPResponceReceiver = Net::HTTPResponse
Net::HTTPRetriableCode = Net::HTTPRedirection
Net::HTTPServerError::EXCEPTION_TYPE = Net::HTTPFatalError
Net::HTTPServerErrorCode = Net::HTTPServerError
-Net::HTTPSession = Net::HTTP
+class Net::HTTP
+end
+Net::HTTPSession::ProxyDelta = Net::HTTP::ProxyDelta
+
+Net::HTTPSession::ProxyMod = Net::HTTP::ProxyDelta
+
+class Net::HTTP
+end
+
Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
Net::HTTPSuccessCode = Net::HTTPSuccess
+class Net::HTTPURITooLong
+ HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPURITooLong
+end
+
Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError
class Net::HTTPVariantAlsoNegotiates
HAS_BODY = ::T.let(nil, ::T.untyped)
end
@@ -7902,94 +7924,49 @@
Net::NetPrivate::Socket = Net::InternetMessageIO
Net::ProtocRetryError = Net::ProtoRetriableError
+class Net::ReadTimeout
+ def initialize(io=T.unsafe(nil)); end
+
+ def io(); end
+end
+
+class Net::WriteTimeout
+ def initialize(io=T.unsafe(nil)); end
+
+ def io(); end
+end
+
+class Net::WriteTimeout
+end
+
class NilClass
include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+ def to_d(); end
+
def to_i(); end
end
class NoMethodError
def args(); end
def private_call?(); end
end
-class Numeric
- def byte(); end
-
- def bytes(); end
-
- def day(); end
-
- def days(); end
-
- def exabyte(); end
-
- def exabytes(); end
-
- def fortnight(); end
-
- def fortnights(); end
-
- def gigabyte(); end
-
- def gigabytes(); end
-
- def hour(); end
-
- def hours(); end
-
- def in_milliseconds(); end
-
- def kilobyte(); end
-
- def kilobytes(); end
-
- def megabyte(); end
-
- def megabytes(); end
-
- def minute(); end
-
- def minutes(); end
-
- def petabyte(); end
-
- def petabytes(); end
-
- def second(); end
-
- def seconds(); end
-
- def terabyte(); end
-
- def terabytes(); end
-
- def week(); end
-
- def weeks(); end
- EXABYTE = ::T.let(nil, ::T.untyped)
- GIGABYTE = ::T.let(nil, ::T.untyped)
- KILOBYTE = ::T.let(nil, ::T.untyped)
- MEGABYTE = ::T.let(nil, ::T.untyped)
- PETABYTE = ::T.let(nil, ::T.untyped)
- TERABYTE = ::T.let(nil, ::T.untyped)
-end
-
class Object
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
include ::ActiveSupport::Tryable
include ::ActiveSupport::Dependencies::Loadable
include ::ActiveSupport::ToJsonWithActiveSupportEncoder
def as_json(options=T.unsafe(nil)); end
- def dclone(); end
-
def html_safe?(); end
+
+ def to_yaml(options=T.unsafe(nil)); end
ARGF = ::T.let(nil, ::T.untyped)
ARGV = ::T.let(nil, ::T.untyped)
CROSS_COMPILING = ::T.let(nil, ::T.untyped)
ENV = ::T.let(nil, ::T.untyped)
RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
@@ -8005,10 +7982,14 @@
STDIN = ::T.let(nil, ::T.untyped)
STDOUT = ::T.let(nil, ::T.untyped)
TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
end
+class Object
+ def self.yaml_tag(url); end
+end
+
class ObjectSpace::WeakMap
def [](_); end
def []=(_, _1); end
@@ -8039,10 +8020,145 @@
def self.garbage_collect(*_); end
def self.undefine_finalizer(_); end
end
+class OpenSSL::ASN1::ASN1Data
+ def indefinite_length(); end
+
+ def indefinite_length=(indefinite_length); end
+end
+
+class OpenSSL::BN
+ def +@(); end
+
+ def -@(); end
+
+ def /(_); end
+
+ def negative?(); end
+end
+
+module OpenSSL::Buffering
+ include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+end
+
+module OpenSSL::KDF
+end
+
+class OpenSSL::KDF::KDFError
+end
+
+class OpenSSL::KDF::KDFError
+end
+
+module OpenSSL::KDF
+ def self.hkdf(*_); end
+
+ def self.pbkdf2_hmac(*_); end
+
+ def self.scrypt(*_); end
+end
+
+class OpenSSL::OCSP::Request
+ def signed?(); end
+end
+
+OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo
+
+class OpenSSL::PKey::EC
+ EXPLICIT_CURVE = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::PKey::EC::Point
+ def to_octet_string(_); end
+end
+
+class OpenSSL::PKey::RSA
+ def sign_pss(*_); end
+
+ def verify_pss(*_); end
+end
+
+module OpenSSL::SSL
+ OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped)
+ OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+ OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped)
+ OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped)
+ OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped)
+ OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+ OP_NO_TLSv1_3 = ::T.let(nil, ::T.untyped)
+ OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped)
+ OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped)
+ SSL2_VERSION = ::T.let(nil, ::T.untyped)
+ SSL3_VERSION = ::T.let(nil, ::T.untyped)
+ TLS1_1_VERSION = ::T.let(nil, ::T.untyped)
+ TLS1_2_VERSION = ::T.let(nil, ::T.untyped)
+ TLS1_3_VERSION = ::T.let(nil, ::T.untyped)
+ TLS1_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::SSL::SSLContext
+ def add_certificate(*_); end
+
+ def alpn_protocols(); end
+
+ def alpn_protocols=(alpn_protocols); end
+
+ def alpn_select_cb(); end
+
+ def alpn_select_cb=(alpn_select_cb); end
+
+ def enable_fallback_scsv(); end
+
+ def max_version=(version); end
+
+ def min_version=(version); end
+ DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::SSL::SSLSocket
+ def alpn_protocol(); end
+
+ def tmp_key(); end
+end
+
+module OpenSSL::X509
+ V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
+ V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::X509::Attribute
+ def ==(other); end
+end
+
+class OpenSSL::X509::CRL
+ def ==(other); end
+end
+
+class OpenSSL::X509::Extension
+ def ==(other); end
+end
+
+class OpenSSL::X509::Name
+ def to_utf8(); end
+end
+
+class OpenSSL::X509::Request
+ def ==(other); end
+end
+
+class OpenSSL::X509::Revoked
+ def ==(other); end
+
+ def to_der(); end
+end
+
+module OpenSSL
+ def self.fips_mode(); end
+end
+
module Parallel
Stop = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
Version = ::T.let(nil, ::T.untyped)
end
@@ -8065,16 +8181,19 @@
class Parser::Lexer
ESCAPES = ::T.let(nil, ::T.untyped)
KEYWORDS = ::T.let(nil, ::T.untyped)
KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped)
LEX_STATES = ::T.let(nil, ::T.untyped)
- NUMPARAM_MAX = ::T.let(nil, ::T.untyped)
PUNCTUATION = ::T.let(nil, ::T.untyped)
PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped)
REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped)
end
+class Parser::Lexer::Dedenter
+ TAB_WIDTH = ::T.let(nil, ::T.untyped)
+end
+
class Parser::Lexer::Literal
DELIMITERS = ::T.let(nil, ::T.untyped)
TYPES = ::T.let(nil, ::T.untyped)
end
@@ -8084,16 +8203,10 @@
class Parser::Rewriter
DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
end
-class Parser::Ruby26
- Racc_arg = ::T.let(nil, ::T.untyped)
- Racc_debug_parser = ::T.let(nil, ::T.untyped)
- Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
-end
-
class Parser::Source::Buffer
ENCODING_RE = ::T.let(nil, ::T.untyped)
end
class Parser::Source::Comment::Associator
@@ -8108,10 +8221,14 @@
ACTIONS = ::T.let(nil, ::T.untyped)
DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped)
end
+class Parser::StaticEnvironment
+ FORWARD_ARGS = ::T.let(nil, ::T.untyped)
+end
+
class Pathname
def empty?(); end
def fnmatch?(*_); end
@@ -8119,12 +8236,16 @@
def make_symlink(_); end
end
class Proc
+ def <<(_); end
+
def ===(*_); end
+ def >>(_); end
+
def clone(); end
def yield(*_); end
end
@@ -8240,18 +8361,10 @@
Pry::BasicObject::Kernel = Kernel
Pry::BasicObject::Pry = Pry
-class Pry::Byebug::Breakpoints::FileBreakpoint
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Byebug::Breakpoints::MethodBreakpoint
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-
class Pry::Code
extend ::MethodSource::CodeHelpers
end
class Pry::CodeFile
@@ -8350,11 +8463,46 @@
module Psych
LIBYAML_VERSION = ::T.let(nil, ::T.untyped)
VERSION = ::T.let(nil, ::T.untyped)
end
+class Psych::BadAlias
+end
+
+class Psych::BadAlias
+end
+
class Psych::ClassLoader
+ def big_decimal(); end
+
+ def complex(); end
+
+ def date(); end
+
+ def date_time(); end
+
+ def exception(); end
+
+ def load(klassname); end
+
+ def object(); end
+
+ def psych_omap(); end
+
+ def psych_set(); end
+
+ def range(); end
+
+ def rational(); end
+
+ def regexp(); end
+
+ def struct(); end
+
+ def symbol(); end
+
+ def symbolize(sym); end
BIG_DECIMAL = ::T.let(nil, ::T.untyped)
CACHE = ::T.let(nil, ::T.untyped)
COMPLEX = ::T.let(nil, ::T.untyped)
DATE = ::T.let(nil, ::T.untyped)
DATE_TIME = ::T.let(nil, ::T.untyped)
@@ -8367,867 +8515,904 @@
REGEXP = ::T.let(nil, ::T.untyped)
STRUCT = ::T.let(nil, ::T.untyped)
SYMBOL = ::T.let(nil, ::T.untyped)
end
-class Psych::Handler
- EVENTS = ::T.let(nil, ::T.untyped)
- OPTIONS = ::T.let(nil, ::T.untyped)
+class Psych::ClassLoader::Restricted
+ def initialize(classes, symbols); end
end
-class Psych::Nodes::Mapping
- ANY = ::T.let(nil, ::T.untyped)
- BLOCK = ::T.let(nil, ::T.untyped)
- FLOW = ::T.let(nil, ::T.untyped)
+class Psych::ClassLoader::Restricted
end
-class Psych::Nodes::Scalar
- ANY = ::T.let(nil, ::T.untyped)
- DOUBLE_QUOTED = ::T.let(nil, ::T.untyped)
- FOLDED = ::T.let(nil, ::T.untyped)
- LITERAL = ::T.let(nil, ::T.untyped)
- PLAIN = ::T.let(nil, ::T.untyped)
- SINGLE_QUOTED = ::T.let(nil, ::T.untyped)
+class Psych::ClassLoader
end
-class Psych::Nodes::Sequence
- ANY = ::T.let(nil, ::T.untyped)
- BLOCK = ::T.let(nil, ::T.untyped)
- FLOW = ::T.let(nil, ::T.untyped)
-end
+class Psych::Coder
+ def [](k); end
-class Psych::Nodes::Stream
- ANY = ::T.let(nil, ::T.untyped)
- UTF16BE = ::T.let(nil, ::T.untyped)
- UTF16LE = ::T.let(nil, ::T.untyped)
- UTF8 = ::T.let(nil, ::T.untyped)
-end
+ def []=(k, v); end
-class Psych::Parser
- ANY = ::T.let(nil, ::T.untyped)
- UTF16BE = ::T.let(nil, ::T.untyped)
- UTF16LE = ::T.let(nil, ::T.untyped)
- UTF8 = ::T.let(nil, ::T.untyped)
-end
+ def add(k, v); end
-class Psych::ScalarScanner
- FLOAT = ::T.let(nil, ::T.untyped)
- INTEGER = ::T.let(nil, ::T.untyped)
- TIME = ::T.let(nil, ::T.untyped)
-end
+ def implicit(); end
-class Psych::Visitors::ToRuby
- SHOVEL = ::T.let(nil, ::T.untyped)
-end
+ def implicit=(implicit); end
-class Psych::Visitors::Visitor
- DISPATCH = ::T.let(nil, ::T.untyped)
-end
+ def initialize(tag); end
-module REXML
- COPYRIGHT = ::T.let(nil, ::T.untyped)
- Copyright = ::T.let(nil, ::T.untyped)
- DATE = ::T.let(nil, ::T.untyped)
- REVISION = ::T.let(nil, ::T.untyped)
- VERSION = ::T.let(nil, ::T.untyped)
- Version = ::T.let(nil, ::T.untyped)
-end
+ def map(tag=T.unsafe(nil), style=T.unsafe(nil)); end
-class REXML::AttlistDecl
- include ::Enumerable
- def [](key); end
+ def map=(map); end
- def each(&block); end
+ def object(); end
- def element_name(); end
+ def object=(object); end
- def include?(key); end
+ def represent_map(tag, map); end
- def initialize(source); end
+ def represent_object(tag, obj); end
- def node_type(); end
+ def represent_scalar(tag, value); end
- def write(out, indent=T.unsafe(nil)); end
-end
+ def represent_seq(tag, list); end
-class REXML::AttlistDecl
-end
+ def scalar(*args); end
-class REXML::Attribute
- include ::REXML::Node
- include ::REXML::Namespace
- include ::REXML::XMLTokens
- def ==(other); end
+ def scalar=(value); end
- def clone(); end
+ def seq(); end
- def doctype(); end
+ def seq=(list); end
- def element(); end
+ def style(); end
- def element=(element); end
+ def style=(style); end
- def initialize(first, second=T.unsafe(nil), parent=T.unsafe(nil)); end
+ def tag(); end
- def namespace(arg=T.unsafe(nil)); end
+ def tag=(tag); end
- def node_type(); end
+ def type(); end
+end
- def normalized=(normalized); end
+class Psych::Coder
+end
- def remove(); end
-
- def to_s(); end
-
- def to_string(); end
-
- def value(); end
-
- def write(output, indent=T.unsafe(nil)); end
-
- def xpath(); end
- NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
- PATTERN = ::T.let(nil, ::T.untyped)
+class Psych::DisallowedClass
+ def initialize(klass_name); end
end
-class REXML::Attribute
+class Psych::DisallowedClass
end
-class REXML::Attributes
- def <<(attribute); end
+class Psych::Emitter
+ def alias(_); end
- def [](name); end
+ def canonical(); end
- def []=(name, value); end
+ def canonical=(canonical); end
- def add(attribute); end
+ def end_document(_); end
- def delete(attribute); end
+ def indentation(); end
- def delete_all(name); end
+ def indentation=(indentation); end
- def each_attribute(); end
+ def initialize(*_); end
- def get_attribute(name); end
+ def line_width(); end
- def get_attribute_ns(namespace, name); end
+ def line_width=(line_width); end
- def initialize(element); end
+ def scalar(_, _1, _2, _3, _4, _5); end
- def namespaces(); end
+ def start_document(_, _1, _2); end
- def prefixes(); end
+ def start_mapping(_, _1, _2, _3); end
+
+ def start_sequence(_, _1, _2, _3); end
+
+ def start_stream(_); end
end
-class REXML::Attributes
+class Psych::Emitter
end
-class REXML::CData
- def initialize(first, whitespace=T.unsafe(nil), parent=T.unsafe(nil)); end
-
- def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
- ILLEGAL = ::T.let(nil, ::T.untyped)
- START = ::T.let(nil, ::T.untyped)
- STOP = ::T.let(nil, ::T.untyped)
+class Psych::Exception
end
-class REXML::CData
+class Psych::Exception
end
-class REXML::Child
- include ::REXML::Node
- def bytes(); end
+class Psych::Handler
+ def alias(anchor); end
- def document(); end
+ def empty(); end
- def initialize(parent=T.unsafe(nil)); end
+ def end_document(implicit); end
- def next_sibling(); end
+ def end_mapping(); end
- def next_sibling=(other); end
+ def end_sequence(); end
- def parent(); end
+ def end_stream(); end
- def parent=(other); end
+ def event_location(start_line, start_column, end_line, end_column); end
- def previous_sibling(); end
+ def scalar(value, anchor, tag, plain, quoted, style); end
- def previous_sibling=(other); end
+ def start_document(version, tag_directives, implicit); end
- def remove(); end
+ def start_mapping(anchor, tag, implicit, style); end
- def replace_with(child); end
-end
+ def start_sequence(anchor, tag, implicit, style); end
-class REXML::Child
+ def start_stream(encoding); end
+
+ def streaming?(); end
+ EVENTS = ::T.let(nil, ::T.untyped)
+ OPTIONS = ::T.let(nil, ::T.untyped)
end
-class REXML::Comment
- include ::Comparable
- def ==(other); end
+class Psych::Handler::DumperOptions
+ def canonical(); end
- def clone(); end
+ def canonical=(canonical); end
- def initialize(first, second=T.unsafe(nil)); end
+ def indentation(); end
- def node_type(); end
+ def indentation=(indentation); end
- def string(); end
+ def line_width(); end
- def string=(string); end
+ def line_width=(line_width); end
+end
- def to_s(); end
+class Psych::Handler::DumperOptions
+end
- def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
- START = ::T.let(nil, ::T.untyped)
- STOP = ::T.let(nil, ::T.untyped)
+class Psych::Handler
end
-class REXML::Comment
+module Psych::Handlers
end
-class REXML::Declaration
- def initialize(src); end
+class Psych::Handlers::DocumentStream
+ def initialize(&block); end
+end
- def to_s(); end
+class Psych::Handlers::DocumentStream
+end
- def write(output, indent); end
+module Psych::Handlers
end
-class REXML::Declaration
+module Psych::JSON
end
-class REXML::DocType
- include ::REXML::XMLTokens
- def add(child); end
+module Psych::JSON::RubyEvents
+ def visit_DateTime(o); end
- def attribute_of(element, attribute); end
+ def visit_String(o); end
- def attributes_of(element); end
+ def visit_Symbol(o); end
- def clone(); end
+ def visit_Time(o); end
+end
- def context(); end
+module Psych::JSON::RubyEvents
+end
- def entities(); end
+class Psych::JSON::Stream
+ include ::Psych::Streaming
+end
- def entity(name); end
+class Psych::JSON::Stream::Emitter
+ include ::Psych::JSON::YAMLEvents
+end
- def external_id(); end
+class Psych::JSON::Stream::Emitter
+end
- def initialize(first, parent=T.unsafe(nil)); end
+class Psych::JSON::Stream
+ extend ::Psych::Streaming::ClassMethods
+end
- def name(); end
+class Psych::JSON::TreeBuilder
+ include ::Psych::JSON::YAMLEvents
+end
- def namespaces(); end
+class Psych::JSON::TreeBuilder
+end
- def node_type(); end
+module Psych::JSON::YAMLEvents
+ def end_document(implicit_end=T.unsafe(nil)); end
- def notation(name); end
+ def scalar(value, anchor, tag, plain, quoted, style); end
- def notations(); end
+ def start_document(version, tag_directives, implicit); end
- def public(); end
+ def start_mapping(anchor, tag, implicit, style); end
- def system(); end
+ def start_sequence(anchor, tag, implicit, style); end
+end
- def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
- DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped)
- PUBLIC = ::T.let(nil, ::T.untyped)
- START = ::T.let(nil, ::T.untyped)
- STOP = ::T.let(nil, ::T.untyped)
- SYSTEM = ::T.let(nil, ::T.untyped)
+module Psych::JSON::YAMLEvents
end
-class REXML::DocType
+module Psych::JSON
end
-class REXML::Document
- def <<(child); end
+module Psych::Nodes
+end
- def add(child); end
+class Psych::Nodes::Alias
+ def anchor(); end
- def add_element(arg=T.unsafe(nil), arg2=T.unsafe(nil)); end
+ def anchor=(anchor); end
- def doctype(); end
+ def initialize(anchor); end
+end
- def encoding(); end
+class Psych::Nodes::Alias
+end
- def entity_expansion_count(); end
+class Psych::Nodes::Document
+ def implicit(); end
- def initialize(source=T.unsafe(nil), context=T.unsafe(nil)); end
+ def implicit=(implicit); end
- def record_entity_expansion(); end
+ def implicit_end(); end
- def stand_alone?(); end
+ def implicit_end=(implicit_end); end
- def version(); end
+ def initialize(version=T.unsafe(nil), tag_directives=T.unsafe(nil), implicit=T.unsafe(nil)); end
- def write(*arguments); end
+ def root(); end
- def xml_decl(); end
- DECLARATION = ::T.let(nil, ::T.untyped)
-end
+ def tag_directives(); end
-class REXML::Document
- def self.entity_expansion_limit(); end
+ def tag_directives=(tag_directives); end
- def self.entity_expansion_limit=(val); end
+ def version(); end
- def self.entity_expansion_text_limit(); end
+ def version=(version); end
+end
- def self.entity_expansion_text_limit=(val); end
-
- def self.parse_stream(source, listener); end
+class Psych::Nodes::Document
end
-class REXML::Element
- include ::REXML::Namespace
- include ::REXML::XMLTokens
- def [](name_or_index); end
+class Psych::Nodes::Mapping
+ def anchor(); end
- def add_attribute(key, value=T.unsafe(nil)); end
+ def anchor=(anchor); end
- def add_attributes(hash); end
+ def implicit(); end
- def add_element(element, attrs=T.unsafe(nil)); end
+ def implicit=(implicit); end
- def add_namespace(prefix, uri=T.unsafe(nil)); end
+ def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
- def add_text(text); end
+ def style(); end
- def attribute(name, namespace=T.unsafe(nil)); end
+ def style=(style); end
- def attributes(); end
+ def tag=(tag); end
+ ANY = ::T.let(nil, ::T.untyped)
+ BLOCK = ::T.let(nil, ::T.untyped)
+ FLOW = ::T.let(nil, ::T.untyped)
+end
- def cdatas(); end
+class Psych::Nodes::Mapping
+end
- def clone(); end
+class Psych::Nodes::Node
+ include ::Enumerable
+ def alias?(); end
- def comments(); end
+ def children(); end
- def context(); end
+ def document?(); end
- def context=(context); end
+ def each(&block); end
- def delete_attribute(key); end
+ def end_column(); end
- def delete_element(element); end
+ def end_column=(end_column); end
- def delete_namespace(namespace=T.unsafe(nil)); end
+ def end_line(); end
- def each_element(xpath=T.unsafe(nil), &block); end
+ def end_line=(end_line); end
- def each_element_with_attribute(key, value=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end
+ def mapping?(); end
- def each_element_with_text(text=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end
+ def scalar?(); end
- def elements(); end
+ def sequence?(); end
- def get_elements(xpath); end
+ def start_column(); end
- def get_text(path=T.unsafe(nil)); end
+ def start_column=(start_column); end
- def has_attributes?(); end
+ def start_line(); end
- def has_elements?(); end
+ def start_line=(start_line); end
- def has_text?(); end
+ def stream?(); end
- def ignore_whitespace_nodes(); end
+ def tag(); end
- def initialize(arg=T.unsafe(nil), parent=T.unsafe(nil), context=T.unsafe(nil)); end
+ def to_ruby(); end
- def instructions(); end
+ def to_yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
- def namespace(prefix=T.unsafe(nil)); end
+ def transform(); end
- def namespaces(); end
+ def yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
+end
- def next_element(); end
+class Psych::Nodes::Node
+end
- def node_type(); end
+class Psych::Nodes::Scalar
+ def anchor(); end
- def prefixes(); end
+ def anchor=(anchor); end
- def previous_element(); end
+ def initialize(value, anchor=T.unsafe(nil), tag=T.unsafe(nil), plain=T.unsafe(nil), quoted=T.unsafe(nil), style=T.unsafe(nil)); end
- def raw(); end
+ def plain(); end
- def root(); end
+ def plain=(plain); end
- def root_node(); end
+ def quoted(); end
- def text(path=T.unsafe(nil)); end
+ def quoted=(quoted); end
- def text=(text); end
+ def style(); end
- def texts(); end
+ def style=(style); end
- def whitespace(); end
+ def tag=(tag); end
- def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+ def value(); end
- def xpath(); end
- UNDEFINED = ::T.let(nil, ::T.untyped)
+ def value=(value); end
+ ANY = ::T.let(nil, ::T.untyped)
+ DOUBLE_QUOTED = ::T.let(nil, ::T.untyped)
+ FOLDED = ::T.let(nil, ::T.untyped)
+ LITERAL = ::T.let(nil, ::T.untyped)
+ PLAIN = ::T.let(nil, ::T.untyped)
+ SINGLE_QUOTED = ::T.let(nil, ::T.untyped)
end
-class REXML::Element
+class Psych::Nodes::Scalar
end
-class REXML::ElementDecl
-end
+class Psych::Nodes::Sequence
+ def anchor(); end
-class REXML::ElementDecl
-end
+ def anchor=(anchor); end
-class REXML::Elements
- include ::Enumerable
- def <<(element=T.unsafe(nil)); end
+ def implicit(); end
- def [](index, name=T.unsafe(nil)); end
+ def implicit=(implicit); end
- def []=(index, element); end
+ def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
- def add(element=T.unsafe(nil)); end
+ def style(); end
- def collect(xpath=T.unsafe(nil)); end
+ def style=(style); end
- def delete(element); end
+ def tag=(tag); end
+ ANY = ::T.let(nil, ::T.untyped)
+ BLOCK = ::T.let(nil, ::T.untyped)
+ FLOW = ::T.let(nil, ::T.untyped)
+end
- def delete_all(xpath); end
+class Psych::Nodes::Sequence
+end
- def each(xpath=T.unsafe(nil), &blk); end
+class Psych::Nodes::Stream
+ def encoding(); end
- def empty?(); end
+ def encoding=(encoding); end
- def index(element); end
+ def initialize(encoding=T.unsafe(nil)); end
+ ANY = ::T.let(nil, ::T.untyped)
+ UTF16BE = ::T.let(nil, ::T.untyped)
+ UTF16LE = ::T.let(nil, ::T.untyped)
+ UTF8 = ::T.let(nil, ::T.untyped)
+end
- def initialize(parent); end
+class Psych::Nodes::Stream
+end
- def inject(xpath=T.unsafe(nil), initial=T.unsafe(nil)); end
+module Psych::Nodes
+end
- def size(); end
-
- def to_a(xpath=T.unsafe(nil)); end
+class Psych::Omap
end
-class REXML::Elements
+class Psych::Omap
end
-module REXML::Encoding
- def decode(string); end
+class Psych::Parser
+ def external_encoding=(external_encoding); end
- def encode(string); end
+ def handler(); end
- def encoding(); end
+ def handler=(handler); end
- def encoding=(encoding); end
+ def initialize(handler=T.unsafe(nil)); end
+
+ def mark(); end
+
+ def parse(*_); end
+ ANY = ::T.let(nil, ::T.untyped)
+ UTF16BE = ::T.let(nil, ::T.untyped)
+ UTF16LE = ::T.let(nil, ::T.untyped)
+ UTF8 = ::T.let(nil, ::T.untyped)
end
-module REXML::Encoding
+class Psych::Parser::Mark
end
-class REXML::Entity
- include ::REXML::XMLTokens
- def external(); end
+class Psych::Parser::Mark
+end
- def initialize(stream, value=T.unsafe(nil), parent=T.unsafe(nil), reference=T.unsafe(nil)); end
+class Psych::Parser
+end
- def name(); end
+class Psych::ScalarScanner
+ def class_loader(); end
- def ndata(); end
+ def initialize(class_loader); end
- def normalized(); end
+ def parse_int(string); end
- def pubid(); end
+ def parse_time(string); end
- def ref(); end
+ def tokenize(string); end
+ FLOAT = ::T.let(nil, ::T.untyped)
+ INTEGER = ::T.let(nil, ::T.untyped)
+ TIME = ::T.let(nil, ::T.untyped)
+end
- def to_s(); end
+class Psych::ScalarScanner
+end
- def unnormalized(); end
+class Psych::Set
+end
- def value(); end
+class Psych::Set
+end
- def write(out, indent=T.unsafe(nil)); end
- ENTITYDECL = ::T.let(nil, ::T.untyped)
- ENTITYDEF = ::T.let(nil, ::T.untyped)
- ENTITYVALUE = ::T.let(nil, ::T.untyped)
- EXTERNALID = ::T.let(nil, ::T.untyped)
- GEDECL = ::T.let(nil, ::T.untyped)
- NDATADECL = ::T.let(nil, ::T.untyped)
- PEDECL = ::T.let(nil, ::T.untyped)
- PEDEF = ::T.let(nil, ::T.untyped)
- PEREFERENCE = ::T.let(nil, ::T.untyped)
- PEREFERENCE_RE = ::T.let(nil, ::T.untyped)
- PUBIDCHAR = ::T.let(nil, ::T.untyped)
- PUBIDLITERAL = ::T.let(nil, ::T.untyped)
- SYSTEMLITERAL = ::T.let(nil, ::T.untyped)
+class Psych::Stream
+ include ::Psych::Streaming
end
-class REXML::Entity
- def self.matches?(string); end
+class Psych::Stream::Emitter
+ def end_document(implicit_end=T.unsafe(nil)); end
end
-module REXML::EntityConst
- AMP = ::T.let(nil, ::T.untyped)
- APOS = ::T.let(nil, ::T.untyped)
- GT = ::T.let(nil, ::T.untyped)
- LT = ::T.let(nil, ::T.untyped)
- QUOT = ::T.let(nil, ::T.untyped)
+class Psych::Stream::Emitter
end
-module REXML::EntityConst
+class Psych::Stream
+ extend ::Psych::Streaming::ClassMethods
end
-class REXML::ExternalEntity
- def initialize(src); end
+module Psych::Streaming
+ def start(encoding=T.unsafe(nil)); end
+end
- def to_s(); end
-
- def write(output, indent); end
+module Psych::Streaming::ClassMethods
+ def new(io); end
end
-class REXML::ExternalEntity
+module Psych::Streaming::ClassMethods
end
-module REXML::Formatters
+module Psych::Streaming
end
-class REXML::Formatters::Default
- def initialize(ie_hack=T.unsafe(nil)); end
+class Psych::SyntaxError
+ def column(); end
- def write(node, output); end
+ def context(); end
- def write_cdata(node, output); end
+ def file(); end
- def write_comment(node, output); end
+ def initialize(file, line, col, offset, problem, context); end
- def write_document(node, output); end
+ def line(); end
- def write_element(node, output); end
+ def offset(); end
- def write_instruction(node, output); end
+ def problem(); end
+end
- def write_text(node, output); end
+class Psych::SyntaxError
end
-class REXML::Formatters::Default
+class Psych::TreeBuilder
+ def end_document(implicit_end=T.unsafe(nil)); end
+
+ def root(); end
end
-class REXML::Formatters::Pretty
- def compact(); end
+class Psych::TreeBuilder
+end
- def compact=(compact); end
+module Psych::Visitors
+end
- def initialize(indentation=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+class Psych::Visitors::DepthFirst
+ def initialize(block); end
+end
- def width(); end
+class Psych::Visitors::DepthFirst
+end
- def width=(width); end
+class Psych::Visitors::Emitter
+ def initialize(io, options=T.unsafe(nil)); end
+
+ def visit_Psych_Nodes_Alias(o); end
+
+ def visit_Psych_Nodes_Document(o); end
+
+ def visit_Psych_Nodes_Mapping(o); end
+
+ def visit_Psych_Nodes_Scalar(o); end
+
+ def visit_Psych_Nodes_Sequence(o); end
+
+ def visit_Psych_Nodes_Stream(o); end
end
-class REXML::Formatters::Pretty
+class Psych::Visitors::Emitter
end
-module REXML::Formatters
+class Psych::Visitors::JSONTree
+ include ::Psych::JSON::RubyEvents
end
-module REXML::Functions
- INTERNAL_METHODS = ::T.let(nil, ::T.untyped)
+class Psych::Visitors::JSONTree
+ def self.create(options=T.unsafe(nil)); end
end
-module REXML::Functions
- def self.boolean(object=T.unsafe(nil)); end
+class Psych::Visitors::NoAliasRuby
+end
- def self.ceiling(number); end
+class Psych::Visitors::NoAliasRuby
+end
- def self.compare_language(lang1, lang2); end
+class Psych::Visitors::ToRuby
+ def class_loader(); end
- def self.concat(*objects); end
+ def initialize(ss, class_loader); end
- def self.contains(string, test); end
+ def visit_Psych_Nodes_Alias(o); end
- def self.context=(value); end
+ def visit_Psych_Nodes_Document(o); end
- def self.count(node_set); end
+ def visit_Psych_Nodes_Mapping(o); end
- def self.false(); end
+ def visit_Psych_Nodes_Scalar(o); end
- def self.floor(number); end
+ def visit_Psych_Nodes_Sequence(o); end
- def self.get_namespace(node_set=T.unsafe(nil)); end
+ def visit_Psych_Nodes_Stream(o); end
+ SHOVEL = ::T.let(nil, ::T.untyped)
+end
- def self.id(object); end
+class Psych::Visitors::ToRuby
+ def self.create(); end
+end
- def self.lang(language); end
+class Psych::Visitors::Visitor
+ def accept(target); end
+ DISPATCH = ::T.let(nil, ::T.untyped)
+end
- def self.last(); end
+class Psych::Visitors::Visitor
+end
- def self.local_name(node_set=T.unsafe(nil)); end
+class Psych::Visitors::YAMLTree
+ def <<(object); end
- def self.name(node_set=T.unsafe(nil)); end
+ def finish(); end
- def self.namespace_context(); end
+ def finished(); end
- def self.namespace_context=(x); end
+ def finished?(); end
- def self.namespace_uri(node_set=T.unsafe(nil)); end
+ def initialize(emitter, ss, options); end
- def self.normalize_space(string=T.unsafe(nil)); end
+ def push(object); end
- def self.not(object); end
+ def start(encoding=T.unsafe(nil)); end
- def self.number(object=T.unsafe(nil)); end
+ def started(); end
- def self.position(); end
+ def started?(); end
- def self.processing_instruction(node); end
+ def tree(); end
- def self.round(number); end
+ def visit_Array(o); end
- def self.send(name, *args); end
+ def visit_BasicObject(o); end
- def self.singleton_method_added(name); end
+ def visit_BigDecimal(o); end
- def self.starts_with(string, test); end
+ def visit_Class(o); end
- def self.string(object=T.unsafe(nil)); end
+ def visit_Complex(o); end
- def self.string_length(string); end
+ def visit_Date(o); end
- def self.string_value(o); end
+ def visit_DateTime(o); end
- def self.substring(string, start, length=T.unsafe(nil)); end
+ def visit_Delegator(o); end
- def self.substring_after(string, test); end
+ def visit_Encoding(o); end
- def self.substring_before(string, test); end
+ def visit_Enumerator(o); end
- def self.sum(nodes); end
+ def visit_Exception(o); end
- def self.text(); end
+ def visit_FalseClass(o); end
- def self.translate(string, tr1, tr2); end
+ def visit_Float(o); end
- def self.true(); end
+ def visit_Hash(o); end
- def self.variables(); end
+ def visit_Integer(o); end
- def self.variables=(x); end
-end
+ def visit_Module(o); end
-class REXML::IOSource
- def initialize(arg, block_size=T.unsafe(nil), encoding=T.unsafe(nil)); end
-end
+ def visit_NameError(o); end
-class REXML::IOSource
-end
+ def visit_NilClass(o); end
-class REXML::Instruction
- def ==(other); end
+ def visit_Object(o); end
- def clone(); end
+ def visit_Psych_Omap(o); end
- def content(); end
+ def visit_Psych_Set(o); end
- def content=(content); end
+ def visit_Range(o); end
- def initialize(target, content=T.unsafe(nil)); end
+ def visit_Rational(o); end
- def node_type(); end
+ def visit_Regexp(o); end
- def target(); end
+ def visit_String(o); end
- def target=(target); end
+ def visit_Struct(o); end
- def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
- START = ::T.let(nil, ::T.untyped)
- STOP = ::T.let(nil, ::T.untyped)
+ def visit_Symbol(o); end
+
+ def visit_Time(o); end
+
+ def visit_TrueClass(o); end
end
-class REXML::Instruction
+class Psych::Visitors::YAMLTree
+ def self.create(options=T.unsafe(nil), emitter=T.unsafe(nil)); end
end
-module REXML::Namespace
- include ::REXML::XMLTokens
- def expanded_name(); end
+module Psych::Visitors
+end
- def fully_expanded_name(); end
+module Psych
+ def self.add_builtin_type(type_tag, &block); end
- def has_name?(other, ns=T.unsafe(nil)); end
+ def self.add_domain_type(domain, type_tag, &block); end
- def local_name(); end
+ def self.add_tag(tag, klass); end
- def name(); end
+ def self.domain_types(); end
- def name=(name); end
+ def self.domain_types=(domain_types); end
- def prefix(); end
+ def self.dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end
- def prefix=(prefix); end
- NAMESPLIT = ::T.let(nil, ::T.untyped)
-end
+ def self.dump_stream(*objects); end
-module REXML::Namespace
-end
+ def self.dump_tags(); end
-module REXML::Node
- def each_recursive(&block); end
+ def self.dump_tags=(dump_tags); end
- def find_first_recursive(&block); end
+ def self.libyaml_version(); end
- def indent(to, ind); end
+ def self.load(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
- def index_in_parent(); end
+ def self.load_file(filename, fallback: T.unsafe(nil)); end
- def next_sibling_node(); end
+ def self.load_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
- def parent?(); end
+ def self.load_tags(); end
- def previous_sibling_node(); end
+ def self.load_tags=(load_tags); end
- def to_s(indent=T.unsafe(nil)); end
-end
+ def self.parse(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
-module REXML::Node
-end
+ def self.parse_file(filename, fallback: T.unsafe(nil)); end
-class REXML::NotationDecl
- def initialize(name, middle, pub, sys); end
+ def self.parse_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), &block); end
- def name(); end
+ def self.parser(); end
- def public(); end
+ def self.remove_type(type_tag); end
- def public=(public); end
+ def self.safe_load(yaml, legacy_permitted_classes=T.unsafe(nil), legacy_permitted_symbols=T.unsafe(nil), legacy_aliases=T.unsafe(nil), legacy_filename=T.unsafe(nil), permitted_classes: T.unsafe(nil), permitted_symbols: T.unsafe(nil), aliases: T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
- def system(); end
+ def self.to_json(object); end
+end
- def system=(system); end
+module REXML
+ COPYRIGHT = ::T.let(nil, ::T.untyped)
+ Copyright = ::T.let(nil, ::T.untyped)
+ DATE = ::T.let(nil, ::T.untyped)
+ REVISION = ::T.let(nil, ::T.untyped)
+ VERSION = ::T.let(nil, ::T.untyped)
+ Version = ::T.let(nil, ::T.untyped)
+end
- def to_s(); end
+class REXML::Attribute
+ NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
+ PATTERN = ::T.let(nil, ::T.untyped)
+end
- def write(output, indent=T.unsafe(nil)); end
+class REXML::CData
+ ILLEGAL = ::T.let(nil, ::T.untyped)
+ START = ::T.let(nil, ::T.untyped)
+ STOP = ::T.let(nil, ::T.untyped)
end
-class REXML::NotationDecl
+class REXML::Comment
+ START = ::T.let(nil, ::T.untyped)
+ STOP = ::T.let(nil, ::T.untyped)
end
-class REXML::Output
- include ::REXML::Encoding
- def <<(content); end
+class REXML::DocType
+ DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped)
+ PUBLIC = ::T.let(nil, ::T.untyped)
+ START = ::T.let(nil, ::T.untyped)
+ STOP = ::T.let(nil, ::T.untyped)
+ SYSTEM = ::T.let(nil, ::T.untyped)
+end
- def initialize(real_IO, encd=T.unsafe(nil)); end
+class REXML::Document
+ DECLARATION = ::T.let(nil, ::T.untyped)
end
-class REXML::Output
+class REXML::Element
+ UNDEFINED = ::T.let(nil, ::T.untyped)
end
-class REXML::Parent
- include ::Enumerable
- def <<(object); end
+class REXML::Entity
+ ENTITYDECL = ::T.let(nil, ::T.untyped)
+ ENTITYDEF = ::T.let(nil, ::T.untyped)
+ ENTITYVALUE = ::T.let(nil, ::T.untyped)
+ EXTERNALID = ::T.let(nil, ::T.untyped)
+ GEDECL = ::T.let(nil, ::T.untyped)
+ NDATADECL = ::T.let(nil, ::T.untyped)
+ PEDECL = ::T.let(nil, ::T.untyped)
+ PEDEF = ::T.let(nil, ::T.untyped)
+ PEREFERENCE = ::T.let(nil, ::T.untyped)
+ PEREFERENCE_RE = ::T.let(nil, ::T.untyped)
+ PUBIDCHAR = ::T.let(nil, ::T.untyped)
+ PUBIDLITERAL = ::T.let(nil, ::T.untyped)
+ SYSTEMLITERAL = ::T.let(nil, ::T.untyped)
+end
- def [](index); end
+module REXML::EntityConst
+ AMP = ::T.let(nil, ::T.untyped)
+ APOS = ::T.let(nil, ::T.untyped)
+ GT = ::T.let(nil, ::T.untyped)
+ LT = ::T.let(nil, ::T.untyped)
+ QUOT = ::T.let(nil, ::T.untyped)
+end
- def []=(*args); end
+module REXML::Functions
+ INTERNAL_METHODS = ::T.let(nil, ::T.untyped)
+end
- def add(object); end
+module REXML::Functions
+ def self.boolean(object=T.unsafe(nil)); end
- def children(); end
+ def self.ceiling(number); end
- def deep_clone(); end
+ def self.compare_language(lang1, lang2); end
- def delete(object); end
+ def self.concat(*objects); end
- def delete_at(index); end
+ def self.contains(string, test); end
- def delete_if(&block); end
+ def self.context=(value); end
- def each(&block); end
+ def self.count(node_set); end
- def each_child(&block); end
+ def self.false(); end
- def each_index(&block); end
+ def self.floor(number); end
- def index(child); end
+ def self.get_namespace(node_set=T.unsafe(nil)); end
- def insert_after(child1, child2); end
+ def self.id(object); end
- def insert_before(child1, child2); end
+ def self.lang(language); end
- def length(); end
+ def self.last(); end
- def push(object); end
+ def self.local_name(node_set=T.unsafe(nil)); end
- def replace_child(to_replace, replacement); end
+ def self.name(node_set=T.unsafe(nil)); end
- def size(); end
+ def self.namespace_context(); end
- def to_a(); end
+ def self.namespace_context=(x); end
- def unshift(object); end
-end
+ def self.namespace_uri(node_set=T.unsafe(nil)); end
-class REXML::Parent
-end
+ def self.normalize_space(string=T.unsafe(nil)); end
-class REXML::ParseException
- def context(); end
+ def self.not(object); end
- def continued_exception(); end
+ def self.number(object=T.unsafe(nil)); end
- def continued_exception=(continued_exception); end
+ def self.position(); end
- def initialize(message, source=T.unsafe(nil), parser=T.unsafe(nil), exception=T.unsafe(nil)); end
+ def self.processing_instruction(node); end
- def line(); end
+ def self.round(number); end
- def parser(); end
+ def self.send(name, *args); end
- def parser=(parser); end
+ def self.singleton_method_added(name); end
- def position(); end
+ def self.starts_with(string, test); end
- def source(); end
+ def self.string(object=T.unsafe(nil)); end
- def source=(source); end
-end
+ def self.string_length(string); end
-class REXML::ParseException
-end
+ def self.string_value(o); end
-module REXML::Parsers
-end
+ def self.substring(string, start, length=T.unsafe(nil)); end
-class REXML::Parsers::BaseParser
- def add_listener(listener); end
+ def self.substring_after(string, test); end
- def empty?(); end
+ def self.substring_before(string, test); end
- def entity(reference, entities); end
+ def self.sum(nodes); end
- def has_next?(); end
+ def self.text(); end
- def initialize(source); end
+ def self.translate(string, tr1, tr2); end
- def normalize(input, entities=T.unsafe(nil), entity_filter=T.unsafe(nil)); end
+ def self.true(); end
- def peek(depth=T.unsafe(nil)); end
+ def self.variables(); end
- def position(); end
+ def self.variables=(x); end
+end
- def pull(); end
+class REXML::Instruction
+ START = ::T.let(nil, ::T.untyped)
+ STOP = ::T.let(nil, ::T.untyped)
+end
- def source(); end
+module REXML::Namespace
+ NAMESPLIT = ::T.let(nil, ::T.untyped)
+end
- def stream=(source); end
-
- def unnormalize(string, entities=T.unsafe(nil), filter=T.unsafe(nil)); end
-
- def unshift(token); end
+class REXML::Parsers::BaseParser
ATTDEF = ::T.let(nil, ::T.untyped)
ATTDEF_RE = ::T.let(nil, ::T.untyped)
ATTLISTDECL_PATTERN = ::T.let(nil, ::T.untyped)
ATTLISTDECL_START = ::T.let(nil, ::T.untyped)
ATTRIBUTE_PATTERN = ::T.let(nil, ::T.untyped)
@@ -9261,14 +9446,12 @@
GEDECL = ::T.let(nil, ::T.untyped)
IDENTITY = ::T.let(nil, ::T.untyped)
INSTRUCTION_PATTERN = ::T.let(nil, ::T.untyped)
INSTRUCTION_START = ::T.let(nil, ::T.untyped)
LETTER = ::T.let(nil, ::T.untyped)
- MISSING_ATTRIBUTE_QUOTES = ::T.let(nil, ::T.untyped)
NAME = ::T.let(nil, ::T.untyped)
NAMECHAR = ::T.let(nil, ::T.untyped)
- NAME_STR = ::T.let(nil, ::T.untyped)
NCNAME_STR = ::T.let(nil, ::T.untyped)
NDATADECL = ::T.let(nil, ::T.untyped)
NMTOKEN = ::T.let(nil, ::T.untyped)
NMTOKENS = ::T.let(nil, ::T.untyped)
NOTATIONDECL_START = ::T.let(nil, ::T.untyped)
@@ -9277,10 +9460,12 @@
PEDEF = ::T.let(nil, ::T.untyped)
PEREFERENCE = ::T.let(nil, ::T.untyped)
PUBIDCHAR = ::T.let(nil, ::T.untyped)
PUBIDLITERAL = ::T.let(nil, ::T.untyped)
PUBLIC = ::T.let(nil, ::T.untyped)
+ QNAME = ::T.let(nil, ::T.untyped)
+ QNAME_STR = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
REFERENCE_RE = ::T.let(nil, ::T.untyped)
STANDALONE = ::T.let(nil, ::T.untyped)
SYSTEM = ::T.let(nil, ::T.untyped)
SYSTEMENTITY = ::T.let(nil, ::T.untyped)
@@ -9291,166 +9476,24 @@
VERSION = ::T.let(nil, ::T.untyped)
XMLDECL_PATTERN = ::T.let(nil, ::T.untyped)
XMLDECL_START = ::T.let(nil, ::T.untyped)
end
-class REXML::Parsers::BaseParser
-end
-
-class REXML::Parsers::StreamParser
- def add_listener(listener); end
-
- def initialize(source, listener); end
-
- def parse(); end
-end
-
-class REXML::Parsers::StreamParser
-end
-
-class REXML::Parsers::TreeParser
- def add_listener(listener); end
-
- def initialize(source, build_context=T.unsafe(nil)); end
-
- def parse(); end
-end
-
-class REXML::Parsers::TreeParser
-end
-
class REXML::Parsers::XPathParser
- include ::REXML::XMLTokens
- def abbreviate(path); end
-
- def expand(path); end
-
- def namespaces=(namespaces); end
-
- def parse(path); end
-
- def predicate(path); end
-
- def predicate_to_string(path, &block); end
AXIS = ::T.let(nil, ::T.untyped)
LITERAL = ::T.let(nil, ::T.untyped)
- NCNAMETEST = ::T.let(nil, ::T.untyped)
+ LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped)
NODE_TYPE = ::T.let(nil, ::T.untyped)
NT = ::T.let(nil, ::T.untyped)
NUMBER = ::T.let(nil, ::T.untyped)
PI = ::T.let(nil, ::T.untyped)
+ PREFIX_WILDCARD = ::T.let(nil, ::T.untyped)
QNAME = ::T.let(nil, ::T.untyped)
VARIABLE_REFERENCE = ::T.let(nil, ::T.untyped)
end
-class REXML::Parsers::XPathParser
-end
-
-module REXML::Parsers
-end
-
-module REXML::Security
-end
-
-module REXML::Security
- def self.entity_expansion_limit(); end
-
- def self.entity_expansion_limit=(val); end
-
- def self.entity_expansion_text_limit(); end
-
- def self.entity_expansion_text_limit=(val); end
-end
-
-class REXML::Source
- include ::REXML::Encoding
- def buffer(); end
-
- def consume(pattern); end
-
- def current_line(); end
-
- def empty?(); end
-
- def encoding=(enc); end
-
- def initialize(arg, encoding=T.unsafe(nil)); end
-
- def line(); end
-
- def match(pattern, cons=T.unsafe(nil)); end
-
- def match_to(char, pattern); end
-
- def match_to_consume(char, pattern); end
-
- def position(); end
-
- def read(); end
-
- def scan(pattern, cons=T.unsafe(nil)); end
-end
-
-class REXML::Source
-end
-
-class REXML::SourceFactory
-end
-
-class REXML::SourceFactory
- def self.create_from(arg); end
-end
-
-class REXML::SyncEnumerator
- include ::Enumerable
- def each(&blk); end
-
- def initialize(*enums); end
-
- def length(); end
-
- def size(); end
-end
-
-class REXML::SyncEnumerator
-end
-
class REXML::Text
- include ::Comparable
- def <<(to_append); end
-
- def clone(); end
-
- def doctype(); end
-
- def empty?(); end
-
- def indent_text(string, level=T.unsafe(nil), style=T.unsafe(nil), indentfirstline=T.unsafe(nil)); end
-
- def initialize(arg, respect_whitespace=T.unsafe(nil), parent=T.unsafe(nil), raw=T.unsafe(nil), entity_filter=T.unsafe(nil), illegal=T.unsafe(nil)); end
-
- def node_type(); end
-
- def parent=(parent); end
-
- def raw(); end
-
- def raw=(raw); end
-
- def to_s(); end
-
- def value(); end
-
- def value=(val); end
-
- def wrap(string, width, addnewline=T.unsafe(nil)); end
-
- def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
-
- def write_with_substitution(out, input); end
-
- def xpath(); end
EREFERENCE = ::T.let(nil, ::T.untyped)
NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
NUMERICENTITY = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
SETUTITSBUS = ::T.let(nil, ::T.untyped)
@@ -9459,88 +9502,18 @@
SUBSTITUTES = ::T.let(nil, ::T.untyped)
VALID_CHAR = ::T.let(nil, ::T.untyped)
VALID_XML_CHARS = ::T.let(nil, ::T.untyped)
end
-class REXML::Text
- def self.check(string, pattern, doctype); end
-
- def self.expand(ref, doctype, filter); end
-
- def self.normalize(input, doctype=T.unsafe(nil), entity_filter=T.unsafe(nil)); end
-
- def self.read_with_substitution(input, illegal=T.unsafe(nil)); end
-
- def self.unnormalize(string, doctype=T.unsafe(nil), filter=T.unsafe(nil), illegal=T.unsafe(nil)); end
-end
-
-class REXML::UndefinedNamespaceException
- def initialize(prefix, source, parser); end
-end
-
-class REXML::UndefinedNamespaceException
-end
-
-module REXML::Validation
-end
-
-class REXML::Validation::ValidationException
- def initialize(msg); end
-end
-
-class REXML::Validation::ValidationException
-end
-
-module REXML::Validation
-end
-
class REXML::XMLDecl
- include ::REXML::Encoding
- def ==(other); end
-
- def clone(); end
-
- def dowrite(); end
-
- def encoding=(enc); end
-
- def initialize(version=T.unsafe(nil), encoding=T.unsafe(nil), standalone=T.unsafe(nil)); end
-
- def node_type(); end
-
- def nowrite(); end
-
- def old_enc=(encoding); end
-
- def stand_alone?(); end
-
- def standalone(); end
-
- def standalone=(standalone); end
-
- def version(); end
-
- def version=(version); end
-
- def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
-
- def writeencoding(); end
-
- def writethis(); end
-
- def xmldecl(version, encoding, standalone); end
DEFAULT_ENCODING = ::T.let(nil, ::T.untyped)
DEFAULT_STANDALONE = ::T.let(nil, ::T.untyped)
DEFAULT_VERSION = ::T.let(nil, ::T.untyped)
START = ::T.let(nil, ::T.untyped)
STOP = ::T.let(nil, ::T.untyped)
end
-class REXML::XMLDecl
- def self.default(); end
-end
-
module REXML::XMLTokens
NAME = ::T.let(nil, ::T.untyped)
NAMECHAR = ::T.let(nil, ::T.untyped)
NAME_CHAR = ::T.let(nil, ::T.untyped)
NAME_START_CHAR = ::T.let(nil, ::T.untyped)
@@ -9549,54 +9522,19 @@
NMTOKEN = ::T.let(nil, ::T.untyped)
NMTOKENS = ::T.let(nil, ::T.untyped)
REFERENCE = ::T.let(nil, ::T.untyped)
end
-module REXML::XMLTokens
-end
-
class REXML::XPath
- include ::REXML::Functions
EMPTY_HASH = ::T.let(nil, ::T.untyped)
end
-class REXML::XPath
- def self.each(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), &block); end
-
- def self.first(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil)); end
-
- def self.match(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil)); end
-end
-
class REXML::XPathParser
- include ::REXML::XMLTokens
- def []=(variable_name, value); end
-
- def first(path_stack, node); end
-
- def get_first(path, nodeset); end
-
- def match(path_stack, nodeset); end
-
- def namespaces=(namespaces=T.unsafe(nil)); end
-
- def parse(path, nodeset); end
-
- def predicate(path, nodeset); end
-
- def variables=(vars=T.unsafe(nil)); end
- ALL = ::T.let(nil, ::T.untyped)
- ELEMENTS = ::T.let(nil, ::T.untyped)
+ DEBUG = ::T.let(nil, ::T.untyped)
LITERAL = ::T.let(nil, ::T.untyped)
end
-class REXML::XPathParser
-end
-
-module REXML
-end
-
module RSpec
MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
end
class RSpec::CallerFilter
@@ -10664,219 +10602,23 @@
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 time(*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
+ include ::T::CompatibilityPatches::RecorderExtensions
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
@@ -11147,12 +10889,10 @@
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
@@ -11287,32 +11027,43 @@
RakeFileUtils = Rake::FileUtilsExt
module Random::Formatter
def alphanumeric(n=T.unsafe(nil)); end
+
ALPHANUMERIC = ::T.let(nil, ::T.untyped)
end
class Random
+ def self.bytes(_); end
+
def self.urandom(_); end
end
class Range
include ::ActiveSupport::RangeWithFormat
include ::ActiveSupport::CompareWithRange
include ::ActiveSupport::IncludeTimeWithZone
include ::ActiveSupport::EachTimeWithZone
+ def %(_); end
+
+ def entries(); end
+
def overlaps?(other); end
+
+ def to_a(); end
end
class Rational
def to_d(precision); end
end
module RbConfig
def self.expand(val, config=T.unsafe(nil)); end
+ def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+
def self.ruby(); end
end
module RbReadline
ABORT_CHAR = ::T.let(nil, ::T.untyped)
@@ -11425,248 +11176,14 @@
Readline::HISTORY = Readline::History
Readline::USERNAME_COMPLETION_PROC = Readline::Ucomp
-module Reek
- DEFAULT_CONFIGURATION_FILE_NAME = ::T.let(nil, ::T.untyped)
- DETECTORS_KEY = ::T.let(nil, ::T.untyped)
- DIRECTORIES_KEY = ::T.let(nil, ::T.untyped)
- EXCLUDE_PATHS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-Reek::AST::SexpExtensions::CSendNode = Reek::AST::SexpExtensions::SendNode
-
-Reek::AST::SexpExtensions::CvasgnNode = Reek::AST::SexpExtensions::CvarNode
-
-Reek::AST::SexpExtensions::CvdeclNode = Reek::AST::SexpExtensions::CvarNode
-
-Reek::AST::SexpExtensions::LvasgnNode = Reek::AST::SexpExtensions::LvarNode
-
-Reek::AST::SexpExtensions::Op_AsgnNode = Reek::AST::SexpExtensions::SendNode
-
-module Reek::AST::SexpExtensions::SendNode
- ATTR_DEFN_METHODS = ::T.let(nil, ::T.untyped)
-end
-
-Reek::AST::SexpExtensions::ZsuperNode = Reek::AST::SexpExtensions::SuperNode
-
-class Reek::CodeComment
- CONFIGURATION_REGEX = ::T.let(nil, ::T.untyped)
- DISABLE_DETECTOR_CONFIGURATION = ::T.let(nil, ::T.untyped)
- MINIMUM_CONTENT_LENGTH = ::T.let(nil, ::T.untyped)
- SANITIZE_REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Configuration::ConfigurationConverter
- REGEXABLE_ATTRIBUTES = ::T.let(nil, ::T.untyped)
-end
-
-module Reek::Configuration::ConfigurationFileFinder
- DEFAULT_FILE_NAME = ::T.let(nil, ::T.untyped)
-end
-
-module Reek::Configuration::ConfigurationFileFinder
- extend ::Reek::Configuration::ConfigurationValidator
-end
-
-class Reek::Configuration::SchemaValidator
- SCHEMA_FILE_PATH = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Context::VisibilityTracker
- VISIBILITY_MAP = ::T.let(nil, ::T.untyped)
- VISIBILITY_MODIFIERS = ::T.let(nil, ::T.untyped)
-end
-
-module Reek::DocumentationLink
- HELP_LINK_TEMPLATE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Errors::BadDetectorConfigurationKeyInCommentError
- UNKNOWN_SMELL_DETECTOR_MESSAGE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Errors::BadDetectorInCommentError
- UNKNOWN_SMELL_DETECTOR_MESSAGE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Errors::EncodingError
- LONG_TEMPLATE = ::T.let(nil, ::T.untyped)
- TEMPLATE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Errors::GarbageDetectorConfigurationInCommentError
- BAD_DETECTOR_CONFIGURATION_MESSAGE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Errors::IncomprehensibleSourceError
- LONG_TEMPLATE = ::T.let(nil, ::T.untyped)
- TEMPLATE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Errors::SyntaxError
- LONG_TEMPLATE = ::T.let(nil, ::T.untyped)
- TEMPLATE = ::T.let(nil, ::T.untyped)
-end
-
-module Reek::Report
- HEADING_FORMATTERS = ::T.let(nil, ::T.untyped)
- LOCATION_FORMATTERS = ::T.let(nil, ::T.untyped)
- PROGRESS_FORMATTERS = ::T.let(nil, ::T.untyped)
- REPORT_CLASSES = ::T.let(nil, ::T.untyped)
- WARNING_FORMATTER_CLASSES = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Report::BaseReport
- NO_WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
- WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Report::CodeClimateFingerprint
- NON_IDENTIFYING_PARAMETERS = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Report::ProgressFormatter::Dots
- NO_WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
- WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellConfiguration
- ENABLED_KEY = ::T.let(nil, ::T.untyped)
- OVERRIDES_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::BaseDetector
- DEFAULT_EXCLUDE_SET = ::T.let(nil, ::T.untyped)
- EXCLUDE_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::ControlParameterHelpers::CallInConditionFinder
- COMPARISON_METHOD_NAMES = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::ControlParameterHelpers::ControlParameterFinder
- CONDITIONAL_NODE_TYPES = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::DataClump
- DEFAULT_MAX_COPIES = ::T.let(nil, ::T.untyped)
- DEFAULT_MIN_CLUMP_SIZE = ::T.let(nil, ::T.untyped)
- MAX_COPIES_KEY = ::T.let(nil, ::T.untyped)
- MIN_CLUMP_SIZE_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::DuplicateMethodCall
- ALLOW_CALLS_KEY = ::T.let(nil, ::T.untyped)
- DEFAULT_ALLOW_CALLS = ::T.let(nil, ::T.untyped)
- DEFAULT_MAX_CALLS = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_CALLS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::LongParameterList
- DEFAULT_MAX_ALLOWED_PARAMS = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_PARAMS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::LongYieldList
- DEFAULT_MAX_ALLOWED_PARAMS = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_PARAMS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::ManualDispatch
- MESSAGE = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::NestedIterators
- DEFAULT_IGNORE_ITERATORS = ::T.let(nil, ::T.untyped)
- DEFAULT_MAX_ALLOWED_NESTING = ::T.let(nil, ::T.untyped)
- IGNORE_ITERATORS_KEY = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_NESTING_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::RepeatedConditional
- BLOCK_GIVEN_CONDITION = ::T.let(nil, ::T.untyped)
- DEFAULT_MAX_IFS = ::T.let(nil, ::T.untyped)
- MAX_IDENTICAL_IFS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::SubclassedFromCoreClass
- CORE_CLASSES = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::TooManyConstants
- DEFAULT_MAX_CONSTANTS = ::T.let(nil, ::T.untyped)
- IGNORED_NODES = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_CONSTANTS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::TooManyInstanceVariables
- DEFAULT_MAX_IVARS = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_IVARS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::TooManyMethods
- DEFAULT_MAX_METHODS = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_METHODS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::TooManyStatements
- DEFAULT_MAX_STATEMENTS = ::T.let(nil, ::T.untyped)
- MAX_ALLOWED_STATEMENTS_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::UncommunicativeMethodName
- ACCEPT_KEY = ::T.let(nil, ::T.untyped)
- DEFAULT_ACCEPT_PATTERNS = ::T.let(nil, ::T.untyped)
- DEFAULT_REJECT_PATTERNS = ::T.let(nil, ::T.untyped)
- REJECT_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::UncommunicativeModuleName
- ACCEPT_KEY = ::T.let(nil, ::T.untyped)
- DEFAULT_ACCEPT_PATTERNS = ::T.let(nil, ::T.untyped)
- DEFAULT_REJECT_PATTERNS = ::T.let(nil, ::T.untyped)
- REJECT_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::UncommunicativeParameterName
- ACCEPT_KEY = ::T.let(nil, ::T.untyped)
- DEFAULT_ACCEPT_PATTERNS = ::T.let(nil, ::T.untyped)
- DEFAULT_REJECT_PATTERNS = ::T.let(nil, ::T.untyped)
- REJECT_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::UncommunicativeVariableName
- ACCEPT_KEY = ::T.let(nil, ::T.untyped)
- DEFAULT_ACCEPT_SET = ::T.let(nil, ::T.untyped)
- DEFAULT_REJECT_SET = ::T.let(nil, ::T.untyped)
- REJECT_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::SmellDetectors::UtilityFunction
- PUBLIC_METHODS_ONLY_DEFAULT = ::T.let(nil, ::T.untyped)
- PUBLIC_METHODS_ONLY_KEY = ::T.let(nil, ::T.untyped)
-end
-
-class Reek::Source::SourceCode
- IO_IDENTIFIER = ::T.let(nil, ::T.untyped)
- STRING_IDENTIFIER = ::T.let(nil, ::T.untyped)
-end
-
-module Reek::Version
- STRING = ::T.let(nil, ::T.untyped)
-end
-
class Regexp
def match?(*_); end
end
-class Regexp
- def self.union(*_); end
-end
-
class Resolv::DNS
def extract_resources(msg, name, typeclass); end
def fetch_resource(name, typeclass); end
@@ -11920,10 +11437,12 @@
end
class Resolv::DNS::Requester::ConnectedUDP
def initialize(host, port=T.unsafe(nil)); end
+ def lazy_initialize(); end
+
def recv_reply(readable_socks); end
def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end
end
@@ -11979,10 +11498,12 @@
end
class Resolv::DNS::Requester::UnconnectedUDP
def initialize(*nameserver_port); end
+ def lazy_initialize(); end
+
def recv_reply(readable_socks); end
def sender(msg, data, host, port=T.unsafe(nil)); end
end
@@ -12170,12 +11691,10 @@
def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
def self.free_request_id(host, port, id); end
def self.random(arg); end
-
- def self.rangerand(range); end
end
class Resolv::Hosts
def lazy_initialize(); end
end
@@ -12289,26 +11808,33 @@
ONE_CHILD_NODE = ::T.let(nil, ::T.untyped)
SECOND_CHILD_ONLY = ::T.let(nil, ::T.untyped)
end
class RuboCop::CLI
- PHASE_1 = ::T.let(nil, ::T.untyped)
- PHASE_1_DISABLED = ::T.let(nil, ::T.untyped)
- PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped)
- PHASE_2 = ::T.let(nil, ::T.untyped)
STATUS_ERROR = ::T.let(nil, ::T.untyped)
STATUS_INTERRUPTED = ::T.let(nil, ::T.untyped)
STATUS_OFFENSES = ::T.let(nil, ::T.untyped)
STATUS_SUCCESS = ::T.let(nil, ::T.untyped)
end
+class RuboCop::CLI::Command::AutoGenerateConfig
+ PHASE_1 = ::T.let(nil, ::T.untyped)
+ PHASE_1_DISABLED = ::T.let(nil, ::T.untyped)
+ PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped)
+ PHASE_2 = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::CLI::Command::InitDotfile
+ DOTFILE = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::CommentConfig
COMMENT_DIRECTIVE_REGEXP = ::T.let(nil, ::T.untyped)
COPS_PATTERN = ::T.let(nil, ::T.untyped)
COP_NAMES_PATTERN = ::T.let(nil, ::T.untyped)
COP_NAME_PATTERN = ::T.let(nil, ::T.untyped)
- UNNEEDED_DISABLE = ::T.let(nil, ::T.untyped)
+ REDUNDANT_DISABLE = ::T.let(nil, ::T.untyped)
end
class RuboCop::Config
DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped)
end
@@ -12336,15 +11862,11 @@
SPLIT_COPS = ::T.let(nil, ::T.untyped)
end
class RuboCop::ConfigValidator
COMMON_PARAMS = ::T.let(nil, ::T.untyped)
- DEFAULT_RUBY_VERSION = ::T.let(nil, ::T.untyped)
INTERNAL_PARAMS = ::T.let(nil, ::T.untyped)
- KNOWN_RUBIES = ::T.let(nil, ::T.untyped)
- OBSOLETE_RUBIES = ::T.let(nil, ::T.untyped)
- RUBY_VERSION_FILENAME = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::Alignment
SPACE = ::T.let(nil, ::T.untyped)
end
@@ -12440,28 +11962,23 @@
class RuboCop::Cop::Layout::AccessModifierIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::AlignArguments
+class RuboCop::Cop::Layout::ArgumentAlignment
ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::AlignArray
+class RuboCop::Cop::Layout::ArrayAlignment
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::AlignHash
+class RuboCop::Cop::Layout::AssignmentIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::AlignParameters
- ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
- FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
-end
-
class RuboCop::Cop::Layout::BlockAlignment
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::BlockEndNewline
@@ -12576,51 +12093,51 @@
class RuboCop::Cop::Layout::ExtraSpacing
MSG_UNALIGNED_ASGN = ::T.let(nil, ::T.untyped)
MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::FirstArrayElementLineBreak
+class RuboCop::Cop::Layout::FirstArgumentIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::FirstHashElementLineBreak
+class RuboCop::Cop::Layout::FirstArrayElementIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak
+class RuboCop::Cop::Layout::FirstArrayElementLineBreak
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::FirstMethodParameterLineBreak
+class RuboCop::Cop::Layout::FirstHashElementIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis
+class RuboCop::Cop::Layout::FirstHashElementLineBreak
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::IndentAssignment
+class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::IndentFirstArgument
+class RuboCop::Cop::Layout::FirstMethodParameterLineBreak
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::IndentFirstArrayElement
+class RuboCop::Cop::Layout::FirstParameterIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::IndentFirstHashElement
- MSG = ::T.let(nil, ::T.untyped)
+class RuboCop::Cop::Layout::HashAlignment
+ MESSAGES = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::IndentFirstParameter
+class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::IndentHeredoc
+class RuboCop::Cop::Layout::HeredocIndentation
LIBRARY_MSG = ::T.let(nil, ::T.untyped)
RUBY23_TYPE_MSG = ::T.let(nil, ::T.untyped)
RUBY23_WIDTH_MSG = ::T.let(nil, ::T.untyped)
STRIP_METHODS = ::T.let(nil, ::T.untyped)
end
@@ -12635,18 +12152,22 @@
class RuboCop::Cop::Layout::InitialIndentation
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::LeadingBlankLines
+class RuboCop::Cop::Layout::LeadingCommentSpace
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Layout::LeadingCommentSpace
+class RuboCop::Cop::Layout::LeadingEmptyLines
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Layout::LineLength
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Layout::MultilineArrayBraceLayout
ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
@@ -12694,10 +12215,15 @@
ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Layout::ParameterAlignment
+ ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
+ FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Layout::RescueEnsureAlignment
ALTERNATIVE_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped)
ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
@@ -12721,13 +12247,15 @@
end
class RuboCop::Cop::Layout::SpaceAroundKeyword
ACCEPT_LEFT_PAREN = ::T.let(nil, ::T.untyped)
ACCEPT_LEFT_SQUARE_BRACKET = ::T.let(nil, ::T.untyped)
+ ACCEPT_NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped)
DO = ::T.let(nil, ::T.untyped)
MSG_AFTER = ::T.let(nil, ::T.untyped)
MSG_BEFORE = ::T.let(nil, ::T.untyped)
+ NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped)
SAFE_NAVIGATION = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Layout::SpaceAroundOperators
EXCESSIVE_SPACE = ::T.let(nil, ::T.untyped)
@@ -12846,15 +12374,15 @@
class RuboCop::Cop::Lint::DuplicateCaseCondition
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Lint::DuplicateMethods
+class RuboCop::Cop::Lint::DuplicateHashKey
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Lint::DuplicatedKey
+class RuboCop::Cop::Lint::DuplicateMethods
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::EachWithObjectArgument
MSG = ::T.let(nil, ::T.untyped)
@@ -12905,14 +12433,10 @@
MSG = ::T.let(nil, ::T.untyped)
SHOVEL = ::T.let(nil, ::T.untyped)
STRING_TYPES = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Lint::HandleExceptions
- MSG = ::T.let(nil, ::T.untyped)
-end
-
class RuboCop::Cop::Lint::HeredocMethodCallPosition
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::ImplicitStringConcatenation
@@ -12953,11 +12477,11 @@
class RuboCop::Cop::Lint::MissingCopEnableDirective
MSG = ::T.let(nil, ::T.untyped)
MSG_BOUND = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Lint::MultipleCompare
+class RuboCop::Cop::Lint::MultipleComparison
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NestedMethodDefinition
MSG = ::T.let(nil, ::T.untyped)
@@ -12971,10 +12495,14 @@
class RuboCop::Cop::Lint::NextWithoutAccumulator
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Lint::NonDeterministicRequireOrder
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Lint::NonLocalExitFromIterator
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::NumberConversion
@@ -13003,10 +12531,37 @@
class RuboCop::Cop::Lint::RandOne
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Lint::RedundantCopDisableDirective
+ COP_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantCopEnableDirective
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantRequireStatement
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantSplatExpansion
+ ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped)
+ ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+ MSG = ::T.let(nil, ::T.untyped)
+ PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped)
+ PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped)
+ PERCENT_I = ::T.let(nil, ::T.untyped)
+ PERCENT_W = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantStringCoercion
+ MSG_DEFAULT = ::T.let(nil, ::T.untyped)
+ MSG_SELF = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Lint::RedundantWithIndex
MSG_EACH_WITH_INDEX = ::T.let(nil, ::T.untyped)
MSG_WITH_INDEX = ::T.let(nil, ::T.untyped)
end
@@ -13068,13 +12623,12 @@
class RuboCop::Cop::Lint::ShadowingOuterLocalVariable
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Lint::StringConversionInInterpolation
- MSG_DEFAULT = ::T.let(nil, ::T.untyped)
- MSG_SELF = ::T.let(nil, ::T.untyped)
+class RuboCop::Cop::Lint::SuppressedException
+ MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::Syntax
ERROR_SOURCE_RANGE = ::T.let(nil, ::T.untyped)
end
@@ -13089,32 +12643,10 @@
class RuboCop::Cop::Lint::UnifiedInteger
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Lint::UnneededCopDisableDirective
- COP_NAME = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Lint::UnneededCopEnableDirective
- MSG = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Lint::UnneededRequireStatement
- MSG = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Lint::UnneededSplatExpansion
- ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped)
- ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
- MSG = ::T.let(nil, ::T.untyped)
- PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped)
- PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped)
- PERCENT_I = ::T.let(nil, ::T.untyped)
- PERCENT_W = ::T.let(nil, ::T.untyped)
-end
-
class RuboCop::Cop::Lint::UnreachableCode
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Lint::UriEscapeUnescape
@@ -13178,14 +12710,10 @@
class RuboCop::Cop::Metrics::CyclomaticComplexity
COUNTED_NODES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Metrics::LineLength
- MSG = ::T.let(nil, ::T.untyped)
-end
-
class RuboCop::Cop::Metrics::MethodLength
LABEL = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Metrics::ParameterLists
@@ -13201,10 +12729,12 @@
BRANCH_NODES = ::T.let(nil, ::T.untyped)
CONDITION_NODES = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Migration::DepartmentName
+ DISABLE_COMMENT_FORMAT = ::T.let(nil, ::T.untyped)
+ DISABLING_COPS_CONTENT_TOKEN = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
module RuboCop::Cop::MultilineExpressionIndentation
ASSIGNMENT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
@@ -13352,10 +12882,14 @@
class RuboCop::Cop::RSpec::DescribedClass
DESCRIBED_CLASS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::RSpec::DescribedClassModuleWrapping
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::RSpec::Dialect
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::RSpec::EmptyExampleGroup
@@ -13400,10 +12934,11 @@
class RuboCop::Cop::RSpec::ExpectActual
COMPLEX_LITERALS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
SIMPLE_LITERALS = ::T.let(nil, ::T.untyped)
+ SUPPORTED_MATCHERS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::RSpec::ExpectChange
MSG_BLOCK = ::T.let(nil, ::T.untyped)
MSG_CALL = ::T.let(nil, ::T.untyped)
@@ -13429,10 +12964,15 @@
class RuboCop::Cop::RSpec::FactoryBot::CreateList
MSG_CREATE_LIST = ::T.let(nil, ::T.untyped)
MSG_N_TIMES = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName
+ ALLOWED_CONSTANTS = ::T.let(nil, ::T.untyped)
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::RSpec::FilePath
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::RSpec::Focus
@@ -13575,10 +13115,18 @@
class RuboCop::Cop::RSpec::RepeatedExample
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::RSpec::RepeatedExampleGroupBody
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::RSpec::ReturnFromStub
MSG_AND_RETURN = ::T.let(nil, ::T.untyped)
MSG_BLOCK = ::T.let(nil, ::T.untyped)
end
@@ -13710,16 +13258,13 @@
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::BlockDelimiters
ALWAYS_BRACES_MESSAGE = ::T.let(nil, ::T.untyped)
+ BRACES_REQUIRED_MESSAGE = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Style::BracesAroundHashParameters
- MSG = ::T.let(nil, ::T.untyped)
-end
-
class RuboCop::Cop::Style::CaseCorrector
extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
end
@@ -13904,11 +13449,13 @@
class RuboCop::Cop::Style::FormatString
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::FrozenStringLiteralComment
- MSG = ::T.let(nil, ::T.untyped)
+ MSG_DISABLED = ::T.let(nil, ::T.untyped)
+ MSG_MISSING = ::T.let(nil, ::T.untyped)
+ MSG_MISSING_TRUE = ::T.let(nil, ::T.untyped)
MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
SHEBANG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::GlobalVars
@@ -13918,10 +13465,14 @@
class RuboCop::Cop::Style::GuardClause
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Style::HashEachMethods
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Style::HashSyntax
MSG_19 = ::T.let(nil, ::T.untyped)
MSG_HASH_ROCKETS = ::T.let(nil, ::T.untyped)
MSG_NO_MIXED_KEYS = ::T.let(nil, ::T.untyped)
end
@@ -13984,19 +13535,20 @@
METHOD_MESSAGE = ::T.let(nil, ::T.untyped)
OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::LineEndConcatenation
- COMPLEX_STRING_EDGE_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
+ COMPLEX_STRING_BEGIN_TOKEN = ::T.let(nil, ::T.untyped)
+ COMPLEX_STRING_END_TOKEN = ::T.let(nil, ::T.untyped)
CONCAT_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
HIGH_PRECEDENCE_OP_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
QUOTE_DELIMITERS = ::T.let(nil, ::T.untyped)
SIMPLE_STRING_TOKEN_TYPE = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Style::MethodCallWithArgsParentheses
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses
MSG = ::T.let(nil, ::T.untyped)
@@ -14179,10 +13731,19 @@
class RuboCop::Cop::Style::RedundantBegin
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Style::RedundantCapitalW
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantCondition
+ MSG = ::T.let(nil, ::T.untyped)
+ REDUNDANT_CONDITION = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Style::RedundantConditional
COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
@@ -14193,20 +13754,40 @@
class RuboCop::Cop::Style::RedundantFreeze
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Style::RedundantInterpolation
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantPercentQ
+ DYNAMIC_MSG = ::T.let(nil, ::T.untyped)
+ EMPTY = ::T.let(nil, ::T.untyped)
+ ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped)
+ MSG = ::T.let(nil, ::T.untyped)
+ PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped)
+ PERCENT_Q = ::T.let(nil, ::T.untyped)
+ QUOTE = ::T.let(nil, ::T.untyped)
+ SINGLE_QUOTE = ::T.let(nil, ::T.untyped)
+ STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Style::RedundantReturn
MSG = ::T.let(nil, ::T.untyped)
MULTI_RETURN_MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RedundantSelf
KERNEL_METHODS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
end
+class RuboCop::Cop::Style::RedundantSort
+ MSG = ::T.let(nil, ::T.untyped)
+end
+
class RuboCop::Cop::Style::RedundantSortBy
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::RegexpLiteral
@@ -14354,39 +13935,10 @@
class RuboCop::Cop::Style::UnlessElse
MSG = ::T.let(nil, ::T.untyped)
end
-class RuboCop::Cop::Style::UnneededCapitalW
- MSG = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Style::UnneededCondition
- MSG = ::T.let(nil, ::T.untyped)
- UNNEEDED_CONDITION = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Style::UnneededInterpolation
- MSG = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Style::UnneededPercentQ
- DYNAMIC_MSG = ::T.let(nil, ::T.untyped)
- EMPTY = ::T.let(nil, ::T.untyped)
- ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped)
- MSG = ::T.let(nil, ::T.untyped)
- PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped)
- PERCENT_Q = ::T.let(nil, ::T.untyped)
- QUOTE = ::T.let(nil, ::T.untyped)
- SINGLE_QUOTE = ::T.let(nil, ::T.untyped)
- STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cop::Style::UnneededSort
- MSG = ::T.let(nil, ::T.untyped)
-end
-
class RuboCop::Cop::Style::UnpackFirst
MSG = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::VariableInterpolation
@@ -14412,10 +13964,11 @@
class RuboCop::Cop::Style::YodaCondition
EQUALITY_OPERATORS = ::T.let(nil, ::T.untyped)
MSG = ::T.let(nil, ::T.untyped)
NONCOMMUTATIVE_OPERATORS = ::T.let(nil, ::T.untyped)
+ PROGRAM_NAMES = ::T.let(nil, ::T.untyped)
REVERSE_COMPARISON = ::T.let(nil, ::T.untyped)
end
class RuboCop::Cop::Style::ZeroLengthPredicate
NONZERO_MSG = ::T.let(nil, ::T.untyped)
@@ -14640,10 +14193,18 @@
class RuboCop::StringInterpreter
STRING_ESCAPES = ::T.let(nil, ::T.untyped)
STRING_ESCAPE_REGEX = ::T.let(nil, ::T.untyped)
end
+class RuboCop::TargetRuby
+ DEFAULT_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::TargetRuby::RubyVersionFile
+ FILENAME = ::T.let(nil, ::T.untyped)
+end
+
module RuboCop::Version
MSG = ::T.let(nil, ::T.untyped)
STRING = ::T.let(nil, ::T.untyped)
end
@@ -15600,10 +15161,40 @@
module RubyToken
def self.def_token(token_n, super_token=T.unsafe(nil), reading=T.unsafe(nil), *opts); end
end
+module RubyVM::AbstractSyntaxTree
+end
+
+class RubyVM::AbstractSyntaxTree::Node
+ def children(); end
+
+ def first_column(); end
+
+ def first_lineno(); end
+
+ def last_column(); end
+
+ def last_lineno(); end
+
+ def pretty_print_children(q, names=T.unsafe(nil)); end
+
+ def type(); end
+end
+
+class RubyVM::AbstractSyntaxTree::Node
+end
+
+module RubyVM::AbstractSyntaxTree
+ def self.of(_); end
+
+ def self.parse(_); end
+
+ def self.parse_file(_); end
+end
+
class RubyVM::InstructionSequence
def absolute_path(); end
def base_label(); end
@@ -15646,21 +15237,30 @@
def self.load_from_binary_extra_data(_); end
def self.of(_); end
end
+module RubyVM::MJIT
+end
+
+module RubyVM::MJIT
+ def self.enabled?(); end
+
+ def self.pause(*_); end
+
+ def self.resume(); end
+end
+
class RubyVM
+ def self.resolve_feature_path(_); end
+
def self.stat(*_); end
end
ScanError = StringScanner::Error
module SecureRandom
-end
-
-module SecureRandom
- extend ::Random::Formatter
def self.bytes(n); end
end
class Set
def ==(other); end
@@ -15712,10 +15312,15 @@
module SimpleCov
VERSION = ::T.let(nil, ::T.untyped)
end
+module SimpleCov::Configuration
+ DEFAULT_COVERAGE_CRITERION = ::T.let(nil, ::T.untyped)
+ SUPPORTED_COVERAGE_CRITERIA = ::T.let(nil, ::T.untyped)
+end
+
module SimpleCov::ExitCodes
EXCEPTION = ::T.let(nil, ::T.untyped)
MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped)
MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped)
SUCCESS = ::T.let(nil, ::T.untyped)
@@ -15731,12 +15336,12 @@
RELEVANT = ::T.let(nil, ::T.untyped)
WHITESPACE_LINE = ::T.let(nil, ::T.untyped)
WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped)
end
-class SimpleDelegator
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+module SimpleCov::UselessResultsRemover
+ ROOT_REGX = ::T.let(nil, ::T.untyped)
end
module SingleForwardable
def def_delegator(accessor, method, ali=T.unsafe(nil)); end
@@ -16235,10 +15840,12 @@
def self.real_instance_methods(mod, arg); end
def self.real_is_a?(o, klass); end
+ def self.real_method(obj, sym); end
+
def self.real_name(o); end
def self.real_object_id(o); end
def self.real_private_instance_methods(mod, arg); end
@@ -16381,10 +15988,14 @@
def self.interval(); end
def self.interval=(interval); end
+ def self.metadata(); end
+
+ def self.metadata=(metadata); end
+
def self.mode(); end
def self.mode=(mode); end
def self.path(); end
@@ -16546,10 +16157,12 @@
def dig(*_); end
def each_pair(); end
+ def filter(*_); end
+
def length(); end
def members(); end
def select(*_); end
@@ -16569,14 +16182,10 @@
Struct::Passwd = Etc::Passwd
Struct::Tms = Process::Tms
-class SynchronizedDelegator
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-
class SystemCallError
def errno(); end
end
class SystemExit
@@ -16587,11 +16196,10 @@
class Tempfile
def _close(); end
def inspect(); end
- RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end
class Tempfile::Remover
def call(*args); end
@@ -16599,274 +16207,15 @@
end
class Tempfile::Remover
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 Time
include ::DateAndTime::Zones
include ::DateAndTime::Calculations
def acts_like_time?(); end
- def advance(options); end
-
def ago(seconds); end
def at_beginning_of_hour(); end
def at_beginning_of_minute(); end
@@ -16936,10 +16285,11 @@
def since(seconds); end
def to_default_s(); end
def to_formatted_s(format=T.unsafe(nil)); end
+
COMMON_YEAR_DAYS_IN_MONTH = ::T.let(nil, ::T.untyped)
DATE_FORMATS = ::T.let(nil, ::T.untyped)
end
class Time
@@ -16968,18 +16318,23 @@
def self.zone=(time_zone); end
def self.zone_default(); end
def self.zone_default=(zone_default); end
-end
-class Timecop
- VERSION = ::T.let(nil, ::T.untyped)
end
class TracePoint
+ def __enable(_, _1); end
+
+ def eval_script(); end
+
def event(); end
+
+ def instruction_sequence(); end
+
+ def parameters(); end
end
class TrueClass
include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
end
@@ -17013,14 +16368,25 @@
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
+class URI::File
+ def check_password(user); end
+
+ def check_user(user); end
+
+ def check_userinfo(user); end
+
+ def set_userinfo(v); end
+ COMPONENT = ::T.let(nil, ::T.untyped)
+ DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end
+class URI::File
+end
+
class URI::LDAP
def attributes(); end
def attributes=(val); end
@@ -17114,17 +16480,12 @@
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
@@ -17151,55 +16512,33 @@
end
module UnicodeNormalize
end
-module Virtus
- EXTRA_CONST_ARGS = ::T.let(nil, ::T.untyped)
- Undefined = ::T.let(nil, ::T.untyped)
+module Warning
+ def warn(_); end
end
-class Virtus::Attribute::DefaultValue::FromClonable
- SINGLETON_CLASSES = ::T.let(nil, ::T.untyped)
+module Warning
+ extend ::Warning
end
-class Virtus::Attribute::EmbeddedValue
- TYPES = ::T.let(nil, ::T.untyped)
-end
+class WeakRef
+ def initialize(orig); end
-class Virtus::Attribute
- extend ::Virtus::TypeLookup
- extend ::Virtus::Options
+ def weakref_alive?(); end
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)
+class WeakRef::RefError
end
-module Virtus::Extensions::AllowedWriterMethods
- INVALID_WRITER_METHODS = ::T.let(nil, ::T.untyped)
- WRITER_METHOD_REGEXP = ::T.let(nil, ::T.untyped)
+class WeakRef::RefError
end
-module Virtus::TypeLookup
- TYPE_FORMAT = ::T.let(nil, ::T.untyped)
+class WeakRef
end
-Visitor = Psych::Visitors::Visitor
-
-module Warning
- def warn(_); end
-end
-
-module Warning
- extend ::Warning
-end
-
YAML = Psych
-
-YAMLTree = Psych::Visitors::YAMLTree
module Zlib
ASCII = ::T.let(nil, ::T.untyped)
BEST_COMPRESSION = ::T.let(nil, ::T.untyped)
BEST_SPEED = ::T.let(nil, ::T.untyped)