bundler: Ruby Standard Library Documentation

CAmbiguousCommandError → AmbiguousCommandError

CAmbiguousTaskError

MBundler

CBundler::APIResponseInvalidDependenciesError

CBundler::APIResponseMismatchError

MBundler::BuildMetadata

CBundler::BundlerError

CBundler::CLI

CBundler::CLI::Add

CBundler::CLI::Binstubs

CBundler::CLI::Cache

CBundler::CLI::Check

CBundler::CLI::Clean

MBundler::CLI::Common

CBundler::CLI::Config

CBundler::CLI::Config::Base

CBundler::CLI::Console

CBundler::CLI::Doctor

CBundler::CLI::Exec

CBundler::CLI::Fund

CBundler::CLI::Gem

CBundler::CLI::Info

CBundler::CLI::Init

CBundler::CLI::Inject

CBundler::CLI::Install

CBundler::CLI::Issue

CBundler::CLI::List

CBundler::CLI::Lock

CBundler::CLI::Open

CBundler::CLI::Outdated

CBundler::CLI::Platform

CBundler::CLI::Plugin

CBundler::CLI::Pristine

CBundler::CLI::Remove

CBundler::CLI::Show

CBundler::CLI::Update

CBundler::CLI::Viz

CBundler::CompactIndexClient

CBundler::CompactIndexClient::Cache

CBundler::CompactIndexClient::Error

CBundler::CompactIndexClient::GemParser

CBundler::CompactIndexClient::Updater

CBundler::CompactIndexClient::Updater::MisMatchedChecksumError

CBundler::ConnectionPool

CBundler::ConnectionPool::Error

CBundler::ConnectionPool::PoolShuttingDownError

CBundler::ConnectionPool::TimedStack

CBundler::ConnectionPool::Wrapper

CBundler::CurrentRuby

CBundler::CyclicDependencyError

CBundler::Definition

CBundler::DepProxy

CBundler::Dependency

CBundler::Deployment

CBundler::Deprecate

CBundler::DeprecatedError

CBundler::Dir

CBundler::Dsl

CBundler::Dsl::DSLError

CBundler::EndpointSpecification

CBundler::Env

CBundler::EnvironmentPreserver

CBundler::FeatureFlag

CBundler::Fetcher

CBundler::Fetcher::AuthenticationRequiredError

CBundler::Fetcher::BadAuthenticationError

CBundler::Fetcher::Base

CBundler::Fetcher::CertificateFailureError

CBundler::Fetcher::CompactIndex

CBundler::Fetcher::Dependency

CBundler::Fetcher::Downloader

CBundler::Fetcher::FallbackError

CBundler::Fetcher::Index

CBundler::Fetcher::NetworkDownError

CBundler::Fetcher::SSLError

CBundler::Fetcher::TooManyRequestsError

MBundler::FileUtils

MBundler::FileUtils::DryRun

MBundler::FileUtils::NoWrite

MBundler::FileUtils::StreamUtils_

MBundler::FileUtils::Verbose

MBundler::FriendlyErrors

CBundler::GemHelper

MBundler::GemHelpers

CBundler::GemHelpers::PlatformMatch

CBundler::GemInstaller

CBundler::GemNotFound

CBundler::GemRequireError

CBundler::GemVersionPromoter

CBundler::Gemdeps

CBundler::GemfileError

CBundler::GemfileEvalError

CBundler::GemfileLockNotFound

CBundler::GemfileNotFound

CBundler::GemspecError

CBundler::GenericSystemCallError

CBundler::GitError

CBundler::Graph

CBundler::Graph::GraphVizClient

CBundler::HTTPError

CBundler::Index

CBundler::Injector

CBundler::InstallError

CBundler::InstallHookError

CBundler::Installer

CBundler::InvalidOption

CBundler::LazySpecification

CBundler::LockfileError

CBundler::LockfileGenerator

CBundler::LockfileParser

CBundler::MarshalError

MBundler::MatchPlatform

CBundler::MirrorSockets

MBundler::Molinillo

CBundler::Molinillo::CircularDependencyError

MBundler::Molinillo::Delegates

MBundler::Molinillo::Delegates::ResolutionState

MBundler::Molinillo::Delegates::SpecificationProvider

CBundler::Molinillo::DependencyGraph

CBundler::Molinillo::DependencyGraph::Action

CBundler::Molinillo::DependencyGraph::AddEdgeNoCircular

CBundler::Molinillo::DependencyGraph::DeleteEdge

CBundler::Molinillo::DependencyGraph::DetachVertexNamed

CBundler::Molinillo::DependencyGraph::Log

CBundler::Molinillo::DependencyGraph::Tag

CBundler::Molinillo::DependencyGraph::Vertex

CBundler::Molinillo::DependencyState

CBundler::Molinillo::NoSuchDependencyError

CBundler::Molinillo::PossibilityState

CBundler::Molinillo::ResolutionState

CBundler::Molinillo::Resolver

CBundler::Molinillo::Resolver::Resolution

CBundler::Molinillo::Resolver::Resolution::Conflict

CBundler::Molinillo::Resolver::Resolution::PossibilitySet

CBundler::Molinillo::Resolver::Resolution::UnwindDetails

CBundler::Molinillo::ResolverError

MBundler::Molinillo::SpecificationProvider

MBundler::Molinillo::UI

CBundler::Molinillo::VersionConflict

CBundler::NoSpaceOnDeviceError

CBundler::OperationNotSupportedError

CBundler::ParallelInstaller

CBundler::ParallelInstaller::SpecInstallation

CBundler::PathError

CBundler::PermissionError

MBundler::Persistent

MBundler::Persistent::Net

MBundler::Persistent::Net::HTTP

CBundler::Persistent::Net::HTTP::Persistent

CBundler::Persistent::Net::HTTP::Persistent::Error

CBundler::PersistentHTTP

MBundler::Plugin

CBundler::Plugin::API

MBundler::Plugin::API::Source

CBundler::Plugin::DSL

CBundler::Plugin::DSL::PluginGemfileError

MBundler::Plugin::Events

CBundler::Plugin::Index

CBundler::Plugin::Index::CommandConflict

CBundler::Plugin::Index::SourceConflict

CBundler::Plugin::Installer

CBundler::Plugin::Installer::Git

CBundler::Plugin::Installer::Rubygems

CBundler::Plugin::MalformattedPlugin

CBundler::Plugin::SourceList

CBundler::Plugin::UndefinedCommandError

CBundler::Plugin::UnknownSourceError

CBundler::PluginError

CBundler::ProcessLock

CBundler::ProductionError

CBundler::RemoteSpecification

CBundler::Resolver

CBundler::Resolver::SpecGroup

CBundler::Retry

MBundler::RubyDsl

CBundler::RubyGemsGemInstaller

CBundler::RubyVersion

CBundler::RubyVersionMismatch

CBundler::RubygemsIntegration

MBundler::RubygemsIntegration::Gem

CBundler::Runtime

CBundler::SecurityError

CBundler::Settings

CBundler::Settings::Mirror

CBundler::Settings::MirrorConfig

CBundler::Settings::Mirrors

CBundler::Settings::TCPSocketProbe

CBundler::Settings::Validator

CBundler::Settings::Validator::Rule

MBundler::SharedHelpers

CBundler::SimilarityDetector

CBundler::SocketAddress

CBundler::Source

CBundler::Source::Gemspec

CBundler::Source::Git

CBundler::Source::Git::GitCommandError

CBundler::Source::Git::GitNotAllowedError

CBundler::Source::Git::GitNotInstalledError

CBundler::Source::Git::GitProxy

CBundler::Source::Git::MissingGitRevisionError

CBundler::Source::Metadata

CBundler::Source::Path

CBundler::Source::Path::Installer

CBundler::Source::Rubygems

CBundler::Source::Rubygems::Remote

CBundler::Source::RubygemsAggregate

CBundler::SourceList

CBundler::SourceMap

CBundler::SpecSet

CBundler::Standalone

CBundler::StubSpecification

CBundler::SudoNotPermittedError

CBundler::TemporaryResourceError

CBundler::Thor

MBundler::Thor::Actions

CBundler::Thor::Actions::CapturableERB

MBundler::Thor::Actions::ClassMethods

MBundler::Thor::Base

MBundler::Thor::Base::ClassMethods

CBundler::Thor::Command

CBundler::Thor::DynamicCommand

CBundler::Thor::DynamicTask → Bundler::Thor::DynamicCommand

CBundler::Thor::Group

CBundler::Thor::HiddenCommand

CBundler::Thor::HiddenTask → Bundler::Thor::HiddenCommand

MBundler::Thor::Invocation

MBundler::Thor::Invocation::ClassMethods

MBundler::Thor::LineEditor

CBundler::Thor::LineEditor::Basic

CBundler::Thor::LineEditor::Readline

CBundler::Thor::LineEditor::Readline::PathCompletion

CBundler::Thor::NestedContext

MBundler::Thor::RakeCompat

MBundler::Thor::Shell

CBundler::Thor::Shell::Basic

CBundler::Thor::Shell::Color

CBundler::Thor::Shell::HTML

CBundler::Thor::Task → Bundler::Thor::Command

MBundler::Thor::Util

CBundler::ThreadCreationError

MBundler::UI

CBundler::UI::RGProxy

CBundler::UI::Shell

CBundler::UI::Silent

MBundler::URI

CBundler::URI::BadURIError

CBundler::URI::Error

MBundler::URI::Escape

CBundler::URI::FTP

CBundler::URI::File

CBundler::URI::Generic

CBundler::URI::HTTP

CBundler::URI::HTTPS

CBundler::URI::InvalidComponentError

CBundler::URI::InvalidURIError

CBundler::URI::LDAP

CBundler::URI::LDAPS

CBundler::URI::MailTo

CBundler::URI::Parser → Bundler::URI::RFC2396_Parser

MBundler::URI::REGEXP → Bundler::URI::RFC2396_REGEXP

CBundler::URI::RFC2396_Parser

MBundler::URI::RFC2396_REGEXP

MBundler::URI::RFC2396_REGEXP::PATTERN

MBundler::URICredentialsFilter

CBundler::VersionConflict

MBundler::VersionRanges

CBundler::VersionRanges::ReqR

CBundler::VirtualProtocolError

CBundler::Worker

CBundler::Worker::WrappedException

MBundler::YAMLSerializer

CBundler::YamlSyntaxError

CError

MGem

CGem::Dependency

CGem::Platform

CGem::Requirement

MGem::Requirement::CorrectHashForLambdaOperator

MGem::Requirement::OrderIndependentComparison

CGem::Specification

CInvocationError

MKernel

CMalformattedArgumentError

CObject

CRequiredArgumentMissingError

CUndefinedCommandError → UndefinedCommandError

CUndefinedCommandError::SpellChecker

CUndefinedTaskError

CUnknownArgumentError

CUnknownArgumentError::SpellChecker

::URI (Bundler)

::action_name (Bundler::Molinillo::DependencyGraph::Action)

::action_name (Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular)

::action_name (Bundler::Molinillo::DependencyGraph::DeleteEdge)

::action_name (Bundler::Molinillo::DependencyGraph::DetachVertexNamed)

::action_name (Bundler::Molinillo::DependencyGraph::Tag)

::aliases_for (Bundler::CLI)

::all_aliases (Bundler::CLI)

::all_errors (Bundler::BundlerError)

::app_cache (Bundler)

::app_config_path (Bundler)

::ask_for_spec_from (Bundler::CLI::Common)

::attempts (Bundler::Retry)

::available? (Bundler::Thor::LineEditor::Basic)

::available? (Bundler::Thor::LineEditor::Readline)

::banner (Bundler::Thor)

::banner (Bundler::Thor::Group)

::best_available (Bundler::Thor::LineEditor)

::bin_path (Bundler)

::build (Bundler::Definition)

::build (Bundler::Index)

::build (Bundler::URI::FTP)

::build (Bundler::URI::File)

::build (Bundler::URI::Generic)

::build (Bundler::URI::HTTP)

