[PackageLoading] Move packageBuilder to FileSystem

Author: aciidgh

Sources/PackageLoading/PackageBuilder.swift

@@ -133,13 +133,16 @@ public struct PackageBuilder {
     /// The path of the package.
     private let packagePath: AbsolutePath
 
+    private let fileSystem: FileSystem
+
     /// Create a builder for the given manifest and package `path`.
     ///
     /// - Parameters:
     ///   - path: The root path of the package.
     public init(manifest: Manifest, path: AbsolutePath) {
         self.manifest = manifest
         self.packagePath = path
+        self.fileSystem = localFileSystem
     }
 
     /// Build a new package following the conventions.
@@ -168,9 +171,10 @@ public struct PackageBuilder {
         if path.basename.hasPrefix(".") { return false }
         if path == manifest.path { return false }
         if excludedPaths.contains(path) { return false }
-        if !path.asString.isFile { return false }
-        guard let ext = path.asString.fileExt else { return false }
-        return validExtensions.contains(ext)
+        if !fileSystem.isFile(path) { return false }
+        guard let ext = path.suffix else { return false }
+        // FIXME: This isn't efficient.
+        return validExtensions.contains(String(ext.utf8.dropFirst()))
     }
 
     private func shouldConsiderDirectory(_ path: AbsolutePath) -> Bool {
@@ -182,7 +186,7 @@ public struct PackageBuilder {
         if base.hasPrefix(".") { return false }  // eg .git
         if excludedPaths.contains(path) { return false }
         if path == packagesDirectory { return false }
-        if !path.asString.isDirectory { return false }
+        if !fileSystem.isDirectory(path) { return false }
         return true
     }
 
@@ -198,12 +202,29 @@ public struct PackageBuilder {
         guard let pkgConfig = manifest.package.pkgConfig else { return nil }
         return RelativePath(pkgConfig)
     }
+
+    // FIXME: Should this be an extension on FileSystem and placed in Utility?
+    /// Returns path to all the items in a directory.
+    func directoryContents(_ path: AbsolutePath) throws -> [AbsolutePath] {
+        return try fileSystem.getDirectoryContents(path).map { path.appending(component: $0) }
+    }
+
+    // FIXME: Optimize.
+    /// Returns path to all the items in a directory tree.
+    func recursiveDirectoryContents(_ path: AbsolutePath, predicate: @noescape (AbsolutePath) -> Bool) throws -> [AbsolutePath] {
+        return try directoryContents(path).flatMap { (entry) -> [AbsolutePath] in
+            if predicate(entry) {
+                return try recursiveDirectoryContents(entry, predicate: predicate)
+            }
+            return [entry]
+        }
+    }
 
     func sourceRoot() throws -> AbsolutePath {
-        let viableRoots = walk(packagePath, recursively: false).filter { entry in
+        let viableRoots = try directoryContents(packagePath).filter { entry in
             switch entry.basename.lowercased() {
             case "sources", "source", "src", "srcs":
-                return entry.asString.isDirectory && !excludedPaths.contains(entry)
+                return fileSystem.isDirectory(entry) && !excludedPaths.contains(entry)
             default:
                 return false
             }
@@ -223,7 +244,7 @@ public struct PackageBuilder {
     /// Collects the modules which are defined by a package.
     private func constructModules() throws -> [Module] {
         let moduleMapPath = packagePath.appending("module.modulemap")
-        if moduleMapPath.asString.isFile {
+        if fileSystem.isFile(moduleMapPath) {
             let sources = Sources(paths: [moduleMapPath], root: packagePath)
             return [try CModule(name: manifest.name, sources: sources, path: packagePath, pkgConfig: pkgConfigPath, providers: manifest.package.providers)]
         }
@@ -235,16 +256,16 @@ public struct PackageBuilder {
         let srcroot = try sourceRoot()
 
         if srcroot != packagePath {
-            let invalidRootFiles = walk(packagePath, recursively: false).filter(isValidSource)
+            let invalidRootFiles = try directoryContents(packagePath).filter(isValidSource)
             guard invalidRootFiles.isEmpty else {
                 throw ModuleError.invalidLayout(.invalidLayout(invalidRootFiles.map{ $0.asString }))
             }
         }
 
-        let maybeModules = walk(srcroot, recursively: false).filter(shouldConsiderDirectory)
+        let maybeModules = try directoryContents(srcroot).filter(shouldConsiderDirectory)
 
         if maybeModules.count == 1 && maybeModules[0] != srcroot {
-            let invalidModuleFiles = walk(srcroot, recursively: false).filter(isValidSource)
+            let invalidModuleFiles = try directoryContents(srcroot).filter(isValidSource)
             guard invalidModuleFiles.isEmpty else {
                 throw ModuleError.invalidLayout(.invalidLayout(invalidModuleFiles.map{ $0.asString }))
             }
@@ -313,7 +334,7 @@ public struct PackageBuilder {
     }
 
     private func modulify(_ path: AbsolutePath, name: String, isTest: Bool) throws -> Module {
-        let walked = walk(path, recursing: shouldConsiderDirectory).map{ $0 }
+        let walked = try recursiveDirectoryContents(path, predicate: shouldConsiderDirectory).map{ $0 }
 
         let cSources = walked.filter{ isValidSource($0, validExtensions: SupportedLanguageExtension.cFamilyExtensions) }
         let swiftSources = walked.filter{ isValidSource($0, validExtensions: SupportedLanguageExtension.swiftExtensions) }
@@ -400,11 +421,13 @@ public struct PackageBuilder {
     private func constructTestModules(modules: [Module]) throws -> [Module] {
         let testsPath = packagePath.appending("Tests")
 
-        // Don't try to walk Tests if it is in excludes.
-        if testsPath.asString.isDirectory && excludedPaths.contains(testsPath) { return [] }
+        // Don't try to walk Tests if it is in excludes or doesn't exists.
+        guard fileSystem.isDirectory(testsPath) && !excludedPaths.contains(testsPath) else {
+            return []
+        }
 
         // Create the test modules
-        let testModules = try walk(testsPath, recursively: false).filter(shouldConsiderDirectory).flatMap { dir in
+        let testModules = try directoryContents(testsPath).filter(shouldConsiderDirectory).flatMap { dir in
             return [try modulify(dir, name: dir.basename, isTest: true)]
         }