Documentation for ruby/ruby (master)

Alphabetic Index

File Listing

README

Namespace Listing A-Z

Top Level Namespace

A (Gem::Resolv::DNS::Resource::IN)
A (Resolv::DNS::Resource::IN)
AAAA (Resolv::DNS::Resource::IN)
AAAA (Gem::Resolv::DNS::Resource::IN)
AC (OptionParser)
AC (Gem::OptionParser)
ALPN (Gem::Resolv::DNS::SvcParam)
ALPN (Resolv::DNS::SvcParam)
ANSI (Reline)
ANY (Gem::Resolv::DNS::Resource)
ANY (Resolv::DNS::Resource)
API (Win32::Registry)
API (Bundler::Plugin)
API (Win32::SSPI)
APIResponseInvalidDependenciesError (Bundler)
APIResponseMismatchError (Bundler)
APISet (Gem::Resolver)
APISpecification (Gem::Resolver)
ASN1 (OpenSSL)
ASN1Data (OpenSSL::ASN1)
ASN1Error (OpenSSL::ASN1)
Abort (IRB)
AbstractNotifier (IRB::Notifier)
Acceptables (OptionParser)
Acceptables (Gem::OptionParser)
Action (Gem::Molinillo::DependencyGraph)
Actions (Bundler::Thor)
ActivationRequest (Gem::Resolver)
Add (Bundler::CLI)
AddressFamilyError (IPAddr)
Addrinfo
Alias (RDoc)
Alias (Psych::Nodes)
AliasesNotEnabled (Psych)
Alt (Resolv::LOC)
Alt (Gem::Resolv::LOC)
AmbiguousArgument (OptionParser)
AmbiguousArgument (Gem::OptionParser)
AmbiguousCommandError (Bundler::Thor)
AmbiguousGitReference (Bundler::Source::Git)
AmbiguousOption (OptionParser)
AmbiguousOption (Gem::OptionParser)
AnchorNotDefined (Psych)
AncillaryData (Socket)
AnonClass (RDoc)
AnyMethod (RDoc)
Arguable (Gem::OptionParser)
Arguable (OptionParser)
Argument (Bundler::Thor)
Arguments (Bundler::Thor)
AroundBlockScan (SyntaxSuggest)
Array (JSON::Ext::Generator::GeneratorMethods)
Array (Gem::SafeMarshal::Elements)
Array (Bug)
Array (RubyVM::RJIT::CType)
Array
Array (RubyVM::RJIT::CPointer)
Assembler (RubyVM::RJIT)
Assignment (Bundler::PubGrub)
AtLeastOneRequiredArgumentError (Bundler::Thor)
Attr (RDoc)
AttrChanger (RDoc::Markup)
AttrSpan (RDoc::Markup)
Attribute (OpenSSL::X509)
AttributeError (OpenSSL::X509)
AttributeManager (RDoc::Markup)
Attributes (RDoc::Markup)
AuthenticationForbiddenError (Bundler::Fetcher)
AuthenticationRequiredError (Bundler::Fetcher)
AuthorityInfoAccess (OpenSSL::X509::Extension)
AuthorityKeyIdentifier (OpenSSL::X509::Extension)
AvailableSet (Gem)

BN (OpenSSL)
BNError (OpenSSL)
BUNDLED_GEMS (Gem)
Backtrace (IRB::ExtendCommand)
BadAlias (Psych)
BadAuthenticationError (Bundler::Fetcher)
BadRequestResponse (Gem::GemcutterUtilities::WebauthnListener)
BadRequirementError (Gem::Requirement)
BadURIError (Bundler::URI)
BadURIError (URI)
BadURIError (Gem::URI)
Bar (Bug)
Base (Digest)
Base (Bundler::Resolver)
Base (Reline::KeyActor)
Base (Bundler::CLI::Config)
Base (Bundler::Thor)
Base (Bundler::Fetcher)
BaseCompletor (IRB)
Basic (Bundler::Thor::Shell)
Basic (Bundler::Thor::LineEditor)
BasicPackageSource (Bundler::PubGrub)
BasicResponse (OpenSSL::OCSP)
BasicSocket
BasicSpecification (Gem)
BasicTypes (Fiddle)
BeforeAfterKeywordEnds (SyntaxSuggest::Capture)
Benchmark
BestSet (Gem::Resolver)
BigDecimal
Bignum (Bug)
Bignum (Gem::SafeMarshal::Elements)
Bignum (JSON::Ext::Generator::GeneratorMethods)
Binding
Binstubs (Bundler::CLI)
BitField (RubyVM::RJIT::CType)
BitField (RubyVM::RJIT::CPointer)
BlankLine (RDoc::Markup)
Block (RubyVM::RJIT)
BlockCaller (Fiddle::Closure)
BlockExpand (SyntaxSuggest)
BlockParser (RDoc::RD)
BlockQuote (RDoc::Markup)
Bool (RubyVM::RJIT::CPointer)
Bool (RubyVM::RJIT::CType)
BoundedStream (Gem::Package::TarWriter)
BranchStub (RubyVM::RJIT)
BranchTarget (RubyVM::RJIT)
Break (IRB::ExtendCommand)
Breakable (PrettyPrint)
Breakable (Bug::Float)
BufError (Zlib)
Buffer (ERB::Compiler)
Buffer (OpenURI)
Buffer (OpenSSL::Buffering)
BufferedIO (Net)
BufferedIO (Gem::Net)
Buffering (OpenSSL)
Bug
BuildCommand (Gem::Commands)
BuildError (Gem::Ext)
BuildMetadata (Bundler)
Builder (Gem::Ext)
Bundler
BundlerError (Bundler)
BundlerVersionFinder (Gem)
BytePtr (RubyVM::RJIT)

C (RDoc::Parser)
CGI
CIDetector (Bundler)
CIDetector (Gem)
CLI (Bundler)
CNAME (Gem::Resolv::DNS::Resource)
CNAME (Resolv::DNS::Resource)
CParser (Fiddle)
CPointer (RubyVM::RJIT)
CRCError (Zlib::GzipFile)
CRL (OpenSSL::X509)
CRLDistributionPoints (OpenSSL::X509::Extension)
CRLError (OpenSSL::X509)
CStruct (Fiddle)
CStructBuilder (Fiddle)
CStructEntity (Fiddle)
CType (RubyVM::RJIT)
CUnion (Fiddle)
CUnionEntity (Fiddle)
Cache (Bundler::CompactIndexClient)
Cache (Bundler::CLI)
CacheFile (Bundler::CompactIndexClient)
Candidate (Bundler::Resolver)
CantChangeBinding (IRB)
CantReturnToNormalMode (IRB)
Canvas (IRB)
CapturableERB (Bundler::Thor::Actions)
Capture (SyntaxSuggest)
CaptureCodeContext (SyntaxSuggest)
CargoBuilder (Gem::Ext)
Catch (IRB::ExtendCommand)
CertCommand (Gem::Commands)
Certificate (OpenSSL::X509)
CertificateError (OpenSSL::X509)
CertificateFailureError (Bundler::Fetcher)
CertificateId (OpenSSL::OCSP)
ChangeLog (RDoc::Parser)
ChangeWorkspace (IRB::ExtendCommand)
Check (Bundler::CLI)
CheckCommand (Gem::Commands)
Checksum (Bundler)
ChecksumMismatchError (Bundler)
ChildExited (PTY)
Chunker (Net::HTTPGenericRequest)
Chunker (Gem::Net::HTTPGenericRequest)
Cipher (OpenSSL)
Cipher (OpenSSL::Cipher)
CipherError (OpenSSL::Cipher)
CircularDatastructure (JSON)
CircularDependencyError (Gem::Molinillo)
Class (Bug)
Class (Digest)
Class
ClassLoader (Psych)
ClassMethods (OpenSSL::Marshal)
ClassMethods (Bundler::Thor::Invocation)
ClassMethods (Psych::Streaming)
ClassMethods (Bundler::Thor::Base)
ClassMethods (Bundler::Thor::Actions)
ClassModule (RDoc)
ClassNameChecker (DidYouMean)
Clean (Bundler::CLI)
CleanDocument (SyntaxSuggest)
CleanupCommand (Gem::Commands)
ClearedReferenceError (Fiddle)
Cli (SyntaxSuggest)
ClientFetcher (Bundler::Fetcher::CompactIndex)
ClosedError (Bundler::CompactIndexClient::CacheFile)
Closer (Tempfile)
Closure (Fiddle)
CmakeBuilder (Gem::Ext)
CodeBlock (SyntaxSuggest)
CodeBlock (RubyVM::RJIT)
CodeFrontier (SyntaxSuggest)
CodeLine (SyntaxSuggest)
CodeObject (RDoc)
CodeSearch (SyntaxSuggest)
Coder (Psych)
Color (Bundler::Thor::Shell)
Color (IRB)
ColorPrinter (IRB)
ColumnPrinter (Bundler::Thor::Shell)
Command (IRB::Statement)
Command (Bundler::Thor)
Command (Gem)
CommandArgumentError (IRB::ExtendCommand)
CommandConflict (Bundler::Plugin::Index)
CommandLineError (Gem)
CommandManager (Gem)
Commands (Gem)
Comment (Prism)
Comment (RDoc)
Common (Bundler::CLI)
CompactIndex (Bundler::Fetcher)
CompactIndexClient (Bundler)
CompilationError (Prism::Pattern)
CompilationError (Prism::Translation::Parser::Compiler)
CompileError (Ripper::TokenPattern)
Compiler (ERB)
Compiler (RubyVM::RJIT)
CompletingHash (OptionParser)
CompletingHash (Gem::OptionParser)
Completion (Gem::OptionParser)
Completion (OptionParser)
CompletionJourneyData (Reline::LineEditor)
CompletionState (Reline::LineEditor)
Complex
ComposedSet (Gem::Resolver)
CompositeHandler (Fiddle)
CompositeNotifier (IRB::Notifier)
ConditionVariable (MonitorMixin)
Config (Gem::Resolv::DNS)
Config (Bundler::CLI)
Config (Reline)
Config (Resolv::DNS)
Config (Psych)
Config (OpenSSL)
ConfigEncodingConversionError (Reline)
ConfigError (OpenSSL)
ConfigFile (Gem)
ConfigurationError (Gem::S3URISigner)
ConfigureBuilder (Gem::Ext)
Conflict (Gem::Resolver)
Conflict (Gem::Molinillo::Resolver::Resolution)
ConflictCause (Bundler::PubGrub::Incompatibility)
ConflictError (Gem)
ConnectedUDP (Gem::Resolv::DNS::Requester)
ConnectedUDP (Resolv::DNS::Requester)
Connection (Gem::Net::HTTP::Persistent)
ConnectionPool (Bundler)
ConnectionPools (Gem::Request)
Console (Bundler::CLI)
ConsoleMode (IO)
ConsoleUI (Gem)
Constant (RDoc)
ConstantPathNode (Prism)
ConstantPathTargetNode (Prism)
ConstantReadNode (Prism)
Constants (Win32::Registry)
Constructive (OpenSSL::ASN1)
ContentsCommand (Gem::Commands)
Context (RDoc)
Context (RubyVM::RJIT)
Context (IRB)
ContextExtender (IRB)
Continue (IRB::ExtendCommand)
Cookie (CGI)
Coord (Resolv::LOC)
Coord (Gem::Resolv::LOC)
Copy (Gem::Net::HTTP)
Copy (Net::HTTP)
Core (Reline)
CoreExt (Bundler::Thor)
CoreExt (ErrorHighlight)
CoreExtensions
CorrectHashForLambdaOperator (Gem::Requirement)
Correctable (DidYouMean)
Coverage
CreateFile (Bundler::Thor::Actions)
CreateLink (Bundler::Thor::Actions)
CrossReference (RDoc)
CurrentRuby (Bundler)
CurrentSet (Gem::Resolver)
CurrentWorkingWorkspace (IRB::ExtendCommand)
CursorPos (Reline)
Cyclic (Gem::TSort)
Cyclic (Bundler::TSort)
Cyclic (TSort)
CyclicDependencyError (Bundler)

