J'utilise git avec mon équipe et je voudrais supprimer les changements d'espaces dans mes différences, journaux, fusions, etc. ) de toutes les validations telles qu'elles sont appliquées.

J'ai essayé d'ajouter ce qui suit à par ~/.gitconfigfichier, mais cela ne fait rien lorsque je valide. Peut-être qu'il est conçu pour quelque chose de différent. Quelle est la solution?

[core]
    whitespace = trailing-space,space-before-tab
[apply]
    whitespace = fix

J'utilise du rubis au cas où quelqu'un aurait des idées spécifiques au rubis. La mise en forme automatique du code avant de valider serait la prochaine étape, mais c'est un problème difficile et qui ne cause pas vraiment un gros problème.

Ces paramètres ( core.whitespaceet apply.whitespace) ne sont pas là pour supprimer les espaces de fin, mais pour:

• core.whitespace: les détecter et générer des erreurs
• apply.whitespace: et les supprimer, mais uniquement pendant le patch, pas "toujours automatiquement"

Je pense que git hook pre-commitcela ferait un meilleur travail pour cela (comprend la suppression des espaces de fin)

Notez qu'à tout moment, vous pouvez choisir de ne pas exécuter le pre-commithook:

• temporairement: git commit --no-verify .
• en permanence: cd .git/hooks/ ; chmod -x pre-commit

Avertissement: par défaut, un pre-commitscript (comme celui-ci ), n'a pas de fonction "supprimer la fin", mais une fonction "d'avertissement" comme:

if (/\s$/) {
    bad_line("trailing whitespace", $_);
}

Vous pourriez cependant construire un meilleur pre-commitcrochet , surtout si vous considérez que:

La validation dans Git avec seulement quelques modifications ajoutées à la zone de transfert entraîne toujours une révision «atomique» qui n'a peut - être jamais existé en tant que copie de travail et peut ne pas fonctionner .

Par exemple, Oldman propose dans une autre réponse un pre-commitcrochet qui détecte et supprime les espaces.
Étant donné que ce hook obtient le nom de fichier de chaque fichier, je recommande de faire attention à certains types de fichiers: vous ne voulez pas supprimer les espaces de fin dans les .mdfichiers (démarques)!

Vous pouvez inciter Git à réparer les espaces blancs pour vous, en incitant Git à traiter vos modifications comme un patch. Contrairement aux solutions de "crochet de pré-validation", ces solutions ajoutent des commandes de correction d'espaces à Git.

Oui, ce sont des hacks.

Solutions robustes

Les alias Git suivants sont extraits de my~/.gitconfig .

Par "robuste", je veux dire que ces alias s'exécutent sans erreur, faisant la bonne chose, que l'arborescence ou l'index soient sales. Cependant, ils ne fonctionnent pas si un interactif git rebase -iest déjà en cours; voir mon~/.gitconfig pour des vérifications supplémentaires si vous vous souciez de ce cas d'angle, où l' git add -eastuce décrite à la fin devrait fonctionner.

Si vous souhaitez les exécuter directement dans le shell, sans créer d'alias Git, copiez et collez tout entre les guillemets doubles (en supposant que votre shell ressemble à Bash).

Correction de l'index mais pas de l'arbre

L' fixwsalias Git suivant corrige toutes les erreurs d'espaces dans l'index, le cas échéant, mais ne touche pas l'arborescence:

# Logic:
#
# The 'git stash save' fails if the tree is clean (instead of
# creating an empty stash :P). So, we only 'stash' and 'pop' if
# the tree is dirty.
#
# The 'git rebase --whitespace=fix HEAD~' throws away the commit
# if it's empty, and adding '--keep-empty' prevents the whitespace
# from being fixed. So, we first check that the index is dirty.
#
# Also:
# - '(! git diff-index --quiet --cached HEAD)' is true (zero) if
#   the index is dirty
# - '(! git diff-files --quiet .)' is true if the tree is dirty
#
# The 'rebase --whitespace=fix' trick is from here:
# https://stackoverflow.com/a/19156679/470844
fixws = !"\
  if (! git diff-files --quiet .) && \
     (! git diff-index --quiet --cached HEAD) ; then \
    git commit -m FIXWS_SAVE_INDEX && \
    git stash save FIXWS_SAVE_TREE && \
    git rebase --whitespace=fix HEAD~ && \
    git stash pop && \
    git reset --soft HEAD~ ; \
  elif (! git diff-index --quiet --cached HEAD) ; then \
    git commit -m FIXWS_SAVE_INDEX && \
    git rebase --whitespace=fix HEAD~ && \
    git reset --soft HEAD~ ; \
  fi"