::build (Bundler::URI::LDAP)

::build (Bundler::URI::MailTo)

::build2 (Bundler::URI::Generic)

::built_at (Bundler::BuildMetadata)

::bundle_path (Bundler)

::bundler_major_version (Bundler)

::call (Bundler::ParallelInstaller)

::camel_case (Bundler::Thor::Util)

::cd (Bundler::FileUtils)

::chdir (Bundler::FileUtils)

::check_unknown_options! (Bundler::Thor)

::chmod (Bundler::FileUtils)

::chmod_R (Bundler::FileUtils)

::chown (Bundler::FileUtils)

::chown_R (Bundler::FileUtils)

::clean_after_install? (Bundler::CLI::Common)

::clean_env (Bundler)

::clean_exec (Bundler)

::clean_system (Bundler)

::clear_gemspec_cache (Bundler)

::cmp (Bundler::FileUtils)

::collect_method (Bundler::FileUtils)

::command (Bundler::Plugin::API)

::command_help (Bundler::Thor)

::commands (Bundler::FileUtils)

::compact_index_request (Bundler::Fetcher::CompactIndex)

::compare_file (Bundler::FileUtils)

::compare_stream (Bundler::FileUtils)

::component (Bundler::URI::Generic)

::configure (Bundler)

::configure_gem_version_promoter (Bundler::CLI::Common)

::configured_bundle_path (Bundler)

::copy (Bundler::FileUtils)

::copy_entry (Bundler::FileUtils)

::copy_file (Bundler::FileUtils)

::copy_stream (Bundler::FileUtils)

::cp (Bundler::FileUtils)

::cp_lr (Bundler::FileUtils)

::cp_r (Bundler::FileUtils)

::cpu_match (Bundler::GemHelpers::PlatformMatch)

::create_for (Bundler::Resolver::SpecGroup)

::current_ruby (Bundler)

::debug (Bundler::CompactIndexClient)

::decode_www_form (Bundler::URI)

::decode_www_form_component (Bundler::URI)

::default_attempts (Bundler::Retry)

::default_bundle_dir (Bundler)

::default_command (Bundler::Thor)

::default_gemfile (Bundler)

::default_lockfile (Bundler)

::default_port (Bundler::URI::Generic)

::default_retries (Bundler::Retry)

::default_task (Bundler::Thor)

::define_task (Bundler::Deployment)

::defined_event? (Bundler::Plugin::Events)

::definition (Bundler)

::desc (Bundler::Thor)

::desc (Bundler::Thor::Group)

::detect_idle_timeout (Bundler::Persistent::Net::HTTP::Persistent)

::disable_required_check! (Bundler::Thor)

::dispatch (Bundler::CLI)

::empty (Bundler::Molinillo::ResolutionState)

::empty? (Bundler::VersionRanges)

::encode_www_form (Bundler::URI)

::encode_www_form_component (Bundler::URI)

::ensure_all_gems_in_lockfile! (Bundler::CLI::Common)

::env_to_hash (Bundler::EnvironmentPreserver)

::environment (Bundler)

::environment (Bundler::Env)

::escape_globs (Bundler::Thor::Util)

::escape_html (Bundler::Thor::Util)

::evaluate (Bundler::Dsl)

::extract (Bundler::URI)

::feature_flag (Bundler)

::find_by_namespace (Bundler::Thor::Util)

::find_class_and_command_by_namespace (Bundler::Thor::Util)

::find_class_and_task_by_namespace (Bundler::Thor::Util)

::find_command_possibilities (Bundler::Thor)

::find_task_possibilities (Bundler::Thor)

::for (Bundler::VersionRanges)

::for_many (Bundler::VersionRanges)

::from_env (Bundler::EnvironmentPreserver)

::from_lock (Bundler::Source::Git)

::from_lock (Bundler::Source::Path)

::from_lock (Bundler::Source::Rubygems)

::from_string (Bundler::RubyVersion)

::from_stub (Bundler::StubSpecification)

::frozen_bundle? (Bundler)

::gem_not_found_message (Bundler::CLI::Common)

::gemspec (Bundler::GemHelper)

::generate (Bundler::LockfileGenerator)

::generic (Bundler::GemHelpers)

::generic_local_platform (Bundler::GemHelpers)

::get_proxy (Bundler::DepProxy)

::getwd (Bundler::FileUtils)

::git_commit_sha (Bundler::BuildMetadata)

::git_present? (Bundler)

::globs_for (Bundler::Thor::Util)

::handle_no_command_error (Bundler::CLI)

::have_option? (Bundler::FileUtils)

::help (Bundler::Thor)

::help (Bundler::Thor::Group)

::home (Bundler)

::hook (Bundler::Plugin::API)

::identical? (Bundler::FileUtils)

::included (Bundler::Thor::RakeCompat)

::inject (Bundler::Injector)

::install (Bundler::FileUtils)

::install (Bundler::Installer)

::install_path (Bundler)

::install_tasks (Bundler::GemHelper)

::invoke (Bundler::Thor::Group)

::invoke_from_option (Bundler::Thor::Group)

::join (Bundler::URI)

::link (Bundler::FileUtils)

::link_entry (Bundler::FileUtils)

::ln (Bundler::FileUtils)

::ln_s (Bundler::FileUtils)

::ln_sf (Bundler::FileUtils)

::load (Bundler)

::load_gemspec (Bundler)

::load_gemspec_uncached (Bundler)

::load_marshal (Bundler)

::load_thorfile (Bundler::Thor::Util)

::local_platform (Bundler)

::local_platform (Bundler::GemHelpers)

::lock (Bundler::ProcessLock)

::locked_gems (Bundler)

::long_desc (Bundler::Thor)

::makedirs (Bundler::FileUtils)

::map (Bundler::Thor)

::method_option (Bundler::Thor)

::method_options (Bundler::Thor)

::mkdir (Bundler::FileUtils)

::mkdir_p (Bundler)

::mkdir_p (Bundler::FileUtils)

::mkpath (Bundler::FileUtils)

::mktmpdir (Bundler::Dir)

::monotonic_time (Bundler::ConnectionPool)

::most_specific_locked_platform? (Bundler)

::move (Bundler::FileUtils)

::mv (Bundler::FileUtils)

::namespace_from_thor_class (Bundler::Thor::Util)

::namespaces_in_content (Bundler::Thor::Util)

::new (Bundler::CLI)

::new (Bundler::CLI::Add)

::new (Bundler::CLI::Binstubs)

::new (Bundler::CLI::Cache)

::new (Bundler::CLI::Check)

::new (Bundler::CLI::Clean)

::new (Bundler::CLI::Config::Base)

::new (Bundler::CLI::Console)

::new (Bundler::CLI::Doctor)

::new (Bundler::CLI::Exec)

::new (Bundler::CLI::Fund)

::new (Bundler::CLI::Gem)

::new (Bundler::CLI::Info)

::new (Bundler::CLI::Init)

::new (Bundler::CLI::Inject)

::new (Bundler::CLI::Install)

::new (Bundler::CLI::List)

::new (Bundler::CLI::Lock)

::new (Bundler::CLI::Open)

::new (Bundler::CLI::Outdated)

::new (Bundler::CLI::Platform)

::new (Bundler::CLI::Pristine)

::new (Bundler::CLI::Remove)

::new (Bundler::CLI::Show)

::new (Bundler::CLI::Update)

::new (Bundler::CLI::Viz)

::new (Bundler::CompactIndexClient)

::new (Bundler::CompactIndexClient::Cache)

::new (Bundler::CompactIndexClient::Updater)

::new (Bundler::CompactIndexClient::Updater::MisMatchedChecksumError)

::new (Bundler::ConnectionPool)

::new (Bundler::ConnectionPool::TimedStack)

::new (Bundler::ConnectionPool::Wrapper)

::new (Bundler::Definition)

::new (Bundler::Dependency)

::new (Bundler::Dsl)

::new (Bundler::Dsl::DSLError)

::new (Bundler::EndpointSpecification)

::new (Bundler::EnvironmentPreserver)

::new (Bundler::FeatureFlag)

::new (Bundler::Fetcher)

::new (Bundler::Fetcher::AuthenticationRequiredError)

::new (Bundler::Fetcher::BadAuthenticationError)

::new (Bundler::Fetcher::Base)

::new (Bundler::Fetcher::CertificateFailureError)

::new (Bundler::Fetcher::Downloader)

::new (Bundler::Fetcher::SSLError)

::new (Bundler::GemHelper)

::new (Bundler::GemInstaller)

::new (Bundler::GemRequireError)

::new (Bundler::GemVersionPromoter)

::new (Bundler::Gemdeps)

::new (Bundler::GenericSystemCallError)

::new (Bundler::Graph)

::new (Bundler::Graph::GraphVizClient)

::new (Bundler::Index)

::new (Bundler::Injector)

::new (Bundler::Installer)

::new (Bundler::LazySpecification)

::new (Bundler::LockfileGenerator)

::new (Bundler::LockfileParser)

::new (Bundler::MirrorSockets)

::new (Bundler::Molinillo::CircularDependencyError)

::new (Bundler::Molinillo::DependencyGraph)

::new (Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular)

::new (Bundler::Molinillo::DependencyGraph::DeleteEdge)

::new (Bundler::Molinillo::DependencyGraph::DetachVertexNamed)

::new (Bundler::Molinillo::DependencyGraph::Log)

::new (Bundler::Molinillo::DependencyGraph::Tag)

::new (Bundler::Molinillo::DependencyGraph::Vertex)

::new (Bundler::Molinillo::NoSuchDependencyError)

::new (Bundler::Molinillo::Resolver)

::new (Bundler::Molinillo::Resolver::Resolution)

::new (Bundler::Molinillo::VersionConflict)

::new (Bundler::ParallelInstaller)

::new (Bundler::ParallelInstaller::SpecInstallation)

::new (Bundler::PermissionError)

::new (Bundler::Persistent::Net::HTTP::Persistent)

::new (Bundler::Plugin::API::Source)

::new (Bundler::Plugin::DSL)

::new (Bundler::Plugin::Index)

::new (Bundler::Plugin::Index::CommandConflict)

::new (Bundler::Plugin::Index::SourceConflict)

::new (Bundler::RemoteSpecification)

::new (Bundler::Resolver)

::new (Bundler::Resolver::SpecGroup)

::new (Bundler::Retry)

::new (Bundler::RubyVersion)

::new (Bundler::RubygemsIntegration)

::new (Bundler::Runtime)

::new (Bundler::Settings)

::new (Bundler::Settings::Mirror)

::new (Bundler::Settings::MirrorConfig)

::new (Bundler::Settings::Mirrors)

::new (Bundler::Settings::Validator::Rule)

::new (Bundler::SimilarityDetector)

::new (Bundler::SocketAddress)

::new (Bundler::Source::Gemspec)

::new (Bundler::Source::Git)

::new (Bundler::Source::Git::GitCommandError)

::new (Bundler::Source::Git::GitNotAllowedError)

::new (Bundler::Source::Git::GitNotInstalledError)

::new (Bundler::Source::Git::GitProxy)

::new (Bundler::Source::Git::MissingGitRevisionError)

::new (Bundler::Source::Path)

::new (Bundler::Source::Path::Installer)

::new (Bundler::Source::Rubygems)

::new (Bundler::Source::Rubygems::Remote)

::new (Bundler::Source::RubygemsAggregate)

::new (Bundler::SourceList)

::new (Bundler::SourceMap)

::new (Bundler::SpecSet)

::new (Bundler::Standalone)

::new (Bundler::Thor::Actions)

::new (Bundler::Thor::Base)

::new (Bundler::Thor::Command)

::new (Bundler::Thor::Command)

::new (Bundler::Thor::DynamicCommand)

::new (Bundler::Thor::DynamicCommand)

::new (Bundler::Thor::LineEditor::Basic)

::new (Bundler::Thor::LineEditor::Readline::PathCompletion)

::new (Bundler::Thor::NestedContext)

