rubygems-update 3.5.3 → 3.7.1

data/bundler/lib/bundler/compact_index_client/cache.rb

@@ -1,120 +1,95 @@
 # frozen_string_literal: true
 
-require_relative "gem_parser"
+require "rubygems/resolver/api_set/gem_parser"
 
 module Bundler
   class CompactIndexClient
     class Cache
       attr_reader :directory
 
-      def initialize(directory)
+      def initialize(directory, fetcher = nil)
         @directory = Pathname.new(directory).expand_path
-        info_roots.each {|dir| mkdir(dir) }
-        mkdir(info_etag_root)
+        @updater = Updater.new(fetcher) if fetcher
+        @mutex = Thread::Mutex.new
+        @endpoints = Set.new
+
+        @info_root = mkdir("info")
+        @special_characters_info_root = mkdir("info-special-characters")
+        @info_etag_root = mkdir("info-etags")
       end
 
       def names
-        lines(names_path)
+        fetch("names", names_path, names_etag_path)
       end
 
-      def names_path
-        directory.join("names")
+      def versions
+        fetch("versions", versions_path, versions_etag_path)
       end
 
-      def names_etag_path
-        directory.join("names.etag")
-      end
+      def info(name, remote_checksum = nil)
+        path = info_path(name)
 
-      def versions
-        versions_by_name = Hash.new {|hash, key| hash[key] = [] }
-        info_checksums_by_name = {}
-
-        lines(versions_path).each do |line|
-          name, versions_string, info_checksum = line.split(" ", 3)
-          info_checksums_by_name[name] = info_checksum || ""
-          versions_string.split(",") do |version|
-            delete = version.delete_prefix!("-")
-            version = version.split("-", 2).unshift(name)
-            if delete
-              versions_by_name[name].delete(version)
-            else
-              versions_by_name[name] << version
-            end
-          end
+        if remote_checksum && remote_checksum != SharedHelpers.checksum_for_file(path, :MD5)
+          fetch("info/#{name}", path, info_etag_path(name))
+        else
+          Bundler::CompactIndexClient.debug { "update skipped info/#{name} (#{remote_checksum ? "versions index checksum is nil" : "versions index checksum matches local"})" }
+          read(path)
         end
-
-        [versions_by_name, info_checksums_by_name]
-      end
-
-      def versions_path
-        directory.join("versions")
       end
 
-      def versions_etag_path
-        directory.join("versions.etag")
+      def reset!
+        @mutex.synchronize { @endpoints.clear }
       end
 
-      def checksums
-        checksums = {}
-
-        lines(versions_path).each do |line|
-          name, _, checksum = line.split(" ", 3)
-          checksums[name] = checksum
-        end
-
-        checksums
-      end
+      private
 
-      def dependencies(name)
-        lines(info_path(name)).map do |line|
-          parse_gem(line)
-        end
-      end
+      def names_path = directory.join("names")
+      def names_etag_path = directory.join("names.etag")
+      def versions_path = directory.join("versions")
+      def versions_etag_path = directory.join("versions.etag")
 
       def info_path(name)
         name = name.to_s
+        # TODO: converge this into the info_root by hashing all filenames like info_etag_path
         if /[^a-z0-9_-]/.match?(name)
           name += "-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}"
-          info_roots.last.join(name)
+          @special_characters_info_root.join(name)
         else
-          info_roots.first.join(name)
+          @info_root.join(name)
         end
       end
 
       def info_etag_path(name)
         name = name.to_s
-        info_etag_root.join("#{name}-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}")
+        @info_etag_root.join("#{name}-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}")
       end
 
-      private
-
-      def mkdir(dir)
-        SharedHelpers.filesystem_access(dir) do
-          FileUtils.mkdir_p(dir)
+      def mkdir(name)
+        directory.join(name).tap do |dir|
+          SharedHelpers.filesystem_access(dir) do
+            FileUtils.mkdir_p(dir)
+          end
         end
       end
 
-      def lines(path)
-        return [] unless path.file?
-        lines = SharedHelpers.filesystem_access(path, :read, &:read).split("\n")
-        header = lines.index("---")
-        header ? lines[header + 1..-1] : lines
-      end
+      def fetch(remote_path, path, etag_path)
+        if already_fetched?(remote_path)
+          Bundler::CompactIndexClient.debug { "already fetched #{remote_path}" }
+        else
+          Bundler::CompactIndexClient.debug { "fetching #{remote_path}" }
+          @updater&.update(remote_path, path, etag_path)
+        end
 
