rubygems-update 3.5.3 → 3.7.1

data/bundler/lib/bundler/source/git.rb

@@ -32,6 +32,20 @@ module Bundler
         @local      = false
       end
 
+      def remote!
+        return if @allow_remote
+
+        @local_specs = nil
+        @allow_remote = true
+      end
+
+      def cached!
+        return if @allow_cached
+
+        @local_specs = nil
+        @allow_cached = true
+      end
+
       def self.from_lock(options)
         new(options.merge("uri" => options.delete("remote")))
       end
@@ -56,13 +70,13 @@ module Bundler
       end
 
       def hash
-        [self.class, uri, ref, branch, name, version, glob, submodules].hash
+        [self.class, uri, ref, branch, name, glob, submodules].hash
       end
 
       def eql?(other)
         other.is_a?(Git) && uri == other.uri && ref == other.ref &&
           branch == other.branch && name == other.name &&
-          version == other.version && glob == other.glob &&
+          glob == other.glob &&
           submodules == other.submodules
       end
 
@@ -88,7 +102,7 @@ module Bundler
       end
 
       def identifier
-        uri_with_specifiers([humanized_ref, cached_revision, glob_for_display])
+        uri_with_specifiers([humanized_ref, locked_revision, glob_for_display])
       end
 
       def uri_with_specifiers(specifiers)
@@ -150,7 +164,8 @@ module Bundler
             "does not exist. Run `bundle config unset local.#{override_for(original_path)}` to remove the local override"
         end
 
-        set_local!(path)
+        @local = true
+        set_paths!(path)
 
         # Create a new git proxy without the cached revision
         # so the Gemfile.lock always picks up the new revision.
@@ -161,10 +176,10 @@ module Bundler
             "#{current_branch} but Gemfile specifies #{branch}"
         end
 
-        changed = cached_revision && cached_revision != revision
+        changed = locked_revision && locked_revision != revision
 
-        if !Bundler.settings[:disable_local_revision_check] && changed && !@unlocked && !git_proxy.contains?(cached_revision)
-          raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(cached_revision)} " \
+        if !Bundler.settings[:disable_local_revision_check] && changed && !@unlocked && !git_proxy.contains?(locked_revision)
+          raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(locked_revision)} " \
             "but the current branch in your local override for #{name} does not contain such commit. " \
             "Please make sure your branch is up to date."
         end
@@ -173,13 +188,11 @@ module Bundler
       end
 
       def specs(*)
-        set_local!(app_cache_path) if has_app_cache? && !local?
+        set_cache_path!(app_cache_path) if use_app_cache?
 
         if requires_checkout? && !@copied
-          fetch
-          git_proxy.copy_to(install_path, submodules)
-          serialize_gemspecs_in(install_path)
-          @copied = true
+          fetch unless use_app_cache?
+          checkout
         end
 
         local_specs
@@ -192,27 +205,25 @@ module Bundler
         print_using_message "Using #{version_message(spec, options[:previous_spec])} from #{self}"
 
         if (requires_checkout? && !@copied) || force
-          Bundler.ui.debug "  * Checking out revision: #{ref}"
-          git_proxy.copy_to(install_path, submodules)
-          serialize_gemspecs_in(install_path)
-          @copied = true
+          checkout
         end
 
-        generate_bin_options = { disable_extensions: !Bundler.rubygems.spec_missing_extensions?(spec), build_args: options[:build_args] }
+        generate_bin_options = { disable_extensions: !spec.missing_extensions?, build_args: options[:build_args] }
         generate_bin(spec, generate_bin_options)
 
         requires_checkout? ? spec.post_install_message : nil
       end
 
+      def migrate_cache(custom_path = nil, local: false)
+        if local
+          cache_to(custom_path, try_migrate: false)
+        else
+          cache_to(custom_path, try_migrate: true)
+        end
+      end
+
       def cache(spec, custom_path = nil)
-        app_cache_path = app_cache_path(custom_path)
-        return unless Bundler.feature_flag.cache_all?
-        return if path == app_cache_path
-        cached!
-        FileUtils.rm_rf(app_cache_path)
-        git_proxy.checkout if requires_checkout?
-        git_proxy.copy_to(app_cache_path, @submodules)
-        serialize_gemspecs_in(app_cache_path)
+        cache_to(custom_path, try_migrate: false)
       end
 
       def load_spec_files
@@ -235,7 +246,7 @@ module Bundler
       end
 
       def app_cache_dirname
