Я использую git с моей командой и хотел бы удалить изменения пробелов из моих различий, журналов, слияний и т. Д. Я предполагаю, что самый простой способ сделать это - git автоматически удалить конечные пробелы (и другие ошибки пробелов) ) из всех коммитов по мере их применения.

Я попытался добавить следующее к ~/.gitconfigфайлу, но он ничего не делает, когда я фиксирую. Может быть, он предназначен для чего-то другого. Какое решение?

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

Я использую ruby ​​на тот случай, если у кого-нибудь есть какие-то конкретные идеи. Следующим шагом будет автоматическое форматирование кода перед фиксацией, но это сложная проблема, которая не вызывает больших проблем.

Эти настройки ( core.whitespaceи apply.whitespace) предназначены не для удаления конечных пробелов, а для:

• core.whitespace: обнаружить их и вызвать ошибки
• apply.whitespace: и лишить их, но только во время патча, а не "всегда автоматически"

Я считаю, что git hook pre-commitэто сделало бы лучшую работу для этого (в том числе удаление конечных пробелов)

Обратите внимание, что в любой момент вы можете не запускать pre-commitхук:

• временно: git commit --no-verify .
• постоянно: cd .git/hooks/ ; chmod -x pre-commit

Предупреждение: по умолчанию, pre-commitскрипт (как этот ), имеет не функцию «удаления висячего», а функцию «предупреждения», такую ​​как:

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

Однако вы можете создать лучший pre-commitхук , особенно если учесть, что:

Фиксация в Git только с некоторыми изменениями, добавленными в область подготовки, все еще приводит к «атомарной» ревизии, которая, возможно, никогда не существовала в качестве рабочей копии и может не работать .

Например, Олдман предлагает в другой ответ на pre-commitкрючок , который детектирует и удалить пробелы.
Так как этот хук получает имя файла каждого файла, я бы рекомендовал быть осторожным с определенным типом файлов: вы не хотите удалять конечные пробелы в .md(уценке) файлах!

Вы можете обмануть Git, чтобы исправить пробелы для вас, обманув Git, рассматривая ваши изменения как патч. В отличие от решений «pre-commit hook», эти решения добавляют в Git команды исправления пробелов.

Да, это хаки.

Надежные решения

Следующие псевдонимы Git взяты из моего~/.gitconfig .

Под «устойчивым» я подразумеваю, что эти псевдонимы работают без ошибок, делая правильные вещи, независимо от того, являются ли дерево или индекс грязными. Тем не менее, они не работают, если интерактив git rebase -iуже выполняется; см. мои~/.gitconfig дополнительные проверки, если вам небезразличен этот угловой случай, где git add -eописанный в конце прием должен работать.

Если вы хотите запустить их непосредственно в оболочке, не создавая псевдоним Git, просто скопируйте и вставьте все в двойные кавычки (при условии, что ваша оболочка похожа на Bash).

Исправить индекс, но не дерево

Следующий fixwsпсевдоним Git исправляет все пробельные ошибки в индексе, если таковые имеются, но не затрагивает дерево:

# 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"

Идея состоит в том, чтобы запускаться git fixwsраньше, git commitесли у вас есть ошибки пробела в индексе.

Исправить индекс и дерево

Следующий fixws-global-tree-and-indexпсевдоним Git исправляет все ошибки пробелов в индексе и дереве, если они есть:

# 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"

Чтобы также исправить пробелы в неверсионных файлах, выполните

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

Простые, но не надежные решения

Эти версии легче копировать и вставлять, но они не делают правильных вещей, если их побочные условия не выполняются.

Исправьте поддерево с корнем в текущем каталоге (но сбрасывает индекс, если он не пустой)

Использование git add -eдля «редактирования» патчей с помощью редактора идентичности ::

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

Исправить и сохранить индекс (но не работает, если дерево грязное или индекс пустой)

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

Исправьте дерево и индекс (но сбрасывает индекс, если он не пустой)

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

Объяснение export GIT_EDITOR=: && git -c apply.whitespace=fix add -ue .уловки

Прежде чем я узнал об git rebase --whitespace=fixуловке из этого ответа, я использовал более сложную git addуловку везде.

Если мы сделали это вручную:

1. Установите apply.whitespaceв fix(вы должны сделать это только один раз):

   git config apply.whitespace fix
   

   Это говорит Git исправлять пробелы в патчах .

2. Убедите Git рассматривать ваши изменения как патч :

   git add -up .
   

   Нажмите a+, enterчтобы выбрать все изменения для каждого файла. Вы получите предупреждение о том, что Git исправляет ваши пробельные ошибки.
   ( git -c color.ui=auto diffв этот момент обнаруживается, что ваши неиндексированные изменения являются именно ошибками пробелов).

3. Удалите ошибки пробелов из вашей рабочей копии:

   git checkout .
   

4. Верните ваши изменения (если вы не готовы их зафиксировать):

   git reset
   

В GIT_EDITOR=:средстве для использования в :качестве редактора, и как команда :является тождественным.

Я нашел git pre-commit hook, который удаляет завершающие пробелы .

#!/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

В Mac OS (или, скорее всего, в любом BSD) параметры команды sed должны немного отличаться. Попробуй это:

#!/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

Сохраните этот файл как .git/hooks/pre-commit- или найдите тот, который уже там, и вставьте нижний блок где-нибудь внутри него. И помните, chmod a+xэто тоже.

Или для глобального использования (через Git commit hooks - глобальные настройки ) вы можете поместить его $GIT_PREFIX/git-core/templates/hooks(где GIT_PREFIX - / usr или / usr / local или / usr / share или / opt / local / share) и запустить git initвнутри существующих репозиториев.

