rubygems-update 2.6.4 → 2.6.5

data/bundler/lib/bundler/ui/silent.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Bundler
+  module UI
+    class Silent
+      def add_color(string, color)
+      end
+
+      def info(message, newline = nil)
+      end
+
+      def confirm(message, newline = nil)
+      end
+
+      def warn(message, newline = nil)
+      end
+
+      def error(message, newline = nil)
+      end
+
+      def debug(message, newline = nil)
+      end
+
+      def debug?
+        false
+      end
+
+      def quiet?
+        false
+      end
+
+      def ask(message)
+      end
+
+      def level=(name)
+      end
+
+      def level(name = nil)
+      end
+
+      def trace(message, newline = nil)
+      end
+
+      def silence
+        yield
+      end
+    end
+  end
+end

data/bundler/lib/bundler/uri_credentials_filter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Bundler
+  module URICredentialsFilter
+  module_function
+
+    def credential_filtered_uri(uri_to_anonymize)
+      return uri_to_anonymize if uri_to_anonymize.nil?
+      uri = uri_to_anonymize.dup
+      uri = URI(uri.to_s) unless uri.is_a?(URI)
+      if uri.userinfo
+        # oauth authentication
+        if uri.password == "x-oauth-basic" || uri.password == "x"
+          # URI as string does not display with password if no user is set
+          oauth_designation = uri.password
+          uri.user = oauth_designation
+        end
+        uri.password = nil
+      end
+      return uri if uri_to_anonymize.is_a?(URI)
+      return uri.to_s if uri_to_anonymize.is_a?(String)
+    rescue URI::InvalidURIError # uri is not canonical uri scheme
+      uri
+    end
+
+    def credential_filtered_string(str_to_filter, uri)
+      return str_to_filter if uri.nil? || str_to_filter.nil?
+      str_with_no_credentials = str_to_filter.dup
+      anonymous_uri_str = credential_filtered_uri(uri).to_s
+      uri_str = uri.to_s
+      if anonymous_uri_str != uri_str
+        str_with_no_credentials = str_with_no_credentials.gsub(uri_str, anonymous_uri_str)
+      end
+      str_with_no_credentials
+    end
+  end
+end