-      def parse_gem(line)
-        @dependency_parser ||= GemParser.new
-        @dependency_parser.parse(line)
+        read(path)
       end
 
-      def info_roots
-        [
-          directory.join("info"),
-          directory.join("info-special-characters"),
-        ]
+      def already_fetched?(remote_path)
+        @mutex.synchronize { !@endpoints.add?(remote_path) }
       end
 
-      def info_etag_root
-        directory.join("info-etags")
+      def read(path)
+        return unless path.file?
+        SharedHelpers.filesystem_access(path, :read, &:read)
       end
     end
   end

data/bundler/lib/bundler/compact_index_client/cache_file.rb

@@ -86,11 +86,6 @@ module Bundler
         end
       end
 
-      # remove this method when we stop generating md5 digests for legacy etags
-      def md5
-        @digests && @digests["md5"]
-      end
-
       def digests?
         @digests&.any?
       end

data/bundler/lib/bundler/compact_index_client/parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CompactIndexClient
+    class Parser
+      # `compact_index` - an object responding to #names, #versions, #info(name, checksum),
+      #                   returning the file contents as a string
+      def initialize(compact_index)
+        @compact_index = compact_index
+        @info_checksums = nil
+        @versions_by_name = nil
+        @available = nil
+        @gem_parser = nil
+      end
+
+      def names
+        lines(@compact_index.names)
+      end
+
+      def versions
+        @versions_by_name ||= Hash.new {|hash, key| hash[key] = [] }
+        @info_checksums = {}
+
+        lines(@compact_index.versions).each do |line|
+          name, versions_string, checksum = line.split(" ", 3)
+          @info_checksums[name] = checksum || ""
+          versions_string.split(",") do |version|
+            delete = version.delete_prefix!("-")
+            version = version.split("-", 2).unshift(name)
+            if delete
+              @versions_by_name[name].delete(version)
+            else
+              @versions_by_name[name] << version
+            end
+          end
+        end
+
+        @versions_by_name
+      end
+
+      def info(name)
+        data = @compact_index.info(name, info_checksums[name])
+        lines(data).map {|line| gem_parser.parse(line).unshift(name) }
+      end
+
+      def available?
+        return @available unless @available.nil?
+        @available = !info_checksums.empty?
+      end
+
+      private
+
+      def info_checksums
+        @info_checksums ||= lines(@compact_index.versions).each_with_object({}) do |line, checksums|
+          parse_version_checksum(line, checksums)
+        end
+      end
+
+      def lines(data)
+        return [] if data.nil? || data.empty?
+        lines = data.split("\n")
+        header = lines.index("---")
+        header ? lines[header + 1..-1] : lines
+      end
+
+      def gem_parser
+        @gem_parser ||= Gem::Resolver::APISet::GemParser.new
+      end
+
+      # This is mostly the same as `split(" ", 3)` but it avoids allocating extra objects.
+      # This method gets called at least once for every gem when parsing versions.
+      def parse_version_checksum(line, checksums)
+        return unless (name_end = line.index(" ")) # Artifactory bug causes blank lines in artifactor index files
+        return unless (checksum_start = line.index(" ", name_end + 1) + 1)
+        checksum_end = line.size - checksum_start
+
+        line.freeze # allows slicing into the string to not allocate a copy of the line
+        name = line[0, name_end]
+        checksum = line[checksum_start, checksum_end]
+        checksums[name.freeze] = checksum # freeze name since it is used as a hash key
+      end
+    end
+  end
+end

data/bundler/lib/bundler/compact_index_client/updater.rb

@@ -28,7 +28,6 @@ module Bundler
 
         CacheFile.copy(local_path) do |file|
           etag = etag_path.read.tap(&:chomp!) if etag_path.file?
-          etag ||= generate_etag(etag_path, file) # Remove this after 2.5.0 has been out for a while.
 
           # Subtract a byte to ensure the range won't be empty.
           # Avoids 416 (Range Not Satisfiable) responses.
@@ -38,11 +37,12 @@ module Bundler
           file.digests = parse_digests(response)
           # server may ignore Range and return the full response
           if response.is_a?(Gem::Net::HTTPPartialContent)
-            break false unless file.append(response.body.byteslice(1..-1))
+            tail = response.body.byteslice(1..-1)
+            break false unless tail && file.append(tail)
           else
             file.write(response.body)
           end
-          CacheFile.write(etag_path, etag(response))
+          CacheFile.write(etag_path, etag_from_response(response))
           true
         end
       end