L'idée est de s'exécuter git fixwsavant git commitsi vous avez des erreurs d'espaces dans l'index.

Correction de l'index et de l'arbre

L' fixws-global-tree-and-indexalias Git suivant corrige toutes les erreurs d'espaces dans l'index et l'arborescence, le cas échéant:

# The different cases are:
# - dirty tree and dirty index
# - dirty tree and clean index
# - clean tree and dirty index
#
# We have to consider separate cases because the 'git rebase
# --whitespace=fix' is not compatible with empty commits (adding
# '--keep-empty' makes Git not fix the whitespace :P).
fixws-global-tree-and-index = !"\
  if (! git diff-files --quiet .) && \
     (! git diff-index --quiet --cached HEAD) ; then \
    git commit -m FIXWS_SAVE_INDEX && \
    git add -u :/ && \
    git commit -m FIXWS_SAVE_TREE && \
    git rebase --whitespace=fix HEAD~2 && \
    git reset HEAD~ && \
    git reset --soft HEAD~ ; \
  elif (! git diff-files --quiet .) ; then \
    git add -u :/ && \
    git commit -m FIXWS_SAVE_TREE && \
    git rebase --whitespace=fix HEAD~ && \
    git reset HEAD~ ; \
  elif (! git diff-index --quiet --cached HEAD) ; then \
    git commit -m FIXWS_SAVE_INDEX && \
    git rebase --whitespace=fix HEAD~ && \
    git reset --soft HEAD~ ; \
  fi"

Pour corriger également les espaces dans les fichiers non versionnés, procédez comme suit:

git add --intent-to-add <unversioned files> && git fixws-global-tree-and-index

Solutions simples mais pas robustes

Ces versions sont plus faciles à copier et coller, mais elles ne font pas la bonne chose si leurs conditions secondaires ne sont pas remplies.