::new (Bundler::Thor::Shell)

::new (Bundler::UI::RGProxy)

::new (Bundler::UI::Shell)

::new (Bundler::UI::Silent)

::new (Bundler::URI::FTP)

::new (Bundler::URI::Generic)

::new (Bundler::URI::LDAP)

::new (Bundler::URI::MailTo)

::new (Bundler::URI::RFC2396_Parser)

::new (Bundler::URI::RFC2396_Parser)

::new (Bundler::VersionConflict)

::new (Bundler::Worker)

::new (Bundler::Worker::WrappedException)

::new (Bundler::YamlSyntaxError)

::new (UndefinedCommandError)

::new (UndefinedCommandError)

::new (UndefinedCommandError::SpellChecker)

::new (UnknownArgumentError)

::new (UnknownArgumentError::SpellChecker)

::option (Bundler::Thor)

::options (Bundler::FileUtils)

::options (Bundler::Thor)

::options_of (Bundler::FileUtils)

::original_env (Bundler)

::original_exec (Bundler)

::original_system (Bundler)

::os_match (Bundler::GemHelpers::PlatformMatch)

::output_fund_metadata_summary (Bundler::CLI::Common)

::output_post_install_messages (Bundler::CLI::Common)

::output_without_groups_message (Bundler::CLI::Common)

::package_name (Bundler::Thor)

::parse (Bundler::URI)

::patch_level_options (Bundler::CLI::Common)

::platform_sort_key (Bundler::Resolver)

::platform_specificity_match (Bundler::GemHelpers)

::platform_version_match (Bundler::GemHelpers::PlatformMatch)

::platforms_match? (Bundler::MatchPlatform)

::preferred_gemfile_name (Bundler)

::print_post_install_message (Bundler::CLI::Common)

::printable_commands (Bundler::Thor)

::printable_commands (Bundler::Thor::Group)

::printable_tasks (Bundler::Thor)

::printable_tasks (Bundler::Thor::Group)

::provides? (Bundler::RubygemsIntegration)

::pwd (Bundler::FileUtils)

::rake_classes (Bundler::Thor::RakeCompat)

::read_file (Bundler)

::readline (Bundler::Thor::LineEditor)

::reformatted_help_args (Bundler::CLI)

::regexp (Bundler::URI)

::register (Bundler::Thor)

::release? (Bundler::BuildMetadata)

::remove (Bundler::FileUtils)

::remove (Bundler::Injector)

::remove_dir (Bundler::FileUtils)

::remove_entry (Bundler::FileUtils)

::remove_entry_secure (Bundler::FileUtils)

::remove_file (Bundler::FileUtils)

::remove_invocation (Bundler::Thor::Group)

::report (Bundler::Env)

::require (Bundler)

::require_thor_actions (Bundler)

::requires_sudo? (Bundler)

::reset! (Bundler)

::reset_paths! (Bundler)

::reset_rubygems! (Bundler)

::reset_settings_and_root! (Bundler)

::resolve (Bundler::Resolver)

::rm (Bundler::FileUtils)

::rm_f (Bundler::FileUtils)

::rm_r (Bundler::FileUtils)

::rm_rf (Bundler)

::rm_rf (Bundler::FileUtils)

::rmdir (Bundler::FileUtils)

::rmtree (Bundler::FileUtils)

::root (Bundler)

::ruby_command (Bundler::Thor::Util)

::ruby_scope (Bundler)

::rubygems (Bundler)

::safe_unlink (Bundler::FileUtils)

::same_deps (Bundler::GemHelpers)

::same_specificity (Bundler::GemHelpers)

::scheme_list (Bundler::URI)

::sections_in_lockfile (Bundler::LockfileParser)

::sections_to_ignore (Bundler::LockfileParser)

::select_best_platform_match (Bundler::GemHelpers)

::select_spec (Bundler::CLI::Common)

::settings (Bundler)

::setup (Bundler)

::shell (Bundler::Thor::Base)

::skip (Bundler::Deprecate)

::skip= (Bundler::Deprecate)

::skip_during (Bundler::Deprecate)

::snake_case (Bundler::Thor::Util)

::sort_specs (Bundler::Index)

::source (Bundler::Plugin::API)

::source_root (Bundler::CLI)

::specificity_score (Bundler::GemHelpers::PlatformMatch)

::specs_path (Bundler)

::split (Bundler::URI)

::start (Bundler::CLI)

::status_code (Bundler::BundlerError)

::stop_on_unknown_option! (Bundler::Thor)

::subclass_files (Bundler::Thor::Base)

::subclasses (Bundler::Thor::Base)

::subcommand (Bundler::Thor)

::subcommand_classes (Bundler::Thor)

::subcommand_help (Bundler::Thor)

::subcommands (Bundler::Thor)

::subtask (Bundler::Thor)

::subtask_help (Bundler::Thor)

::subtasks (Bundler::Thor)

::sudo (Bundler)

::symlink (Bundler::FileUtils)

::system (Bundler::RubyVersion)

::system_bindir (Bundler)

::tag_prefix= (Bundler::GemHelper)

::task_help (Bundler::Thor)

::thor_classes_in (Bundler::Thor::Util)

::thor_root (Bundler::Thor::Util)

::thor_root_glob (Bundler::Thor::Util)

::tmp (Bundler)

::tmpdir (Bundler::Dir)

::to_h (Bundler::BuildMetadata)

::touch (Bundler::FileUtils)

::tsort (Bundler::Molinillo::DependencyGraph)

::ui (Bundler)

::ui= (Bundler)

::unbundled_env (Bundler)

::unbundled_exec (Bundler)

::unbundled_system (Bundler)

::unknown_sections_in_lockfile (Bundler::LockfileParser)

::uptodate? (Bundler::FileUtils)

::use_system_gems? (Bundler)

::user_bundle_path (Bundler)

::user_cache (Bundler)

::user_home (Bundler)

::user_home (Bundler::Thor::Util)

::validate! (Bundler::Settings::Validator)

::verbalize_groups (Bundler::CLI::Common)

::version (Bundler::RubygemsIntegration)

::which (Bundler)

::with_clean_env (Bundler)

::with_friendly_errors (Bundler)

::with_original_env (Bundler)

::with_unbundled_env (Bundler)

::without_groups_message (Bundler::CLI::Common)

::wrap (Bundler::ConnectionPool)

::write (Bundler::Env)

#+ (Bundler::URI::Generic)

#- (Bundler::URI::Generic)

#<< (Bundler::ConnectionPool::TimedStack)

#<< (Bundler::Index)

#<< (Bundler::SpecSet)

#<=> (Bundler::Molinillo::Resolver::Resolution::UnwindDetails)

#<=> (Bundler::RemoteSpecification)

#<=> (Bundler::VersionRanges::ReqR)

#== (Bundler::Index)

#== (Bundler::LazySpecification)

#== (Bundler::Molinillo::DependencyGraph)

#== (Bundler::Molinillo::DependencyGraph::Vertex)

#== (Bundler::Plugin::API::Source)

#== (Bundler::Resolver::SpecGroup)

#== (Bundler::RubyVersion)

#== (Bundler::Settings::Mirror)

#== (Bundler::Source::Git)

#== (Bundler::Source::Metadata)

#== (Bundler::Source::Path)

#== (Bundler::Source::Rubygems)

#== (Bundler::URI::Generic)

#== (Gem::Requirement::OrderIndependentComparison)

#[] (Bundler::Index)

#[] (Bundler::Settings)

#[] (Bundler::SpecSet)

#[]= (Bundler::SpecSet)

#__materialize__ (Bundler::LazySpecification)

#__swap__ (Bundler::EndpointSpecification)

#__swap__ (Bundler::RemoteSpecification)

#_local_specification (Bundler::EndpointSpecification)

#_path_to? (Bundler::Molinillo::DependencyGraph::Vertex)

#_recursive_predecessors (Bundler::Molinillo::DependencyGraph::Vertex)

#_recursive_successors (Bundler::Molinillo::DependencyGraph::Vertex)

#_requirements_sorted? (Gem::Requirement::OrderIndependentComparison)

#_with_sorted_requirements (Gem::Requirement::OrderIndependentComparison)

#absolute (Bundler::URI::Generic)

#absolute? (Bundler::URI::Generic)

#action (Bundler::PermissionError)

#activated (Bundler::Molinillo::Delegates::ResolutionState)

#activated (Bundler::StubSpecification)

#activated= (Bundler::StubSpecification)

#add (Bundler::CLI)

#add_child_vertex (Bundler::Molinillo::DependencyGraph)

#add_color (Bundler::UI::Shell)

#add_color (Bundler::UI::Silent)

#add_command (Bundler::Plugin)

#add_default_gems_to (Bundler::RubygemsIntegration)

#add_dependency_names (Bundler::Plugin::API::Source)

#add_dependency_names (Bundler::Source)

#add_edge (Bundler::Molinillo::DependencyGraph)

#add_edge_no_circular (Bundler::Molinillo::DependencyGraph::Log)

#add_file (Bundler::Thor::Actions)

#add_git_source (Bundler::Plugin::SourceList)

#add_git_source (Bundler::SourceList)

#add_global_rubygems_remote (Bundler::SourceList)

#add_hook (Bundler::Plugin)

#add_link (Bundler::Thor::Actions)

#add_path_source (Bundler::SourceList)

#add_platform (Bundler::Definition)

#add_plugin_source (Bundler::SourceList)

#add_remote (Bundler::Source::Rubygems)

#add_rubygems_source (Bundler::Plugin::SourceList)

#add_rubygems_source (Bundler::SourceList)

#add_runtime_options! (Bundler::Thor::Actions::ClassMethods)

#add_source (Bundler::Index)

#add_source (Bundler::Plugin)

#add_to_load_path (Bundler::RubygemsIntegration)

#add_vertex (Bundler::Molinillo::DependencyGraph)

#add_vertex (Bundler::Molinillo::DependencyGraph::Log)

#after_resolution (Bundler::Molinillo::UI)

#after_resolution (Bundler::Resolver)

#aggregate_global_source? (Bundler::SourceList)

#all (Bundler::Settings)

#all? (Bundler::Settings::MirrorConfig)

#all_commands (Bundler::Thor::Base::ClassMethods)

#all_dependencies (Bundler::ParallelInstaller::SpecInstallation)

#all_requirements (Bundler::Molinillo::Resolver::Resolution::UnwindDetails)

#all_requirements (Bundler::SourceMap)

#all_sources (Bundler::Plugin::SourceList)

#all_sources (Bundler::SourceList)

#all_specs (Bundler::RubygemsIntegration)

#all_tasks (Bundler::Thor::Base::ClassMethods)

#allow_git_ops? (Bundler::Source::Git)

#allow_incompatible_default_type! (Bundler::Thor::Base::ClassMethods)

#allow_missing? (Bundler::Molinillo::Delegates::SpecificationProvider)

#allow_missing? (Bundler::Molinillo::SpecificationProvider)

#allow_sudo? (Bundler::Settings)

#allowed_push_host (Bundler::GemHelper)

#already_tagged? (Bundler::GemHelper)

#ancestor? (Bundler::Molinillo::DependencyGraph::Vertex)

#answer_match (Bundler::Thor::Shell::Basic)

#any? (Bundler::MirrorSockets)

#api_fetcher? (Bundler::Fetcher::Base)

#api_fetcher? (Bundler::Fetcher::CompactIndex)

#api_fetcher? (Bundler::Fetcher::Dependency)

#api_fetchers (Bundler::Source::Rubygems)

#app_cache_dirname (Bundler::Plugin::API::Source)

#app_cache_dirname (Bundler::Source::Git)

#app_cache_dirname (Bundler::Source::Path)

#app_cache_path (Bundler::Plugin::API::Source)

#app_cache_path (Bundler::Settings)

#append_file (Bundler::Thor::Actions)

#append_to_file (Bundler::Thor::Actions)

#apply (Bundler::Thor::Actions)

#are_colors_disabled? (Bundler::Thor::Shell::Color)

