Address PR feedback

Author: MaxDesiatov

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

@@ -11,9 +11,11 @@
 //===----------------------------------------------------------------------===//
 
 import struct TSCBasic.AbsolutePath
+import protocol TSCBasic.FileSystem
 
-/// An `Archiver` that handles multiple formats by delegating to other archivers it was initialized with.
-public final class MultiFormatArchiver: Archiver {
+/// An `Archiver` that handles multiple formats by delegating to other existing archivers each dedicated to its own
+/// format.
+public final class UniversalArchiver: Archiver {
     public var supportedExtensions: Set<String>
 
     enum Error: Swift.Error {
@@ -32,11 +34,14 @@ public final class MultiFormatArchiver: Archiver {
 
     private let formatMapping: [String: any Archiver]
 
-    public init(_ archivers: [any Archiver]) {
+    public init(_ fileSystem: any FileSystem, _ cancellator: Cancellator? = nil) {
         var formatMapping = [String: any Archiver]()
         var supportedExtensions = Set<String>()
 
-        for archiver in archivers {
+        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
@@ -48,22 +53,10 @@ public final class MultiFormatArchiver: Archiver {
     }
 
     private func archiver(for archivePath: AbsolutePath) throws -> any Archiver {
-        let filename = archivePath.basename
-
-        // Calculating extension manually, since ``AbsolutePath//extension`` doesn't support multiple extensions,
-        // like `.tar.gz`. It returns just `gz` for `.tar.gz` archives.
-        guard let firstDot = filename.firstIndex(of: ".") else {
-            throw Error.noFileNameExtension(archivePath)
-        }
-
-        var extensions = String(filename[firstDot ..< filename.endIndex])
-
-        guard extensions.count > 1 else {
+        guard let extensions = archivePath.allExtensions else {
             throw Error.noFileNameExtension(archivePath)
         }
 
-        extensions.removeFirst()
-
         guard let archiver = self.formatMapping[extensions] else {
             throw Error.unknownFormat(extensions, archivePath)
         }

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/MultiFormatArchiver.swift renamed to 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
+    }
 }

Sources/Basics/Archiver+Zip.swift renamed to Sources/Basics/Archiver/ZipArchiver.swift

@@ -16,12 +16,10 @@ import TSCclibc // for SPM_posix_spawn_file_actions_addchdir_np_supported
 import TSCTestSupport
 import XCTest
 
-final class MultiFormatArchiverTests: XCTestCase {
+final class UniversalArchiverTests: XCTestCase {
     func testSuccess() throws {
         try testWithTemporaryDirectory { tmpdir in
-            let archiver = MultiFormatArchiver(
-                [TarArchiver(fileSystem: localFileSystem), ZipArchiver(fileSystem: localFileSystem)]
-            )
+            let archiver = UniversalArchiver(localFileSystem)
             let inputArchivePath = AbsolutePath(path: #file).parentDirectory
                 .appending(components: "Inputs", "archive.tar.gz")
             let tarDestination = tmpdir.appending("tar")
@@ -42,9 +40,7 @@ final class MultiFormatArchiverTests: XCTestCase {
 
     func testArchiveDoesntExist() {
         let fileSystem = InMemoryFileSystem()
-        let archiver = MultiFormatArchiver(
-            [TarArchiver(fileSystem: fileSystem), ZipArchiver(fileSystem: fileSystem)]
-        )
+        let archiver = UniversalArchiver(fileSystem)
         let archive = AbsolutePath("/archive.tar.gz")
         XCTAssertThrowsError(try archiver.extract(from: archive, to: "/")) { error in
             XCTAssertEqual(error as? FileSystemError, FileSystemError(.noEntry, archive))
@@ -53,9 +49,7 @@ final class MultiFormatArchiverTests: XCTestCase {
 
     func testDestinationDoesntExist() throws {
         let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.tar.gz")
-        let archiver = MultiFormatArchiver(
-            [TarArchiver(fileSystem: fileSystem), ZipArchiver(fileSystem: fileSystem)]
-        )
+        let archiver = UniversalArchiver(fileSystem)
         let destination = AbsolutePath("/destination")
         XCTAssertThrowsError(try archiver.extract(from: "/archive.tar.gz", to: destination)) { error in
             XCTAssertEqual(error as? FileSystemError, FileSystemError(.notDirectory, destination))
@@ -64,9 +58,7 @@ final class MultiFormatArchiverTests: XCTestCase {
 
     func testDestinationIsFile() throws {
         let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.tar.gz", "/destination")
-        let archiver = MultiFormatArchiver(
-            [TarArchiver(fileSystem: fileSystem), ZipArchiver(fileSystem: fileSystem)]
-        )
+        let archiver = UniversalArchiver(fileSystem)
         let destination = AbsolutePath("/destination")
         XCTAssertThrowsError(try archiver.extract(from: "/archive.tar.gz", to: destination)) { error in
             XCTAssertEqual(error as? FileSystemError, FileSystemError(.notDirectory, destination))
@@ -75,9 +67,7 @@ final class MultiFormatArchiverTests: XCTestCase {
 
     func testInvalidArchive() throws {
         try testWithTemporaryDirectory { tmpdir in
-            let archiver = MultiFormatArchiver(
-                [TarArchiver(fileSystem: localFileSystem), ZipArchiver(fileSystem: localFileSystem)]
-            )
+            let archiver = UniversalArchiver(localFileSystem)
             var inputArchivePath = AbsolutePath(path: #file).parentDirectory
                 .appending(components: "Inputs", "invalid_archive.tar.gz")
             XCTAssertThrowsError(try archiver.extract(from: inputArchivePath, to: tmpdir)) { error in
@@ -103,27 +93,21 @@ final class MultiFormatArchiverTests: XCTestCase {
     func testValidation() throws {
         // valid
         try testWithTemporaryDirectory { _ in
-            let archiver = MultiFormatArchiver(
-                [TarArchiver(fileSystem: localFileSystem), ZipArchiver(fileSystem: localFileSystem)]
-            )
+            let archiver = UniversalArchiver(localFileSystem)
             let path = AbsolutePath(path: #file).parentDirectory
                 .appending(components: "Inputs", "archive.tar.gz")
             XCTAssertTrue(try archiver.validate(path: path))
         }
         // invalid
         try testWithTemporaryDirectory { _ in
-            let archiver = MultiFormatArchiver(
-                [TarArchiver(fileSystem: localFileSystem), ZipArchiver(fileSystem: localFileSystem)]
-            )
+            let archiver = UniversalArchiver(localFileSystem)
             let path = AbsolutePath(path: #file).parentDirectory
                 .appending(components: "Inputs", "invalid_archive.tar.gz")
             XCTAssertFalse(try archiver.validate(path: path))
         }
         // error
         try testWithTemporaryDirectory { _ in
-            let archiver = MultiFormatArchiver(
-                [TarArchiver(fileSystem: localFileSystem), ZipArchiver(fileSystem: localFileSystem)]
-            )
+            let archiver = UniversalArchiver(localFileSystem)
             let path = AbsolutePath.root.appending("does_not_exist.tar.gz")
             XCTAssertThrowsError(try archiver.validate(path: path)) { error in
                 XCTAssertEqual(error as? FileSystemError, FileSystemError(.noEntry, path))
@@ -139,9 +123,7 @@ final class MultiFormatArchiverTests: XCTestCase {
         #endif
 
         try testWithTemporaryDirectory { tmpdir in
-            let archiver = MultiFormatArchiver(
-                [TarArchiver(fileSystem: localFileSystem), ZipArchiver(fileSystem: localFileSystem)]
-            )
+            let archiver = UniversalArchiver(localFileSystem)
 
             let rootDir = tmpdir.appending(component: UUID().uuidString)
             try localFileSystem.createDirectory(rootDir)