DBM (YAML)
DH (OpenSSL::PKey)
DHError (OpenSSL::PKey)
DLError (Fiddle)
DNS (Gem::Resolv)
DNS (Resolv)
DSA (OpenSSL::PKey)
DSAError (OpenSSL::PKey)
DSL
DSL (Bundler::Plugin)
DSL (Bundler::PubGrub::StaticPackageSource)
DSLError (Bundler::Dsl)
Darkfish (RDoc::Generator)
DashHeredoc (Prism::LexCompat::Heredoc)
Data
DataError (Zlib)
DataError (Bug::Array)
Date
DateTime
Debug (IRB::ExtendCommand)
Debug (Bug)
Debug (IRB)
DebugCommand (IRB::ExtendCommand)
DecodeError (Gem::Resolv::DNS)
DecodeError (Resolv::DNS)
DedentingHeredoc (Prism::LexCompat::Heredoc)
DefMethod (ERB)
DefaultFormatter (ErrorHighlight)
DefaultUserInteraction (Gem)
Definition (Bundler)
Deflate (Zlib)
Delegator
Delete (Net::HTTP)
Delete (Gem::Net::HTTP)
Delete (IRB::ExtendCommand)
Dependency (Bundler::Fetcher)
Dependency (Gem)
Dependency (Bundler)
DependencyCommand (Gem::Commands)
DependencyError (Gem)
DependencyGraph (Gem::Molinillo)
DependencyInstaller (Gem)
DependencyList (Gem)
DependencyRemovalException (Gem)
DependencyRequest (Gem::Resolver)
DependencyResolutionError (Gem)
DependencyState (Gem::Molinillo)
Deployment (Bundler)
Deprecate (Bundler)
Deprecate (Gem)
DeprecatedError (Bundler)
DepthFirst (Psych::Visitors)
DesugarCompiler (Prism)
Diagnostic (Prism::Translation::Parser)
Dialog (Reline::LineEditor)
DialogProc (Reline::Core)
DialogProcScope (Reline::LineEditor)
DialogRenderInfo (Reline)
DidYouMean
Digest (Bundler)
Digest (OpenSSL::Digest)
Digest (OpenSSL)
Digest
DigestError (Digest)
DigestError (OpenSSL::Digest)
DigestIO (Gem::Package)
DigestMismatchError (Bundler::CompactIndexClient::CacheFile)
Dir
Directive (Prism::Pack)
Directory (Bundler::Thor::Actions)
DirectoryRemovalError (Bundler)
DisallowedClass (Psych)
DisplayCodeWithLineNumbers (SyntaxSuggest)
DisplayInvalidBlocks (SyntaxSuggest)
DoHPath (Gem::Resolv::DNS::SvcParam)
DoHPath (Resolv::DNS::SvcParam)
Doctor (Bundler::CLI)
Doctor (Gem)
Document (Psych::Nodes)
Document (RDoc::Markup)
DocumentError (Gem)
DocumentStream (Psych::Handlers)
DomainName (Gem::Resolv::DNS::Resource)
DomainName (Resolv::DNS::Resource)
Downloader (Bundler::Fetcher)
Driver (RDoc::RI)
DryRun (Bundler::FileUtils)
DryRun (FileUtils)
Dsl (Bundler)
DumperOptions (Psych::Handler)
DwordPtr (RubyVM::RJIT)
DylibNotFoundError (Gem::Ext::CargoBuilder)
DynamicCommand (Bundler::Thor)
DynamicPartsInConstantPathError (Prism::ConstantPathNode)

EC (OpenSSL::PKey)
ECError (OpenSSL::PKey)
ENV
EOFError (Gem::SafeMarshal::Reader)
ERB
ERBIO (RDoc)
ERBPartial (RDoc)
EastAsianWidth (Reline::Unicode)
Edge (Gem::Molinillo::DependencyGraph)
Edit (IRB::ExtendCommand)
Elem (Ripper::Lexer)
Element (Gem::SafeMarshal::Elements)
Elements (Gem::SafeMarshal)
Emacs (Reline::KeyActor)
EmbDocComment (Prism)
Emitter (Psych::JSON::Stream)
Emitter (Psych)
Emitter (Psych::Visitors)
Emitter (Psych::Stream)
Empty (Bundler::PubGrub::VersionRange)
EmptyDirectory (Bundler::Thor::Actions)
EncodeError (Resolv::DNS)
EncodeError (Gem::Resolv::DNS)
Encoding (RDoc)
EndContentToken (Prism::LexCompat)
EndOfYAMLException (Gem)
EndpointSpecification (Bundler)
Engine (OpenSSL)
EngineError (OpenSSL::Engine)
English
Entry (Gem::Package::TarReader)
EntryStub (RubyVM::RJIT)
Entry_ (FileUtils)
Entry_ (Bundler::FileUtils)
Enumerable
EnumeratorKw (Bug)
Env (Bundler)
EnvironmentCommand (Gem::Commands)
EnvironmentPreserver (Bundler)
ErrUndefinedNotifier (IRB::Notifier)
ErrUnrecognizedLevel (IRB::Notifier)
Error (Ripper::TokenPattern)
Error (Zlib::GzipFile)
Error (Date)
Error (RDoc::RI::Driver)
Error (Bundler::URI)
Error (Bundler::ConnectionPool)
Error (Gem::Net::HTTP::Persistent)
Error (Logger)
Error (Gem::Timeout)
Error (RDoc::Markup::Parser)
Error (Bundler::CompactIndexClient)
Error (Zlib)
Error (Gem::SafeMarshal::Reader)
Error (Fiddle)
Error (Gem::URI)
Error (RDoc::Store)
Error (URI)
Error (Win32::Registry)
Error (SyntaxSuggest)
Error (RDoc::RI)
Error (Timeout)
Error (StringScanner)
Error (Bundler::CompactIndexClient::CacheFile)
Error (OpenSSL::PKey::EC::Group)
Error (Gem::SafeMarshal::Visitors::ToRuby)
Error (PStore)
Error (Bundler::Thor)
Error (IPAddr)
Error (RDoc)
Error (OpenSSL::PKey::EC::Point)
Error (Gem::Package)
ErrorData (Gem::Validator)
ErrorHighlight
ErrorReason (Gem)
Escape (CGI)
Escape (ERB)
Etc
EvalHistory (IRB)
Event (WIN32OLE)
Events (Bundler::Plugin)
Exception (Bug)
Exception (Gem::Security)
Exception (Psych)
Exception (Gem)
Exception
ExclusiveArgumentError (Bundler::Thor)
Exec (Bundler::CLI)
ExecCommand (Gem::Commands)
Exit (IRB::ExtendCommand)
ExitException (Gem::Timeout)
ExitException (Timeout)
ExplainSyntax (SyntaxSuggest)
ExportableString (MemoryViewTestUtils)
Expression (IRB::Statement)
Ext (JSON)
Ext (Gem)
ExtConfBuilder (Gem::Ext)
Extend (JSON::Ext::Generator::GeneratorMethods::String)
Extend (RDoc)
ExtendCommand (IRB)
ExtendCommandBundle (IRB)
Extension (OpenSSL::X509)
ExtensionError (OpenSSL::X509)
ExtensionFactory (OpenSSL::X509)

