Make Git automatically remove trailing white space before committing
GitWhitespaceGithooksGit Problem Overview
I'm using Git with my team and would like to remove white space changes from my diffs, logs, merges, etc. I'm assuming that the easiest way to do this would be for Git to automatically remove trailing white space (and other white space errors) from all commits as they are applied.
I have tried to add the following to the ~/.gitconfig
file, but it doesn't do anything when I commit. Maybe it's designed for something different. What's the solution?
[core]
whitespace = trailing-space,space-before-tab
[apply]
whitespace = fix
I'm using Ruby in case anyone has any Ruby specific ideas. Automatic code formatting before committing would be the next step, but that's a hard problem and is not really causing a big problem.
Git Solutions
Solution 1 - Git
Those settings (core.whitespace
and apply.whitespace
) are not there to remove trailing whitespace but to:
core.whitespace
: detect them, and raise errorsapply.whitespace
: and strip them, but only during patch, not "always automatically"
I believe the git hook pre-commit
would do a better job for that (includes removing trailing whitespace)
Note that at any given time you can choose to not run the pre-commit
hook:
- temporarily:
git commit --no-verify .
- permanently:
cd .git/hooks/ ; chmod -x pre-commit
Warning: by default, a pre-commit
script (like this one), has not a "remove trailing" feature", but a "warning" feature like:
if (/\s$/) {
bad_line("trailing whitespace", $_);
}
You could however build a better pre-commit
hook, especially when you consider that:
> Committing in Git with only some changes added to the staging area still results in an “atomic” revision that may never have existed as a working copy and may not work.
For instance, oldman proposes in another answer a pre-commit
hook which detects and remove whitespace.
Since that hook get the file name of each file, I would recommend to be careful for certain type of files: you don't want to remove trailing whitespace in .md
(markdown) files!
Another approach, suggested by hakre in the comments:
> You can have two spaces at end of line in markdown and not have it as trailing whitespace by adding "\
" before \n
.
Then a content filter driver:
git config --global filter.space-removal-at-eol.clean 'sed -e "s/ \+$//"'
# register in .gitattributes
*.md filter=space-removal-at-eol
Solution 2 - Git
You can trick Git into fixing the whitespace for you, by tricking Git into treating your changes as a patch. In contrast to the "pre-commit hook" solutions, these solutions add whitespace-fixing commands to Git.
Yes, these are hacks.
Robust solutions
The following Git aliases are taken from
my ~/.gitconfig
.
By "robust" I mean that these aliases run without error, doing
the right thing, regardless of whether the tree or index are dirty. However, they don't work if an interactive git rebase -i
is already in progress; see my ~/.gitconfig
for additional checks if you care about this corner case, where the git add -e
trick described at the end should work.
If you want to run them directly in the shell, without creating a Git alias, just copy and paste everything between the double quotes (assuming your shell is Bash like).
Fix the index but not the tree
The following fixws
Git alias fixes all whitespace errors in the index,
if any, but doesn't touch the tree:
# 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"
The idea is to run git fixws
before git commit
if you have
whitespace errors in the index.
Fix the index and the tree
The following fixws-global-tree-and-index
Git alias fixes all whitespace
errors in the index and the tree, if any:
# 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"
To also fix whitespace in unversioned files, do
git add --intent-to-add <unversioned files> && git fixws-global-tree-and-index
Simple but not robust solutions
These versions are easier to copy and paste, but they don't do the right thing if their side conditions are not met.
Fix the sub-tree rooted at the current directory (but resets the index if it's not empty)
Using git add -e
to "edit" the patches with the identity editor :
:
(export GIT_EDITOR=: && git -c apply.whitespace=fix add -ue .) && git checkout . && git reset
Fix and preserve the index (but fails if the tree is dirty or the index is empty)
git commit -m TEMP && git rebase --whitespace=fix HEAD~ && git reset --soft HEAD~
Fix the tree and the index (but resets the index if it's not empty)
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 .
trick
Explanation of the Before I learned about the git rebase --whitespace=fix
trick from this answer I was using the more complicated git add
trick everywhere.
If we did it manually:
-
Set
apply.whitespace
tofix
(you only have to do this once):git config apply.whitespace fix
This tells Git to fix whitespace in patches.
-
Convince Git to treat your changes as a patch:
git add -up .
Hit a+enterto select all changes for each file. You'll get a warning about Git fixing your whitespace errors.
(git -c color.ui=auto diff
at this point reveals that your non-indexed changes are exactly the whitespace errors). -
Remove the whitespace errors from your working copy:
git checkout .
-
Bring back your changes (if you aren't ready to commit them):
git reset
The GIT_EDITOR=:
means to use :
as the editor, and as a command
:
is the identity.
Solution 3 - Git
I found a Git pre-commit hook that removes trailing white space.
#!/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
Solution 4 - Git
On macOS (or, likely, any BSD), the sed command parameters have to be slightly different. Try this:
#!/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
Save this file as .git/hooks/pre-commit
-- or look for the one that's already there, and paste the bottom chunk somewhere inside it. And remember to chmod a+x
it too.
Or for global use (via https://stackoverflow.com/questions/2293498) you can put it in $GIT_PREFIX/git-core/templates/hooks
(where GIT_PREFIX is /usr or /usr/local or /usr/share or /opt/local/share) and run git init
inside your existing repos.
According to git help init
:
> Running git init
in an existing repository is safe. It will not overwrite things that are already there. The primary reason for rerunning git init
is to pick up newly added templates.
Solution 5 - Git
I'd rather leave this task to your favorite editor.
Just set a command to remove trailing spaces when saving.
Solution 6 - Git
Using Git attributes, and filters setup with Git configuration
OK, this is a new tack on solving this problem… My approach is to not use any hooks, but rather use filters and Git attributes. This allows you to set up, on each machine you develop on, a set of filters that will strip extra trailing white space and extra blank lines at the end of files before committing them.
Then set up a .gitattributes file that says which types of files the filter should be applied to. The filters have two phases, clean
which is applied when adding files to the index, and smudge
which is applied when adding them to the working directory.
Tell your Git to look for a global attributes file
First, tell your global configuration to use a global attributes file:
git config --global core.attributesfile ~/.gitattributes_global
Create global filters
Now, create the filter:
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 scripting magic
Add theFinally, put the fixup-eol-eof
script somewhere on your path, and make it executable. The script uses sed to do some on the fly editing (remove spaces and blanks at the end of lines, and extraneous blank lines at the end of the file)
fixup-eol-eof should look like this:
#!/bin/bash
sed -e 's/[ ]*$//' -e :a -e '/^\n*$/{$d;N;ba' -e '}' $1
Tell Git which file types to apply your newly created filter to
Lastly, create or open file ~/.gitattributes_global in your favorite text editor and add lines like:
pattern attr1 [attr2 [attr3 […]]]
So if we want to fix the white space issue, for all of our C source files we would add a line that looks like this:
*.c filter=fix-eol-eof
Discussion of the filter
The filter has two phases. The clean phase which is applied when things are added to the index or checked in, and the smudge phase when Git puts stuff into your working directory.
Here, our smudge is just running the contents through the cat
command which should leave them unchanged, with the exception of possibly adding a trailing newline character if there wasn’t one at the end of the file.
The clean command is the white space filtering which I cobbled together from notes at http://sed.sourceforge.net/sed1line.txt. It seems that it must be put into a shell script. I couldn’t figure out how to inject the sed command, including the sanitation of the extraneous extra lines at the end of the file directly into the git-config file. (You can get rid of trailing blanks, however, without the need of a separate sed script. Just set the filter.fix-eol-eof
to something like sed 's/[ \t]*$//' %f
where the \t
is an actual tab, by pressing Tab.)
The require = true
causes an error to be raised if something goes wrong, to keep you out of trouble.
Solution 7 - Git
I wrote this pre-commit hook, which only removes the trailing white space from the lines which you've changed/added, since the previous suggestions tend to create unreadable commits if the target files have too much trailing white space.
#!/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
Solution 8 - Git
Please try my pre-commit hooks. It can auto detect trailing white space and remove it.
It can work under Git Bash (Windows), Mac OS X and Linux!
Snapshot:
$ 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(-)
Solution 9 - Git
Here is an Ubuntu and Mac OS X compatible version:
#!/bin/sh
#
# A Git hook script to find and fix trailing white space
# 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
Solution 10 - Git
I was thinking about this today. This is all I ended up doing for a Java project:
egrep -rl ' $' --include *.java * | xargs sed -i 's/\s\+$//g'
Solution 11 - Git
For Sublime Text users.
Set the following properly in your Setting-User configuration.
"trim_trailing_white_space_on_save": true
Solution 12 - Git
The for
loop for files uses the $IFS
shell variable.
In the given script, filenames with a character in them that also is in the $IFS-variable will be seen as two different files in the for
loop.
This script fixes it: multiline-mode modifier as given in the sed manual doesn't seem to work by default on my Ubuntu box, so I sought for a different implementation and found this with an iterating label, essentially it will only start substitution on the last line of the file if I've understood it correctly.
#!/bin/sh
#
# A Git hook script to find and fix trailing white space
# 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 separator, introduces EOL-bug?
IFS='
'
# Find files with trailing white space
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 (Mac OS X 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 white space characters
exec git diff-index --check --cached $against --
1 sed-substitution pattern: https://stackoverflow.com/questions/1251999/sed-how-can-i-replace-a-newline-n/7697604#7697604
Solution 13 - Git
This doesn't remove white space automatically before a commit, but it is pretty easy to effect. I put the following Perl script in a file named git-wsf (Git white space fix) in a directory in $PATH, so I can:
git wsf | sh
And it removes all white space only from lines of files that Git reports as a 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";
}
Solution 14 - Git
Python Script for the same result.
import subprocess
def get_trailing_lines():
result = subprocess.run([
'git',
'diff',
'--check'
], capture_output=True)
return result.stdout.decode().split('\n')
def modify_line(file_path, l_num):
f_lines = open(file_path).readlines()
f_lines[l_num] = f_lines[l_num].rstrip()+'\n'\
if '\n' in f_lines[l_num] else f_lines[l_num].rstrip()
with open(file_path, "w") as w_fp:
w_fp.writelines(f_lines)
if __name__ == '__main__':
l = get_trailing_lines()
for m, d in zip(l[::2], l[1::2]):
f_path, l_no, *_ = m.split(":")
modify_line(f_path, int(l_no)-1)
Solution 15 - Git
This probably won't directly solve your problem, but you might want to set those via git-config in your actual project space, which edits file ./.git/config as opposed to file ~/.gitconfig. It is nice to keep the settings consistent among all project members.
git config core.whitespace "trailing-space,space-before-tab"
git config apply.whitespace "trailing-space,space-before-tab"
Solution 16 - Git
To delete trailing white space at the end of lines in a file portably, use ed
:
test -s file &&
printf '%s\n' H ',g/[[:space:]]*$/s///' 'wq' | ed -s file
Solution 17 - Git
Open the file in Vim. To replace tabs with white spaces, type the following on the Vim command line:
:%s#\t# #gc
To get rid of other trailing white spaces
:%s#\s##gc
This pretty much did it for me. It's tedious if you have a lot of files to edit. But I found it easier than pre-commit hooks and working with multiple text editors.