#are_colors_supported? (Bundler::Thor::Shell::Color)

#argument (Bundler::Thor::Base::ClassMethods)

#arguments (Bundler::Thor::Base::ClassMethods)

#as_path_source (Bundler::Source::Gemspec)

#as_unicode (Bundler::Thor::Shell::Basic)

#ask (Bundler::Thor::Shell::Basic)

#ask (Bundler::Thor::Shell::HTML)

#ask (Bundler::UI::Shell)

#ask (Bundler::UI::Silent)

#ask_filtered (Bundler::Thor::Shell::Basic)

#ask_simply (Bundler::Thor::Shell::Basic)

#attempt (Bundler::Retry)

#attempts (Bundler::Retry)

#attributes (Bundler::URI::LDAP)

#attributes= (Bundler::URI::LDAP)

#available (Bundler::ConnectionPool)

#available? (Bundler::Fetcher::Base)

#available? (Bundler::Fetcher::CompactIndex)

#available? (Bundler::Fetcher::Dependency)

#backport_ext_builder_monitor (Bundler::RubygemsIntegration)

#backup (Bundler::EnvironmentPreserver)

#base (Bundler::CLI::Config)

#basename (Bundler::Thor::Base::ClassMethods)

#before_resolution (Bundler::Molinillo::UI)

#before_resolution (Bundler::Resolver)

#bin_path (Bundler::RubygemsIntegration)

#bindir (Bundler::EndpointSpecification)

#binstubs (Bundler::CLI)

#branch (Bundler::Source::Git::GitProxy)

#build (Bundler::RubygemsIntegration)

#build_args (Bundler::RubygemsIntegration)

#build_args= (Bundler::RubygemsIntegration)

#build_checksum (Bundler::GemHelper)

#build_extensions (Bundler::RubyGemsGemInstaller)

#build_gem (Bundler::GemHelper)

#build_gem (Bundler::RubygemsIntegration)

#built_gem_path (Bundler::GemHelper)

#builtin_gem? (Bundler::Source::Rubygems)

#bundler_plugin_api_source? (Bundler::Plugin::API::Source)

#bundles_for_gem (Bundler::CLI::Doctor)

#ca_file= (Bundler::Persistent::Net::HTTP::Persistent)

#ca_path= (Bundler::Persistent::Net::HTTP::Persistent)

#cache (Bundler::CLI)

#cache (Bundler::Plugin)

#cache (Bundler::Plugin::API::Source)

#cache (Bundler::Runtime)

#cache (Bundler::Source::Git)

#cache (Bundler::Source::Path)

#cache (Bundler::Source::Rubygems)

#cache_dir (Bundler::Plugin::API)

#cache_path (Bundler::Plugin::Installer::Git)

#cache_path (Bundler::Source::Git)

#cache_path (Bundler::Source::Rubygems)

#cache_slug (Bundler::Source::Rubygems::Remote)

#cached! (Bundler::Plugin::API::Source)

#cached! (Bundler::Source)

#cached! (Bundler::Source::Path)

#cached! (Bundler::Source::Rubygems)

#cached! (Bundler::SourceList)

#cached_built_in_gem (Bundler::Source::Rubygems)

#cached_gem (Bundler::Source::Rubygems)

#cached_path (Bundler::Source::Rubygems)

#cached_specs (Bundler::Source::Rubygems)

#call (Bundler::ParallelInstaller)

#can_display_colors? (Bundler::Thor::Shell::Basic)

#can_display_colors? (Bundler::Thor::Shell::Color)

#can_display_colors? (Bundler::Thor::Shell::HTML)

#can_lock? (Bundler::Plugin::API::Source)

#can_lock? (Bundler::Source)

#can_lock? (Bundler::Source::Rubygems)

#cert= (Bundler::Persistent::Net::HTTP::Persistent)

#cert_store= (Bundler::Persistent::Net::HTTP::Persistent)

#certificate= (Bundler::Persistent::Net::HTTP::Persistent)

#chdir (Bundler::SharedHelpers)

#check (Bundler::CLI)

#check! (Bundler::CLI::Doctor)

#check_default_type! (Bundler::Thor::Base::ClassMethods)

#check_executable_overwrite (Bundler::RubyGemsGemInstaller)

#check_for_corrupt_lockfile (Bundler::ParallelInstaller)

#check_for_unmet_dependencies (Bundler::ParallelInstaller)

#check_password (Bundler::URI::File)

#check_primary_source_safety (Bundler::Dsl)

#check_unknown_options! (Bundler::Thor::Base::ClassMethods)

#check_user (Bundler::URI::File)

#check_userinfo (Bundler::URI::File)

#checkin (Bundler::ConnectionPool)

#checkout (Bundler::ConnectionPool)

#checkout (Bundler::Source::Git::GitProxy)

#checksum_for_file (Bundler::CompactIndexClient::Updater)

#checksums (Bundler::CompactIndexClient::Cache)

#chmod (Bundler::Thor::Actions)

#ciphers= (Bundler::Persistent::Net::HTTP::Persistent)

#class_option (Bundler::Thor::Base::ClassMethods)

#class_options (Bundler::Thor::Base::ClassMethods)

#clean (Bundler::CLI)

#clean (Bundler::Runtime)

#clean? (Bundler::GemHelper)

#clear_paths (Bundler::RubygemsIntegration)

#cli_help (Bundler::CLI)

#clone (Bundler::DepProxy)

#coerce (Bundler::URI::Generic)

#command? (Bundler::Plugin)

#command_plugin (Bundler::Plugin::Index)

#commands (Bundler::Thor::Base::ClassMethods)

#comment_lines (Bundler::Thor::Actions)

#committed? (Bundler::GemHelper)

#component (Bundler::URI::Generic)

#component_ary (Bundler::URI::Generic)

#configuration (Bundler::RubygemsIntegration)

#confirm (Bundler::CLI::Config::Base)

#confirm (Bundler::UI::Shell)

#confirm (Bundler::UI::Silent)

#confirm_all (Bundler::CLI::Config::Base)

#conflicts (Bundler::Molinillo::Delegates::ResolutionState)

#connection_for (Bundler::Persistent::Net::HTTP::Persistent)

#connection_for (Bundler::PersistentHTTP)

#console (Bundler::CLI)

#const_get_safely (Bundler::SharedHelpers)

#contains? (Bundler::Source::Git::GitProxy)

#contents (Bundler::Dsl::DSLError)

#convert_to_backward_compatible_key (Bundler::YAMLSerializer)

#copy_file (Bundler::Thor::Actions)

#copy_to (Bundler::Source::Git::GitProxy)

#correct_for_windows_path (Bundler::RubygemsIntegration)

#corrections (UndefinedCommandError::SpellChecker)

#corrections (UnknownArgumentError::SpellChecker)

#cover? (Bundler::VersionRanges::ReqR)

#create_file (Bundler::Thor::Actions)

#create_link (Bundler::Thor::Actions)

#credential_filtered_string (Bundler::URICredentialsFilter)

#credential_filtered_uri (Bundler::URICredentialsFilter)

#credentials_for (Bundler::Settings)

#credless_remotes (Bundler::Source::Rubygems)

#current_branch (Bundler::GemHelper)

#current_command_chain (Bundler::Thor::Invocation)

#current_dependencies (Bundler::Definition)

#current_dependencies (Bundler::Gemdeps)

#current_env? (Bundler::Dependency)

#current_platform? (Bundler::Dependency)

#debug (Bundler::Molinillo::UI)

#debug (Bundler::Resolver)

#debug (Bundler::UI::Shell)

#debug (Bundler::UI::Silent)

#debug? (Bundler::Molinillo::UI)

#debug? (Bundler::Resolver)

#debug? (Bundler::UI::Shell)

#debug? (Bundler::UI::Silent)

#decode (Bundler::URI::Escape)

#default_bundle_dir (Bundler::SharedHelpers)

#default_gem? (Bundler::StubSpecification)

#default_gemfile (Bundler::SharedHelpers)

#default_lockfile (Bundler::SharedHelpers)

#default_port (Bundler::URI::Generic)

#default_remote (Bundler::GemHelper)

#default_source (Bundler::Plugin::SourceList)

#default_source (Bundler::SourceList)

#default_stubs (Bundler::RubygemsIntegration)

#delete_edge (Bundler::Molinillo::DependencyGraph)

#delete_edge (Bundler::Molinillo::DependencyGraph::Log)

#dependencies (Bundler::CompactIndexClient)

#dependencies (Bundler::CompactIndexClient::Cache)

#dependencies (Bundler::Gemdeps)

#dependencies (Bundler::ParallelInstaller::SpecInstallation)

#dependencies (Bundler::RemoteSpecification)

#dependencies_eql? (Bundler::Index)

#dependencies_equal? (Bundler::Molinillo::Delegates::SpecificationProvider)

#dependencies_equal? (Bundler::Molinillo::SpecificationProvider)

#dependencies_equal? (Bundler::Resolver)

#dependencies_for (Bundler::Definition)

#dependencies_for (Bundler::Molinillo::Delegates::SpecificationProvider)

#dependencies_for (Bundler::Molinillo::SpecificationProvider)

#dependencies_for (Bundler::Resolver)

#dependencies_for_activated_platforms (Bundler::Resolver::SpecGroup)

#dependencies_installed? (Bundler::ParallelInstaller::SpecInstallation)

#dependency_api_available? (Bundler::Source::Rubygems)

#dependency_api_uri (Bundler::Fetcher::Dependency)

#dependency_names (Bundler::Index)

#dependency_names_to_double_check (Bundler::Source)

#dependency_names_to_double_check (Bundler::Source::Rubygems)

#dependency_specs (Bundler::Fetcher::Dependency)

#depth (Bundler::Molinillo::Delegates::ResolutionState)

#deq (Bundler::Worker)

#descendent? (Bundler::Molinillo::DependencyGraph::Vertex)

#destination_root (Bundler::Thor::Actions)

#destination_root= (Bundler::Thor::Actions)

#detach_vertex_named (Bundler::Molinillo::DependencyGraph)

#detach_vertex_named (Bundler::Molinillo::DependencyGraph::Log)

#diff (Bundler::RubyVersion)

#digest (Bundler::SharedHelpers)

#direct_requirements (Bundler::SourceMap)

#directory (Bundler::Thor::Actions)

#disable! (Bundler::FriendlyErrors)

#disabled? (Bundler::FriendlyErrors)

#dn (Bundler::URI::LDAP)

#dn= (Bundler::URI::LDAP)

#doctor (Bundler::CLI)

#doctor (Bundler::CLI::Issue)

#double_check_for (Bundler::Plugin::API::Source)

#double_check_for (Bundler::Source)

#double_check_for (Bundler::Source::Rubygems)

#down (Bundler::Molinillo::DependencyGraph::Action)

#down (Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular)

#down (Bundler::Molinillo::DependencyGraph::DeleteEdge)

#down (Bundler::Molinillo::DependencyGraph::DetachVertexNamed)

#down (Bundler::Molinillo::DependencyGraph::Tag)

#download_gem (Bundler::RubygemsIntegration)

#dump (Bundler::YAMLSerializer)

#dump_hash (Bundler::YAMLSerializer)

#dup (Bundler::DepProxy)

#dylibs (Bundler::CLI::Doctor)

#dylibs_darwin (Bundler::CLI::Doctor)

#dylibs_ldd (Bundler::CLI::Doctor)

#dynamic_width (Bundler::Thor::Shell::Basic)

#dynamic_width_stty (Bundler::Thor::Shell::Basic)

#dynamic_width_tput (Bundler::Thor::Shell::Basic)

#each (Bundler::Index)

#each (Bundler::Molinillo::DependencyGraph)

#each (Bundler::Molinillo::DependencyGraph::Log)

#each (Bundler::Settings::Mirrors)

#each (Bundler::SpecSet)

#empty? (Bundler::ConnectionPool::TimedStack)

#empty? (Bundler::Index)

#empty? (Bundler::SpecSet)