FTP (Bundler::URI)
FTP (URI)
FTP (Gem::URI)
Face (Reline)
Factory (OpenSSL::Timestamp)
FailureWriter (Bundler::PubGrub)
FakePackage (Gem::Installer)
FallbackError (Bundler::Fetcher)
FallingIndentLines (SyntaxSuggest::Capture)
False (Gem::SafeMarshal::Elements)
FalseClass (JSON::Ext::Generator::GeneratorMethods)
Fcntl
FeatureFlag (Bundler)
FetchCommand (Gem::Commands)
FetchError (Gem::RemoteFetcher)
FetchMetadata (Bundler)
Fetcher (Bundler)
Fiddle
File (Bug)
File (Gem::URI)
File (URI)
File (Bundler::URI)
File
FileInputMethod (IRB)
FileOverflow (Gem::Package::TarWriter)
FilePermissionError (Gem)
FileSource (Gem::Package)
FileStore (CGI::Session)
FileUtils
FileUtils (Bundler)
Filter (Ripper)
Find
Finish (IRB::ExtendCommand)
Fixnum (JSON::Ext::Generator::GeneratorMethods)
Float (JSON::Ext::Generator::GeneratorMethods)
Float (Bug)
Float (Gem::SafeMarshal::Elements)
FloatNode (Prism)
ForcePlatform (Bundler)
Foreground (IRB::ExtendCommand)
ForkTracker (Bundler::ConnectionPool)
Format (Prism::Pack)
FormatError (Gem::SafeMarshal::Visitors::ToRuby)
FormatError (Gem::Package)
FormatException (Gem)
Formatter (Logger)
Formatter (RDoc::RI)
Formatter (DidYouMean)
Formatter (Random)
Formatter (RDoc::Markup)
Forwardable
Frame (IRB)
FrameOverflow (IRB::Frame)
FrameUnderflow (IRB::Frame)
FriendlyErrors (Bundler)
Function (Fiddle)
Fund (Bundler::CLI)

Gem (Bundler::CLI)
Gem
GemDependencyAPI (Gem::RequestSet)
GemHelper (Bundler)
GemHelpers (Bundler)
GemInstaller (Bundler)
GemNotFound (Bundler)
GemNotFoundException (Gem)
GemNotInHomeException (Gem)
GemParser (Gem::Resolver::APISet)
GemParser (Bundler::CompactIndexClient)
GemRemoteFetcher (Bundler::Fetcher)
GemRequireError (Bundler)
GemRunner (Gem)
GemVersionPromoter (Bundler)
GemcutterUtilities (Gem)
GemfileError (Bundler)
GemfileEvalError (Bundler)
GemfileLockNotFound (Bundler)
GemfileNotFound (Bundler)
Gemspec (Bundler::Source)
GemspecError (Bundler)
GeneralIO (Reline)
GenerateIndexCommand (Gem::Commands)
Generator (RDoc)
Generator (JSON::Ext)
GeneratorError (JSON)
GeneratorMethods (JSON::Ext::Generator)
Generic (Gem::Resolv::DNS::SvcParam)
Generic (Bundler::URI)
Generic (URI)
Generic (Gem::Resolv::DNS::Resource)
Generic (Resolv::DNS::Resource)
Generic (Resolv::DNS::SvcParam)
Generic (Gem::URI)
GenericObject (JSON)
GenericSystemCallError (Bundler)
Get (Gem::Net::HTTP)
Get (Net::HTTP)
GetParseErrors (SyntaxSuggest)
GhostMethod (RDoc)
Git (Gem::Source)
Git (RDoc::Parser::ChangeLog)
Git (Bundler::Plugin::Installer)
Git (Bundler::Source)
GitCommandError (Bundler::Source::Git)
GitError (Bundler)
GitNotAllowedError (Bundler::Source::Git)
GitNotInstalledError (Bundler::Source::Git)
GitProxy (Bundler::Source::Git)
GitSet (Gem::Resolver)
GitSpecification (Gem::Resolver)
Graph (Bundler)
GraphVizClient (Bundler::Graph)
Group (Etc)
Group (Bundler::Thor)
Group (PrettyPrint)
Group (OpenSSL::PKey::EC)
GroupQueue (PrettyPrint)
GzipFile (Zlib)
GzipReader (Zlib)
GzipWriter (Zlib)
generic_readable (IO)
generic_writable (IO)

HINFO (Gem::Resolv::DNS::Resource)
HINFO (Resolv::DNS::Resource)
HMAC (OpenSSL)
HMACError (OpenSSL)
HTML (Bundler::Thor::Shell)
HTML3 (CGI)
HTML4 (CGI)
HTML4Fr (CGI)
HTML4Tr (CGI)
HTML5 (CGI)
HTTP (Bundler::URI)
HTTP (Gem::URI)
HTTP (Gem::Net)
HTTP (URI)
HTTP (Net)
HTTP (Bundler::Persistent::Net)
HTTPAccepted (Net)
HTTPAccepted (Gem::Net)
HTTPAlreadyReported (Gem::Net)
HTTPAlreadyReported (Net)
HTTPBadGateway (Gem::Net)
HTTPBadGateway (Net)
HTTPBadRequest (Net)
HTTPBadRequest (Gem::Net)
HTTPBadResponse (Gem::Net)
HTTPBadResponse (Net)
HTTPClientError (Net)
HTTPClientError (Gem::Net)
HTTPClientException (Gem::Net)
HTTPClientException (Net)
HTTPConflict (Gem::Net)
HTTPConflict (Net)
HTTPContinue (Net)
HTTPContinue (Gem::Net)
HTTPCreated (Gem::Net)
HTTPCreated (Net)
HTTPEarlyHints (Gem::Net)
HTTPEarlyHints (Net)
HTTPError (Gem::Net)
HTTPError (Bundler)
HTTPError (OpenURI)
HTTPError (Net)
HTTPExceptions (Gem::Net)
HTTPExceptions (Net)
HTTPExpectationFailed (Gem::Net)
HTTPExpectationFailed (Net)
HTTPFailedDependency (Gem::Net)
HTTPFailedDependency (Net)
HTTPFatalError (Gem::Net)
HTTPFatalError (Net)
HTTPForbidden (Net)
HTTPForbidden (Gem::Net)
HTTPFound (Gem::Net)
HTTPFound (Net)
HTTPGatewayTimeout (Net)
HTTPGatewayTimeout (Gem::Net)
HTTPGenericRequest (Gem::Net)
HTTPGenericRequest (Net)
HTTPGone (Net)
HTTPGone (Gem::Net)
HTTPHeader (Gem::Net)
HTTPHeader (Net)
HTTPHeaderSyntaxError (Gem::Net)
HTTPHeaderSyntaxError (Net)
HTTPIMUsed (Gem::Net)
HTTPIMUsed (Net)
HTTPInformation (Gem::Net)
HTTPInformation (Net)
HTTPInsufficientStorage (Gem::Net)
HTTPInsufficientStorage (Net)
HTTPInternalServerError (Gem::Net)
HTTPInternalServerError (Net)
HTTPLengthRequired (Gem::Net)
HTTPLengthRequired (Net)
HTTPLocked (Gem::Net)
HTTPLocked (Net)
HTTPLoopDetected (Net)
HTTPLoopDetected (Gem::Net)
HTTPMethodNotAllowed (Gem::Net)
HTTPMethodNotAllowed (Net)
HTTPMisdirectedRequest (Gem::Net)
HTTPMisdirectedRequest (Net)
HTTPMovedPermanently (Net)
HTTPMovedPermanently (Gem::Net)
HTTPMultiStatus (Gem::Net)
HTTPMultiStatus (Net)
HTTPMultipleChoices (Gem::Net)
HTTPMultipleChoices (Net)
HTTPNetworkAuthenticationRequired (Gem::Net)
HTTPNetworkAuthenticationRequired (Net)
HTTPNoContent (Gem::Net)
HTTPNoContent (Net)
HTTPNonAuthoritativeInformation (Gem::Net)
HTTPNonAuthoritativeInformation (Net)
HTTPNotAcceptable (Net)
HTTPNotAcceptable (Gem::Net)
HTTPNotExtended (Gem::Net)
HTTPNotExtended (Net)
HTTPNotFound (Gem::Net)
HTTPNotFound (Net)
HTTPNotImplemented (Gem::Net)
HTTPNotImplemented (Net)
HTTPNotModified (Gem::Net)
HTTPNotModified (Net)
HTTPOK (Net)
HTTPOK (Gem::Net)
HTTPPartialContent (Gem::Net)
HTTPPartialContent (Net)
HTTPPayloadTooLarge (Gem::Net)
HTTPPayloadTooLarge (Net)
HTTPPaymentRequired (Net)
HTTPPaymentRequired (Gem::Net)
HTTPPermanentRedirect (Gem::Net)
HTTPPermanentRedirect (Net)
HTTPPool (Gem::Request)
HTTPPreconditionFailed (Net)
HTTPPreconditionFailed (Gem::Net)
HTTPPreconditionRequired (Net)
HTTPPreconditionRequired (Gem::Net)
HTTPProcessing (Gem::Net)
HTTPProcessing (Net)
HTTPProxyAuthenticationRequired (Net)
HTTPProxyAuthenticationRequired (Gem::Net)
HTTPRangeNotSatisfiable (Net)
HTTPRangeNotSatisfiable (Gem::Net)
HTTPRedirect (OpenURI)
HTTPRedirection (Net)
HTTPRedirection (Gem::Net)
HTTPRequest (Gem::Net)
HTTPRequest (Net)
HTTPRequestHeaderFieldsTooLarge (Net)
HTTPRequestHeaderFieldsTooLarge (Gem::Net)
HTTPRequestTimeout (Net)
HTTPRequestTimeout (Gem::Net)
HTTPResetContent (Net)
HTTPResetContent (Gem::Net)
HTTPResponse (Net)
HTTPResponse (Gem::Net)
HTTPRetriableError (Net)
HTTPRetriableError (Gem::Net)
HTTPS (Gem::Resolv::DNS::Resource::IN)
HTTPS (Bundler::URI)
HTTPS (URI)
HTTPS (Gem::URI)
HTTPS (Resolv::DNS::Resource::IN)
HTTPSPool (Gem::Request)
HTTPSeeOther (Net)
HTTPSeeOther (Gem::Net)
HTTPServerError (Net)
HTTPServerError (Gem::Net)
HTTPServiceUnavailable (Gem::Net)
HTTPServiceUnavailable (Net)
HTTPSuccess (Net)
HTTPSuccess (Gem::Net)
HTTPSwitchProtocol (Gem::Net)
HTTPSwitchProtocol (Net)
HTTPTemporaryRedirect (Net)
HTTPTemporaryRedirect (Gem::Net)
HTTPTooManyRequests (Net)
HTTPTooManyRequests (Gem::Net)
HTTPURITooLong (Net)
HTTPURITooLong (Gem::Net)
HTTPUnauthorized (Gem::Net)
HTTPUnauthorized (Net)
HTTPUnavailableForLegalReasons (Net)
HTTPUnavailableForLegalReasons (Gem::Net)
HTTPUnknownResponse (Net)
HTTPUnknownResponse (Gem::Net)
HTTPUnprocessableEntity (Net)
HTTPUnprocessableEntity (Gem::Net)
HTTPUnsupportedMediaType (Net)
HTTPUnsupportedMediaType (Gem::Net)
HTTPUpgradeRequired (Net)
HTTPUpgradeRequired (Gem::Net)
HTTPUseProxy (Net)
HTTPUseProxy (Gem::Net)
HTTPVariantAlsoNegotiates (Gem::Net)
HTTPVariantAlsoNegotiates (Net)
HTTPVersionNotSupported (Net)
HTTPVersionNotSupported (Gem::Net)
Handle (Fiddle)
Handler (Psych)
Handlers (Psych)
HardBreak (RDoc::Markup)
Hash (Bug)
Hash (JSON::Ext::Generator::GeneratorMethods)
Hash (Gem::SafeMarshal::Elements)
Hash
HashWithDefaultValue (Gem::SafeMarshal::Elements)
HashWithIndifferentAccess (Bundler::Thor::CoreExt)
Head (Net::HTTP)
Head (Gem::Net::HTTP)
Help (IRB::ExtendCommand)
HelpCommand (Gem::Commands)
Helpers (OpenSSL::X509::Extension)
HiddenCommand (Bundler::Thor)
History (IRB::ExtendCommand)
History (Reline)
HistorySavingAbility (IRB)
Hooks (RubyVM::RJIT)
Hosts (Resolv)
Hosts (Gem::Resolv)
Html3 (CGI)
Html4 (CGI)
Html4Fr (CGI)
Html4Tr (CGI)
Html5 (CGI)
HtmlExtension (CGI)