@@ -53,13 +53,13 @@ module Bundler
         response = @fetcher.call(remote_path, request_headers(etag))
         return true if response.is_a?(Gem::Net::HTTPNotModified)
         CacheFile.write(local_path, response.body, parse_digests(response))
-        CacheFile.write(etag_path, etag(response))
+        CacheFile.write(etag_path, etag_from_response(response))
       end
 
       def request_headers(etag, range_start = nil)
         headers = {}
         headers["Range"] = "bytes=#{range_start}-" if range_start
-        headers["If-None-Match"] = etag if etag
+        headers["If-None-Match"] = %("#{etag}") if etag
         headers
       end
 
@@ -67,17 +67,7 @@ module Bundler
         etag_path.read.tap(&:chomp!) if etag_path.file?
       end
 
-      # When first releasing this opaque etag feature, we want to generate the old MD5 etag
-      # based on the content of the file. After that it will always use the saved opaque etag.
-      # This transparently saves existing users with good caches from updating a bunch of files.
-      # Remove this behavior after 2.5.0 has been out for a while.
-      def generate_etag(etag_path, file)
-        etag = file.md5.hexdigest
-        CacheFile.write(etag_path, etag)
-        etag
-      end
-
-      def etag(response)
+      def etag_from_response(response)
         return unless response["ETag"]
         etag = response["ETag"].delete_prefix("W/")
         return if etag.delete_prefix!('"') && !etag.delete_suffix!('"')

data/bundler/lib/bundler/compact_index_client.rb

@@ -4,14 +4,40 @@ require "pathname"
 require "set"
 
 module Bundler
+  # The CompactIndexClient is responsible for fetching and parsing the compact index.
+  #
+  # The compact index is a set of caching optimized files that are used to fetch gem information.
+  # The files are:
+  # - names: a list of all gem names
+  # - versions: a list of all gem versions
+  # - info/[gem]: a list of all versions of a gem
+  #
+  # The client is instantiated with:
+  # - `directory`: the root directory where the cache files are stored.
+  # - `fetcher`: (optional) an object that responds to #call(uri_path, headers) and returns an http response.
+  # If the `fetcher` is not provided, the client will only read cached files from disk.
+  #
+  # The client is organized into:
+  # - `Updater`: updates the cached files on disk using the fetcher.
+  # - `Cache`: calls the updater, caches files, read and return them from disk
+  # - `Parser`: parses the compact index file data
+  # - `CacheFile`: a concurrency safe file reader/writer that verifies checksums
+  #
+  # The client is intended to optimize memory usage and performance.
+  # It is called 100s or 1000s of times, parsing files with hundreds of thousands of lines.
+  # It may be called concurrently without global interpreter lock in some Rubies.
+  # As a result, some methods may look more complex than necessary to save memory or time.
   class CompactIndexClient
-    # NOTE: MD5 is here not because we expect a server to respond with it, but
-    # because we use it to generate the etag on first request during the upgrade
-    # to the compact index client that uses opaque etags saved to files.
-    # Remove once 2.5.0 has been out for a while.
-    SUPPORTED_DIGESTS = { "sha-256" => :SHA256, "md5" => :MD5 }.freeze
+    SUPPORTED_DIGESTS = { "sha-256" => :SHA256 }.freeze
     DEBUG_MUTEX = Thread::Mutex.new
 
+    # info returns an Array of INFO Arrays. Each INFO Array has the following indices:
+    INFO_NAME = 0
+    INFO_VERSION = 1
+    INFO_PLATFORM = 2
+    INFO_DEPS = 3
+    INFO_REQS = 4
+
     def self.debug
       return unless ENV["DEBUG_COMPACT_INDEX"]
       DEBUG_MUTEX.synchronize { warn("[#{self}] #{yield}") }
@@ -21,106 +47,47 @@ module Bundler
 
     require_relative "compact_index_client/cache"
     require_relative "compact_index_client/cache_file"
+    require_relative "compact_index_client/parser"
     require_relative "compact_index_client/updater"
 
-    attr_reader :directory
-
-    def initialize(directory, fetcher)
-      @directory = Pathname.new(directory)
-      @updater = Updater.new(fetcher)
-      @cache = Cache.new(@directory)
-      @endpoints = Set.new
-      @info_checksums_by_name = {}
-      @parsed_checksums = false
-      @mutex = Thread::Mutex.new
-    end
-
-    def execution_mode=(block)
-      Bundler::CompactIndexClient.debug { "execution_mode=" }
-      @endpoints = Set.new
-
-      @execution_mode = block
-    end
-
-    # @return [Lambda] A lambda that takes an array of inputs and a block, and
-    #         maps the inputs with the block in parallel.
-    #
-    def execution_mode
-      @execution_mode || sequentially
-    end
-
-    def sequential_execution_mode!
-      self.execution_mode = sequentially
-    end
-
-    def sequentially
-      @sequentially ||= lambda do |inputs, &blk|
-        inputs.map(&blk)
-      end
+    def initialize(directory, fetcher = nil)
+      @cache = Cache.new(directory, fetcher)
+      @parser = Parser.new(@cache)
     end
 
     def names
