Basics: support multiple formats with a single archiver (#6369)

In certain function signatures only a single archiver instance can be taken as an argument. We need to support multiple archive formats, such as `.zip` and `.tar.gz`, for example in cross-compilation destination bundles. Instead of updating those functions to take multiple archivers, creating a single type that can support multiple formats would be a better solution.

Added `MultiFormatArchiver` that can handle multiple formats by delegating to other archivers it was initialized with. Since most uses of `Archiver` are either generic or take an existential, this allows us to pass `MultiFormatArchiver` to functions that previously supported only a single archive format.

This is technically NFC as `MultiFormatArchiver` is not used anywhere yet.

rdar://107485048

Author: MaxDesiatov

Sources/Basics/Archiver.swift renamed to Sources/Basics/Archiver/Archiver.swift

@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2014-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct TSCBasic.AbsolutePath
+import protocol TSCBasic.FileSystem
+
+/// An `Archiver` that handles multiple formats by delegating to other existing archivers each dedicated to its own
+/// format.
+public struct UniversalArchiver: Archiver {
+    public var supportedExtensions: Set<String>
+
+    /// Errors specific to the implementation of ``UniversalArchiver``.
+    enum Error: Swift.Error {
+        case unknownFormat(String, AbsolutePath)
+        case noFileNameExtension(AbsolutePath)
+
+        var description: String {
+            switch self {
+            case .unknownFormat(let ext, let path):
+                return "unknown format with extension \(ext) at path `\(path)`"
+            case .noFileNameExtension(let path):
+                return "file at path `\(path)` has no extension to detect archival format from"
+            }
+        }
+    }
+
+    /// A dictionary that maps file extension strings to archiver instances that supports these extensions.
+    private let formatMapping: [String: any Archiver]
+
+    public init(_ fileSystem: any FileSystem, _ cancellator: Cancellator? = nil) {
+        var formatMapping = [String: any Archiver]()
+        var supportedExtensions = Set<String>()
+
+        for archiver in [
+            ZipArchiver(fileSystem: fileSystem, cancellator: cancellator),
+            TarArchiver(fileSystem: fileSystem, cancellator: cancellator),
+        ] as [any Archiver] {
+            supportedExtensions.formUnion(archiver.supportedExtensions)
+            for ext in archiver.supportedExtensions {
+                formatMapping[ext] = archiver
+            }
+        }
+
+        self.formatMapping = formatMapping
+        self.supportedExtensions = supportedExtensions
+    }
+
+    private func archiver(for archivePath: AbsolutePath) throws -> any Archiver {
+        guard let extensions = archivePath.allExtensions else {
+            throw Error.noFileNameExtension(archivePath)
+        }
+
+        guard let archiver = self.formatMapping[extensions] else {
+            throw Error.unknownFormat(extensions, archivePath)
+        }
+
+        return archiver
+    }
+
+    public func extract(
+        from archivePath: AbsolutePath,
+        to destinationPath: AbsolutePath,
+        completion: @escaping (Result<Void, Swift.Error>) -> Void
+    ) {
+        do {
+            let archiver = try archiver(for: archivePath)
+            archiver.extract(from: archivePath, to: destinationPath, completion: completion)
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    public func compress(
+        directory: AbsolutePath,
+        to destinationPath: AbsolutePath,
+        completion: @escaping (Result<Void, Swift.Error>) -> Void
+    ) {
+        do {
+            let archiver = try archiver(for: destinationPath)
+            archiver.compress(directory: directory, to: destinationPath, completion: completion)
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    public func validate(
+        path: AbsolutePath,
+        completion: @escaping (Result<Bool, Swift.Error>) -> Void
+    ) {
+        do {
+            let archiver = try archiver(for: path)
+            archiver.validate(path: path, completion: completion)
+        } catch {
+            completion(.failure(error))
+        }
+    }
+}

Sources/Basics/Archiver+Tar.swift renamed to Sources/Basics/Archiver/TarArchiver.swift

@@ -7,9 +7,10 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 add_library(Basics
-  Archiver.swift
-  Archiver+Tar.swift
-  Archiver+Zip.swift
+  Archiver/Archiver.swift
+  Archiver/TarArchiver.swift
+  Archiver/ZipArchiver.swift
+  Archiver/UniversalArchiver.swift
   AuthorizationProvider.swift
   ByteString+Extensions.swift
   Cancellator.swift

Sources/Basics/Archiver/UniversalArchiver.swift

@@ -38,4 +38,22 @@ extension AbsolutePath {
     public func escapedPathString() -> String {
         return self.pathString.replacingOccurrences(of: "\\", with: "\\\\")
     }
+
+    /// Unlike ``AbsolutePath//extension``, this property returns all characters after the first `.` character in a
+    /// `````. If no dot character is present in the filename or first dot is the last character, `nil` is returned.
+    var allExtensions: String? {
+        guard let firstDot = basename.firstIndex(of: ".") else {
+            return nil
+        }
+
+        var extensions = String(basename[firstDot ..< basename.endIndex])
+
+        guard extensions.count > 1 else {
+            return nil
+        }
+
+        extensions.removeFirst()
+
+        return extensions
+    }
 }