Add isGitIgnored method for checking if a file is ignored by git (#1613)

* Ignore files from .gitignore

Add getIgnoredFiles to GitRepository

* Use git check-ignore for filtering files

This makes an improvement performance-wise, because
it can be used to check only the files we are concerned about

* Fix checkoutExists and add test for it

* Fix isIgnored and add test for it

* Modify `isGitIgnored` to be able to process multiple paths in one invocation

This way there is no need to create the shell process for every path separately which can improve the performance

* Use file input for check-ignore

This ensures that we won't surpass ARG_MAX with the arguments to check-ignore,
and also that paths now can include spaces

* Rename isGitIgnored to areIgnored

* Use localFileSystem to write the temporary file with the paths

* Add quotes around the path arguments for git in areIgnored

* Append paths directly to the output stream

* Use shellEscaped on path arguments in areIgnored

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, "-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 +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.
@@ -387,6 +397,35 @@ public class GitRepository: Repository, WorkingCheckout {
         return localFileSystem.isDirectory(AbsolutePath(firstLine))
     }
 
+    /// Returns true if the file at `path` is ignored by `git`
+    public func areIgnored(_ paths: [AbsolutePath]) throws -> [Bool] {
+        return try queue.sync {
+            let stringPaths = paths.map({ $0.asString })
+
+            let pathsFile = try TemporaryFile()
+            try localFileSystem.writeFileContents(pathsFile.path) {
+                for path in paths {
+                    $0 <<< path.asString <<< "\0"
+                }
+            }
+
+            let args = [Git.tool, "-C", self.path.asString.shellEscaped(), "check-ignore", "-z", "--stdin", "<", pathsFile.path.asString.shellEscaped()]
+            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 areIgnored(_ 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 areIgnored(_ 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,43 @@ class GitRepositoryTests: XCTestCase {
         }
     }
 
+    func testAreIgnored() 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.areIgnored([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.areIgnored([testRepoPath.appending(component: "not_ignored")])
+            XCTAssertFalse(notIgnored[0])
+        }
+    }
+
+    func testAreIgnoredWithSpaceInRepoPath() 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")
+
+            let ignored = try repo.areIgnored([testRepoPath.appending(component: "ignored_file1")])
+            XCTAssertTrue(ignored[0])
+        }
+    }
+
     static var allTests = [
         ("testBranchOperations", testBranchOperations),
         ("testCheckoutRevision", testCheckoutRevision),
@@ -620,5 +658,6 @@ class GitRepositoryTests: XCTestCase {
         ("testSubmodules", testSubmodules),
         ("testUncommitedChanges", testUncommitedChanges),
         ("testAlternativeObjectStoreValidation", testAlternativeObjectStoreValidation),
+        ("testGitIgnored", testAreIgnored),
     ]
 }

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