I18n (RDoc)
IN (Gem::Resolv::DNS::Resource)
IN (Resolv::DNS::Resource)
IO
IOSource (Gem::Package)
IPAddr
IPSocket
IPv4 (Resolv)
IPv4 (Gem::Resolv)
IPv4Hint (Gem::Resolv::DNS::SvcParam)
IPv4Hint (Resolv::DNS::SvcParam)
IPv6 (Gem::Resolv)
IPv6 (Resolv)
IPv6Hint (Gem::Resolv::DNS::SvcParam)
IPv6Hint (Resolv::DNS::SvcParam)
IRB
IdentToken (Prism::LexCompat)
Identity (Win32::SSPI)
Ifaddr (Socket)
IgnoreStateToken (Prism::LexCompat)
IgnoredNewlineToken (Prism::LexCompat)
IllegalParameter (IRB)
IllegalRCGenerator (IRB)
ImaginaryNode (Prism)
Immediate (RubyVM::RJIT::CType)
Immediate (RubyVM::RJIT::CPointer)
Importer (Fiddle)
ImpossibleDependenciesError (Gem)
InProgressError (Zlib)
Include (RDoc::Markup)
Include (RDoc)
Incompatibility (Bundler::PubGrub)
Incompatibility (Bundler::Resolver)
IndentedParagraph (RDoc::Markup)
Index (Bundler::Fetcher)
Index (Bundler::Plugin)
Index (Bundler)
IndexSet (Gem::Resolver)
IndexSpecification (Gem::Resolver)
Infinity (Date)
Inflate (Zlib)
Inflater (Gem::Net::HTTPResponse)
Inflater (Net::HTTPResponse)
Info (Bundler::CLI)
Info (IRB::ExtendCommand)
InfoCommand (Gem::Commands)
Init (Bundler::CLI)
Initializer (CoreExtensions::TCPSocketExt)
Inject (Bundler::CLI)
InjectIntoFile (Bundler::Thor::Actions)
Injector (Bundler)
Inline (RDoc::RD)
InlineComment (Prism)
InlineParser (RDoc::RD)
InlineTag (RDoc::Markup::Formatter)
InnerStateLex (RDoc::Parser::RipperStateLex)
InputCompletor (IRB)
InputMethod (IRB)
InsecureInstallPathError (Bundler)
Inspector (IRB)
Install (Bundler::CLI)
InstallCommand (Gem::Commands)
InstallError (Gem)
InstallError (Bundler)
InstallHookError (Bundler)
InstallUpdateOptions (Gem)
Installed (Gem::Source)
InstalledSpecification (Gem::Resolver)
Installer (Gem)
Installer (Bundler)
Installer (Bundler::Source::Path)
Installer (Bundler::Plugin)
InstallerSet (Gem::Resolver)
InstallerUninstallerUtils (Gem)
Instance (Digest)
InstanceProfileError (Gem::S3URISigner)
Integer (Gem::SafeMarshal::Elements)
Integer
Integer (JSON::Ext::Generator::GeneratorMethods)
Integer (Bug)
IntegerNode (Prism)
InternalObjectWrapper (ObjectSpace)
InternetMessageIO (Gem::Net)
InternetMessageIO (Net)
InterpolatedMatchLastLineNode (Prism)
InterpolatedRegularExpressionNode (Prism)
InterpolatedStringNode (Prism)
InterpolatedXStringNode (Prism)
InvalidAddressError (IPAddr)
InvalidArgument (Gem::OptionParser)
InvalidArgument (OptionParser)
InvalidComponentError (Gem::URI)
InvalidComponentError (Bundler::URI)
InvalidComponentError (URI)
InvalidDependency (Bundler::PubGrub::Incompatibility)
InvalidEncoding (CGI)
InvalidInputrc (Reline::Config)
InvalidOption (Gem::OptionParser)
InvalidOption (Bundler)
InvalidOption (OptionParser)
InvalidPrefixError (IPAddr)
InvalidSpecificationException (Gem)
InvalidURIError (Bundler::URI)
InvalidURIError (Gem::URI)
InvalidURIError (URI)
Invariants (RubyVM::RJIT)
Invocation (Bundler::Thor)
InvocationError (Bundler::Thor)
Irb (IRB)
IrbAlreadyDead (IRB)
IrbCommand (IRB::ExtendCommand)
IrbInfo (IRB::ExtendCommand)
IrbLoader (IRB)
IrbSwitchedToCurrentThread (IRB)
Issue (Bundler::CLI)
Iter (Bug)

JITState (RubyVM::RJIT)
JSON (Psych)
JSON
JSONError (JSON)
JSONTree (Psych::Visitors)
Jaro (DidYouMean)
JaroWinkler (DidYouMean)
Job (Benchmark)
JobManager (IRB)
Jobs (IRB::ExtendCommand)
JsonIndex (RDoc::Generator)

KDF (OpenSSL)
KDFError (OpenSSL::KDF)
Kernel
Kernel32 (Win32::Registry::Error)
Key (Reline)
KeyActor (Reline)
KeyErrorChecker (DidYouMean)
KeyEventRecord (Reline::Windows)
KeyStroke (Reline)
Kill (IRB::ExtendCommand)
KillRing (Reline)
KpegPosInfo (RDoc::Markdown)
KpegPosInfo (RDoc::Markdown::Literals)