data/bundler/lib/bundler/vendor/compact_index_client/lib/compact_index_client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require "pathname"
+require "set"
+
+class Bundler::CompactIndexClient
+  class Error < StandardError; end
+
+  require "bundler/vendor/compact_index_client/lib/compact_index_client/cache"
+  require "bundler/vendor/compact_index_client/lib/compact_index_client/updater"
+  require "bundler/vendor/compact_index_client/lib/compact_index_client/version"
+
+  attr_reader :directory
+
+  # @return [Lambda] A lambda that takes an array of inputs and a block, and
+  #         maps the inputs with the block in parallel.
+  #
+  attr_accessor :in_parallel
+
+  def initialize(directory, fetcher)
+    @directory = Pathname.new(directory)
+    @updater = Updater.new(fetcher)
+    @cache = Cache.new(@directory)
+    @endpoints = Set.new
+    @info_checksums_by_name = {}
+    @in_parallel = lambda do |inputs, &blk|
+      inputs.map(&blk)
+    end
+  end
+
+  def names
+    update(@cache.names_path, "names")
+    @cache.names
+  end
+
+  def versions
+    update(@cache.versions_path, "versions")
+    versions, @info_checksums_by_name = @cache.versions
+    versions
+  end
+
+  def dependencies(names)
+    in_parallel.call(names) do |name|
+      update_info(name)
+      @cache.dependencies(name).map {|d| d.unshift(name) }
+    end.flatten(1)
+  end
+
+  def spec(name, version, platform = nil)
+    update_info(name)
+    @cache.specific_dependency(name, version, platform)
+  end
+
+  def update_and_parse_checksums!
+    return @info_checksums_by_name if @parsed_checksums
+    update(@cache.versions_path, "versions")
+    @info_checksums_by_name = @cache.checksums
+    @parsed_checksums = true
+  end
+
+private
+
+  def update(local_path, remote_path)
+    return if @endpoints.include?(remote_path)
+    @updater.update(local_path, url(remote_path))
+    @endpoints << remote_path
+  end
+
+  def update_info(name)
+    path = @cache.info_path(name)
+    checksum = @updater.checksum_for_file(path)
+    return unless existing = @info_checksums_by_name[name]
+    return if checksum == existing
+    update(path, "info/#{name}")
+  end
+
+  def url(path)
+    path
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+class Bundler::CompactIndexClient
+  class Cache
+    attr_reader :directory
+
+    def initialize(directory)
+      @directory = Pathname.new(directory).expand_path
+      FileUtils.mkdir_p info_path(nil)
+    end
+
+    def names
+      lines(names_path)
+    end
+
+    def names_path
+      directory.join("names")
+    end
+
+    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(",").each do |version|
+          if version.start_with?("-")
+            version = version[1..-1].split("-", 2).unshift(name)
+            versions_by_name[name].delete(version)
+          else
+            version = version.split("-", 2).unshift(name)
+            versions_by_name[name] << version
+          end
+        end
+      end
+
+      [versions_by_name, info_checksums_by_name]
+    end
+
+    def versions_path
+      directory.join("versions")
+    end
+
+    def checksums
+      checksums = {}
+
+      lines(versions_path).each do |line|
+        name, _, checksum = line.split(" ", 3)
+        checksums[name] = checksum
+      end
+
+      checksums
+    end
+
+    def dependencies(name)
+      lines(info_path(name)).map do |line|
+        parse_gem(line)
+      end
+    end
+
+    def info_path(name)
+      directory.join("info", name.to_s)
+    end
+
+    def specific_dependency(name, version, platform)
+      pattern = [version, platform].compact.join("-")
+      return nil if pattern.empty?
+
+      gem_lines = info_path(name).read
+      gem_line = gem_lines[/^#{Regexp.escape(pattern)}\b.*/, 0]
+      gem_line ? parse_gem(gem_line) : nil
+    end
+
+  private
+
+    def lines(path)
+      return [] unless path.file?
+      lines = path.read.split("\n")
+      header = lines.index("---")
+      lines = header ? lines[header + 1..-1] : lines
+    end
+
+    def parse_gem(string)
+      version_and_platform, rest = string.split(" ", 2)
+      version, platform = version_and_platform.split("-", 2)
+      dependencies, requirements = rest.split("|", 2).map {|s| s.split(",") } if rest
+      dependencies = dependencies ? dependencies.map {|d| parse_dependency(d) } : []
+      requirements = requirements ? requirements.map {|r| parse_dependency(r) } : []
+      [version, platform, dependencies, requirements]
+    end
+
+    def parse_dependency(string)
+      dependency = string.split(":")
+      dependency[-1] = dependency[-1].split("&") if dependency.size > 1
+      dependency
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+require "fileutils"
+require "stringio"
+require "tmpdir"
+require "zlib"
+
+class Bundler::CompactIndexClient
+  class Updater
+    class MisMatchedChecksumError < Error
+      def initialize(path, server_checksum, local_checksum)
+        @path = path
+        @server_checksum = server_checksum
+        @local_checksum = local_checksum
+      end
+
+      def message
+        "The checksum of /#{@path} does not match the checksum provided by the server! Something is wrong " \
+          "(local checksum is #{@local_checksum.inspect}, was expecting #{@server_checksum.inspect})."
+      end
+    end
+
+    def initialize(fetcher)
+      @fetcher = fetcher
+    end
+
+    def update(local_path, remote_path, retrying = nil)
+      headers = {}
+
+      Dir.mktmpdir(local_path.basename.to_s, local_path.dirname) do |local_temp_dir|
+        local_temp_path = Pathname.new(local_temp_dir).join(local_path.basename)
+
+        # download new file if retrying
+        if retrying.nil? && local_path.file?
+          FileUtils.cp local_path, local_temp_path
+          headers["If-None-Match"] = etag_for(local_temp_path)
+          headers["Range"] = "bytes=#{local_temp_path.size}-"
+        else
+          # Fastly ignores Range when Accept-Encoding: gzip is set
+          headers["Accept-Encoding"] = "gzip"
+        end
+
+        response = @fetcher.call(remote_path, headers)
+        return if response.is_a?(Net::HTTPNotModified)
+
+        content = response.body
+        if response["Content-Encoding"] == "gzip"
+          content = Zlib::GzipReader.new(StringIO.new(content)).read
+        end
+
+        mode = response.is_a?(Net::HTTPPartialContent) ? "a" : "w"
+        local_temp_path.open(mode) {|f| f << content }
+
+        response_etag = response["ETag"]
+        if etag_for(local_temp_path) == response_etag
+          FileUtils.mv(local_temp_path, local_path)
+          return
+        end
+
+        if retrying.nil?
+          update(local_path, remote_path, :retrying)
+        else
+          raise MisMatchedChecksumError.new(remote_path, response_etag, etag_for(local_temp_path))
+        end
+      end
+    end
+
+    def etag_for(path)
+      sum = checksum_for_file(path)
+      sum ? %("#{sum}") : nil
+    end
+
+    def checksum_for_file(path)
+      return nil unless path.file?
+      # This must use IO.read instead of Digest.file().hexdigest
+      # because we need to preserve \n line endings on windows when calculating
+      # the checksum
+      Digest::MD5.hexdigest(IO.read(path))
+    end
+  end
+end

data/bundler/lib/bundler/vendor/compact_index_client/lib/compact_index_client/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+class Bundler::CompactIndexClient
+  VERSION = "0.1.0".freeze
+end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'bundler/vendor/molinillo/lib/molinillo/gem_metadata'
+require 'bundler/vendor/molinillo/lib/molinillo/errors'
+require 'bundler/vendor/molinillo/lib/molinillo/resolver'
+require 'bundler/vendor/molinillo/lib/molinillo/modules/ui'
+require 'bundler/vendor/molinillo/lib/molinillo/modules/specification_provider'
+
+# Bundler::Molinillo is a generic dependency resolution algorithm.
+module Bundler::Molinillo
+end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/delegates/resolution_state.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Bundler::Molinillo
+  # @!visibility private
+  module Delegates
+    # Delegates all {Bundler::Molinillo::ResolutionState} methods to a `#state` property.
+    module ResolutionState
+      # (see Bundler::Molinillo::ResolutionState#name)
+      def name
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.name
+      end
+
+      # (see Bundler::Molinillo::ResolutionState#requirements)
+      def requirements
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.requirements
+      end
+
+      # (see Bundler::Molinillo::ResolutionState#activated)
+      def activated
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.activated
+      end
+
+      # (see Bundler::Molinillo::ResolutionState#requirement)
+      def requirement
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.requirement
+      end
+
+      # (see Bundler::Molinillo::ResolutionState#possibilities)
+      def possibilities
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.possibilities
+      end
+
+      # (see Bundler::Molinillo::ResolutionState#depth)
+      def depth
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.depth
+      end
+
+      # (see Bundler::Molinillo::ResolutionState#conflicts)
+      def conflicts
+        current_state = state || Bundler::Molinillo::ResolutionState.empty
+        current_state.conflicts
+      end
+    end
+  end
+end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/delegates/specification_provider.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Bundler::Molinillo
+  module Delegates
+    # Delegates all {Bundler::Molinillo::SpecificationProvider} methods to a
+    # `#specification_provider` property.
+    module SpecificationProvider
+      # (see Bundler::Molinillo::SpecificationProvider#search_for)
+      def search_for(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.search_for(dependency)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#dependencies_for)
+      def dependencies_for(specification)
+        with_no_such_dependency_error_handling do
+          specification_provider.dependencies_for(specification)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#requirement_satisfied_by?)
+      def requirement_satisfied_by?(requirement, activated, spec)
+        with_no_such_dependency_error_handling do
+          specification_provider.requirement_satisfied_by?(requirement, activated, spec)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#name_for)
+      def name_for(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for(dependency)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#name_for_explicit_dependency_source)
+      def name_for_explicit_dependency_source
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for_explicit_dependency_source
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#name_for_locking_dependency_source)
+      def name_for_locking_dependency_source
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for_locking_dependency_source
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#sort_dependencies)
+      def sort_dependencies(dependencies, activated, conflicts)
+        with_no_such_dependency_error_handling do
+          specification_provider.sort_dependencies(dependencies, activated, conflicts)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#allow_missing?)
+      def allow_missing?(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.allow_missing?(dependency)
+        end
+      end
+
+      private
+
+      # Ensures any raised {NoSuchDependencyError} has its
+      # {NoSuchDependencyError#required_by} set.
+      # @yield
+      def with_no_such_dependency_error_handling
+        yield
+      rescue NoSuchDependencyError => error
+        if state
+          vertex = activated.vertex_named(name_for(error.dependency))
+          error.required_by += vertex.incoming_edges.map { |e| e.origin.name }
+          error.required_by << name_for_explicit_dependency_source unless vertex.explicit_requirements.empty?
+        end
+        raise
+      end
+    end
+  end
+end