[SR-7836] Added swift package update --dry-run (#2380)

* [SR-7836] Added swift package update --dry-run

- Added swift package --dry-run
- Added prettyPrinted to Requirement
- Added tests

* removed unused function

* replaced guard with if

Author: tgymnich

Sources/Commands/SwiftPackageTool.swift

@@ -151,10 +151,18 @@ public class SwiftPackageTool: SwiftTool<PackageToolOptions> {
 
         case .update:
             let workspace = try getActiveWorkspace()
-            try workspace.updateDependencies(
+            
+            let changes = try workspace.updateDependencies(
                 root: getWorkspaceRoot(),
-                diagnostics: diagnostics
+                diagnostics: diagnostics,
+                dryRun: options.updateDryRun
             )
+            
+            if let pinsStore = diagnostics.wrap({ try workspace.pinsStore.load() }),
+                let changes = changes,
+                options.updateDryRun {
+                logPackageChanges(changes: changes, pins: pinsStore)
+            }
 
         case .fetch:
             diagnostics.emit(warning: "'fetch' command is deprecated; use 'resolve' instead")
@@ -371,7 +379,13 @@ public class SwiftPackageTool: SwiftTool<PackageToolOptions> {
         parser.add(subparser: PackageMode.clean.rawValue, overview: "Delete build artifacts")
         parser.add(subparser: PackageMode.fetch.rawValue, overview: "")
         parser.add(subparser: PackageMode.reset.rawValue, overview: "Reset the complete cache/build directory")
-        parser.add(subparser: PackageMode.update.rawValue, overview: "Update package dependencies")
+        
+        let updateParser = parser.add(subparser: PackageMode.update.rawValue, overview: "Update package dependencies")
+        binder.bind(
+        option: updateParser.add(
+            option: "--dry-run", shortName: "-n", kind: Bool.self,
+            usage: "Display the list of dependencies that can be updated"),
+            to: { $0.updateDryRun = $1 })
 
         let formatParser = parser.add(subparser: PackageMode.format.rawValue, overview: "")
         binder.bindArray(
@@ -622,6 +636,8 @@ public class PackageToolOptions: ToolOptions {
         case setCurrent
     }
     var toolsVersionMode: ToolsVersionMode = .display
+    
+    var updateDryRun = false
 
     enum ConfigMode: String {
         case setMirror = "set-mirror"
@@ -727,3 +743,34 @@ private extension Diagnostic.Message {
         .error("missing required argument \(argument)")
     }
 }
+
+fileprivate extension SwiftPackageTool {
+    /// Logs all changed dependencies to a stream
+    /// - Parameter changes: Changes to log
+    /// - Parameter pins: PinsStore with currently pinned packages to compare changed packages to.
+    /// - Parameter stream: Stream used for logging
+    func logPackageChanges(changes: [(PackageReference, Workspace.PackageStateChange)], pins: PinsStore, on stream: OutputByteStream = stdoutStream) {
+        let changes = changes.filter { $0.1 != .unchanged }
+        
+        stream <<< "\n"
+        stream <<< "\(changes.count) dependenc\(changes.count == 1 ? "y has" : "ies have") changed\(changes.count > 0 ? ":" : ".")"
+        stream <<< "\n"
+        
+        for (package, change) in changes {
+            guard let packageName = package.name else { continue }
+            let currentVersion = pins.pinsMap[package.identity]?.state.description ?? ""
+            switch change {
+            case let .added(requirement):
+                stream <<< "+ \(packageName) \(requirement.prettyPrinted)"
+            case let .updated(requirement):
+                stream <<< "~ \(packageName) \(currentVersion) -> \(packageName) \(requirement.prettyPrinted)"
+            case .removed:
+                stream <<< "- \(packageName) \(currentVersion)"
+            case .unchanged:
+                continue
+            }
+            stream <<< "\n"
+        }
+        stream.flush()
+    }
+}

Sources/SPMTestSupport/TestWorkspace.swift

@@ -249,6 +249,20 @@ public final class TestWorkspace {
         workspace.updateDependencies(root: rootInput, diagnostics: diagnostics)
         result(diagnostics)
     }
+    
+    public func checkUpdateDryRun(
+        roots: [String] = [],
+        deps: [TestWorkspace.PackageDependency] = [],
+        _ result: ([(PackageReference, Workspace.PackageStateChange)]?, DiagnosticsEngine) -> ()
+    ) {
+        let dependencies = deps.map({ $0.convert(packagesDir) })
+        let diagnostics = DiagnosticsEngine()
+        let workspace = createWorkspace()
+        let rootInput = PackageGraphRootInput(
+            packages: rootPaths(for: roots), dependencies: dependencies)
+        let changes = workspace.updateDependencies(root: rootInput, diagnostics: diagnostics, dryRun: true)
+        result(changes, diagnostics)
+    }
 
     public func checkPackageGraph(
         roots: [String] = [],

Sources/TSCTestSupport/XCTAssertHelpers.swift

@@ -89,3 +89,8 @@ public func XCTAssertNoDiagnostics(_ engine: DiagnosticsEngine, file: StaticStri
     let diags = engine.diagnostics.map({ "- " + $0.description }).joined(separator: "\n")
     XCTFail("Found unexpected diagnostics: \n\(diags)", file: file, line: line)
 }
+
+public func XCTAssertEqual<T:Equatable, U:Equatable> (_ lhs:(T,U), _ rhs:(T,U), file: StaticString = #file, line: UInt = #line) {
+    XCTAssertEqual(lhs.0, rhs.0)
+    XCTAssertEqual(lhs.1, rhs.1)
+}

Sources/Workspace/Workspace.swift

@@ -597,10 +597,11 @@ extension Workspace {
     /// - Parameters:
     ///     - diagnostics: The diagnostics engine that reports errors, warnings
     ///       and notes.
-    public func updateDependencies(
+    @discardableResult public func updateDependencies(
         root: PackageGraphRootInput,
-        diagnostics: DiagnosticsEngine
-    ) {
+        diagnostics: DiagnosticsEngine,
+        dryRun: Bool = false
+    ) -> [(PackageReference, Workspace.PackageStateChange)]? {
         // Create cache directories.
         createCacheDirectories(with: diagnostics)
 
@@ -615,12 +616,10 @@ extension Workspace {
         let currentManifests = loadDependencyManifests(root: graphRoot, diagnostics: diagnostics)
 
         // Abort if we're unable to load the pinsStore or have any diagnostics.
-        guard let pinsStore = diagnostics.wrap({ try self.pinsStore.load() }) else {
-            return
-        }
+        guard let pinsStore = diagnostics.wrap({ try self.pinsStore.load() }) else { return nil }
 
         // Ensure we don't have any error at this point.
-        guard !diagnostics.hasErrors else { return }
+        guard !diagnostics.hasErrors else { return nil }
 
         // Add unversioned constraints for edited packages.
         var updateConstraints = currentManifests.editedPackagesConstraints()
@@ -637,23 +636,29 @@ extension Workspace {
         // Reset the active resolver.
         activeResolver = nil
 
-        guard !diagnostics.hasErrors else { return }
+        guard !diagnostics.hasErrors else { return nil }
+        
+        if dryRun {
+            return diagnostics.wrap { return try computePackageStateChanges(root: graphRoot, resolvedDependencies: updateResults, updateBranches: true) }
+        }
 
         // Update the checkouts based on new dependency resolution.
         updateCheckouts(root: graphRoot, updateResults: updateResults, updateBranches: true, diagnostics: diagnostics)
 
         // Load the updated manifests.
         let updatedDependencyManifests = loadDependencyManifests(root: graphRoot, diagnostics: diagnostics)
 
-        guard !diagnostics.hasErrors else { return }
+        guard !diagnostics.hasErrors else { return nil }
 
         // Update the pins store.
-        return pinAll(
+        pinAll(
             dependencyManifests: updatedDependencyManifests,
             pinsStore: pinsStore,
             diagnostics: diagnostics)
+        
+        return nil
     }
-
+    
     /// Loads a package graph from a root package using the resources associated with a particular `swiftc` executable.
     ///
     /// - Parameters:
@@ -1524,10 +1529,10 @@ extension Workspace {
     }
 
     /// This enum represents state of an external package.
-    fileprivate enum PackageStateChange: Equatable, CustomStringConvertible {
+    public enum PackageStateChange: Equatable, CustomStringConvertible {
 
         /// The requirement imposed by the the state.
-        enum Requirement: Equatable, CustomStringConvertible {
+        public enum Requirement: Equatable, CustomStringConvertible {
             /// A version requirement.
             case version(Version)
 
@@ -1536,7 +1541,7 @@ extension Workspace {
 
             case unversioned
 
-            var description: String {
+            public var description: String {
                 switch self {
                 case .version(let version):
                     return "requirement(\(version))"
@@ -1546,6 +1551,17 @@ extension Workspace {
                     return "requirement(unversioned)"
                 }
             }
+            
+            public var prettyPrinted: String {
+                switch self {
+                case .version(let version):
+                    return "\(version)"
+                case .revision(let revision, let branch):
+                    return "\(revision) \(branch ?? "")"
+                case .unversioned:
+                    return "unversioned"
+                }
+            }
         }
 
         /// The package is added.
@@ -1560,7 +1576,7 @@ extension Workspace {
         /// The package is updated.
         case updated(Requirement)
 
-        var description: String {
+        public var description: String {
             switch self {
             case .added(let requirement):
                 return "added(\(requirement))"

Tests/WorkspaceTests/WorkspaceTests.swift

@@ -986,6 +986,90 @@ final class WorkspaceTests: XCTestCase {
         }
         XCTAssertMatch(workspace.delegate.events, [.equal("Everything is already up-to-date")])
     }
+    
+    func testUpdateDryRun() throws {
+        let sandbox = AbsolutePath("/tmp/ws/")
+        let fs = InMemoryFileSystem()
+
+        let workspace = try TestWorkspace(
+            sandbox: sandbox,
+            fs: fs,
+            roots: [
+                TestPackage(
+                    name: "Root",
+                    targets: [
+                        TestTarget(name: "Root", dependencies: ["Foo"]),
+                    ],
+                    products: [
+                        TestProduct(name: "Root", targets: ["Root"]),
+                    ],
+                    dependencies: [
+                        TestDependency(name: "Foo", requirement: .upToNextMajor(from: "1.0.0")),
+                    ]
+                ),
+            ],
+            packages: [
+                TestPackage(
+                    name: "Foo",
+                    targets: [
+                        TestTarget(name: "Foo"),
+                    ],
+                    products: [
+                        TestProduct(name: "Foo", targets: ["Foo"]),
+                    ],
+                    versions: ["1.0.0"]
+                ),
+                TestPackage(
+                    name: "Foo",
+                    targets: [
+                        TestTarget(name: "Foo"),
+                    ],
+                    products: [
+                        TestProduct(name: "Foo", targets: ["Foo"]),
+                    ],
+                    versions: ["1.5.0"]
+                ),
+            ]
+        )
+        
+        // Do an intial run, capping at Foo at 1.0.0.
+        let deps: [TestWorkspace.PackageDependency] = [
+            .init(name: "Foo", requirement: .exact("1.0.0")),
+        ]
+
+        workspace.checkPackageGraph(roots: ["Root"], deps: deps) { (graph, diagnostics) in
+            PackageGraphTester(graph) { result in
+                result.check(roots: "Root")
+                result.check(packages: "Foo", "Root")
+            }
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+        }
+
+        // Run update.
+        workspace.checkUpdateDryRun(roots: ["Root"]) { changes, diagnostics in
+            XCTAssertNoDiagnostics(diagnostics)
+            let expectedChange = (PackageReference(identity: "foo", path: "/tmp/ws/pkgs/Foo"),
+                Workspace.PackageStateChange.updated(.version(Version("1.5.0"))))
+            guard let change = changes?.first, changes?.count == 1 else {
+                XCTFail()
+                return
+            }
+            XCTAssertEqual(expectedChange, change)
+        }
+        workspace.checkPackageGraph(roots: ["Root"]) { (graph, diagnostics) in
+            PackageGraphTester(graph) { result in
+                result.check(roots: "Root")
+                result.check(packages: "Foo", "Root")
+            }
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+        }
+    }
 
     func testCleanAndReset() throws {
         let sandbox = AbsolutePath("/tmp/ws/")

Tests/WorkspaceTests/XCTestManifests.swift

@@ -88,6 +88,7 @@ extension WorkspaceTests {
         ("testTransitiveDependencySwitchWithSameIdentity", testTransitiveDependencySwitchWithSameIdentity),
         ("testUnsafeFlags", testUnsafeFlags),
         ("testUpdate", testUpdate),
+        ("testUpdateDryRun", testUpdateDryRun),
     ]
 }