.gitconfig

[include]
  # For username / creds / etc
  path = ~/.gitconfig.local

[status]
  submodulesummary = true # meh, why not.  don't use submodules unless you have to

[push]
  # 'current' should be the safe default.  Without this, by default, 'git push'
  # will push all branches, possibly pushing unintended changes
  default = current

[diff]
  renames = true
  renameLimit = 2000
  noprefix = true # drops the annoying a/filename.foo b/filename.foo prefixes

[merge]
  # This is REALLY useful.  Adds 'original_version' to diffs like so:
  # <<<<<<<
  # OUR_VERSION
  # |||||||
  # ORIGNINAL_VERSION
  # =======
  # THEIR_VERSION
  # >>>>>>>
  conflictstyle = diff3
  defaultToUpstream = true

[core]
  excludesfile = .gitignore.local
  editor = vim

[format]
  pretty = fuller # more detail for "git show"

[color]
  ui = true # everybody loves color (except for Linus :( )

[column]
  # This lets "git stat" stack multiple filenames per row (like vanilla 'ls')
  ui = always

[pretty]
  # Key:
  # %h: abbreviated commit hash (bright yellow)
  # %ar: author date, relative (bright green)
  # %an: author name (red)
  # %s: subject (plain)
  # %d: ref names, like --decorate (pink)
  hist      = "\
%C(bold yellow)%h\
%C(reset)%C(yellow) %t\
%C(bold green) (%ar)\
%C(reset)%C(red) [%an]\
%C(reset) %s\
%C(bold red) %d\
%C(reset)"
  histp     = "\
%C(reset)%C(yellow)%p\
%C(reset) ->\
%C(bold yellow)%h\
%C(bold green) (%ad)\
%C(reset)%C(red) [%an]\
%C(reset) %s\
%C(bold red) %d\
%C(reset)"

  # Key:
  # %gD: reflog selector, e.g., refs/stash@{1}
  # %gs: reflog subject
  # (remainder same as pretty=hist)
  ghist     = "\
%C(bold blue)%gD\
%C(reset)%C(blue) %gs\n\
\
%C(bold yellow)%h\
%C(bold green) (%ar)\
%C(reset)%C(red) [%an]\
%C(reset) %s\
%C(bold red) %d\
%C(reset)"

# DAILY: aliases core to my workflow.
[alias]
  # Short Forms
  co           = checkout
  st           = status --short --branch --untracked-files=no
  sta          = status --short --branch --untracked-files=no
  stat         = status --short --branch --untracked-files=normal
  statall      = status --short --branch --untracked-files=normal --ignored=traditional
  which        = help
  ss           = show --stat
  dc           = diff --cached
  fixup        = commit --fixup
  amend        = commit --amend --no-edit
  export       = "!git commit --amend --no-edit; git5 export"
  u            = "!git add -u; git st"
  rebi         = rebase -i
  pick         = cherry-pick
  ff           = merge --ff-only
  b            = !git branch -vv
  ba           = !git branch -avv
  vs           = !git --paginate versus # Defined below.
  vb           = !git vs blank

  # Rebasing
  abort        = rebase --abort
  continue     = rebase --continue
  skip         = rebase --skip

  # Meh. ...
  autosquash   = rebase -i HEAD~20 --autosquash --preserve-merges

  # Log w/o merges.
  hlog    = !git log --graph --max-parents=1 --date-order --color=always --pretty=hist
  h       = !git --no-pager hlog -10
  hh      = !git --no-pager hlog -20
  hhh     = !git --no-pager hlog -40
  hhhh    = !git --no-pager hlog

  # Log w/ merges.
  mlog    = !git log --graph --date-order --color=always --pretty=hist
  m       = !git --no-pager mlog -10
  mm      = !git --no-pager mlog -20
  mmm     = !git --no-pager mlog -40
  mmmm    = !git --no-pager mlog

  # Reflog history
  glog    = !"\
    git log             \
      --color=always    \
      --date=relative   \
      --walk-reflogs    \
      --invert-grep     \
      --grep-reflog=ceheckout: \
      --pretty=ghist \
      "$@" \
    | perl -ne '\
      if (m/HEAD/ && !m/HEAD.*checkout/) { \
        $print = 2; \
        $primed = 1; \
      } \
      if ($primed and m/HEAD.*checkout/) { \
        $print = 1; \
        $primed = 0; \
      } \
      if ($print) { \
        print; \
        $print -= 1; \
      };'"

  g       = !git --no-pager glog
  gg      = !git --no-pager glog -20
  ggg     = !git --no-pager glog -40
  gggg    = !git --no-pager glog

  histstat= "!\
    git h --stat=160,160 \"$@\" \
      | perl -ne ' \
        /([|*])/; \
        if($1 eq \"*\") { \
          print \
        } else { \
          m/[|] *[0-9]/ and print \
        }'; \
    true"
  hstat   = !git --no-pager histstat -10
  hhstat  = !git --no-pager histstat -20
  hhhstat = !git --no-pager histstat

  hstats  = !git h --shortstat --dirstat=changes,10
  hhstats = !git hh --shortstat --dirstat=changes,10
  hhhstats= !git hhh--shortstat --dirstat=changes,10