#empty? (Bundler::VersionRanges::ReqR)

#empty_directory (Bundler::Thor::Actions)

#enable! (Bundler::FriendlyErrors)

#encode (Bundler::URI::Escape)

#encode_with (Gem::Dependency)

#enq (Bundler::Worker)

#enqueued? (Bundler::ParallelInstaller::SpecInstallation)

#ensure_equivalent_gemfile_and_lockfile (Bundler::Definition)

#ensure_same_dependencies (Bundler::SharedHelpers)

#enter (Bundler::Thor::NestedContext)

#entered? (Bundler::Thor::NestedContext)

#env (Bundler::CLI)

#env (Bundler::Dsl)

#eql? (Bundler::LazySpecification)

#eql? (Bundler::Molinillo::DependencyGraph::Vertex)

#eql? (Bundler::Plugin::API::Source)

#eql? (Bundler::Resolver::SpecGroup)

#eql? (Bundler::Source::Git)

#eql? (Bundler::Source::Metadata)

#eql? (Bundler::Source::Path)

#eql? (Bundler::Source::Rubygems)

#eql? (Bundler::URI::Generic)

#equivalent_remotes? (Bundler::Source::Rubygems)

#error (Bundler::Thor::Shell::Basic)

#error (Bundler::UI::Shell)

#error (Bundler::UI::Silent)

#escape (Bundler::Persistent::Net::HTTP::Persistent)

#escape (Bundler::URI::Escape)

#escape (Bundler::URI::RFC2396_Parser)

#escape (Bundler::URI::RFC2396_Parser)

#etag_for (Bundler::CompactIndexClient::Updater)

#eval_gemfile (Bundler::Dsl)

#exact? (Bundler::RubyVersion)

#exec (Bundler::CLI)

#exec_command (Bundler::Plugin)

#executables (Bundler::EndpointSpecification)

#execution_mode (Bundler::CompactIndexClient)

#execution_mode= (Bundler::CompactIndexClient)

#exit_on_failure? (Bundler::Thor::Base::ClassMethods)

#exit_status (Bundler::FriendlyErrors)

#expanded_original_path (Bundler::Source::Path)

#expanded_platforms (Bundler::Dependency)

#expired? (Bundler::Persistent::Net::HTTP::Persistent)

#expired_sources? (Bundler::SourceList)

#explicit_scope? (Bundler::CLI::Config::Base)

#ext_lock (Bundler::RubygemsIntegration)

#extension_cache_path (Bundler::Source)

#extension_dir (Gem::Specification)

#extension_dir_name (Bundler::Source::Git)

#extensions (Bundler::EndpointSpecification)

#extensions (Bundler::StubSpecification)

#extensions (Bundler::URI::LDAP)

#extensions= (Bundler::URI::LDAP)

#extract (Bundler::URI::RFC2396_Parser)

#extract (Bundler::URI::RFC2396_Parser)

#fail! (Bundler::Settings::Validator::Rule)

#failed? (Bundler::ParallelInstaller::SpecInstallation)

#fallback_timeout= (Bundler::Settings::Mirror)

#fetch (Bundler::Fetcher::Downloader)

#fetch_all_remote_specs (Bundler::RubygemsIntegration)

#fetch_gem (Bundler::Source::Rubygems)

#fetch_gemspec_files (Bundler::Plugin::API::Source)

#fetch_names (Bundler::Source::Rubygems)

#fetch_platform (Bundler::EndpointSpecification)

#fetch_platform (Bundler::RemoteSpecification)

#fetch_spec (Bundler::Fetcher)

#fetch_spec (Bundler::Fetcher::CompactIndex)

#fetch_spec (Bundler::Fetcher::Index)

#fetch_specs (Bundler::RubygemsIntegration)

#fetch_uri (Bundler::Fetcher::Base)

#fetchers (Bundler::Fetcher)

#fetchers (Bundler::Source::Rubygems)

#file_collision (Bundler::Thor::Shell::Basic)

#filesystem_access (Bundler::SharedHelpers)

#filter (Bundler::URI::LDAP)

#filter= (Bundler::URI::LDAP)

#filter_uri (Bundler::HTTPError)

#find_by_name_and_platform (Bundler::SpecSet)

#find_in_source_paths (Bundler::Thor::Actions)

#find_name (Bundler::RubygemsIntegration)

#find_proxy (Bundler::URI::Generic)

#finish (Bundler::Persistent::Net::HTTP::Persistent)

#for (Bundler::Settings::Mirrors)

#for (Bundler::SpecSet)

#formatted_usage (Bundler::Thor::Command)

#formatted_usage (Bundler::Thor::Command)

#fragment= (Bundler::URI::Generic)

#from_superclass (Bundler::Thor::Base::ClassMethods)

#full_gem_path (Bundler::StubSpecification)

#full_gem_path (Gem::Specification)

#full_name (Bundler::LazySpecification)

#full_name (Bundler::RemoteSpecification)

#full_require_paths (Bundler::StubSpecification)

#full_version (Bundler::Source::Git::GitProxy)

#fund (Bundler::CLI)

#g (Bundler::Graph::GraphVizClient)

#gem (Bundler::Dsl)

#gem_bindir (Bundler::RubygemsIntegration)

#gem_build_complete_path (Bundler::StubSpecification)

#gem_cache (Bundler::RubygemsIntegration)

#gem_command (Bundler::GemHelper)

#gem_dir (Bundler::RubygemsIntegration)

#gem_dir (Gem::Specification)

#gem_from_path (Bundler::RubygemsIntegration)

#gem_install_dir (Bundler::Plugin::API::Source)

#gem_key (Bundler::GemHelper)

#gem_mirrors (Bundler::Settings)

#gem_path (Bundler::RubygemsIntegration)

#gem_platforms (Bundler::Dependency)

#gem_push? (Bundler::GemHelper)

#gem_push_host (Bundler::GemHelper)

#gem_remote_fetcher (Bundler::RubygemsIntegration)

#gem_version_promoter (Bundler::Definition)

#gemfile (Object)

#gemfile_install (Bundler::Plugin)

#gemspec (Bundler::Dsl)

#generate (Bundler::Standalone)

#generate! (Bundler::LockfileGenerator)

#generate_bin (Bundler::Plugin::Installer::Git)

#generate_bundler_executable_stubs (Bundler::Installer)

#generate_plugins (Bundler::RubyGemsGemInstaller)

#generate_standalone_bundler_executable_stubs (Bundler::Installer)

#get (Bundler::CLI::Config)

#get (Bundler::SourceList)

#get (Bundler::Thor::Actions)

#get_console (Bundler::CLI::Console)

#get_constant (Bundler::CLI::Console)

#get_formatted_specs_and_deps (Bundler::Fetcher::Dependency)

#get_time (Bundler::ConnectionPool)

#git (Bundler::Dsl)

#git_push (Bundler::GemHelper)

#git_source (Bundler::Dsl)

#git_version (Bundler::LazySpecification)

#git_version (Bundler::RemoteSpecification)

#git_version (Gem::Specification)

#github (Bundler::Dsl)

#glob_files_in_dir (Gem)

#global_index_file (Bundler::Plugin::Index)

#global_root (Bundler::Plugin)

#global_rubygems_source (Bundler::SourceList)

#group (Bundler::Dsl)

#group (Bundler::Thor::Base::ClassMethods)

#groups (Bundler::Definition)

#groups (Gem::Specification)

#gsub_file (Bundler::Thor::Actions)

#guard_clean (Bundler::GemHelper)

#handle_argument_error? (Bundler::Thor::Command)

#handle_argument_error? (Bundler::Thor::Command)

#handle_no_method_error? (Bundler::Thor::Command)

#handle_no_method_error? (Bundler::Thor::Command)

#has_post_install_message? (Bundler::ParallelInstaller::SpecInstallation)

#has_rubygems_remotes? (Bundler::Definition)

#hash (Bundler::LazySpecification)

#hash (Bundler::Molinillo::DependencyGraph::Vertex)

#hash (Bundler::Plugin::API::Source)

#hash (Bundler::Resolver::SpecGroup)

#hash (Bundler::Source::Git)

#hash (Bundler::Source::Metadata)

#hash (Bundler::Source::Path)

#hash (Bundler::Source::Rubygems)

#hash (Bundler::URI::Generic)

#hash (Gem::Platform)

#hash (Gem::Requirement::CorrectHashForLambdaOperator)

#headers= (Bundler::URI::MailTo)

#help (Bundler::CLI)

#help (Bundler::Thor)

#hidden? (Bundler::Thor::Command)

#hidden? (Bundler::Thor::Command)

#hidden? (Bundler::Thor::HiddenCommand)

#hidden? (Bundler::Thor::HiddenCommand)

#hierarchical? (Bundler::URI::Generic)

#hierarchical? (Bundler::URI::LDAP)

#hook (Bundler::Plugin)

#hook_plugins (Bundler::Plugin::Index)

#host (Bundler::RubyVersion)

#host= (Bundler::URI::Generic)

#hostname (Bundler::URI::Generic)

#hostname= (Bundler::URI::Generic)

#http_proxy (Bundler::Fetcher)

#http_version (Bundler::Persistent::Net::HTTP::Persistent)

#identifier (Bundler::LazySpecification)

#ignorable_dependency? (Bundler::ParallelInstaller::SpecInstallation)

#ignore_config? (Bundler::Settings)

#in_bundle? (Bundler::SharedHelpers)

#in_root (Bundler::Thor::Actions)

#include? (Bundler::Plugin::API::Source)

#include? (Bundler::Source)

#include? (Bundler::Source::Rubygems)

#indent (Bundler::Thor::Shell::Basic)

#index (Bundler::Plugin)

#index_file (Bundler::Plugin::Index)

#index_for (Bundler::Resolver)

#indicate_progress (Bundler::Molinillo::UI)

#indicate_progress (Bundler::Resolver)

#inflate (Bundler::RubygemsIntegration)

#info (Bundler::CLI)

#info (Bundler::UI::Shell)

#info (Bundler::UI::Silent)

#info_path (Bundler::CompactIndexClient::Cache)

#inherited (Bundler::Thor::Base::ClassMethods)

#init (Bundler::CLI)

#initialize_copy (Bundler::Index)

#initialize_copy (Bundler::Molinillo::DependencyGraph)

#inject (Bundler::CLI)

#inject (Bundler::Injector)

#inject_into_class (Bundler::Thor::Actions)

#inject_into_file (Bundler::Thor::Actions)

#inject_into_module (Bundler::Thor::Actions)

#insert_into_file (Bundler::Thor::Actions)

#inside (Bundler::Thor::Actions)

#inspect (Bundler::Fetcher)

#inspect (Bundler::Index)

#inspect (Bundler::Molinillo::DependencyGraph)

#inspect (Bundler::Molinillo::DependencyGraph::Vertex)

#inspect (Bundler::Source)

#inspect (Bundler::URI::Generic)

#inspect (Bundler::URI::RFC2396_Parser)

#inspect (Bundler::URI::RFC2396_Parser)

#install (Bundler::CLI)

#install (Bundler::CLI::Plugin)

#install (Bundler::GemHelper)

#install (Bundler::Plugin)

#install (Bundler::Plugin::API::Source)

#install (Bundler::Plugin::Installer)

#install (Bundler::RubyGemsGemInstaller)

#install (Bundler::Source::Git)

#install (Bundler::Source::Metadata)

#install (Bundler::Source::Path)

#install (Bundler::Source::Rubygems)

#install_definition (Bundler::Plugin::Installer)

#install_from_spec (Bundler::GemInstaller)

#install_gem (Bundler::GemHelper)

#install_if (Bundler::Dsl)

#install_path (Bundler::Plugin::API::Source)

#install_path (Bundler::Plugin::Installer::Git)

#install_path (Bundler::Source::Git)

#install_with_build_args (Bundler::RubygemsIntegration)

#installed? (Bundler::ParallelInstaller::SpecInstallation)

#installed? (Bundler::Plugin)

#installed? (Bundler::Plugin::API::Source)