-        "#{base_name}-#{shortref_for_path(cached_revision || revision)}"
+        "#{base_name}-#{shortref_for_path(locked_revision || revision)}"
       end
 
       def revision
@@ -256,6 +267,43 @@ module Bundler
 
       private
 
+      def cache_to(custom_path, try_migrate: false)
+        return unless Bundler.feature_flag.cache_all?
+
+        app_cache_path = app_cache_path(custom_path)
+
+        migrate = try_migrate ? bare_repo?(app_cache_path) : false
+
+        set_cache_path!(nil) if migrate
+
+        return if cache_path == app_cache_path
+
+        cached!
+        FileUtils.rm_rf(app_cache_path)
+        git_proxy.checkout if migrate || requires_checkout?
+        git_proxy.copy_to(app_cache_path, @submodules)
+        serialize_gemspecs_in(app_cache_path)
+      end
+
+      def checkout
+        Bundler.ui.debug "  * Checking out revision: #{ref}"
+        if use_app_cache? && !bare_repo?(app_cache_path)
+          SharedHelpers.filesystem_access(install_path.dirname) do |p|
+            FileUtils.mkdir_p(p)
+          end
+          FileUtils.cp_r("#{app_cache_path}/.", install_path)
+        else
+          if use_app_cache? && bare_repo?(app_cache_path)
+            Bundler.ui.warn "Installing from cache in old \"bare repository\" format for compatibility. " \
+                            "Please run `bundle cache` and commit the updated cache to migrate to the new format and get rid of this warning."
+          end
+
+          git_proxy.copy_to(install_path, submodules)
+        end
+        serialize_gemspecs_in(install_path)
+        @copied = true
+      end
+
       def humanized_ref
         if local?
           path
@@ -278,28 +326,45 @@ module Bundler
           # The gemspecs we cache should already be evaluated.
           spec = Bundler.load_gemspec(spec_path)
           next unless spec
-          Bundler.rubygems.set_installed_by_version(spec)
+          spec.installed_by_version = Gem::VERSION
           Bundler.rubygems.validate(spec)
           File.open(spec_path, "wb") {|file| file.write(spec.to_ruby) }
         end
       end
 
-      def set_local!(path)
-        @local       = true
-        @local_specs = @git_proxy = nil
-        @cache_path  = @install_path = path
+      def set_paths!(path)
+        set_cache_path!(path)
+        set_install_path!(path)
+      end
+
+      def set_cache_path!(path)
+        @git_proxy = nil
+        @cache_path = path
+      end
+
+      def set_install_path!(path)
+        @local_specs = nil
+        @install_path = path
       end
 
       def has_app_cache?
-        cached_revision && super
+        locked_revision && super
+      end
+
+      def use_app_cache?
+        has_app_cache? && !local?
       end
 
       def requires_checkout?
-        allow_git_ops? && !local? && !cached_revision_checked_out?
+        allow_git_ops? && !local? && !locked_revision_checked_out?
+      end
+
+      def locked_revision_checked_out?
+        locked_revision && locked_revision == revision && installed?
       end
 
-      def cached_revision_checked_out?
-        cached_revision && cached_revision == revision && install_path.exist?
+      def installed?
+        git_proxy.installed_to?(install_path)
       end
 
       def base_name