LDAP (Bundler::URI)
LDAP (URI)
LDAP (Gem::URI)
LDAPS (Gem::URI)
LDAPS (URI)
LDAPS (Bundler::URI)
LOC (Gem::Resolv)
LOC (Resolv::DNS::Resource)
LOC (Resolv)
LOC (Gem::Resolv::DNS::Resource)
Label (Resolv::DNS)
Label (RubyVM::RJIT::Assembler)
Label (Gem::Resolv::DNS)
LazySpecification (Bundler)
LeftRightLexCount (SyntaxSuggest)
LengthError (Zlib::GzipFile)
LeveledNotifier (IRB::Notifier)
Levenshtein (DidYouMean)
LexAll (SyntaxSuggest)
LexValue (SyntaxSuggest)
Lexer (Ripper)
Licenses (Gem)
LineEditor (Bundler::Thor)
LineEditor (Reline)
LinkFlagConverter (Gem::Ext::CargoBuilder)
List (Gem)
List (RDoc::Markup)
List (Gem::OptionParser)
List (Bundler::CLI)
List (OptionParser)
ListCommand (Gem::Commands)
ListItem (RDoc::Markup)
Literals (RDoc::Markdown)
Load (IRB::ExtendCommand)
LoadAbort (IRB)
LoadError (Gem)
LoadError
LoaderCommand (IRB::ExtendCommand)
Local (Gem::Source)
LocalRemoteOptions (Gem)
LocalSpecification (Gem::Resolver)
Locale (RDoc::I18n)
Locale (IRB)
Location (Prism)
LocationTarget (Prism::ParseResult::Comments)
Lock (Gem::Source)
Lock (Net::HTTP)
Lock (Gem::Net::HTTP)
Lock (Bundler::CLI)
LockCommand (Gem::Commands)
LockSet (Gem::Resolver)
LockSpecification (Gem::Resolver)
Lockfile (Gem::RequestSet)
LockfileError (Bundler)
LockfileGenerator (Bundler)
LockfileParser (Bundler)
Log (Gem::Molinillo::DependencyGraph)
LogDevice (Logger)
LogEntry (RDoc::Parser::ChangeLog::Git)
Logger
Logging (MakeMakefile)
Loop (Bug::Class)
LowMethods (FileUtils)
LowMethods (Bundler::FileUtils)
Ls (IRB::ExtendCommand)

MD5 (Digest)
MDNS (Gem::Resolv)
MDNS (Resolv)
MDNSOneShot (Resolv::DNS::Requester)
MDNSOneShot (Gem::Resolv::DNS::Requester)
MINFO (Resolv::DNS::Resource)
MINFO (Gem::Resolv::DNS::Resource)
MX (Resolv::DNS::Resource)
MX (Gem::Resolv::DNS::Resource)
MagicComment (Prism)
MailTo (URI)
MailTo (Bundler::URI)
MailTo (Gem::URI)
MakeDirs (Gem::Commands::SetupCommand)
MakeMakefile
MalformattedArgumentError (Bundler::Thor)
MalformattedPlugin (Bundler::Plugin)
Mandatory (Resolv::DNS::SvcParam)
Mandatory (Gem::Resolv::DNS::SvcParam)
Mapping (Psych::Nodes)
Mark (Psych::Parser)
Markdown (RDoc::Parser)
Markdown (RDoc)
Markup (RDoc)
Markup (RDoc::Generator)
Marshal (OpenSSL)
MarshalError (Bundler)
MatchData (Ripper::TokenPattern)
MatchData
MatchError (Ripper::TokenPattern)
MatchLastLineNode (Prism)
MatchMetadata (Bundler)
MatchPlatform (Bundler)
MatchRemoteMetadata (Bundler)
Measure (IRB::ExtendCommand)
MemError (Zlib)
MemoEntry (RDoc::Markdown)
MemoEntry (RDoc::Markdown::Literals)
Memory
MemoryStore (CGI::Session)
MemoryView (Fiddle)
MemoryViewTestUtils
MenuInfo (Reline::LineEditor)
Message (Resolv::DNS)
Message (Gem::Resolv::DNS)
MessageDecoder (Resolv::DNS::Message)
MessageDecoder (Gem::Resolv::DNS::Message)
MessageEncoder (Resolv::DNS::Message)
MessageEncoder (Gem::Resolv::DNS::Message)
MessageExtractor (RDoc::Generator::POT)
Meta (OpenURI)
MetaMethod (RDoc)
Metadata (Bundler::Source)
Method (Bug)
Method (WIN32OLE)
MethodAttr (RDoc)
MethodCallError (Gem::SafeMarshal::Visitors::ToRuby)
MethodNameChecker (DidYouMean)
MethodNotAllowedResponse (Gem::GemcutterUtilities::WebauthnListener)
MiniStringIO (SyntaxSuggest)
Mirror (Bundler::Settings)
MirrorCommand (Gem::Commands)
MirrorConfig (Bundler::Settings)
MirrorSockets (Bundler)
Mirrors (Bundler::Settings)
MismatchedChecksumError (Bundler::CompactIndexClient::Updater)
MissingArgument (Gem::OptionParser)
MissingArgument (OptionParser)
MissingFileError (RDoc::Store)
MissingGitRevisionError (Bundler::Source::Git)
MissingSpecError (Gem)
MissingSpecVersionError (Gem)
MissingUnicodeSupport (JSON)
Mixin (RDoc)
Mkcol (Net::HTTP)
Mkcol (Gem::Net::HTTP)
ModRM (RubyVM::RJIT::Assembler)
Molinillo (Gem)
Monitor
MonitorMixin
Move (Net::HTTP)
Move (Gem::Net::HTTP)
MultiDimensionalView (MemoryViewTestUtils)
MultiIRBCommand (IRB::ExtendCommand)
MyInteger (Bug::NotImplement)
MyStringScanner (RDoc::Markup::Parser)

NS (Resolv::DNS::Resource)
NS (Gem::Resolv::DNS::Resource)
NXDomain (Resolv::DNS::Config)
NXDomain (Gem::Resolv::DNS::Config)
Name (Resolv::DNS)
Name (Gem::Resolv::DNS)
Name (OpenSSL::X509)
NameError (OpenSSL::X509)
NameTuple (Gem)
NeedDict (Zlib)
NeedlessArgument (OptionParser)
NeedlessArgument (Gem::OptionParser)
NegotiateAuth (Win32::SSPI)
NestedContext (Bundler::Thor)
NestingError (JSON)
NestingParser (IRB)
Net (Bundler::Persistent)
Net
Net (Gem)
NetPrivate (Gem::Net)
NetPrivate (Net)
Netscape (OpenSSL)
NetworkDownError (Bundler::Fetcher)
NewlineConv (Bug::File)
Next (IRB::ExtendCommand)
Nil (Gem::SafeMarshal::Elements)
NilClass (JSON::Ext::Generator::GeneratorMethods)
NoAliasRuby (Psych::Visitors)
NoAliasYAMLTree (Gem)
NoArgument (Gem::OptionParser::Switch)
NoArgument (OptionParser::Switch)
NoContentResponse (Gem::GemcutterUtilities::WebauthnListener)
NoDefaultALPN (Resolv::DNS::SvcParam)
NoDefaultALPN (Gem::Resolv::DNS::SvcParam)
NoFooter (Zlib::GzipFile)
NoMsgNotifier (IRB::Notifier)
NoSession (CGI::Session)
NoSpaceOnDeviceError (Bundler)
NoSuchDependencyError (Gem::Molinillo)
NoSuchJob (IRB)
NoVersions (Bundler::PubGrub::Incompatibility)
NoWrite (Bundler::FileUtils)
NoWrite (FileUtils)
Node (Psych::Nodes)
Node (RubyVM::AbstractSyntaxTree)
NodeInspector (Prism)
NodeTarget (Prism::ParseResult::Comments)
Nodes (Psych)
NonSeekableIO (Gem::Package)
Nop (IRB::ExtendCommand)
Normal (RDoc::Stats)
NormalClass (RDoc)
NormalModule (RDoc)
NotFoundError (RDoc::RI::Driver)
NotFoundResponse (Gem::GemcutterUtilities::WebauthnListener)
NotImplement (Bug)
NotImplementedError (IRB::OutputMethod)
NotImplementedError (IRB)
NotImplementedError (Gem::SafeMarshal::Reader)
Notifier (IRB)
NullChecker (DidYouMean)
NullIO (Gem::SilentUI)
NullStore (CGI::Session)
Num2int

OCSP (OpenSSL)
OCSPError (OpenSSL::OCSP)
Object (JSON::Ext::Generator::GeneratorMethods)
Object
Object (Gem::SafeMarshal::Elements)
ObjectId (OpenSSL::ASN1)
ObjectLink (Gem::SafeMarshal::Elements)
ObjectMixin (PP)
ObjectSpace
OkResponse (Gem::GemcutterUtilities::WebauthnListener)
Old (Gem::Package)
Omap (Psych)
OpCode (Resolv::DNS)
OpCode (Gem::Resolv::DNS)
Open (Bundler::CLI)
Open3
OpenCommand (Gem::Commands)
OpenRead (OpenURI)
OpenSSL
OpenSSLError (OpenSSL)
OpenStruct
OpenTimeout (Gem::Net)
OpenTimeout (Net)
OpenURI
OperandMatcher (RubyVM::RJIT)
OperationNotSupportedError (Gem)
OperationNotSupportedError (Bundler)
Option (Bundler::Thor)
Option (Socket)
OptionMap (Gem::OptionParser)
OptionMap (OptionParser)
OptionParser (Gem)
OptionParser
OptionalArgument (Gem::OptionParser::Switch)
OptionalArgument (OptionParser::Switch)
Options (Bundler::Thor)
Options (Gem::Net::HTTP)
Options (Net::HTTP)
Options (RDoc)
OtherResolvError (Gem::Resolv::DNS::Config)
OtherResolvError (Resolv::DNS::Config)
Outdated (Bundler::CLI)
OutdatedCommand (Gem::Commands)
OutputMethod (IRB)
OwnerCommand (Gem::Commands)

