Gem::RemoteFetcher#download

# File tmp/rubies/ruby-4.1.0-preview1/lib/rubygems/remote_fetcher.rb, line 117
def download(spec, source_uri, install_dir = Gem.dir)
  gem_file_name = File.basename spec.cache_file

  source_uri = Gem::Uri.new(source_uri)

  scheme = source_uri.scheme

  # Gem::URI.parse gets confused by MS Windows paths with forward slashes.
  scheme = nil if /^[a-z]$/i.match?(scheme)

  remote_source = REMOTE_SCHEMES.include?(scheme)

  install_cache_dir = File.join install_dir, "cache"
  cache_dir =
    if File.identical?(".", install_dir) # gem fetch asks for it this way
      install_dir
    elsif Gem.configuration.global_gem_cache && remote_source && ensure_writable_cache_dir(Gem.global_gem_cache_path)
      Gem.global_gem_cache_path
    elsif File.writable?(install_cache_dir) || (File.writable?(install_dir) && !File.exist?(install_cache_dir))
      install_cache_dir
    else
      File.join Gem.user_dir, "cache"
    end

  local_gem_path = File.join cache_dir, gem_file_name

  require "fileutils"
  begin
    FileUtils.mkdir_p cache_dir
  rescue StandardError
    nil
  end unless File.exist? cache_dir

  # REFACTOR: split this up and dispatch on scheme (eg download_http)
  # REFACTOR: be sure to clean up fake fetcher when you do this... cleaner
  case scheme
  when *REMOTE_SCHEMES then
    if File.exist? local_gem_path
      verbose "Using local gem #{local_gem_path}"
    else
      begin
        verbose "Downloading gem #{gem_file_name} to #{cache_dir}"

        remote_gem_path = source_uri + "gems/#{gem_file_name}"

        cache_update_path remote_gem_path, local_gem_path
      rescue FetchError
        raise if Gem::ContentAddress.content_addressed?(spec, validate_ruby_abi: false)
        raise if spec.original_platform.to_s == spec.platform.to_s

        alternate_name = "#{spec.original_name}.gem"

        verbose "Failed, downloading gem #{alternate_name} to #{cache_dir}"

        remote_gem_path = source_uri + "gems/#{alternate_name}"

        cache_update_path remote_gem_path, local_gem_path
      end
    end
  when "file" then
    begin
      path = source_uri.path
      path = File.dirname(path) if File.extname(path) == ".gem"

      remote_gem_path = Gem::Util.correct_for_windows_path(File.join(path, "gems", gem_file_name))

      atomic_copy(remote_gem_path, local_gem_path)
    rescue Errno::EACCES
      local_gem_path = source_uri.to_s
    end

    verbose "Using local gem #{local_gem_path}"
  when nil then
    source_path = if Gem.win_platform? && source_uri.scheme &&
                     !source_uri.path.include?(":")
      "#{source_uri.scheme}:#{source_uri.path}"
    else
      source_uri.path
    end

    source_path = Gem::UriFormatter.new(source_path).unescape

    begin
      atomic_copy(source_path, local_gem_path) unless
        File.identical?(source_path, local_gem_path)
    rescue Errno::EACCES
      local_gem_path = source_uri.to_s
    end

    verbose "Using local gem #{local_gem_path}"
  else
    raise ArgumentError, "unsupported URI scheme #{source_uri.scheme}"
  end

  local_gem_path
end