@@ -326,7 +391,7 @@ module Bundler
         if %r{^\w+://(\w+@)?}.match?(uri)
           # Downcase the domain component of the URI
           # and strip off a trailing slash, if one is present
-          input = Bundler::URI.parse(uri).normalize.to_s.sub(%r{/$}, "")
+          input = Gem::URI.parse(uri).normalize.to_s.sub(%r{/$}, "")
         else
           # If there is no URI scheme, assume it is an ssh/git URI
           input = uri
@@ -336,7 +401,7 @@ module Bundler
         Bundler::Digest.sha1(input)
       end
 
-      def cached_revision
+      def locked_revision
         options["revision"]
       end
 
@@ -345,7 +410,7 @@ module Bundler
       end
 
       def git_proxy
-        @git_proxy ||= GitProxy.new(cache_path, uri, options, cached_revision, self)
+        @git_proxy ||= GitProxy.new(cache_path, uri, options, locked_revision, self)
       end
 
       def fetch
@@ -359,9 +424,12 @@ module Bundler
       def validate_spec(_spec); end
 
       def load_gemspec(file)
-        stub = Gem::StubSpecification.gemspec_stub(file, install_path.parent, install_path.parent)
-        stub.full_gem_path = Pathname.new(file).dirname.expand_path(root).to_s
-        StubSpecification.from_stub(stub)
+        dirname = Pathname.new(file).dirname
+        SharedHelpers.chdir(dirname.to_s) do
+          stub = Gem::StubSpecification.gemspec_stub(file, install_path.parent, install_path.parent)
+          stub.full_gem_path = dirname.expand_path(root).to_s
+          StubSpecification.from_stub(stub)
+        end
       end
 
       def git_scope
@@ -375,6 +443,10 @@ module Bundler
       def override_for(path)
         Bundler.settings.local_overrides.key(path)
       end
+
+      def bare_repo?(path)
+        File.exist?(path.join("objects")) && File.exist?(path.join("HEAD"))
+      end
     end
   end
 end

data/bundler/lib/bundler/source/metadata.rb

@@ -11,6 +11,8 @@ module Bundler
           end
 
           if local_spec = Gem.loaded_specs["bundler"]
+            raise CorruptBundlerInstallError.new(local_spec) if local_spec.version.to_s != Bundler::VERSION
+
             idx << local_spec
           else
             idx << Gem::Specification.new do |s|
@@ -22,9 +24,8 @@ module Bundler
               s.bindir   = "exe"
               s.homepage = "https://bundler.io"
               s.summary  = "The best way to manage your application's dependencies"
-              s.executables = %w[bundle]
-              # can't point to the actual gemspec or else the require paths will be wrong
-              s.loaded_from = __dir__
+              s.executables = %w[bundle bundler]
+              s.loaded_from = SharedHelpers.gemspec_path
             end
           end
 

data/bundler/lib/bundler/source/path.rb

@@ -18,9 +18,6 @@ module Bundler
         @options = options.dup
         @glob = options["glob"] || DEFAULT_GLOB
 
-        @allow_cached = false
-        @allow_remote = false
-
         @root_path = options["root_path"] || root
 
         if options["path"]
@@ -41,16 +38,6 @@ module Bundler
         @original_path = @path
       end
 
-      def remote!
-        @local_specs = nil
-        @allow_remote = true
-      end
-
-      def cached!
-        @local_specs = nil
-        @allow_cached = true
-      end
-
       def self.from_lock(options)
         new(options.merge("path" => options.delete("remote")))
       end
@@ -66,13 +53,15 @@ module Bundler
         "source at `#{@path}`"
       end
 
+      alias_method :to_gemfile, :path
+
       def hash
         [self.class, expanded_path, version].hash
       end
 
       def eql?(other)
-        return unless other.class == self.class
-        expanded_original_path == other.expanded_original_path &&
+        [Gemspec, Path].include?(other.class) &&
+          expanded_original_path == other.expanded_original_path &&
           version == other.version
       end
 
@@ -161,7 +150,7 @@ module Bundler
 
       def load_gemspec(file)
         return unless spec = Bundler.load_gemspec(file)
-        Bundler.rubygems.set_installed_by_version(spec)
+        spec.installed_by_version = Gem::VERSION
         spec
       end
 
@@ -178,6 +167,13 @@ module Bundler
             next unless spec = load_gemspec(file)
             spec.source = self
 
+            # The ignore attribute is for ignoring installed gems that don't
+            # have extensions correctly compiled for activation. In the case of
+            # path sources, there's a single version of each gem in the path
+            # source available to Bundler, so we always certainly want to
+            # consider that for activation and never makes sense to ignore it.
+            spec.ignored = false
+
             # Validation causes extension_dir to be calculated, which depends
             # on #source, so we validate here instead of load_gemspec
             validate_spec(spec)
@@ -225,7 +221,7 @@ module Bundler
 
         # Some gem authors put absolute paths in their gemspec
         # and we have to save them from themselves
-        spec.files = spec.files.map do |path|
+        spec.files = spec.files.filter_map do |path|
           next path unless /\A#{Pathname::SEPARATOR_PAT}/o.match?(path)
           next if File.directory?(path)
           begin
@@ -233,7 +229,7 @@ module Bundler
           rescue ArgumentError
             path
           end
-        end.compact
+        end
 
         installer = Path::Installer.new(
           spec,

data/bundler/lib/bundler/source/rubygems/remote.rb

@@ -16,6 +16,9 @@ module Bundler
           @anonymized_uri = remove_auth(@uri).freeze
         end
 
+        MAX_CACHE_SLUG_HOST_SIZE = 255 - 1 - 32 # 255 minus dot minus MD5 length
+        private_constant :MAX_CACHE_SLUG_HOST_SIZE
+
         # @return [String] A slug suitable for use as a cache key for this
         #         remote.
         #
@@ -28,10 +31,15 @@ module Bundler
             host = cache_uri.to_s.start_with?("file://") ? nil : cache_uri.host
 
             uri_parts = [host, cache_uri.user, cache_uri.port, cache_uri.path]
-            uri_digest = SharedHelpers.digest(:MD5).hexdigest(uri_parts.compact.join("."))
+            uri_parts.compact!
+            uri_digest = SharedHelpers.digest(:MD5).hexdigest(uri_parts.join("."))
+
+            uri_parts.pop
+            host_parts = uri_parts.join(".")
+            return uri_digest if host_parts.empty?
 
-            uri_parts[-1] = uri_digest
-            uri_parts.compact.join(".")
+            shortened_host_parts = host_parts[0...MAX_CACHE_SLUG_HOST_SIZE]
+            [shortened_host_parts, uri_digest].join(".")
           end
         end
 
@@ -48,7 +56,7 @@ module Bundler
           end
 
           uri
-        rescue Bundler::URI::InvalidComponentError
+        rescue Gem::URI::InvalidComponentError
           error_message = "Please CGI escape your usernames and passwords before " \
                           "setting them for authentication."
           raise HTTPError.new(error_message)

data/bundler/lib/bundler/source/rubygems.rb

@@ -10,7 +10,7 @@ module Bundler
       # Ask for X gems per API request
       API_REQUEST_SIZE = 50
 
-      attr_reader :remotes
+      attr_accessor :remotes
 
       def initialize(options = {})
         @options = options
@@ -19,15 +19,22 @@ module Bundler
         @allow_remote = false
         @allow_cached = false
         @allow_local = options["allow_local"] || false
+        @prefer_local = false
         @checksum_store = Checksum::Store.new
 
         Array(options["remotes"]).reverse_each {|r| add_remote(r) }
+
+        @lockfile_remotes = @remotes if options["from_lockfile"]
       end
 
       def caches
         @caches ||= [cache_path, *Bundler.rubygems.gem_cache]
       end
 
+      def prefer_local!
+        @prefer_local = true
+      end
+
       def local_only!
         @specs = nil
         @allow_local = true
@@ -35,6 +42,10 @@ module Bundler
         @allow_remote = false
       end
 
+      def local_only?
+        @allow_local && !@allow_remote
+      end
+
       def local!
         return if @allow_local
 
@@ -50,10 +61,11 @@ module Bundler
       end
 
       def cached!
+        return unless File.exist?(cache_path)
+
         return if @allow_cached
 
         @specs = nil
-        @allow_local = true
         @allow_cached = true
       end
 
@@ -90,13 +102,13 @@ module Bundler
 
       def self.from_lock(options)
         options["remotes"] = Array(options.delete("remote")).reverse
-        new(options)
+        new(options.merge("from_lockfile" => true))
       end
 
       def to_lock
         out = String.new("GEM\n")
-        remotes.reverse_each do |remote|
-          out << "  remote: #{suppress_configured_credentials remote}\n"
+        lockfile_remotes.reverse_each do |remote|
+          out << "  remote: #{remote}\n"
         end
         out << "  specs:\n"
       end
@@ -133,22 +145,25 @@ module Bundler
           # sources, and large_idx.merge! small_idx is way faster than
           # small_idx.merge! large_idx.
           index = @allow_remote ? remote_specs.dup : Index.new
-          index.merge!(cached_specs) if @allow_cached || @allow_remote
+          index.merge!(cached_specs) if @allow_cached
           index.merge!(installed_specs) if @allow_local
+
+          if @allow_local
+            if @prefer_local
+              index.merge!(default_specs)
+            else
+              # complete with default specs, only if not already available in the
+              # index through remote, cached, or installed specs
+              index.use(default_specs)
+            end
+          end
+
           index
         end
       end
 
       def install(spec, options = {})
-        force = options[:force]
-        ensure_builtin_gems_cached = options[:ensure_builtin_gems_cached]
-
-        if ensure_builtin_gems_cached && spec.default_gem? && !cached_path(spec)
-          cached_built_in_gem(spec) unless spec.remote
-          force = true
-        end
-
-        if installed?(spec) && !force
+        if (spec.default_gem? && !cached_built_in_gem(spec, local: options[:local])) || (installed?(spec) && !options[:force])
           print_using_message "Using #{version_message(spec, options[:previous_spec])}"
           return nil # no post-install message
         end
@@ -206,6 +221,7 @@ module Bundler
 
         spec.full_gem_path = installed_spec.full_gem_path
         spec.loaded_from = installed_spec.loaded_from
+        spec.base_dir = installed_spec.base_dir
 
         spec.post_install_message
       end
@@ -221,12 +237,13 @@ module Bundler
         raise InstallError, e.message
       end
 
-      def cached_built_in_gem(spec)
-        cached_path = cached_path(spec)
-        if cached_path.nil?
+      def cached_built_in_gem(spec, local: false)
+        cached_path = cached_gem(spec)
+        if cached_path.nil? && !local
           remote_spec = remote_specs.search(spec).first
           if remote_spec
             cached_path = fetch_gem(remote_spec)
+            spec.remote = remote_spec.remote
           else
             Bundler.ui.warn "#{spec.full_name} is built in to Ruby, and can't be cached because your Gemfile doesn't have any sources that contain it."
           end
@@ -312,11 +329,7 @@ module Bundler
       end
 
       def credless_remotes
-        if Bundler.settings[:allow_deployment_source_credential_changes]
-          remotes.map(&method(:remove_auth))
-        else
-          remotes.map(&method(:suppress_configured_credentials))
-        end
+        remotes.map(&method(:remove_auth))
       end
 
       def remotes_for_spec(spec)
@@ -327,14 +340,6 @@ module Bundler
       end
 
       def cached_gem(spec)
-        if spec.default_gem?
-          cached_built_in_gem(spec)
-        else
-          cached_path(spec)
-        end
-      end
-
-      def cached_path(spec)
         global_cache_path = download_cache_path(spec)
         caches << global_cache_path if global_cache_path
 
@@ -349,21 +354,12 @@ module Bundler
       def normalize_uri(uri)
         uri = URINormalizer.normalize_suffix(uri.to_s)
         require_relative "../vendored_uri"
-        uri = Bundler::URI(uri)
+        uri = Gem::URI(uri)
         raise ArgumentError, "The source must be an absolute URI. For example:\n" \
-          "source 'https://rubygems.org'" if !uri.absolute? || (uri.is_a?(Bundler::URI::HTTP) && uri.host.nil?)
+          "source 'https://rubygems.org'" if !uri.absolute? || (uri.is_a?(Gem::URI::HTTP) && uri.host.nil?)
         uri
       end
 
-      def suppress_configured_credentials(remote)
-        remote_nouser = remove_auth(remote)
-        if remote.userinfo && remote.userinfo == Bundler.settings[remote_nouser]
-          remote_nouser
-        else
-          remote
-        end
-      end
-
       def remove_auth(remote)
         if remote.user || remote.password
           remote.dup.tap {|uri| uri.user = uri.password = nil }.to_s
@@ -374,12 +370,18 @@ module Bundler
 
       def installed_specs
         @installed_specs ||= Index.build do |idx|
-          Bundler.rubygems.all_specs.reverse_each do |spec|
+          Bundler.rubygems.installed_specs.reverse_each do |spec|
+            spec.source = self
+            next if spec.ignored?
+            idx << spec
+          end
+        end
+      end
+
+      def default_specs
+        @default_specs ||= Index.build do |idx|
+          Bundler.rubygems.default_specs.each do |spec|
             spec.source = self
-            if Bundler.rubygems.spec_missing_extensions?(spec, false)
-              Bundler.ui.debug "Source #{self} is ignoring #{spec} because it is missing extensions"
-              next
-            end
             idx << spec
           end
         end
@@ -452,7 +454,7 @@ module Bundler
       end
 
       def installed?(spec)
-        installed_specs[spec].any? && !spec.deleted_gem?
+        installed_specs[spec].any? && !spec.installation_missing?
       end
 
       def rubygems_dir
@@ -469,6 +471,10 @@ module Bundler
 
       private
 
+      def lockfile_remotes
+        @lockfile_remotes || credless_remotes
+      end
+
       # Checks if the requested spec exists in the global cache. If it does,
       # we copy it to the download path, and if it does not, we download it.
       #

data/bundler/lib/bundler/source.rb

@@ -35,6 +35,8 @@ module Bundler
       spec.source == self
     end
 
+    def prefer_local!; end
+
     def local!; end
 
     def local_only!; end