[PackageLoading] Split out function which loads a specific manifest file.

 - This should become private eventually, we want to define loading in terms of
   a complete package not just the manifest (in case in the future we expose
   other parts of the package to the manifest loading process).

Author: ddunbar

Sources/Commands/SwiftPackageTool.swift

@@ -224,7 +224,7 @@ public struct SwiftPackageTool: SwiftTool {
 
             case .dumpPackage:
                 let root = opts.inputPath ?? opts.path.root
-                let manifest = try packageGraphLoader.manifestLoader.load(path: root, baseURL: root.asString, version: nil)
+                let manifest = try packageGraphLoader.manifestLoader.loadFile(path: root, baseURL: root.asString, version: nil)
                 let package = manifest.package
                 let json = try jsonString(package: package)
                 print(json)

Sources/Get/PackagesDirectory.swift

@@ -68,7 +68,7 @@ public final class PackagesDirectory {
     /// - Throws: Error.InvalidDependencyGraph
     public func loadManifests(ignoreDependencies: Bool = false) throws -> (rootManifest: Manifest, externalManifests: [Manifest]) {
         // Load the manifest for the root package.
-        let manifest = try manifestLoader.load(path: rootPath, baseURL: rootPath.asString, version: nil)
+        let manifest = try manifestLoader.load(packagePath: rootPath, baseURL: rootPath.asString, version: nil)
         if ignoreDependencies {
             return (manifest, [])
         }
@@ -114,7 +114,7 @@ extension PackagesDirectory: Fetcher {
             return nil
         }
 
-        return try manifestLoader.load(path: repo.path, baseURL: origin, version: version)
+        return try manifestLoader.load(packagePath: repo.path, baseURL: origin, version: version)
     }
 
     func find(url: String) throws -> Fetchable? {
@@ -126,7 +126,7 @@ extension PackagesDirectory: Fetcher {
 
     func fetch(url: String) throws -> Fetchable {
         // Clone into a staging location, we will rename it once all versions are selected.
-        let manifestParser = { try self.manifestLoader.load(path: $0, baseURL: $1, version: $2) }
+        let manifestParser = { try self.manifestLoader.load(packagePath: $0, baseURL: $1, version: $2) }
         let basename = url.components(separatedBy: "/").last!
         let dstdir = packagesPath.appending(component: basename)
         if let repo = Git.Repo(path: dstdir), repo.origin == url {

Sources/PackageLoading/ManifestLoader.swift

@@ -50,20 +50,34 @@ public final class ManifestLoader {
         self.resources = resources
     }
 
-    /// Create a manifest by loading from the given `path`.
+    /// Load the manifest for the package at `path`.
     ///
     /// - Parameters:
-    ///   - path: The path to the manifest file or directory containing `Package.swift`.
+    ///   - path: The root path of the package.
     ///   - baseURL: The URL the manifest was loaded from.
     ///   - version: The version the manifest is from, if known.
     ///   - fileSystem: If given, the file system to load from (otherwise load from the local file system).
-    public func load(path inputPath: AbsolutePath, baseURL: String, version: Version?, fileSystem: FileSystem? = nil) throws -> Manifest {
+    public func load(packagePath: AbsolutePath, baseURL: String, version: Version?, fileSystem: FileSystem? = nil) throws -> Manifest {
+        return try loadFile(path: packagePath.appending(component: Manifest.filename), baseURL: baseURL, version: version, fileSystem: fileSystem)
+    }
+
+    /// Create a manifest by loading a specific manifest file from the given `path`.
+    ///
+    /// - Parameters:
+    ///   - path: The path to the manifest file (or a package root).
+    ///   - baseURL: The URL the manifest was loaded from.
+    ///   - version: The version the manifest is from, if known.
+    ///   - fileSystem: If given, the file system to load from (otherwise load from the local file system).
+    //
+    // FIXME: We should stop exposing this publicly, from a public perspective
+    // we should only ever load complete repositories.
+    public func loadFile(path inputPath: AbsolutePath, baseURL: String, version: Version?, fileSystem: FileSystem? = nil) throws -> Manifest {
         // If we were given a file system, load via a temporary file.
         if let fileSystem = fileSystem {
             let tmpFile = try TemporaryFile()
             let contents = try fileSystem.readFileContents(inputPath)
             try localFileSystem.writeFileContents(tmpFile.path, bytes: contents)
-            return try load(path: tmpFile.path, baseURL: baseURL, version: version)
+            return try loadFile(path: tmpFile.path, baseURL: baseURL, version: version)
         }
 
         guard baseURL.chuzzle() != nil else { fatalError() }  //TODO

Tests/PackageLoadingTests/ManifestTests.swift

@@ -59,7 +59,7 @@ class ManifestTests: XCTestCase {
     private func loadManifest(_ inputName: String, line: UInt = #line, body: (Manifest) -> Void) {
         do {
             let input = AbsolutePath(#file).parentDirectory.appending(component: "Inputs").appending(component: inputName)
-            body(try ManifestLoader(resources: Resources()).load(path: input, baseURL: input.parentDirectory.asString, version: nil))
+            body(try ManifestLoader(resources: Resources()).loadFile(path: input, baseURL: input.parentDirectory.asString, version: nil))
         } catch {
             XCTFail("Unexpected error: \(error)", file: #file, line: line)
         }
@@ -70,7 +70,7 @@ class ManifestTests: XCTestCase {
             let fs = InMemoryFileSystem()
             let manifestPath = AbsolutePath.root.appending(component: Manifest.filename)
             try fs.writeFileContents(manifestPath, bytes: contents)
-            body(try ManifestLoader(resources: Resources()).load(path: manifestPath, baseURL: AbsolutePath.root.asString, version: nil, fileSystem: fs))
+            body(try ManifestLoader(resources: Resources()).loadFile(path: manifestPath, baseURL: AbsolutePath.root.asString, version: nil, fileSystem: fs))
         } catch {
             XCTFail("Unexpected error: \(error)", file: #file, line: line)
         }
@@ -115,14 +115,14 @@ class ManifestTests: XCTestCase {
     }
 
     func testNoManifest() {
-        let foo = try? ManifestLoader(resources: Resources()).load(path: AbsolutePath("/non-existent-file"), baseURL: "/", version: nil)
+        let foo = try? ManifestLoader(resources: Resources()).loadFile(path: AbsolutePath("/non-existent-file"), baseURL: "/", version: nil)
         XCTAssertNil(foo)
     }
 
     func testInvalidTargetName() {
         fixture(name: "Miscellaneous/PackageWithInvalidTargets") { (prefix: AbsolutePath) in
             do {
-                let manifest = try ManifestLoader(resources: Resources()).load(path: prefix.appending(component: "Package.swift"), baseURL: prefix.asString, version: nil)
+                let manifest = try ManifestLoader(resources: Resources()).loadFile(path: prefix.appending(component: "Package.swift"), baseURL: prefix.asString, version: nil)
                 _ = try PackageBuilder(manifest: manifest, path: prefix).construct(includingTestModules: false)
             } catch ModuleError.modulesNotFound(let moduleNames) {
                 XCTAssertEqual(Set(moduleNames), Set(["Bake", "Fake"]))