diff options
Diffstat (limited to 'lib/rubygems.rb')
| -rw-r--r-- | lib/rubygems.rb | 934 |
1 files changed, 498 insertions, 436 deletions
diff --git a/lib/rubygems.rb b/lib/rubygems.rb index 56290aa570..d289cab0fd 100644 --- a/lib/rubygems.rb +++ b/lib/rubygems.rb @@ -1,24 +1,23 @@ # frozen_string_literal: true -# -*- ruby -*- + #-- # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. # All rights reserved. # See LICENSE.txt for permissions. #++ -require 'rbconfig' -require 'thread' +require "rbconfig" module Gem - VERSION = "2.7.2" + VERSION = "4.1.0.dev" end -# Must be first since it unloads the prelude from 1.9.2 -require 'rubygems/compatibility' - -require 'rubygems/defaults' -require 'rubygems/deprecate' -require 'rubygems/errors' +require_relative "rubygems/defaults" +require_relative "rubygems/deprecate" +require_relative "rubygems/errors" +require_relative "rubygems/target_rbconfig" +require_relative "rubygems/win_platform" +require_relative "rubygems/util/atomic_file_writer" ## # RubyGems is the Ruby standard for publishing and managing third party @@ -27,32 +26,30 @@ require 'rubygems/errors' # For user documentation, see: # # * <tt>gem help</tt> and <tt>gem help [command]</tt> -# * {RubyGems User Guide}[http://guides.rubygems.org/] -# * {Frequently Asked Questions}[http://guides.rubygems.org/faqs] +# * {RubyGems User Guide}[https://guides.rubygems.org/] +# * {Frequently Asked Questions}[https://guides.rubygems.org/faqs] # # For gem developer documentation see: # -# * {Creating Gems}[http://guides.rubygems.org/make-your-own-gem] +# * {Creating Gems}[https://guides.rubygems.org/make-your-own-gem] # * Gem::Specification # * Gem::Version for version dependency notes # # Further RubyGems documentation can be found at: # -# * {RubyGems Guides}[http://guides.rubygems.org] -# * {RubyGems API}[http://www.rubydoc.info/github/rubygems/rubygems] (also available from +# * {RubyGems Guides}[https://guides.rubygems.org] +# * {RubyGems API}[https://guides.rubygems.org/rubygems-org-api/] (also available from # <tt>gem server</tt>) # # == RubyGems Plugins # -# As of RubyGems 1.3.2, RubyGems will load plugins installed in gems or +# RubyGems will load plugins in the latest version of each installed gem or # $LOAD_PATH. Plugins must be named 'rubygems_plugin' (.rb, .so, etc) and -# placed at the root of your gem's #require_path. Plugins are discovered via -# Gem::find_files and then loaded. Take care when implementing a plugin as your -# plugin file may be loaded multiple times if multiple versions of your gem -# are installed. +# placed at the root of your gem's #require_path. Plugins are installed at a +# special location and loaded on boot. # # For an example plugin, see the {Graph gem}[https://github.com/seattlerb/graph] -# which adds a `gem graph` command. +# which adds a <tt>gem graph</tt> command. # # == RubyGems Defaults, Packaging # @@ -73,7 +70,7 @@ require 'rubygems/errors' # == Bugs # # You can submit bugs to the -# {RubyGems bug tracker}[https://github.com/rubygems/rubygems/issues] +# {RubyGems bug tracker}[https://github.com/ruby/rubygems/issues] # on GitHub # # == Credits @@ -109,34 +106,21 @@ require 'rubygems/errors' # # == License # -# See {LICENSE.txt}[rdoc-ref:lib/rubygems/LICENSE.txt] for permissions. +# See {LICENSE.txt}[https://github.com/ruby/rubygems/blob/master/LICENSE.txt] for permissions. # # Thanks! # # -The RubyGems Team - module Gem - RUBYGEMS_DIR = File.dirname File.expand_path(__FILE__) - - ## - # An Array of Regexps that match windows Ruby platforms. - - WIN_PATTERNS = [ - /bccwin/i, - /cygwin/i, - /djgpp/i, - /mingw/i, - /mswin/i, - /wince/i, - ] + RUBYGEMS_DIR = __dir__ GEM_DEP_FILES = %w[ gem.deps.rb gems.rb Gemfile Isolate - ] + ].freeze ## # Subdirectories in a gem repository @@ -147,8 +131,9 @@ module Gem doc extensions gems + plugins specifications - ] + ].freeze ## # Subdirectories in a gem repository for default gems @@ -156,36 +141,19 @@ module Gem REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES = %w[ gems specifications/default - ] - - ## - # Exception classes used in a Gem.read_binary +rescue+ statement. Not all of - # these are defined in Ruby 1.8.7, hence the need for this convoluted setup. - - READ_BINARY_ERRORS = begin - read_binary_errors = [Errno::EACCES, Errno::EROFS] - read_binary_errors << Errno::ENOTSUP if Errno.const_defined?(:ENOTSUP) - read_binary_errors - end.freeze + ].freeze ## - # Exception classes used in Gem.write_binary +rescue+ statement. Not all of - # these are defined in Ruby 1.8.7. - - WRITE_BINARY_ERRORS = begin - write_binary_errors = [] - write_binary_errors << Errno::ENOTSUP if Errno.const_defined?(:ENOTSUP) - write_binary_errors - end.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. - USE_BUNDLER_FOR_GEMDEPS = true # :nodoc: - - @@win_platform = nil + DEFAULT_SOURCE_DATE_EPOCH = 315_619_200 @configuration = nil @gemdeps = nil @loaded_specs = {} - LOADED_SPECS_MUTEX = Mutex.new + LOADED_SPECS_MUTEX = Thread::Mutex.new @path_to_default_spec_map = {} @platforms = [] @ruby = nil @@ -200,12 +168,18 @@ module Gem @pre_reset_hooks ||= [] @post_reset_hooks ||= [] + @default_source_date_epoch = nil + + @discover_gems_on_require = true + + @target_rbconfig = nil + ## # 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. - def self.try_activate path + def self.try_activate(path) # finds the _latest_ version... regardless of loaded specs and their deps # if another gem had a requirement that would mean we shouldn't # activate the latest version, then either it would already be activated @@ -219,15 +193,17 @@ module Gem begin spec.activate rescue Gem::LoadError => e # this could fail due to gem dep collisions, go lax - spec_by_name = Gem::Specification.find_by_name(spec.name) - if spec_by_name.nil? + name = spec.name + spec = Gem::Specification.find_unloaded_by_path(path) + spec ||= Gem::Specification.find_by_name(name) + if spec.nil? raise e else - spec_by_name.activate + spec.activate end end - return true + true end def self.needs @@ -238,7 +214,7 @@ module Gem finish_resolve rs end - def self.finish_resolve(request_set=Gem::RequestSet.new) + 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) } @@ -249,45 +225,44 @@ module Gem ## # Find the full path to the executable for gem +name+. If the +exec_name+ - # is not given, the gem's default_executable is chosen, otherwise the + # is not given, an exception will be raised, otherwise the # specified executable's path is returned. +requirements+ allows # you to specify specific gem versions. def self.bin_path(name, exec_name = nil, *requirements) - # TODO: fails test_self_bin_path_bin_file_gone_in_latest - # Gem::Specification.find_by_name(name, *requirements).bin_file exec_name - - raise ArgumentError, "you must supply exec_name" unless exec_name - requirements = Gem::Requirement.default if requirements.empty? find_spec_for_exe(name, exec_name, requirements).bin_file exec_name end - def self.find_spec_for_exe name, exec_name, requirements + def self.find_and_activate_spec_for_exe(name, exec_name, requirements) + spec = find_spec_for_exe name, exec_name, requirements + Gem::LOADED_SPECS_MUTEX.synchronize do + spec.activate + finish_resolve + end + spec + end + private_class_method :find_and_activate_spec_for_exe + + def self.find_spec_for_exe(name, exec_name, requirements) + raise ArgumentError, "you must supply exec_name" unless exec_name + dep = Gem::Dependency.new name, requirements loaded = Gem.loaded_specs[name] return loaded if loaded && dep.matches_spec?(loaded) - find_specs = proc { dep.matching_specs(true) } - if dep.to_s == "bundler (>= 0.a)" - specs = Gem::BundlerVersionFinder.without_filtering(&find_specs) - else - specs = find_specs.call - end + specs = dep.matching_specs(true) - specs = specs.find_all { |spec| + specs = specs.find_all do |spec| spec.executables.include? exec_name - } if exec_name + end if exec_name unless spec = specs.first msg = "can't find gem #{dep} with executable #{exec_name}" - if name == "bundler" && bundler_message = Gem::BundlerVersionFinder.missing_version_message - msg = bundler_message - end raise Gem::GemNotFoundException, msg end @@ -296,8 +271,8 @@ module Gem private_class_method :find_spec_for_exe ## - # Find the full path to the executable for gem +name+. If the +exec_name+ - # is not given, the gem's default_executable is chosen, otherwise the + # 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. # @@ -306,32 +281,70 @@ module Gem # # This method should *only* be used in bin stub files. - def self.activate_bin_path name, exec_name, requirement # :nodoc: - spec = find_spec_for_exe name, exec_name, [requirement] - Gem::LOADED_SPECS_MUTEX.synchronize do - spec.activate - finish_resolve + 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" + # Old versions of Bundler need a workaround to support nested `bundle + # exec` invocations by overriding `Gem.activate_bin_path`. However, + # RubyGems now uses this new `Gem.activate_and_load_bin_path` helper in + # binstubs, which is of course not overridden in Bundler since it didn't + # exist at the time. So, include the override here to workaround that. + load ENV["BUNDLE_BIN_PATH"] if ENV["BUNDLE_BIN_PATH"] && spec.version <= Gem::Version.create("2.5.22") + + # Make sure there's no version of Bundler in `$LOAD_PATH` that's different + # from the version we just activated. If that was the case (it happens + # when testing Bundler from ruby/ruby), we would load Bundler extensions + # to RubyGems from the copy in `$LOAD_PATH` but then load the binstub from + # an installed copy, causing those copies to be mixed and yet more + # redefinition warnings. + # + 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 - spec.bin_file exec_name + + load spec.bin_file(exec_name) + end + + ## + # 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. + + def self.activate_bin_path(name, exec_name = nil, *requirements) # :nodoc: + find_and_activate_spec_for_exe(name, exec_name, requirements).bin_file exec_name end ## # The mode needed to read a file as straight binary. def self.binary_mode - 'rb' + "rb" end ## # The path where gem executables are to be installed. - def self.bindir(install_dir=Gem.dir) - return File.join install_dir, 'bin' unless + 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 ## + # The path were rubygems plugins are to be installed. + + def self.plugindir(install_dir = Gem.dir) + File.join install_dir, "plugins" + end + + ## # 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. @@ -339,18 +352,13 @@ module Gem def self.clear_paths @paths = nil @user_home = nil + @cache_home = nil + @data_home = nil Gem::Specification.reset Gem::Security.reset if defined?(Gem::Security) end ## - # The path to standard location of the user's .gemrc file. - - def self.config_file - @config_file ||= File.join Gem.user_home, '.gemrc' - end - - ## # The standard configuration object for gems. def self.configuration @@ -366,25 +374,10 @@ module Gem end ## - # The path to the data directory specified by the gem name. If the - # package is not available as a gem, return nil. - - def self.datadir(gem_name) - spec = @loaded_specs[gem_name] - return nil if spec.nil? - spec.datadir - end - - class << self - extend Gem::Deprecate - deprecate :datadir, "spec.datadir", 2016, 10 - end - - ## # A Zlib::Deflate.deflate wrapper def self.deflate(data) - require 'zlib' + require "zlib" Zlib::Deflate.deflate data end @@ -406,17 +399,17 @@ module Gem target = {} env.each_pair do |k,v| case k - when 'GEM_HOME', 'GEM_PATH', 'GEM_SPEC_CACHE' + when "GEM_HOME", "GEM_PATH", "GEM_SPEC_CACHE" case v when nil, String target[k] = v when Array unless Gem::Deprecate.skip - warn <<-eowarn + 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 + EOWARN end target[k] = v.join File::PATH_SEPARATOR end @@ -430,8 +423,6 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} ## # The path where gems are to be installed. - #-- - # FIXME deprecate these once everything else has been done -ebh def self.dir paths.home @@ -446,6 +437,23 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} end ## + # 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. + + def self.target_rbconfig + @target_rbconfig || Gem::TargetRbConfig.for_running_ruby + end + + def self.set_target_rbconfig(rbconfig_path) + @target_rbconfig = Gem::TargetRbConfig.from_path(rbconfig_path) + Gem::Platform.local(refresh: true) + Gem.platforms << Gem::Platform.local unless Gem.platforms.include? Gem::Platform.local + @target_rbconfig + end + + ## # Quietly 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. @@ -454,7 +462,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # # World-writable directories will never be created. - def self.ensure_gem_subdirectories dir = Gem.dir, mode = nil + def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil) ensure_subdirectories(dir, mode, REPOSITORY_SUBDIRECTORIES) end @@ -467,15 +475,13 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # # World-writable directories will never be created. - def self.ensure_default_gem_subdirectories dir = Gem.dir, mode = nil + def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil) ensure_subdirectories(dir, mode, REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES) end - def self.ensure_subdirectories dir, mode, subdirs # :nodoc: + def self.ensure_subdirectories(dir, mode, subdirs) # :nodoc: old_umask = File.umask - File.umask old_umask | 002 - - require 'fileutils' + File.umask old_umask | 0o002 options = {} @@ -484,7 +490,13 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} subdirs.each do |name| subdir = File.join dir, name next if File.exist? subdir - FileUtils.mkdir_p subdir, options rescue nil + + require "fileutils" + + begin + FileUtils.mkdir_p subdir, **options + rescue SystemCallError + end end ensure File.umask old_umask @@ -495,7 +507,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # distinction as extensions cannot be shared between the two. def self.extension_api_version # :nodoc: - if 'no' == RbConfig::CONFIG['ENABLE_SHARED'] then + if target_rbconfig["ENABLE_SHARED"] == "no" "#{ruby_api_version}-static" else ruby_api_version @@ -514,28 +526,29 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Note that find_files will return all files even if they are from different # versions of the same gem. See also find_latest_files - def self.find_files(glob, check_load_path=true) + 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.map { |spec| + files.concat gem_specifications.flat_map {|spec| spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}") - }.flatten + } # $LOAD_PATH might contain duplicate entries or reference # the spec dirs directly, so we prune. files.uniq! if check_load_path - return files + files end - def self.find_files_from_load_path glob # :nodoc: - $LOAD_PATH.map { |load_path| - Dir["#{File.expand_path glob, load_path}#{Gem.suffix_pattern}"] - }.flatten.select { |file| File.file? file.untaint } + def self.find_files_from_load_path(glob) # :nodoc: + 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 ## @@ -550,83 +563,20 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Unlike find_files, find_latest_files will return only files from the # latest version of a gem. - def self.find_latest_files(glob, check_load_path=true) + 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).map { |spec| + files.concat Gem::Specification.latest_specs(true).flat_map {|spec| spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}") - }.flatten + } # $LOAD_PATH might contain duplicate entries or reference # the spec dirs directly, so we prune. files.uniq! if check_load_path - return files - end - - ## - # Finds the user's home directory. - #-- - # Some comments from the ruby-talk list regarding finding the home - # directory: - # - # I have HOME, USERPROFILE and HOMEDRIVE + HOMEPATH. Ruby seems - # to be depending on HOME in those code samples. I propose that - # it should fallback to USERPROFILE and HOMEDRIVE + HOMEPATH (at - # least on Win32). - #++ - #-- - # - # FIXME move to pathsupport - # - #++ - - def self.find_home - windows = File::ALT_SEPARATOR - if not windows or RUBY_VERSION >= '1.9' then - File.expand_path "~" - else - ['HOME', 'USERPROFILE'].each do |key| - return File.expand_path ENV[key] if ENV[key] - end - - if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then - File.expand_path "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" - end - end - rescue - if windows then - File.expand_path File.join(ENV['HOMEDRIVE'] || ENV['SystemDrive'], '/') - else - File.expand_path "/" - end - end - - private_class_method :find_home - - # FIXME deprecate these in 3.0 - - ## - # Zlib::GzipReader wrapper that unzips +data+. - - def self.gunzip(data) - Gem::Util.gunzip data - end - - ## - # Zlib::GzipWriter wrapper that zips +data+. - - def self.gzip(data) - Gem::Util.gzip data - end - - ## - # A Zlib::Inflate#inflate wrapper - - def self.inflate(data) - Gem::Util.inflate data + files end ## @@ -634,11 +584,11 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # # % irb # >> Gem.install "minitest" - # Fetching: minitest-3.0.1.gem (100%) + # Fetching: minitest-5.14.0.gem (100%) # => [#<Gem::Specification:0x1013b4528 @name="minitest", ...>] - def self.install name, version = Gem::Requirement.default, *options - require "rubygems/dependency_installer" + 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 @@ -649,14 +599,12 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # <tt>https://rubygems.org</tt>. def self.host - # TODO: move to utils @host ||= Gem::DEFAULT_HOST end ## Set the default RubyGems API host. - def self.host= host - # TODO: move to utils + def self.host=(host) @host = host end @@ -669,64 +617,91 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} return i if path.instance_variable_defined?(:@gem_prelude_index) end - index = $LOAD_PATH.index RbConfig::CONFIG['sitelibdir'] + index = $LOAD_PATH.index RbConfig::CONFIG["sitelibdir"] + + index || 0 + end + + ## + # The number of paths in the +$LOAD_PATH+ from activated gems. Used to + # prioritize +-I+ and <code>ENV['RUBYLIB']</code> entries during +require+. + + def self.activated_gem_paths + @activated_gem_paths ||= 0 + end + + ## + # Add a list of paths to the $LOAD_PATH at the proper place. + + def self.add_to_load_path(*paths) + @activated_gem_paths = activated_gem_paths + paths.size - index + # gem directories must come after -I and ENV['RUBYLIB'] + $LOAD_PATH.insert(Gem.load_path_insert_index, *paths) end @yaml_loaded = false + @use_psych = nil + + ## + # Returns true if the Psych YAML parser is enabled via configuration. + + def self.use_psych? + @use_psych || false + end ## # Loads YAML, preferring Psych def self.load_yaml return if @yaml_loaded - return unless defined?(gem) - test_syck = ENV['TEST_SYCK'] + @use_psych = ENV["RUBYGEMS_USE_PSYCH"] == "true" || + (defined?(@configuration) && @configuration && !@configuration[:use_psych].nil?) - # Only Ruby 1.8 and 1.9 have syck - test_syck = false unless /^1\./ =~ RUBY_VERSION + if @use_psych + require "psych" + require_relative "rubygems/psych_tree" + end - unless test_syck - begin - gem 'psych', '>= 2.0.0' - rescue Gem::LoadError - # It's OK if the user does not have the psych gem installed. We will - # attempt to require the stdlib version - end + require_relative "rubygems/yaml_serializer" + require_relative "rubygems/safe_yaml" - begin - # Try requiring the gem version *or* stdlib version of psych. - require 'psych' - rescue ::LoadError - # If we can't load psych, thats fine, go on. - else - # If 'yaml' has already been required, then we have to - # be sure to switch it over to the newly loaded psych. - if defined?(YAML::ENGINE) && YAML::ENGINE.yamler != "psych" - YAML::ENGINE.yamler = "psych" - end + @yaml_loaded = true + end - require 'rubygems/psych_additions' - require 'rubygems/psych_tree' - end - end + @safe_marshal_loaded = false + + def self.load_safe_marshal + return if @safe_marshal_loaded + + require_relative "rubygems/safe_marshal" + + @safe_marshal_loaded = true + end + + ## + # Load Bundler extensions to RubyGems, making sure to avoid redefinition + # warnings in platform constants + + def self.load_bundler_extensions(version) + return unless version <= Gem::Version.create("2.6.9") - require 'yaml' - require 'rubygems/safe_yaml' + previous_platforms = {} - # If we're supposed to be using syck, then we may have to force - # activate it via the YAML::ENGINE API. - if test_syck and defined?(YAML::ENGINE) - YAML::ENGINE.yamler = "syck" unless YAML::ENGINE.syck? + 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 - # Now that we're sure some kind of yaml library is loaded, pull - # in our hack to deal with Syck's DefaultKey ugliness. - require 'rubygems/syck_hack' + require "bundler/rubygems_ext" - @yaml_loaded = true + 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 ## @@ -855,9 +830,9 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} def self.prefix prefix = File.dirname RUBYGEMS_DIR - if prefix != File.expand_path(RbConfig::CONFIG['sitelibdir']) and - prefix != File.expand_path(RbConfig::CONFIG['libdir']) and - 'lib' == File.basename(RUBYGEMS_DIR) then + if prefix != File.expand_path(RbConfig::CONFIG["sitelibdir"]) && + prefix != File.expand_path(RbConfig::CONFIG["libdir"]) && + File.basename(RUBYGEMS_DIR) == "lib" prefix end end @@ -873,41 +848,57 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Safely read a file in binary mode on all platforms. def self.read_binary(path) - open path, 'rb+' do |f| - f.flock(File::LOCK_EX) - f.read - end - rescue *READ_BINARY_ERRORS - open path, 'rb' do |f| - f.read - end - rescue Errno::ENOLCK # NFS - if Thread.main != Thread.current - raise - else - open path, 'rb' do |f| - f.read - end - end + File.binread(path) end ## - # Safely write a file in binary mode on all platforms. + # Atomically write a file in binary mode on all platforms. + def self.write_binary(path, data) - open(path, 'wb') do |io| - begin - io.flock(File::LOCK_EX) - rescue *WRITE_BINARY_ERRORS - end - io.write data + Gem::AtomicFileWriter.open(path) do |file| + file.write(data) end - rescue Errno::ENOLCK # NFS - if Thread.main != Thread.current - raise - else - open(path, 'wb') do |io| - io.write data + end + + ## + # Open a file with given flags + + def self.open_file(path, flags, &block) + File.open(path, flags, &block) + end + + ## + # Open a file with given flags, and protect access with a file lock + + 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 + + ## + # Open a file with given flags, and protect access with flock + + def self.open_file_with_flock(path, &block) + # read-write mode is used rather than read-only in order to support NFS + 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 + # Try to get a lock without blocking. + # If we do, the file is locked. + # Otherwise, explain why we're waiting and get a lock, but block this time. + 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 @@ -915,11 +906,10 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # The path to the running Ruby interpreter. def self.ruby - if @ruby.nil? then - @ruby = File.join(RbConfig::CONFIG['bindir'], - "#{RbConfig::CONFIG['ruby_install_name']}#{RbConfig::CONFIG['EXEEXT']}") + if @ruby.nil? + @ruby = RbConfig.ruby - @ruby = "\"#{@ruby}\"" if @ruby =~ /\s/ + @ruby = "\"#{@ruby}\"" if /\s/.match?(@ruby) end @ruby @@ -929,13 +919,13 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Returns a String containing the API compatibility version of Ruby def self.ruby_api_version - @ruby_api_version ||= RbConfig::CONFIG['ruby_version'].dup + @ruby_api_version ||= target_rbconfig["ruby_version"].dup end 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'.freeze + req = ENV["GEM_REQUIREMENT_#{gem_name.upcase}"] || ">= 0" Gem::Requirement.create(req) end end @@ -944,12 +934,12 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} ## # Returns the latest release-version specification for the gem +name+. - def self.latest_spec_for name + 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.first + spec, = spec_tuples.last spec end @@ -958,16 +948,15 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Returns the latest release version of RubyGems. def self.latest_rubygems_version - latest_version_for('rubygems-update') or - raise "Can't find 'rubygems-update' in any repo. Check `gem source list`." + latest_version_for("rubygems-update") || + raise("Can't find 'rubygems-update' in any repo. Check `gem source list`.") end ## # Returns the version of the latest release-version of gem +name+ - def self.latest_version_for name - spec = latest_spec_for name - spec and spec.version + def self.latest_version_for(name) + latest_spec_for(name)&.version end ## @@ -977,10 +966,13 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} return @ruby_version if defined? @ruby_version version = RUBY_VERSION.dup - if defined?(RUBY_PATCHLEVEL) && RUBY_PATCHLEVEL != -1 then - version << ".#{RUBY_PATCHLEVEL}" - elsif defined?(RUBY_REVISION) then - version << ".dev.#{RUBY_REVISION}" + 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 @@ -1010,7 +1002,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # DOC: This comment is not documentation about the method itself, it's # more of a code comment about the implementation. - def self.sources= new_sources + def self.sources=(new_sources) if !new_sources @sources = nil else @@ -1022,21 +1014,48 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Glob pattern for require-able path suffixes. def self.suffix_pattern - @suffix_pattern ||= "{#{suffixes.join(',')}}" + @suffix_pattern ||= "{#{suffixes.join(",")}}" + end + + ## + # Regexp for require-able path suffixes. + + def self.suffix_regexp + @suffix_regexp ||= /#{Regexp.union(suffixes)}\z/ + end + + ## + # Glob pattern for require-able plugin suffixes. + + def self.plugin_suffix_pattern + @plugin_suffix_pattern ||= "_plugin#{suffix_pattern}" + end + + ## + # Regexp for require-able plugin suffixes. + + def self.plugin_suffix_regexp + @plugin_suffix_regexp ||= /_plugin#{suffix_regexp}\z/ end ## # Suffixes for require-able paths. def self.suffixes - @suffixes ||= ['', - '.rb', - *%w(DLEXT DLEXT2).map { |key| + @suffixes ||= ["", + ".rb", + *%w[DLEXT DLEXT2].map do |key| val = RbConfig::CONFIG[key] - next unless val and not val.empty? + next unless val && !val.empty? ".#{val}" - } - ].compact.uniq + end].compact.uniq + end + + ## + # Suffixes for dynamic library require-able paths. + + def self.dynamic_library_suffixes + @dynamic_library_suffixes ||= suffixes - [".rb"] end ## @@ -1050,7 +1069,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} elapsed = Time.now - now - ui.say "%2$*1$s: %3$3.3fs" % [-width, msg, elapsed] if display + ui.say format("%2$*1$s: %3$3.3fs", -width, msg, elapsed) if display value end @@ -1059,7 +1078,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Lazily loads DefaultUserInteraction and returns the default UI. def self.ui - require 'rubygems/user_interaction' + require_relative "rubygems/user_interaction" Gem::DefaultUserInteraction.ui end @@ -1072,43 +1091,44 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} paths.flatten! paths.compact! hash = { "GEM_HOME" => home, "GEM_PATH" => paths.empty? ? home : paths.join(File::PATH_SEPARATOR) } - hash.delete_if { |_, v| v.nil? } + hash.delete_if {|_, v| v.nil? } self.paths = hash end ## - # The home directory for the user. + # Is this a java platform? - def self.user_home - @user_home ||= find_home.untaint + def self.java_platform? + RUBY_PLATFORM == "java" end ## - # Is this a windows platform? + # Is this platform Solaris? - def self.win_platform? - if @@win_platform.nil? then - ruby_platform = RbConfig::CONFIG['host_os'] - @@win_platform = !!WIN_PATTERNS.find { |r| ruby_platform =~ r } - end + def self.solaris_platform? + RUBY_PLATFORM.include?("solaris") + end - @@win_platform + ## + # Is this platform FreeBSD + + def self.freebsd_platform? + RbConfig::CONFIG["host_os"].to_s.include?("bsd") end ## # Load +plugins+ as Ruby files - def self.load_plugin_files plugins # :nodoc: + def self.load_plugin_files(plugins) # :nodoc: plugins.each do |plugin| - # Skip older versions of the GemCutter plugin: Its commands are in # RubyGems proper now. - next if plugin =~ /gemcutter-0\.[0-3]/ + next if /gemcutter-0\.[0-3]/.match?(plugin) begin load plugin - rescue ::Exception => e + rescue ScriptError, StandardError => e details = "#{plugin.inspect}: #{e.message} (#{e.class})" warn "Error loading RubyGems plugin #{details}" end @@ -1116,15 +1136,11 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} end ## - # Find the 'rubygems_plugin' files in the latest installed gems and load - # them + # Find rubygems plugin files in the standard location and load them def self.load_plugins - # Remove this env var by at least 3.0 - if ENV['RUBYGEMS_LOAD_ALL_PLUGINS'] - load_plugin_files find_files('rubygems_plugin', false) - else - load_plugin_files find_latest_files('rubygems_plugin', false) + Gem.path.each do |gem_path| + load_plugin_files Gem::Util.glob_files_in_dir("*#{Gem.plugin_suffix_pattern}", plugindir(gem_path)) end end @@ -1132,18 +1148,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Find all 'rubygems_plugin' files in $LOAD_PATH and load them def self.load_env_plugins - path = "rubygems_plugin" - - files = [] - $LOAD_PATH.each do |load_path| - globbed = Dir["#{File.expand_path path, load_path}#{Gem.suffix_pattern}"] - - globbed.each do |load_path_file| - files << load_path_file if File.file?(load_path_file.untaint) - end - end - - load_plugin_files files + load_plugin_files find_files_from_load_path("rubygems_plugin") end ## @@ -1166,17 +1171,17 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # execution of arbitrary code when used from directories outside your # control. - def self.use_gemdeps path = nil + def self.use_gemdeps(path = nil) raise_exception = path - path ||= ENV['RUBYGEMS_GEMDEPS'] + path ||= ENV["RUBYGEMS_GEMDEPS"] return unless path path = path.dup - if path == "-" then + if path == "-" Gem::Util.traverse_parents Dir.pwd do |directory| - dep_file = GEM_DEP_FILES.find { |f| File.file?(f) } + dep_file = GEM_DEP_FILES.find {|f| File.file?(f) } next unless dep_file @@ -1185,57 +1190,83 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} end end - path.untaint - - unless File.file? path then + unless File.file? path return unless raise_exception raise ArgumentError, "Unable to find gem dependencies file at #{path}" end - if USE_BUNDLER_FOR_GEMDEPS - - ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path) - require 'rubygems/user_interaction' + ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path) + require_relative "rubygems/user_interaction" + require "bundler" + begin Gem::DefaultUserInteraction.use_ui(ui) do - require "bundler" - @gemdeps = Bundler.setup - Bundler.ui = nil - @gemdeps.requested_specs.map(&:to_spec).sort_by(&:name) + 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 - else + ## + # 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: + # https://reproducible-builds.org/specs/source-date-epoch/ - rs = Gem::RequestSet.new - @gemdeps = rs.load_gemdeps path + def self.source_date_epoch_string + specified_epoch = ENV["SOURCE_DATE_EPOCH"] - rs.resolve_current.map do |s| - s.full_spec.tap(&:activate) - end + # If it's empty or just whitespace, treat it like it wasn't set at all. + specified_epoch = nil if !specified_epoch.nil? && specified_epoch.strip.empty? - end - rescue => e - case e - when Gem::LoadError, Gem::UnsatisfiableDependencyError, (defined?(Bundler::GemNotFound) ? Bundler::GemNotFound : Gem::LoadError) - warn e.message - warn "You may need to `gem install -g` to install missing gems" - warn "" - else - raise - end + epoch = specified_epoch || DEFAULT_SOURCE_DATE_EPOCH.to_s + + epoch.strip end - class << self - ## - # TODO remove with RubyGems 3.0 + ## + # Returns the value of Gem.source_date_epoch_string, as a Time object. + # + # This is used throughout RubyGems for enabling reproducible builds. - alias detect_gemdeps use_gemdeps # :nodoc: + def self.source_date_epoch + Time.at(source_date_epoch_string.to_i).utc.freeze end # FIX: Almost everywhere else we use the `def self.` way of defining class # methods, and then we switch over to `class << self` here. Pick one or the # other. class << self + ## + # 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. + + attr_accessor :disable_system_update_message + + ## + # 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`. + + attr_accessor :discover_gems_on_require ## # Hash of loaded Gem::Specification keyed by name @@ -1261,41 +1292,47 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # def register_default_spec(spec) - new_format = Gem.default_gems_use_full_paths? || spec.require_paths.any? {|path| spec.files.any? {|f| f.start_with? path } } + 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 = spec.require_paths.map {|f| f + "/"}.join("|") + prefix_group = extended_require_paths.join("|") prefix_pattern = /^(#{prefix_group})/ end - suffix_pattern = /#{Regexp.union(Gem.suffixes)}\z/ + native_extension_suffixes = Gem.dynamic_library_suffixes.reject(&:empty?) spec.files.each do |file| if new_format file = file.sub(prefix_pattern, "") - next unless $~ + unless $~ + # Also register native extension files (e.g. date_core.bundle) + # that are listed without require path prefix in the gemspec + next if file.include?("/") + next unless file.end_with?(*native_extension_suffixes) + end end + spec.activate if already_loaded?(file) + @path_to_default_spec_map[file] = spec - @path_to_default_spec_map[file.sub(suffix_pattern, "")] = spec + @path_to_default_spec_map[file.sub(suffix_regexp, "")] = spec end end ## # Find a Gem::Specification of default gem from +path+ - def find_unresolved_default_spec(path) + def find_default_spec(path) @path_to_default_spec_map[path] end ## - # Remove needless Gem::Specification of default gem from - # unresolved default gem list + # Find an unresolved Gem::Specification of default gem from +path+ - def remove_unresolved_default_spec(spec) - spec.files.each do |file| - @path_to_default_spec_map.delete(file) - end + 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 ## @@ -1349,64 +1386,89 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # work attr_reader :pre_uninstall_hooks + + private + + def already_loaded?(file) + $LOADED_FEATURES.any? do |feature_path| + feature_path.end_with?(file) && default_gem_load_paths.any? {|load_path_entry| feature_path == "#{load_path_entry}/#{file}" } + end + end + + def default_gem_load_paths + @default_gem_load_paths ||= $LOAD_PATH[load_path_insert_index..-1].map do |lp| + expanded = File.expand_path(lp) + next expanded unless File.exist?(expanded) + + File.realpath(expanded) + end + end end ## # Location of Marshal quick gemspecs on remote repositories - MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/" - - autoload :BundlerVersionFinder, 'rubygems/bundler_version_finder' - autoload :ConfigFile, 'rubygems/config_file' - autoload :Dependency, 'rubygems/dependency' - autoload :DependencyList, 'rubygems/dependency_list' - autoload :DependencyResolver, 'rubygems/resolver' - autoload :Installer, 'rubygems/installer' - autoload :Licenses, 'rubygems/util/licenses' - autoload :PathSupport, 'rubygems/path_support' - autoload :Platform, 'rubygems/platform' - autoload :RequestSet, 'rubygems/request_set' - autoload :Requirement, 'rubygems/requirement' - autoload :Resolver, 'rubygems/resolver' - autoload :Source, 'rubygems/source' - autoload :SourceList, 'rubygems/source_list' - autoload :SpecFetcher, 'rubygems/spec_fetcher' - autoload :Specification, 'rubygems/specification' - autoload :Util, 'rubygems/util' - autoload :Version, 'rubygems/version' - - require "rubygems/specification" + MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/".freeze + + autoload :ConfigFile, File.expand_path("rubygems/config_file", __dir__) + autoload :CIDetector, File.expand_path("rubygems/ci_detector", __dir__) + autoload :Dependency, File.expand_path("rubygems/dependency", __dir__) + autoload :DependencyList, File.expand_path("rubygems/dependency_list", __dir__) + autoload :Installer, File.expand_path("rubygems/installer", __dir__) + autoload :Licenses, File.expand_path("rubygems/util/licenses", __dir__) + autoload :NameTuple, File.expand_path("rubygems/name_tuple", __dir__) + autoload :PathSupport, File.expand_path("rubygems/path_support", __dir__) + autoload :RequestSet, File.expand_path("rubygems/request_set", __dir__) + autoload :Requirement, File.expand_path("rubygems/requirement", __dir__) + autoload :Resolver, File.expand_path("rubygems/resolver", __dir__) + autoload :Source, File.expand_path("rubygems/source", __dir__) + autoload :SourceList, File.expand_path("rubygems/source_list", __dir__) + autoload :SpecFetcher, File.expand_path("rubygems/spec_fetcher", __dir__) + autoload :SpecificationPolicy, File.expand_path("rubygems/specification_policy", __dir__) + autoload :Util, File.expand_path("rubygems/util", __dir__) + autoload :Version, File.expand_path("rubygems/version", __dir__) end -require 'rubygems/exceptions' +require_relative "rubygems/exceptions" +require_relative "rubygems/specification" # REFACTOR: This should be pulled out into some kind of hacks file. -gem_preluded = Gem::GEM_PRELUDE_SUCKAGE and defined? Gem -unless gem_preluded then # TODO: remove guard after 1.9.2 dropped - begin - ## - # Defaults the operating system (or packager) wants to provide for RubyGems. - - require 'rubygems/defaults/operating_system' - rescue LoadError - end - - if defined?(RUBY_ENGINE) then - begin - ## - # Defaults the Ruby implementation wants to provide for RubyGems +begin + # Defaults the operating system (or packager) wants to provide for RubyGems. + require "rubygems/defaults/operating_system" +rescue LoadError + # Ignored +rescue StandardError => e + path = e.backtrace_locations.reverse.find {|l| l.path.end_with?("rubygems/defaults/operating_system.rb") }.path + msg = "#{e.message}\n" \ + "Loading the #{path} file caused an error. " \ + "This file is owned by your OS, not by rubygems upstream. " \ + "Please find out which OS package this file belongs to and follow the guidelines from your OS to report " \ + "the problem and ask for help." + raise e.class, msg +end - require "rubygems/defaults/#{RUBY_ENGINE}" - rescue LoadError - end - end +begin + # Defaults the Ruby implementation wants to provide for RubyGems + require "rubygems/defaults/#{RUBY_ENGINE}" +rescue LoadError end ## # Loads the default specs. Gem::Specification.load_defaults -require 'rubygems/core_ext/kernel_gem' -require 'rubygems/core_ext/kernel_require' +require_relative "rubygems/core_ext/kernel_gem" + +path = File.join(__dir__, "rubygems/core_ext/kernel_require.rb") +# When https://bugs.ruby-lang.org/issues/17259 is available, there is no need to override Kernel#warn +if RUBY_ENGINE == "truffleruby" || + RUBY_ENGINE == "ruby" + file = "<internal:#{path}>" +else + require_relative "rubygems/core_ext/kernel_warn" + file = path +end +eval File.read(path), nil, file -Gem.use_gemdeps +require ENV["BUNDLER_SETUP"] if ENV["BUNDLER_SETUP"] && !defined?(Bundler) |