Index.Remove with directory/pattern does not always work

[mbektchiev]

The problem could be related to the commit operation but I'm not sure. If instead of repo.Index.Remove("*") you pass the filename, it is correctly removed from the Index.

Also if you commit the file using the console git client the * version starts working correctly.

For reproduction please see the following unit test:

using LibGit2Sharp;
using NUnit.Framework;
using System;
using System.IO;
using System.Linq;

namespace Tests
{
    public class LibGitTest
    {
        [Test]
        public void TestRemove()
        {
            var tempPath = Path.Combine(Path.GetTempPath(), "LibGitTest");

            if (Directory.Exists(tempPath))
            {
                DeleteDirectory(tempPath);
            }
            Directory.CreateDirectory(tempPath);

            using (var repo = new Repository(Repository.Init(tempPath)))
            {
                File.WriteAllText(Path.Combine(tempPath, "a.txt"), "some text");

                repo.Stage("*.*");
                var signature = repo.Config.BuildSignature(DateTimeOffset.Now);
                repo.Commit("Initial commit", signature, signature);

                repo.Index.Remove("*");
                // repo.Index.Remove("a.txt"); // uncomment this line to make the test pass

                var status = repo.RetrieveStatus();
                Assert.Contains("a.txt", status.Removed.Select(entry => entry.FilePath).ToArray());
            }
        }

        private static void DeleteDirectory(string tempPath)
        {
            // Some files in the .git folder are readonly, I'm not sure whether that's normal, but we need to reset the flag in order to successfully delete the directory
            Directory.EnumerateFiles(Path.Combine(tempPath), "*", SearchOption.AllDirectories)
                .ForEach(f => File.SetAttributes(f, File.GetAttributes(f) & ~FileAttributes.ReadOnly));

            Directory.Delete(tempPath, recursive: true);
        }
    }
}

[ethomson]

This seems correct. Index.Remove is a plumbing method and expects a path. In the code as you have it written, if it did take a wildcard, it would remove everything from the index, which is probably not what you want.

If you want to remove a file with a wildcard, remove it from the working directory and use Commands.Stage with a wildcard.

[mbektchiev]

I am using the 0.22.0 version from NuGet and there's no such command there. Can I replace it with something else?

[ethomson]

In 0.22.0, it's Repository.Stage.

[mbektchiev]

Thank you for the hint! I managed to do what I wanted by invoking repo.Stage after deleting the directory.

repo.Index.Remove however has a slightly different semantics and actually doesn't remove any files from the working directory of the repository. I still think that it should support directories, and in fact it does -- if the commit is created with another tool (e.g. the command line git)

[ethomson]

repo.Index.Remove however has a slightly different semantics and actually doesn't remove any files from the working directory of the repository

That's correct, it is explicitly for operating on the index. It does not touch the working directory.

I still think that it should support directories, and in fact it does -- if the commit is created with another tool (e.g. the command line git)

I'm not exactly sure what you mean - the index shouldn't care what it was written by. Can you provide the steps that you took and the end result?

[mbektchiev]

Execute these commands from a Git Bash window:

mkdir -p "C:\Temp\LibGitTest"
cd "C:\Temp\LibGitTest"
git init
echo Test | cat >a.txt
git add a.txt
git commit -m "Test"

After that run the same test but without the repository creation code -> It passes, as opposed to not passing before.

using LibGit2Sharp;
using NUnit.Framework;
using System;
using System.IO;
using System.Linq;

namespace Tests
{
    public class LibGitTest
    {
        [Test]
        public void TestRemove()
        {
            var repoPath = @"C:\Temp\LibGitTest";

            using (var repo = new Repository(Repository.Init(repoPath)))
            {
                repo.Index.Remove("*");
                // repo.Index.Remove("a.txt"); // uncomment this line to make the test pass

                var status = repo.RetrieveStatus();
                Assert.Contains("a.txt", status.Removed.Select(entry => entry.FilePath).ToArray());
            }
        }
    }
}

I've played around a bit and found out that even if there are many files and you commit some of them using git CLI, and others with LibGit, then only the ones from LibGit will be missed by the Remove. It's rather strange and that's why I decided to report the issue here.

[mbektchiev]

I spoke too fast. This doesn't fix it now. I'll try and find a bash script which recreates a repository that is working with Index.Remove("*"). I had cases where it worked earlier today.

[mbektchiev]

I managed to reproduce it. But only if I modify the file while breaking the execution in the debugger before the repo.Index.Remove("*"); line.

1. Add a breakpoint on the Remove line
2. After the debugger breaks go to the repository's working directory and execute: echo TestTestTest | cat >a.txt && git commit -m "Modify a.txt" a.txt
3. Continue execution from the debugger - the file is correctly removed. If there are more files in the repository, only the ones that have been recommitted will be removed.

[ethomson]

Removed from the index? From the working directory? It should remove neither.

AFAICT, you're not even losing a race condition; you're changing the in-memory index, but you're not writing it...?

[mbektchiev]

Removed from the index and remaining in the working directory as it is expected from Index.Remove.

Yes, I know that it's not expected to behave correctly after such a monstrous fiddling with the files, but it just serves as an example to show how I actually saw that the function works on directories. If it weren't suppose to work this way, it would never actually find those files and remove them from the index.

Moreover I found this issue: #327 which definitely supports the statement that Remove should work on directories.

[ethomson]

Directories, not globs or wildcards.