Add isGitIgnored method for checking if a file is ignored by git

Sources/SourceControl/GitRepository.swift

@@ -11,6 +11,7 @@
 import Basic
 import Dispatch
 import Utility
+import struct Foundation.Data
 
 public enum GitRepositoryProviderError: Swift.Error {
     case gitCloneFailure(errorOutput: String)
@@ -92,6 +93,13 @@ public class GitRepositoryProvider: RepositoryProvider {
         }
     }
 
+    public func checkoutExists(at path: AbsolutePath) throws -> Bool {
+        precondition(exists(path))
+
+        let result = try Process.popen(args: Git.tool, "-C", path.asString, "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 +108,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.
@@ -387,6 +398,33 @@ public class GitRepository: Repository, WorkingCheckout {
         return localFileSystem.isDirectory(AbsolutePath(firstLine))
     }
 
+    /// Returns true if the file at `path` is ignored by `git`
+    public func isGitIgnored(_ paths: [AbsolutePath]) throws -> [Bool] {
+        return try queue.sync {
+            let stringPaths = paths.map({ $0.asString })
+            let pathsFileContent = stringPaths.joined(separator: "\0")
+
+            let pathsFile = try TemporaryFile()
+            let pathsData = Data(pathsFileContent.utf8)
+            pathsFile.fileHandle.write(pathsData)
+
+            let args = [Git.tool, "-C", self.path.asString, "check-ignore", "-z", "--stdin", "<", "\(pathsFile.path.asString)"]
+            let argsWithSh = ["sh", "-c", args.joined(separator: " ")]
+            let result = try Process.popen(arguments: argsWithSh)
+            let output = try result.output.dematerialize()
+
+            let outputs: [String] = output.split(separator: 0).map(Array.init).map({ (bytes: [Int8]) -> String in
+                return String(cString: bytes + [0])
+            })
+
+            guard result.exitStatus == .terminated(code: 0) || result.exitStatus == .terminated(code: 1) else {
+                throw GitInterfaceError.fatalError
+            }
+
+            return stringPaths.map(outputs.contains)
+        }
+    }
+
     // MARK: Git Operations
 
     /// Resolve a "treeish" to a concrete hash.

Sources/SourceControl/InMemoryGitRepository.swift

@@ -272,6 +272,10 @@ extension InMemoryGitRepository: WorkingCheckout {
     public func isAlternateObjectStoreValid() -> Bool {
         return true
     }
+
+    public func isGitIgnored(_ paths: [AbsolutePath]) throws -> [Bool] {
+        return [false]
+    }
 }
 
 /// This class implement provider for in memeory git repository.
@@ -323,6 +327,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

@@ -88,6 +88,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:
@@ -193,6 +196,9 @@ public protocol WorkingCheckout {
 
     /// Returns true if there is an alternative store in the checkout and it is valid.
     func isAlternateObjectStoreValid() -> Bool
+
+    /// Returns true if the file at `path` is ignored by `git`
+    func isGitIgnored(_ paths: [AbsolutePath]) throws -> [Bool]
 }
 
 /// A single repository revision.

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/GitRepositoryTests.swift

@@ -40,6 +40,7 @@ class GitRepositoryTests: XCTestCase {
             // Test the provider.
             let testCheckoutPath = path.appending(component: "checkout")
             let provider = GitRepositoryProvider()
+            XCTAssertTrue(try provider.checkoutExists(at: testRepoPath))
             let repoSpec = RepositorySpecifier(url: testRepoPath.asString)
             try! provider.fetch(repository: repoSpec, to: testCheckoutPath)
 
@@ -604,6 +605,27 @@ class GitRepositoryTests: XCTestCase {
         }
     }
 
+    func testGitIgnored() throws {
+        mktmpdir { path in
+            // Create a repo.
+            let testRepoPath = path.appending(component: "test_repo")
+            try makeDirectories(testRepoPath)
+            initGitRepo(testRepoPath)
+            let repo = GitRepository(path: testRepoPath)
+
+            // Add a .gitignore
+            try localFileSystem.writeFileContents(testRepoPath.appending(component: ".gitignore"), bytes: "ignored_file1\nignored file2")
+
+            let ignored = try repo.isGitIgnored([testRepoPath.appending(component: "ignored_file1"), testRepoPath.appending(component: "ignored file2"), testRepoPath.appending(component: "not ignored")])
+            XCTAssertTrue(ignored[0])
+            XCTAssertTrue(ignored[1])
+            XCTAssertFalse(ignored[2])
+
+            let notIgnored = try repo.isGitIgnored([testRepoPath.appending(component: "not_ignored")])
+            XCTAssertFalse(notIgnored[0])
+        }
+    }
+
     static var allTests = [
         ("testBranchOperations", testBranchOperations),
         ("testCheckoutRevision", testCheckoutRevision),
@@ -620,5 +642,6 @@ class GitRepositoryTests: XCTestCase {
         ("testSubmodules", testSubmodules),
         ("testUncommitedChanges", testUncommitedChanges),
         ("testAlternativeObjectStoreValidation", testAlternativeObjectStoreValidation),
+        ("testGitIgnored", testGitIgnored),
     ]
 }

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")
     }