#installed? (Bundler::Plugin::Index)

#installed? (Bundler::Source::Rubygems)

#installed_plugins (Bundler::Plugin::Index)

#installed_specs (Bundler::Source::Rubygems)

#invoke (Bundler::Thor::Invocation)

#invoke_with_padding (Bundler::Thor::Invocation)

#is_reachable_from? (Bundler::Molinillo::DependencyGraph::Vertex)

#issue (Bundler::CLI)

#issues_url (Bundler::FriendlyErrors)

#join (Bundler::URI::RFC2396_Parser)

#join (Bundler::URI::RFC2396_Parser)

#jruby? (Bundler::CurrentRuby)

#k (Bundler::Settings::Validator::Rule)

#key= (Bundler::Persistent::Net::HTTP::Persistent)

#key_for (Bundler::Settings)

#latest_version (Bundler::Molinillo::Resolver::Resolution::PossibilitySet)

#ldd_available? (Bundler::CLI::Doctor)

#length (Bundler::ConnectionPool::TimedStack)

#length (Bundler::SpecSet)

#level (Bundler::UI::Shell)

#level (Bundler::UI::Silent)

#level= (Bundler::GemVersionPromoter)

#level= (Bundler::UI::Shell)

#level= (Bundler::UI::Silent)

#levenshtein_distance (Bundler::SimilarityDetector)

#licenses (Bundler::CLI)

#link_file (Bundler::Thor::Actions)

#list (Bundler::CLI)

#list (Bundler::CLI::Config)

#list (Bundler::CLI::Plugin)

#list (Bundler::Plugin)

#load (Bundler::YAMLSerializer)

#load_env_plugins (Bundler::RubygemsIntegration)

#load_paths (Bundler::EndpointSpecification)

#load_paths (Bundler::Plugin::Index)

#load_paths (Bundler::StubSpecification)

#load_paths (Gem::Specification)

#load_plugin (Bundler::Plugin)

#load_plugin_files (Bundler::RubygemsIntegration)

#load_plugins (Bundler::RubygemsIntegration)

#load_spec_files (Bundler::Source::Git)

#loaded_from (Bundler::Source::Rubygems)

#loaded_from (Bundler::StubSpecification)

#loaded_from (Gem::Specification)

#loaded_gem_paths (Bundler::RubygemsIntegration)

#loaded_specs (Bundler::RubygemsIntegration)

#local! (Bundler::Plugin::API::Source)

#local! (Bundler::Source)

#local! (Bundler::Source::Rubygems)

#local? (Bundler::Source::Git)

#local_index_file (Bundler::Plugin::Index)

#local_method? (Bundler::Thor::Command)

#local_method? (Bundler::Thor::Command)

#local_only! (Bundler::Source)

#local_only! (Bundler::Source::Rubygems)

#local_only! (Bundler::SourceList)

#local_override! (Bundler::Source::Git)

#local_overrides (Bundler::Settings)

#local_root (Bundler::Plugin)

#local_search (Bundler::Index)

#local_specs (Bundler::Source::Path)

#locations (Bundler::Settings)

#lock (Bundler::CLI)

#lock (Bundler::Definition)

#lock (Bundler::Runtime)

#lock_other_sources (Bundler::SourceList)

#lock_rubygems_sources (Bundler::SourceList)

#lock_sources (Bundler::SourceList)

#locked_bundler_version (Bundler::Definition)

#locked_ruby_version (Bundler::Definition)

#locked_ruby_version_object (Bundler::Definition)

#log_error (Bundler::FriendlyErrors)

#lookup_color (Bundler::Thor::Shell::Basic)

#maglev? (Bundler::CurrentRuby)

#major? (Bundler::GemVersionPromoter)

#major_deprecation (Bundler::SharedHelpers)

#make_edge (Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular)

#make_edge (Bundler::Molinillo::DependencyGraph::DeleteEdge)

#make_regexp (Bundler::URI::RFC2396_Parser)

#make_regexp (Bundler::URI::RFC2396_Parser)

#manually_installed? (Bundler::StubSpecification)

#mark_loaded (Bundler::RubygemsIntegration)

#marshal_spec_dir (Bundler::RubygemsIntegration)

#match_platform (Bundler::MatchPlatform)

#matches (Bundler::Thor::LineEditor::Readline::PathCompletion)

#matches_for_glob (Bundler::StubSpecification)

#materialize (Bundler::SpecSet)

#materialized_for_all_platforms (Bundler::SpecSet)

#max_retries= (Bundler::Persistent::Net::HTTP::Persistent)

#max_version= (Bundler::Persistent::Net::HTTP::Persistent)

#md5_available? (Bundler::SharedHelpers)

#merge (Bundler::SpecSet)

#merge (Bundler::URI::Generic)

#merge! (Bundler::URI::Generic)

#merged_gem_lockfile_sections! (Bundler::SourceList)

#merged_gem_lockfile_sections? (Bundler::SourceList)

#message (Bundler::CLI::Config::Base)

#message (Bundler::CompactIndexClient::Updater::MisMatchedChecksumError)

#message (Bundler::Molinillo::NoSuchDependencyError)

#message (Bundler::NoSpaceOnDeviceError)

#message (Bundler::OperationNotSupportedError)

#message (Bundler::PermissionError)

#message (Bundler::TemporaryResourceError)

#message (Bundler::VirtualProtocolError)

#message_with_trees (Bundler::Molinillo::VersionConflict)

#method_added (Bundler::Thor::Base::ClassMethods)

#method_missing (Bundler::ConnectionPool::Wrapper)

#method_missing (Bundler::Dsl)

#method_missing (Bundler::Plugin::API)

#method_missing (Bundler::Plugin::DSL)

#method_visibility (Bundler::RubygemsIntegration)

#min_version= (Bundler::Persistent::Net::HTTP::Persistent)

#mingw? (Bundler::CurrentRuby)

#minor? (Bundler::GemVersionPromoter)

#mirror_for (Bundler::Settings)

#missing_extensions? (Bundler::StubSpecification)

#missing_lockfile_dependencies (Bundler::ParallelInstaller::SpecInstallation)

#missing_specs (Bundler::Definition)

#missing_specs? (Bundler::Definition)

#most_specific_locked_platform (Bundler::Definition)

#mri? (Bundler::CurrentRuby)

#mswin64? (Bundler::CurrentRuby)

#mswin? (Bundler::CurrentRuby)

#multiple_remotes? (Bundler::Source::Rubygems)

#multisource_allowed? (Bundler::Definition)

#mute (Bundler::Thor::Shell::Basic)

#mute? (Bundler::Thor::Shell::Basic)

#name (Bundler::DepProxy)

#name (Bundler::GemHelper)

#name (Bundler::Molinillo::Delegates::ResolutionState)

#name (Bundler::Source::Git)

#name (Bundler::Source::Path)

#name (Bundler::Source::Rubygems)

#name_for (Bundler::Molinillo::Delegates::SpecificationProvider)

#name_for (Bundler::Molinillo::SpecificationProvider)

#name_for (Bundler::Resolver)

#name_for_explicit_dependency_source (Bundler::Molinillo::Delegates::SpecificationProvider)

#name_for_explicit_dependency_source (Bundler::Molinillo::SpecificationProvider)

#name_for_explicit_dependency_source (Bundler::Resolver)

#name_for_locking_dependency_source (Bundler::Molinillo::Delegates::SpecificationProvider)

#name_for_locking_dependency_source (Bundler::Molinillo::SpecificationProvider)

#name_for_locking_dependency_source (Bundler::Resolver)

#names (Bundler::CompactIndexClient)

#names (Bundler::CompactIndexClient::Cache)

#names_path (Bundler::CompactIndexClient::Cache)

#namespace (Bundler::Thor::Base::ClassMethods)

#namespace (Object)

#new_specs (Bundler::Definition)

#new_value (Bundler::CLI::Config::Base)

#no? (Bundler::Thor::Shell::Basic)

#no? (Bundler::UI::Shell)

#no? (Bundler::UI::Silent)

#no_commands (Bundler::Thor::Base::ClassMethods)

#no_commands? (Bundler::Thor::Base::ClassMethods)

#no_commands_context (Bundler::Thor::Base::ClassMethods)

#no_tasks (Bundler::Thor::Base::ClassMethods)

#non_default_explicit_sources (Bundler::SourceList)

#non_global_rubygems_sources (Bundler::SourceList)

#nondevelopment_dependencies (Gem::Specification)

#normalize (Bundler::URI::Generic)

#normalize! (Bundler::URI::Generic)

#normalize_uri (Bundler::Persistent::Net::HTTP::Persistent)

#normalize_uri (Bundler::Source::Rubygems)

#not_debugging? (Bundler::Thor::Command)

#not_debugging? (Bundler::Thor::Command)

#nothing_changed? (Bundler::Definition)

#opaque= (Bundler::URI::Generic)

#open (Bundler::CLI)

#options (Bundler::Source::Metadata)

#options (Bundler::Source::Rubygems)

#options_to_lock (Bundler::Plugin::API::Source)

#otool_available? (Bundler::CLI::Doctor)

#outdated (Bundler::CLI)

#output (Bundler::Molinillo::UI)

#padding= (Bundler::Thor::Shell::Basic)

#parse (Bundler::CompactIndexClient::GemParser)

#parse (Bundler::Settings::Mirrors)

#parse (Bundler::URI::RFC2396_Parser)

#parse (Bundler::URI::RFC2396_Parser)

#parser (Bundler::URI::Generic)

#password (Bundler::URI::Generic)

#password= (Bundler::URI::Generic)

#path (Bundler::Dsl)

#path (Bundler::RubygemsIntegration)

#path (Bundler::Settings)

#path (Bundler::Source::Git)

#path (Bundler::URI::FTP)

#path= (Bundler::URI::Generic)

#path? (Bundler::Source)

#path_separator (Bundler::RubygemsIntegration)

#path_to? (Bundler::Molinillo::DependencyGraph::Vertex)

#perform_git_push (Bundler::GemHelper)

#pinned_spec_names (Bundler::SourceMap)

#plain_specs (Bundler::RubygemsIntegration)

#plain_specs= (Bundler::RubygemsIntegration)

#platform (Bundler::CLI)

#platform (Bundler::Dsl)

#platform_string (Bundler::LazySpecification)

#platforms (Bundler::Dsl)

#plugin (Bundler::Dsl)

#plugin (Bundler::Plugin::DSL)

#plugin_commands (Bundler::Plugin::Index)

#plugin_path (Bundler::Plugin::Index)

#pool_available (Bundler::ConnectionPool::Wrapper)

#pool_shutdown (Bundler::ConnectionPool::Wrapper)

#pool_size (Bundler::ConnectionPool::Wrapper)

#pop (Bundler::ConnectionPool::TimedStack)

#pop! (Bundler::Molinillo::DependencyGraph::Log)

#pop_possibility_state (Bundler::Molinillo::DependencyState)

#port= (Bundler::URI::Generic)

#possibilities (Bundler::Molinillo::Delegates::ResolutionState)

#possibility (Bundler::Molinillo::Resolver::Resolution::Conflict)

#post_install (Bundler::Plugin::API::Source)

#post_install (Bundler::Source::Path::Installer)

#post_install_message (Bundler::EndpointSpecification)

#post_reset_hooks (Bundler::RubygemsIntegration)

#pre_install_checks (Bundler::RubyGemsGemInstaller)

#predecessors (Bundler::Molinillo::DependencyGraph::Vertex)

#prepare_message (Bundler::Thor::Shell::Basic)

#prepend_file (Bundler::Thor::Actions)

#prepend_to_file (Bundler::Thor::Actions)

#pretty_dependency (Bundler::SharedHelpers)

#pretty_values_for (Bundler::Settings)

#print_in_columns (Bundler::Thor::Shell::Basic)

#print_major_deprecations! (Bundler::SharedHelpers)

#print_options (Bundler::Thor::Base::ClassMethods)

#print_table (Bundler::Thor::Shell::Basic)