-      Bundler::CompactIndexClient.debug { "/names" }
-      update("names", @cache.names_path, @cache.names_etag_path)
-      @cache.names
+      Bundler::CompactIndexClient.debug { "names" }
+      @parser.names
     end
 
     def versions
-      Bundler::CompactIndexClient.debug { "/versions" }
-      update("versions", @cache.versions_path, @cache.versions_etag_path)
-      versions, @info_checksums_by_name = @cache.versions
-      versions
+      Bundler::CompactIndexClient.debug { "versions" }
+      @parser.versions
     end
 
     def dependencies(names)
       Bundler::CompactIndexClient.debug { "dependencies(#{names})" }
-      execution_mode.call(names) do |name|
-        update_info(name)
-        @cache.dependencies(name).map {|d| d.unshift(name) }
-      end.flatten(1)
+      names.map {|name| info(name) }
     end
 
-    def update_and_parse_checksums!
-      Bundler::CompactIndexClient.debug { "update_and_parse_checksums!" }
-      return @info_checksums_by_name if @parsed_checksums
-      update("versions", @cache.versions_path, @cache.versions_etag_path)
-      @info_checksums_by_name = @cache.checksums
-      @parsed_checksums = true
-    end
-
-    private
-
-    def update(remote_path, local_path, local_etag_path)
-      Bundler::CompactIndexClient.debug { "update(#{local_path}, #{remote_path})" }
-      unless synchronize { @endpoints.add?(remote_path) }
-        Bundler::CompactIndexClient.debug { "already fetched #{remote_path}" }
-        return
-      end
-      @updater.update(url(remote_path), local_path, local_etag_path)
+    def info(name)
+      Bundler::CompactIndexClient.debug { "info(#{name})" }
+      @parser.info(name)
     end
 
-    def update_info(name)
-      Bundler::CompactIndexClient.debug { "update_info(#{name})" }
-      path = @cache.info_path(name)
-      unless existing = @info_checksums_by_name[name]
-        Bundler::CompactIndexClient.debug { "skipping updating info for #{name} since it is missing from versions" }
-        return
-      end
-      checksum = SharedHelpers.checksum_for_file(path, :MD5)
-      if checksum == existing
-        Bundler::CompactIndexClient.debug { "skipping updating info for #{name} since the versions checksum matches the local checksum" }
-        return
-      end
-      Bundler::CompactIndexClient.debug { "updating info for #{name} since the versions checksum #{existing} != the local checksum #{checksum}" }
-      update("info/#{name}", path, @cache.info_etag_path(name))
+    def latest_version(name)
+      Bundler::CompactIndexClient.debug { "latest_version(#{name})" }
+      @parser.info(name).map {|d| Gem::Version.new(d[INFO_VERSION]) }.max
     end
 
-    def url(path)
-      path
+    def available?
+      Bundler::CompactIndexClient.debug { "available?" }
+      @parser.available?
     end
 
-    def synchronize
-      @mutex.synchronize { yield }
+    def reset!
+      Bundler::CompactIndexClient.debug { "reset!" }
+      @cache.reset!
     end
   end
 end

data/bundler/lib/bundler/constants.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
+require "rbconfig"
+
 module Bundler
   WINDOWS = RbConfig::CONFIG["host_os"] =~ /(msdos|mswin|djgpp|mingw)/
+  deprecate_constant :WINDOWS
+
   FREEBSD = RbConfig::CONFIG["host_os"].to_s.include?("bsd")
-  NULL    = File::NULL
+  deprecate_constant :FREEBSD
+
+  NULL = File::NULL
+  deprecate_constant :NULL
 end

data/bundler/lib/bundler/current_ruby.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "rubygems_ext"
+
 module Bundler
   # Returns current version of Ruby
   #
@@ -9,41 +11,28 @@ module Bundler
   end
 
   class CurrentRuby