Correction du sous-arbre enraciné dans le répertoire courant (mais réinitialise l'index s'il n'est pas vide)

Utiliser git add -epour "éditer" les patchs avec l'éditeur d'identité ::

(export GIT_EDITOR=: && git -c apply.whitespace=fix add -ue .) && git checkout . && git reset

Correction et conservation de l'index (mais échoue si l'arborescence est sale ou l'index est vide)

git commit -m TEMP && git rebase --whitespace=fix HEAD~ && git reset --soft HEAD~

Correction de l'arborescence et de l'index (mais réinitialise l'index s'il n'est pas vide)

git add -u :/ && git commit -m TEMP && git rebase --whitespace=fix HEAD~ && git reset HEAD~

Explication de l' export GIT_EDITOR=: && git -c apply.whitespace=fix add -ue .astuce

Avant d'apprendre l' git rebase --whitespace=fixastuce de cette réponse, j'utilisais git addpartout l'astuce la plus compliquée .

Si nous l'avons fait manuellement:

1. Réglez apply.whitespacesur fix(vous ne devez le faire qu'une seule fois):

   git config apply.whitespace fix
   

   Cela indique à Git de corriger les espaces dans les correctifs .

2. Convaincre Git de traiter vos modifications comme un patch :

   git add -up .
   

   Appuyez sur a+ enterpour sélectionner toutes les modifications pour chaque fichier. Vous recevrez un avertissement vous informant que Git corrige vos erreurs d'espaces.
   ( git -c color.ui=auto diffà ce stade, révèle que vos modifications non indexées sont exactement les erreurs d'espacement).

3. Supprimez les erreurs d'espacement de votre copie de travail:

   git checkout .
   

4. Ramenez vos modifications (si vous n'êtes pas prêt à les valider):

   git reset
   

Le GIT_EDITOR=:moyen à utiliser en :tant qu'éditeur et en tant que commande :est l'identité.

J'ai trouvé un hook de pré-validation git qui supprime les espaces de fin .

#!/bin/sh

if git-rev-parse --verify HEAD >/dev/null 2>&1 ; then
   against=HEAD
else
   # Initial commit: diff against an empty tree object
   against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi
# Find files with trailing whitespace
for FILE in `exec git diff-index --check --cached $against -- | sed '/^[+-]/d' | sed -r 's/:[0-9]+:.*//' | uniq` ; do
   # Fix them!
   sed -i 's/[[:space:]]*$//' "$FILE"
   git add "$FILE"
done
exit

Sous Mac OS (ou, probablement, n'importe quel BSD), les paramètres de la commande sed doivent être légèrement différents. Essaye ça:

#!/bin/sh

if git-rev-parse --verify HEAD >/dev/null 2>&1 ; then
   against=HEAD
else
   # Initial commit: diff against an empty tree object
   against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi

# Find files with trailing whitespace
for FILE in `exec git diff-index --check --cached $against -- | sed '/^[+-]/d' | sed -E 's/:[0-9]+:.*//' | uniq` ; do
    # Fix them!
    sed -i '' -E 's/[[:space:]]*$//' "$FILE"
    git add "$FILE"
done

Enregistrez ce fichier sous .git/hooks/pre-commit- ou recherchez celui qui est déjà là, et collez le morceau inférieur quelque part à l'intérieur. Et souvenez-vous-en chmod a+xaussi.

Ou pour une utilisation globale (via les hooks de validation Git - paramètres globaux ), vous pouvez le placer $GIT_PREFIX/git-core/templates/hooks(où GIT_PREFIX est / usr ou / usr / local ou / usr / share ou / opt / local / share) et l'exécuter git initdans votre référentiel existant.

Selon git help init:

L'exécution de git init dans un référentiel existant est sûre. Il n'écrasera pas les éléments qui existent déjà. La principale raison de la réexécution de git init est de récupérer les nouveaux modèles ajoutés.

Je préfère laisser cette tâche à votre éditeur préféré.

Définissez simplement une commande pour supprimer les espaces de fin lors de l'enregistrement.

Utilisation des attributs git et de la configuration des filtres avec git config

OK, c'est une nouvelle approche pour résoudre ce problème… Mon approche est de ne pas utiliser de hooks, mais plutôt d'utiliser des filtres et des attributs git. Ce que cela vous permet de faire, c'est de configurer, sur chaque machine sur laquelle vous développez, un ensemble de filtres qui supprimera les espaces blancs finaux supplémentaires et les lignes vierges supplémentaires à la fin des fichiers avant de les valider. Configurez ensuite un fichier .gitattributes qui indique à quels types de fichiers le filtre doit être appliqué. Les filtres ont deux phases, cleanqui sont appliquées lors de l'ajout de fichiers à l'index, etsmudge qui sont appliquées lors de leur ajout au répertoire de travail.

Dites à votre git de rechercher un fichier d'attributs global

Tout d'abord, dites à votre configuration globale d'utiliser un fichier d'attributs global:

git config --global core.attributesfile ~/.gitattributes_global

Créer des filtres globaux

Maintenant, créez le filtre:

git config --global filter.fix-eol-eof.clean fixup-eol-eof %f
git config --global filter.fix-eol-eof.smudge cat
git config --global filter.fix-eol-eof.required true

Ajoutez la magie des scripts sed

Enfin, mettez le fixup-eol-eof script quelque part sur votre chemin et rendez-le exécutable. Le script utilise sed pour effectuer certaines modifications à la volée (supprimer les espaces et les blancs à la fin des lignes et les lignes blanches superflues à la fin du fichier)

fixup-eol-eof devrait ressembler à ceci:

#!/bin/bash
sed -e 's/[  ]*$//' -e :a -e '/^\n*$/{$d;N;ba' -e '}' $1

mon essentiel de cela

Dites à git à quels types de fichiers appliquer votre filtre nouvellement créé

Enfin, créez ou ouvrez ~ / .gitattributes_global dans votre éditeur préféré et ajoutez des lignes comme:

pattern attr1 [attr2 [attr3 […]]]

Donc, si nous voulons résoudre le problème des espaces, pour tous nos fichiers source c, nous ajouterions une ligne qui ressemble à ceci:

*.c filter=fix-eol-eof

Discussion du filtre

Le filtre a deux phases, la phase de nettoyage qui est appliquée lorsque des éléments sont ajoutés à l'index ou archivés, et la phase de maculage lorsque git place des éléments dans votre répertoire de travail. Ici, notre tache exécute simplement le contenu via la catcommande qui devrait les laisser inchangés, à l'exception peut-être d'ajouter un caractère de fin de ligne s'il n'y en avait pas à la fin du fichier. La commande clean est le filtrage des espaces que j'ai bricolé à partir de notes sur http://sed.sourceforge.net/sed1line.txt . Il semble qu'il doit être mis dans un script shell, je n'ai pas pu comprendre comment injecter la commande sed, y compris l'assainissement des lignes supplémentaires superflues à la fin du fichier directement dans le fichier git-config. (Vous POUVEZse débarrasser des blancs de fin, cependant, sans avoir besoin d'un script sed séparé, il suffit de définir filter.fix-eol-eofquelque chose comme sed 's/[ \t]*$//' %foù se \ttrouve un onglet réel, en appuyant sur tab.)

L'exigence require = true déclenche une erreur en cas de problème, afin de vous éviter des ennuis.

Veuillez me pardonner si ma langue concernant git est imprécise. Je pense avoir une assez bonne compréhension des concepts mais j'apprends encore la terminologie.

J'ai écrit ce crochet de pré-validation, qui supprime uniquement l'espace blanc de fin des lignes que vous avez modifiées / ajoutées, car les suggestions précédentes ont tendance à créer des validations illisibles si les fichiers cibles ont trop d'espace blanc de fin.

#!/bin/sh

if git rev-parse --verify HEAD >/dev/null 2>&1 ; then
   against=HEAD
else
   # Initial commit: diff against an empty tree object
   against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi

IFS='
'

files=$(git diff-index --check --cached $against -- | sed '/^[+-]/d' | perl -pe 's/:[0-9]+:.*//' | uniq)
for file in $files ; do
    diff=$(git diff --cached $file)
    if test "$(git config diff.noprefix)" = "true"; then
        prefix=0
    else
        prefix=1
    fi
    echo "$diff" | patch -R -p$prefix
    diff=$(echo "$diff" | perl -pe 's/[ \t]+$// if m{^\+}')
    out=$(echo "$diff" | patch -p$prefix -f -s -t -o -)
    if [ $? -eq 0 ]; then
        echo "$diff" | patch -p$prefix -f -t -s
    fi
    git add $file
done

Veuillez essayer mes crochets de pré-validation , il peut détecter automatiquement les espaces de fin et les supprimer . Je vous remercie!

ça peut marcher sous GitBash(windows), Mac OS X and Linux!

Instantané:

$ git commit -am "test"
auto remove trailing whitespace in foobar/main.m!
auto remove trailing whitespace in foobar/AppDelegate.m!
[master 80c11fe] test
1 file changed, 2 insertions(+), 2 deletions(-)

Voici une version compatible ubuntu + mac os x:

#!/bin/sh
#

# A git hook script to find and fix trailing whitespace
# in your commits. Bypass it with the --no-verify option
# to git-commit
#

if git-rev-parse --verify HEAD >/dev/null 2>&1 ; then
  against=HEAD
else
  # Initial commit: diff against an empty tree object
  against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi
# Find files with trailing whitespace
for FILE in `exec git diff-index --check --cached $against -- | sed '/^[+-]/d' | (sed -r 's/:[0-9]+:.*//' > /dev/null 2>&1 || sed -E 's/:[0-9]+:.*//') | uniq` ; do
  # Fix them!
  (sed -i 's/[[:space:]]*$//' "$FILE" > /dev/null 2>&1 || sed -i '' -E 's/[[:space:]]*$//' "$FILE")
  git add "$FILE"
done

# Now we can commit
exit

S'amuser

J'y pensais aujourd'hui. C'est tout ce que j'ai fini par faire pour un projet java:

egrep -rl ' $' --include *.java *  | xargs sed -i 's/\s\+$//g'

Pour les utilisateurs de Sublime Text .

Définissez correctement les paramètres suivants dans la configuration des paramètres utilisateur .

"trim_trailing_white_space_on_save": true

la boucle for pour les fichiers utilise la variable shell $ IFS. dans le script donné, les noms de fichiers contenant un caractère qui se trouve également dans la variable $ IFS seront considérés comme deux fichiers différents dans la boucle for. Ce script le corrige: le modificateur de mode multiligne tel que sed-manual ne semble pas fonctionner par défaut sur ma boîte Ubuntu, j'ai donc cherché une implémentation différente et l'ai trouvé avec une étiquette itérative, essentiellement il ne commencera la substitution que sur le dernière ligne du fichier si je l'ai bien compris.

#!/bin/sh
#

# A git hook script to find and fix trailing whitespace
# in your commits. Bypass it with the --no-verify option
# to git-commit
#

if git rev-parse --verify HEAD >/dev/null 2>&1
then
    against=HEAD
else
    # Initial commit: diff against an empty tree object
    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi

SAVEIFS="$IFS"
# only use new-line character as seperator, introduces EOL-bug?
IFS='
'
# Find files with trailing whitespace
for FILE in $(
    git diff-index --check --cached $against -- \
    | sed '/^[+-]/d' \
    | ( sed -r 's/:[0-9]+:.*//' || sed -E 's/:[0-9]+:.*//' ) \
    | uniq \
)
do
# replace whitespace-characters with nothing
# if first execution of sed-command fails, try second one( MacOSx-version)
    (
        sed -i ':a;N;$!ba;s/\n\+$//' "$FILE" > /dev/null 2>&1 \
        || \
        sed -i '' -E ':a;N;$!ba;s/\n\+$//' "$FILE" \
    ) \
    && \
# (re-)add files that have been altered to git commit-tree
#   when change was a [:space:]-character @EOL|EOF git-history becomes weird...
    git add "$FILE"
done
# restore $IFS
IFS="$SAVEIFS"

# exit script with the exit-code of git's check for whitespace-characters
exec git diff-index --check --cached $against --

[1] Modèle sed-subsition: comment remplacer une nouvelle ligne (\ n) en utilisant sed? .

Cela ne supprime pas automatiquement les espaces avant un commit, mais il est assez facile à effectuer. J'ai mis le script perl suivant dans un fichier nommé git-wsf (git whitespace fix) dans un répertoire dans $ PATH pour que je puisse:

git wsf | sh

et il supprime tous les espaces uniquement des lignes de fichiers qui git les rapports en tant que diff.

#! /bin/sh
git diff --check | perl -x $0
exit

#! /usr/bin/perl

use strict;

my %stuff;
while (<>) {
    if (/trailing whitespace./) {
        my ($file,$line) = split(/:/);
        push @{$stuff{$file}},$line;
    }
}

while (my ($file, $line) = each %stuff) {
    printf "ex %s <<EOT\n", $file;
    for (@$line) {
        printf '%ds/ *$//'."\n", $_;
    }
    print "wq\nEOT\n";
}

Un peu tard, mais comme cela pourrait aider quelqu'un là-bas, c'est parti.

Ouvrez le fichier dans VIM. Pour remplacer les onglets par des espaces, tapez ce qui suit dans la ligne de commande vim

:%s#\t#    #gc

Pour se débarrasser des autres espaces vides de fin

:%s#\s##gc

C'est à peu près tout pour moi. C'est fastidieux si vous avez beaucoup de fichiers à éditer. Mais je l'ai trouvé plus facile que les hooks de pré-validation et le travail avec plusieurs éditeurs.

Pour supprimer les espaces blancs de fin à la fin de la ligne d'un fichier de manière portable, utilisez ed:

test -s file &&
   printf '%s\n' H ',g/[[:space:]]*$/s///' 'wq' | ed -s file

Cela ne résoudra probablement pas directement votre problème, mais vous voudrez peut-être les définir via git-config dans votre espace de projet réel, qui édite ./.git/config par opposition à ~ / .gitconfig. Agréable de garder les paramètres cohérents entre tous les membres du projet.

git config core.whitespace "trailing-space,space-before-tab"
git config apply.whitespace "trailing-space,space-before-tab"