Git tricks

Learning git

See the fastai masterclass for many more helpful tips/links/scripts/recommendations. Learn Git Branching explains the mechanics in a friendly fashion. Steve Bennett’s 10 things I hate about Git is also useful.

Mark Dominus’ master class:

• The Universe of Discourse : Things I wish everyone knew about Git (Part I)
• The Universe of Discourse : Things I wish everyone knew about Git (Part II)

Handy git config

git config --global core.editor "code-insiders --wait"  # insiders

echo .DS_Store >> .gitignore_global
git config --global core.excludesfile $HOME/.gitignore_global

Handy git commands

grep -lr '<<<<<<<' . | xargs git checkout --theirs --

git log -Sword

git log --oneline --find-renames --stat --follow -- src/somefile.ts

git clone --single-branch --branch <branchname> <remote-repo>

git rm --cached blah.tmp

git push <remote_name> --delete <branch_name>

git push origin HEAD:refs/heads/backdoor

What git calls things

By which I mean that which is formally referred to as git references. git references is the canonical description of the mechanics. tl;dr the most common names are refs/heads/SOMETHING for branch SOMETHING, refs/tags/SOMETHING and remotes/SOMEREMOTE/SOMETHING for (last known state of) a remote branch.

As alexwlchan explains, these references are friendly names for commits. The uses are (at least partly) convention and other references can be used too. For example gerrit uses refs/for/ for code review purposes.

Filters

Commands applied to your files on the way in and out of the repository. Keywords, smudge, clean, .gitattr These are a long story, but not so complicated in practice. A useful one is stripping crap from jupyter notebooks.

Commit hooks

For doing stuff before you put it in cold storage. For me this means, e.g asking DID YOU REALLY WANT TO INCLUDE THAT GIANT FILE?

Here is a commit hook that does exactly that. I made a slightly modernized version:

curl -L https://gist.github.com/danmackinlay/6e4a0e5c38a43972a0de2938e6ddadba/raw/install.sh | bash

After that installation you can retrofit the hook to an existing repository thusly

p -R ~/.git_template/hooks .git/

There are various frameworks for managing hooks, if you have lots. For example, pre-commit is a mini-system for managing git hooks, based on python. Husky is a node.js-based one.

I am not sure whether hook management system actually saves time overall for a solo developer, since the kind of person who remembers to install a pre-commit hook is also the kind of person who is relatively less likely to need one. Also it is remarkably labour-intensive to install the dependencies for all these systems, so if you are using heterogeneous systems this becomes tedious.

To skip the pre-commit hook,

git commit --no-verify

Subtrees/submodules/subprojects/subdirs/subterranean mole people

Sub-projects inside other projects? External projects? The simplest way of integrating external projects is as subtrees. Once this is set up you can mostly ignore them. Alternatively there are submodules, which have various complications. More recently, there is the subtrac system, which I have not yet used.

git fetch remote branch
git subtree add --prefix=subdir remote branch --squash

git fetch remote branch
git subtree pull --prefix=subdir remote branch --squash
git subtree push --prefix=subdir remote branch --squash

pushd superproject
git subtree split -P project_subdir -b project_branch
popd
mkdir project
pushd project
git init
git pull ../superproject project_branch

pushd superproject
cd ..
git clone superproject subproject
pushd subproject
git filter-branch \
    --subdirectory-filter project_subdir \
    --prune-empty -- \
    --all

svn co https://github.com/buckyroberts/Source-Code-from-Tutorials/trunk/Python

Deleting all tags

git tag -l | xargs -I %% git push -v origin :refs/tags/%%
git tag -l | xargs git tag -d && git fetch -t

Helpers

git-branchless

arxanas/git-branchless: Branchless workflow for Git

The branchless workflow is designed for use in a repository with a single main branch that all commits are rebased onto. It improves developer velocity by encouraging fast and frequent commits, and helps developers operate on these commits fearlessly.

In the branchless workflow, the commits you’re working on are inferred based on your activity, so you no longer need branches to keep track of them. Nonetheless, branches are sometimes convenient, and git-branchless fully supports them. If you prefer, you can continue to use your normal workflow and benefit from features like git sl or git undo without going entirely branchless.

git-undo

Also : git undo: We can do better

How is it so easy to “lose” your data in a system that’s supposed to never lose your data?

Well, it’s not that it’s too easy to lose your data — but rather, that it’s too difficult to recover it. For each operation you want to recover from, there’s a different “magic” incantation to undo it. All the data is still there in principle, but it’s not accessible to many in practice.

…To address this problem, I offer git undo

git config --global rerere.enabled true
git config --global rerere.autoupdate true

Importing some files across a branch

git checkout my_branch -- my_file/

Garbage collecting

In brief, this will purge a lot of stuff from a constipated repo in emergencies:

git reflog expire --expire=now --all && git gc --prune=now

In-depth explanation.

Editing history

git clone --mirror git://example.com/some-big-repo.git
cd some-big-repo.git
git repack
bfg --strip-blobs-bigger-than 10M .
git reflog expire --expire=now --all && git gc --prune=now --aggressive
git push -f

git filter-branch -f \
    --index-filter
    'git rm -r --cached --ignore-unmatch unwanted_files'

Making it work with a broken-permission FS

e.g. you are editing a git repo on NTFS via Linux and things are silly.

git config core.filemode false

Detecting if there are changes to commit

Thomas Nyman:

if output=$(git status --porcelain) && [ -z "$output" ]; then
  # Working directory clean
else
  # Uncommitted changes
fi

Emergency commit

Oh crap I’m leaving the office in a hurry and I just need to get my work into git ASAP for continuing on another computer. I don’t care about sensible commit messages because I am on my own private branch and no-one else will see them when I squash the pull request.

I put this little script in a file called gitbang to automate the this case.

#!/usr/bin/env bash
# I’m leaving the office. Capture all changes in my private branch and push to server.
if output=$(git status --porcelain) && [ -z "$output" ]; then
  echo "nothing to commit"
else
  git add --all && git commit -m bang
fi
git pull && git submodule update --init --recursive  && git push

Git hosting

• What is Codeberg? | Codeberg Documentation is a gitea host
• Gitlab
• github

Or maybe avoid the need for hosting by using…

git email workflows

Learn to use email with git!

Content-specific diffing

Tools such as git-latexdiff provide custom diffing for, in this case, LaTeX code. These need to be found on a case-by-case basis.

SSH credentials

Managing SSH credentials in git is non-obvious. See SSH.

Jupyter

For sanity in git+jupyter, see jupyter.

Decent GUIs

See Git GUIs.

Which repo am I in?

For fish and bash shell, see bash-git-prompt.

Data versioning

See data versioning.