################################################################################
# USEFUL ALIASES (ala git's "porcelain")
[alias]
  # git-versus compares the current branch to origin/master or a branch of your
  # choosing, displaying commits to/from the other branch
  # Try "git vs --stat" as well
  # TODO: clean this up to use only plumbing commands:
  # http://schacon.github.com/git/git.html#_low_level_commands_plumbing
  versus = "! \
    O=(); \
    SEEN_DD=false; \
    unset A; \
    while [ ! -z \"$1\" ]; do \
      if [[ \"$1\" =~ ^- ]] || $SEEN_DD; then \
        O=(\"${O[@]}\" $1); \
        if [ \"$1\" == \"--\" ]; then SEEN_DD=true; fi; \
      elif [ -z \"$A\" ]; then \
        A=\"$1\"; \
      else \
        O=(\"${O[@]}\" \"$1\"); \
      fi; \
      shift; \
    done; \
    if ! $SEEN_DD; then O=(\"${O[@]}\" \"--\"); fi; \
    if [ -z \"$A\" ]; then \
      A=$(git first-valid-rev origin/master blank); \
    fi; \
    A=\"${A-origin/master}\"; \
    B=\"$(git symbolic-ref HEAD --short || git rev-parse HEAD)\"; \
    echo From \"$A..$B:\"; \
    git --no-pager mlog $A..$B \"${O[@]}\"; \
    echo; \
    echo From \"$B..$A:\"; \
    git --no-pager mlog $B..$A \"${O[@]}\"; \
    "

  # For repos with multiple working trees [git-worktree]. Parking a secondary
  # working-dir on a 'detached' head (ie, not a named branch) prevents the
  # situation where changes to the named branch, made on he primary working-dir,
  # manifest as an inverse diff on the secondary working-dir (shows up 'green',
  # ie, staged but uncommitted).
  detach = !"\
    if ! git symbolic-ref --quiet HEAD >/dev/null; then \
      echo \"Already detached\" && exit; \
    fi; \
    echo \"Detaching HEAD from $(git current-branch) to $(git rev-parse HEAD)\"; \
    git-checkout --quiet $(git rev-parse HEAD)"
  retach = !git-checkout $(git name-rev --name-only HEAD)

  drop = !git5 drop "$@" && git b -D "$@"

  # Fetch-Rebase: pure AWESOMEness.
  # Fetches 'origin' and rebases the current branch on top of origin/master.
  # Uses 'stash' intelligently to avoid blocking on trivial working-dir changes
  frb = "! \
    git fetch; \
    if git diff-index --quiet --ignore-submodules HEAD --; then \
      git rebase origin/master \"$@\"; \
    else \
      git stash save -q 'Fetch-Rebase Stashed Changes'; \
      git rebase origin/master \"$@\"; \
      git stash pop -q; \
    fi; true"

  # Rebase-interactive: allows editing the specified commit
  rbi = "! git rebase -i $1^"
  rbh1         = rebase -i HEAD^
  rbh2         = rebase -i HEAD^^
  rbh3         = rebase -i HEAD^^^
  rbh4         = rebase -i HEAD^^^^
  rbh5         = rebase -i HEAD^^^^^
  rbh6         = rebase -i HEAD^^^^^^
  rbh7         = rebase -i HEAD^^^^^^^
  rbh8         = rebase -i HEAD^^^^^^^^
  rbh9         = rebase -i HEAD^^^^^^^^^

  # List files ignored by .gitignore and friends
  show-ignored = "! \
    git clean -ndX | \
    perl -pe 's/Would remove/ignored:/'"

  find-children = "! \
    REVSPEC="$(git rev-parse "$1")" || exit; \
    git rev-list $REVSPEC^.. --parents | \
      grep $REVSPEC | \
      cut -d' ' -f1 | \
      xargs git show -s --format=histp --graph --color=always | \
      grep .; \
    true"

  #############################################################################
  # PLUMBING: not intended for direct use.

  # Plunbing: Print the current branch name.
  current-branch = symbolic-ref --quiet --short HEAD

  # Plumbing: echo back the first rev name that exists.
  first-valid-rev = "! \
    while [ ! -z \"$1\" ]; do \
      git rev-parse -q --verify --symbolic \"$1\" && exit; \
      shift; \
    done; \
    # None found \
    exit 1 \
    "

###############################################################################
# DEMO: demonstrate git's behavior and effed-up flags architecture.
[alias]
  # Document symbolic name patterns (this is way more messy than it seems).
  #    {input}       =  {symbolic0}  |   {symbolic1}   |  {symbolic2}
  #  --------------------------------|-----------------|-------------
  #  HEAD(=branch)   =     HEAD      |     branch      |    branch
  #  HEAD(=88916d7)  =     HEAD      |    branch_2     |      ''
  #  branch          =    branch     |     branch      |      ''
  #  invalid         =      ''       |    {error!}     |      ''
  symbolic0 = rev-parse --verify --quiet --symbolic  # Literal.
  symbolic1 = name-rev --always --name-only          # Branch name.
  symbolic2 = symbolic-ref --quiet --short           # HEAD-to-branch-name (one-trick-pony)
  symbolic-demo = !"\
    HASH=$(git rev-parse HEAD); \
    BNAME=$(git current-branch); \
    echo HASH=\"$HASH\"; \
    echo BNAME=\"$BNAME\"; \
    for method in symbolic0 symbolic1 symbolic2; do \
      git checkout --quiet \"$HASH\" || exit; \
      echo \"$method: deHEAD => $(git $method HEAD)\"; \
      git checkout --quiet \"$BNAME\" || exit; \
      for name in HEAD \"$BNAME\" \"$HASH\" inval1d; do \
        echo \"$method: $name => $(git $method $name)\"; \
      done; \
      echo; \
    done; \
    git checkout --quiet \"$BNAME\"; \
    "