Use git check-ignore for filtering files, check if a checkout exists

before opening it

Author: ViktorSimko

Sources/SourceControl/GitRepository.swift

@@ -92,6 +92,13 @@ public class GitRepositoryProvider: RepositoryProvider {
         }
     }
 
+    public func checkoutExists(at path: AbsolutePath) throws -> Bool {
+        precondition(exists(path))
+
+        let result = try Process.popen(args: Git.tool, "rev-parse", "--is-bare-repository")
+        return try result.exitStatus == .terminated(code: 0) && result.utf8Output().chomp() == "false"
+    }
+
     public func openCheckout(at path: AbsolutePath) throws -> WorkingCheckout {
         return GitRepository(path: path)
     }
@@ -100,6 +107,9 @@ public class GitRepositoryProvider: RepositoryProvider {
 enum GitInterfaceError: Swift.Error {
     /// This indicates a problem communicating with the `git` tool.
     case malformedResponse(String)
+
+    /// This indicates that a fatal error was encountered
+    case fatalError
 }
 
 /// A basic `git` repository. This class is thread safe.
@@ -391,13 +401,19 @@ public class GitRepository: Repository, WorkingCheckout {
         return localFileSystem.isDirectory(AbsolutePath(firstLine))
     }
 
-    public func getIgnoredFiles() -> [AbsolutePath] {
-        return queue.sync {
-            let result = try? Process.checkNonZeroExit(
-                args: Git.tool, "-C", path.asString, "ls-files", "-o", "-i", "--exclude-standard").chomp()
-            return result?.split(separator: "\n").map(String.init).map {
-                return path.appending(RelativePath($0))
-            } ?? []
+    /// Returns true if the file at `path` is ignored by `git`
+    public func isIgnored(_ path: AbsolutePath) throws -> Bool {
+        return try queue.sync {
+            let result = try Process.popen(args: Git.tool, "check-ignore", path.asString)
+
+            switch result.exitStatus {
+            case .terminated(code: 0):
+                return true
+            case .terminated(code: 1):
+                return false
+            default:
+                throw GitInterfaceError.fatalError
+            }
         }
     }
 

Sources/SourceControl/InMemoryGitRepository.swift

@@ -269,8 +269,8 @@ extension InMemoryGitRepository: WorkingCheckout {
         return true
     }
 
-    public func getIgnoredFiles() -> [AbsolutePath] {
-        return []
+    public func isIgnored(_ path: AbsolutePath) throws -> Bool {
+        return false
     }
 }
 
@@ -323,6 +323,10 @@ public final class InMemoryGitRepositoryProvider: RepositoryProvider {
         try checkout.installHead()
     }
 
+    public func checkoutExists(at path: AbsolutePath) throws -> Bool {
+        return checkoutsMap.keys.contains(path)
+    }
+
     public func openCheckout(at path: AbsolutePath) throws -> WorkingCheckout {
         return checkoutsMap[path]!
     }

Sources/SourceControl/Repository.swift

@@ -98,6 +98,9 @@ public protocol RepositoryProvider {
         to destinationPath: AbsolutePath,
         editable: Bool) throws
 
+    /// Returns true if a working repository exists at `path`
+    func checkoutExists(at path: AbsolutePath) throws -> Bool
+
     /// Open a working repository copy.
     ///
     /// - Parameters:
@@ -204,8 +207,8 @@ public protocol WorkingCheckout {
     /// Returns true if there is an alternative store in the checkout and it is valid.
     func isAlternateObjectStoreValid() -> Bool
 
-    /// Returns the `AbsolutePath` of the files ignored by git.
-    func getIgnoredFiles() -> [AbsolutePath]
+    /// Returns true if the file at `path` is ignored by `git`
+    func isIgnored(_ path: AbsolutePath) throws -> Bool
 }
 
 /// A single repository revision.

Sources/Xcodeproj/generate().swift

@@ -74,15 +74,23 @@ public func generate(
     // Find non-source files in the source directories and root that should be added
     // as a reference to the project.
     var extraFiles = try findNonSourceFiles(path: srcroot)
-    let sourcesExtraFiles = try findNonSourceFiles(path: srcroot.appending(component: "Sources"), recursively: true)
-    extraFiles.append(contentsOf: sourcesExtraFiles)
-    let testsExtraFiles = try findNonSourceFiles(path: srcroot.appending(component: "Tests"), recursively: true)
-    extraFiles.append(contentsOf: testsExtraFiles)
-
-    // Get the ignored files and exclude them
-    let ignoredFiles = try repositoryProvider.openCheckout(at: srcroot).getIgnoredFiles()
-    extraFiles = extraFiles.filter {
-        return !ignoredFiles.contains($0)
+
+    let sourcesDirectory = srcroot.appending(component: "Sources")
+    if localFileSystem.isDirectory(sourcesDirectory) {
+        let sourcesExtraFiles = try findNonSourceFiles(path: sourcesDirectory, recursively: true)
+        extraFiles.append(contentsOf: sourcesExtraFiles)
+    }
+
+    let testsDirectory = srcroot.appending(component: "Tests")
+    if localFileSystem.isDirectory(testsDirectory) {
+        let testsExtraFiles = try findNonSourceFiles(path: testsDirectory, recursively: true)
+        extraFiles.append(contentsOf: testsExtraFiles)
+    }
+
+    if try repositoryProvider.checkoutExists(at: srcroot) {
+        // Get the ignored files and exclude them
+        let repository = try repositoryProvider.openCheckout(at: srcroot)
+        extraFiles = try extraFiles.filter { try !repository.isIgnored($0) }
     }
 
     /// Generate the contents of project.xcodeproj (inside the .xcodeproj).

Sources/Xcodeproj/pbxproj().swift

@@ -297,6 +297,7 @@ func xcodeProject(
             let name = (sourcesGroup == nil ? groupName : target.name)
             let group = (sourcesGroup ?? parentGroup)
                 .addGroup(path: (path == "." ? "" : path), pathBase: .projectDir, name: name)
+
             // Associate the group with the target's root path.
             srcPathsToGroups[target.sources.root] = group
         }

Tests/PackageGraphTests/RepositoryPackageContainerProviderTests.swift

@@ -97,6 +97,10 @@ private class MockRepositories: RepositoryProvider {
         // No-op.
         assert(repositories.index(forKey: repository.url) != nil)
     }
+
+    func checkoutExists(at path: AbsolutePath) throws -> Bool {
+        return false
+    }
 
     func open(repository: RepositorySpecifier, at path: AbsolutePath) throws -> Repository {
         return repositories[repository.url]!

Tests/SourceControlTests/InMemoryGitRepositoryTests.swift

@@ -100,7 +100,9 @@ class InMemoryGitRepositoryTests: XCTestCase {
         XCTAssert(fooRepo.exists(revision: try fooRepo.resolveRevision(tag: v1)))
 
         let fooCheckoutPath = AbsolutePath("/fooCheckout")
+        XCTAssertFalse(try provider.checkoutExists(at: fooCheckoutPath))
         try provider.cloneCheckout(repository: specifier, at: fooRepoPath, to: fooCheckoutPath, editable: false)
+        XCTAssertTrue(try provider.checkoutExists(at: fooCheckoutPath))
         let fooCheckout = try provider.openCheckout(at: fooCheckoutPath)
 
         XCTAssertEqual(fooCheckout.tags.sorted(), [v1, v2])

Tests/SourceControlTests/RepositoryManagerTests.swift

@@ -95,6 +95,10 @@ private class DummyRepositoryProvider: RepositoryProvider {
         try localFileSystem.writeFileContents(destinationPath.appending(component: "README.txt"), bytes: "Hi")
     }
 
+    func checkoutExists(at path: AbsolutePath) throws -> Bool {
+        return false
+    }
+
     func openCheckout(at path: AbsolutePath) throws -> WorkingCheckout {
         fatalError("unsupported")
     }