[Commands] Add Workspace support for loading current manifest tree.

 - The versions in the manifests are not properly preserved yet...

Author: ddunbar

Sources/Commands/Workspace.swift

@@ -9,6 +9,8 @@
 */
 
 import Basic
+import PackageLoading
+import PackageModel
 import SourceControl
 import Utility
 
@@ -80,7 +82,10 @@ public class Workspace {
 
     /// The path for working repository clones (checkouts).
     let checkoutsPath: AbsolutePath
-    
+
+    /// The manifest loader to use.
+    let manifestLoader: ManifestLoaderProtocol
+
     /// The checkout manager.
     private let checkoutManager: CheckoutManager
 
@@ -92,7 +97,7 @@ public class Workspace {
         return AnySequence<ManagedDependency>(dependencyMap.values)
     }
 
-    /// Create a new manager for the package at the given path.
+    /// Create a new workspace for the package at the given path.
     ///
     /// This will automatically load the persisted state for the package, if
     /// present. If the state isn't present then a default state will be
@@ -101,10 +106,17 @@ public class Workspace {
     /// - Parameters:
     ///   - path: The path of the root package.
     ///   - dataPath: The path for the workspace data files, if explicitly provided.
+    ///   - manifestLoader: The manifest loader.
     /// - Throws: If the state was present, but could not be loaded.
-    public init(rootPackage path: AbsolutePath, dataPath: AbsolutePath? = nil) throws {
+    public init(
+        rootPackage path: AbsolutePath,
+        dataPath: AbsolutePath? = nil,
+        manifestLoader: ManifestLoaderProtocol
+    ) throws {
         self.rootPackagePath = path
         self.dataPath = dataPath ?? path.appending(component: ".build")
+        self.manifestLoader = manifestLoader
+
         let repositoriesPath = self.dataPath.appending(component: "repositories")
         self.checkoutManager = CheckoutManager(path: repositoriesPath, provider: GitRepositoryProvider())
         self.checkoutsPath = self.dataPath.appending(component: "checkouts")
@@ -195,7 +207,42 @@ public class Workspace {
 
         return path
     }
-    
+
+    /// Load the manifests for the current dependency tree.
+    ///
+    /// This will load the manifests for the root package as well as all the
+    /// current dependencies from the working checkouts.
+    ///
+    /// Throws: If the root manifest could not be loaded.
+    func loadDependencyManifests() throws -> (root: Manifest, dependencies: [Manifest]) {
+        // Load the root manifest.
+        let rootManifest = try manifestLoader.load(packagePath: rootPackagePath, baseURL: rootPackagePath.asString, version: nil)
+
+        // Compute the transitive closure of available dependencies.
+        let dependencies = transitiveClosure([KeyedPair(rootManifest, key: rootManifest.url)]) { node in
+            return node.item.package.dependencies.flatMap{ dependency in
+                // Check if this dependency is available.
+                guard let managedDependency = dependencyMap[RepositorySpecifier(url: dependency.url)] else {
+                    return nil
+                }
+
+                // If so, load its manifest.
+                //
+                // This should *never* fail, because we should only have ever
+                // got this checkout via loading its manifest successfully.
+                //
+                // FIXME: Nevertheless, we should handle this failure explicitly.
+                //
+                // FIXME: We need to have the correct version to pass here.
+                let manifest: Manifest = try! manifestLoader.load(packagePath: checkoutsPath.appending(managedDependency.subpath), baseURL: managedDependency.repository.url, version: nil)
+
+                return KeyedPair(manifest, key: manifest.url)
+            }
+        }
+
+        return (root: rootManifest, dependencies: dependencies.map{ $0.item })
+    }
+
     // MARK: Persistence
 
     // FIXME: A lot of the persistence mechanism here is copied from

Sources/TestSupport/MockManifestLoader.swift

@@ -55,7 +55,7 @@ public struct MockManifestLoader: ManifestLoaderProtocol {
         version: PackageDescription.Version?,
         fileSystem: FileSystem?
     ) throws -> PackageModel.Manifest {
-        if let result = manifests[Key(url: baseURL, version: version!)] {
+        if let result = manifests[Key(url: baseURL, version: version)] {
             return result
         }
         throw MockManifestLoaderError.unknownRequest

Tests/CommandsTests/WorkspaceTests.swift

@@ -12,13 +12,29 @@ import XCTest
 
 import Basic
 import Commands
+import PackageDescription
+import PackageLoading
+import PackageModel
 import SourceControl
 import Utility
 
+import struct TestSupport.MockManifestLoader
+
 import TestSupport
 
 @testable import class Commands.Workspace
 
+private let sharedManifestLoader = ManifestLoader(resources: Resources())
+
+extension Workspace {
+    convenience init(rootPackage path: AbsolutePath) throws {
+        try self.init(rootPackage: path, manifestLoader: sharedManifestLoader)
+    }
+}
+
+private let v1: Version = "1.0.0"
+private let v2: Version = "2.0.0"
+
 final class WorkspaceTests: XCTestCase {
     func testBasics() throws {
         mktmpdir { path in
@@ -83,7 +99,84 @@ final class WorkspaceTests: XCTestCase {
         }
     }
 
+    func testDependencyManifestLoading() {
+        // We mock up the following dep graph:
+        //
+        // Root
+        // \ A: checked out (@v1)
+        //   \ AA: checked out (@v2)
+        // \ B: missing
+        
+        mktmpdir { path in
+            // Create the test repositories, we don't need them to have actual
+            // contents (the manifests are mocked).
+            var repos: [String: RepositorySpecifier] = [:]
+            for name in ["A", "AA"] {
+                let repoPath = path.appending(component: name)
+                try makeDirectories(repoPath)
+                initGitRepo(repoPath, tag: "initial")
+                repos[name] = RepositorySpecifier(url: repoPath.asString)
+            }
+
+            // Create the mock manifests.
+            let rootManifest = Manifest(
+                path: AbsolutePath("/UNUSED"),
+                url: path.asString,
+                package: PackageDescription.Package(
+                    name: "Root",
+                    dependencies: [
+                        .Package(url: repos["A"]!.url, majorVersion: 1),
+                        .Package(url: "//B", majorVersion: 1)
+                    ]),
+                products: [],
+                version: nil
+            )
+            let aManifest = Manifest(
+                path: AbsolutePath("/UNUSED"),
+                url: repos["A"]!.url,
+                package: PackageDescription.Package(
+                    name: "A",
+                    dependencies: [
+                        .Package(url: repos["AA"]!.url, majorVersion: 2)
+                    ]),
+                products: [],
+                version: v1
+            )
+            let aaManifest = Manifest(
+                path: AbsolutePath("/UNUSED"),
+                url: repos["AA"]!.url,
+                package: PackageDescription.Package(
+                    name: "AA"),
+                products: [],
+                version: v2
+            )
+            let mockManifestLoader = MockManifestLoader(manifests: [
+                    MockManifestLoader.Key(url: path.asString, version: nil): rootManifest,
+                    // FIXME: These versions are wrong, we aren't preserving versions currently.
+                    MockManifestLoader.Key(url: repos["A"]!.url, version: nil): aManifest,
+                    MockManifestLoader.Key(url: repos["AA"]!.url, version: nil): aaManifest
+                ])
+                    
+            // Create the workspace.
+            let workspace = try Workspace(rootPackage: path, manifestLoader: mockManifestLoader)
+
+            // Ensure we have checkouts for A & AA.
+            for name in ["A", "AA"] {
+                let revision = try GitRepository(path: AbsolutePath(repos[name]!.url)).getCurrentRevision()
+                _ = try workspace.clone(repository: repos[name]!, at: revision)
+            }
+
+            // Load the "current" manifests.
+            let manifests = try workspace.loadDependencyManifests()
+            XCTAssertEqual(manifests.root.package, rootManifest.package)
+            XCTAssertEqual(manifests.dependencies.map{ $0.package.name }.sorted(), ["A", "AA"])
+
+            // FIXME: These manifests do not have the right versions in them, and they should.
+        }
+    }
+
     static var allTests = [
         ("testBasics", testBasics),
+        ("testDependencyManifestLoading", testDependencyManifestLoading),
     ]
 }