-    KNOWN_MINOR_VERSIONS = %w[
-      1.8
-      1.9
-      2.0
-      2.1
-      2.2
-      2.3
-      2.4
-      2.5
-      2.6
-      2.7
-      3.0
-      3.1
-      3.2
-      3.3
-    ].freeze
-
-    KNOWN_MAJOR_VERSIONS = KNOWN_MINOR_VERSIONS.map {|v| v.split(".", 2).first }.uniq.freeze
-
-    KNOWN_PLATFORMS = %w[
-      jruby
-      maglev
-      mingw
-      mri
-      mswin
-      mswin64
-      rbx
-      ruby
-      truffleruby
-      windows
-      x64_mingw
-    ].freeze
+    ALL_RUBY_VERSIONS = (18..27).to_a.concat((30..35).to_a).freeze
+    KNOWN_MINOR_VERSIONS = ALL_RUBY_VERSIONS.map {|v| v.digits.reverse.join(".") }.freeze
+    KNOWN_MAJOR_VERSIONS = ALL_RUBY_VERSIONS.map {|v| v.digits.last.to_s }.uniq.freeze
+    PLATFORM_MAP = {
+      ruby: [Gem::Platform::RUBY, CurrentRuby::ALL_RUBY_VERSIONS],
+      mri: [Gem::Platform::RUBY, CurrentRuby::ALL_RUBY_VERSIONS],
+      rbx: [Gem::Platform::RUBY],
+      truffleruby: [Gem::Platform::RUBY],
+      jruby: [Gem::Platform::JAVA, [18, 19]],
+      windows: [Gem::Platform::WINDOWS, CurrentRuby::ALL_RUBY_VERSIONS],
+      # deprecated
+      mswin: [Gem::Platform::MSWIN, CurrentRuby::ALL_RUBY_VERSIONS],
+      mswin64: [Gem::Platform::MSWIN64, CurrentRuby::ALL_RUBY_VERSIONS - [18]],
+      mingw: [Gem::Platform::UNIVERSAL_MINGW, CurrentRuby::ALL_RUBY_VERSIONS],
+      x64_mingw: [Gem::Platform::UNIVERSAL_MINGW, CurrentRuby::ALL_RUBY_VERSIONS - [18, 19]],
+    }.each_with_object({}) do |(platform, spec), hash|
+      hash[platform] = spec[0]
+      spec[1]&.each {|version| hash[:"#{platform}_#{version}"] = spec[0] }
+    end.freeze
 
     def ruby?
-      return true if Bundler::GemHelpers.generic_local_platform_is_ruby?
+      return true if Bundler::MatchPlatform.generic_local_platform_is_ruby?
 
       !windows? && (RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx" || RUBY_ENGINE == "maglev" || RUBY_ENGINE == "truffleruby")
     end
@@ -61,6 +50,18 @@ module Bundler
     end
 
     def maglev?
+      message =
+        "`CurrentRuby#maglev?` is deprecated with no replacement. Please use the " \
+        "built-in Ruby `RUBY_ENGINE` constant to check the Ruby implementation you are running on."
+      removed_message =
+        "`CurrentRuby#maglev?` was removed with no replacement. Please use the " \
+        "built-in Ruby `RUBY_ENGINE` constant to check the Ruby implementation you are running on."
+      internally_exempted = caller_locations(1, 1).first.path == __FILE__
+
+      unless internally_exempted
+        SharedHelpers.major_deprecation(2, message, removed_message: removed_message, print_caller_location: true)
+      end
+
       RUBY_ENGINE == "maglev"
     end
 
@@ -82,11 +83,24 @@ module Bundler
         RUBY_VERSION.start_with?("#{version}.")
       end
 
-      KNOWN_PLATFORMS.each do |platform|
+      PLATFORM_MAP.keys.each do |platform|
         define_method(:"#{platform}_#{trimmed_version}?") do
           send(:"#{platform}?") && send(:"on_#{trimmed_version}?")
         end
       end
+
+      define_method(:"maglev_#{trimmed_version}?") do
+        message =
+          "`CurrentRuby##{__method__}` is deprecated with no replacement. Please use the " \
+          "built-in Ruby `RUBY_ENGINE` and `RUBY_VERSION` constants to perform a similar check."
+        removed_message =
+          "`CurrentRuby##{__method__}` was removed with no replacement. Please use the " \
+          "built-in Ruby `RUBY_ENGINE` and `RUBY_VERSION` constants to perform a similar check."
+
+        SharedHelpers.major_deprecation(2, message, removed_message: removed_message, print_caller_location: true)
+
+        send(:"maglev?") && send(:"on_#{trimmed_version}?")
+      end
     end
   end
 end