PATTERN (Gem::URI::RFC2396_REGEXP)
PATTERN (Bundler::URI::RFC2396_REGEXP)
PATTERN (URI::RFC2396_REGEXP)
PKCS12 (OpenSSL)
PKCS12Error (OpenSSL::PKCS12)
PKCS5 (OpenSSL)
PKCS7 (OpenSSL)
PKCS7Error (OpenSSL::PKCS7)
PKey (OpenSSL)
PKey (OpenSSL::PKey)
PKeyError (OpenSSL::PKey)
PO (RDoc::Generator::POT)
POEntry (RDoc::Generator::POT)
POT (RDoc::Generator)
PP
PPMethods (PP)
PStore (CGI::Session)
PStore
PTR (Gem::Resolv::DNS::Resource)
PTR (Resolv::DNS::Resource)
PTY
Pack (Prism)
PackInfo (Fiddle)
Package (Bundler::PubGrub)
Package (Bundler::Resolver)
Package (Gem)
PackageTask (Gem)
Packer (Fiddle)
Pager (IRB)
Paragraph (RDoc::Markup)
ParallelInstaller (Bundler)
Param (WIN32OLE)
ParamToken (Prism::LexCompat)
ParametersNode (Prism)
ParseBlocksFromIndentLine (SyntaxSuggest)
ParseError (Gem::OptionParser)
ParseError (Gem::RequestSet::Lockfile)
ParseError (RDoc::Markdown::Literals)
ParseError (Racc)
ParseError (RDoc::Markup::Parser)
ParseError (Prism)
ParseError (RDoc::Markdown)
ParseError (OptionParser)
ParseResult (Prism)
ParseWarning (Prism)
Parser (Gem::RequestSet::Lockfile)
Parser (JSON::Ext)
Parser (Prism::Translation)
Parser (Racc)
Parser (RDoc::Markup)
Parser (Psych)
Parser (RDoc)
ParserError (JSON)
PartialSolution (Bundler::PubGrub)
Passwd (Etc)
Patch (Net::HTTP)
Patch (Gem::Net::HTTP)
Path (Bundler::Source)
Path (Bundler::Settings)
PathCompletion (Bundler::Thor::LineEditor::Readline)
PathError (Gem::Package)
PathError (Bundler)
PathSupport (Gem)
Pathname
PathnameFromMessage (SyntaxSuggest)
Paths (RDoc::RI)
Pattern (Prism)
PatternKeyNameChecker (DidYouMean)
PercentLine (ERB::Compiler)
Period (Logger)
PermissionError (Bundler)
Persistent (Bundler)
Persistent (Gem::Net::HTTP)
Pinned (Fiddle)
PlacedArgument (Gem::OptionParser::Switch)
PlacedArgument (OptionParser::Switch)
PlainHeredoc (Prism::LexCompat::Heredoc)
Platform (Bundler::CLI)
Platform (Gem)
PlatformMatch (Bundler::GemHelpers)
PlatformMismatch (Gem)
Plugin (Bundler)
Plugin (Bundler::CLI)
PluginError (Bundler)
PluginGemfileError (Bundler::Plugin::DSL)
PluginInstallError (Bundler::Plugin)
Point (OpenSSL::PKey::EC)
Pointer (RubyVM::RJIT::CType)
Pointer (RubyVM::RJIT::CPointer)
Pointer (Fiddle)
Policy (Gem::Security)
Pool (Gem::Net::HTTP::Persistent)
PoolShuttingDownError (Bundler::ConnectionPool)
PopWorkspace (IRB::ExtendCommand)
Port (Gem::Resolv::DNS::SvcParam)
Port (Resolv::DNS::SvcParam)
Position (Bundler::LockfileParser)
PossibilitySet (Gem::Molinillo::Resolver::Resolution)
PossibilityState (Gem::Molinillo)
Post (Net::HTTP)
Post (Gem::Net::HTTP)
PreProcess (RDoc::Markup)
PredefinedKey (Win32::Registry)
PrettyPrint
Primitive (OpenSSL::ASN1)
PriorityEngulfQueue (SyntaxSuggest)
PriorityQueue (SyntaxSuggest)
Prism
PrismBuffer (Prism::LibRubyParser)
PrismString (Prism::LibRubyParser)
Pristine (Bundler::CLI)
PristineCommand (Gem::Commands)
Proc (Bug)
ProcessLock (Bundler)
ProcessedSource (Prism::Translation::Parser)
ProductionError (Bundler)
Property (WIN32OLE)
Propfind (Net::HTTP)
Propfind (Gem::Net::HTTP)
Proppatch (Net::HTTP)
Proppatch (Gem::Net::HTTP)
ProtoAuthError (Gem::Net)
ProtoAuthError (Net)
ProtoCommandError (Gem::Net)
ProtoCommandError (Net)
ProtoFatalError (Gem::Net)
ProtoFatalError (Net)
ProtoRetriableError (Gem::Net)
ProtoRetriableError (Net)
ProtoServerError (Gem::Net)
ProtoServerError (Net)
ProtoSyntaxError (Gem::Net)
ProtoSyntaxError (Net)
ProtoUnknownError (Gem::Net)
ProtoUnknownError (Net)
Protocol (Gem::Net)
Protocol (Net)
ProtocolError (Gem::Net)
ProtocolError (Net)
Provider (OpenSSL)
ProviderError (OpenSSL::Provider)
ProxyDelta (Net::HTTP)
ProxyDelta (Gem::Net::HTTP)
Psych
PubGrub (Bundler)
PushCommand (Gem::Commands)
PushWorkspace (IRB::ExtendCommand)
Put (Net::HTTP)
Put (Gem::Net::HTTP)

Query (Gem::Resolv::DNS)
Query (Resolv::DNS)
QueryCommand (Gem::Commands)
QueryExtension (CGI)
QueryInterfaceError (WIN32OLE)
QueryUtils (Gem)
Quiet (RDoc::Stats)

RCode (Resolv::DNS)
RCode (Gem::Resolv::DNS)
RD (RDoc::Parser)
RD (RDoc)
RDoc
RDoc (RDoc)
RFC2253DN (OpenSSL::X509::Name)
RFC2396_Parser (Gem::URI)
RFC2396_Parser (Bundler::URI)
RFC2396_Parser (URI)
RFC2396_REGEXP (Gem::URI)
RFC2396_REGEXP (Bundler::URI)
RFC2396_REGEXP (URI)
RFC3986_Parser (Gem::URI)
RFC3986_Parser (Bundler::URI)
RFC3986_Parser (URI)
RGProxy (Bundler::UI)
RI (RDoc)
RI (RDoc::Generator)
RJIT (RubyVM)
RMD160 (Digest)
RSA (OpenSSL::PKey)
RSAError (OpenSSL::PKey)
Racc
Rake
RakeBuilder (Gem::Ext)
RakeCompat (Bundler::Thor)
Random (OpenSSL)
RandomError (OpenSSL::Random)
Range
Rational
Rational (Bug)
RationalNode (Prism)
Raw (RDoc::Markup)
RbCallSuperKw (Bug)
RdocCommand (Gem::Commands)
ReadAdapter (Gem::Net)
ReadAdapter (Net)
ReadTimeout (Gem::Net)
ReadTimeout (Net)
Reader (Gem::SafeMarshal)
Readline (Bundler::Thor::LineEditor)
ReadlineInputMethod (IRB)
RecipientInfo (OpenSSL::PKCS7)
Record (WIN32OLE)
Recorder (Psych::Handlers)
RefError (WeakRef)
Regexp (Bug)
Regexp
RegexpCompletor (IRB)
RegexpHandling (RDoc::Markup)
Registrar (Psych::Visitors::YAMLTree)
Registry (Win32)
RegularExpressionNode (Prism)
ReidlineInputMethod (IRB)
Rel32 (RubyVM::RJIT::Assembler)
Reline
RelineInputMethod (IRB)
Remote (Bundler::Source::Rubygems)
RemoteError (Gem)
RemoteFetcher (Gem)
RemoteInstallationCancelled (Gem)
RemoteInstallationSkipped (Gem)
RemoteSourceException (Gem)
RemoteSpecification (Bundler)
Remove (Bundler::CLI)
Remover (Tempfile)
Report (Benchmark)
Request (OpenSSL::Timestamp)
Request (Gem)
Request (OpenSSL::X509)
Request (OpenSSL::OCSP)
RequestError (Gem::Resolv::DNS::Requester)
RequestError (OpenSSL::X509)
RequestError (Resolv::DNS::Requester)
RequestSet (Gem)
Requester (Gem::Resolv::DNS)
Requester (Resolv::DNS)
Require (RDoc)
Require (IRB::ExtendCommand)
RequirePathChecker (DidYouMean)
RequiredArgument (Gem::OptionParser::Switch)
RequiredArgument (OptionParser::Switch)
RequiredArgumentMissingError (Bundler::Thor)
Requirement (Gem)
RequirementList (Gem::Resolver)
Resolution (Gem::Molinillo::Resolver)
ResolutionError (Socket)
ResolutionState (Gem::Molinillo)
ResolutionState (Gem::Molinillo::Delegates)
Resolv (Gem)
Resolv (Win32)
Resolv
ResolvError (Gem::Resolv)
ResolvError (Resolv)
ResolvTimeout (Gem::Resolv)
ResolvTimeout (Resolv)
ResolveSymbolResolver
ResolveSymbolTarget
Resolver (Gem)
Resolver (Bundler)
Resolver (Gem::Molinillo)
ResolverError (Gem::Molinillo)
Resource (Gem::Resolv::DNS)
Resource (Resolv::DNS)
Response (OpenSSL::OCSP)
Response (OpenSSL::Timestamp)
Response (Gem::GemcutterUtilities::WebauthnListener)
Restricted (Psych::ClassLoader)
RestrictedStream (Gem::Package::TarWriter)
RestrictedYAMLTree (Psych::Visitors)
Retry (Bundler)
Revoked (OpenSSL::X509)
RevokedError (OpenSSL::X509)
RingBuffer (Reline::KillRing)
RingPoint (Reline::KillRing)
Ripper
RipperCompat (Prism)
RipperErrors (SyntaxSuggest)
RipperStateLex (RDoc::Parser)
Root (Bundler::Resolver)
Ruby (RDoc::Parser)
RubyDsl (Bundler)
RubyEvents (Psych::JSON)
RubyGems (Bundler::PubGrub)
RubyGemsGemInstaller (Bundler)
RubyLex (IRB)
RubyModel (IRB)
RubyTools (RDoc::Parser)
RubyVersion (Bundler)
RubyVersionMismatch (Gem)
RubyVersionMismatch (Bundler)
Rubygems (Bundler::Plugin::Installer)
Rubygems (Bundler::Source)
RubygemsAggregate (Bundler::Source)
RubygemsHook (RDoc)
RubygemsIntegration (Bundler)
Rule (Bundler::Settings::Validator)
Rule (RDoc::Markup)
RuleInfo (RDoc::Markdown::Literals)
RuleInfo (RDoc::Markdown)
Runner (Bundler::Thor)
Runtime (Bundler)
RuntimeError (WIN32OLE)
RuntimeRequirementNotMetError (Gem)

