Git alias which works for `main` or `master` or other

Question

With the variety of Default Branch choices in git, how can I write a script/alias which references the default branch no matter the name?

My specific example is my alias which rebases onto the newest remote master:

### version for `master`
#   rebaseOn = "!f() { BRANCH=$(git symbolic-ref --short HEAD) && git fetch && git pull --rebase; git rebase origin/${1:-master}; }; f"
### version for `main`
    rebaseOn = "!f() { BRANCH=$(git symbolic-ref --short HEAD) && git fetch && git pull --rebase; git rebase origin/${1:-main}; }; f"

usage: git rebaseOn or git rebaseOn newParentBranch (because its defaulting the input ${1:-main})

I would like that command to work for either version there, because various repositories I work with have main or master or default or trunk

---

So far I've found https://stackoverflow.com/a/50056710/356218: git remote show upstream | grep "HEAD branch" | sed 's/.*: //' but that is quite long for inserting into an alias.

Is there a better option than that?

---

Best answer so far

Restating the current best answer in my own words:

@matt suggesting of using git branch --set-upstream-to:

• I suppose you set git branch --set-upstream-to <main/master> when you initially clone a repo, and be very consistent about running that command with every repo you touch
• So then you can ignore what github or such says is the default master, and know that on this setup of yours, you always use your preference locally
  • As opposed to pair programming or anything where you must fall back to standard behavior
• Then before rebasing onto default, you must pull your choice of name (script this) so that any new commits are included before the rebase
  • So if you're using a branch to work in parallel with working on something else on default you can't really do that ever with this method, always need a separate branch for commits which aren't ready to push yet
• Then you can merge into default and push without extra work

Merging works mildly better probably (as is always the case with git)

Note: the real frustration is when a repo has both a master and main branch, and its difficult to remember/know/discover which is the primary via CLI (have to git log and look at dates, remember fairly obscure commands, or check github. All those take more than 2 seconds and a context change, to give an idea of the level of the frustration)

Answer 1

Continuing from great @torek's comment, you can set your aliases like that:

main-branch = !git symbolic-ref refs/remotes/origin/HEAD | cut -d'/' -f4
remotesh = remote set-head origin --auto
com = "!f(){ git checkout $(git main-branch) $@;}; f"
upm = "!f(){ git pull --rebase --autostash origin $(git main-branch) $@;}; f"
rebasem = "!f(){ git rebase -i --autosquash origin/$(git main-branch) --no-verify $@;}; f"

git main-branch will return the name of the current "main" branch (main/master).

In other aliases use $(git main-branch) instead of hardcoded master branch name. Just remember that it needs to be a shell script (which starts with !) so that the $(git main-branch) gets actually interpolated.

If any of the aliases errors with fatal: ref refs/remotes/origin/HEAD is not a symbolic ref, then simply run git remotesh .

Answer 2

You have numerous options here. I would, however, recommend that you use none of the ones I list here, because your branch names are yours. There's no reason you need to use the same names as some other repository. That's what matt suggests in a comment as well.

Still, your options include:

• Read origin/HEAD in your own repository.

  repo-A$ git symbolic-ref refs/remotes/origin/HEAD
  refs/remotes/origin/master
  
  repo-B$ git symbolic-ref refs/remotes/origin/HEAD
  refs/remotes/origin/main
  

  where repo-A is a clone of an older repository that uses master and repo-B is a clone of a newer repository that uses main, for instance.

  Note that you may occasionally need to run git remote set-head --auto to get your Git to notice that their Git has renamed master to main and hence to update your origin/HEAD to match. Your origin/HEAD is established when you run git clone and not updated after that, unless you use git remote set-head --auto. You could of course put this git remote set-head operation into your alias.

• Use git remote show, just as you showed. It's in an alias: why do you care how long the alias is?

• Use the upstream setting (git branch --set-upstream-to) and then just run git rebase, so as to pick the upstream of the current branch. Of course that will mostly be origin/name for branch name; presumably, you're using this alias when you want to update your name before a forced push to update the branch named name over on origin. If so, this option is a bad one.

• Write a script. Put the script in your $PATH somewhere, naming it git-rebase-on-default-branch for instance. Running git rebase-on-default-branch will run your script. Now that it's not an alias, but rather a script—in whatever language you like—you can put as much code as you like in it, making it as clever and fancy as you want. (This, I see, is also Ôrel's suggestion.)

There are no doubt more, but this should cover at least some of the bases.

Answer 3

I solved it with a "git" wrapper which rewrites "main" to "master" (or vice versa, depending on the default branch name) in the command arguments before invoking git.

Add this to your PATH somewhere before the actual git command, for example /usr/local/bin, ~/bin, ~/.local/bin, or whatever makes sense on your system. Remember to make it executable too.

Note that:

• You will need zsh (not as the default shell, just installed); I'm sure it can be done in bash too but it's more difficult and I can't be bothered to port it.

• Git is assumed to be in /usr/bin/git; we need the full path because otherwise it'll keep calling itself. Could parse it from PATH, but that's more complex.

• It works everywhere on the commandline (this is a feature): if you type something like git commit -am main then this will get rewritten too if the branch name is master.

• You could convert it to a shell function, which is slightly faster. Then it will only work from your shell though (which may or may not be a good thing, but I like it because e.g. :!git from Vim will work identical).

The upshot of all of this is that you don't need special aliases for every command, and can just continue using git as before.

#!/usr/bin/env zsh
#
# Frob with git so that "main" gets rewritten to "master" if that's the default
# branch, or vice versa.
#
# The "real" git is assumed to be in /usr/bin/git.
[ "${ZSH_VERSION:-}" = "" ] && echo >&2 "Only works with zsh" && exit 1
setopt err_exit no_unset no_clobber pipefail

def=${$(/usr/bin/git symbolic-ref refs/remotes/origin/HEAD >&/dev/null ||:):t}
if [[ $def = 'master' && $argv[(i)main] -le $#argv ]] then
    print >&2 "Using 'main' instead of 'master'"
    argv[$argv[(i)main]]=master
elif [[ $def = 'main' && $argv[(i)master] -le $#argv ]] then
    print >&2 "Using 'master' instead of 'main'"
    argv[$argv[(i)master]]=main
fi

exec /usr/bin/git $argv