#print_wrapped (Bundler::Thor::Shell::Basic)

#pristine (Bundler::CLI)

#private_key= (Bundler::Persistent::Net::HTTP::Persistent)

#private_method? (Bundler::Thor::Command)

#private_method? (Bundler::Thor::Command)

#processor_count (Bundler::Settings)

#progress_rate (Bundler::Molinillo::UI)

#provides? (Bundler::RubygemsIntegration)

#proxy= (Bundler::Persistent::Net::HTTP::Persistent)

#proxy_bypass? (Bundler::Persistent::Net::HTTP::Persistent)

#proxy_from_env (Bundler::Persistent::Net::HTTP::Persistent)

#prune_cache (Bundler::Runtime)

#public_command (Bundler::Thor::Base::ClassMethods)

#public_task (Bundler::Thor::Base::ClassMethods)

#push (Bundler::ConnectionPool::TimedStack)

#pwd (Bundler::SharedHelpers)

#query= (Bundler::URI::Generic)

#quiet? (Bundler::UI::Shell)

#quiet? (Bundler::UI::Silent)

#rake_namespace (Object)

#raw_require_paths (Bundler::StubSpecification)

#rbx? (Bundler::CurrentRuby)

#read_binary (Bundler::RubygemsIntegration)

#readline (Bundler::Thor::LineEditor::Basic)

#readline (Bundler::Thor::LineEditor::Readline)

#ready_to_enqueue? (Bundler::ParallelInstaller::SpecInstallation)

#reconnect (Bundler::Persistent::Net::HTTP::Persistent)

#reconnect_ssl (Bundler::Persistent::Net::HTTP::Persistent)

#recursive_predecessors (Bundler::Molinillo::DependencyGraph::Vertex)

#recursive_successors (Bundler::Molinillo::DependencyGraph::Vertex)

#redefine_method (Bundler::RubygemsIntegration)

#register_plugin (Bundler::Plugin)

#register_plugin (Bundler::Plugin::Index)

#registry= (Bundler::URI::Generic)

#relative? (Bundler::URI::Generic)

#relative_to_original_destination_root (Bundler::Thor::Actions)

#remote! (Bundler::Plugin::API::Source)

#remote! (Bundler::Source)

#remote! (Bundler::Source::Path)

#remote! (Bundler::Source::Rubygems)

#remote! (Bundler::SourceList)

#remote_specs (Bundler::Source::Rubygems)

#remote_uri (Bundler::Fetcher::Base)

#remotes_for_spec (Bundler::Source::Rubygems)

#remove (Bundler::CLI)

#remove (Bundler::Injector)

#remove_argument (Bundler::Thor::Base::ClassMethods)

#remove_auth (Bundler::Source::Rubygems)

#remove_class_option (Bundler::Thor::Base::ClassMethods)

#remove_command (Bundler::Thor::Base::ClassMethods)

#remove_dir (Bundler::Thor::Actions)

#remove_file (Bundler::Thor::Actions)

#remove_platform (Bundler::Definition)

#remove_task (Bundler::Thor::Base::ClassMethods)

#removed_specs (Bundler::Definition)

#replace_bin_path (Bundler::RubygemsIntegration)

#replace_entrypoints (Bundler::RubygemsIntegration)

#replace_gem (Bundler::RubygemsIntegration)

#replace_sources! (Bundler::SourceList)

#replace_with_backup (Bundler::EnvironmentPreserver)

#replies? (Bundler::Settings::TCPSocketProbe)

#repository_subdirectories (Bundler::RubygemsIntegration)

#request (Bundler::Fetcher::Downloader)

#request (Bundler::Persistent::Net::HTTP::Persistent)

#request_issue_report_for (Bundler::FriendlyErrors)

#request_uri (Bundler::URI::HTTP)

#requested_dependencies (Bundler::Definition)

#requested_specs (Bundler::Definition)

#requested_specs (Bundler::Gemdeps)

#require (Bundler::Runtime)

#require_path_or_force (Bundler::CLI::Clean)

#require_paths (Bundler::EndpointSpecification)

#required_arguments_for (Bundler::Thor::Command)

#required_arguments_for (Bundler::Thor::Command)

#required_options (Bundler::Thor::Command)

#required_options (Bundler::Thor::Command)

#requirement (Bundler::DepProxy)

#requirement (Bundler::Molinillo::Delegates::ResolutionState)

#requirement_satisfied_by? (Bundler::Molinillo::Delegates::SpecificationProvider)

#requirement_satisfied_by? (Bundler::Molinillo::SpecificationProvider)

#requirement_satisfied_by? (Bundler::Resolver)

#requirements (Bundler::Molinillo::Delegates::ResolutionState)

#requirements (Bundler::Molinillo::DependencyGraph::Vertex)

#requires (Bundler::Gemdeps)

#requires_sudo? (Bundler::Source::Rubygems)

#reset (Bundler::Persistent::Net::HTTP::Persistent)

#reset (Bundler::RubygemsIntegration)

#reset! (Bundler::Plugin)

#resolve (Bundler::Definition)

#resolve (Bundler::Molinillo::Resolver)

#resolve (Bundler::Molinillo::Resolver::Resolution)

#resolve_only_locally! (Bundler::Definition)

#resolve_remotely! (Bundler::Definition)

#resolve_with_cache! (Bundler::Definition)

#respond_to? (Bundler::ConnectionPool::Wrapper)

#respond_to? (Bundler::LazySpecification)

#respond_to? (Bundler::RemoteSpecification)

#respond_to_missing? (Bundler::Plugin::API)

#restore (Bundler::EnvironmentPreserver)

#results_for (Bundler::Resolver)

#reverse_each (Bundler::Molinillo::DependencyGraph::Log)

#reverse_rubygems_kernel_mixin (Bundler::RubygemsIntegration)

#reversed_requirement_tree_index (Bundler::Molinillo::Resolver::Resolution::UnwindDetails)

#revision (Bundler::Source::Git)

#revision (Bundler::Source::Git::GitProxy)

#rewind_to (Bundler::Molinillo::DependencyGraph)

#rewind_to (Bundler::Molinillo::DependencyGraph::Log)

#rg_extension_dir (Gem::Specification)

#rg_full_gem_path (Gem::Specification)

#rg_loaded_from (Gem::Specification)

#root (Bundler::Plugin)

#root (Bundler::Plugin::API::Source)

#root (Bundler::Plugin::Installer::Git)

#root (Bundler::SharedHelpers)

#root (Bundler::Source::Path)

#root_vertex_named (Bundler::Molinillo::DependencyGraph)

#route_from (Bundler::URI::Generic)

#route_to (Bundler::URI::Generic)

#ruby (Bundler::RubyDsl)

#ruby? (Bundler::CurrentRuby)

#ruby_engine (Bundler::RubygemsIntegration)

#rubygem_push (Bundler::GemHelper)

#rubygems_dir (Bundler::Source::Rubygems)

#rubygems_remotes (Bundler::SourceList)

#rubygems_sources (Bundler::SourceList)

#run (Bundler::CLI::Add)

#run (Bundler::CLI::Binstubs)

#run (Bundler::CLI::Cache)

#run (Bundler::CLI::Check)

#run (Bundler::CLI::Clean)

#run (Bundler::CLI::Config::Base)

#run (Bundler::CLI::Console)

#run (Bundler::CLI::Doctor)

#run (Bundler::CLI::Exec)

#run (Bundler::CLI::Fund)

#run (Bundler::CLI::Gem)

#run (Bundler::CLI::Info)

#run (Bundler::CLI::Init)

#run (Bundler::CLI::Inject)

#run (Bundler::CLI::Install)

#run (Bundler::CLI::Issue)

#run (Bundler::CLI::List)

#run (Bundler::CLI::Lock)

#run (Bundler::CLI::Open)

#run (Bundler::CLI::Outdated)

#run (Bundler::CLI::Platform)

#run (Bundler::CLI::Pristine)

#run (Bundler::CLI::Remove)

#run (Bundler::CLI::Show)

#run (Bundler::CLI::Update)

#run (Bundler::CLI::Viz)

#run (Bundler::Graph::GraphVizClient)

#run (Bundler::Installer)

#run (Bundler::Thor::Actions)

#run (Bundler::Thor::Command)

#run (Bundler::Thor::Command)

#run (Bundler::Thor::DynamicCommand)

#run (Bundler::Thor::DynamicCommand)

#run_ruby_script (Bundler::Thor::Actions)

#satisfies? (Bundler::LazySpecification)

#save_plugins (Bundler::Plugin)

#say (Bundler::Thor::Shell::Basic)

#say (Bundler::UI::RGProxy)

#say_status (Bundler::Thor::Shell::Basic)

#scheme= (Bundler::URI::Generic)

#scope (Bundler::URI::LDAP)

#scope= (Bundler::URI::LDAP)

#search (Bundler::Index)

#search_all (Bundler::Index)

#search_for (Bundler::Molinillo::Delegates::SpecificationProvider)

#search_for (Bundler::Molinillo::SpecificationProvider)

#search_for (Bundler::Resolver)

#security_policies (Bundler::RubygemsIntegration)

#security_policy_keys (Bundler::RubygemsIntegration)

#select (Bundler::URI::Generic)

#sequential_execution_mode! (Bundler::CompactIndexClient)

#sequentially (Bundler::CompactIndexClient)

#set (Bundler::CLI::Config)

#set (Bundler::Settings::Validator::Rule)

#set_attributes (Bundler::URI::LDAP)

#set_bundle_environment (Bundler::SharedHelpers)

#set_color (Bundler::Thor::Shell::Color)

#set_color (Bundler::Thor::Shell::HTML)

#set_command_option (Bundler::Settings)

#set_command_option_if_given (Bundler::Settings)

#set_dn (Bundler::URI::LDAP)

#set_env (Bundler::SharedHelpers)

#set_eoutvar (Bundler::Thor::Actions::CapturableERB)

#set_extensions (Bundler::URI::LDAP)

#set_filter (Bundler::URI::LDAP)

#set_global (Bundler::Settings)

#set_headers (Bundler::URI::MailTo)

#set_host (Bundler::URI::File)

#set_host (Bundler::URI::Generic)

#set_installed_by_version (Bundler::RubygemsIntegration)

#set_local (Bundler::Settings)

#set_opaque (Bundler::URI::Generic)

#set_password (Bundler::URI::File)

#set_password (Bundler::URI::Generic)

#set_path (Bundler::URI::FTP)

#set_path (Bundler::URI::Generic)

#set_payload (Bundler::Molinillo::DependencyGraph)

#set_payload (Bundler::Molinillo::DependencyGraph::Log)

#set_port (Bundler::URI::File)

#set_port (Bundler::URI::Generic)

#set_scheme (Bundler::URI::Generic)

#set_scope (Bundler::URI::LDAP)

#set_to (Bundler::URI::MailTo)

#set_typecode (Bundler::URI::FTP)

#set_user (Bundler::URI::File)

#set_user (Bundler::URI::Generic)

#set_userinfo (Bundler::URI::File)

#set_userinfo (Bundler::URI::Generic)

#setup (Bundler::Runtime)

#sh (Bundler::GemHelper)

#sh_with_input (Bundler::GemHelper)

#sh_with_status (Bundler::GemHelper)

#shallow_eql? (Bundler::Molinillo::DependencyGraph::Vertex)

#shell (Bundler::Thor::Shell)

#should_include? (Bundler::Dependency)

#show (Bundler::CLI)

#show_pretty_values_for (Bundler::CLI::Config::Base)

#shutdown (Bundler::ConnectionPool)

#shutdown (Bundler::ConnectionPool::TimedStack)

#shutdown (Bundler::Persistent::Net::HTTP::Persistent)

#silence (Bundler::UI::Shell)

#silence (Bundler::UI::Silent)

#similar_word_list (Bundler::SimilarityDetector)

#similar_words (Bundler::SimilarityDetector)

#single? (Bundler::VersionRanges::ReqR)

#single_version_string (Bundler::RubyVersion)