По словам git help init:

Запуск git init в существующем хранилище безопасен. Это не перезапишет то, что уже есть. Основная причина перезапуска git init - это выбор новых добавленных шаблонов.

Я бы предпочел оставить это задание вашему любимому редактору.

Просто установите команду для удаления завершающих пробелов при сохранении.

Использование атрибутов git и настройка фильтров с помощью git config

Хорошо, это новый подход к решению этой проблемы ... Мой подход состоит в том, чтобы не использовать какие-либо хуки, а использовать фильтры и атрибуты git. Это позволяет вам настроить на каждом компьютере, на котором вы разрабатываете, набор фильтров, которые уберут лишние пробелы и лишние пустые строки в конце файлов перед их фиксацией. Затем настройте файл .gitattributes, в котором указано, к каким типам файлов должен применяться фильтр. Фильтры имеют две фазы, cleanкоторые применяются при добавлении файлов в индекс, иsmudge которые применяются при добавлении их в рабочий каталог.

Скажите вашему git искать глобальный файл атрибутов

Сначала скажите вашей глобальной конфигурации использовать файл глобальных атрибутов:

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

Создать глобальные фильтры

Теперь создайте фильтр:

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

Добавьте магию сценариев sed

Наконец, положить fixup-eol-eof скрипт где-нибудь на вашем пути и сделайте его исполняемым. Сценарий использует sed для редактирования на лету (удаление пробелов и пробелов в конце строк и лишних пустых строк в конце файла)

fixup-eol-eof должен выглядеть так:

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

моя суть этого

Сообщите git, к каким типам файлов применять ваш вновь созданный фильтр

Наконец, создайте или откройте ~ / .gitattributes_global в вашем любимом редакторе и добавьте такие строки, как:

pattern attr1 [attr2 [attr3 […]]]

Поэтому, если мы хотим исправить проблему пробелов, для всех наших исходных файлов c мы добавим строку, которая выглядит следующим образом:

*.c filter=fix-eol-eof

Обсуждение фильтра

Фильтр имеет две фазы: чистая фаза, которая применяется, когда вещи добавляются в индекс или регистрируются, и фаза размазывания, когда git помещает вещи в ваш рабочий каталог. Здесь наше пятно просто запускает содержимое через catкоманду, которая должна оставить их без изменений, за исключением возможного добавления завершающего символа новой строки, если в конце файла его не было. Команда clean - это фильтрация пробелов, которую я собрал из заметок на http://sed.sourceforge.net/sed1line.txt . Кажется, что это должно быть помещено в сценарий оболочки, я не мог понять, как внедрить команду sed, в том числе очистку лишних лишних строк в конце файла непосредственно в файле git-config. (Вы МОЖЕТЕизбавиться от конечных пробелов, однако, без необходимости отдельного сценария sed, просто установите на filter.fix-eol-eofчто-то вроде, sed 's/[ \t]*$//' %fгде \tявляется реальной вкладкой, нажав tab.)

Require = true вызывает ошибку, если что-то идет не так, чтобы вы не попадали в неприятности.

Пожалуйста, прости меня, если мой язык относительно мерзости неточен. Я думаю, что я достаточно хорошо понимаю концепции, но все еще изучаю терминологию.

Я написал этот хук перед фиксацией, который удаляет только пробел из строк, которые вы изменили / добавили, поскольку предыдущие предложения, как правило, создают нечитаемые коммиты, если целевые файлы имеют слишком много пробела.

#!/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

Пожалуйста, попробуйте мой предварительный коммит хуки , он может автоматически определить конечный пробел и удалить его . Спасибо!

это может работать под GitBash(windows), Mac OS X and Linux!

Снимок:

$ 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(-)

Вот версия, совместимая с 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

Радоваться, веселиться

Думал об этом сегодня. Это все, что я сделал для проекта Java:

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

Для пользователей Sublime Text .

Правильно настройте следующее в настройках пользователя .

"trim_trailing_white_space_on_save": true

цикл for для файлов использует переменную оболочки $ IFS. в данном сценарии имена файлов с символом в них, который также находится в переменной $ IFS, будут рассматриваться как два разных файла в цикле for. Этот скрипт исправляет это: модификатор многострочного режима, как указано в sed-manual, по-видимому, не работает по умолчанию на моем компьютере с Ubuntu, поэтому я искал другую реализацию и нашел это с помощью итеративной метки, по сути, он только начнет замену на Последняя строка файла, если я правильно понял.

#!/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] шаблон sed-subition: как заменить символ новой строки (\ n) с помощью sed? ,

Это не удаляет пробелы автоматически перед фиксацией, но это довольно легко сделать. Я поместил следующий скрипт на Perl в файл с именем git-wsf (git whitespace fix) в директорию в $ PATH, чтобы я мог:

мерзавец wsf | ш

и он удаляет все пробелы только из строк файлов, которые git сообщает как 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";
}

Немного поздно, но так как это может помочь кому-то там, здесь идет.

Откройте файл в VIM. Чтобы заменить вкладки пробелами, введите в командной строке vim следующую команду

:%s#\t#    #gc

Чтобы избавиться от других конечных пробелов

:%s#\s##gc

Это в значительной степени сделало это для меня. Это утомительно, если у вас есть много файлов для редактирования. Но я обнаружил, что это проще, чем предварительная фиксация и работа с несколькими редакторами.

Чтобы удалить конечные пробелы в конце строки в файле, используйте ed:

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

Это, вероятно, не решит вашу проблему напрямую, но вы можете установить ее с помощью git-config в вашем реальном пространстве проекта, которое редактирует ./.git/config, а не ~ / .gitconfig. Приятно сохранять настройки согласованными среди всех участников проекта.

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