S3Config (Gem::S3URISigner)
S3URISigner (Gem)
SHA1 (Digest)
SHA2 (Digest)
SHA256 (Digest)
SHA384 (Digest)
SHA512 (Digest)
SOA (Gem::Resolv::DNS::Resource)
SOA (Resolv::DNS::Resource)
SOCKSSocket
SPKI (OpenSSL::Netscape)
SPKIError (OpenSSL::Netscape)
SRV (Gem::Resolv::DNS::Resource::IN)
SRV (Resolv::DNS::Resource::IN)
SSL (OpenSSL)
SSLContext (OpenSSL::SSL)
SSLError (Bundler::Fetcher)
SSLError (OpenSSL::SSL)
SSLErrorWaitReadable (OpenSSL::SSL)
SSLErrorWaitWritable (OpenSSL::SSL)
SSLServer (OpenSSL::SSL)
SSLSocket (OpenSSL::SSL)
SSPI (Win32)
SSPIResult (Win32::SSPI)
SVCB (Gem::Resolv::DNS::Resource::IN)
SVCB (Resolv::DNS::Resource::IN)
SZ (Win32::Resolv)
SafeMarshal (Bundler)
SafeMarshal (Gem)
SafeYAML (Gem)
Sandbox (Bundler::Thor)
Scalar (Psych::Nodes)
ScalarScanner (Psych)
ScanArgs (Bug)
ScanHistory (SyntaxSuggest)
Scanner (ERB::Compiler)
SearchCommand (Gem::Commands)
Section (RDoc::Context)
SecureRandom
Security (Gem)
SecurityBuffer (Win32::SSPI)
SecurityError (Bundler)
SecurityHandle (Win32::SSPI)
SecurityOption (Gem)
SelfManager (Bundler)
Sender (Gem::Resolv::DNS::Requester::TCP)
Sender (Gem::Resolv::DNS::Requester::UnconnectedUDP)
Sender (Gem::Resolv::DNS::Requester::ConnectedUDP)
Sender (Gem::Resolv::DNS::Requester)
Sender (Resolv::DNS::Requester::TCP)
Sender (Resolv::DNS::Requester::UnconnectedUDP)
Sender (Resolv::DNS::Requester::ConnectedUDP)
Sender (Resolv::DNS::Requester)
Sequence (Psych::Nodes)
ServerCommand (Gem::Commands)
ServiceBinding (Gem::Resolv::DNS::Resource::IN)
ServiceBinding (Resolv::DNS::Resource::IN)
Servlet (RDoc)
Session (CGI)
Session (OpenSSL::SSL)
SessionError (OpenSSL::SSL::Session)
Set (Gem::Resolver)
Set
Set (Psych)
Settings (Bundler)
SetupCommand (Gem::Commands)
Severity (Logger)
SexpBuilder (Prism::RipperCompat)
SexpBuilder (Ripper)
SexpBuilderPP (Prism::RipperCompat)
SexpBuilderPP (Ripper)
SharedHelpers (Bundler)
Shell (Bundler::UI)
Shell (Bundler::Thor)
Shellwords
ShiftingError (Logger)
Show (Bundler::CLI)
ShowCmds (IRB::ExtendCommand)
ShowDoc (IRB::ExtendCommand)
ShowSource (IRB::ExtendCommand)
Signer (Gem::Security)
SignerInfo (OpenSSL::PKCS7)
SigninCommand (Gem::Commands)
SignoutCommand (Gem::Commands)
Silent (Bundler::UI)
SilentDownloadReporter (Gem::StreamUI)
SilentProgressReporter (Gem::StreamUI)
SilentUI (Gem)
SimilarityDetector (Bundler)
SimilarityScore (Bundler::SimilarityDetector)
Simple (RDoc::Parser)
SimpleDelegator
SimpleProgressReporter (Gem::StreamUI)
SingleClass (RDoc)
SingleForwardable
SingleLine (PrettyPrint)
SingleLine (PP)
SingleResponse (OpenSSL::OCSP)
Singleton
SingletonClassMethods (Singleton)
Size (Gem::Resolv::LOC)
Size (Resolv::LOC)
SkipPathHelperForIRB (IRB::Debug)
Socket
SocketAddress (Bundler)
SocketError
SocketForwarder (OpenSSL::SSL)
SocketResponder (Gem::GemcutterUtilities::WebauthnListener)
SolveFailure (Bundler::PubGrub)
SolveFailure (Bundler)
Source (Gem::Package)
Source (Prism)
Source (Gem)
Source (Bundler::Checksum)
Source (Bundler)
Source (Bundler::Plugin::API)
Source (IRB::ExtendCommand)
SourceConflict (Bundler::Plugin::Index)
SourceFetchProblem (Gem)
SourceFinder (IRB)
SourceList (Bundler::Plugin)
SourceList (Gem)
SourceList (Bundler)
SourceMap (Bundler)
SourceSet (Gem::Resolver)
SourcesCommand (Gem::Commands)
SpecFetcher (Gem)
SpecGroup (Bundler::Resolver)
SpecInstallation (Bundler::ParallelInstaller)
SpecSet (Bundler)
SpecSpecification (Gem::Resolver)
SpecificFile (Gem::Source)
SpecificGemNotFoundException (Gem)
Specification (Gem::Resolver)
Specification (Gem)
SpecificationCommand (Gem::Commands)
SpecificationPolicy (Gem)
SpecificationProvider (Gem::Molinillo)
SpecificationProvider (Gem::Molinillo::Delegates)
SpellChecker (Bundler::Thor::UnknownArgumentError)
SpellChecker (Bundler::Thor::UndefinedCommandError)
SpellChecker (DidYouMean)
StaleCommand (Gem::Commands)
Standalone (Bundler)
Stat (Bug::File)
Stat (File)
State (Ripper::Lexer)
State (JSON::Ext::Generator)
State (Reline::KillRing)
Statement (IRB)
StaticPackageSource (Bundler::PubGrub)
Stats (Gem::Resolver)
Stats (RDoc)
StdioInputMethod (IRB)
StdioOutputMethod (IRB)
Step (IRB::ExtendCommand)
Store (Bundler::Checksum)
Store (YAML)
Store (RDoc)
Store (OpenSSL::X509)
StoreContext (OpenSSL::X509)
StoreError (OpenSSL::X509)
Str (Gem::Resolv::DNS::Label)
Str (Resolv::DNS::Label)
Stream (Psych::Nodes)
Stream (Psych::JSON)
Stream (Psych)
StreamEnd (Zlib)
StreamError (Zlib)
StreamPrinter (Gem::SafeMarshal::Visitors)
StreamUI (Gem)
StreamUtils_ (FileUtils)
StreamUtils_ (Bundler::FileUtils)
Streaming (Psych)
String (Gem::SafeMarshal::Elements)
String (JSON::Ext::Generator::GeneratorMethods)
String
String (Bug)
StringIO
StringInputMethod (XMP)
StringNode (Prism)
StringScanner
StringWithTiparm (Reline::Terminfo)
StringifySymbols
StringifyTarget
Struct (RubyVM::RJIT::CType)
Struct
Struct (RubyVM::RJIT::CPointer)
Struct (Bug)
StructArray (Fiddle)
Stub (RubyVM::RJIT::CType)
StubLine (Gem::StubSpecification)
StubSpecification (Gem)
StubSpecification (Bundler)
SubjectKeyIdentifier (OpenSSL::X509::Extension)
SvcParam (Gem::Resolv::DNS)
SvcParam (Resolv::DNS)
SvcParams (Gem::Resolv::DNS)
SvcParams (Resolv::DNS)
Switch (Gem::OptionParser)
Switch (OptionParser)
Symbol (Gem::SafeMarshal::Elements)
Symbol
Symbol (Bug)
SymbolLink (Gem::SafeMarshal::Elements)
SymlinkError (Gem::Package)
SyntaxError (Psych)
SyntaxSuggest
SystemExitException (Gem)