#size (Bundler::ConnectionPool)

#size (Bundler::Index)

#size (Bundler::SpecSet)

#slice_body (Bundler::CompactIndexClient::Updater)

#sort! (Bundler::SpecSet)

#sort_dependencies (Bundler::Molinillo::Delegates::SpecificationProvider)

#sort_dependencies (Bundler::Molinillo::SpecificationProvider)

#sort_dependencies (Bundler::Resolver)

#sort_obj (Bundler::RemoteSpecification)

#sort_specs (Bundler::Index)

#sort_versions (Bundler::GemVersionPromoter)

#sorted_activated_platforms (Bundler::Resolver::SpecGroup)

#source (Bundler::Dsl)

#source (Bundler::Plugin)

#source (Bundler::Plugin::DSL)

#source (Gem::Specification)

#source= (Bundler::StubSpecification)

#source? (Bundler::Plugin)

#source? (Bundler::Plugin::Index)

#source_for (Bundler::Resolver)

#source_from_lock (Bundler::Plugin)

#source_paths (Bundler::Thor::Actions)

#source_paths (Bundler::Thor::Actions::ClassMethods)

#source_paths_for_search (Bundler::Thor::Actions::ClassMethods)

#source_plugin (Bundler::Plugin::Index)

#source_root (Bundler::Thor::Actions::ClassMethods)

#sources (Bundler::RubygemsIntegration)

#sources= (Bundler::RubygemsIntegration)

#spec (Bundler::CompactIndexClient)

#spec_cache_dirs (Bundler::RubygemsIntegration)

#spec_default_gem? (Bundler::RubygemsIntegration)

#spec_from_gem (Bundler::RubygemsIntegration)

#spec_git_paths (Bundler::Definition)

#spec_matches_for_glob (Bundler::RubygemsIntegration)

#spec_missing_extensions? (Bundler::RubygemsIntegration)

#spec_names (Bundler::Index)

#spec_names (Bundler::Plugin::API::Source)

#spec_names (Bundler::Source)

#spec_names (Bundler::Source::Rubygems)

#specific? (Bundler::Dependency)

#specific_dependency (Bundler::CompactIndexClient::Cache)

#specs (Bundler::Definition)

#specs (Bundler::Fetcher)

#specs (Bundler::Fetcher::CompactIndex)

#specs (Bundler::Fetcher::Dependency)

#specs (Bundler::Fetcher::Index)

#specs (Bundler::Gemdeps)

#specs (Bundler::Plugin::API::Source)

#specs (Bundler::Source::Git)

#specs (Bundler::Source::Metadata)

#specs (Bundler::Source::Path)

#specs (Bundler::Source::Rubygems)

#specs (Bundler::Source::RubygemsAggregate)

#specs_for (Bundler::Definition)

#specs_for_names (Bundler::Fetcher::CompactIndex)

#specs_with_retry (Bundler::Fetcher)

#spell_checker (UndefinedCommandError::SpellChecker)

#spell_checker (UnknownArgumentError::SpellChecker)

#split (Bundler::URI::RFC2396_Parser)

#split (Bundler::URI::RFC2396_Parser)

#ssl (Bundler::Persistent::Net::HTTP::Persistent)

#ssl_timeout= (Bundler::Persistent::Net::HTTP::Persistent)

#ssl_version= (Bundler::Persistent::Net::HTTP::Persistent)

#start (Bundler::Persistent::Net::HTTP::Persistent)

#start (Bundler::Resolver)

#start (Bundler::Thor::Base::ClassMethods)

#status_code (Bundler::Dsl::DSLError)

#stderr (Bundler::Thor::Shell::Basic)

#stdout (Bundler::Thor::Shell::Basic)

#stop (Bundler::Worker)

#strict_args_position! (Bundler::Thor::Base::ClassMethods)

#stub_rubygems (Bundler::RubygemsIntegration)

#stub_set_spec (Bundler::RubygemsIntegration)

#sub_dependencies_to_avoid (Bundler::Molinillo::Resolver::Resolution::UnwindDetails)

#successors (Bundler::Molinillo::DependencyGraph::Vertex)

#suffix_pattern (Bundler::RubygemsIntegration)

#suppress_configured_credentials (Bundler::Source::Rubygems)

#tag (Bundler::Molinillo::DependencyGraph)

#tag (Bundler::Molinillo::DependencyGraph::Log)

#tag_version (Bundler::GemHelper)

#task (Object)

#tasks (Bundler::Thor::Base::ClassMethods)

#template (Bundler::Thor::Actions)

#temporary (Bundler::Settings)

#terminal_width (Bundler::Thor::Shell::Basic)

#thor (Bundler::Thor::Actions)

#tmp (Bundler::Plugin::API)

#to= (Bundler::URI::MailTo)

#to_a (Bundler::SpecSet)

#to_definition (Bundler::Dsl)

#to_dot (Bundler::Molinillo::DependencyGraph)

#to_gem_version_with_patchlevel (Bundler::RubyVersion)

#to_gemfile (Gem::Specification)

#to_hash (Bundler::SpecSet)

#to_lock (Bundler::Definition)

#to_lock (Bundler::Dependency)

#to_lock (Bundler::LazySpecification)

#to_lock (Bundler::Plugin::API::Source)

#to_lock (Bundler::Source::Git)

#to_lock (Bundler::Source::Path)

#to_lock (Bundler::Source::Rubygems)

#to_lock (Gem::Dependency)

#to_mailtext (Bundler::URI::MailTo)

#to_rfc822text (Bundler::URI::MailTo)

#to_s (Bundler::DepProxy)

#to_s (Bundler::Dsl::DSLError)

#to_s (Bundler::LazySpecification)

#to_s (Bundler::Molinillo::Resolver::Resolution::PossibilitySet)

#to_s (Bundler::ParallelInstaller::SpecInstallation)

#to_s (Bundler::Plugin::API::Source)

#to_s (Bundler::RemoteSpecification)

#to_s (Bundler::Resolver::SpecGroup)

#to_s (Bundler::RubyVersion)

#to_s (Bundler::Source::Git)

#to_s (Bundler::Source::Metadata)

#to_s (Bundler::Source::Path)

#to_s (Bundler::Source::Rubygems)

#to_s (Bundler::Source::Rubygems::Remote)

#to_s (Bundler::Source::RubygemsAggregate)

#to_s (Bundler::URI::FTP)

#to_s (Bundler::URI::Generic)

#to_s (Bundler::URI::MailTo)

#to_s (Bundler::VersionRanges::ReqR)

#to_socket_address (Bundler::SocketAddress)

#to_specs (Bundler::Resolver::SpecGroup)

#to_yaml (Bundler::StubSpecification)

#to_yaml_properties (Gem::Dependency)

#trace (Bundler::UI::Shell)

#trace (Bundler::UI::Silent)

#trap (Bundler::SharedHelpers)

#truffleruby? (Bundler::CurrentRuby)

#truncate (Bundler::Thor::Shell::Basic)

#tsort_each_child (Bundler::Molinillo::DependencyGraph)

#tsort_each_node (Bundler::Molinillo::DependencyGraph)

#type (Bundler::DepProxy)

#typecode= (Bundler::URI::FTP)

#ui= (Bundler::RubygemsIntegration)

#uncomment_lines (Bundler::Thor::Actions)

#undo_replacements (Bundler::RubygemsIntegration)

#unescape (Bundler::Persistent::Net::HTTP::Persistent)

#unescape (Bundler::URI::Escape)

#unescape (Bundler::URI::RFC2396_Parser)

#unescape (Bundler::URI::RFC2396_Parser)

#uninstall (Bundler::CLI::Plugin)

#uninstall (Bundler::Plugin)

#unix? (Bundler::Thor::Shell::Basic)

#unlock! (Bundler::Plugin::API::Source)

#unlock! (Bundler::Source::Git)

#unlocking? (Bundler::Definition)

#unmarshalled_dep_gems (Bundler::Fetcher::Dependency)

#unmet_dependency_names (Bundler::Index)

#unmet_deps (Bundler::Plugin::API::Source)

#unmet_deps (Bundler::Source)

#unmet_deps (Bundler::Source::Rubygems)

#unprinted_warnings (Bundler::UI::Shell)

#unprinted_warnings (Bundler::UI::Silent)

#unregister_plugin (Bundler::Plugin::Index)

#unset (Bundler::CLI::Config)

#unsorted_search (Bundler::Index)

#unused_unwind_options (Bundler::Molinillo::Delegates::ResolutionState)

#unwinding_to_primary_requirement? (Bundler::Molinillo::Resolver::Resolution::UnwindDetails)

#up (Bundler::Molinillo::DependencyGraph::Action)

#up (Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular)

#up (Bundler::Molinillo::DependencyGraph::DeleteEdge)

#up (Bundler::Molinillo::DependencyGraph::DetachVertexNamed)

#up (Bundler::Molinillo::DependencyGraph::Tag)

#update (Bundler::CLI)

#update (Bundler::CompactIndexClient::Updater)

#update_and_parse_checksums! (Bundler::CompactIndexClient)

#update_mirror (Bundler::Settings::MirrorConfig)

#uri (Bundler::Fetcher)

#uri= (Bundler::Settings::Mirror)

#uri_hash (Bundler::Plugin::API::Source)

#use (Bundler::Index)

#use_api (Bundler::Fetcher)

#use_gemdeps (Bundler::RubygemsIntegration)

#user (Bundler::URI::Generic)

#user= (Bundler::URI::Generic)

#user_agent (Bundler::Fetcher)

#user_home (Bundler::RubygemsIntegration)

#userinfo (Bundler::URI::Generic)

#userinfo= (Bundler::URI::Generic)

#valid? (Bundler::Settings::Mirror)

#validate (Bundler::RubygemsIntegration)

#validate! (Bundler::Settings)

#validate! (Bundler::Settings::Mirror)

#validate! (Bundler::Settings::Validator::Rule)

#validate_platforms! (Bundler::Definition)

#validate_plugin! (Bundler::Plugin)

#validate_ruby! (Bundler::Definition)

#validate_runtime! (Bundler::Definition)

#validate_scope! (Bundler::CLI::Config::Base)

#verify_callback= (Bundler::Persistent::Net::HTTP::Persistent)

#verify_depth= (Bundler::Persistent::Net::HTTP::Persistent)

#verify_mode= (Bundler::Persistent::Net::HTTP::Persistent)

#version (Bundler::CLI)

#version (Bundler::GemHelper)

#version (Bundler::RubygemsIntegration)

#version (Bundler::Source::Git::GitProxy)

#version_message (Bundler::Plugin::Installer::Git)

#version_message (Bundler::Plugin::Installer::Rubygems)

#version_message (Bundler::Source)

#version_message (Bundler::Source::Metadata)

#version_tag (Bundler::GemHelper)

#versions (Bundler::CompactIndexClient)

#versions (Bundler::CompactIndexClient::Cache)

#versions_path (Bundler::CompactIndexClient::Cache)

#versions_string (Bundler::RubyVersion)

#vertex_named (Bundler::Molinillo::DependencyGraph)

#viz (Bundler::CLI)

#viz (Bundler::Graph)

#warn (Bundler::UI::Shell)

#warn (Bundler::UI::Silent)

#warn_for_outdated_bundler_version (Bundler::LockfileParser)

#warn_old_tls_version_rubygems_connection (Bundler::PersistentHTTP)

#warn_unused_scope (Bundler::CLI::Config::Base)

#what_required (Bundler::SpecSet)

#with (Bundler::ConnectionPool)

#with (Bundler::ConnectionPool::Wrapper)

#with_build_args (Bundler::RubygemsIntegration)

#with_clean_git_env (Bundler::SharedHelpers)

#with_padding (Bundler::Thor::Shell)

#write_to_gemfile (Bundler::SharedHelpers)

#x64_mingw? (Bundler::CurrentRuby)

#yes? (Bundler::Thor::Shell::Basic)

#yes? (Bundler::UI::Shell)

#yes? (Bundler::UI::Silent)