Git tricks

git editor

I often do editing in VS code it is convenient to set it as git editor:

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

Ignore macOS .DS_Store files

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

merging

During a merge, git checkout --theirs filename (or --ours) will checkout respectively their (or our) version. The following sweet hack will resolve all files accordingly:

git diff --name-only --diff-filter=U | xargs git checkout --theirs --

Searching

git log -Sword

track the history of a file including renames

Kashyap Kondamudi advises Use --follow option in git log to view a file’s history

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

Clone a single branch

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

Remove file from versioning without deleting my copy

git rm --cached blah.tmp

delete remote branch

git push <remote_name> --delete <branch_name>

Push to a non-obvious branch

git push origin HEAD:refs/heads/backdoor

This is almost obvious except the git naming of things seems… arbitrary? Why refs/heads/SOMETHING?

Read on.

Submodule

Include external projects as separate repositories within a repository is possible, but I won’t document it, since it’s well documented elsewhere, and I use it less often, because it is fiddly, in that Some discipline is required to make it go; you need to remember to git submodule init etc.

Subtrac

Have not yet tried.

subtrac is a helper tool that makes it easier to keep track of your git submodule contents. It collects the entire contents of the entire history of all your submodules (recursively) into a separate git branch, which can be pushed, pulled, forked, and merged however you want.

Subtree

Subtree subsumes one git tree into another in a usually-transparent way (no separate checkout as with submodules.) It can be used for temporary merging or for splicing and dicing projects.

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

Download a sub-directory from a git tree

This works for github at least. I think anything running git-svn?

Heinous hack

1. replace tree/master => trunk
2. svn co the new url

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

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

gerrit

Gerrit is a code review system for git.

legit

legit simplifies feature branch workflows.

rerere

Not repeating yourself during merges/rebases? git rerere automates this:

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

Cleaning out all big files

bfg does that:

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

Deleting specific things

I think bfg also does this. There is also native support:

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

Exporting a minimal history from some repository

i.e. Exporting a branch for a client/collaborator, which they should still operate on in git, but which does not contain all the potentially proprietary stuff in the main repo. Ideally they should see one commit with no history.

If the merge history is clean, there is no need to be fancy; if I have a branch which ahs never merged in any secret information then I can just push it to a new repository and it won’t bring along any of the secret stuff.

OTOH, research code is often unhygienic and chaotic, so we might need to be more careful.

Option 0: Export a tarball and then forget about git:

git archive HEAD --format=zip > archive.zip

git checkout -b temp_branch
git rebase --root -i

git reset $(git commit-tree HEAD^{tree} -m "A new start")

git checkout --orphan temp_branch
git add -A
git commit -am "Initial commit"
git branch -D master
git branch -m master
git push -f origin master

TREE=`git cat-file -p master |sed '1,/^$/s/^tree //p;d;'`
COMMIT=`echo Truncated tree | git commit-tree $TREE`
git branch truncated-master $COMMIT
git branch backup-master-just-in-case-i-regret-it-later master
git push -f origin truncated-master:master