Refresh index without discard_index + repo_read_index

Roman Perepelitsa· Mar 9, 2019, 19:59 UTC · lore

I’m writing a program that reads stdin in a loop and prints the equivalent of `git status` whenever it reads a character. It always prints its results for the same repository, the same pathspec, etc. The input characters have no effect on the output, only the sate of the repository does. I’m hoping that I can make it produce results faster than a bash script that literally calls `git status` in a loop. I’m thinking that maybe I can keep some caches around so that I don’t have to redo all the work on every iteration that git status does.

What I cannot figure out is how to refresh the index so that it picks up all the changes that might have happened to the repository and workdir since the last iteration. Here’s what I have:

```c #include <stdio.h> #include <string.h>

#define USE_THE_INDEX_COMPATIBILITY_MACROS #include "cache.h" #include "wt-status.h" #include "pathspec.h" #include "repository.h"

int cmd_multi_status(int argc, const char** argv, const char* prefix) {
  struct pathspec pathspec;
  memset(&pathspec, 0, sizeof(pathspec));
  repo_read_index(the_repository);
  while (getchar() != EOF) {
    refresh_index(&the_index,
                  REFRESH_QUIET | REFRESH_UNMERGED | REFRESH_REALLY,
                  &pathspec, NULL, NULL);
    int uncommitted = has_uncommitted_changes(the_repository, 1);
    int unstaged = has_unstaged_changes(the_repository, 1);
    int untracked = has_untracked(the_repository);  // I added this to
wt-status.h
    printf("%d %d %d\n", uncommitted, unstaged, untracked);
  }
  return 0;
}
```

This produces correct results on the first iteration but then it doesn’t pick up all changes. I’ve hacked some code in preload-index.c and cache.c so that it picks up more changes but I still cannot detect when an unstaged file becomes uncommitted or the other way around.

Any pointers would be greatly appreciated.

Roman.

P.S.

I have working code that uses libgit2. Updating the index with `git_index_read(index, 0)` works as expected and is indeed faster than discarding the index and starting from scratch. But it's still slower than `git status` on large repositories, especially with many ignored files.

Roman Perepelitsa· Mar 11, 2019, 16:00 UTC · re: Roman Perepelitsa · lore

Re: Refresh index without discard_index + repo_read_index

In the end I managed to patch diffing code in libgit2 (git_diff_tree_to_index and git_diff_index_to_workdir) to make it about 4x faster. It's now faster than `git status`, so good enough for me.

I'm still curious whether it's possible to refresh index in git (not libgit2), so please chime if if you know.

Roman.

On Sat, Mar 9, 2019 at 8:59 PM Roman Perepelitsa <roman.perepelitsa@gmail.com> wrote:

Show 59 quoted lines

>
> I’m writing a program that reads stdin in a loop and prints the
> equivalent of `git status` whenever it reads a character. It always
> prints its results for the same repository, the same pathspec, etc.
> The input characters have no effect on the output, only the sate of
> the repository does.
> I’m hoping that I can make it produce results faster than a bash
> script that literally calls `git status` in a loop. I’m thinking that
> maybe I can keep some caches around so that I don’t have to redo all
> the work on every iteration that git status does.
>
> What I cannot figure out is how to refresh the index so that it picks
> up all the changes that might have happened to the repository and
> workdir since the last iteration. Here’s what I have:
>
> ```c
> #include <stdio.h>
> #include <string.h>
>
> #define USE_THE_INDEX_COMPATIBILITY_MACROS
> #include "cache.h"
> #include "wt-status.h"
> #include "pathspec.h"
> #include "repository.h"
>
> int cmd_multi_status(int argc, const char** argv, const char* prefix) {
>   struct pathspec pathspec;
>   memset(&pathspec, 0, sizeof(pathspec));
>   repo_read_index(the_repository);
>   while (getchar() != EOF) {
>     refresh_index(&the_index,
>                   REFRESH_QUIET | REFRESH_UNMERGED | REFRESH_REALLY,
>                   &pathspec, NULL, NULL);
>     int uncommitted = has_uncommitted_changes(the_repository, 1);
>     int unstaged = has_unstaged_changes(the_repository, 1);
>     int untracked = has_untracked(the_repository);  // I added this to
> wt-status.h
>     printf("%d %d %d\n", uncommitted, unstaged, untracked);
>   }
>   return 0;
> }
> ```
>
> This produces correct results on the first iteration but then it
> doesn’t pick up all changes. I’ve hacked some code in preload-index.c
> and cache.c so that it picks up more changes but I still cannot detect
> when an unstaged file becomes uncommitted or the other way around.
>
> Any pointers would be greatly appreciated.
>
> Roman.
>
> P.S.
>
> I have working code that uses libgit2. Updating the index with
> `git_index_read(index, 0)` works as expected and is indeed faster than
> discarding the index and starting from scratch. But it's still slower
> than `git status` on large repositories, especially with many ignored
> files.