Modules: BundlerVersionFinder, CIDetector, Commands, DefaultUserInteraction, Deprecate, Ext, GemcutterUtilities, GemspecHelpers, InstallUpdateOptions, InstallerUninstallerUtils, LocalRemoteOptions, Molinillo, Net, QueryUtils, SafeMarshal, SafeYAML, SecureRandom, Security, SecurityOption, TSort, Text, Timeout, URI, UpdateSuggestion, UserInteraction, Util, VersionOption, YAMLSerializer Classes: AvailableSet, BasicSpecification, Command, CommandLineError, CommandManager, ConfigFile, ConflictError, ConsoleUI, Dependency, DependencyError, DependencyInstaller, DependencyList, DependencyRemovalException, DependencyResolutionError, Doctor, DocumentError, EndOfYAMLException, ErrorReason, Exception, FilePermissionError, FormatException, GemNotFoundException, GemNotInHomeException, GemRunner, ImpossibleDependenciesError, InstallError, Installer, InvalidSpecificationException, Licenses, List, LoadError, MissingSpecError, MissingSpecVersionError, NameTuple, NoAliasYAMLTree, OperationNotSupportedError, OptionParser, Package, PackageTask, PathSupport, Platform, PlatformMismatch, RemoteError, RemoteFetcher, RemoteInstallationCancelled, RemoteInstallationSkipped, RemoteSourceException, Request, RequestSet, Requirement, Resolv, Resolver, RubyVersionMismatch, RuntimeRequirementNotMetError, S3URISigner, SilentUI, Source, SourceFetchProblem, SourceList, SpecFetcher, SpecificGemNotFoundException, Specification, SpecificationPolicy, SpecificationRecord, StreamUI, StubSpecification, SystemExitException, TargetRbConfig, UninstallError, Uninstaller, UnknownCommandError, UnknownCommandSpellChecker, UnsatisfiableDependencyError, Uri, UriFormatter, Validator, VerificationError, Version, WebauthnVerificationError
Constant Summary collapse"3.8.0.dev"
__dir__
An Array of Regexps that match windows Ruby platforms.
[ /bccwin/i, /cygwin/i, /djgpp/i, /mingw/i, /mswin/i, /wince/i, ].freeze
%w[ gem.deps.rb gems.rb Gemfile Isolate ].freeze
Subdirectories in a gem repository
%w[ build_info cache doc extensions gems plugins specifications ].freeze
Subdirectories in a gem repository for default gems
%w[ gems specifications/default ].freeze
The default value for SOURCE_DATE_EPOCH if not specified. We want a date after 1980-01-01, to prevent issues with Zip files. This particular timestamp is for 1980-01-02 00:00:00 GMT.
315_619_200
Thread::Mutex.new
Location of Marshal quick gemspecs on remote repositories
"quick/Marshal.#{Gem.marshal_version}/".freeze
defined? OpenSSL::SSL
"https://rubygems.org"
VERSION
%w[ MAJOR MINOR TEENY EXEEXT RUBY_SO_NAME arch bindir datadir libdir ruby_install_name ruby_version rubylibprefix sitedir sitelibdir vendordir vendorlibdir rubylibdir ].freeze
Configuration settings from ::RbConfig
Hash.new do |cm, key| cm[key] = RbConfig::CONFIG[key.to_s] end
nil
RubyGems distributors (like operating system package managers) can disable RubyGems update by setting this to error message printed to end-users on gem update –system instead of actual update.
Whether RubyGems should enhance builtin ‘require` to automatically check whether the path required is present in installed gems, and automatically activate them and add them to `$LOAD_PATH`.
The list of hooks to be run after Gem::DependencyInstaller installs a set of gems.
GemDependencyAPI object, which is set when .use_gemdeps is called.
Hash of loaded Gem::Specification keyed by name.
The list of hooks to be run after Gem::Installer#install extracts files and builds extensions.
The list of hooks to be run after Gem::Installer#install completes installation.
The list of hooks to be run after Gem::Specification.reset is run.
The list of hooks to be run after Gem::Uninstaller#uninstall completes installation.
The list of hooks to be run before Gem::Installer#install does any work.
The list of hooks to be run before Gem::Specification.reset is run.
The list of hooks to be run before Gem::Uninstaller#uninstall does any work.
Find and load the full path to the executable for gem name.
Find the full path to the executable for gem name.
The number of paths in the $LOAD_PATH from activated gems.
Add a list of paths to the $LOAD_PATH at the proper place.
Find the full path to the executable for gem name.
The mode needed to read a file as straight binary.
The path where gem executables are to be installed.
The path to standard location of the user’s cache directory.
Clear default gem related variables.
Reset the dir and path values.
The path to standard location of the user’s .gemrc file.
The path to standard location of the user’s configuration directory.
The standard configuration object for gems.
Use the given configuration object (which implements the ConfigFile protocol) as the standard configuration object.
The path to standard location of the user’s data directory.
The default directory for binaries.
The default signing certificate chain path.
Default home directory path to be used if an alternate value is not specified in the environment.
Deduce Ruby’s –program-prefix and –program-suffix from its install name.
Returns binary extensions dir for specified RubyGems base dir or nil if such directory cannot be determined.
The default signing key path.
Default gem load path.
Paths where RubyGems’ .rb files and bin files are installed.
An Array of the default sources that come with RubyGems.
Default spec directory path to be used if an alternate value is not specified in the environment.
Path to specification files of default gems.
Enables automatic installation into user directory.
A Zlib::Deflate.deflate wrapper.
The path where gems are to be installed.
Adds a post-installs hook that will be passed a Gem::DependencyInstaller and a list of installed specifications when Gem::DependencyInstaller#install is complete.
Suffixes for dynamic library require-able paths.
Quietly ensure the Gem directory dir contains all the proper subdirectories for handling default gems.
Quietly ensure the Gem directory dir contains all the proper subdirectories.
:nodoc:.
The extension API version of ruby.
Finds the user’s config file.
Find a Gem::Specification of default gem from path.
Returns a list of paths matching glob that can be used by a gem to pick up features from other gems.
:nodoc:.
Returns a list of paths matching glob from the latest gems that can be used by a gem to pick up features from other gems.
Find an unresolved Gem::Specification of default gem from path.
Is this platform FreeBSD.
Get the default RubyGems API host.
Set the default RubyGems API host.
Top level install helper method.
Install extensions into lib as well as into the extension directory.
Is this a java platform?.
Returns the latest release version of RubyGems.
Returns the latest release-version specification for the gem name.
Returns the version of the latest release-version of gem name.
Load Bundler extensions to RubyGems, making sure to avoid redefinition warnings in platform constants.
Find all ‘rubygems_plugin’ files in $LOAD_PATH and load them.
The index to insert activated gem paths into the $LOAD_PATH.
Load plugins as Ruby files.
Find rubygems plugin files in the standard location and load them.
Loads YAML, preferring Psych.
The file name and line number of the caller of the caller of this method.
The version of the Marshal format for your Ruby.
Open a file with given flags.
Open a file with given flags, and protect access with flock.
Open a file with given flags, and protect access with a file lock.
Default options for gem commands for Ruby packagers.
How String Gem paths should be split.
Retrieve the PathSupport object that RubyGems uses to lookup files.
Initialize the filesystem paths to use from env.
Default options for gem commands for Ruby implementers.
Array of platforms this RubyGems supports.
Set array of platforms this RubyGems supports (primarily for testing).
Glob pattern for require-able plugin suffixes.
Regexp for require-able plugin suffixes.
The path were rubygems plugins are to be installed.
Adds a post-build hook that will be passed an Gem::Installer instance when Gem::Installer#install is called.
Adds a post-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is called.
Adds a hook that will get run after Gem::Specification.reset is run.
Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance and the spec that was uninstalled when Gem::Uninstaller#uninstall is called.
Adds a pre-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is called.
Adds a hook that will get run before Gem::Specification.reset is run.
Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance and the spec that will be uninstalled when Gem::Uninstaller#uninstall is called.
The directory prefix this RubyGems was installed at.
Safely read a file in binary mode on all platforms.
Refresh available gems from disk.
Register a Gem::Specification for default gem.
The path to the running Ruby interpreter.
Returns a String containing the API compatibility version of Ruby.
A Gem::Version for the currently running Ruby.
A Gem::Version for the currently running RubyGems.
Is this platform Solaris?.
Returns the value of Gem.source_date_epoch_string, as a Time object.
If the SOURCE_DATE_EPOCH environment variable is set, returns it’s value.
Returns an Array of sources to fetch remote gems from.
Need to be able to set the sources without calling Gem.sources.replace since that would cause an infinite loop.
The path to standard location of the user’s state file.
The path to standard location of the user’s state directory.
Glob pattern for require-able path suffixes.
Regexp for require-able path suffixes.
Suffixes for require-able paths.
The RbConfig object for the deployment target platform.
Prints the amount of time the supplied block takes to run using the debug UI output.
Try to activate a gem containing path.
Lazily loads DefaultUserInteraction and returns the default UI.
Returns a Gem::URI object derived from the given uri, which may be a Gem::URI string or an existing Gem::URI object:.
Looks for a gem dependency file at path and activates the gems in the file if found.
Use the home and paths values for Gem.dir and Gem.path.
Path for gems in the user’s home directory.
The home directory for the user.
Directory where vendor gems are installed.
Is this a windows platform?.
Safely write a file in binary mode on all platforms.
RubyGems distributors (like operating system package managers) can disable RubyGems update by setting this to error message printed to end-users on gem update –system instead of actual update.
1273 1274 1275
# File 'lib/rubygems.rb', line 1273 def disable_system_update_message @disable_system_update_message end.discover_gems_on_require ⇒ Object
Whether RubyGems should enhance builtin ‘require` to automatically check whether the path required is present in installed gems, and automatically activate them and add them to `$LOAD_PATH`.
1280 1281 1282
# File 'lib/rubygems.rb', line 1280 def discover_gems_on_require @discover_gems_on_require end.done_installing_hooks ⇒ Object
The list of hooks to be run after Gem::DependencyInstaller installs a set of gems
1365 1366 1367
# File 'lib/rubygems.rb', line 1365 def done_installing_hooks @done_installing_hooks end.gemdeps ⇒ Object
GemDependencyAPI object, which is set when .use_gemdeps is called. This contains all the information from the Gemfile.
1291 1292 1293
# File 'lib/rubygems.rb', line 1291 def gemdeps @gemdeps end.loaded_specs ⇒ Object
Hash of loaded Gem::Specification keyed by name
1285 1286 1287
# File 'lib/rubygems.rb', line 1285 def loaded_specs @loaded_specs end.post_build_hooks ⇒ Object
The list of hooks to be run after Gem::Installer#install extracts files and builds extensions
1353 1354 1355
# File 'lib/rubygems.rb', line 1353 def post_build_hooks @post_build_hooks end.post_install_hooks ⇒ Object
The list of hooks to be run after Gem::Installer#install completes installation
1359 1360 1361
# File 'lib/rubygems.rb', line 1359 def post_install_hooks @post_install_hooks end.post_reset_hooks ⇒ Object
The list of hooks to be run after Gem::Specification.reset is run.
1370 1371 1372
# File 'lib/rubygems.rb', line 1370 def post_reset_hooks @post_reset_hooks end.post_uninstall_hooks ⇒ Object
The list of hooks to be run after Gem::Uninstaller#uninstall completes installation
1376 1377 1378
# File 'lib/rubygems.rb', line 1376 def post_uninstall_hooks @post_uninstall_hooks end.pre_install_hooks ⇒ Object
The list of hooks to be run before Gem::Installer#install does any work
1381 1382 1383
# File 'lib/rubygems.rb', line 1381 def pre_install_hooks @pre_install_hooks end.pre_reset_hooks ⇒ Object
The list of hooks to be run before Gem::Specification.reset is run.
1386 1387 1388
# File 'lib/rubygems.rb', line 1386 def pre_reset_hooks @pre_reset_hooks end.pre_uninstall_hooks ⇒ Object
The list of hooks to be run before Gem::Uninstaller#uninstall does any work
1392 1393 1394
# File 'lib/rubygems.rb', line 1392 def pre_uninstall_hooks @pre_uninstall_hooks endClass Method Details .activate_and_load_bin_path(name, exec_name = nil, *requirements) ⇒ Object
Find and load the full path to the executable for gem name. If the exec_name is not given, an exception will be raised, otherwise the specified executable’s path is returned. requirements allows you to specify specific gem versions.
A side effect of this method is that it will activate the gem that contains the executable.
This method should only be used in bin stub files.
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
# File 'lib/rubygems.rb', line 297
def self.activate_and_load_bin_path(name, exec_name = nil, *requirements)
spec = find_and_activate_spec_for_exe name, exec_name, requirements
if spec.name == "bundler"
load ENV["BUNDLE_BIN_PATH"] if ENV["BUNDLE_BIN_PATH"] && spec.version <= "2.5.22"
require_path = $LOAD_PATH.resolve_feature_path("bundler").last.delete_suffix("/bundler.rb")
Gem.load_bundler_extensions(spec.version) if spec.full_require_paths.include?(require_path)
end
load spec.bin_file(exec_name)
end .activate_bin_path(name, exec_name = nil, *requirements) ⇒ Object
Find the full path to the executable for gem name. If the exec_name is not given, an exception will be raised, otherwise the specified executable’s path is returned. requirements allows you to specify specific gem versions.
A side effect of this method is that it will activate the gem that contains the executable.
This method should only be used in bin stub files.
333 334 335
# File 'lib/rubygems.rb', line 333 def self.activate_bin_path(name, exec_name = nil, *requirements) find_and_activate_spec_for_exe(name, exec_name, requirements).bin_file exec_name end.activated_gem_paths ⇒ Object
The number of paths in the $LOAD_PATH from activated gems. Used to prioritize -I and ENV['RUBYLIB'] entries during require.
640 641 642
# File 'lib/rubygems.rb', line 640 def self.activated_gem_paths @activated_gem_paths ||= 0 end.add_to_load_path(*paths) ⇒ Object
Add a list of paths to the $LOAD_PATH at the proper place.
647 648 649 650 651 652
# File 'lib/rubygems.rb', line 647
def self.add_to_load_path(*paths)
@activated_gem_paths = activated_gem_paths + paths.size
$LOAD_PATH.insert(Gem.load_path_insert_index, *paths)
end .bin_path(name, exec_name = nil, *requirements) ⇒ Object
Find the full path to the executable for gem name. If the exec_name is not given, an exception will be raised, otherwise the specified executable’s path is returned. requirements allows you to specify specific gem versions.
245 246 247 248 249 250
# File 'lib/rubygems.rb', line 245
def self.bin_path(name, exec_name = nil, *requirements)
requirements = Gem::Requirement.default if
requirements.empty?
find_spec_for_exe(name, exec_name, requirements).bin_file exec_name
end .binary_mode ⇒ Object
The mode needed to read a file as straight binary.
340 341 342
# File 'lib/rubygems.rb', line 340 def self.binary_mode "rb" end.bindir(install_dir = Gem.dir) ⇒ Object
The path where gem executables are to be installed.
347 348 349 350 351
# File 'lib/rubygems.rb', line 347
def self.bindir(install_dir=Gem.dir)
return File.join install_dir, "bin" unless
install_dir.to_s == Gem.default_dir.to_s
Gem.default_bindir
end .cache_home ⇒ Object
The path to standard location of the user’s cache directory.
147 148 149
# File 'lib/rubygems/defaults.rb', line 147 def self.cache_home @cache_home ||= ENV["XDG_CACHE_HOME"] || File.join(Gem.user_home, ".cache") end.clear_default_specs ⇒ Object
Clear default gem related variables. It is for test
1345 1346 1347
# File 'lib/rubygems.rb', line 1345 def clear_default_specs @path_to_default_spec_map.clear end.clear_paths ⇒ Object
Reset the dir and path values. The next time dir or path is requested, the values will be calculated from scratch. This is mainly used by the unit tests to provide test isolation.
The path to standard location of the user’s .gemrc file.
133 134 135
# File 'lib/rubygems/defaults.rb', line 133 def self.config_file @config_file ||= find_config_file end.config_home ⇒ Object
The path to standard location of the user’s configuration directory.
114 115 116
# File 'lib/rubygems/defaults.rb', line 114 def self.config_home @config_home ||= ENV["XDG_CONFIG_HOME"] || File.join(Gem.user_home, ".config") end.configuration ⇒ Object
The standard configuration object for gems.
375 376 377
# File 'lib/rubygems.rb', line 375 def self.configuration @configuration ||= Gem::ConfigFile.new [] end.configuration=(config) ⇒ Object
Use the given configuration object (which implements the ConfigFile protocol) as the standard configuration object.
383 384 385
# File 'lib/rubygems.rb', line 383 def self.configuration=(config) @configuration = config end.data_home ⇒ Object
The path to standard location of the user’s data directory.
154 155 156
# File 'lib/rubygems/defaults.rb', line 154 def self.data_home @data_home ||= ENV["XDG_DATA_HOME"] || File.join(Gem.user_home, ".local", "share") end.default_bindir ⇒ Object
The default directory for binaries
204 205 206
# File 'lib/rubygems/defaults.rb', line 204 def self.default_bindir RbConfig::CONFIG["bindir"] end.default_cert_path ⇒ Object
The default signing certificate chain path
228 229 230 231 232 233 234 235 236
# File 'lib/rubygems/defaults.rb', line 228
def self.default_cert_path
default_cert_path = File.join Gem.user_home, ".gem", "gem-public_cert.pem"
unless File.exist?(default_cert_path)
default_cert_path = File.join Gem.data_home, "gem", "gem-public_cert.pem"
end
default_cert_path
end .default_dir ⇒ Object
Default home directory path to be used if an alternate value is not specified in the environment
37 38 39
# File 'lib/rubygems/defaults.rb', line 37 def self.default_dir @default_dir ||= File.join(RbConfig::CONFIG["rubylibprefix"], "gems", RbConfig::CONFIG["ruby_version"]) end.default_exec_format ⇒ Object
Deduce Ruby’s –program-prefix and –program-suffix from its install name
186 187 188 189 190 191 192 193 194 195 196 197 198 199
# File 'lib/rubygems/defaults.rb', line 186
def self.default_exec_format
exec_format = begin
RbConfig::CONFIG["ruby_install_name"].sub("ruby", "%s")
rescue StandardError
"%s"
end
unless exec_format.include?("%s")
raise Gem::Exception,
"[BUG] invalid exec_format #{exec_format.inspect}, no %s"
end
exec_format
end .default_ext_dir_for(base_dir) ⇒ Object
Returns binary extensions dir for specified RubyGems base dir or nil if such directory cannot be determined.
By default, the binary extensions are located side by side with their Ruby counterparts, therefore nil is returned
48 49 50
# File 'lib/rubygems/defaults.rb', line 48 def self.default_ext_dir_for(base_dir) nil end.default_key_path ⇒ Object
The default signing key path
215 216 217 218 219 220 221 222 223
# File 'lib/rubygems/defaults.rb', line 215
def self.default_key_path
default_key_path = File.join Gem.user_home, ".gem", "gem-private_key.pem"
unless File.exist?(default_key_path)
default_key_path = File.join Gem.data_home, "gem", "gem-private_key.pem"
end
default_key_path
end .default_path ⇒ Object
175 176 177 178 179 180 181
# File 'lib/rubygems/defaults.rb', line 175 def self.default_path path = [] path << user_dir if user_home && File.exist?(user_home) path << default_dir path << vendor_dir if vendor_dir && File.directory?(vendor_dir) path end.default_rubygems_dirs ⇒ Object
Paths where RubyGems’ .rb files and bin files are installed
55 56 57
# File 'lib/rubygems/defaults.rb', line 55 def self.default_rubygems_dirs nil end.default_sources ⇒ Object
An Array of the default sources that come with RubyGems
15 16 17
# File 'lib/rubygems/defaults.rb', line 15 def self.default_sources %w[https://rubygems.org/] end.default_spec_cache_dir ⇒ Object
Default spec directory path to be used if an alternate value is not specified in the environment
23 24 25 26 27 28 29 30 31
# File 'lib/rubygems/defaults.rb', line 23
def self.default_spec_cache_dir
default_spec_cache_dir = File.join Gem.user_home, ".gem", "specs"
unless File.exist?(default_spec_cache_dir)
default_spec_cache_dir = File.join Gem.cache_home, "gem", "specs"
end
default_spec_cache_dir
end .default_specifications_dir ⇒ Object
Path to specification files of default gems.
62 63 64
# File 'lib/rubygems/defaults.rb', line 62 def self.default_specifications_dir @default_specifications_dir ||= File.join(Gem.default_dir, "specifications", "default") end.default_user_install ⇒ Object
Enables automatic installation into user directory
241 242 243 244 245 246 247 248
# File 'lib/rubygems/defaults.rb', line 241
def self.default_user_install if !ENV.key?("GEM_HOME") && File.exist?(Gem.dir) && !File.writable?(Gem.dir)
Gem.ui.say "Defaulting to user installation because default installation directory (#{Gem.dir}) is not writable."
return true
end
false
end .deflate(data) ⇒ Object
A Zlib::Deflate.deflate wrapper
390 391 392 393
# File 'lib/rubygems.rb', line 390 def self.deflate(data) require "zlib" Zlib::Deflate.deflate data end.dir ⇒ Object
The path where gems are to be installed.
438 439 440
# File 'lib/rubygems.rb', line 438 def self.dir paths.home end.done_installing(&hook) ⇒ Object
Adds a post-installs hook that will be passed a Gem::DependencyInstaller and a list of installed specifications when Gem::DependencyInstaller#install is complete
775 776 777
# File 'lib/rubygems.rb', line 775 def self.done_installing(&hook) @done_installing_hooks << hook end.dynamic_library_suffixes ⇒ Object
Suffixes for dynamic library require-able paths.
1056 1057 1058
# File 'lib/rubygems.rb', line 1056 def self.dynamic_library_suffixes @dynamic_library_suffixes ||= suffixes - [".rb"] end.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil) ⇒ Object
Quietly ensure the Gem directory dir contains all the proper subdirectories for handling default gems. If we can’t create a directory due to a permission problem, then we will silently continue.
If mode is given, missing directories are created with this mode.
World-writable directories will never be created.
.ensure_gem_subdirectories(dir = Gem.dir, mode = nil) ⇒ ObjectQuietly ensure the Gem directory dir contains all the proper subdirectories. If we can’t create a directory due to a permission problem, then we will silently continue.
If mode is given, missing directories are created with this mode.
World-writable directories will never be created.
476 477 478
# File 'lib/rubygems.rb', line 476 def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil) ensure_subdirectories(dir, mode, REPOSITORY_SUBDIRECTORIES) end.ensure_subdirectories(dir, mode, subdirs) ⇒ Object
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
# File 'lib/rubygems.rb', line 493
def self.ensure_subdirectories(dir, mode, subdirs) old_umask = File.umask
File.umask old_umask | 0o002
options = {}
options[:mode] = mode if mode
subdirs.each do |name|
subdir = File.join dir, name
next if File.exist? subdir
require "fileutils"
begin
FileUtils.mkdir_p subdir, **options
rescue SystemCallError
end
end
ensure
File.umask old_umask
end .env_requirement(gem_name) ⇒ Object
924 925 926 927 928 929 930
# File 'lib/rubygems.rb', line 924
def self.env_requirement(gem_name)
@env_requirements_by_name ||= {}
@env_requirements_by_name[gem_name] ||= begin
req = ENV["GEM_REQUIREMENT_#{gem_name.upcase}"] || ">= 0"
Gem::Requirement.create(req)
end
end .extension_api_version ⇒ Object
The extension API version of ruby. This includes the static vs non-static distinction as extensions cannot be shared between the two.
520 521 522 523 524 525 526
# File 'lib/rubygems.rb', line 520
def self.extension_api_version if target_rbconfig["ENABLE_SHARED"] == "no"
"#{ruby_api_version}-static"
else
ruby_api_version
end
end .find_config_file ⇒ Object
Finds the user’s config file
121 122 123 124 125 126 127 128
# File 'lib/rubygems/defaults.rb', line 121
def self.find_config_file
gemrc = File.join Gem.user_home, ".gemrc"
if File.exist? gemrc
gemrc
else
File.join Gem.config_home, "gem", "gemrc"
end
end .find_default_spec(path) ⇒ Object
Find a Gem::Specification of default gem from path
1330 1331 1332
# File 'lib/rubygems.rb', line 1330 def find_default_spec(path) @path_to_default_spec_map[path] end.find_files(glob, check_load_path = true) ⇒ Object
Returns a list of paths matching glob that can be used by a gem to pick up features from other gems. For example:
Gem.find_files('rdoc/discover').each do |path| load path end
if check_load_path is true (the default), then find_files also searches $LOAD_PATH for files as well as gems.
Note that find_files will return all files even if they are from different versions of the same gem. See also find_latest_files
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
# File 'lib/rubygems.rb', line 540
def self.find_files(glob, check_load_path=true)
files = []
files = find_files_from_load_path glob if check_load_path
gem_specifications = @gemdeps ? Gem.loaded_specs.values : Gem::Specification.stubs
files.concat gem_specifications.flat_map {|spec|
spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
}
files.uniq! if check_load_path
files
end .find_files_from_load_path(glob) ⇒ Object
558 559 560 561 562 563
# File 'lib/rubygems.rb', line 558
def self.find_files_from_load_path(glob) glob_with_suffixes = "#{glob}#{Gem.suffix_pattern}"
$LOAD_PATH.flat_map do |load_path|
Gem::Util.glob_files_in_dir(glob_with_suffixes, load_path)
end.select {|file| File.file? file }
end .find_latest_files(glob, check_load_path = true) ⇒ Object
Returns a list of paths matching glob from the latest gems that can be used by a gem to pick up features from other gems. For example:
Gem.find_latest_files('rdoc/discover').each do |path| load path end
if check_load_path is true (the default), then find_latest_files also searches $LOAD_PATH for files as well as gems.
Unlike find_files, find_latest_files will return only files from the latest version of a gem.
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
# File 'lib/rubygems.rb', line 577
def self.find_latest_files(glob, check_load_path=true)
files = []
files = find_files_from_load_path glob if check_load_path
files.concat Gem::Specification.latest_specs(true).flat_map {|spec|
spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
}
files.uniq! if check_load_path
files
end .find_unresolved_default_spec(path) ⇒ Object
Find an unresolved Gem::Specification of default gem from path
1337 1338 1339 1340
# File 'lib/rubygems.rb', line 1337 def find_unresolved_default_spec(path) default_spec = @path_to_default_spec_map[path] default_spec if default_spec && loaded_specs[default_spec.name] != default_spec end.finish_resolve(request_set = Gem::RequestSet.new) ⇒ Object
230 231 232 233 234 235 236 237
# File 'lib/rubygems.rb', line 230
def self.finish_resolve(request_set=Gem::RequestSet.new)
request_set.import Gem::Specification.unresolved_deps.values
request_set.import Gem.loaded_specs.values.map {|s| Gem::Dependency.new(s.name, s.version) }
request_set.resolve_current.each do |s|
s.full_spec.activate
end
end .freebsd_platform? ⇒ Boolean
1126 1127 1128
# File 'lib/rubygems.rb', line 1126
def self.freebsd_platform?
RbConfig::CONFIG["host_os"].to_s.include?("bsd")
end .host ⇒ Object
Get the default RubyGems API host. This is normally https://rubygems.org.
612 613 614
# File 'lib/rubygems.rb', line 612 def self.host @host ||= Gem::DEFAULT_HOST end.host=(host) ⇒ Object
Set the default RubyGems API host.
618 619 620
# File 'lib/rubygems.rb', line 618 def self.host=(host) @host = host end.install(name, version = Gem::Requirement.default, *options) ⇒ Object
Top level install helper method. Allows you to install gems interactively:
% irb
>> Gem.install "minitest"
Fetching: minitest-5.14.0.gem (100%)
=> [#<Gem::Specification:0x1013b4528 @name="minitest", ...>]
601 602 603 604 605 606
# File 'lib/rubygems.rb', line 601 def self.install(name, version = Gem::Requirement.default, *options) require_relative "rubygems/dependency_installer" inst = Gem::DependencyInstaller.new(*options) inst.install name, version inst.installed_gems end.install_extension_in_lib ⇒ Object
Install extensions into lib as well as into the extension directory.
253 254 255
# File 'lib/rubygems/defaults.rb', line 253 def self.install_extension_in_lib Gem.configuration.install_extension_in_lib end.java_platform? ⇒ Boolean
1112 1113 1114
# File 'lib/rubygems.rb', line 1112 def self.java_platform? RUBY_PLATFORM == "java" end.latest_rubygems_version ⇒ Object
Returns the latest release version of RubyGems.
949 950 951 952
# File 'lib/rubygems.rb', line 949
def self.latest_rubygems_version
latest_version_for("rubygems-update") ||
raise("Can't find 'rubygems-update' in any repo. Check `gem source list`.")
end .latest_spec_for(name) ⇒ Object
Returns the latest release-version specification for the gem name.
936 937 938 939 940 941 942 943 944
# File 'lib/rubygems.rb', line 936 def self.latest_spec_for(name) dependency = Gem::Dependency.new name fetcher = Gem::SpecFetcher.fetcher spec_tuples, = fetcher.spec_for_dependency dependency spec, = spec_tuples.last spec end.latest_version_for(name) ⇒ Object
Returns the version of the latest release-version of gem name
957 958 959
# File 'lib/rubygems.rb', line 957 def self.latest_version_for(name) latest_spec_for(name)&.version end.load_bundler_extensions(version) ⇒ Object
Load Bundler extensions to RubyGems, making sure to avoid redefinition warnings in platform constants
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
# File 'lib/rubygems.rb', line 684
def self.load_bundler_extensions(version)
return unless version <= "2.6.9"
previous_platforms = {}
platform_const_list = ["JAVA", "MSWIN", "MSWIN64", "MINGW", "X64_MINGW_LEGACY", "X64_MINGW", "UNIVERSAL_MINGW", "WINDOWS", "X64_LINUX", "X64_LINUX_MUSL"]
platform_const_list.each do |platform|
previous_platforms[platform] = Gem::Platform.const_get(platform)
Gem::Platform.send(:remove_const, platform)
end
require "bundler/rubygems_ext"
platform_const_list.each do |platform|
Gem::Platform.send(:remove_const, platform) if Gem::Platform.const_defined?(platform)
Gem::Platform.const_set(platform, previous_platforms[platform])
end
end .load_env_plugins ⇒ Object
Find all ‘rubygems_plugin’ files in $LOAD_PATH and load them
1161 1162 1163
# File 'lib/rubygems.rb', line 1161
def self.load_env_plugins
load_plugin_files find_files_from_load_path("rubygems_plugin")
end .load_path_insert_index ⇒ Object
The index to insert activated gem paths into the $LOAD_PATH. The activated gem’s paths are inserted before site lib directory by default.
626 627 628 629 630 631 632 633 634
# File 'lib/rubygems.rb', line 626
def self.load_path_insert_index
$LOAD_PATH.each_with_index do |path, i|
return i if path.instance_variable_defined?(:@gem_prelude_index)
end
index = $LOAD_PATH.index RbConfig::CONFIG["sitelibdir"]
index || 0
end .load_plugin_files(plugins) ⇒ Object
Load plugins as Ruby files
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
# File 'lib/rubygems.rb', line 1133
def self.load_plugin_files(plugins) plugins.each do |plugin|
next if /gemcutter-0\.[0-3]/.match?(plugin)
begin
load plugin
rescue ScriptError, StandardError => e
details = "#{plugin.inspect}: #{e.message} (#{e.class})"
warn "Error loading RubyGems plugin #{details}"
end
end
end .load_plugins ⇒ Object
Find rubygems plugin files in the standard location and load them
.load_safe_marshal ⇒ Object672 673 674 675 676 677 678
# File 'lib/rubygems.rb', line 672 def self.load_safe_marshal return if @safe_marshal_loaded require_relative "rubygems/safe_marshal" @safe_marshal_loaded = true end.load_yaml ⇒ Object
Loads YAML, preferring Psych
659 660 661 662 663 664 665 666 667 668
# File 'lib/rubygems.rb', line 659 def self.load_yaml return if @yaml_loaded require "psych" require_relative "rubygems/psych_tree" require_relative "rubygems/safe_yaml" @yaml_loaded = true end.location_of_caller(depth = 1) ⇒ Object
The file name and line number of the caller of the caller of this method.
depth is how many layers up the call stack it should go.
e.g.,
def a; Gem.location_of_caller; end a #=> [“x.rb”, 2] # (it’ll vary depending on file name and line number)
def b; c; end def c; Gem.location_of_caller(2); end b #=> [“x.rb”, 6] # (it’ll vary depending on file name and line number)
718 719 720 721 722 723 724
# File 'lib/rubygems.rb', line 718 def self.location_of_caller(depth = 1) caller[depth] =~ /(.*?):(\d+).*?$/i file = $1 lineno = $2.to_i [file, lineno] end.marshal_version ⇒ Object
The version of the Marshal format for your Ruby.
729 730 731
# File 'lib/rubygems.rb', line 729
def self.marshal_version
"#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
end .needs {|rs| ... } ⇒ Object
222 223 224 225 226 227 228
# File 'lib/rubygems.rb', line 222 def self.needs rs = Gem::RequestSet.new yield rs finish_resolve rs end.open_file(path, flags, &block) ⇒ Object
Open a file with given flags
865 866 867
# File 'lib/rubygems.rb', line 865 def self.open_file(path, flags, &block) File.open(path, flags, &block) end.open_file_with_flock(path, &block) ⇒ Object
Open a file with given flags, and protect access with flock
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
# File 'lib/rubygems.rb', line 883
def self.open_file_with_flock(path, &block)
mode = IO::RDWR | IO::APPEND | IO::CREAT | IO::BINARY
mode |= IO::SHARE_DELETE if IO.const_defined?(:SHARE_DELETE)
File.open(path, mode) do |io|
begin
if io.flock(File::LOCK_EX | File::LOCK_NB) != 0
warn "Waiting for another process to let go of lock: #{path}"
io.flock(File::LOCK_EX)
end
io.puts(Process.pid)
rescue Errno::ENOSYS, Errno::ENOTSUP
end
yield io
end
end .open_file_with_lock(path, &block) ⇒ Object
Open a file with given flags, and protect access with a file lock
872 873 874 875 876 877 878
# File 'lib/rubygems.rb', line 872
def self.open_file_with_lock(path, &block)
file_lock = "#{path}.lock"
open_file_with_flock(file_lock, &block)
ensure
require "fileutils"
FileUtils.rm_f file_lock
end .operating_system_defaults ⇒ Object
Default options for gem commands for Ruby packagers.
The options here should be structured as an array of string “gem” command names as keys and a string of the default options as values.
Example:
def self.operating_system_defaults
{
'install' => '--no-rdoc --no-ri --env-shebang',
'update' => '--no-rdoc --no-ri --env-shebang'
}
end
286 287 288
# File 'lib/rubygems/defaults.rb', line 286
def self.operating_system_defaults
{}
end .path ⇒ Object
442 443 444
# File 'lib/rubygems.rb', line 442 def self.path paths.path end.path_separator ⇒ Object
How String Gem paths should be split. Overridable for esoteric platforms.
168 169 170
# File 'lib/rubygems/defaults.rb', line 168 def self.path_separator File::PATH_SEPARATOR end.paths ⇒ Object
Retrieve the PathSupport object that RubyGems uses to lookup files.
398 399 400
# File 'lib/rubygems.rb', line 398 def self.paths @paths ||= Gem::PathSupport.new(ENV) end.paths=(env) ⇒ Object
Initialize the filesystem paths to use from env. env is a hash-like object (typically ENV) that is queried for ‘GEM_HOME’, ‘GEM_PATH’, and ‘GEM_SPEC_CACHE’ Keys for the env hash should be Strings, and values of the hash should be Strings or nil.
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
# File 'lib/rubygems.rb', line 408
def self.paths=(env)
clear_paths
target = {}
env.each_pair do |k,v|
case k
when "GEM_HOME", "GEM_PATH", "GEM_SPEC_CACHE"
case v
when nil, String
target[k] = v
when Array
unless Gem::Deprecate.skip
warn <<-EOWARN
Array values in the parameter to `Gem.paths=` are deprecated.
Please use a String or nil.
An Array (#{env.inspect}) was passed in from #{caller[3]}
EOWARN
end
target[k] = v.join File::PATH_SEPARATOR
end
else
target[k] = v
end
end
@paths = Gem::PathSupport.new ENV.to_hash.merge(target)
Gem::Specification.dirs = @paths.path
end .platform_defaults ⇒ Object
Default options for gem commands for Ruby implementers.
The options here should be structured as an array of string “gem” command names as keys and a string of the default options as values.
Example:
def self.platform_defaults
{
'install' => '--no-rdoc --no-ri --env-shebang',
'update' => '--no-rdoc --no-ri --env-shebang'
}
end
305 306 307
# File 'lib/rubygems/defaults.rb', line 305
def self.platform_defaults
{}
end .platforms ⇒ Object
Array of platforms this RubyGems supports.
743 744 745 746 747 748 749
# File 'lib/rubygems.rb', line 743
def self.platforms
@platforms ||= []
if @platforms.empty?
@platforms = [Gem::Platform::RUBY, Gem::Platform.local]
end
@platforms
end .platforms=(platforms) ⇒ Object
Set array of platforms this RubyGems supports (primarily for testing).
736 737 738
# File 'lib/rubygems.rb', line 736 def self.platforms=(platforms) @platforms = platforms end.plugin_suffix_pattern ⇒ Object
Glob pattern for require-able plugin suffixes.
1029 1030 1031
# File 'lib/rubygems.rb', line 1029
def self.plugin_suffix_pattern
@plugin_suffix_pattern ||= "_plugin#{suffix_pattern}"
end .plugin_suffix_regexp ⇒ Object
Regexp for require-able plugin suffixes.
1036 1037 1038
# File 'lib/rubygems.rb', line 1036
def self.plugin_suffix_regexp
@plugin_suffix_regexp ||= /_plugin#{suffix_regexp}\z/
end .plugindir(install_dir = Gem.dir) ⇒ Object
The path were rubygems plugins are to be installed.
356 357 358
# File 'lib/rubygems.rb', line 356 def self.plugindir(install_dir=Gem.dir) File.join install_dir, "plugins" end.post_build(&hook) ⇒ Object
Adds a post-build hook that will be passed an Gem::Installer instance when Gem::Installer#install is called. The hook is called after the gem has been extracted and extensions have been built but before the executables or gemspec has been written. If the hook returns false then the gem’s files will be removed and the install will be aborted.
758 759 760
# File 'lib/rubygems.rb', line 758 def self.post_build(&hook) @post_build_hooks << hook end.post_install(&hook) ⇒ Object
Adds a post-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is called
766 767 768
# File 'lib/rubygems.rb', line 766 def self.post_install(&hook) @post_install_hooks << hook end.post_reset(&hook) ⇒ Object
Adds a hook that will get run after Gem::Specification.reset is run.
783 784 785
# File 'lib/rubygems.rb', line 783 def self.post_reset(&hook) @post_reset_hooks << hook end.post_uninstall(&hook) ⇒ Object
Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance and the spec that was uninstalled when Gem::Uninstaller#uninstall is called
792 793 794
# File 'lib/rubygems.rb', line 792 def self.post_uninstall(&hook) @post_uninstall_hooks << hook end.pre_install(&hook) ⇒ Object
Adds a pre-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is called. If the hook returns false then the install will be aborted.
801 802 803
# File 'lib/rubygems.rb', line 801 def self.pre_install(&hook) @pre_install_hooks << hook end.pre_reset(&hook) ⇒ Object
Adds a hook that will get run before Gem::Specification.reset is run.
809 810 811
# File 'lib/rubygems.rb', line 809 def self.pre_reset(&hook) @pre_reset_hooks << hook end.pre_uninstall(&hook) ⇒ Object
Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance and the spec that will be uninstalled when Gem::Uninstaller#uninstall is called
818 819 820
# File 'lib/rubygems.rb', line 818 def self.pre_uninstall(&hook) @pre_uninstall_hooks << hook end.prefix ⇒ Object
The directory prefix this RubyGems was installed at. If your prefix is in a standard location (ie, rubygems is installed where you’d expect it to be), then prefix returns nil.
827 828 829 830 831 832 833 834 835
# File 'lib/rubygems.rb', line 827
def self.prefix
prefix = File.dirname RUBYGEMS_DIR
if prefix != File.expand_path(RbConfig::CONFIG["sitelibdir"]) &&
prefix != File.expand_path(RbConfig::CONFIG["libdir"]) &&
File.basename(RUBYGEMS_DIR) == "lib"
prefix
end
end .read_binary(path) ⇒ Object
Safely read a file in binary mode on all platforms.
847 848 849
# File 'lib/rubygems.rb', line 847 def self.read_binary(path) File.binread(path) end.refresh ⇒ Object
Refresh available gems from disk.
.register_default_spec(spec) ⇒ ObjectRegister a Gem::Specification for default gem.
Two formats for the specification are supported:
MRI 2.0 style, where spec.files contains unprefixed require names. The spec’s filenames will be registered as-is.
New style, where spec.files contains files prefixed with paths from spec.require_paths. The prefixes are stripped before registering the spec’s filenames. Unprefixed files are omitted.
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
# File 'lib/rubygems.rb', line 1305
def register_default_spec(spec)
extended_require_paths = spec.require_paths.map {|f| f + "/" }
new_format = extended_require_paths.any? {|path| spec.files.any? {|f| f.start_with? path } }
if new_format
prefix_group = extended_require_paths.join("|")
prefix_pattern = /^(#{prefix_group})/
end
spec.files.each do |file|
if new_format
file = file.sub(prefix_pattern, "")
next unless $~
end
spec.activate if already_loaded?(file)
@path_to_default_spec_map[file] = spec
@path_to_default_spec_map[file.sub(suffix_regexp, "")] = spec
end
end .ruby ⇒ Object
The path to the running Ruby interpreter.
907 908 909 910 911 912 913 914 915
# File 'lib/rubygems.rb', line 907
def self.ruby
if @ruby.nil?
@ruby = RbConfig.ruby
@ruby = "\"#{@ruby}\"" if /\s/.match?(@ruby)
end
@ruby
end .ruby_api_version ⇒ Object
Returns a String containing the API compatibility version of Ruby
920 921 922
# File 'lib/rubygems.rb', line 920 def self.ruby_api_version @ruby_api_version ||= target_rbconfig["ruby_version"].dup end.ruby_engine ⇒ Object
208 209 210
# File 'lib/rubygems/defaults.rb', line 208 def self.ruby_engine RUBY_ENGINE end.ruby_version ⇒ Object
A Gem::Version for the currently running Ruby.
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
# File 'lib/rubygems.rb', line 964
def self.ruby_version
return @ruby_version if defined? @ruby_version
version = RUBY_VERSION.dup
if RUBY_PATCHLEVEL == -1
if RUBY_ENGINE == "ruby"
desc = RUBY_DESCRIPTION[/\Aruby #{Regexp.quote(RUBY_VERSION)}([^ ]+) /, 1]
else
desc = RUBY_DESCRIPTION[/\A#{RUBY_ENGINE} #{Regexp.quote(RUBY_ENGINE_VERSION)} \(#{RUBY_VERSION}([^ ]+)\) /, 1]
end
version << ".#{desc}" if desc
end
@ruby_version = Gem::Version.new version
end .rubygems_version ⇒ Object
A Gem::Version for the currently running RubyGems
983 984 985 986
# File 'lib/rubygems.rb', line 983 def self.rubygems_version return @rubygems_version if defined? @rubygems_version @rubygems_version = Gem::Version.new Gem::VERSION end.set_target_rbconfig(rbconfig_path) ⇒ Object .solaris_platform? ⇒ Boolean
Is this platform Solaris?
1119 1120 1121
# File 'lib/rubygems.rb', line 1119
def self.solaris_platform?
RUBY_PLATFORM.include?("solaris")
end .source_date_epoch ⇒ Object
Returns the value of Gem.source_date_epoch_string, as a Time object.
This is used throughout RubyGems for enabling reproducible builds.
1260 1261 1262
# File 'lib/rubygems.rb', line 1260 def self.source_date_epoch Time.at(source_date_epoch_string.to_i).utc.freeze end.source_date_epoch_string ⇒ Object
If the SOURCE_DATE_EPOCH environment variable is set, returns it’s value. Otherwise, returns DEFAULT_SOURCE_DATE_EPOCH as a string.
NOTE(@duckinator): The implementation is a tad weird because we want to:
1. Make builds reproducible by default, by having this function always
return the same result during a given run.
2. Allow changing ENV['SOURCE_DATE_EPOCH'] at runtime, since multiple
tests that set this variable will be run in a single process.
If you simplify this function and a lot of tests fail, that is likely due to #2 above.
Details on SOURCE_DATE_EPOCH: reproducible-builds.org/specs/source-date-epoch/
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
# File 'lib/rubygems.rb', line 1244
def self.source_date_epoch_string
specified_epoch = ENV["SOURCE_DATE_EPOCH"]
specified_epoch = nil if !specified_epoch.nil? && specified_epoch.strip.empty?
epoch = specified_epoch || DEFAULT_SOURCE_DATE_EPOCH.to_s
epoch.strip
end .sources ⇒ Object
Returns an Array of sources to fetch remote gems from. Uses default_sources if the sources list is empty.
992 993 994 995
# File 'lib/rubygems.rb', line 992 def self.sources source_list = configuration.sources || default_sources @sources ||= Gem::SourceList.from(source_list) end.sources=(new_sources) ⇒ Object
Need to be able to set the sources without calling Gem.sources.replace since that would cause an infinite loop.
DOC: This comment is not documentation about the method itself, it’s more of a code comment about the implementation.
1004 1005 1006 1007 1008 1009 1010
# File 'lib/rubygems.rb', line 1004
def self.sources=(new_sources)
if !new_sources
@sources = nil
else
@sources = Gem::SourceList.from(new_sources)
end
end .spec_cache_dir ⇒ Object
446 447 448
# File 'lib/rubygems.rb', line 446 def self.spec_cache_dir paths.spec_cache_dir end.state_file ⇒ Object
The path to standard location of the user’s state file.
140 141 142
# File 'lib/rubygems/defaults.rb', line 140 def self.state_file @state_file ||= File.join(Gem.state_home, "gem", "last_update_check") end.state_home ⇒ Object
The path to standard location of the user’s state directory.
161 162 163
# File 'lib/rubygems/defaults.rb', line 161 def self.state_home @state_home ||= ENV["XDG_STATE_HOME"] || File.join(Gem.user_home, ".local", "state") end.suffix_pattern ⇒ Object
Glob pattern for require-able path suffixes.
1015 1016 1017
# File 'lib/rubygems.rb', line 1015
def self.suffix_pattern
@suffix_pattern ||= "{#{suffixes.join(",")}}"
end .suffix_regexp ⇒ Object
Regexp for require-able path suffixes.
1022 1023 1024
# File 'lib/rubygems.rb', line 1022
def self.suffix_regexp
@suffix_regexp ||= /#{Regexp.union(suffixes)}\z/
end .suffixes ⇒ Object
Suffixes for require-able paths.
1043 1044 1045 1046 1047 1048 1049 1050 1051
# File 'lib/rubygems.rb', line 1043
def self.suffixes
@suffixes ||= ["",
".rb",
*%w[DLEXT DLEXT2].map do |key|
val = RbConfig::CONFIG[key]
next unless val && !val.empty?
".#{val}"
end].compact.uniq
end .target_rbconfig ⇒ Object
The RbConfig object for the deployment target platform.
This is usually the same as the running platform, but may be different if you are cross-compiling.
.time(msg, width = 0, display = Gem.configuration.verbose) ⇒ ObjectPrints the amount of time the supplied block takes to run using the debug UI output.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
# File 'lib/rubygems.rb', line 1064
def self.time(msg, width = 0, display = Gem.configuration.verbose)
now = Time.now
value = yield
elapsed = Time.now - now
ui.say format("%2$*1$s: %3$3.3fs", -width, msg, elapsed) if display
value
end .try_activate(path) ⇒ Object
Try to activate a gem containing path. Returns true if activation succeeded or wasn’t needed because it was already activated. Returns false if it can’t find the path in a gem.
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
# File 'lib/rubygems.rb', line 197
def self.try_activate(path)
spec = Gem::Specification.find_by_path path
return false unless spec
return true if spec.activated?
begin
spec.activate
rescue Gem::LoadError => e spec_by_name = Gem::Specification.find_by_name(spec.name)
if spec_by_name.nil?
raise e
else
spec_by_name.activate
end
end
true
end .ui ⇒ Object
Lazily loads DefaultUserInteraction and returns the default UI.
1079 1080 1081 1082 1083
# File 'lib/rubygems.rb', line 1079 def self.ui require_relative "rubygems/user_interaction" Gem::DefaultUserInteraction.ui end.URI(uri) ⇒ Object
Returns a Gem::URI object derived from the given uri, which may be a Gem::URI string or an existing Gem::URI object:
uri = Gem::URI('http://github.com/ruby/ruby')
Gem::URI(uri)
869 870 871 872 873 874 875 876 877 878
# File 'lib/rubygems/vendor/uri/lib/uri/common.rb', line 869
def URI(uri)
if uri.is_a?(Gem::URI::Generic)
uri
elsif uri = String.try_convert(uri)
Gem::URI.parse(uri)
else
raise ArgumentError,
"bad argument (expected Gem::URI object or Gem::URI string)"
end
end .use_gemdeps(path = nil) ⇒ Object
Looks for a gem dependency file at path and activates the gems in the file if found. If the file is not found an ArgumentError is raised.
If path is not given the RUBYGEMS_GEMDEPS environment variable is used, but if no file is found no exception is raised.
If ‘-’ is given for path RubyGems searches up from the current working directory for gem dependency files (gem.deps.rb, Gemfile, Isolate) and activates the gems in the first one found.
You can run this automatically when rubygems starts. To enable, set the RUBYGEMS_GEMDEPS environment variable to either the path of your gem dependencies file or “-” to auto-discover in parent directories.
NOTE: Enabling automatic discovery on multiuser systems can lead to execution of arbitrary code when used from directories outside your control.
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
# File 'lib/rubygems.rb', line 1185
def self.use_gemdeps(path = nil)
raise_exception = path
path ||= ENV["RUBYGEMS_GEMDEPS"]
return unless path
path = path.dup
if path == "-"
Gem::Util.traverse_parents Dir.pwd do |directory|
dep_file = GEM_DEP_FILES.find {|f| File.file?(f) }
next unless dep_file
path = File.join directory, dep_file
break
end
end
unless File.file? path
return unless raise_exception
raise ArgumentError, "Unable to find gem dependencies file at #{path}"
end
ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path)
require_relative "rubygems/user_interaction"
require "bundler"
begin
Gem::DefaultUserInteraction.use_ui(ui) do
Bundler.ui.silence do
@gemdeps = Bundler.setup
end
ensure
Gem::DefaultUserInteraction.ui.close
end
rescue Bundler::BundlerError => e
warn e.message
warn "You may need to `bundle install` to install missing gems"
warn ""
end
end .use_paths(home, *paths) ⇒ Object
Use the home and paths values for Gem.dir and Gem.path. Used mainly by the unit tests to provide environment isolation.
1089 1090 1091 1092 1093 1094 1095
# File 'lib/rubygems.rb', line 1089
def self.use_paths(home, *paths)
paths.flatten!
paths.compact!
hash = { "GEM_HOME" => home, "GEM_PATH" => paths.empty? ? home : paths.join(File::PATH_SEPARATOR) }
hash.delete_if {|_, v| v.nil? }
self.paths = hash
end .user_dir ⇒ Object
Path for gems in the user’s home directory
103 104 105 106 107 108 109
# File 'lib/rubygems/defaults.rb', line 103 def self.user_dir gem_dir = File.join(Gem.user_home, ".gem") gem_dir = File.join(Gem.data_home, "gem") unless File.exist?(gem_dir) parts = [gem_dir, ruby_engine] parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty? File.join parts end.user_home ⇒ Object
The home directory for the user.
96 97 98
# File 'lib/rubygems/defaults.rb', line 96 def self.user_home @user_home ||= find_home end.vendor_dir ⇒ Object
Directory where vendor gems are installed.
260 261 262 263 264 265 266 267 268 269
# File 'lib/rubygems/defaults.rb', line 260
def self.vendor_dir if vendor_dir = ENV["GEM_VENDOR"]
return vendor_dir.dup
end
return nil unless RbConfig::CONFIG.key? "vendordir"
File.join RbConfig::CONFIG["vendordir"], "gems",
RbConfig::CONFIG["ruby_version"]
end .win_platform? ⇒ Boolean
Is this a windows platform?
1100 1101 1102 1103 1104 1105 1106 1107
# File 'lib/rubygems.rb', line 1100
def self.win_platform?
if @@win_platform.nil?
ruby_platform = RbConfig::CONFIG["host_os"]
@@win_platform = !WIN_PATTERNS.find {|r| ruby_platform =~ r }.nil?
end
@@win_platform
end .write_binary(path, data) ⇒ Object
Safely write a file in binary mode on all platforms.
854 855 856 857 858 859 860
# File 'lib/rubygems.rb', line 854
def self.write_binary(path, data)
File.binwrite(path, data)
rescue Errno::ENOSPC
File.delete(path) if File.exist?(path)
raise
end
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4