Setting git default flags on commands

I want to know if there is a way to set a flag by default for git command. Specifically, I want to set the --abbrev-commit flag so that when executing git log , I want to execute git log --abbrev-commit.

Unlike the question "is there any way to set a flag by default for a git command?", there is apparently not a configuration flag for adding --abbrev-commit to git log. Furthermore, the git manual states that I cannot create an alias: "To avoid confusion and troubles with script usage, aliases that hide existing git commands are ignored"

My third option is to invent a new alias like glog=log --abbrev-commit in my .gitconfig file. But I'd rather not invent my own DSL with new commands.

Is there another way to achieve it so that the abbrev-commit flag is set by default??

Since git version 1.7.6, git config has gained a log.abbrevCommit option which can be set to true. Thus the answer is upgrade to at least 1.7.6 (current as of this writing is 1.7.11.4) and use:

git config --global log.abbrevCommit true

You can use a custom format to have git log mimic --abbrev-commit by default:

git config format.pretty "format:%h %s"

There is no generic mechanism in git to set default arguments for commands.

You can use git aliases to define a new command with the required arguments:

git config alias.lg "log --oneline"

Then you can run git lg.

Some commands also have configuration settings to change their behavior.

I like the git log --oneline format. To get it as default, use

git config --global format.pretty oneline

Credit: https://willi.am/blog/2015/02/19/customize-your-git-log-format/

VonC has already hinted at a shell wrapper in his answer; here is my Bash implementation of such a wrapper. If you put this e.g. into your .bashrc, your interactive shell will support overriding of Git built-in commands as well as uppercase aliases.

# Git supports aliases defined in .gitconfig, but you cannot override Git
# builtins (e.g. "git log") by putting an executable "git-log" somewhere in the
# PATH. Also, git aliases are case-insensitive, but case can be useful to create
# a negated command (gf = grep --files-with-matches; gF = grep
# --files-without-match). As a workaround, translate "X" to "-x".
git()
{
    typeset gitAlias="git-$1"
    if type ${BASH_VERSION:+-t} "$gitAlias" >/dev/null 2>&1; then
        shift
        eval $gitAlias '"$@"'
    elif [ "$1" = "${1#-}" ] && expr "$1" : '.*[[:upper:]]' >/dev/null; then
        # Translate "X" to "-x" to enable aliases with uppercase letters.
	translatedAlias=$(echo "$1" | sed -e 's/[[:upper:]]/-\l\0/g')
        shift
        command git "$translatedAlias" "$@"
    else
        command git "$@"
    fi
}

You can then override git log by putting a script named git-log somewhere into your PATH:

#!/bin/sh
exec git log --abbrev-commit "$@"

I have a similar issue (many of the default options for Git commands are dumb). Here's my approach. Create a script called 'grit' (or whatever) on your path, as follows:

#!/bin/bash
cmd=$1
shift 1
if [ "$cmd" = "" ]; then
  git
elif [ $cmd = "log" ]; then
  git log --abbrev-commit $@
elif [ $cmd = "branch" ]; then
  git branch -v $@
elif [ $cmd = "remote" ]; then
  git remote -v $@
else
  git $cmd $@
fi

Very straightforward to read and maintain, in case you need to share it with Bash non-experts.

Every utility we use (svn, maven, git, ...) are always encapsulated in a .bat (on Windows, or .sh on Unix), in order to offer our developers one directory to add to their path.

If git is encapsulated in a wrapper script, then... everything is possible.

But that remains a solution linked to the user's setup, not linked to Git itself or the git repo.