Prueba de lo que está a punto de cometerse en un enganche previo a la confirmación

Question

Internet está repleto de respuestas incorrectas y no ideales a esta pregunta. Esto es desafortunado porque pensarías que esto sería algo común que querrías hacer.

El problema: cuando se ejecuta un gancho pre-commit, es posible que el repositorio no esté limpio. Así que si ingenuamente ejecutas tus pruebas, no estarán en contra de lo que estás cometiendo, pero cualquier suciedad que se encuentre en tu árbol de trabajo.

Lo más obvio es hacer git stash --keep-index --include-untracked al comienzo de pre-commit y git pop en la salida. De esta manera, estás probando contra el índice (puro), que es lo que queremos.

Desafortunadamente, esto genera marcadores de conflictos de combinación si usa git add --patch, (especialmente si edita hunks), ya que el contenido de stash@{0} podría no coincidir con el árbol de trabajo después de la confirmación.

Otra solución común es clonar el repositorio y ejecutar las pruebas en uno nuevo temporal. Hay dos problemas con eso: uno es que aún no nos hemos comprometido, por lo que no podemos obtener fácilmente una copia del repositorio en el estado que estamos a punto de comprometer (estoy seguro de que hay una forma de hacerlo) , pero no estoy interesado porque :). En segundo lugar, mis pruebas pueden ser sensibles a la ubicación del directorio de trabajo actual. Por ejemplo, debido a la configuración del entorno local.

Entonces, ¿cómo puedo restaurar mi árbol de trabajo al estado en el que estaba antes del git stash --keep-index --include-untracked, sin introducir los marcadores de conflicto de fusión y sin modificar el HEAD post-commit?

Answer 1

Si la clonación de todo el repositorio es demasiado costosa, quizás solo necesite una copia del directorio de trabajo. Hacer una copia sería más simple que intentar lidiar con conflictos. Por ejemplo:

#!/bin/sh -e 

trap 'rm -rf $TMPD' 0 
mkdir ${TMPD=$PWD/.tmpdir} 
git ls-tree -r HEAD | while read mod type sha name; do 
    if test "$type" = blob; then 
     mkdir -p $TMPD/$(dirname "$name") 
     git show $sha > $TMPD/"$name"; 
     chmod $mod $TMPD/"$name" 
    fi 
done 
cd $TMPD 
git diff --cached HEAD | patch 
# Run tests here 

Esto volcar el estado del árbol, ya que será después de la confirmación de $ DPMT, para que pueda ejecutar las pruebas allí. Debería obtener un directorio temporal de una manera más segura que aquí, pero para que el último diff funcione (o para simplificar el script y el cd anteriormente), debe ser un elemento secundario del directorio de trabajo.

Answer 2

Finalmente he encontrado la solución que estaba buscando. Solo se comprueba el estado del índice antes de la confirmación, y deja el índice y el árbol de trabajo exactamente como estaba antes de la confirmación.

Si ve algún problema o una mejor manera, responda, ya sea como comentario o como respuesta propia.

Esto supone que nada más intentará esconder o modificar el repositorio de git o el árbol de trabajo mientras se está ejecutando. Esto viene sin garantía, puede ser incorrecto y arrojar su código al viento. UTILIZAR CON PRECAUCIÓN.

# pre-commit.sh 
REPO_PATH=$PWD 
git stash save -q --keep-index --include-untracked # (stash@{1}) 
git stash save -q         # (stash@{0}) 

# Our state at this point: 
# * clean worktree 
# * stash@{0} contains what is to be committed 
# * stash@{1} contains everything, including dirt 

# Now reintroduce the changes to be committed so that they can be tested 
git stash apply stash@{0} -q 

git_unstash() { 
    G="git --work-tree \"$REPO_PATH\" --git-dir \"$REPO_PATH/.git\"" 
    eval "$G" reset -q --hard    # Clean worktree again 
    eval "$G" stash pop -q stash@{1}  # Put worktree to original dirty state 
    eval "$G" reset -q stash@{0} .  # Restore index, ready for commit 
    eval "$G" stash drop -q stash@{0}  # Clean up final remaining stash 
} 
trap git_unstash EXIT 

... tests against what is being committed go here ... 

Answer 3

Si usted puede permitirse el lujo de utilizar un directorio temporal (. Es decir, hacer una copia completa de la caja actual) se puede utilizar un directorio temporal de este modo:

tmpdir=$(mktemp -d) # Or put it wherever you like 
git archive HEAD | tar -xf - -C "$tmpdir" 
git diff --staged | patch -p1 -d "$tmpdir" 
cd "$tmpdir" 
... 

Esto es básicamente William Pursell de solución, pero toma ventaja de git archive que hace que el código sea más simple, y espero que sea más rápido.

Alternativamente, por cd'ing primero:

cd somewhere 
git -C path/to/repo archive HEAD | tar -xf - 
git -C path/to/repo diff --staged | patch -p1 
... 

git -C requiere Git 1.8.5.

Answer 4

git write-tree es útil en pre-commit ganchos. Escribe un árbol en el repositorio del índice (este árbol se reutilizará cuando se complete la confirmación).

Una vez que el árbol se escribe en el repositorio, puede usar git archive | tar -x para escribir el árbol en un directorio temporal .

ej .:

#!/bin/bash 

TMPDIR=$(mktemp -d) 
TREE=$(git write-tree) 
git archive $TREE | tar -x -C $TMPDIR 

# Run tests in $TMPDIR 

RESULT=$? 
rm -rf "$TMPDIR" 
exit $RESULT