Merge pull request #19 from apple/update

Sync with SwiftPM trunk

Author: aciidgh

Package.swift

@@ -23,6 +23,13 @@ let package = Package(
         .library(
             name: "SwiftToolsSupport-auto",
             targets: ["TSCBasic", "TSCUtility"]),
+
+        .library(
+            name: "TSCTestSupport",
+            targets: ["TSCTestSupport"]),
+        .executable(
+            name: "TSCTestSupportExecutable",
+            targets: ["TSCTestSupportExecutable"]),
     ],
     dependencies: [
 

Sources/TSCBasic/CMakeLists.txt

@@ -62,3 +62,10 @@ install(TARGETS TSCBasic
   LIBRARY DESTINATION lib
   RUNTIME DESTINATION bin)
 endif()
+
+# Don't use GNU strerror_r on Android.
+if(CMAKE_SYSTEM_NAME STREQUAL Android)
+  target_compile_options(TSCBasic PUBLIC "SHELL:-Xcc -U_GNU_SOURCE")
+endif()
+
+set_property(GLOBAL APPEND PROPERTY TSC_EXPORTS TSCBasic)

Sources/TSCBasic/FileSystem.swift

@@ -58,6 +58,12 @@ public enum FileSystemError: Swift.Error {
 
     /// An unspecific operating system error.
     case unknownOSError
+
+    /// File or folder already exists at destination.
+    ///
+    /// This is thrown when copying or moving a file or directory but the destination
+    /// path already contains a file or folder.
+    case alreadyExistsAtDestination
 }
 
 extension FileSystemError {
@@ -179,11 +185,16 @@ public protocol FileSystem: class {
     /// Change file mode.
     func chmod(_ mode: FileMode, path: AbsolutePath, options: Set<FileMode.Option>) throws
 
-
     /// Returns the file info of the given path.
     ///
     /// The method throws if the underlying stat call fails.
     func getFileInfo(_ path: AbsolutePath) throws -> FileInfo
+
+    /// Copy a file or directory.
+    func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws
+
+    /// Move a file or directory.
+    func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws
 }
 
 /// Convenience implementations (default arguments aren't permitted in protocol
@@ -408,6 +419,18 @@ private class LocalFileSystem: FileSystem {
             try setMode(path: (path as! URL).path)
         }
     }
+
+    func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
+        guard exists(sourcePath) else { throw FileSystemError.noEntry }
+        guard !exists(destinationPath) else { throw FileSystemError.alreadyExistsAtDestination }
+        try FileManager.default.copyItem(at: sourcePath.asURL, to: destinationPath.asURL)
+    }
+
+    func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
+        guard exists(sourcePath) else { throw FileSystemError.noEntry }
+        guard !exists(destinationPath) else { throw FileSystemError.alreadyExistsAtDestination }
+        try FileManager.default.moveItem(at: sourcePath.asURL, to: destinationPath.asURL)
+    }
 }
 
 // FIXME: This class does not yet support concurrent mutation safely.
@@ -675,6 +698,45 @@ public class InMemoryFileSystem: FileSystem {
     public func chmod(_ mode: FileMode, path: AbsolutePath, options: Set<FileMode.Option>) throws {
         // FIXME: We don't have these semantics in InMemoryFileSystem.
     }
+
+    public func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
+        // Get the source node.
+        guard let source = try getNode(sourcePath) else {
+            throw FileSystemError.noEntry
+        }
+
+        // Create directory to destination parent.
+        guard let destinationParent = try getNode(destinationPath.parentDirectory) else {
+            throw FileSystemError.noEntry
+        }
+
+        // Check that the parent is a directory.
+        guard case .directory(let contents) = destinationParent.contents else {
+            throw FileSystemError.notDirectory
+        }
+
+        guard contents.entries[destinationPath.basename] == nil else {
+            throw FileSystemError.alreadyExistsAtDestination
+        }
+
+        contents.entries[destinationPath.basename] = source
+    }
+
+    public func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
+        // Get the source parent node.
+        guard let sourceParent = try getNode(sourcePath.parentDirectory) else {
+            throw FileSystemError.noEntry
+        }
+
+        // Check that the parent is a directory.
+        guard case .directory(let contents) = sourceParent.contents else {
+            throw FileSystemError.notDirectory
+        }
+
+        try copy(from: sourcePath, to: destinationPath)
+
+        contents.entries[sourcePath.basename] = nil
+    }
 }
 
 /// A rerooted view on an existing FileSystem.
