More often than I care to admit, I would pick up to do work on a device only to realize that I'm working with an older version of the codebase. I could use the `git status` command, but the output is verbose and stale if you haven't `git fetch/pull`'d.
I keep the majority of my git repositories in the folder `~/repo/` on all my devices. Inspired by a recent [blog post by Clayton Errington](https://claytonerrington.com/blog/git-status/), I wanted a way to quickly check within a folder which repositories need updating. Their blog post has a script written in PowerShell. I decided to write my own bash implementation, and also ignore the bit about modified files since I mostly care about the state of my commits with respect to the `origin` remote.
Before writing a recursive implementation, let's first discuss how to check the ahead/behind status for a single repository.
First things first, you need to make sure that we have all the references from the remote.
```bash
git remote update
```
To print out how many commits the local `main` branch is ahead of the one located on the `origin` remote we can use:
```bash
git rev-list --count origin/main..main
```
Similarly for checking how many commits the local `main` branch is behind we can use:
```bash
git rev-list --count main..origin/main
```
Instead of looking at the `main` branch, maybe we can to check whichever branch we're currently at.
```bash
branch=$(git rev-parse --abbrev-ref HEAD)
```
We can wrap all of this into a nice bash function. We'll additionally check if there is a `.git` in the current folder as none of the git commands will work without it.
I currently have 15 repositories in my `~/repo` folder. Now I can `cd` into each of them and run this bash function. Or, I can have `bash` do it for me :)
Let's write a function called `process` that does just that. We'll pass in a folder as an argument stored in `$1`
```bash
process() {
if [ -d "$1/.git" ]; then
pushd "$PWD" > /dev/null
cd "$1"
echo -n "$1 "
check_remote
popd > /dev/null
fi
}
```
The `pushd` command will keep track of the folder that we're currently in. Then we `cd` into the directory that has `.git` folder. Print the name of the folder so we can associate the ahead/behind counts, and then run the `check_remote` function. Lastly we `popd` back to the folder we started from.
All that's left is to get the list of folders to process:
```bash
find . -type d -print0
```
Feed it into a `while read` loop passing in each folder into the `process` function.
```bash
find . -type d -print0 | while read -d $'\0' folder
find . -type d -print0 | while read -d $'\0' folder
do
process $folder
done
```
This gives us two options. If we pass in no flags, then it'll print out the ahead/behind status for the current folder. If we pass in `-R`, then we recursively check all the subfolders as well.
