¿Cómo determino programáticamente si hay cambios no confirmados?

En un Makefile, me gustaría realizar ciertas acciones si hay cambios no confirmados (ya sea en el árbol de trabajo o en el índice). ¿Cuál es la forma más limpia y eficiente de hacer eso? Un comando que sale con un valor de retorno de cero en un caso y distinto de cero en el otro sería adecuado para mis propósitos.

Puedo ejecutar git statusy canalizar la salida grep, pero siento que debe haber una mejor manera.

ACTUALIZACIÓN : el OP Daniel Stutzbach señala en los comentarios que este simple comando git diff-indexfuncionó para él:

git update-index --refresh 
git diff-index --quiet HEAD --

( Nornagon menciona en los comentarios que, si hay archivos que se han tocado, pero cuyo contenido es el mismo que en el índice, deberá ejecutarlo git update-index --refreshantes git diff-index; de lo contrario diff-index, informará incorrectamente que el árbol está sucio)

Luego puede ver " ¿Cómo verificar si un comando tuvo éxito? " Si lo está utilizando en un script bash:

git diff-index --quiet HEAD -- || echo "untracked"; // do something about it

Nota: como se ha comentado por Anthony Sottile

git diff-index HEAD ...fallará en una rama que no tiene confirmaciones (como un repositorio recién inicializado).
Una solución que he encontrado esgit diff-index $(git write-tree) ...

Y haridsvseñala en los comentarios que git diff-filesen un nuevo archivo no lo detecta como una diferencia.
El enfoque más seguro parece ser ejecutar git addprimero en la especificación del archivo y luego usar git diff-indexpara ver si se agregó algo al índice antes de ejecutarse git commit.

git add ${file_args} && \
git diff-index --cached --quiet HEAD || git commit -m '${commit_msg}'

Y 6502 informes en los comentarios:

Un problema con el que me topé es que git diff-indexdirá que hay diferencias cuando de hecho no hay ninguna, excepto las marcas de tiempo de los archivos.
Ejecutar git diffuna vez resuelve el problema (sorprendentemente, en git diffrealidad cambia el contenido del sandbox, lo que significa aquí .git/index)

Estos problemas de marca de tiempo también pueden ocurrir si git se está ejecutando en Docker .

Respuesta original:

"Programáticamente" significa nunca confiar en los comandos de porcelana .
Siempre confíe en los comandos de plomería .

Consulte también " Verificación de un índice sucio o archivos sin seguimiento con Git " para alternativas (como git status --porcelain)

Puede inspirarse en la nueva " require_clean_work_treefunción " que está escrita mientras hablamos ;) (principios de octubre de 2010)

require_clean_work_tree () {
    # Update the index
    git update-index -q --ignore-submodules --refresh
    err=0

    # Disallow unstaged changes in the working tree
    if ! git diff-files --quiet --ignore-submodules --
    then
        echo >&2 "cannot $1: you have unstaged changes."
        git diff-files --name-status -r --ignore-submodules -- >&2
        err=1
    fi

    # Disallow uncommitted changes in the index
    if ! git diff-index --cached --quiet HEAD --ignore-submodules --
    then
        echo >&2 "cannot $1: your index contains uncommitted changes."
        git diff-index --cached --name-status -r --ignore-submodules HEAD -- >&2
        err=1
    fi

    if [ $err = 1 ]
    then
        echo >&2 "Please commit or stash them."
        exit 1
    fi
}

Si bien las otras soluciones son muy completas, si quieres algo realmente rápido y sucio, prueba algo como esto:

[[ -z $(git status -s) ]]

Simplemente comprueba si hay algún resultado en el resumen de estado.

git diff --exit-codedevolverá un valor distinto de cero si hay algún cambio; git diff --quietEs lo mismo sin salida. Como desea verificar el árbol de trabajo y el índice, use

git diff --quiet && git diff --cached --quiet

O

git diff --quiet HEAD

Cualquiera de los dos le dirá si hay cambios no confirmados que se organizan o no.

Ampliando la respuesta de @ Nepthar:

if [[ -z $(git status -s) ]]
then
  echo "tree is clean"
else
  echo "tree is dirty, please commit changes before running this"
  exit
fi

Como se señaló en otra respuesta, tan simple como dicho comando es suficiente:

git diff-index --quiet HEAD --

Si omite los dos últimos guiones, el comando fallará si tiene un archivo llamado HEAD.

Ejemplo:

#!/bin/bash
set -e
echo -n "Checking if there are uncommited changes... "
trap 'echo -e "\033[0;31mFAILED\033[0m"' ERR
git diff-index --quiet HEAD --
trap - ERR
echo -e "\033[0;32mAll set!\033[0m"

# continue as planned...

Advertencia: este comando ignora los archivos no rastreados.

Creé algunos prácticos alias de git para enumerar archivos sin clasificar y en etapas:

git config --global alias.unstaged 'diff --name-only'
git config --global alias.staged 'diff --name-only --cached'

Entonces puedes hacer cosas como:

[[ -n "$(git unstaged)" ]] && echo unstaged files || echo NO unstaged files
[[ -n "$(git staged)" ]] && echo staged files || echo NO staged files

Puede hacerlo más legible creando un script en algún lugar de su PATHllamada git-has:

#!/bin/bash
[[ $(git "$@" | wc -c) -ne 0 ]]

Ahora los ejemplos anteriores se pueden simplificar para:

git has unstaged && echo unstaged files || echo NO unstaged files
git has staged && echo staged files || echo NO staged files

Para completar, aquí hay alias similares para archivos no rastreados e ignorados:

git config --global alias.untracked 'ls-files --exclude-standard --others'
git config --global alias.ignored 'ls-files --exclude-standard --others --ignored'

Con python y el paquete GitPython:

import git
git.Repo(path).is_dirty(untracked_files=True)

Devuelve True si el repositorio no está limpio

Aquí está la mejor y más limpia manera.

function git_dirty {
    text=$(git status)
    changed_text="Changes to be committed"
    untracked_files="Untracked files"

    dirty=false

    if [[ ${text} = *"$changed_text"* ]];then
        dirty=true
    fi

    if [[ ${text} = *"$untracked_files"* ]];then
        dirty=true
    fi

    echo $dirty
}