@@ -767,6 +829,14 @@ public class RerootedFileSystemView: FileSystem {
     public func chmod(_ mode: FileMode, path: AbsolutePath, options: Set<FileMode.Option>) throws {
         try underlyingFileSystem.chmod(mode, path: path, options: options)
     }
+
+    public func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
+        try underlyingFileSystem.copy(from: formUnderlyingPath(sourcePath), to: formUnderlyingPath(sourcePath))
+    }
+
+    public func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
+        try underlyingFileSystem.move(from: formUnderlyingPath(sourcePath), to: formUnderlyingPath(sourcePath))
+    }
 }
 
 /// Public access to the local FS proxy.

Sources/TSCBasic/OutputByteStream.swift

@@ -651,7 +651,7 @@ public final class LocalFileOutputByteStream: FileOutputByteStream {
     private var closeOnDeinit: Bool
 
     /// Instantiate using the file pointer.
-    init(filePointer: UnsafeMutablePointer<FILE>, closeOnDeinit: Bool = true, buffered: Bool = true) throws {
+    public init(filePointer: UnsafeMutablePointer<FILE>, closeOnDeinit: Bool = true, buffered: Bool = true) throws {
         self.filePointer = filePointer
         self.closeOnDeinit = closeOnDeinit
         super.init(buffered: buffered)

Sources/TSCLibc/CMakeLists.txt

@@ -26,3 +26,5 @@ install(TARGETS TSCLibc
   LIBRARY DESTINATION lib
   RUNTIME DESTINATION bin)
 endif()
+
+set_property(GLOBAL APPEND PROPERTY TSC_EXPORTS TSCLibc)

Sources/TSCTestSupport/PseudoTerminal.swift

@@ -8,7 +8,7 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
  */
 
-@testable import TSCBasic
+import TSCBasic
 import TSCLibc
 
 public final class PseudoTerminal {

Sources/TSCTestSupport/XCTAssertHelpers.swift

@@ -47,7 +47,7 @@ public func XCTAssertThrows<T: Swift.Error>(
     } catch let error as T {
         XCTAssertEqual(error, expectedError, file: file, line: line)
     } catch {
-        XCTFail("unexpected error thrown", file: file, line: line)
+        XCTFail("unexpected error thrown: \(error)", file: file, line: line)
     }
 }
 
@@ -61,9 +61,9 @@ public func XCTAssertThrows<T: Swift.Error, Ignore>(
         let result = try expression()
         XCTFail("body completed successfully: \(result)", file: file, line: line)
     } catch let error as T {
-        XCTAssertTrue(errorHandler(error), "Error handler returned false")
+        XCTAssertTrue(errorHandler(error), "Error handler returned false", file: file, line: line)
     } catch {
-        XCTFail("unexpected error thrown", file: file, line: line)
+        XCTFail("unexpected error thrown: \(error)", file: file, line: line)
     }
 }
 
@@ -83,6 +83,76 @@ public func XCTNonNil<T>(
     }
 }
 
+public func XCTAssertResultSuccess<Success, Failure: Error>(
+    _ result: Result<Success, Failure>,
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    switch result {
+    case .success:
+        return
+    case .failure(let error):
+        XCTFail("unexpected error: \(error)", file: file, line: line)
+    }
+}
+
+public func XCTAssertResultSuccess<Success, Failure: Error>(
+    _ result: Result<Success, Failure>,
+    file: StaticString = #file,
+    line: UInt = #line,
+    _ body: (Success) throws -> Void
+) rethrows {
+    switch result {
+    case .success(let value):
+        try body(value)
+    case .failure(let error):
+        XCTFail("unexpected error: \(error)", file: file, line: line)
+    }
+}
+
+public func XCTAssertResultFailure<Success, Failure: Error>(
+    _ result: Result<Success, Failure>,
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    switch result {
+    case .success(let value):
+        XCTFail("unexpected success: \(value)", file: file, line: line)
+    case .failure:
+        return
+    }
+}
+
+public func XCTAssertResultFailure<Success, Failure: Error, ExpectedFailure: Error>(
+    _ result: Result<Success, Failure>,
+    equals expectedError: ExpectedFailure,
+    file: StaticString = #file,
+    line: UInt = #line
+) where ExpectedFailure: Equatable {
+    switch result {
+    case .success(let value):
+        XCTFail("unexpected success: \(value)", file: file, line: line)
+    case .failure(let error as ExpectedFailure):
+        XCTAssertEqual(error, expectedError, file: file, line: line)
+    case .failure(let error):
+        XCTFail("unexpected error: \(error)", file: file, line: line)
+    }
+}
+
+public func XCTAssertResultFailure<Success, Failure: Error>(
+    _ result: Result<Success, Failure>,
+    file: StaticString = #file,
+    line: UInt = #line,
+    _ body: (Failure) throws -> Void
+) rethrows {
+    switch result {
+    case .success(let value):
+        XCTFail("unexpected success: \(value)", file: file, line: line)
+    case .failure(let error):
+        try body(error)
+    }
+}
+
 public func XCTAssertNoDiagnostics(_ engine: DiagnosticsEngine, file: StaticString = #file, line: UInt = #line) {
     let diagnostics = engine.diagnostics
     if diagnostics.isEmpty { return }

Sources/TSCTestSupport/XCTestCasePerf.swift

@@ -9,17 +9,20 @@
 */
 
 import XCTest
+import TSCBasic
 
 /// A helper class to write performance tests for SwiftPM.
 ///
 /// Subclasses of this will always build the tests but only run
-/// run the tests when ENABLE_PERF_TESTS is defined. This is very
-/// useful because we always want to be able to compile the perf tests
+/// run the tests when `TSC_ENABLE_PERF_TESTS` is present in the environment.
+/// This is useful because we always want to be able to compile the perf tests
 /// even if they are not run locally.
 open class XCTestCasePerf: XCTestCase {
-
-  #if os(macOS) && !ENABLE_PERF_TESTS
+  #if os(macOS)
     override open class var defaultTestSuite: XCTestSuite {
+        if ProcessEnv.vars.keys.contains("TSC_ENABLE_PERF_TESTS") {
+            return super.defaultTestSuite
+        }
         return XCTestSuite(name: String(describing: type(of: self)))
     }
   #endif

Sources/TSCUtility/Archiver.swift

@@ -0,0 +1,76 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2014 - 2019 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 Swift project authors
+*/
+
+import TSCBasic
+import Dispatch
+
+/// The `Archiver` protocol abstracts away the different operations surrounding archives.
+public protocol Archiver {
+
+    /// A set of extensions the current archiver supports.
+    var supportedExtensions: Set<String> { get }
+
+    /// Asynchronously extracts the contents of an archive to a destination folder.
+    ///
+    /// - Parameters:
+    ///   - archivePath: The `AbsolutePath` to the archive to extract.
+    ///   - destinationPath: The `AbsolutePath` to the directory to extract to.
+    ///   - completion: The completion handler that will be called when the operation finishes to notify of its success.
+    func extract(
+        from archivePath: AbsolutePath,
+        to destinationPath: AbsolutePath,
+        completion: @escaping (Result<Void, Error>) -> Void
+    )
+}
+
+/// An `Archiver` that handles ZIP archives using the command-line `zip` and `unzip` tools.
+public struct ZipArchiver: Archiver {
+    public var supportedExtensions: Set<String> { ["zip"] }
+
+    /// The file-system implementation used for various file-system operations and checks.
+    private let fileSystem: FileSystem
+
+    /// Creates a `ZipArchiver`.
+    ///
+    /// - Parameters:
+    ///   - fileSystem: The file-system to used by the `ZipArchiver`.
+    public init(fileSystem: FileSystem = localFileSystem) {
+        self.fileSystem = fileSystem
+    }
+
+    public func extract(
+        from archivePath: AbsolutePath,
+        to destinationPath: AbsolutePath,
+        completion: @escaping (Result<Void, Error>) -> Void
+    ) {
+        guard fileSystem.exists(archivePath) else {
+            completion(.failure(FileSystemError.noEntry))
+            return
+        }
+
+        guard fileSystem.isDirectory(destinationPath) else {
+            completion(.failure(FileSystemError.notDirectory))
+            return
+        }
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                let result = try Process.popen(args: "unzip", archivePath.pathString, "-d", destinationPath.pathString)
+                guard result.exitStatus == .terminated(code: 0) else {
+                    throw try StringError(result.utf8stderrOutput())
+                }
+
+                completion(.success(()))
+            } catch {
+                completion(.failure(error))
+            }
+        }
+    }
+}

Sources/TSCUtility/CMakeLists.txt

@@ -34,3 +34,5 @@ target_link_libraries(TSCUtility PUBLIC
 # NOTE(compnerd) workaround for CMake not setting up include flags yet
 set_target_properties(TSCUtility PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
+
+set_property(GLOBAL APPEND PROPERTY TSC_EXPORTS TSCUtility)

Sources/TSCUtility/CollectionExtensions.swift

@@ -10,7 +10,7 @@
 
 extension Collection where Iterator.Element : Equatable {
     /// Split around a delimiting subsequence with maximum number of splits == 2
-    func spm_split(around delimiter: [Iterator.Element]) -> ([Iterator.Element], [Iterator.Element]?) {
+    public func spm_split(around delimiter: [Iterator.Element]) -> ([Iterator.Element], [Iterator.Element]?) {
 
         let orig = Array(self)
         let end = orig.endIndex