From 56499eb9b84453742222676d98e11be3c390c34d Mon Sep 17 00:00:00 2001 From: Eyvind Bernhardsen Date: Wed, 19 May 2010 22:43:09 +0200 Subject: [PATCH 1/4] Add tests for per-repository eol normalization Signed-off-by: Eyvind Bernhardsen Signed-off-by: Junio C Hamano --- t/t0025-crlf-auto.sh | 142 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100755 t/t0025-crlf-auto.sh diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh new file mode 100755 index 0000000000..2c9833800e --- /dev/null +++ b/t/t0025-crlf-auto.sh @@ -0,0 +1,142 @@ +#!/bin/sh + +test_description='CRLF conversion' + +. ./test-lib.sh + +has_cr() { + tr '\015' Q <"$1" | grep Q >/dev/null +} + +test_expect_success setup ' + + git config core.autocrlf false && + + for w in Hello world how are you; do echo $w; done >one && + for w in I am very very fine thank you; do echo ${w}Q; done | q_to_cr >two && + for w in Oh here is a QNUL byte how alarming; do echo ${w}; done | q_to_nul >three && + git add . && + + git commit -m initial && + + one=`git rev-parse HEAD:one` && + two=`git rev-parse HEAD:two` && + three=`git rev-parse HEAD:three` && + + echo happy. +' + +test_expect_success 'default settings cause no changes' ' + + rm -f .gitattributes tmp one two three && + git read-tree --reset -u HEAD && + + ! has_cr one && + has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + threediff=`git diff three` && + test -z "$onediff" -a -z "$twodiff" -a -z "$threediff" +' + +test_expect_failure 'crlf=true causes a CRLF file to be normalized' ' + + rm -f .gitattributes tmp one two three && + echo "two crlf" > .gitattributes && + git read-tree --reset -u HEAD && + + # Note, "normalized" means that git will normalize it if added + has_cr two && + twodiff=`git diff two` && + test -n "$twodiff" +' + +test_expect_failure 'eol=crlf gives a normalized file CRLFs with autocrlf=false' ' + + rm -f .gitattributes tmp one two three && + git config core.autocrlf false && + echo "one eol=crlf" > .gitattributes && + git read-tree --reset -u HEAD && + + has_cr one && + onediff=`git diff one` && + test -z "$onediff" +' + +test_expect_failure 'eol=crlf gives a normalized file CRLFs with autocrlf=input' ' + + rm -f .gitattributes tmp one two three && + git config core.autocrlf input && + echo "one eol=crlf" > .gitattributes && + git read-tree --reset -u HEAD && + + has_cr one && + onediff=`git diff one` && + test -z "$onediff" +' + +test_expect_failure 'eol=lf gives a normalized file LFs with autocrlf=true' ' + + rm -f .gitattributes tmp one two three && + git config core.autocrlf true && + echo "one eol=lf" > .gitattributes && + git read-tree --reset -u HEAD && + + ! has_cr one && + onediff=`git diff one` && + test -z "$onediff" +' + +test_expect_success 'autocrlf=true does not normalize CRLF files' ' + + rm -f .gitattributes tmp one two three && + git config core.autocrlf true && + git read-tree --reset -u HEAD && + + has_cr one && + has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + threediff=`git diff three` && + test -z "$onediff" -a -z "$twodiff" -a -z "$threediff" +' + +test_expect_failure 'crlf=auto, autocrlf=true _does_ normalize CRLF files' ' + + rm -f .gitattributes tmp one two three && + git config core.autocrlf true && + echo "* crlf=auto" > .gitattributes && + git read-tree --reset -u HEAD && + + has_cr one && + has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + threediff=`git diff three` && + test -z "$onediff" -a -n "$twodiff" -a -z "$threediff" +' + +test_expect_success 'crlf=auto, autocrlf=true does not normalize binary files' ' + + rm -f .gitattributes tmp one two three && + git config core.autocrlf true && + echo "* crlf=auto" > .gitattributes && + git read-tree --reset -u HEAD && + + ! has_cr three && + threediff=`git diff three` && + test -z "$threediff" +' + +test_expect_failure 'eol=crlf _does_ normalize binary files' ' + + rm -f .gitattributes tmp one two three && + echo "three eol=crlf" > .gitattributes && + git read-tree --reset -u HEAD && + + has_cr three && + threediff=`git diff three` && + test -z "$threediff" +' + +test_done From fd6cce9e89ab5ac1125a3b5f5611048ad22379e7 Mon Sep 17 00:00:00 2001 From: Eyvind Bernhardsen Date: Wed, 19 May 2010 22:43:10 +0200 Subject: [PATCH 2/4] Add per-repository eol normalization Change the semantics of the "crlf" attribute so that it enables end-of-line normalization when it is set, regardless of "core.autocrlf". Add a new setting for "crlf": "auto", which enables end-of-line conversion but does not override the automatic text file detection. Add a new attribute "eol" with possible values "crlf" and "lf". When set, this attribute enables normalization and forces git to use CRLF or LF line endings in the working directory, respectively. The line ending style to be used for normalized text files in the working directory is set using "core.autocrlf". When it is set to "true", CRLFs are used in the working directory; when set to "input" or "false", LFs are used. Signed-off-by: Eyvind Bernhardsen Signed-off-by: Junio C Hamano --- Documentation/config.txt | 4 +- Documentation/gitattributes.txt | 138 ++++++++++++++++++++++++++------ cache.h | 9 ++- config.c | 2 +- convert.c | 117 +++++++++++++++++++-------- environment.c | 2 +- t/t0025-crlf-auto.sh | 12 +-- 7 files changed, 215 insertions(+), 69 deletions(-) diff --git a/Documentation/config.txt b/Documentation/config.txt index 4c36aa95b7..c6cc7abe3e 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -203,8 +203,8 @@ core.autocrlf:: based on the file's contents. See linkgit:gitattributes[5]. core.safecrlf:: - If true, makes git check if converting `CRLF` as controlled by - `core.autocrlf` is reversible. Git will verify if a command + If true, makes git check if converting `CRLF` is reversible when + end-of-line conversion is active. Git will verify if a command modifies a file in the work tree either directly or indirectly. For example, committing a file followed by checking out the same file should yield the original file in the work tree. If diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt index b396a871b3..f621b23b84 100644 --- a/Documentation/gitattributes.txt +++ b/Documentation/gitattributes.txt @@ -95,50 +95,138 @@ repository upon 'git add' and 'git commit'. `crlf` ^^^^^^ -This attribute controls the line-ending convention. +This attribute enables and controls end-of-line normalization. When a +text file is normalized, its line endings are converted to LF in the +repository. To control what line ending style is used in the working +directory, use the `eol` attribute for a single file and the +`core.autocrlf` configuration variable for all text files. Set:: - Setting the `crlf` attribute on a path is meant to mark - the path as a "text" file. 'core.autocrlf' conversion - takes place without guessing the content type by - inspection. + Setting the `crlf` attribute on a path enables end-of-line + normalization and marks the path as a text file. End-of-line + conversion takes place without guessing the content type. Unset:: Unsetting the `crlf` attribute on a path tells git not to attempt any end-of-line conversion upon checkin or checkout. +Set to string value "auto":: + + When `crlf` is set to "auto", the path is marked for automatic + end-of-line normalization. If git decides that the content is + text, its line endings are normalized to LF on checkin. + Unspecified:: - Unspecified `crlf` attribute tells git to apply the - `core.autocrlf` conversion when the file content looks - like text. + If the `crlf` attribute is unspecified, git uses the `eol` + attribute and the `core.autocrlf` configuration variable to + determine if the file should be converted. -Set to string value "input":: +Any other value causes git to act as if `crlf` has been left +unspecified. - This is similar to setting the attribute to `true`, but - also forces git to act as if `core.autocrlf` is set to - `input` for the path. +`eol` +^^^^^ -Any other value set to `crlf` attribute is ignored and git acts -as if the attribute is left unspecified. +This attribute sets a specific line-ending style to be used in the +working directory. It enables end-of-line normalization without any +content checks, similar to setting the `crlf` attribute. +Set to string value "crlf":: -The `core.autocrlf` conversion -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + This setting forces git to normalize line endings on checkin + and convert them to CRLF when the file is checked out, + regardless of `crlf` and `core.autocrlf`. -If the configuration variable `core.autocrlf` is false, no -conversion is done. +Set to string value "lf":: -When `core.autocrlf` is true, it means that the platform wants -CRLF line endings for files in the working tree, and you want to -convert them back to the normal LF line endings when checking -in to the repository. + This setting forces git to normalize line endings to LF on + checkin and prevents conversion to CRLF when the file is + checked out, regardless of `crlf` and `core.autocrlf`. + `crlf=input` is a backwards compatibility alias for `eol=lf`. -When `core.autocrlf` is set to "input", line endings are -converted to LF upon checkin, but there is no conversion done -upon checkout. +End-of-line conversion +^^^^^^^^^^^^^^^^^^^^^^ + +While git normally leaves file contents alone, it can be configured to +normalize line endings to LF in the repository and, optionally, to +convert them to CRLF when files are checked out. + +Here is an example that will make git normalize .txt, .vcproj and .sh +files, ensure that .vcproj files have CRLF and .sh files have LF in +the working directory, and prevent .jpg files from being normalized +regardless of their content. + +------------------------ +*.txt crlf +*.vcproj eol=crlf +*.sh eol=lf +*.jpg -crlf +------------------------ + +Other source code management systems normalize all text files in their +repositories, and there are two ways to enable similar automatic +normalization in git. + +If you simply want to have CRLF line endings in your working directory +regardless of the repository you are working with, you can set the +config variable "core.autocrlf" without changing any attributes. + +------------------------ +[core] + autocrlf = true +------------------------ + +This does not force normalization of all text files, but does ensure +that text files that you introduce to the repository have their line +endings normalized to LF when they are added, and that files that are +already normalized in the repository stay normalized. You can also +set `autocrlf` to "input" to have automatic normalization of new text +files without conversion to CRLF in the working directory. + +If you want to interoperate with a source code management system that +enforces end-of-line normalization, or you simply want all text files +in your repository to be normalized, you should instead set the `crlf` +attribute to "auto" for _all_ files. + +------------------------ +* crlf=auto +------------------------ + +This ensures that all files that git considers to be text will have +normalized (LF) line endings in the repository. + +NOTE: When `crlf=auto` normalization is enabled in an existing +repository, any text files containing CRLFs should be normalized. If +they are not they will be normalized the next time someone tries to +change them, causing unfortunate misattribution. From a clean working +directory: + +------------------------------------------------- +$ echo "* crlf=auto" >>.gitattributes +$ rm .git/index # Remove the index to force git to +$ git reset # re-scan the working directory +$ git status # Show files that will be normalized +$ git add -u +$ git add .gitattributes +$ git commit -m "Introduce end-of-line normalization" +------------------------------------------------- + +If any files that should not be normalized show up in 'git status', +unset their `crlf` attribute before running 'git add -u'. + +------------------------ +manual.pdf -crlf +------------------------ + +Conversely, text files that git does not detect can have normalization +enabled manually. + +------------------------ +weirdchars.txt crlf +------------------------ If `core.safecrlf` is set to "true" or "warn", git verifies if the conversion is reversible for the current setting of diff --git a/cache.h b/cache.h index d478eff1f3..e1a2e14fd9 100644 --- a/cache.h +++ b/cache.h @@ -535,7 +535,6 @@ extern int core_compression_seen; extern size_t packed_git_window_size; extern size_t packed_git_limit; extern size_t delta_base_cache_limit; -extern int auto_crlf; extern int read_replace_refs; extern int fsync_object_files; extern int core_preload_index; @@ -549,6 +548,14 @@ enum safe_crlf { extern enum safe_crlf safe_crlf; +enum auto_crlf { + AUTO_CRLF_FALSE = 0, + AUTO_CRLF_TRUE = 1, + AUTO_CRLF_INPUT = -1, +}; + +extern enum auto_crlf auto_crlf; + enum branch_track { BRANCH_TRACK_UNSPECIFIED = -1, BRANCH_TRACK_NEVER = 0, diff --git a/config.c b/config.c index 6963fbea43..b60a1ff64b 100644 --- a/config.c +++ b/config.c @@ -461,7 +461,7 @@ static int git_default_core_config(const char *var, const char *value) if (!strcmp(var, "core.autocrlf")) { if (value && !strcasecmp(value, "input")) { - auto_crlf = -1; + auto_crlf = AUTO_CRLF_INPUT; return 0; } auto_crlf = git_config_bool(var, value); diff --git a/convert.c b/convert.c index a54c5fc4a2..1144e0b4f5 100644 --- a/convert.c +++ b/convert.c @@ -8,13 +8,23 @@ * This should use the pathname to decide on whether it wants to do some * more interesting conversions (automatic gzip/unzip, general format * conversions etc etc), but by default it just does automatic CRLF<->LF - * translation when the "auto_crlf" option is set. + * translation when the "crlf" attribute or "auto_crlf" option is set. */ -#define CRLF_GUESS (-1) -#define CRLF_BINARY 0 -#define CRLF_TEXT 1 -#define CRLF_INPUT 2 +enum action { + CRLF_GUESS = -1, + CRLF_BINARY = 0, + CRLF_TEXT, + CRLF_INPUT, + CRLF_CRLF, + CRLF_AUTO, +}; + +enum eol { + EOL_UNSET, + EOL_LF, + EOL_CRLF, +}; struct text_stat { /* NUL, CR, LF and CRLF counts */ @@ -89,13 +99,14 @@ static int is_binary(unsigned long size, struct text_stat *stats) return 0; } -static void check_safe_crlf(const char *path, int action, +static void check_safe_crlf(const char *path, enum action action, struct text_stat *stats, enum safe_crlf checksafe) { if (!checksafe) return; - if (action == CRLF_INPUT || auto_crlf <= 0) { + if (action == CRLF_INPUT || + (action == CRLF_GUESS && auto_crlf == AUTO_CRLF_INPUT)) { /* * CRLFs would not be restored by checkout: * check if we'd remove CRLFs @@ -106,7 +117,8 @@ static void check_safe_crlf(const char *path, int action, else /* i.e. SAFE_CRLF_FAIL */ die("CRLF would be replaced by LF in %s.", path); } - } else if (auto_crlf > 0) { + } else if (action == CRLF_CRLF || + (action == CRLF_GUESS && auto_crlf == AUTO_CRLF_TRUE)) { /* * CRLFs would be added by checkout: * check if we have "naked" LFs @@ -158,17 +170,18 @@ static int has_cr_in_index(const char *path) } static int crlf_to_git(const char *path, const char *src, size_t len, - struct strbuf *buf, int action, enum safe_crlf checksafe) + struct strbuf *buf, enum action action, enum safe_crlf checksafe) { struct text_stat stats; char *dst; - if ((action == CRLF_BINARY) || !auto_crlf || !len) + if (action == CRLF_BINARY || + (action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE) || !len) return 0; gather_stats(src, len, &stats); - if (action == CRLF_GUESS) { + if (action == CRLF_AUTO || action == CRLF_GUESS) { /* * We're currently not going to even try to convert stuff * that has bare CR characters. Does anybody do that crazy @@ -183,12 +196,14 @@ static int crlf_to_git(const char *path, const char *src, size_t len, if (is_binary(len, &stats)) return 0; - /* - * If the file in the index has any CR in it, do not convert. - * This is the new safer autocrlf handling. - */ - if (has_cr_in_index(path)) - return 0; + if (action == CRLF_GUESS) { + /* + * If the file in the index has any CR in it, do not convert. + * This is the new safer autocrlf handling. + */ + if (has_cr_in_index(path)) + return 0; + } } check_safe_crlf(path, action, &stats, checksafe); @@ -201,7 +216,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len, if (strbuf_avail(buf) + buf->len < len) strbuf_grow(buf, len - buf->len); dst = buf->buf; - if (action == CRLF_GUESS) { + if (action == CRLF_AUTO || action == CRLF_GUESS) { /* * If we guessed, we already know we rejected a file with * lone CR, and we can strip a CR without looking at what @@ -224,13 +239,13 @@ static int crlf_to_git(const char *path, const char *src, size_t len, } static int crlf_to_worktree(const char *path, const char *src, size_t len, - struct strbuf *buf, int action) + struct strbuf *buf, enum action action) { char *to_free = NULL; struct text_stat stats; if ((action == CRLF_BINARY) || (action == CRLF_INPUT) || - auto_crlf <= 0) + (action != CRLF_CRLF && auto_crlf != AUTO_CRLF_TRUE)) return 0; if (!len) @@ -246,11 +261,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len, if (stats.lf == stats.crlf) return 0; - if (action == CRLF_GUESS) { - /* If we have any CR or CRLF line endings, we do not touch it */ - /* This is the new safer autocrlf-handling */ - if (stats.cr > 0 || stats.crlf > 0) - return 0; + if (action == CRLF_AUTO || action == CRLF_GUESS) { + if (action == CRLF_GUESS) { + /* If we have any CR or CRLF line endings, we do not touch it */ + /* This is the new safer autocrlf-handling */ + if (stats.cr > 0 || stats.crlf > 0) + return 0; + } /* If we have any bare CR characters, we're not going to touch it */ if (stats.cr != stats.crlf) @@ -423,11 +440,13 @@ static int read_convert_config(const char *var, const char *value, void *cb) static void setup_convert_check(struct git_attr_check *check) { static struct git_attr *attr_crlf; + static struct git_attr *attr_eol; static struct git_attr *attr_ident; static struct git_attr *attr_filter; if (!attr_crlf) { attr_crlf = git_attr("crlf"); + attr_eol = git_attr("eol"); attr_ident = git_attr("ident"); attr_filter = git_attr("filter"); user_convert_tail = &user_convert; @@ -436,6 +455,7 @@ static void setup_convert_check(struct git_attr_check *check) check[0].attr = attr_crlf; check[1].attr = attr_ident; check[2].attr = attr_filter; + check[3].attr = attr_eol; } static int count_ident(const char *cp, unsigned long size) @@ -592,9 +612,24 @@ static int git_path_check_crlf(const char *path, struct git_attr_check *check) ; else if (!strcmp(value, "input")) return CRLF_INPUT; + else if (!strcmp(value, "auto")) + return CRLF_AUTO; return CRLF_GUESS; } +static int git_path_check_eol(const char *path, struct git_attr_check *check) +{ + const char *value = check->value; + + if (ATTR_UNSET(value)) + ; + else if (!strcmp(value, "lf")) + return EOL_LF; + else if (!strcmp(value, "crlf")) + return EOL_CRLF; + return EOL_UNSET; +} + static struct convert_driver *git_path_check_convert(const char *path, struct git_attr_check *check) { @@ -616,20 +651,32 @@ static int git_path_check_ident(const char *path, struct git_attr_check *check) return !!ATTR_TRUE(value); } +enum action determine_action(enum action crlf_attr, enum eol eol_attr) { + if (crlf_attr == CRLF_BINARY) + return CRLF_BINARY; + if (eol_attr == EOL_LF) + return CRLF_INPUT; + if (eol_attr == EOL_CRLF) + return CRLF_CRLF; + return crlf_attr; +} + int convert_to_git(const char *path, const char *src, size_t len, struct strbuf *dst, enum safe_crlf checksafe) { - struct git_attr_check check[3]; - int crlf = CRLF_GUESS; + struct git_attr_check check[4]; + enum action action = CRLF_GUESS; + enum eol eol = EOL_UNSET; int ident = 0, ret = 0; const char *filter = NULL; setup_convert_check(check); if (!git_checkattr(path, ARRAY_SIZE(check), check)) { struct convert_driver *drv; - crlf = git_path_check_crlf(path, check + 0); + action = git_path_check_crlf(path, check + 0); ident = git_path_check_ident(path, check + 1); drv = git_path_check_convert(path, check + 2); + eol = git_path_check_eol(path, check + 3); if (drv && drv->clean) filter = drv->clean; } @@ -639,7 +686,8 @@ int convert_to_git(const char *path, const char *src, size_t len, src = dst->buf; len = dst->len; } - ret |= crlf_to_git(path, src, len, dst, crlf, checksafe); + action = determine_action(action, eol); + ret |= crlf_to_git(path, src, len, dst, action, checksafe); if (ret) { src = dst->buf; len = dst->len; @@ -649,17 +697,19 @@ int convert_to_git(const char *path, const char *src, size_t len, int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst) { - struct git_attr_check check[3]; - int crlf = CRLF_GUESS; + struct git_attr_check check[4]; + enum action action = CRLF_GUESS; + enum eol eol = EOL_UNSET; int ident = 0, ret = 0; const char *filter = NULL; setup_convert_check(check); if (!git_checkattr(path, ARRAY_SIZE(check), check)) { struct convert_driver *drv; - crlf = git_path_check_crlf(path, check + 0); + action = git_path_check_crlf(path, check + 0); ident = git_path_check_ident(path, check + 1); drv = git_path_check_convert(path, check + 2); + eol = git_path_check_eol(path, check + 3); if (drv && drv->smudge) filter = drv->smudge; } @@ -669,7 +719,8 @@ int convert_to_working_tree(const char *path, const char *src, size_t len, struc src = dst->buf; len = dst->len; } - ret |= crlf_to_worktree(path, src, len, dst, crlf); + action = determine_action(action, eol); + ret |= crlf_to_worktree(path, src, len, dst, action); if (ret) { src = dst->buf; len = dst->len; diff --git a/environment.c b/environment.c index 739ec27040..3c8abae848 100644 --- a/environment.c +++ b/environment.c @@ -38,7 +38,7 @@ const char *pager_program; int pager_use_color = 1; const char *editor_program; const char *excludes_file; -int auto_crlf = 0; /* 1: both ways, -1: only when adding git objects */ +enum auto_crlf auto_crlf = AUTO_CRLF_FALSE; int read_replace_refs = 1; enum safe_crlf safe_crlf = SAFE_CRLF_WARN; unsigned whitespace_rule_cfg = WS_DEFAULT_RULE; diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh index 2c9833800e..2781f15302 100755 --- a/t/t0025-crlf-auto.sh +++ b/t/t0025-crlf-auto.sh @@ -39,7 +39,7 @@ test_expect_success 'default settings cause no changes' ' test -z "$onediff" -a -z "$twodiff" -a -z "$threediff" ' -test_expect_failure 'crlf=true causes a CRLF file to be normalized' ' +test_expect_success 'crlf=true causes a CRLF file to be normalized' ' rm -f .gitattributes tmp one two three && echo "two crlf" > .gitattributes && @@ -51,7 +51,7 @@ test_expect_failure 'crlf=true causes a CRLF file to be normalized' ' test -n "$twodiff" ' -test_expect_failure 'eol=crlf gives a normalized file CRLFs with autocrlf=false' ' +test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' ' rm -f .gitattributes tmp one two three && git config core.autocrlf false && @@ -63,7 +63,7 @@ test_expect_failure 'eol=crlf gives a normalized file CRLFs with autocrlf=false' test -z "$onediff" ' -test_expect_failure 'eol=crlf gives a normalized file CRLFs with autocrlf=input' ' +test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=input' ' rm -f .gitattributes tmp one two three && git config core.autocrlf input && @@ -75,7 +75,7 @@ test_expect_failure 'eol=crlf gives a normalized file CRLFs with autocrlf=input' test -z "$onediff" ' -test_expect_failure 'eol=lf gives a normalized file LFs with autocrlf=true' ' +test_expect_success 'eol=lf gives a normalized file LFs with autocrlf=true' ' rm -f .gitattributes tmp one two three && git config core.autocrlf true && @@ -101,7 +101,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' ' test -z "$onediff" -a -z "$twodiff" -a -z "$threediff" ' -test_expect_failure 'crlf=auto, autocrlf=true _does_ normalize CRLF files' ' +test_expect_success 'crlf=auto, autocrlf=true _does_ normalize CRLF files' ' rm -f .gitattributes tmp one two three && git config core.autocrlf true && @@ -128,7 +128,7 @@ test_expect_success 'crlf=auto, autocrlf=true does not normalize binary files' ' test -z "$threediff" ' -test_expect_failure 'eol=crlf _does_ normalize binary files' ' +test_expect_success 'eol=crlf _does_ normalize binary files' ' rm -f .gitattributes tmp one two three && echo "three eol=crlf" > .gitattributes && From 5ec3e67052289217c84e53d2cda90d939ac5725b Mon Sep 17 00:00:00 2001 From: Eyvind Bernhardsen Date: Wed, 19 May 2010 22:43:11 +0200 Subject: [PATCH 3/4] Rename the "crlf" attribute "text" As discussed on the list, "crlf" is not an optimal name. Linus suggested "text", which is much better. Signed-off-by: Eyvind Bernhardsen Signed-off-by: Junio C Hamano --- Documentation/config.txt | 16 +++++---- Documentation/git-cvsserver.txt | 13 +++----- Documentation/gitattributes.txt | 59 +++++++++++++++++++-------------- attr.c | 2 +- convert.c | 23 ++++++++----- git-cvsserver.perl | 13 +++++--- t/t0025-crlf-auto.sh | 21 +++++++++--- 7 files changed, 91 insertions(+), 56 deletions(-) diff --git a/Documentation/config.txt b/Documentation/config.txt index c6cc7abe3e..35569a0a77 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -199,7 +199,7 @@ core.autocrlf:: reading from the filesystem but files are written out with `LF` at the end of lines. A file is considered "text" (i.e. be subjected to the autocrlf mechanism) based on - the file's `crlf` attribute, or if `crlf` is unspecified, + the file's `text` attribute, or if `text` is unspecified, based on the file's contents. See linkgit:gitattributes[5]. core.safecrlf:: @@ -943,13 +943,15 @@ gitcvs.logfile:: various stuff. See linkgit:git-cvsserver[1]. gitcvs.usecrlfattr:: - If true, the server will look up the `crlf` attribute for - files to determine the '-k' modes to use. If `crlf` is set, - the '-k' mode will be left blank, so cvs clients will - treat it as text. If `crlf` is explicitly unset, the file + If true, the server will look up the end-of-line conversion + attributes for files to determine the '-k' modes to use. If + the attributes force git to treat a file as text, + the '-k' mode will be left blank so cvs clients will + treat it as text. If they suppress text conversion, the file will be set with '-kb' mode, which suppresses any newline munging - the client might otherwise do. If `crlf` is not specified, - then 'gitcvs.allbinary' is used. See linkgit:gitattributes[5]. + the client might otherwise do. If the attributes do not allow + the file type to be determined, then 'gitcvs.allbinary' is + used. See linkgit:gitattributes[5]. gitcvs.allbinary:: This is used if 'gitcvs.usecrlfattr' does not resolve diff --git a/Documentation/git-cvsserver.txt b/Documentation/git-cvsserver.txt index dbb053ee17..086485763c 100644 --- a/Documentation/git-cvsserver.txt +++ b/Documentation/git-cvsserver.txt @@ -340,16 +340,13 @@ By default the server leaves the '-k' mode blank for all files, which causes the cvs client to treat them as a text files, subject to crlf conversion on some platforms. -You can make the server use `crlf` attributes to set the '-k' modes -for files by setting the `gitcvs.usecrlfattr` config variable. -In this case, if `crlf` is explicitly unset ('-crlf'), then the -server will set '-kb' mode for binary files. If `crlf` is set, -then the '-k' mode will explicitly be left blank. See -also linkgit:gitattributes[5] for more information about the `crlf` -attribute. +You can make the server use the end-of-line conversion attributes to +set the '-k' modes for files by setting the `gitcvs.usecrlfattr` +config variable. See linkgit:gitattributes[5] for more information +about end-of-line conversion. Alternatively, if `gitcvs.usecrlfattr` config is not enabled -or if the `crlf` attribute is unspecified for a filename, then +or the attributes do not allow automatic detection for a filename, then the server uses the `gitcvs.allbinary` config for the default setting. If `gitcvs.allbinary` is set, then file not otherwise specified will default to '-kb' mode. Otherwise the '-k' mode diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt index f621b23b84..1120b90a58 100644 --- a/Documentation/gitattributes.txt +++ b/Documentation/gitattributes.txt @@ -92,7 +92,7 @@ such as 'git checkout' and 'git merge' run. They also affect how git stores the contents you prepare in the working tree in the repository upon 'git add' and 'git commit'. -`crlf` +`text` ^^^^^^ This attribute enables and controls end-of-line normalization. When a @@ -103,28 +103,28 @@ directory, use the `eol` attribute for a single file and the Set:: - Setting the `crlf` attribute on a path enables end-of-line + Setting the `text` attribute on a path enables end-of-line normalization and marks the path as a text file. End-of-line conversion takes place without guessing the content type. Unset:: - Unsetting the `crlf` attribute on a path tells git not to + Unsetting the `text` attribute on a path tells git not to attempt any end-of-line conversion upon checkin or checkout. Set to string value "auto":: - When `crlf` is set to "auto", the path is marked for automatic + When `text` is set to "auto", the path is marked for automatic end-of-line normalization. If git decides that the content is text, its line endings are normalized to LF on checkin. Unspecified:: - If the `crlf` attribute is unspecified, git uses the `eol` + If the `text` attribute is unspecified, git uses the `eol` attribute and the `core.autocrlf` configuration variable to determine if the file should be converted. -Any other value causes git to act as if `crlf` has been left +Any other value causes git to act as if `text` has been left unspecified. `eol` @@ -132,20 +132,31 @@ unspecified. This attribute sets a specific line-ending style to be used in the working directory. It enables end-of-line normalization without any -content checks, similar to setting the `crlf` attribute. +content checks, similar to setting the `text` attribute. Set to string value "crlf":: This setting forces git to normalize line endings on checkin and convert them to CRLF when the file is checked out, - regardless of `crlf` and `core.autocrlf`. + regardless of `text` and `core.autocrlf`. Set to string value "lf":: This setting forces git to normalize line endings to LF on checkin and prevents conversion to CRLF when the file is - checked out, regardless of `crlf` and `core.autocrlf`. - `crlf=input` is a backwards compatibility alias for `eol=lf`. + checked out, regardless of `text` and `core.autocrlf`. + +Backwards compatibility with `crlf` attribute +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +For backwards compatibility, the `crlf` attribute is interpreted as +follows: + +------------------------ +crlf text +-crlf -text +crlf=input eol=lf +------------------------ End-of-line conversion ^^^^^^^^^^^^^^^^^^^^^^ @@ -160,10 +171,10 @@ the working directory, and prevent .jpg files from being normalized regardless of their content. ------------------------ -*.txt crlf +*.txt text *.vcproj eol=crlf *.sh eol=lf -*.jpg -crlf +*.jpg -text ------------------------ Other source code management systems normalize all text files in their @@ -188,24 +199,24 @@ files without conversion to CRLF in the working directory. If you want to interoperate with a source code management system that enforces end-of-line normalization, or you simply want all text files -in your repository to be normalized, you should instead set the `crlf` +in your repository to be normalized, you should instead set the `text` attribute to "auto" for _all_ files. ------------------------ -* crlf=auto +* text=auto ------------------------ This ensures that all files that git considers to be text will have normalized (LF) line endings in the repository. -NOTE: When `crlf=auto` normalization is enabled in an existing +NOTE: When `text=auto` normalization is enabled in an existing repository, any text files containing CRLFs should be normalized. If they are not they will be normalized the next time someone tries to change them, causing unfortunate misattribution. From a clean working directory: ------------------------------------------------- -$ echo "* crlf=auto" >>.gitattributes +$ echo "* text=auto" >>.gitattributes $ rm .git/index # Remove the index to force git to $ git reset # re-scan the working directory $ git status # Show files that will be normalized @@ -215,17 +226,17 @@ $ git commit -m "Introduce end-of-line normalization" ------------------------------------------------- If any files that should not be normalized show up in 'git status', -unset their `crlf` attribute before running 'git add -u'. +unset their `text` attribute before running 'git add -u'. ------------------------ -manual.pdf -crlf +manual.pdf -text ------------------------ Conversely, text files that git does not detect can have normalization enabled manually. ------------------------ -weirdchars.txt crlf +weirdchars.txt text ------------------------ If `core.safecrlf` is set to "true" or "warn", git verifies if @@ -311,11 +322,11 @@ Interaction between checkin/checkout attributes In the check-in codepath, the worktree file is first converted with `filter` driver (if specified and corresponding driver defined), then the result is processed with `ident` (if -specified), and then finally with `crlf` (again, if specified +specified), and then finally with `text` (again, if specified and applicable). In the check-out codepath, the blob content is first converted -with `crlf`, and then `ident` and fed to `filter`. +with `text`, and then `ident` and fed to `filter`. Generating diff text @@ -718,7 +729,7 @@ You do not want any end-of-line conversions applied to, nor textual diffs produced for, any binary file you track. You would need to specify e.g. ------------ -*.jpg -crlf -diff +*.jpg -text -diff ------------ but that may become cumbersome, when you have many attributes. Using @@ -731,7 +742,7 @@ the same time. The system knows a built-in attribute macro, `binary`: which is equivalent to the above. Note that the attribute macros can only be "Set" (see the above example that sets "binary" macro as if it were an -ordinary attribute --- setting it in turn unsets "crlf" and "diff"). +ordinary attribute --- setting it in turn unsets "text" and "diff"). DEFINING ATTRIBUTE MACROS @@ -742,7 +753,7 @@ at the toplevel (i.e. not in any subdirectory). The built-in attribute macro "binary" is equivalent to: ------------ -[attr]binary -diff -crlf +[attr]binary -diff -text ------------ diff --git a/attr.c b/attr.c index f5346ed32a..bf00469ecc 100644 --- a/attr.c +++ b/attr.c @@ -287,7 +287,7 @@ static void free_attr_elem(struct attr_stack *e) } static const char *builtin_attr[] = { - "[attr]binary -diff -crlf", + "[attr]binary -diff -text", NULL, }; diff --git a/convert.c b/convert.c index 1144e0b4f5..c61c02b190 100644 --- a/convert.c +++ b/convert.c @@ -439,12 +439,14 @@ static int read_convert_config(const char *var, const char *value, void *cb) static void setup_convert_check(struct git_attr_check *check) { + static struct git_attr *attr_text; static struct git_attr *attr_crlf; static struct git_attr *attr_eol; static struct git_attr *attr_ident; static struct git_attr *attr_filter; - if (!attr_crlf) { + if (!attr_text) { + attr_text = git_attr("text"); attr_crlf = git_attr("crlf"); attr_eol = git_attr("eol"); attr_ident = git_attr("ident"); @@ -456,6 +458,7 @@ static void setup_convert_check(struct git_attr_check *check) check[1].attr = attr_ident; check[2].attr = attr_filter; check[3].attr = attr_eol; + check[4].attr = attr_text; } static int count_ident(const char *cp, unsigned long size) @@ -651,20 +654,20 @@ static int git_path_check_ident(const char *path, struct git_attr_check *check) return !!ATTR_TRUE(value); } -enum action determine_action(enum action crlf_attr, enum eol eol_attr) { - if (crlf_attr == CRLF_BINARY) +enum action determine_action(enum action text_attr, enum eol eol_attr) { + if (text_attr == CRLF_BINARY) return CRLF_BINARY; if (eol_attr == EOL_LF) return CRLF_INPUT; if (eol_attr == EOL_CRLF) return CRLF_CRLF; - return crlf_attr; + return text_attr; } int convert_to_git(const char *path, const char *src, size_t len, struct strbuf *dst, enum safe_crlf checksafe) { - struct git_attr_check check[4]; + struct git_attr_check check[5]; enum action action = CRLF_GUESS; enum eol eol = EOL_UNSET; int ident = 0, ret = 0; @@ -673,7 +676,9 @@ int convert_to_git(const char *path, const char *src, size_t len, setup_convert_check(check); if (!git_checkattr(path, ARRAY_SIZE(check), check)) { struct convert_driver *drv; - action = git_path_check_crlf(path, check + 0); + action = git_path_check_crlf(path, check + 4); + if (action == CRLF_GUESS) + action = git_path_check_crlf(path, check + 0); ident = git_path_check_ident(path, check + 1); drv = git_path_check_convert(path, check + 2); eol = git_path_check_eol(path, check + 3); @@ -697,7 +702,7 @@ int convert_to_git(const char *path, const char *src, size_t len, int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst) { - struct git_attr_check check[4]; + struct git_attr_check check[5]; enum action action = CRLF_GUESS; enum eol eol = EOL_UNSET; int ident = 0, ret = 0; @@ -706,7 +711,9 @@ int convert_to_working_tree(const char *path, const char *src, size_t len, struc setup_convert_check(check); if (!git_checkattr(path, ARRAY_SIZE(check), check)) { struct convert_driver *drv; - action = git_path_check_crlf(path, check + 0); + action = git_path_check_crlf(path, check + 4); + if (action == CRLF_GUESS) + action = git_path_check_crlf(path, check + 0); ident = git_path_check_ident(path, check + 1); drv = git_path_check_convert(path, check + 2); eol = git_path_check_eol(path, check + 3); diff --git a/git-cvsserver.perl b/git-cvsserver.perl index 13751db882..4e55041ec7 100755 --- a/git-cvsserver.perl +++ b/git-cvsserver.perl @@ -2369,15 +2369,20 @@ sub kopts_from_path if ( defined ( $cfg->{gitcvs}{usecrlfattr} ) and $cfg->{gitcvs}{usecrlfattr} =~ /\s*(1|true|yes)\s*$/i ) { - my ($val) = check_attr( "crlf", $path ); - if ( $val eq "set" ) + my ($val) = check_attr( "text", $path ); + if ( $val eq "unspecified" ) { - return ""; + $val = check_attr( "crlf", $path ); } - elsif ( $val eq "unset" ) + if ( $val eq "unset" ) { return "-kb" } + elsif ( check_attr( "eol", $path ) ne "unspecified" || + $val eq "set" || $val eq "input" ) + { + return ""; + } else { $log->info("Unrecognized check_attr crlf $path : $val"); diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh index 2781f15302..f5f67a6337 100755 --- a/t/t0025-crlf-auto.sh +++ b/t/t0025-crlf-auto.sh @@ -41,6 +41,7 @@ test_expect_success 'default settings cause no changes' ' test_expect_success 'crlf=true causes a CRLF file to be normalized' ' + # Backwards compatibility check rm -f .gitattributes tmp one two three && echo "two crlf" > .gitattributes && git read-tree --reset -u HEAD && @@ -51,6 +52,18 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' ' test -n "$twodiff" ' +test_expect_success 'text=true causes a CRLF file to be normalized' ' + + rm -f .gitattributes tmp one two three && + echo "two text" > .gitattributes && + git read-tree --reset -u HEAD && + + # Note, "normalized" means that git will normalize it if added + has_cr two && + twodiff=`git diff two` && + test -n "$twodiff" +' + test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' ' rm -f .gitattributes tmp one two three && @@ -101,11 +114,11 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' ' test -z "$onediff" -a -z "$twodiff" -a -z "$threediff" ' -test_expect_success 'crlf=auto, autocrlf=true _does_ normalize CRLF files' ' +test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' ' rm -f .gitattributes tmp one two three && git config core.autocrlf true && - echo "* crlf=auto" > .gitattributes && + echo "* text=auto" > .gitattributes && git read-tree --reset -u HEAD && has_cr one && @@ -116,11 +129,11 @@ test_expect_success 'crlf=auto, autocrlf=true _does_ normalize CRLF files' ' test -z "$onediff" -a -n "$twodiff" -a -z "$threediff" ' -test_expect_success 'crlf=auto, autocrlf=true does not normalize binary files' ' +test_expect_success 'text=auto, autocrlf=true does not normalize binary files' ' rm -f .gitattributes tmp one two three && git config core.autocrlf true && - echo "* crlf=auto" > .gitattributes && + echo "* text=auto" > .gitattributes && git read-tree --reset -u HEAD && ! has_cr three && From 942e7747678ecf5f118ea5b2d0c763166de21f3a Mon Sep 17 00:00:00 2001 From: Eyvind Bernhardsen Date: Fri, 4 Jun 2010 21:29:08 +0200 Subject: [PATCH 4/4] Add "core.eol" config variable Introduce a new configuration variable, "core.eol", that allows the user to set which line endings to use for end-of-line-normalized files in the working directory. It defaults to "native", which means CRLF on Windows and LF everywhere else. Note that "core.autocrlf" overrides core.eol. This means that [core] autocrlf = true puts CRLFs in the working directory even if core.eol is set to "lf". Signed-off-by: Eyvind Bernhardsen Signed-off-by: Junio C Hamano --- Documentation/config.txt | 35 ++++++++------ Documentation/gitattributes.txt | 28 +++++------ Makefile | 3 ++ cache.h | 13 ++++++ config.c | 16 +++++++ convert.c | 60 ++++++++++++++---------- environment.c | 1 + t/t0026-eol-config.sh | 83 +++++++++++++++++++++++++++++++++ 8 files changed, 188 insertions(+), 51 deletions(-) create mode 100755 t/t0026-eol-config.sh diff --git a/Documentation/config.txt b/Documentation/config.txt index 35569a0a77..5cb334c2b9 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -191,16 +191,13 @@ core.quotepath:: quoted without `-z` regardless of the setting of this variable. -core.autocrlf:: - If true, makes git convert `CRLF` at the end of lines in text files to - `LF` when reading from the filesystem, and convert in reverse when - writing to the filesystem. The variable can be set to - 'input', in which case the conversion happens only while - reading from the filesystem but files are written out with - `LF` at the end of lines. A file is considered - "text" (i.e. be subjected to the autocrlf mechanism) based on - the file's `text` attribute, or if `text` is unspecified, - based on the file's contents. See linkgit:gitattributes[5]. +core.eol:: + Sets the line ending type to use in the working directory for + files that have the `text` property set. Alternatives are + 'lf', 'crlf' and 'native', which uses the platform's native + line ending. The default value is `native`. See + linkgit:gitattributes[5] for more information on end-of-line + conversion. core.safecrlf:: If true, makes git check if converting `CRLF` is reversible when @@ -214,7 +211,7 @@ core.safecrlf:: irreversible conversion but continue the operation. + CRLF conversion bears a slight chance of corrupting data. -autocrlf=true will convert CRLF to LF during commit and LF to +When it is enabled, git will convert CRLF to LF during commit and LF to CRLF during checkout. A file that contains a mixture of LF and CRLF before the commit cannot be recreated by git. For text files this is the right thing to do: it corrects line endings @@ -238,15 +235,25 @@ converting CRLFs corrupts data. + Note, this safety check does not mean that a checkout will generate a file identical to the original file for a different setting of -`core.autocrlf`, but only for the current one. For example, a text -file with `LF` would be accepted with `core.autocrlf=input` and could -later be checked out with `core.autocrlf=true`, in which case the +`core.eol` and `core.autocrlf`, but only for the current one. For +example, a text file with `LF` would be accepted with `core.eol=lf` +and could later be checked out with `core.eol=crlf`, in which case the resulting file would contain `CRLF`, although the original file contained `LF`. However, in both work trees the line endings would be consistent, that is either all `LF` or all `CRLF`, but never mixed. A file with mixed line endings would be reported by the `core.safecrlf` mechanism. +core.autocrlf:: + Setting this variable to "true" is almost the same as setting + the `text` attribute to "auto" on all files except that text + files are not guaranteed to be normalized: files that contain + `CRLF` in the repository will not be touched. Use this + setting if you want to have `CRLF` line endings in your + working directory even though the repository does not have + normalized line endings. This variable can be set to 'input', + in which case no output conversion is performed. + core.symlinks:: If false, symbolic links are checked out as small plain files that contain the link text. linkgit:git-update-index[1] and diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt index 1120b90a58..c2efe4c079 100644 --- a/Documentation/gitattributes.txt +++ b/Documentation/gitattributes.txt @@ -99,7 +99,7 @@ This attribute enables and controls end-of-line normalization. When a text file is normalized, its line endings are converted to LF in the repository. To control what line ending style is used in the working directory, use the `eol` attribute for a single file and the -`core.autocrlf` configuration variable for all text files. +`core.eol` configuration variable for all text files. Set:: @@ -120,9 +120,9 @@ Set to string value "auto":: Unspecified:: - If the `text` attribute is unspecified, git uses the `eol` - attribute and the `core.autocrlf` configuration variable to - determine if the file should be converted. + If the `text` attribute is unspecified, git uses the + `core.autocrlf` configuration variable to determine if the + file should be converted. Any other value causes git to act as if `text` has been left unspecified. @@ -132,19 +132,19 @@ unspecified. This attribute sets a specific line-ending style to be used in the working directory. It enables end-of-line normalization without any -content checks, similar to setting the `text` attribute. +content checks, effectively setting the `text` attribute. Set to string value "crlf":: - This setting forces git to normalize line endings on checkin - and convert them to CRLF when the file is checked out, - regardless of `text` and `core.autocrlf`. + This setting forces git to normalize line endings for this + file on checkin and convert them to CRLF when the file is + checked out. Set to string value "lf":: This setting forces git to normalize line endings to LF on checkin and prevents conversion to CRLF when the file is - checked out, regardless of `text` and `core.autocrlf`. + checked out. Backwards compatibility with `crlf` attribute ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -193,9 +193,7 @@ config variable "core.autocrlf" without changing any attributes. This does not force normalization of all text files, but does ensure that text files that you introduce to the repository have their line endings normalized to LF when they are added, and that files that are -already normalized in the repository stay normalized. You can also -set `autocrlf` to "input" to have automatic normalization of new text -files without conversion to CRLF in the working directory. +already normalized in the repository stay normalized. If you want to interoperate with a source code management system that enforces end-of-line normalization, or you simply want all text files @@ -207,7 +205,11 @@ attribute to "auto" for _all_ files. ------------------------ This ensures that all files that git considers to be text will have -normalized (LF) line endings in the repository. +normalized (LF) line endings in the repository. The `core.eol` +configuration variable controls which line endings git will use for +normalized files in your working directory; the default is to use the +native line ending for your platform, or CRLF if `core.autocrlf` is +set. NOTE: When `text=auto` normalization is enabled in an existing repository, any text files containing CRLFs should be normalized. If diff --git a/Makefile b/Makefile index 7bf2fca407..bf5f8a7b0e 100644 --- a/Makefile +++ b/Makefile @@ -214,6 +214,8 @@ all:: # DEFAULT_EDITOR='~/bin/vi', # DEFAULT_EDITOR='$GIT_FALLBACK_EDITOR', # DEFAULT_EDITOR='"C:\Program Files\Vim\gvim.exe" --nofork' +# +# Define NATIVE_CRLF if your platform uses CRLF for line endings. GIT-VERSION-FILE: FORCE @$(SHELL_PATH) ./GIT-VERSION-GEN @@ -947,6 +949,7 @@ ifeq ($(uname_S),Windows) NO_CURL = YesPlease NO_PYTHON = YesPlease BLK_SHA1 = YesPlease + NATIVE_CRLF = YesPlease CC = compat/vcbuild/scripts/clink.pl AR = compat/vcbuild/scripts/lib.pl diff --git a/cache.h b/cache.h index e1a2e14fd9..ebe71c7e87 100644 --- a/cache.h +++ b/cache.h @@ -556,6 +556,19 @@ enum auto_crlf { extern enum auto_crlf auto_crlf; +enum eol { + EOL_UNSET, + EOL_CRLF, + EOL_LF, +#ifdef NATIVE_CRLF + EOL_NATIVE = EOL_CRLF +#else + EOL_NATIVE = EOL_LF +#endif +}; + +extern enum eol eol; + enum branch_track { BRANCH_TRACK_UNSPECIFIED = -1, BRANCH_TRACK_NEVER = 0, diff --git a/config.c b/config.c index b60a1ff64b..1479ee6ed4 100644 --- a/config.c +++ b/config.c @@ -461,6 +461,8 @@ static int git_default_core_config(const char *var, const char *value) if (!strcmp(var, "core.autocrlf")) { if (value && !strcasecmp(value, "input")) { + if (eol == EOL_CRLF) + return error("core.autocrlf=input conflicts with core.eol=crlf"); auto_crlf = AUTO_CRLF_INPUT; return 0; } @@ -477,6 +479,20 @@ static int git_default_core_config(const char *var, const char *value) return 0; } + if (!strcmp(var, "core.eol")) { + if (value && !strcasecmp(value, "lf")) + eol = EOL_LF; + else if (value && !strcasecmp(value, "crlf")) + eol = EOL_CRLF; + else if (value && !strcasecmp(value, "native")) + eol = EOL_NATIVE; + else + eol = EOL_UNSET; + if (eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT) + return error("core.autocrlf=input conflicts with core.eol=crlf"); + return 0; + } + if (!strcmp(var, "core.notesref")) { notes_ref_name = xstrdup(value); return 0; diff --git a/convert.c b/convert.c index c61c02b190..061fb23d6a 100644 --- a/convert.c +++ b/convert.c @@ -8,7 +8,7 @@ * This should use the pathname to decide on whether it wants to do some * more interesting conversions (automatic gzip/unzip, general format * conversions etc etc), but by default it just does automatic CRLF<->LF - * translation when the "crlf" attribute or "auto_crlf" option is set. + * translation when the "text" attribute or "auto_crlf" option is set. */ enum action { @@ -20,12 +20,6 @@ enum action { CRLF_AUTO, }; -enum eol { - EOL_UNSET, - EOL_LF, - EOL_CRLF, -}; - struct text_stat { /* NUL, CR, LF and CRLF counts */ unsigned nul, cr, lf, crlf; @@ -99,33 +93,55 @@ static int is_binary(unsigned long size, struct text_stat *stats) return 0; } +static enum eol determine_output_conversion(enum action action) { + switch (action) { + case CRLF_BINARY: + return EOL_UNSET; + case CRLF_CRLF: + return EOL_CRLF; + case CRLF_INPUT: + return EOL_LF; + case CRLF_GUESS: + if (!auto_crlf) + return EOL_UNSET; + /* fall through */ + case CRLF_TEXT: + case CRLF_AUTO: + if (auto_crlf == AUTO_CRLF_TRUE) + return EOL_CRLF; + else if (auto_crlf == AUTO_CRLF_INPUT) + return EOL_LF; + else if (eol == EOL_UNSET) + return EOL_NATIVE; + } + return eol; +} + static void check_safe_crlf(const char *path, enum action action, struct text_stat *stats, enum safe_crlf checksafe) { if (!checksafe) return; - if (action == CRLF_INPUT || - (action == CRLF_GUESS && auto_crlf == AUTO_CRLF_INPUT)) { + if (determine_output_conversion(action) == EOL_LF) { /* * CRLFs would not be restored by checkout: * check if we'd remove CRLFs */ if (stats->crlf) { if (checksafe == SAFE_CRLF_WARN) - warning("CRLF will be replaced by LF in %s.", path); + warning("CRLF will be replaced by LF in %s.\nThe file will have its original line endings in your working directory.", path); else /* i.e. SAFE_CRLF_FAIL */ die("CRLF would be replaced by LF in %s.", path); } - } else if (action == CRLF_CRLF || - (action == CRLF_GUESS && auto_crlf == AUTO_CRLF_TRUE)) { + } else if (determine_output_conversion(action) == EOL_CRLF) { /* * CRLFs would be added by checkout: * check if we have "naked" LFs */ if (stats->lf != stats->crlf) { if (checksafe == SAFE_CRLF_WARN) - warning("LF will be replaced by CRLF in %s", path); + warning("LF will be replaced by CRLF in %s.\nThe file will have its original line endings in your working directory.", path); else /* i.e. SAFE_CRLF_FAIL */ die("LF would be replaced by CRLF in %s", path); } @@ -244,11 +260,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len, char *to_free = NULL; struct text_stat stats; - if ((action == CRLF_BINARY) || (action == CRLF_INPUT) || - (action != CRLF_CRLF && auto_crlf != AUTO_CRLF_TRUE)) - return 0; - - if (!len) + if (!len || determine_output_conversion(action) != EOL_CRLF) return 0; gather_stats(src, len, &stats); @@ -669,7 +681,7 @@ int convert_to_git(const char *path, const char *src, size_t len, { struct git_attr_check check[5]; enum action action = CRLF_GUESS; - enum eol eol = EOL_UNSET; + enum eol eol_attr = EOL_UNSET; int ident = 0, ret = 0; const char *filter = NULL; @@ -681,7 +693,7 @@ int convert_to_git(const char *path, const char *src, size_t len, action = git_path_check_crlf(path, check + 0); ident = git_path_check_ident(path, check + 1); drv = git_path_check_convert(path, check + 2); - eol = git_path_check_eol(path, check + 3); + eol_attr = git_path_check_eol(path, check + 3); if (drv && drv->clean) filter = drv->clean; } @@ -691,7 +703,7 @@ int convert_to_git(const char *path, const char *src, size_t len, src = dst->buf; len = dst->len; } - action = determine_action(action, eol); + action = determine_action(action, eol_attr); ret |= crlf_to_git(path, src, len, dst, action, checksafe); if (ret) { src = dst->buf; @@ -704,7 +716,7 @@ int convert_to_working_tree(const char *path, const char *src, size_t len, struc { struct git_attr_check check[5]; enum action action = CRLF_GUESS; - enum eol eol = EOL_UNSET; + enum eol eol_attr = EOL_UNSET; int ident = 0, ret = 0; const char *filter = NULL; @@ -716,7 +728,7 @@ int convert_to_working_tree(const char *path, const char *src, size_t len, struc action = git_path_check_crlf(path, check + 0); ident = git_path_check_ident(path, check + 1); drv = git_path_check_convert(path, check + 2); - eol = git_path_check_eol(path, check + 3); + eol_attr = git_path_check_eol(path, check + 3); if (drv && drv->smudge) filter = drv->smudge; } @@ -726,7 +738,7 @@ int convert_to_working_tree(const char *path, const char *src, size_t len, struc src = dst->buf; len = dst->len; } - action = determine_action(action, eol); + action = determine_action(action, eol_attr); ret |= crlf_to_worktree(path, src, len, dst, action); if (ret) { src = dst->buf; diff --git a/environment.c b/environment.c index 3c8abae848..5bafcd83a5 100644 --- a/environment.c +++ b/environment.c @@ -40,6 +40,7 @@ const char *editor_program; const char *excludes_file; enum auto_crlf auto_crlf = AUTO_CRLF_FALSE; int read_replace_refs = 1; +enum eol eol = EOL_UNSET; enum safe_crlf safe_crlf = SAFE_CRLF_WARN; unsigned whitespace_rule_cfg = WS_DEFAULT_RULE; enum branch_track git_branch_track = BRANCH_TRACK_REMOTE; diff --git a/t/t0026-eol-config.sh b/t/t0026-eol-config.sh new file mode 100755 index 0000000000..f37ac8fa0b --- /dev/null +++ b/t/t0026-eol-config.sh @@ -0,0 +1,83 @@ +#!/bin/sh + +test_description='CRLF conversion' + +. ./test-lib.sh + +has_cr() { + tr '\015' Q <"$1" | grep Q >/dev/null +} + +test_expect_success setup ' + + git config core.autocrlf false && + + echo "one text" > .gitattributes + + for w in Hello world how are you; do echo $w; done >one && + for w in I am very very fine thank you; do echo $w; done >two && + git add . && + + git commit -m initial && + + one=`git rev-parse HEAD:one` && + two=`git rev-parse HEAD:two` && + + echo happy. +' + +test_expect_success 'eol=lf puts LFs in normalized file' ' + + rm -f .gitattributes tmp one two && + git config core.eol lf && + git read-tree --reset -u HEAD && + + ! has_cr one && + ! has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + test -z "$onediff" -a -z "$twodiff" +' + +test_expect_success 'eol=crlf puts CRLFs in normalized file' ' + + rm -f .gitattributes tmp one two && + git config core.eol crlf && + git read-tree --reset -u HEAD && + + has_cr one && + ! has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + test -z "$onediff" -a -z "$twodiff" +' + +test_expect_success 'autocrlf=true overrides eol=lf' ' + + rm -f .gitattributes tmp one two && + git config core.eol lf && + git config core.autocrlf true && + git read-tree --reset -u HEAD && + + has_cr one && + has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + test -z "$onediff" -a -z "$twodiff" +' + +test_expect_success 'autocrlf=true overrides unset eol' ' + + rm -f .gitattributes tmp one two && + git config --unset-all core.eol && + git config core.autocrlf true && + git read-tree --reset -u HEAD && + + has_cr one && + has_cr two && + onediff=`git diff one` && + twodiff=`git diff two` && + test -z "$onediff" -a -z "$twodiff" +' + +test_done