TCP (Gem::Resolv::DNS::Requester)
TCP (Resolv::DNS::Requester)
TCPServer
TCPSocket
TCPSocketExt (CoreExtensions)
TCPSocketProbe (Bundler::Settings)
TSort (Gem)
TSort (Bundler)
TSort
TXT (Gem::Resolv::DNS::Resource)
TXT (Resolv::DNS::Resource)
Table (RDoc::Markup)
TablePrinter (Bundler::Thor::Shell)
TagMaker (CGI)
TarHeader (Gem::Package)
TarInvalidError (Gem::Package)
TarReader (Gem::Package)
TarWriter (Gem::Package)
Task (RDoc::RI)
Task (RDoc)
Tempfile
TemporaryResourceError (Bundler)
Term (Bundler::PubGrub)
Terminal (Bundler::Thor::Shell)
TerminateLineInput (IRB::RubyLex)
Terminfo (Reline)
TerminfoError (Reline::Terminfo)
Text (RDoc::I18n)
Text (PrettyPrint)
Text (RDoc::Parser)
Text (Gem)
Text (RDoc)
Thor (Bundler)
Thread (Bug)
Thread
ThreadCreationError (Bundler)
ThreadInstrumentation (Bug)
ThreadedDownloadReporter (Gem::StreamUI)
Time
Time (Bug)
TimeStamp (Win32::SSPI)
TimedStack (Bundler::ConnectionPool)
TimedStackMulti (Gem::Net::HTTP::Persistent)
Timeout (Gem)
Timeout
TimeoutError (Bundler::ConnectionPool)
Timestamp (OpenSSL)
TimestampError (OpenSSL::Timestamp)
Tmpname (Dir)
Tms (Benchmark)
ToAnsi (RDoc::Markup)
ToBs (RDoc::Markup)
ToHtml (RDoc::Markup)
ToHtmlCrossref (RDoc::Markup)
ToHtmlSnippet (RDoc::Markup)
ToJoinedParagraph (RDoc::Markup)
ToLabel (RDoc::Markup)
ToMarkdown (RDoc::Markup)
ToRdoc (RDoc::Markup)
ToRuby (Gem::SafeMarshal::Visitors)
ToRuby (Psych::Visitors)
ToTableOfContents (RDoc::Markup)
ToTest (RDoc::Markup)
ToTtOnly (RDoc::Markup)
Token (Gem::RequestSet::Lockfile::Tokenizer)
Token (RDoc::Parser::RipperStateLex)
Token (Prism)
Token (Prism::LexCompat)
TokenInfo (OpenSSL::Timestamp)
TokenPattern (Ripper)
TokenStream (RDoc)
Tokenizer (Gem::RequestSet::Lockfile)
TomDoc (RDoc)
TooLongFileName (Gem::Package)
TooManyRedirects (OpenURI)
TooManyRequestsError (Bundler::Fetcher)
TopLevel (RDoc)
Trace (Net::HTTP)
Trace (Gem::Net::HTTP)
Translation (Prism)
TreeBuilder (Psych::JSON)
TreeBuilder (Psych)
TreeSpellChecker (DidYouMean)
TrimScanner (ERB::Compiler)
True (Gem::SafeMarshal::Elements)
TrueClass (JSON::Ext::Generator::GeneratorMethods)
TrustDir (Gem::Security)
Tuple (Gem::AvailableSet)
Type (WIN32OLE)
TypeCompletor (IRB)
TypeDiff (RubyVM::RJIT)
TypeLib (WIN32OLE)
TypedData (Bug)
Types (Fiddle)

UDPSocket
UDPSource (Socket)
UI (IRB::Debug)
UI (Gem::Molinillo)
UI (Bundler)
UN
UNIXServer
UNIXSocket
URI (Gem)
URI (Bundler)
URI
URICredentialsFilter (Bundler)
URINormalizer (Bundler)
UnconnectedUDP (Gem::Resolv::DNS::Requester)
UnconnectedUDP (Resolv::DNS::Requester)
UnconsumedBytesError (Gem::SafeMarshal::Reader)
UndefinedCommandError (Bundler::Thor)
UndefinedCommandError (Bundler::Plugin)
UndefinedPromptMode (IRB)
Unicode (Reline)
UnicodeNormalize
UninstallCommand (Gem::Commands)
UninstallError (Gem)
Uninstaller (Gem)
Union (RubyVM::RJIT::CType)
Union (RubyVM::RJIT::CPointer)
UnknownArgumentError (Bundler::Thor)
UnknownCommandError (Gem)
UnknownCommandSpellChecker (Gem)
UnknownHostError (Gem::RemoteFetcher)
UnknownSourceError (Bundler::Plugin)
Unlock (Net::HTTP)
Unlock (Gem::Net::HTTP)
UnpackCommand (Gem::Commands)
UnpermittedClassError (Gem::SafeMarshal::Visitors::ToRuby)
UnpermittedIvarError (Gem::SafeMarshal::Visitors::ToRuby)
UnpermittedSymbolError (Gem::SafeMarshal::Visitors::ToRuby)
UnrecognizedSwitch (IRB)
UnsatisfiableDependencyError (Gem)
UnsupportedError (Gem::SafeMarshal::Visitors::ToRuby)
UnsupportedVersionError (Gem::SafeMarshal::Reader)
UnvisitedLines (SyntaxSuggest)
UnwindDetails (Gem::Molinillo::Resolver::Resolution)
Update (Bundler::CLI)
UpdateCommand (Gem::Commands)
UpdateSuggestion (Gem)
Updater (Bundler::CompactIndexClient)
Uri (Gem)
UriFormatter (Gem)
UserClass (Gem::SafeMarshal::Elements)
UserDefined (Gem::SafeMarshal::Elements)
UserInteraction (Gem)
UserMarshal (Gem::SafeMarshal::Elements)
Util (Bundler::URI)
Util (Bundler::Thor)
Util (Gem)
Util (URI)
Util (ERB)
Util (CGI)
Util (Gem::URI)

VM (Bug)
Validator (Bundler::Settings)
Validator (Gem)
ValueUtil (Fiddle)
Variable (WIN32OLE)
VariableNameChecker (DidYouMean)
Variant (WIN32OLE)
VariantType (WIN32OLE)
Vec (IRB)
Vendor (Gem::Source)
VendorSet (Gem::Resolver)
VendorSpecification (Gem::Resolver)
Verbatim (RDoc::Markup)
Verbose (Bundler::FileUtils)
Verbose (RDoc::Stats)
Verbose (FileUtils)
VerboseProgressReporter (Gem::StreamUI)
VerificationError (Gem)
Version (Gem)
VersionConflict (Gem::Molinillo)
VersionConstraint (Bundler::PubGrub)
VersionError (Zlib)
VersionMax (Bug::Class)
VersionOption (Gem)
VersionRange (Bundler::PubGrub)
VersionSolver (Bundler::PubGrub)
VersionUnion (Bundler::PubGrub)
VersionZero (Bug::Class)
Vertex (Gem::Molinillo::DependencyGraph)
ViCommand (Reline::KeyActor)
ViInsert (Reline::KeyActor)
VirtualProtocolError (Bundler)
Visitor (Gem::SafeMarshal::Visitors)
Visitor (Psych::Visitors)
Visitors (Gem::SafeMarshal)
Visitors (Psych)
Viz (Bundler::CLI)

WIN32OLE
WKS (Gem::Resolv::DNS::Resource::IN)
WKS (Resolv::DNS::Resource::IN)
WS (Gem::URI)
WS (Bundler::URI)
WS (URI)
WSS (Gem::URI)
WSS (Bundler::URI)
WSS (URI)
WaitReadable (IO)
WaitWritable (IO)
WeakRef
WebauthnListener (Gem::GemcutterUtilities)
WebauthnPoller (Gem::GemcutterUtilities)
WebauthnVerificationError (Gem)
Whereami (IRB::ExtendCommand)
WhichCommand (Gem::Commands)
Win32
Win32 (Bug)
Win32API (Reline::Windows)
Win32Types (Fiddle)
Windows (Reline)
WithIvars (Gem::SafeMarshal::Elements)
WorkSpace (IRB)
Worker (Bundler)
Workspaces (IRB::ExtendCommand)
WrappedException (Bundler::Worker)
WrappedPrinter (Bundler::Thor::Shell)
Wrapper (Bundler::ConnectionPool)
WriteAdapter (Gem::Net)
WriteAdapter (Net)
WriteTimeout (Gem::Net)
WriteTimeout (Net)

X509 (OpenSSL)
XMP
XStringNode (Prism)

YAML
YAMLEvents (Psych::JSON)
YAMLSerializer (Gem)
YAMLSerializer (Bundler)
YAMLTree (Psych::Visitors)
YamlSyntaxError (Bundler)
YankCommand (Gem::Commands)
Yield (Bug::Float)

ZStream (Zlib)
Zlib