Git

You created a sequence of commits, feat-1 and feat-2, and you realize "hrmm, feat-2 doesn't actually depend on feat-1. I could make both of these PRs against main at the same time."

Given a repo like this:

git init
touch A && git add A && git commit -m "A"
touch B && git add B && git commit -m "B"
git checkout -b "feat-1"
touch C && git add C && git commit -m "C"
git checkout -b "feat-2"
touch D && git add D && git commit -m "D"

gitdot --png

You want feat-2 and feat-1 to both be based off main. You can't just rebase feat-2 on main:

git checkout feat-2
git rebase main

gitdot --png

Nothing happens, because a rebase replays commits onto the new base, and in this case that would just replay the feat-1 and feat-2 commits on main again (changing nothing).

Solution: only reply the feat-2 commit on man using --onto with a cut-point! The form of the command is git rebase --onto <Target> <Cut Point>.

git checkout feat-2
git rebase --onto main feat-1

gitdot --png

Given a repo like this:

git init
touch A && git add A && git commit -m "A"
git checkout -b "feat-1"
touch B && git add B && git commit -m "B"
git checkout main
touch C && git add C && git commit -m "C"
touch D && git add D && git commit -m "D"

gitdot --png --msg

Rebasing feat-1 on main would make B point to D. But say we wanted to rebase B on to C instead?

git checkout feat-1
git rebase --onto C

You locally committed to main instead of develop, but you haven't pushed the commit yet.

• Soft-reset main back to origin/develop
• The committed changes will now be staged
• Switch to develop branch
• Commit staged changes

git reset --soft origin/develop

You rebased, and then remembered that the branch you were on has already been pushed to a remote repo. You shouldn't push this rebase!

• You need to return the current branch to where it was before the rebase.

You ran a git commit --ammend, then realized you've already pushed the commit you were ammending! You can't push the ammended commit! (You can, but that would be rewriting history on the remote server).

• Reset soft to origin/<branch-name>. Then the changes you just committed will be staged.
• Commit again as a new commit.

Somebody pushed changes to your branch while you were still committing locally. Now your branch and the remote branch have diverged.

• Option 1: Merge remote into local. Just do a git merge of remote/branch-name.

HEAD is usually a symbolic ref, meaning it points to another ref. The exception is when you are in a detached HEAD state, in which case HEAD points directly to a commit.

git symbolic-ref HEAD

Some ways to print the SHA of the HEAD ref:

git rev-parse HEAD

git log -1 --format='%H'

Current branch name:

git rev-parse --abbrev-ref HEAD

I got this from cider here.

git describe --tags --abbrev=0

If HEAD is a tag, this will print the tag name. If not, it prints nothing.

git tag --points-at HEAD